Contents Index Search Previous Next

1

The generic library
package Numerics.Generic_Complex_Elementary_Functions has the following
declaration:

2

pragma Pure(Generic_Complex_Elementary_Functions);

3

4

5

6

7

8

9/1

{*8652/0020*}
{*Ada.Numerics.Complex_Elementary_Functions*}
The
library package Numerics.Complex_Elementary_Functions __is declared
pure and __ defines the same subprograms as Numerics.Generic_Complex_Elementary_Functions,
except that the predefined type Float is systematically substituted for
Real'Base, and the Complex and Imaginary types exported by Numerics.Complex_Types
are systematically substituted for Complex and Imaginary, throughout.
Nongeneric equivalents of Numerics.Generic_Complex_Elementary_Functions
corresponding to each of the other predefined floating point types are
defined similarly, with the names Numerics.Short_Complex_Elementary_Functions,
Numerics.Long_Complex_Elementary_Functions, etc.

9.a

10

The overloading of the Exp function for the pure-imaginary
type is provided to give the user an alternate way to compose a complex
value from a given modulus and argument. In addition to Compose_From_Polar(Rho,
Theta) (see G.1.1), the programmer may write
Rho * Exp(i * Theta).

11

The imaginary (resp., real) component of the
parameter X of the forward hyperbolic (resp., trigonometric) functions
and of the Exp function (and the parameter X, itself, in the case of
the overloading of the Exp function for the pure-imaginary type) represents
an angle measured in radians, as does the imaginary (resp., real) component
of the result of the Log and inverse hyperbolic (resp., trigonometric)
functions.

12

The functions have
their usual mathematical meanings. However, the arbitrariness inherent
in the placement of branch cuts, across which some of the complex elementary
functions exhibit discontinuities, is eliminated by the following conventions:

13

- The imaginary component of the result of the Sqrt and Log functions is discontinuous as the parameter X crosses the negative real axis.

14

- The result of the exponentiation operator when the left operand is of complex type is discontinuous as that operand crosses the negative real axis.

15

- The real (resp., imaginary) component of the result of the Arcsin and Arccos (resp., Arctanh) functions is discontinuous as the parameter X crosses the real axis to the left of -1.0 or the right of 1.0.

16

- The real (resp., imaginary) component
of the result of the Arctan (resp., Arcsinh) function is discontinuous
as the parameter X crosses the imaginary axis below -
*i*or above*i*.

17

- The real component of the result of
the Arccot function is discontinuous as the parameter X crosses the imaginary
axis between -
*i*and*i*.

18

- The imaginary component of the Arccosh function is discontinuous as the parameter X crosses the real axis to the left of 1.0.

19

- The imaginary component of the result of the Arccoth function is discontinuous as the parameter X crosses the real axis between -1.0 and 1.0.

20

The computed results
of the mathematically multivalued functions are rendered single-valued
by the following conventions, which are meant to imply the principal
branch:

21

- The real component of the result of the Sqrt and Arccosh functions is nonnegative.

22

- The same convention applies to the imaginary component of the result of the Log function as applies to the result of the natural-cycle version of the Argument function of Numerics.Generic_Complex_Types (see G.1.1).

23

- The range of the real (resp., imaginary) component of the result of the Arcsin and Arctan (resp., Arcsinh and Arctanh) functions is approximately -PI/2.0 to PI/2.0.

24

- The real (resp., imaginary) component of the result of the Arccos and Arccot (resp., Arccoth) functions ranges from 0.0 to approximately PI.

25

- The range of the imaginary component of the result of the Arccosh function is approximately -PI to PI.

26

In addition, the exponentiation operator inherits
the single-valuedness of the Log function.

27

The exception Numerics.Argument_Error is raised
by the exponentiation operator, signaling a parameter value outside the
domain of the corresponding mathematical function, when the value of
the left operand is zero and the real component of the exponent (or the
exponent itself, when it is of real type) is zero.

28

{*Division_Check*
[partial]} {*check, language-defined
(Division_Check)*} {*Constraint_Error
(raised by failure of run-time check)*} The
exception Constraint_Error is raised, signaling a pole of the mathematical
function (analogous to dividing by zero), in the following cases, provided
that Complex_Types.Real'Machine_Overflows is True:

29

- by the Log, Cot, and Coth functions, when the value of the parameter X is zero;

30

- by the exponentiation operator, when the value of the left operand is zero and the real component of the exponent (or the exponent itself, when it is of real type) is negative;

31

- by the Arctan and Arccot functions,
when the value of the parameter X is ±
*i*;

32

- by the Arctanh and Arccoth functions, when the value of the parameter X is ± 1.0.

33

[Constraint_Error can also be raised when a finite
result overflows (see G.2.6); this may occur
for parameter values sufficiently *near* poles, and, in the case
of some of the functions, for parameter values having components of sufficiently
large magnitude.] {*unspecified* [partial]}
When Complex_Types.Real'Machine_Overflows is False,
the result at poles is unspecified.

33.a

33.b

34

In the implementation of Numerics.Generic_Complex_Elementary_Functions,
the range of intermediate values allowed during the calculation of a
final result shall not be affected by any range constraint of the subtype
Complex_Types.Real.

34.a

35

{*prescribed
result (for the evaluation of a complex elementary function)*}
In the following cases, evaluation of a complex elementary
function shall yield the *prescribed result* (or a result having
the prescribed component), provided that the preceding rules do not call
for an exception to be raised:

36

- When the parameter X has the value zero, the Sqrt, Sin, Arcsin, Tan, Arctan, Sinh, Arcsinh, Tanh, and Arctanh functions yield a result of zero; the Exp, Cos, and Cosh functions yield a result of one; the Arccos and Arccot functions yield a real result; and the Arccoth function yields an imaginary result.

37

- When the parameter X has the value one, the Sqrt function yields a result of one; the Log, Arccos, and Arccosh functions yield a result of zero; and the Arcsin function yields a real result.

38

- When the parameter X has the value -1.0, the Sqrt function yields the result

39

*i*(resp., -*i*), when the sign of the imaginary component of X is positive (resp., negative), if Complex_Types.Real'Signed_Zeros is True;

40

*i*, if Complex_Types.Real'Signed_Zeros is False;

41

- the Log function yields an imaginary result; and the Arcsin and Arccos functions yield a real result.

42

- When the parameter X has the value
±
*i*, the Log function yields an imaginary result.

43

- Exponentiation by a zero exponent yields the value one. Exponentiation by a unit exponent yields the value of the left operand (as a complex value). Exponentiation of the value one yields the value one. Exponentiation of the value zero yields the value zero.

43.a

44

Other accuracy requirements for the complex elementary
functions, which apply only in the strict mode, are given in G.2.6.

45

The sign of a zero result or zero result component
yielded by a complex elementary function is implementation defined when
Complex_Types.Real'Signed_Zeros is True.

45.a

46

The nongeneric equivalent packages may, but need
not, be actual instantiations of the generic package with the appropriate
predefined nongeneric equivalent of Numerics.Generic_Complex_Types; if
they are, then the latter shall have been obtained by actual instantiation
of Numerics.Generic_Complex_Types.

47

The exponentiation operator may be implemented
in terms of the Exp and Log functions. Because this implementation yields
poor accuracy in some parts of the domain, no accuracy requirement is
imposed on complex exponentiation.

48

{*unspecified* [partial]}
The implementation of the Exp function of a complex
parameter X is allowed to raise the exception Constraint_Error, signaling
overflow, when the real component of X exceeds an unspecified threshold
that is approximately log(Complex_Types.Real'Safe_Last). This permission
recognizes the impracticality of avoiding overflow in the marginal case
that the exponential of the real component of X exceeds the safe range
of Complex_Types.Real but both components of the final result do not.
Similarly, the Sin and Cos (resp., Sinh and Cosh) functions are allowed
to raise the exception Constraint_Error, signaling overflow, when the
absolute value of the imaginary (resp., real) component of the parameter
X exceeds an unspecified threshold that is approximately log(Complex_Types.Real'Safe_Last)
+ log(2.0). {*unspecified* [partial]} This
permission recognizes the impracticality of avoiding overflow in the
marginal case that the hyperbolic sine or cosine of the imaginary (resp.,
real) component of X exceeds the safe range of Complex_Types.Real but
both components of the final result do not.

49

Implementations in which Complex_Types.Real'Signed_Zeros
is True should attempt to provide a rational treatment of the signs of
zero results and result components. For example, many of the complex
elementary functions have components that are odd functions of one of
the parameter components; in these cases, the result component should
have the sign of the parameter component at the origin. Other complex
elementary functions have zero components whose sign is opposite that
of a parameter component at the origin, or is always positive or always
negative.

49.a

The
semantics of Numerics.Generic_Complex_Elementary_Functions differs from
Generic_Complex_Elementary_Functions as defined in ISO/IEC CD 13814 (for
Ada 83) in the following ways:

49.b

- The generic package is a child unit of the package defining the Argument_Error exception.

49.c

- The proposed Generic_Complex_Elementary_Functions standard (for Ada 83) specified names for the nongeneric equivalents, if provided. Here, those nongeneric equivalents are required.

49.d

- The generic package imports an instance of Numerics.Generic_Complex_Types rather than a long list of individual types and operations exported by such an instance.

49.e

- The dependence of the imaginary component of the Sqrt and Log functions on the sign of a zero parameter component is tied to the value of Complex_Types.Real'Signed_Zeros.

49.f

- Conformance to accuracy requirements is conditional.