X-Git-Url: https://pd.if.org/git/?p=pdclib;a=blobdiff_plain;f=includes%2Ftgmath.h;h=c356272b6bc2fc662a70b9d4257ef6a379ee7e2e;hp=976715b668b559a05837bb5d20353067f7bc6e7e;hb=ac3f809c3c10347c110fac3db93af0954eda98bb;hpb=8b8277d2940a8745f85d86a9af3ad6970b5fa52c diff --git a/includes/tgmath.h b/includes/tgmath.h index 976715b..c356272 100644 --- a/includes/tgmath.h +++ b/includes/tgmath.h @@ -4,12 +4,374 @@ // Public Domain C Library - http://pdclib.sourceforge.net // This code is Public Domain. Use, modify, and redistribute at will. // ---------------------------------------------------------------------------- -// TODO +// Type-generic math // ---------------------------------------------------------------------------- #ifndef __TGMATH_H #define __TGMATH_H __TGMATH_H +// These functions return the sine of their parameter. +double sin(double value); +float sin(float value); +long double sin(long double value); +double _Complex sin(double _Complex value); +float _Complex sin(float _Complex value); +long double _Complex sin(long double _Complex value); + +// These functions return the hyperbolic sine of their parameter. +double sinh(double value); +float sinh(float value); +long double sinh(long double value); +double _Complex sinh(double _Complex value); +float _Complex sinh(float _Complex value); +long double _Complex sinh(long double _Complex value); + +// These functions return the arcsine of their parameter. +double asin(double value); +float asin(float value); +long double asin(long double value); +double _Complex asin(double _Complex value); +float _Complex asin(float _Complex value); +long double _Complex asin(long double _Complex value); + +// These functions return the hyperbolic arcsine of their parameter. +double asinh(double value); +float asinh(float value); +long double asinh(long double value); +double _Complex asinh(double _Complex value); +float _Complex asinh(float _Complex value); +long double _Complex asinh(long double _Complex value); + +// These functions return the cosine of their parameter. +double cos(double value); +float cos(float value); +long double cos(long double value); +double _Complex cos(double _Complex value); +float _Complex cos(float _Complex value); +long double _Complex cos(long double _Complex value); + +// These functions return the hyperbolic cosine of their parameter. +double cosh(double value); +float cosh(float value); +long double cosh(long double value); +double _Complex cosh(double _Complex value); +float _Complex cosh(float _Complex value); +long double _Complex cosh(long double _Complex value); + +// These functions return the arccosine of their parameter. +double acos(double value); +float acos(float value); +long double acos(long double value); +double _Complex acos(double _Complex value); +float _Complex acos(float _Complex value); +long double _Complex acos(long double _Complex value); + +// These functions return the hyperbolic arccosine of their parameter. +double acosh(double value); +float acosh(float value); +long double acosh(long double value); +double _Complex acosh(double _Complex value); +float _Complex acosh(float _Complex value); +long double _Complex acosh(long double _Complex value); + +// These functions return the tangent of their parameter. +double tan(double value); +float tan(float value); +long double tan(long double value); +double _Complex tan(double _Complex value); +float _Complex tan(float _Complex value); +long double _Complex tan(long double _Complex value); + +// These functions return the hyperbolic tangent of their parameter. +double tanh(double value); +float tanh(float value); +long double tanh(long double value); +double _Complex tanh(double _Complex value); +float _Complex tanh(float _Complex value); +long double _Complex tanh(long double _Complex value); + +// These functions return the arctangent of their parameter. +double atan(double value); +float atan(float value); +long double atan(long double value); +double _Complex atan(double _Complex value); +float _Complex atan(float _Complex value); +long double _Complex atan(long double _Complex value); + +// These functions return the hyperbolic arctangent of their parameter. +double atanh(double value); +float atanh(float value); +long double atanh(long double value); +double _Complex atanh(double _Complex value); +float _Complex atanh(float _Complex value); +long double _Complex atanh(long double _Complex value); + +// These functions return the angle whose tangent is x / y. +double atan2(double x, double y); +float atan2(float x, float y); +long double atan2(long double x, long double y); + +// These functions return the phase angle of their parameter. +double carg(double _Complex value); +float carg(float _Complex value); +long double carg(long double _Complex value); + +// These functions return the largest integer no larger than their parameter. +double floor(double value); +float floor(float value); +long double floor(long double value); + +// These functions return the smallest integer not less than their parameter. +double ceil(double value); +float ceil(float value); +long double ceil(long double value); + +// These functions return the square root of their parameter. +double sqrt(double value); +float sqrt(float value); +long double sqrt(long double value); +double _Complex sqrt(double _Complex value); +float _Complex sqrt(float _Complex value); +long double _Complex sqrt(long double _Complex value); + +// These functions return the cube root of their parameter. +double cbrt(double value); +float cbrt(float value); +long double cbrt(long double value); + +// These functions return the imaginary part of their parameter. +double cimag(double _Complex value); +float cimag(float _Complex value); +long double cimag(long double _Complex value); + +// These functions return the real value of their parameter. +double creal(double _Complex value); +float creal(float _Complex value); +long double creal(long double _Complex value); + +// These functions return the conjugate of their parameter. +double _Complex conj(double _Complex value); +float _Complex conj(float _Complex value); +long double _Complex conj(long double _Complex value); + +// These functions return their parameter x with the sign of y. +double copysign(double x, double y); +float copysign(float x, float y); +long double copysign(long double x, long double y); + +// These functions return the projection of their parameter. +double _Complex cproj(double _Complex value); +float _Complex cproj(float _Complex value); +long double _Complex cproj(long double _Complex value); + +// These functions return the error function of their parameter. +double erf(double value); +float erf(float value); +long double erf(long double value); + +// These functions return the complementary error function of their parameter. +double erfc(double value); +float erfc(float value); +long double erfc(long double value); + +// These functions return the exponential of their parameter (e^x). +double exp(double value); +float exp(float value); +long double exp(long double value); +double _Complex exp(double _Complex value); +float _Complex exp(float _Complex value); +long double _Complex exp(long double _Complex value); + +// These functions return 2 raised to the power of their parameter (2^x). +double exp2(double value); +float exp2(float value); +long double exp2(long double value); + +// These functions return exp(value) - 1. +double expm1(double value); +float expm1(float value); +long double expm1(long double value); + +// These functions return the magnitude of their parameter. +double fabs(double value); +float fabs(float value); +long double fabs(long double value); +double fabs(double _Complex value); +float fabs(float _Complex value); +long double fabs(long double _Complex value); + +// These functions return the larger of (x-y) and zero. +double fdim(double x, double y); +float fdim(float x, float y); +long double fdim(long double x, long double y); + +// These functions return (x * y + z) to arbitrary intermediate precision. +double fma(double x, double y, double z); +float fma(float x, float y, float z); +long double fma(long double x, long double y, long double z); + +// These functions return the larger of their parameters. +double fmax(double x, double y); +float fmax(float x, float y); +long double fmax(long double x, long double y); + +// These functions return the smaller of their parameters. +double fmin(double x, double y); +float fmin(float x, float y); +long double fmin(long double x, long double y); + +// These functions return the remainder of (x/y). +double fmod(double x, double y); +float fmod(float x, float y); +long double fmod(long double x, long double y); + +// These functions return a fraction (as return value) and an integer +// exponent (in the parameter 'exponent') that represent value, with the +// fraction being in the interval [0.5, 1) or being zero. If value is zero, +// exponent will also be zero. +// (fraction * 2^exponent) == value) +double frexp(double value, int * exponent); +float frexp(float value, int * exponent); +long double frexp(long double value, int * exponent); + +// These functions return x raised to the power of y. +double pow(double x, double y); +float pow(float x, float y); +long double pow(long double x, long double y); +double _Complex pow(double _Complex x, double _Complex y); +float _Complex pow(float _Complex x, float _Complex y); +long double _Complex pow(long double _Complex x, long double _Complex y); + +// TODO: Check spelling of hypothenuse and cathedes. +// These functions determine the length of the hypothenuse for the cathedes +// x and y. (Square root of a^2 + b^2.) +double hypot(double a, double b); +float hypot(float a, float b); +long double hypot(long double a, long double b); + +// These functions return (int) logb(value). +int ilogb(double value); +int ilogb(float value); +int ilogb(long double value); + +// These functions return (value * 2^exponent). +double ldexp(double value, int exponent); +float ldexp(float value, int exponent); +long double ldexp(long double value, int exponent); + +// These functions return the natural logarithm of their parameter. +double log(double value); +float log(float value); +long double log(long double value); +double _Complex log(double _Complex value); +float _Complex log(float _Complex value); +long double _Complex log(long double _Complex value); + +// These functions return the logarithm (base 10) of their parameter. +double log10(double value); +float log10(float value); +long double log10(long double value); + +// These functions return the natural logarithm of (their parameter + 1). +double log1p(double value); +float log1p(float value); +long double log1p(long double value); + +// These functions return the logarithm (base 2) of their parameter. +double log2(double value); +float log2(float value); +long double log2(long double value); + +// TODO: What do these functions actually do? +double logb(double value); +float logb(float value); +long double logb(long double value); + +// These functions return their parameter rounded to the next integer, using +// the current rounding mode. +long long llrint(double value); +long long llrint(float value); +long long llrint(long double value); +long lrint(double value); +long lrint(float value); +long lrint(long double value); +double rint(double value); +float rint(float value); +long double rint(long double value); + +// These functions return their parameter rounded to the next integer, with +// halfway values rounded away from zero regardless of current rounding mode. +long long llround(double value); +long long llround(float value); +long long llround(long double value); +long lround(double value); +long lround(float value); +long lround(long double value); +// TODO: Do the round() functions really return FP values? +double round(double value); +float round(float value); +long double round(long double value); + +// These functions return their parameter, rounded toward zero. +// TODO: Do these functions really return FP values? +double trunc(double value); +float trunc(float value); +long double trunc(long double value); + +// These functions store the integer part of value in integer, and return the +// remaining part of value. +double modf(double value, double * integer); +float modf(float value, float * integer); +long double modf(long double value, long double * integer); + +// These functions return their parameter rounded to the next integer, using +// the current rounding mode but without raising an inexact FP exception. +double nearbyint(double value); +float nearbyint(float value); +long double nearbyint(long double value); + +// These functions return the next representable value after the smaller of +// their parameters. +// TODO: This might be a wrong description. +double nextafter(double x, double y); +float nextafter(float x, float y); +long double nextafter(long double x, long double y); + +// These functions return the next representable value after the smaller of +// their parameters. +// TODO: This might be a wrong description. +double nexttoward(double x, long double y); +float nexttoward(float x, long double y); +long double nexttoward(long double x, long double y); + // TODO +double remainder(double x, double y); +float remainder(float x, float y); +long double remainder(long double x, long double y); + +// TODO +double remquo(double x, double y, int * pquo); +float remquo(float x, float y, int * pquo); +long double remquo(long double x, long double y, int * pquo); + +// TODO +double scalbln(double x, long ex); +float scalbln(float x, long ex); +long double scalbln(long double x, long ex); + +// TODO +double scalbn(double x, int ex); +float scalbn(float x, int ex); +long double scalbn(long double x, int ex); + +// These functions return the gamma function of their parameter. +double tgamma(double value); +float tgamma(float value); +long double tgamma(long double value); + +// These functions return log( fabs( tgamma(value) ) ). +double lgamma(double value); +float lgamma(float value); +long double lgamma(long double value); #endif // __TGMATH_H