*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->IRIX man pages -> ftn/log10 (3)              


EXP(3M)								       EXP(3M)

NAME    [Toc]    [Back]

     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

SYNOPSIS    [Toc]    [Back]

     #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);

DESCRIPTION    [Toc]    [Back]

     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.
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.

DIAGNOSTICS    [Toc]    [Back]

     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

     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.

NOTES    [Toc]    [Back]

     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.

SEE ALSO    [Toc]    [Back]

     math(3M), matherr(3M)

									Page 3

LOG10(3F)							     LOG10(3F)

NAME    [Toc]    [Back]

     log10, alog10, dlog10, qlog10 - FORTRAN common logarithm intrinsic

SYNOPSIS    [Toc]    [Back]

     real r1, r2
     double precision dp1, dp2
     real*16 qp1, qp2

     r2	= alog10(r1)
     r2	= log10(r1)

     dp2 = dlog10(dp1)
     dp2 = log10(dp1)

     qp2 = qlog10(qp1)
     qp2 = log10(qp1)

DESCRIPTION    [Toc]    [Back]

     alog10 returns the	real common logarithm of its real argument.  dlog10
     returns the double-precision common logarithm of its double-precision
     argument.	qlog10 returns the real*16 common logarithm of its real*16
     argument.	The absolute value of the argument for alog10, dlog10, and
     qlog10 must be greater than zero.	The generic function log10 becomes a
     call to alog10, dlog10, or	qlog10 depending on the	type of	its argument.

SEE ALSO    [Toc]    [Back]


									PPPPaaaaggggeeee 1111
[ Back ]
 Similar pages
Name OS Title
pow NetBSD exponential, logarithm, power functions
log1pf NetBSD exponential, logarithm, power functions
exp OpenBSD exponential, logarithm, power functions
log1p NetBSD exponential, logarithm, power functions
log10f NetBSD exponential, logarithm, power functions
log10 NetBSD exponential, logarithm, power functions
logf NetBSD exponential, logarithm, power functions
log NetBSD exponential, logarithm, power functions
powf NetBSD exponential, logarithm, power functions
log1p OpenBSD exponential, logarithm, power functions
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service