/* File: fp.h Contains: FPCE Floating-Point Definitions and Declarations. Version: QuickTime 7.3 Copyright: (c) 2007 (c) 1987-2001 by Apple Computer, Inc., all rights reserved. Bugs?: For bug reports, consult the following page on the World Wide Web: http://developer.apple.com/bugreporter/ */ #ifndef __FP__ #define __FP__ #ifndef __CONDITIONALMACROS__ #include #endif #ifndef __MACTYPES__ #include #endif /******************************************************************************** * * * A collection of numerical functions designed to facilitate a wide * * range of numerical programming as required by C9X. * * * * The declares many functions in support of numerical programming. * * It provides a superset of and functions. Some * * functionality previously found in and not in the FPCE * * can be found in this under the heading "__NOEXTENSIONS__". * * * * All of these functions are IEEE 754 aware and treat exceptions, NaNs, * * positive and negative zero and infinity consistent with the floating- * * point standard. * * * ********************************************************************************/ #if PRAGMA_ONCE #pragma once #endif #ifdef __cplusplus extern "C" { #endif #if PRAGMA_IMPORT #pragma import on #endif #if PRAGMA_STRUCT_ALIGN #pragma options align=mac68k #elif PRAGMA_STRUCT_PACKPUSH #pragma pack(push, 2) #elif PRAGMA_STRUCT_PACK #pragma pack(2) #endif /******************************************************************************** * * * Efficient types * * * * float_t Most efficient type at least as wide as float * * double_t Most efficient type at least as wide as double * * * * CPU float_t(bits) double_t(bits) * * -------- ----------------- ----------------- * * PowerPC float(32) double(64) * * 68K long double(80/96) long double(80/96) * * x86 double(64) double(64) * * * ********************************************************************************/ #if (defined(__MWERKS__) && defined(__cmath__)) || (TARGET_RT_MAC_MACHO && defined(__MATH__)) /* these types were already defined in math.h */ #else #if TARGET_CPU_PPC typedef float float_t; typedef double double_t; #elif TARGET_CPU_68K typedef long double float_t; typedef long double double_t; #elif TARGET_CPU_X86 //typedef double float_t; typedef double double_t; #elif TARGET_CPU_MIPS typedef double float_t; typedef double double_t; #elif TARGET_CPU_ALPHA typedef double float_t; typedef double double_t; #elif TARGET_CPU_SPARC typedef double float_t; typedef double double_t; #else #error unsupported CPU #endif /* */ /******************************************************************************** * * * Define some constants. * * * * HUGE_VAL IEEE 754 value of infinity. * * INFINITY IEEE 754 value of infinity. * * NAN A generic NaN (Not A Number). * * DECIMAL_DIG Satisfies the constraint that the conversion from * * double to decimal and back is the identity function. * * * ********************************************************************************/ #if TARGET_OS_MAC #if !TARGET_RT_MAC_MACHO #define HUGE_VAL __inf() #define INFINITY __inf() #define NAN nan("255") #endif #else //#define NAN sqrt(-1) #endif #if TARGET_CPU_PPC #define DECIMAL_DIG 17 /* does not exist for double-double */ #elif TARGET_CPU_68K #define DECIMAL_DIG 21 #endif #endif /* (defined(__MWERKS__) && defined(__cmath__)) || (TARGET_RT_MAC_MACHO && defined(__MATH__)) */ #if TARGET_OS_MAC /* MSL or math.h already defines these */ #if (!defined(__MWERKS__) || !defined(__cmath__)) && (!TARGET_RT_MAC_MACHO || !defined(__MATH__)) /******************************************************************************** * * * Trigonometric functions * * * * acos result is in [0,pi]. * * asin result is in [-pi/2,pi/2]. * * atan result is in [-pi/2,pi/2]. * * atan2 Computes the arc tangent of y/x in [-pi,pi] using the sign of * * both arguments to determine the quadrant of the computed value. * * * ********************************************************************************/ /* * cos() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) cos(double_t x); /* * sin() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) sin(double_t x); /* * tan() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) tan(double_t x); /* * acos() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) acos(double_t x); /* * asin() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) asin(double_t x); /* * atan() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) atan(double_t x); /* * atan2() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) atan2(double_t y, double_t x); /******************************************************************************** * * * Hyperbolic functions * * * ********************************************************************************/ /* * cosh() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) cosh(double_t x); /* * sinh() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) sinh(double_t x); /* * tanh() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) tanh(double_t x); /* * acosh() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) acosh(double_t x); /* * asinh() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) asinh(double_t x); /* * atanh() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) atanh(double_t x); /******************************************************************************** * * * Exponential functions * * * * expm1 expm1(x) = exp(x) - 1. But, for small enough arguments, * * expm1(x) is expected to be more accurate than exp(x) - 1. * * frexp Breaks a floating-point number into a normalized fraction * * and an integral power of 2. It stores the integer in the * * object pointed by *exponent. * * ldexp Multiplies a floating-point number by an integer power of 2. * * log1p log1p = log(1 + x). But, for small enough arguments, * * log1p is expected to be more accurate than log(1 + x). * * logb Extracts the exponent of its argument, as a signed integral * * value. A subnormal argument is treated as though it were first * * normalized. Thus: * * 1 <= x * 2^(-logb(x)) < 2 * * modf Returns fractional part of x as function result and returns * * integral part of x via iptr. Note C9X uses double not double_t. * * scalb Computes x * 2^n efficently. This is not normally done by * * computing 2^n explicitly. * * * ********************************************************************************/ /* * exp() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) exp(double_t x); /* * expm1() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) expm1(double_t x); /* * exp2() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) exp2(double_t x); /* * frexp() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) frexp(double_t x, int *exponent); /* * ldexp() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) ldexp(double_t x, int n); /* * log() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) log(double_t x); /* * log2() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) log2(double_t x); /* * log1p() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) log1p(double_t x); /* * log10() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) log10(double_t x); /* * logb() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) logb(double_t x); #if !TYPE_LONGDOUBLE_IS_DOUBLE /* * modfl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) modfl(long double x, long double *iptrl); #endif /* !TYPE_LONGDOUBLE_IS_DOUBLE */ /* * modf() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) modf(double_t x, double_t *iptr); /* * modff() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( float ) modff(float x, float *iptrf); /* Note: For compatiblity scalb(x,n) has n of type int on Mac OS X long on Mac OS */ typedef long _scalb_n_type; /* * scalb() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) scalb(double_t x, _scalb_n_type n); /******************************************************************************** * * * Power and absolute value functions * * * * hypot Computes the square root of the sum of the squares of its * * arguments, without undue overflow or underflow. * * pow Returns x raised to the power of y. Result is more accurate * * than using exp(log(x)*y). * * * ********************************************************************************/ /* * fabs() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) fabs(double_t x); /* * hypot() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) hypot(double_t x, double_t y); /* * pow() * * Availability: * Non-Carbon CFM: in MathLib 2.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) pow(double_t x, double_t y); /* * sqrt() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) sqrt(double_t x); /******************************************************************************** * * * Gamma and Error functions * * * * erf The error function. * * erfc Complementary error function. * * gamma The gamma function. * * lgamma Computes the base-e logarithm of the absolute value of * * gamma of its argument x, for x > 0. * * * ********************************************************************************/ /* * erf() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) erf(double_t x); /* * erfc() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) erfc(double_t x); /* * gamma() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) gamma(double_t x); /* * lgamma() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) lgamma(double_t x); /******************************************************************************** * * * Nearest integer functions * * * * rint Rounds its argument to an integral value in floating point * * format, honoring the current rounding direction. * * * * nearbyint Differs from rint only in that it does not raise the inexact * * exception. It is the nearbyint function recommended by the * * IEEE floating-point standard 854. * * * * rinttol Rounds its argument to the nearest long int using the current * * rounding direction. NOTE: if the rounded value is outside * * the range of long int, then the result is undefined. * * * * round Rounds the argument to the nearest integral value in floating * * point format similar to the Fortran "anint" function. That is: * * add half to the magnitude and chop. * * * * roundtol Similar to the Fortran function nint or to the Pascal round. * * NOTE: if the rounded value is outside the range of long int, * * then the result is undefined. * * * * trunc Computes the integral value, in floating format, nearest to * * but no larger in magnitude than its argument. NOTE: on 68K * * compilers when using -elems881, trunc must return an int * * * ********************************************************************************/ /* * ceil() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) ceil(double_t x); /* * floor() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) floor(double_t x); /* * rint() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) rint(double_t x); /* * nearbyint() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) nearbyint(double_t x); /* * rinttol() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) rinttol(double_t x); /* * round() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) round(double_t x); /* * roundtol() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) roundtol(double_t round); /* Note: For compatiblity trunc(x) has a return type of int for classic 68K with FPU enabled double_t everywhere else */ #if TARGET_RT_MAC_68881 typedef int _trunc_return_type; #else typedef double_t _trunc_return_type; #endif /* TARGET_RT_MAC_68881 */ /* * trunc() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( _trunc_return_type ) trunc(double_t x); /******************************************************************************** * * * Remainder functions * * * * remainder IEEE 754 floating point standard for remainder. * * remquo SANE remainder. It stores into 'quotient' the 7 low-order * * bits of the integer quotient x/y, such that: * * -127 <= quotient <= 127. * * * ********************************************************************************/ /* * fmod() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) fmod(double_t x, double_t y); /* * remainder() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) remainder(double_t x, double_t y); /* * remquo() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) remquo(double_t x, double_t y, int *quo); /******************************************************************************** * * * Auxiliary functions * * * * copysign Produces a value with the magnitude of its first argument * * and sign of its second argument. NOTE: the order of the * * arguments matches the recommendation of the IEEE 754 * * floating point standard, which is opposite from the SANE * * copysign function. * * * * nan The call 'nan("n-char-sequence")' returns a quiet NaN * * with content indicated through tagp in the selected * * data type format. * * * * nextafter Computes the next representable value after 'x' in the * * direction of 'y'. if x == y, then y is returned. * * * ********************************************************************************/ /* * copysign() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) copysign(double_t x, double_t y); /* * nan() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double ) nan(const char * tagp); /* * nanf() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( float ) nanf(const char * tagp); /* * nanl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) nanl(const char * tagp); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) nanl(const char *tagp) { return (long double) nan(tagp); } #else #define nanl(tagp) ((long double) nan(tagp)) #endif #endif /* * nextafterd() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double ) nextafterd(double x, double y); /* * nextafterf() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( float ) nextafterf(float x, float y); /* * nextafterl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) nextafterl(long double x, long double y); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) nextafterl(long double x, long double y) { return (long double) nextafterd((double)(x),(double)(y)); } #else #define nextafterl(x, y) ((long double) nextafterd((double)(x),(double)(y))) #endif #endif /* * __fpclassifyd() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) __fpclassifyd(double x); /* * __fpclassifyf() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) __fpclassifyf(float x); /* * __fpclassify() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long ) __fpclassify(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long ) __fpclassify(long double x) { return __fpclassifyd((double)(x)); } #else #define __fpclassify(x) (__fpclassifyd((double)(x))) #endif #endif /* * __isnormald() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) __isnormald(double x); /* * __isnormalf() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) __isnormalf(float x); /* * __isnormal() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long ) __isnormal(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long ) __isnormal(long double x) { return __isnormald((double)(x)); } #else #define __isnormal(x) (__isnormald((double)(x))) #endif #endif /* * __isfinited() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) __isfinited(double x); /* * __isfinitef() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) __isfinitef(float x); /* * __isfinite() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long ) __isfinite(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long ) __isfinite(long double x) { return __isfinited((double)(x)); } #else #define __isfinite(x) (__isfinited((double)(x))) #endif #endif /* * __isnand() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) __isnand(double x); /* * __isnanf() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) __isnanf(float x); /* * __isnan() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long ) __isnan(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long ) __isnan(long double x) { return __isnand((double)(x)); } #else #define __isnan(x) (__isnand((double)(x))) #endif #endif /* * __signbitd() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) __signbitd(double x); /* * __signbitf() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) __signbitf(float x); /* * __signbit() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long ) __signbit(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long ) __signbit(long double x) { return __signbitd((double)(x)); } #else #define __signbit(x) (__signbitd((double)(x))) #endif #endif /* * __inf() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) __inf(void); /******************************************************************************** * * * Inquiry macros * * * * fpclassify Returns one of the FP_* values. * * isnormal Non-zero if and only if the argument x is normalized. * * isfinite Non-zero if and only if the argument x is finite. * * isnan Non-zero if and only if the argument x is a NaN. * * signbit Non-zero if and only if the sign of the argument x is * * negative. This includes, NaNs, infinities and zeros. * * * ********************************************************************************/ enum { FP_SNAN = 0, /* signaling NaN */ FP_QNAN = 1, /* quiet NaN */ FP_INFINITE = 2, /* + or - infinity */ FP_ZERO = 3, /* + or - zero */ FP_NORMAL = 4, /* all normal numbers */ FP_SUBNORMAL = 5 /* denormal numbers */ }; #define fpclassify(x) ( ( sizeof ( x ) == sizeof(double) ) ? \ __fpclassifyd ( x ) : \ ( sizeof ( x ) == sizeof(float) ) ? \ __fpclassifyf ( x ) : \ __fpclassify ( x ) ) #define isnormal(x) ( ( sizeof ( x ) == sizeof(double) ) ? \ __isnormald ( x ) : \ ( sizeof ( x ) == sizeof(float) ) ? \ __isnormalf ( x ) : \ __isnormal ( x ) ) #define isfinite(x) ( ( sizeof ( x ) == sizeof(double) ) ? \ __isfinited ( x ) : \ ( sizeof ( x ) == sizeof(float) ) ? \ __isfinitef ( x ) : \ __isfinite ( x ) ) #define isnan(x) ( ( sizeof ( x ) == sizeof(double) ) ? \ __isnand ( x ) : \ ( sizeof ( x ) == sizeof(float) ) ? \ __isnanf ( x ) : \ __isnan ( x ) ) #define signbit(x) ( ( sizeof ( x ) == sizeof(double) ) ? \ __signbitd ( x ) : \ ( sizeof ( x ) == sizeof(float) ) ? \ __signbitf ( x ) : \ __signbit ( x ) ) /******************************************************************************** * * * Max, Min and Positive Difference * * * * fdim Determines the 'positive difference' between its arguments: * * { x - y, if x > y }, { +0, if x <= y }. If one argument is * * NaN, then fdim returns that NaN. if both arguments are NaNs, * * then fdim returns the first argument. * * * * fmax Returns the maximum of the two arguments. Corresponds to the * * max function in FORTRAN. NaN arguments are treated as missing * * data. If one argument is NaN and the other is a number, then * * the number is returned. If both are NaNs then the first * * argument is returned. * * * * fmin Returns the minimum of the two arguments. Corresponds to the * * min function in FORTRAN. NaN arguments are treated as missing * * data. If one argument is NaN and the other is a number, then * * the number is returned. If both are NaNs then the first * * argument is returned. * * * ********************************************************************************/ /* * fdim() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) fdim(double_t x, double_t y); /* * fmax() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) fmax(double_t x, double_t y); /* * fmin() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) fmin(double_t x, double_t y); #endif /* (defined(__MWERKS__) && defined(__cmath__)) || (TARGET_RT_MAC_MACHO && defined(__MATH__)) */ /******************************************************************************* * Constants * *******************************************************************************/ /* * pi * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ extern const double_t pi; /******************************************************************************** * * * Non NCEG extensions * * * ********************************************************************************/ #ifndef __NOEXTENSIONS__ /******************************************************************************** * * * Financial functions * * * * compound Computes the compound interest factor "(1 + rate)^periods" * * more accurately than the straightforward computation with * * the Power function. This is SANE's compound function. * * * * annuity Computes the present value factor for an annuity * * "(1 - (1 + rate)^(-periods)) /rate" more accurately than * * the straightforward computation with the Power function. * * This is SANE's annuity function. * * * ********************************************************************************/ /* * compound() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) compound(double_t rate, double_t periods); /* * annuity() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) annuity(double_t rate, double_t periods); /******************************************************************************** * * * Random function * * * * randomx A pseudorandom number generator. It uses the iteration: * * (7^5*x)mod(2^31-1) * * * ********************************************************************************/ /* * randomx() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) randomx(double_t * x); /******************************************************************************* * Relational operator * *******************************************************************************/ /* relational operator */ typedef short relop; enum { GREATERTHAN = 0, LESSTHAN = 1, EQUALTO = 2, UNORDERED = 3 }; #if !defined(__MWERKS__) || !defined(__cmath__) /* * relation() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( relop ) relation(double_t x, double_t y); #endif /* !defined(__MWERKS__) || !defined(__cmath__) */ /******************************************************************************** * * * Binary to decimal conversions * * * * SIGDIGLEN Significant decimal digits. * * * * decimal A record which provides an intermediate unpacked form for * * programmers who wish to do their own parsing of numeric input * * or formatting of numeric output. * * * * decform Controls each conversion to a decimal string. The style field * * is either FLOATDECIMAL or FIXEDDECIMAL. If FLOATDECIMAL, the * * value of the field digits is the number of significant digits. * * If FIXEDDECIMAL value of the field digits is the number of * * digits to the right of the decimal point. * * * * num2dec Converts a double_t to a decimal record using a decform. * * dec2num Converts a decimal record d to a double_t value. * * dec2str Converts a decform and decimal to a string using a decform. * * str2dec Converts a string to a decimal struct. * * dec2d Similar to dec2num except a double is returned (68k only). * * dec2f Similar to dec2num except a float is returned. * * dec2s Similar to dec2num except a short is returned. * * dec2l Similar to dec2num except a long is returned. * * * ********************************************************************************/ #if TARGET_CPU_PPC #define SIGDIGLEN 36 #elif TARGET_CPU_68K #define SIGDIGLEN 20 #elif TARGET_CPU_X86 #define SIGDIGLEN 20 #endif #define DECSTROUTLEN 80 /* max length for dec2str output */ #define FLOATDECIMAL ((char)(0)) #define FIXEDDECIMAL ((char)(1)) struct decimal { char sgn; /* sign 0 for +, 1 for - */ char unused; short exp; /* decimal exponent */ struct { unsigned char length; unsigned char text[SIGDIGLEN]; /* significant digits */ unsigned char unused; } sig; }; typedef struct decimal decimal; struct decform { char style; /* FLOATDECIMAL or FIXEDDECIMAL */ char unused; short digits; }; typedef struct decform decform; /* * num2dec() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( void ) num2dec(const decform *f, double_t x, decimal *d); /* * dec2num() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double_t ) dec2num(const decimal * d); /* * dec2str() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( void ) dec2str(const decform *f, const decimal *d, char *s); /* * str2dec() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( void ) str2dec(const char *s, short *ix, decimal *d, short *vp); #if TARGET_CPU_68K #if CALL_NOT_IN_CARBON /* * dec2d() * * Availability: * Non-Carbon CFM: not available * CarbonLib: not available * Mac OS X: not available */ EXTERN_API_C( double ) dec2d(const decimal * d); #endif /* CALL_NOT_IN_CARBON */ #endif /* TARGET_CPU_68K */ /* * dec2f() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( float ) dec2f(const decimal * d); /* * dec2s() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( short ) dec2s(const decimal * d); /* * dec2l() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( long ) dec2l(const decimal * d); /******************************************************************************** * * * 68k-only Transfer Function Prototypes * * * ********************************************************************************/ #if TARGET_CPU_68K #if CALL_NOT_IN_CARBON /* * x96tox80() * * Availability: * Non-Carbon CFM: not available * CarbonLib: not available * Mac OS X: not available */ EXTERN_API_C( void ) x96tox80(const extended96 *x, extended80 *x80); /* * x80tox96() * * Availability: * Non-Carbon CFM: not available * CarbonLib: not available * Mac OS X: not available */ EXTERN_API_C( void ) x80tox96(const extended80 *x80, extended96 *x); #endif /* CALL_NOT_IN_CARBON */ #endif /* TARGET_CPU_68K */ #endif /* !defined(__NOEXTENSIONS__) */ /******************************************************************************** * * * PowerPC-only Function Prototypes * * * ********************************************************************************/ #if TARGET_CPU_PPC #ifndef __MWERKS__ /* Metrowerks does not support double double */ /* * cosl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) cosl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) cosl(long double x) { return (long double) cos((double)(x)); } #else #define cosl(x) ((long double) cos((double)(x))) #endif #endif /* * sinl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) sinl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) sinl(long double x) { return (long double) sin((double)(x)); } #else #define sinl(x) ((long double) sin((double)(x))) #endif #endif /* * tanl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) tanl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) tanl(long double x) { return (long double) tan((double)(x)); } #else #define tanl(x) ((long double) tan((double)(x))) #endif #endif /* * acosl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) acosl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) acosl(long double x) { return (long double) acos((double)(x)); } #else #define acosl(x) ((long double) acos((double)(x))) #endif #endif /* * asinl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) asinl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) asinl(long double x) { return (long double) asin((double)(x)); } #else #define asinl(x) ((long double) asin((double)(x))) #endif #endif /* * atanl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) atanl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) atanl(long double x) { return (long double) atan((double)(x)); } #else #define atanl(x) ((long double) atan((double)(x))) #endif #endif /* * atan2l() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) atan2l(long double y, long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) atan2l(long double y, long double x) { return (long double) atan2((double)(y), (double)(x)); } #else #define atan2l(y, x) ((long double) atan2((double)(y), (double)(x))) #endif #endif /* * coshl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) coshl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) coshl(long double x) { return (long double) cosh((double)(x)); } #else #define coshl(x) ((long double) cosh((double)(x))) #endif #endif /* * sinhl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) sinhl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) sinhl(long double x) { return (long double) sinh((double)(x)); } #else #define sinhl(x) ((long double) sinh((double)(x))) #endif #endif /* * tanhl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) tanhl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) tanhl(long double x) { return (long double) tanh((double)(x)); } #else #define tanhl(x) ((long double) tanh((double)(x))) #endif #endif /* * acoshl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) acoshl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) acoshl(long double x) { return (long double) acosh((double)(x)); } #else #define acoshl(x) ((long double) acosh((double)(x))) #endif #endif /* * asinhl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) asinhl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) asinhl(long double x) { return (long double) asinh((double)(x)); } #else #define asinhl(x) ((long double) asinh((double)(x))) #endif #endif /* * atanhl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) atanhl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) atanhl(long double x) { return (long double) atanh((double)(x)); } #else #define atanhl(x) ((long double) atanh((double)(x))) #endif #endif /* * expl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) expl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) expl(long double x) { return (long double) exp((double)(x)); } #else #define expl(x) ((long double) exp((double)(x))) #endif #endif /* * expm1l() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) expm1l(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) expm1l(long double x) { return (long double) expm1((double)(x)); } #else #define expm1l(x) ((long double) expm1((double)(x))) #endif #endif /* * exp2l() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) exp2l(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) exp2l(long double x) { return (long double) exp2((double)(x)); } #else #define exp2l(x) ((long double) exp2((double)(x))) #endif #endif /* * frexpl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) frexpl(long double x, int *exponent); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) frexpl(long double x, int *exponent) { return (long double) frexp((double)(x), (exponent)); } #else #define frexpl(x, exponent) ((long double) frexp((double)(x), (exponent))) #endif #endif /* * ldexpl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) ldexpl(long double x, int n); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) ldexpl(long double x, int n) { return (long double) ldexp((double)(x), (n)); } #else #define ldexpl(x, n) ((long double) ldexp((double)(x), (n))) #endif #endif /* * logl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) logl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) logl(long double x) { return (long double) log((double)(x)); } #else #define logl(x) ((long double) log((double)(x))) #endif #endif /* * log1pl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) log1pl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) log1pl(long double x) { return (long double) log1p((double)(x)); } #else #define log1pl(x) ((long double) log1p((double)(x))) #endif #endif /* * log10l() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) log10l(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) log10l(long double x) { return (long double) log10((double)(x)); } #else #define log10l(x) ((long double) log10((double)(x))) #endif #endif /* * log2l() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) log2l(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) log2l(long double x) { return (long double) log2((double)(x)); } #else #define log2l(x) ((long double) log2((double)(x))) #endif #endif /* * logbl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) logbl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) logbl(long double x) { return (long double) logb((double)(x)); } #else #define logbl(x) ((long double) logb((double)(x))) #endif #endif /* * scalbl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) scalbl(long double x, long n); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) scalbl(long double x, long n) { return (long double) scalb((double)(x), (n)); } #else #define scalbl(x, n) ((long double) scalb((double)(x), (n))) #endif #endif /* * fabsl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) fabsl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) fabsl(long double x) { return (long double) fabs((double)(x)); } #else #define fabsl(x) ((long double) fabs((double)(x))) #endif #endif /* * hypotl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) hypotl(long double x, long double y); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) hypotl(long double x, long double y) { return (long double) hypot((double)(x), (double)(y)); } #else #define hypotl(x, y) ((long double) hypot((double)(x), (double)(y))) #endif #endif /* * powl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) powl(long double x, long double y); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) powl(long double x, long double y) { return (long double) pow((double)(x), (double)(y)); } #else #define powl(x, y) ((long double) pow((double)(x), (double)(y))) #endif #endif /* * sqrtl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) sqrtl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) sqrtl(long double x) { return (long double) sqrt((double)(x)); } #else #define sqrtl(x) ((long double) sqrt((double)(x))) #endif #endif /* * erfl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) erfl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) erfl(long double x) { return (long double) erf((double)(x)); } #else #define erfl(x) ((long double) erf((double)(x))) #endif #endif /* * erfcl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) erfcl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) erfcl(long double x) { return (long double) erfc((double)(x)); } #else #define erfcl(x) ((long double) erfc((double)(x))) #endif #endif /* * gammal() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) gammal(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) gammal(long double x) { return (long double) gamma((double)(x)); } #else #define gammal(x) ((long double) gamma((double)(x))) #endif #endif /* * lgammal() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) lgammal(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) lgammal(long double x) { return (long double) lgamma((double)(x)); } #else #define lgammal(x) ((long double) lgamma((double)(x))) #endif #endif /* * ceill() * * Availability: * Non-Carbon CFM: in MathLib 2.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) ceill(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) ceill(long double x) { return (long double) ceil((double)(x)); } #else #define ceill(x) ((long double) ceil((double)(x))) #endif #endif /* * floorl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) floorl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) floorl(long double x) { return (long double) floor((double)(x)); } #else #define floorl(x) ((long double) floor((double)(x))) #endif #endif /* * rintl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) rintl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) rintl(long double x) { return (long double) rint((double)(x)); } #else #define rintl(x) ((long double) rint((double)(x))) #endif #endif /* * nearbyintl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) nearbyintl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) nearbyintl(long double x) { return (long double) nearbyint((double)(x)); } #else #define nearbyintl(x) ((long double) nearbyint((double)(x))) #endif #endif /* * rinttoll() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long ) rinttoll(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long ) rinttoll(long double x) { return rinttol((double)(x)); } #else #define rinttoll(x) (rinttol((double)(x))) #endif #endif /* * roundl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) roundl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) roundl(long double x) { return (long double) round((double)(x)); } #else #define roundl(x) ((long double) round((double)(x))) #endif #endif /* * roundtoll() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long ) roundtoll(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long ) roundtoll(long double x) { return roundtol((double)(x)); } #else #define roundtoll(x) (roundtol((double)(x))) #endif #endif /* * truncl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) truncl(long double x); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) truncl(long double x) { return (long double) trunc((double)(x)); } #else #define truncl(x) ((long double) trunc((double)(x))) #endif #endif /* * remainderl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) remainderl(long double x, long double y); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) remainderl(long double x, long double y) { return (long double) remainder((double)(x), (double)(y)); } #else #define remainderl(x, y) ((long double) remainder((double)(x), (double)(y))) #endif #endif /* * remquol() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) remquol(long double x, long double y, int *quo); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) remquol(long double x, long double y, int *quo) { return (long double) remquo((double)(x), (double)(y), (quo)); } #else #define remquol(x, y, quo) ((long double) remquo((double)(x), (double)(y), (quo))) #endif #endif /* * copysignl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) copysignl(long double x, long double y); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) copysignl(long double x, long double y) { return (long double) copysign((double)(x), (double)(y)); } #else #define copysignl(x, y) ((long double) copysign((double)(x), (double)(y))) #endif #endif /* * fdiml() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) fdiml(long double x, long double y); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) fdiml(long double x, long double y) { return (long double) fdim((double)(x), (double)(y)); } #else #define fdiml(x, y) ((long double) fdim((double)(x), (double)(y))) #endif #endif /* * fmaxl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) fmaxl(long double x, long double y); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) fmaxl(long double x, long double y) { return (long double) fmax((double)(x), (double)(y)); } #else #define fmaxl(x, y) ((long double) fmax((double)(x), (double)(y))) #endif #endif /* * fminl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) fminl(long double x, long double y); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) fminl(long double x, long double y) { return (long double) fmin((double)(x), (double)(y)); } #else #define fminl(x, y) ((long double) fmin((double)(x), (double)(y))) #endif #endif #endif /* __MWERKS__ */ #ifndef __NOEXTENSIONS__ /* * relationl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( relop ) relationl(long double x, long double y); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(relop ) relationl(long double x, long double y) { return relation((double)(x), (double)(y)); } #else #define relationl(x, y) (relation((double)(x), (double)(y))) #endif #endif /* * num2decl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( void ) num2decl(const decform *f, long double x, decimal *d); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(void) num2decl(const decform *f, long double x, decimal *d) { num2dec((f), (double)(x), (d)); } #else #define num2decl(f, x, d) (num2dec((f), (double)(x), (d))) #endif #endif /* * dec2numl() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( long double ) dec2numl(const decimal * d); #if TYPE_LONGDOUBLE_IS_DOUBLE #ifdef __cplusplus inline DEFINE_API_C(long double ) dec2numl(const decimal *d) { return (long double) dec2num(d); } #else #define dec2numl(d) ((long double) dec2num(d)) #endif #endif #endif /* !defined(__NOEXTENSIONS__) */ #endif /* TARGET_CPU_PPC */ #endif /* TARGET_OS_MAC */ #ifndef __NOEXTENSIONS__ /* MathLib v2 has two new transfer functions: x80tod and dtox80. They can be used to directly transform 68k 80-bit extended data types to double and back for PowerPC based machines without using the functions x80told or ldtox80. Double rounding may occur. */ /* * x80tod() * * Availability: * Non-Carbon CFM: in MathLib 2.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( double ) x80tod(const extended80 * x80); /* * dtox80() * * Availability: * Non-Carbon CFM: in MathLib 2.0 and later * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: in version 10.0 and later */ EXTERN_API_C( void ) dtox80(const double *x, extended80 *x80); /* * x80told() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( void ) x80told(const extended80 *x80, long double *x); #if TYPE_LONGDOUBLE_IS_DOUBLE && !TARGET_OS_WIN32 #ifdef __cplusplus inline DEFINE_API_C(void) x80told(const extended80 *x80, long double *x) { *(x) = (long double) x80tod(x80); } #else #define x80told(x80, x) (*(x) = (long double) x80tod(x80)) #endif #endif /* * ldtox80() * * Availability: * Non-Carbon CFM: in MathLib 1.0 and later or as macro/inline * CarbonLib: in CarbonLib 1.0 and later * Mac OS X: not available */ EXTERN_API_C( void ) ldtox80(const long double *x, extended80 *x80); #if TYPE_LONGDOUBLE_IS_DOUBLE && !TARGET_OS_WIN32 #ifdef __cplusplus inline DEFINE_API_C(void) ldtox80(const long double *x, extended80 *x80) { double d = (double) *(x); dtox80(&d, (x80)); } #else #define ldtox80(x, x80) do { double d = (double) *(x); dtox80(&d, (x80)); } while (false) #endif #endif #endif /* !defined(__NOEXTENSIONS__) */ #if PRAGMA_STRUCT_ALIGN #pragma options align=reset #elif PRAGMA_STRUCT_PACKPUSH #pragma pack(pop) #elif PRAGMA_STRUCT_PACK #pragma pack() #endif #ifdef PRAGMA_IMPORT_OFF #pragma import off #elif PRAGMA_IMPORT #pragma import reset #endif #ifdef __cplusplus } #endif #endif /* __FP__ */