1 // ----------------------------------------------------------------------------
3 // ----------------------------------------------------------------------------
4 // Public Domain C Library - http://pdclib.sourceforge.net
5 // This code is Public Domain. Use, modify, and redistribute at will.
6 // ----------------------------------------------------------------------------
8 // ----------------------------------------------------------------------------
11 #define __MATH_H __MATH_H
13 // TODO: Documentation
15 // ----------------------------------------------------------------------------
18 #define HUGE_VAL // TODO - personality?
19 #define HUGE_VALF // TODO - personality?
20 #define HUGE_VALL // TODO - personality?
22 #define INFINITY // TODO - personality?
23 #define NAN // TODO - personality?
25 #define FP_FAST_FMA // TODO - personality?
26 #define FP_FAST_FMAF // TODO - personality?
27 #define FP_FAST_FMAL // TODO - personality?
29 #define FP_INFINITE // TODO - personality?
30 #define FP_NAN // TODO - personality?
31 #define FP_NORMAL // TODO - personality?
32 #define FP_SUBNORMAL // TODO - personality?
33 #define FP_ZERO // TODO - personality?
35 #define FP_ILOGB0 // TODO - personality?
36 #define FP_ILOGBNAN // TODO - personality?
38 #define MATH_ERRNO 1 // personality?
39 #define MATH_ERREXCEPT 2 // personality?
40 #define math_errhandling // TODO - personality?
42 // --------------------------------------------------------------------------
45 typedef double_t; // TODO - personality?
46 typedef float_t; // TODO - personality?
48 // --------------------------------------------------------------------------
53 #define isgreater( x, y ) // TODO
54 #define isgreaterequal( x, y ) // TODO
55 #define isless( x, y ) // TODO
56 #define islessequal( x, y ) // TODO
57 #define islessgreater( x, y ) // TODO
58 #define isunordered( x, y ) // TODO
59 #define fpclassify( x ) // TODO
60 #define isfinite( x ) // TODO
62 #define isinf( x ) // TODO
63 #define isnan( x ) // TODO
64 #define isnormal( x ) // TODO
65 #define signbit( x ) // TODO
69 // The same functionality as above is implemented as functions in C++.
70 bool signbit( float x );
71 bool signbit( double x );
72 bool signbit( long double x );
73 int fpclassify( float x );
74 int fpclassify( double x );
75 int fpclassify( long double x );
76 bool isfinite( float x );
77 bool isfinite( double x );
78 bool isfinite( long double x );
79 bool isinf( float x );
80 bool isinf( double x );
81 bool isinf( long double x );
82 bool isnan( float x );
83 bool isnan( double x );
84 bool isnan( long double x );
85 bool isnormal( float x );
86 bool isnormal( double x );
87 bool isnormal( long double x );
88 bool isgreater( float x, float y );
89 bool isgreater( double x, double y );
90 bool isgreater( long double x, long double y );
91 bool isgreaterequal( float x, float y );
92 bool isgreaterequal( double x, double y );
93 bool isgreaterequal( long double x, long double y );
94 bool isless( float x, float y );
95 bool isless( double x, double y );
96 bool isless( long double x, long double y );
97 bool islessequal( float x, float y );
98 bool islessequal( double x, double y );
99 bool islessequal( long double x, long double y );
100 bool islessgreater( float x, float y );
101 bool islessgreater( double x, double y );
102 bool islessgreater( long double x, long double y );
103 bool isunordered( float x, float y );
104 bool isunordered( double x, double y );
105 bool isunordered( long double x, long double y );
107 #endif // __cplusplus
109 // --------------------------------------------------------------------------
114 // These functions return the magnitude of their parameter.
115 double abs( double x );
116 float abs( float x );
117 long double abs( long double x );
118 float fabs( float x );
119 long double fabs( long double x );
121 // These functions return the sine of their parameter.
122 float sin( float x );
123 long double sin( long double x );
125 // These functions return the hyperbolic sine of their parameter.
126 float sinh( float x );
127 long double sinh( long double x );
129 // These functions return the arcsine of their parameter.
130 float asin( float x );
131 long double asin( long double x );
133 // These functions compute the arc hyperbolic sine of x.
134 float asinh( float x );
135 long double asinh( long double x );
137 // These functions return the cosine of their parameter.
138 float cos( float x );
139 long double cos( long double x );
141 // These functions return the hyperbolic cosine of their parameter.
142 float cosh( float x );
143 long double cosh( long double x );
145 // These functions return the arcsine of their parameter.
146 float acos( float x );
147 long double acos( long double x );
149 // These functions return the hyperbolic arccosine of their parameter.
150 float acosh( float x );
151 long double acosh( long double x );
153 // These functions return the tangent of their parameter.
154 float tan( float x );
155 long double tan( long double x );
157 // These functions return the hyperbolic tangent of their parameter.
158 float tanh( float x );
159 long double tanh( long double x );
161 // These functions return the arctangent of their parameter.
162 float atan( float x );
163 long double atan( long double x );
165 // These functions return the hyperbolic arctangent of their parameter.
166 float atanh( float x );
167 long double atanh( long double x );
170 float atan2( float y, float x );
171 long double atan2( long double y, long double x );
173 // These functions return sqrt( x^2 + y^2 ).
174 float hypot( float x, float y );
175 long double hypot( long double x, long double y );
177 // These functions return their parameter x, raised to the power y.
178 float pow( float x, float y );
179 long double pow( long double x, long double y );
180 double pow( double x, int y );
181 float pow( float x, int y );
182 long double pow( long double x, int y );
184 // These functions return the square root of their parameter.
185 float sqrt( float x );
186 long double sqrt( long double x );
189 float cbrt( float x );
190 long double cbrt( long double x );
193 float exp( float x );
194 long double exp( long double x );
197 float exp2( float x );
198 long double exp2( long double x );
201 float expm1( float x );
202 long double expm1( long double x );
205 float frexp( float x, int * exponent );
206 long double frexp( long double x, int * exponent );
209 float ldexp( float x, int exponent );
210 long double ldexp( long double x, int exponent );
212 // These functions return the natural logarithm of their parameter.
213 float log( float x );
214 long double log( long double x );
216 // These functions return the logarithm (base 10 ) of their parameter.
217 float log10( float x );
218 long double log10( long double x );
220 // These functions return the logarithm (base 2 ) of their parameter.
221 float log2( float x );
222 long double log2( long double x );
225 float logb( float x );
226 long double logb( long double x );
229 int ilogb( float x );
230 int ilogb( long double x );
233 float log1p( float x );
234 long double log1p( long double x );
236 // These functions return the smallest integer no larger than their parameter
237 float ceil( float x );
238 long double ceil( long double x );
240 // These functions return the biggest integer no larger than their parameter.
241 float floor( float x );
242 long double floor( long double x );
245 float fmod( float x, float y );
246 long double fmod( long double x, long double y );
249 float modf( float x, float * integer );
250 long double modf( long double x, long double * integer );
252 // These functions return their parameter x, with the sign of parameter y.
253 float copysign( float x, float y );
254 long double copysign( long double x, long double y );
257 float erf( float x );
258 long double erf( long double x );
261 float erfc( float x );
262 long double erfc( long double x );
265 float fdim( float x, float y );
266 long double fdim( long double x, long double y );
269 float fma( float x, float y, float z );
270 long double fma( long double x, long double y, long double z );
272 // These functions return the larger of their parameters.
273 float fmax( float x, float y );
274 long double fmax( long double x, long double y );
276 // These functions return the smaller of their parameters.
277 float fmin( float x, float y );
278 long double fmin( long double x, long double y );
281 long long llrint( float x );
282 long long llrint( long double x );
283 long lrint( float x );
284 long lrint( long double x );
285 float rint( float x );
286 long double rint( long double x );
289 long long llround( float x );
290 long long llround( long double x );
291 long lround( float x );
292 long lround( long double x );
293 float round( float x );
294 long double round( long double x );
297 float trunc( float x );
298 long double trunc( long double x );
301 float nearbyint( float x );
302 long double nearbyint( long double x );
305 float nextafter( float x, float y );
306 long double nextafter( long double x, long double y );
309 float nexttoward( float x, long double y );
310 long double nexttoward( long double x, long double y );
313 float remainder( float x, float y );
314 long double remainder( long double x, long double y );
317 float remquo( float x, float y, int * quotient );
318 long double remquo( long double x, long double y, int * quotient );
321 float scalbn( float x, int ex );
322 long double scalbn( long double x, int ex );
325 float scalbln( float x, long ex );
326 long double scalbln( long double x, long ex );
329 float lgamma( float x );
330 long double lgamma( long double x );
333 float tgamma( float x );
334 long double tgamma( long double x );
336 #endif // __cplusplus
338 // ----------------------------------------------------------------------------
339 // FUNCTIONS - Standard C
341 // These functions return the magnitude of their parameter.
342 double fabs( double x );
343 float fabsf( float x );
344 long double fabsl( long double x );
346 // These functions compute the sine of x (measured in radians).
347 double sin( double x );
348 float sinf( float x );
349 long double sinl( long double x );
351 // These functions return the hyperbolic cosine of their parameter.
352 double sinh( double x );
353 float sinhf( float x );
354 long double sinhl( long double x );
356 // These functions return the arcsine of their parameter.
357 double asin( double x );
358 float asinf( float x );
359 long double asinl( long double x );
361 // These functions return the hyperbolic arcsine of their parameter.
362 double asinh( double x );
363 float asinhf( float x );
364 long double asinhl( long double x );
366 // These functions compute the cosine of x (measured in radians).
367 double cos( double x );
368 float cosf( float x );
369 long double cosl( long double x );
371 // These functions return the hyperbolic cosine of their parameter.
372 double cosh( double x );
373 float coshf( float x );
374 long double coshl( long double x );
376 // These functions return the arccosine of their parameter.
377 double acos( double x );
378 float acosf( float x );
379 long double acosl( long double x );
381 // These functions return the hyperbolic arccosine of their parameter.
382 double acosh( double x );
383 float acoshf( float x );
384 long double acoshl( long double x );
386 // These functions return the tangent of x.
387 double tan( double x );
388 float tanf( float x );
389 long double tanl( long double x );
391 // These functions return the hyperbolic tangent of their parameter.
392 double tanh( double x );
393 float tanhf( float x );
394 long double tanhl( long double x );
396 // These functions compute the arctangent of x.
397 double atan( double x );
398 float atanf( float x );
399 long double atanl( long double x );
401 // These functions return the hyperbolic arctangent of their parameter.
402 double atanh( double x );
403 float atanhf( float x );
404 long double atanhl( long double x );
407 double atan2( double y, double x );
408 float atan2f( float y, float x );
409 long double atan2l( long double y, long double x );
411 // These functions return sqrt(x^2 + y^2 ).
412 double hypot( double x, double y );
413 float hypotf( float x, float y );
414 long double hypotl( long double x, long double y );
416 // These functions return their parameter x, raised to the power y.
417 double pow( double x, double y );
418 float powf( float x, float y );
419 long double powl( long double x, long double y );
421 // These functions return the square root of their parameter.
422 double sqrt( double x );
423 float sqrtf( float x );
424 long double sqrtl( long double x );
427 double cbrt( double x );
428 float cbrtf( float x );
429 long double cbrtl( long double x );
432 double exp( double x );
433 float expf( float x );
434 long double expl( long double x );
437 double exp2( double x );
438 float exp2f( float x );
439 long double exp2l( long double x );
442 double expm1( double x );
443 float expm1f( float x );
444 long double expm1l( long double x );
447 double frexp( double x, int * exp );
448 float frexpf( float x, int * exp );
449 long double frexpl( long double x, int * exp );
452 double ldexp( double x, int exp );
453 float ldexpf( float x, int exp );
454 long double ldexpl( long double x, int exp );
456 // These functions return the natural logarithm of their parameter.
457 double log( double x );
458 float logf( float x );
459 long double logl( long double x );
461 // These functions return the logarithm (base 10 ) of their parameter.
462 double log10( double x );
463 float log10f( float x );
464 long double log10l( long double x );
466 // These functions return the logarithm (base 2 ) of their parameter.
467 double log2( double x );
468 float log2f( float x );
469 long double log2l( long double x );
472 double logb( double x );
473 float logbf( float x );
474 long double logbl( long double x );
477 int ilogb( double x );
478 int ilogbf( float x );
479 int ilogbl( long double x );
482 double log1p( double x );
483 float log1pf( float x );
484 long double log1pl( long double x );
486 // These functions return the smallest integer no smaller than value.
487 double ceil( double x );
488 float ceilf( float x );
489 long double ceill( long double x );
491 // These functions return the largest integer no larger than their parameter.
492 double floor( double x );
493 float floorf( float x );
494 long double floorl( long double x );
497 double fmod( double x, double y );
498 float fmodf( float x, float y );
499 long double fmodl( long double x, long double y );
502 double modf( double x, double * integer );
503 float modff( float x, float * integer );
504 long double modfl( long double x, long double * integer );
506 // These functions return their parameter x, with the sign of parameter y.
507 double copysign( double x, double y );
508 float copysignf( float x, float y );
509 long double copysignl( long double x, long double y );
512 double erf( double x );
513 float erff( float x );
514 long double erfl( long double x );
517 double erfc( double x );
518 float erfcf( float x );
519 long double erfcl( long double x );
522 double fdim( double x, double y );
523 float fdimf( float x, float y );
524 long double fdiml( long double x, long double y );
527 double fma( double x, double y, double z );
528 float fmaf( float x, float y, float z );
529 long double fmal( long double x, long double y, long double z );
531 // These functions return the larger of their parameters.
532 double fmax( double x, double y );
533 float fmaxf( float x, float y );
534 long double fmaxl( long double x, long double y );
536 // These functions return the smaller of their parameters.
537 double fmin( double x, double y );
538 float fminf( float x, float y );
539 long double fminl( long double x, long double y );
542 long long llrint( double x );
543 long long llrintf( float x );
544 long long llrintl( long double x );
545 long lrint( double x );
546 long lrintf( float x );
547 long lrintl( long double x );
548 double rint( double x );
549 float rintf( float x );
550 long double rintl( long double x );
553 long long llround( double x );
554 long long llroundf( float x );
555 long long llroundl( long double x );
556 long lround( double x );
557 long lroundf( float x );
558 long lroundl( long double x );
559 double round( double x );
560 float roundf( float x );
561 long double roundl( long double x );
564 double trunc( double x );
565 float truncf( float x );
566 long double truncl( long double x );
568 double nearbyint( double x );
569 float nearbyintf( float x );
570 long double nearbyintl( long double x );
572 double nextafter( double x, double y );
573 float nextafterf( float x, float y );
574 long double nextafterl( long double x, long double y );
577 double nexttoward( double x, long double y );
578 float nexttowardf( float x, long double y );
579 long double nexttowardl( long double x, long double y );
582 double remainder( double x, double y );
583 float remainderf( float x, float y );
584 long double remainderl( long double x, long double y );
587 double remquo( double x, double y, int * pquo );
588 float remquof( float x, float y, int * pquo );
589 long double remquol( long double x, long double y, int * pquo );
592 double scalbn( double x, int ex );
593 float scalbnf( float x, int ex );
594 long double scalbnl( long double x, int ex );
597 double scalbln( double x, long ex );
598 float scalblnf( float x, long ex );
599 long double scalblnl( long double x, long ex );
602 double lgamma( double x );
603 float lgammaf( float x );
604 long double lgammal( long double x );
607 double tgamma( double x );
608 float tgammaf( float x );
609 long double tgammal( long double x );
612 double nan( const char *str );
613 float nanf( const char *str );
614 long double nanl( const char *str );