468 lines
12 KiB
C
468 lines
12 KiB
C
/* Mathematics <math.h>
|
|
|
|
This file is part of the Public Domain C Library (PDCLib).
|
|
Permission is granted to use, modify, and / or redistribute at will.
|
|
*/
|
|
|
|
#ifndef _PDCLIB_MATH_H
|
|
#define _PDCLIB_MATH_H _PDCLIB_MATH_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "pdclib/_PDCLIB_lib_ext1.h"
|
|
#include "pdclib/_PDCLIB_internal.h"
|
|
|
|
typedef float float_t;
|
|
typedef double double_t;
|
|
|
|
#define HUGE_VALF _PDCLIB_HUGE_VALF;
|
|
#define HUGE_VAL _PDCLIB_HUGE_VAL;
|
|
#define HUGE_VALL _PDCLIB_HUGE_VALL;
|
|
|
|
#define INFINITY (_PDCLIB_FLT_MAX * 2)
|
|
#define NAN ( -(0.0f / 0.0f) )
|
|
|
|
#define FP_FAST_FMAF
|
|
#define FP_FAST_FMA
|
|
#define FP_FAST_FMAL
|
|
|
|
#define FP_ILOGB0 INT_MIN
|
|
#define FP_ILOGBNAN INT_MAX
|
|
|
|
#define MATH_ERRNO 1
|
|
#define MATH_ERREXCEPT 2
|
|
|
|
#define math_errhandling
|
|
|
|
/* Classification */
|
|
|
|
/* FP_ZERO, FP_SUBNORMAL, FP_NORMAL */
|
|
#define isfinite( x ) _PDCLIB_GENERIC( isfinite, x )
|
|
|
|
/* FP_INFINITE */
|
|
#define isinf( x ) _PDCLIB_GENERIC( isinf, x )
|
|
|
|
/* FP_NAN */
|
|
#define isnan( x ) _PDCLIB_GENERIC( isnan, x )
|
|
|
|
/* FP_NORMAL */
|
|
#define isnormal( x ) _PDCLIB_GENERIC( isnormal, x )
|
|
|
|
/* Negative */
|
|
#define signbit( x ) _PDCLIB_GENERIC( signbit, x )
|
|
|
|
/* See FP_* classes */
|
|
#define fpclassify( x ) _PDCLIB_GENERIC( fpclassify, x )
|
|
|
|
#define FP_INFINITE 1
|
|
#define FP_NAN 2
|
|
#define FP_NORMAL 3
|
|
#define FP_SUBNORMAL 4
|
|
#define FP_ZERO 5
|
|
|
|
/* Trigonometric functions */
|
|
|
|
/* The principal value of the arc cosine of x.
|
|
Domain error for arguments not in the interval -1..+1.
|
|
Returns the interval 0..Pi radians.
|
|
*/
|
|
double acos( double x );
|
|
float acosf( float x );
|
|
long double acosl( long double x );
|
|
|
|
/* The principal value of the arc sine of x.
|
|
Domain error for arguments not in the interval -1..+1.
|
|
Returns the interval -Pi/2..Pi/2 radians.
|
|
*/
|
|
double asin( double x );
|
|
float asinf( float x );
|
|
long double asinl( long double x );
|
|
|
|
/* The principal value of the arc tangent of x.
|
|
Returns the interval -Pi/2..Pi/2 radians.
|
|
*/
|
|
double atan( double x );
|
|
float atanf( float x );
|
|
long double atanl( long double x );
|
|
|
|
/* The value of the arc tangent of y/x, using the signs of both
|
|
arguments to determine the quadrant of the return value.
|
|
Domain error if both arguments are zero.
|
|
Returns the interval -Pi..Pi radians.
|
|
*/
|
|
double atan2( double y, double x );
|
|
float atan2f( float y, float x );
|
|
long double atan2l( long double y, long double x );
|
|
|
|
/* Cosine of x in radians. */
|
|
double cos( double x );
|
|
float cosf( float x );
|
|
long double cosl( long double x );
|
|
|
|
/* Sine of x in radians. */
|
|
double sin( double x );
|
|
float sinf( float x );
|
|
long double sinl( long double x );
|
|
|
|
/* Tangent of x in radians. */
|
|
double tan( double x );
|
|
float tanf( float x );
|
|
long double tanl( long double x );
|
|
|
|
/* Hyperbolic functions */
|
|
|
|
/* The (nonnegative) arc hyberbolic cosine of x.
|
|
Domain error for arguments less than 1.
|
|
Returns the interval 0..INF.
|
|
*/
|
|
double acosh( double x );
|
|
float acoshf( float x );
|
|
long double acoshl( long double x );
|
|
|
|
/* The arc hyberbolic sine of x.
|
|
*/
|
|
double asinh( double x );
|
|
float asinhf( float x );
|
|
long double asinhl( long double x );
|
|
|
|
/* The arc hyberbolic tangent of x.
|
|
Domain error for arguments not in -1..1.
|
|
Range error if -1 or +1.
|
|
*/
|
|
double atanh( double x );
|
|
float atanhf( float x );
|
|
long double atanhl( long double x );
|
|
|
|
/* The hyberbolic cosine of x.
|
|
Range error if magnitude of x is too large.
|
|
*/
|
|
double cosh( double x );
|
|
float coshf( float x );
|
|
long double coshl( long double x );
|
|
|
|
/* The hyberbolic sine of x.
|
|
Range error if magnitude of x is too large.
|
|
*/
|
|
double sinh( double x );
|
|
float sinhf( float x );
|
|
long double sinhl( long double x );
|
|
|
|
/* The hyberbolic tangent of x.
|
|
Range error if magnitude of x is too large.
|
|
*/
|
|
double tanh( double x );
|
|
float tanhf( float x );
|
|
long double tanhl( long double x );
|
|
|
|
/* Exponential and logarithmic functions */
|
|
|
|
/* The base-e exponential of x.
|
|
Range error if magnitude of x is too large.
|
|
*/
|
|
double exp( double x );
|
|
float expf( float x );
|
|
long double expl( long double x );
|
|
|
|
/* The base-2 exponential of x.
|
|
Range error if magnitude of x is too large.
|
|
*/
|
|
double exp2( double x );
|
|
float exp2f( float x );
|
|
long double exp2l( long double x );
|
|
|
|
/* The base-e exponential of x, minus 1.
|
|
Range error if magnitude of x is too large.
|
|
Returns e^x - 1.
|
|
*/
|
|
double expm1( double x );
|
|
float expm1f( float x );
|
|
long double expm1l( long double x );
|
|
|
|
/* Breaks a floating-point number into a normalized fraction
|
|
and an integral power of 2 (stored in the object pointed
|
|
to by exp).
|
|
*/
|
|
double frexp( double value, int * exp );
|
|
float frexpf( float value, int * exp );
|
|
long double frexpl( long double value, int * exp );
|
|
|
|
/* Extract the exponent of x as a signed int.
|
|
* Returns FP_ILOGB0 if x is zero, INT_MAX if x is infinite,
|
|
* FP_ILOGBNAN if x is a NaN. Range error may occur if x is 0.
|
|
*/
|
|
double ilogb( double x );
|
|
float ilogbf( float x );
|
|
long double ilogbl( long double x );
|
|
|
|
/* Multiply x by 2^exp. Range error may occur. */
|
|
double ldexp( double x, int exp );
|
|
float ldexpf( float x, int exp );
|
|
long double ldexpl( long double x, int exp );
|
|
|
|
/* Compute the base-e logarithm of x.
|
|
Domain error if argument is negative.
|
|
Range error if argument is zero.
|
|
*/
|
|
double log( double x );
|
|
float logf( float x );
|
|
long double logl( long double x );
|
|
|
|
/* Compute the base-10 logarithm of x.
|
|
Domain error if argument is negative.
|
|
Range error if argument is zero.
|
|
*/
|
|
double log10( double x );
|
|
float log10f( float x );
|
|
long double log10l( long double x );
|
|
|
|
/* Compute the base-e logarithm of 1 plus x.
|
|
Domain error if argument is less than -1.
|
|
Range error if argument is -1.
|
|
*/
|
|
double log1p( double x );
|
|
float log1pf( float x );
|
|
long double log1pl( long double x );
|
|
|
|
/* Compute the base-2 logarithm of x.
|
|
Domain error if argument is negative.
|
|
Range error if argument is zero.
|
|
*/
|
|
double log2( double x );
|
|
float log2f( float x );
|
|
long double log2l( long double x );
|
|
|
|
/* Extract exponent of x, as signed integer in floating-point format.
|
|
Subnormal is treated as though normalized.
|
|
Domain error if argument is zero.
|
|
*/
|
|
double logb( double x );
|
|
float logbf( float x );
|
|
long double logbl( long double x );
|
|
|
|
/* Breaks value into integral and fractional parts, each having
|
|
the same type and sign as the argument. The integral part is
|
|
stored in the object pointed to by iptr.
|
|
*/
|
|
double modf( double value, double * exp );
|
|
float modff( float value, float * exp );
|
|
long double modfl( long double value, long double * exp );
|
|
|
|
/* Compute x * FLT_RADIX^n efficiently. Range error may occur. */
|
|
double scalbn( double x, int n );
|
|
float scalbnf( float x, int n );
|
|
long double scalbnl( long double x, int n );
|
|
|
|
double scalbln( double x, long int * n );
|
|
float scalblnf( float x, long int * n );
|
|
long double scalblnl( long double x, long int * n );
|
|
|
|
/* Power and absolute-value functions */
|
|
|
|
/* Returns x^1/3. */
|
|
double cbrt( double x );
|
|
float cbrtf( float x );
|
|
long double cbrtl( long double x );
|
|
|
|
/* Returns absolute value of x. */
|
|
double fabs( double x );
|
|
float fabsf( float x );
|
|
long double fabsl( long double x );
|
|
|
|
/* Returns square root of the sum of squares of x and y.
|
|
Range error may occur.
|
|
*/
|
|
double hypot( double x, double y );
|
|
float hypotf( float x, float y );
|
|
long double hypotl( long double x, long double y );
|
|
|
|
/* Returns x^y.
|
|
Domain error if x is finite and negative and y is finite and not
|
|
an integer value.
|
|
Domain error if x is zero and y is less or equal zero.
|
|
Range error may occur.
|
|
*/
|
|
double pow( double x, double y );
|
|
float powf( float x, float y );
|
|
long double powl( long double x, long double y );
|
|
|
|
/* Returns x^1/2. */
|
|
double sqrt( double x );
|
|
float sqrtf( float x );
|
|
long double sqrtl( long double x );
|
|
|
|
/* Error and gamma functions */
|
|
|
|
/* Compute the error function of x. */
|
|
double erf( double x );
|
|
float erff( float x );
|
|
long double erfl( long double x );
|
|
|
|
/* Compute the complementary error function of x.
|
|
Range error if x is too large.
|
|
*/
|
|
double erfc( double x );
|
|
float erfcf( float x );
|
|
long double erfcl( long double x );
|
|
|
|
/* Compute the natural logarithm of the absolute value of gamma(x).
|
|
Range error if x is too lange, x is negative, or zero.
|
|
*/
|
|
double lgamma( double x );
|
|
float lgammaf( float x );
|
|
long double lgammal( long double x );
|
|
|
|
/* Compute the gamma function of x.
|
|
Range error if x is negative, or zero, too large or too small.
|
|
*/
|
|
double tgamma( double x );
|
|
float tgammaf( float x );
|
|
long double tgammal( long double x );
|
|
|
|
/* Nearest integer functions */
|
|
|
|
/* The smallest integer no less than x. */
|
|
double ceil( double x );
|
|
float ceilf( float x );
|
|
long double ceill( long double x );
|
|
|
|
/* The largest integer no greater than x. */
|
|
double floor( double x );
|
|
float floorf( float x );
|
|
long double floorl( long double x );
|
|
|
|
/* Round in current rounding direction. No "inexact" exception. */
|
|
double nearbyint( double x );
|
|
float nearbyintf( float x );
|
|
long double nearbyintl( long double x );
|
|
|
|
/* Round in current rounding direction. Raises "inexact" exception. */
|
|
double rint( double x );
|
|
float rintf( float x );
|
|
long double rintl( long double x );
|
|
|
|
/* Round in current rounding direction.
|
|
Range error if magnitude is too large.
|
|
*/
|
|
long int lrint( double x );
|
|
long int lrintf( float x );
|
|
long int lrintl( long double x );
|
|
long long int llrint( double x );
|
|
long long int llrintf( float x );
|
|
long long int llrintl( long double x );
|
|
|
|
/* Round to nearest, breaking ties away from zero. */
|
|
double round( double x );
|
|
float roundf( float x );
|
|
long double roundl( long double x );
|
|
|
|
/* Round to nearest, breaking ties away from zero.
|
|
Range error if magnitude is too large.
|
|
*/
|
|
long int lround( double x );
|
|
long int lroundf( float x );
|
|
long int lroundl( long double x );
|
|
long long int llround( double x );
|
|
long long int llroundf( float x );
|
|
long long int llroundl( long double x );
|
|
|
|
/* Round toward zero. */
|
|
double trunc( double x );
|
|
float truncf( float x );
|
|
long double truncl( long double x );
|
|
|
|
/* Remainder functions */
|
|
|
|
/* Compute the remainder of x / y. */
|
|
double fmod( double x, double y );
|
|
float fmodf( float x, float y );
|
|
long double fmodl( long double x, long double y );
|
|
|
|
/* Compute the remainder of x REM y. */
|
|
double remainder( double x, double y );
|
|
float remainderf( float x, float y );
|
|
long double remainderl( long double x, long double y );
|
|
|
|
/* Compute the remainder of x REM y. In quo store a value with
|
|
the sign of the quotient and magnitude congruent mod 2^n to
|
|
the magnitude of the integral quotient of x / y, with n
|
|
an implementation-defined integer greater than or equal to 3.
|
|
*/
|
|
double rmquo( double x, double y );
|
|
float rmquof( float x, float y );
|
|
long double rmquol( long double x, long double y );
|
|
|
|
/* Manipulation functions */
|
|
|
|
/* Returns a value with magnitude of x and sign of y. */
|
|
double copysign( double x, double y );
|
|
float copysignf( float x, float y );
|
|
long double copysignl( long double x, long double y );
|
|
|
|
/* Returns a NaN value with the given n-char sequence. */
|
|
double nan( const char * tagp );
|
|
float nanf( const char * tagp );
|
|
long double nanl( const char * tagp );
|
|
|
|
/* Determine the next representable value after x in direction y.
|
|
Range error if result is not representable.
|
|
*/
|
|
double nextafter( double x, double y );
|
|
float nextafterf( float x, float y );
|
|
long double nextafterl( long double x, long double y );
|
|
|
|
/* As nextafter but with long double as second parameter. */
|
|
double nexttoward( double x, double y );
|
|
float nexttowardf( float x, float y );
|
|
long double nexttowardl( long double x, long double y );
|
|
|
|
/* Maximum, minimum, and positive difference functions */
|
|
|
|
/* Positive difference. */
|
|
double fdim( double x, double y );
|
|
float fdimf( float x, float y );
|
|
long double fdiml( long double x, long double y );
|
|
|
|
/* Maximum. */
|
|
double fmax( double x, double y );
|
|
float fmaxf( float x, float y );
|
|
long double fmaxl( long double x, long double y );
|
|
|
|
/* Minimum. */
|
|
double fmin( double x, double y );
|
|
float fminf( float x, float y );
|
|
long double fminl( long double x, long double y );
|
|
|
|
/* Multiply-add. */
|
|
double fma( double x, double y, double z );
|
|
float fmaf( float x, float y, float z );
|
|
long double fmal( long double x, long double y, long double z );
|
|
|
|
/* Comparison macros (without "invalid" FP exception) */
|
|
|
|
#define isgreater( x, y )
|
|
|
|
#define isgreaterequal( x, y )
|
|
|
|
#define isless( x, y )
|
|
|
|
#define islessequal( x, y )
|
|
|
|
#define islessgreater( x, y )
|
|
|
|
#define isunordered( x, y )
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
/* Extension hook for downstream projects that want to have non-standard
|
|
extensions to standard headers.
|
|
*/
|
|
#ifdef _PDCLIB_EXTEND_MATH_H
|
|
#include _PDCLIB_EXTEND_MATH_H
|
|
#endif
|
|
|
|
#endif
|