EXP(3M) EXP(3M)
exp, expm1, log, log10, log1p, pow, fexp, expf, fexpm1, expm1f, flog,
logf, flog10, log10f, flog1p, log1pf, fpow, powf, expl, expm1l, logl,
log10l, log1pl, powl - exponential, logarithm, power
#include <math.h>
double exp(double x);
float fexp(float x);
float expf(float x);
long double expl(long double x);
long double expm1l(long double x);
double expm1(double x);
float fexpm1(float x);
float expm1f(float x);
double log(double x);
float flog(float x);
float logf(float x);
long double logl(long double x);
double log10(double x);
float flog10(float x);
float log10f(float x);
long double log10l(long double x);
double log1p(double x);
float flog1p(float x);
float log1pf(float x);
long double log1pl(long double x);
double pow(double x, double y);
float powf(float x, float y);
long double powl(long double x, \
long double y);
The long double and single-precision routines listed above are only
available in the standard math library, -lm, and in -lmx.
The exp family return the exponential function of x, e**x.
The expm1 family return exp(x)-1 accurately even for tiny x.
The log functions return the natural logarithm of x.
The log10 functions return the base 10 logarithm of x.
Page 1
EXP(3M) EXP(3M)
The log1p family return log(1+x) accurately even for tiny x.
pow(x,y), its single-precision counterpart powf(x,y), and its long double
counterpart powl(x,y), return x**y.
ERROR (due to Roundoff etc.) [Toc] [Back] exp(x), log(x), expm1(x) and log1p(x) are accurate to within an ulp, and
log10(x) and pow(x,y) to within about 2 ulps; an ulp is one Unit in the
Last Place. Moderate values of pow are accurate enough that
pow(integer,integer) is exact until it is bigger than 2**53 for double.
In the diagnostics below, functions in the standard math library libm.a,
are referred to as -lm versions, those in math library libmx.a are
referred to as -lmx versions, and those in the the BSD math library
libm43.a are referred to as -lm43 versions.
When NaN is used as an argument, a NaN is returned. The -lm and -lmx
versions always return the default Quiet NaN and set errno to EDOM. The
-lm43 versions never set errno.
The value of HUGE_VAL is IEEE Infinity.
The exp functions return HUGE_VAL when the correct value would overflow,
and return zero if the correct value would underflow. The -lm and -lmx
versions set the value of errno to ERANGE for both underflow and
overflow.
The log functions return NaN when x is less than zero, indicating an
invalid operation. The -lm and -lmx versions also set errno to EDOM.
When x is zero, the log functions return -HUGE_VAL. The -lm and -lmx
versions set errno to ERANGE.
The pow functions return NaN indicating an invalid operation, if x is
negative and y is not an integer. The -lm and -lmx versions also set
errno to EDOM.
When x is zero and y is negative, the -lm and -lmx versions return
HUGE_VAL and set errno to EDOM. The -lm43 versions return HUGE_VAL.
When both arguments are zero, the pow functions return one.
When the correct value for pow would overflow or underflow the pow
functions return +/-HUGE_VAL or zero, respectively. The -lm and -lmx
versions set errno to ERANGE.
See matherr(3M) for a description of error handling for -lmx functions.
Long double operations on this system are only supported in round to
nearest rounding mode (the default). The system must be in round to
nearest rounding mode when calling any of the long double functions, or
incorrect answers will result.
Users concerned with portability to other computer systems should note
that the long double and float versions of these functions are optional
according to the ANSI C Programming Language Specification ISO/IEC 9899 :
Page 2
EXP(3M) EXP(3M)
1990 (E).
Long double functions have been renamed to be compliant with the ANSI-C
standard, however to be backward compatible, they may still be called
with the double precision function name prefixed with a q.
Pow(x,0) returns x**0 = 1 for all x including x = 0 and Infinity.
Previous implementations of pow defined NaN**0 to be 1 as well, but this
behavior has been changed to conform to the IEEE standard. Here are
reasons for returning x**0 = 1 in all other cases:
(1) Any program that already tests whether x is zero (or infinite) before
computing x**0 cannot care whether 0**0 = 1 or not. Any program that
depends upon 0**0 to be invalid is dubious anyway since that
expression's meaning and, if invalid, its consequences vary from one
computer system to another.
(2) Some Algebra texts (e.g. Sigler's) define x**0 = 1 for all x,
including x = 0. This is compatible with the convention that accepts
a[0] as the value of polynomial
p(x) = a[0]*x**0 + a[1]*x**1 + a[2]*x**2 +...+ a[n]*x**n
at x = 0 rather than reject a[0]*0**0 as invalid.
(3) Analysts will accept 0**0 = 1 despite that x**y can approach anything
or nothing as x and y approach 0 independently. The reason for
setting 0**0 = 1 anyway is this:
If x(z) and y(z) are any functions analytic (expandable in power
series) in z around z = 0, and if there x(0) = y(0) = 0, then
x(z)**y(z) -> 1 as z -> 0.
(4) If 0**0 = 1, then infinity**0 = 1/0**0 = 1 too; and because x**0 = 1
for all finite and infinite non-NaN x.
math(3M), matherr(3M)
Page 3
CPLXEXP(3C++) CPLXEXP(3C++)
exp, log, pow, sqrt - exponential, logarithm, power, square root
functions for the C++ complex library
#include <complex.h>
class complex {
public:
friend complex exp(complex);
friend complex log(complex);
friend complex pow(double, complex);
friend complex pow(complex, int);
friend complex pow(complex, double);
friend complex pow(complex, complex);
friend complex sqrt(complex);
};
The following math functions are overloaded by the complex library,
where:
- x, y, and z are of type complex.
z <b>= exp(x<b>) Returns ex.
z <b>= log(x<b>) Returns the natural logarithm of x.
z <b>= pow(x<b>, y<b>) Returns xy.
z <b>= sqrt(x<b>) Returns the square root of x, contained in the first or
fourth quadrants of the complex plane.
complex(3C++), cartpol(3C++), cplxerr(3C++), cplxops(3C++), and
cplxtrig(3C++).
exp returns (0, 0) when the real part of x is so small, or the imaginary
part is so large, as to cause overflow. When the real part is large
enough to cause overflow, exp returns (HUGE, HUGE) if the cosine and sine
of the imaginary part of x are positive, (HUGE, -HUGE) if the cosine is
positive and the sine is not, (-HUGE, HUGE) if the sine is positive and
the cosine is not, and (-HUGE, -HUGE) if neither sine nor cosine is
positive. In all these cases, errno is set to ERANGE.
log returns (-HUGE, 0) and sets errno to EDOM when x is (0, 0). A
message indicating SING error is printed on the standard error output.
These error-handling procedures may be changed with the function
complex_error (cplxerr(3C++)).
Page 1
EXP(3F) EXP(3F)
exp, dexp, qexp, cexp, zexp - FORTRAN exponential intrinsic function
real r1, r2
double precision dp1, dp2
real*16 qp1, qp2
complex cx1, cx2
complex*16 cd1, cd2
r2 = exp(r1)
dp2 = dexp(dp1)
dp2 = exp(dp1)
qp2 = qexp(qp1)
qp2 = exp(qp1)
cx2 = cexp(cx1)
cx2 = exp(cx1)
cd2 = zexp(cd1)
cd2 = exp(cd1)
exp returns the real exponential function ex of its real argument. dexp
returns the double-precision exponential function of its double-precision
argument. qexp returns the real*16 exponential function of its real*16
argument. cexp returns the complex exponential function of its complex
argument. zexp returns the complex*16 exponential function of its
complex*16 argument. The generic function exp becomes a call to dexp,
qexp, cexp, or zexp as required, depending on the type of its argument.
exp(3M).
Page 1
EXP(3M) Last changed: 1-6-98
EXP, DEXP, CEXP, CDEXP - Computes exponential function
UNICOS and UNICOS/mk systems:
EXP ([X=]x)
DEXP ([X=]x)
CEXP ([X=]x)
UNICOS and IRIX systems:
CDEXP ([X=]x)
UNICOS, UNICOS/mk, and IRIX systems
Fortran 90
CDEXP is a compiler extension to Fortran 90.
EXP is the generic function name. EXP, DEXP, and CEXP are elemental
functions for the CF90 compiler.
The entry point CDEXP is provided for support in other languages. It
is not recognized as an intrinsic function; therefore, you must use
the CDIR$ VFUNCTION directive to allow vectorization.
A vector version of this intrinsic exists on UNICOS and UNICOS/mk
systems. On UNICOS/mk systems, the vector version of this intrinsic
is used when -h vector3 (C) or -O vector3 (Fortran) has been specified
on the compiler command line.
x
These functions evaluate y = e .
CF90 [Toc] [Back]
CDEXP is called implicitly by the Fortran 90 compiler as a result of a
generic EXP call with a complex double-precision argument.
CAL Register Usage (Cray Research Systems Only)
Scalar EXP: EXP% (call-by-register)
on entry (S1) = argument
on exit (S1) = result
Vector EXP: %EXP% (call-by-register)
on entry (V1) = argument vector
on exit (V1) = result vector
Scalar DEXP: DEXP% (call-by-register)
on entry (S1) and (S2) = argument
on exit (S1) and (S2) = result
Vector DEXP: %DEXP% (call-by-register)
on entry (V1) and (V2) = argument vector
on exit (V1) and (V2) = result vector
Scalar CEXP: CEXP% (call-by-register)
on entry (S1) and (S2) = argument
on exit (S1) and (S2) = result
Vector CEXP: %CEXP% (call-by-register)
on entry (V1) and (V2) = argument vector
on exit (V1) and (V2) = result vector
Scalar CDEXP: %CEDXP% (call-by-register)
on entry (S1), (S2), (S3), and (V4) = argument
on exit (S1), (S2), (S3), and (S4) = result
Vector CDEXP: %CEDXP% (call-by-register)
on entry (V1), (V2), (V3), and (V4) = argument vector
on exit (V1), (V2), (V3), and (V4) = result vector
Argument Range [Toc] [Back]
EXP, DEXP:
13
|x| < 2 * ln 2
On UNICOS/mk systems and on CRAY T90 systems that support IEEE
arithmetic:
x > -708.3964 and x < 709.7827
CEXP:
13 13
|x| < 2 * ln 2 and |x | < 2 * ln 2
r
On UNICOS/mk systems and on CRAY T90 systems that support IEEE
arithmetic:
-708.3964 < x < 709.7827
r
25
|x | < 2
i
CDEXP:
13 45
|x | < 2 * ln 2, |x | < 2
r i
CDEXP is an outmoded routine for the CF90 compiler. Refer to the
Fortran Language Reference Manual, Volume 3, publication SR-3905, for
information about outmoded features and their preferred standard
alternatives.
The name of the EXP, DEXP, and CEXP intrinsic can be passed as an
argument. The name of the CDEXP intrinsic cannot be passed as an
argument.
RETURN VALUES x
EXP returns the real exponential function e of its real argument.
x
DEXP returns the double-precision exponential function e of its
double-precision argument.
x
CEXP returns the complex exponential function e of its complex
argument.
x
CDEXP returns the complex double exponential function e of its
complex double-precision argument.
On CRAY T90 systems that support IEEE arithmetic, the following return
values occur:
EXP(x) = 0 if x < -708.4
EXP(x) = infinity if x > 709.78
EXP(NaN) = NaN
Intrinsic Procedures Reference Manual, publication SR-2138, for the
printed version of this man page.
EXP(3M) Last changed: 1-6-98
EXP, DEXP, CEXP, CDEXP - Computes exponential function
UNICOS and UNICOS/mk systems:
EXP ([X=]x)
DEXP ([X=]x)
CEXP ([X=]x)
UNICOS and IRIX systems:
CDEXP ([X=]x)
UNICOS, UNICOS/mk, and IRIX systems
Fortran 90
CDEXP is a compiler extension to Fortran 90.
EXP is the generic function name. EXP, DEXP, and CEXP are elemental
functions for the CF90 compiler.
The entry point CDEXP is provided for support in other languages. It
is not recognized as an intrinsic function; therefore, you must use
the CDIR$ VFUNCTION directive to allow vectorization.
A vector version of this intrinsic exists on UNICOS and UNICOS/mk
systems. On UNICOS/mk systems, the vector version of this intrinsic
is used when -h vector3 (C) or -O vector3 (Fortran) has been specified
on the compiler command line.
x
These functions evaluate y = e .
CF90 [Toc] [Back]
CDEXP is called implicitly by the Fortran 90 compiler as a result of a
generic EXP call with a complex double-precision argument.
CAL Register Usage (Cray Research Systems Only)
Scalar EXP: EXP% (call-by-register)
on entry (S1) = argument
on exit (S1) = result
Vector EXP: %EXP% (call-by-register)
on entry (V1) = argument vector
on exit (V1) = result vector
Scalar DEXP: DEXP% (call-by-register)
on entry (S1) and (S2) = argument
on exit (S1) and (S2) = result
Vector DEXP: %DEXP% (call-by-register)
on entry (V1) and (V2) = argument vector
on exit (V1) and (V2) = result vector
Scalar CEXP: CEXP% (call-by-register)
on entry (S1) and (S2) = argument
on exit (S1) and (S2) = result
Vector CEXP: %CEXP% (call-by-register)
on entry (V1) and (V2) = argument vector
on exit (V1) and (V2) = result vector
Scalar CDEXP: %CEDXP% (call-by-register)
on entry (S1), (S2), (S3), and (V4) = argument
on exit (S1), (S2), (S3), and (S4) = result
Vector CDEXP: %CEDXP% (call-by-register)
on entry (V1), (V2), (V3), and (V4) = argument vector
on exit (V1), (V2), (V3), and (V4) = result vector
Argument Range [Toc] [Back]
EXP, DEXP:
13
|x| < 2 * ln 2
On UNICOS/mk systems and on CRAY T90 systems that support IEEE
arithmetic:
x > -708.3964 and x < 709.7827
CEXP:
13 13
|x| < 2 * ln 2 and |x | < 2 * ln 2
r
On UNICOS/mk systems and on CRAY T90 systems that support IEEE
arithmetic:
-708.3964 < x < 709.7827
r
25
|x | < 2
i
CDEXP:
13 45
|x | < 2 * ln 2, |x | < 2
r i
CDEXP is an outmoded routine for the CF90 compiler. Refer to the
Fortran Language Reference Manual, Volume 3, publication SR-3905, for
information about outmoded features and their preferred standard
alternatives.
The name of the EXP, DEXP, and CEXP intrinsic can be passed as an
argument. The name of the CDEXP intrinsic cannot be passed as an
argument.
RETURN VALUES x
EXP returns the real exponential function e of its real argument.
x
DEXP returns the double-precision exponential function e of its
double-precision argument.
x
CEXP returns the complex exponential function e of its complex
argument.
x
CDEXP returns the complex double exponential function e of its
complex double-precision argument.
On CRAY T90 systems that support IEEE arithmetic, the following return
values occur:
EXP(x) = 0 if x < -708.4
EXP(x) = infinity if x > 709.78
EXP(NaN) = NaN
Intrinsic Procedures Reference Manual, publication SR-2138, for the
printed version of this man page.
[ Back ]
|
