Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members

fxmath.h
1 /********************************************************************************
2 * *
3 * M a t h F u n c t i o n s *
4 * *
5 *********************************************************************************
6 * Copyright (C) 2015,2024 by Jeroen van der Zijp. All Rights Reserved. *
7 *********************************************************************************
8 * This library is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU Lesser General Public License as published by *
10 * the Free Software Foundation; either version 3 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This library is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU Lesser General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU Lesser General Public License *
19 * along with this program. If not, see <http://www.gnu.org/licenses/> *
20 ********************************************************************************/
21 #ifndef FXMATH_H
22 #define FXMATH_H
23 
24 // Remove macros
25 #undef fabs
26 #undef fabsf
27 #undef fmod
28 #undef fmodf
29 
30 #undef ceil
31 #undef ceilf
32 #undef floor
33 #undef floorf
34 #undef round
35 #undef roundf
36 #undef trunc
37 #undef truncf
38 #undef nearbyint
39 #undef nearbyintf
40 #undef rint
41 #undef rintf
42 
43 #undef sin
44 #undef sinf
45 #undef cos
46 #undef cosf
47 #undef tan
48 #undef tanf
49 #undef asin
50 #undef asinf
51 #undef acos
52 #undef acosf
53 #undef atan
54 #undef atanf
55 #undef atan2
56 #undef atan2f
57 #undef sincos
58 #undef sincosf
59 #undef sinh
60 #undef sinhf
61 #undef cosh
62 #undef coshf
63 #undef tanh
64 #undef tanhf
65 #undef asinh
66 #undef asinhf
67 #undef acosh
68 #undef acoshf
69 #undef atanh
70 #undef atanhf
71 
72 #undef pow
73 #undef powf
74 #undef pow10
75 #undef pow10f
76 #undef exp
77 #undef expf
78 #undef expm1
79 #undef expm1f
80 #undef exp2
81 #undef exp2f
82 #undef exp10
83 #undef exp10f
84 #undef log
85 #undef logf
86 #undef log1p
87 #undef log1pf
88 #undef log2
89 #undef log2f
90 #undef log10
91 #undef log10f
92 
93 #undef sqrt
94 #undef sqrtf
95 #undef cbrt
96 #undef cbrtf
97 #undef sqr
98 #undef sqrf
99 #undef cub
100 #undef cubf
101 
102 #undef max
103 #undef min
104 #undef fmax
105 #undef fmaxf
106 #undef fmin
107 #undef fminf
108 #undef copysign
109 #undef copysignf
110 #undef hypot
111 #undef hypotf
112 
113 
114 // Switch on remedial math on Windows with VC++
115 #if defined(WIN32) && (defined(_MSC_VER) || defined(__MINGW32__))
116 #define NO_CEILF
117 #define NO_FLOORF
118 #define NO_ROUNDF
119 #define NO_ROUND
120 #define NO_TRUNCF
121 #define NO_TRUNC
122 #define NO_NEARBYINTF
123 #define NO_NEARBYINT
124 #define NO_RINTF
125 #define NO_RINT
126 #define NO_EXPM1F
127 #define NO_EXPM1
128 #define NO_EXP2F
129 #define NO_EXP2
130 #define NO_EXP10F
131 #define NO_EXP10
132 #define NO_POW10F
133 #define NO_POW10
134 #define NO_LOG1PF
135 #define NO_LOG1P
136 #define NO_LOG2F
137 #define NO_LOG2
138 #define NO_CBRTF
139 #define NO_CBRT
140 #define NO_SINHF
141 #define NO_SINH
142 #define NO_COSHF
143 #define NO_COSH
144 #define NO_TANHF
145 #define NO_TANH
146 #define NO_ASINHF
147 #define NO_ASINH
148 #define NO_ACOSHF
149 #define NO_ACOSH
150 #define NO_ATANHF
151 #define NO_ATANH
152 #define NO_FMAXF
153 #define NO_FMAX
154 #define NO_FMINF
155 #define NO_FMIN
156 #define NO_COPYSIGNF
157 #define NO_COPYSIGN
158 #define NO_HYPOTF
159 #define NO_HYPOT
160 #define NO_FDIMF
161 #define NO_FDIM
162 #define NO_SINCOS
163 #define NO_SINCOSF
164 #define NO_LRINT
165 #define NO_LRINTF
166 #endif
167 
168 // Systems below are missing these functions
169 #if defined(__sun__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__APPLE__)
170 #define NO_EXP10F
171 #define NO_EXP10
172 #endif
173 
174 // Apple is missing sincos
175 #if defined(__APPLE__)
176 #define NO_SINCOS
177 #define NO_SINCOSF
178 #endif
179 
180 
181 namespace FX {
182 
183 /********************************* Constants *********************************/
184 
186 const FXdouble PI=3.1415926535897932384626433833;
187 
189 const FXdouble EULER=2.7182818284590452353602874713;
190 
192 const FXdouble DTOR=0.0174532925199432957692369077;
193 
195 const FXdouble RTOD=57.295779513082320876798154814;
196 
198 const FXdouble FEIGENBAUM=4.6692016091029906718532038215;
199 
201 const FXdouble GOLDENRATIO=1.6180339887498948482045868343;
202 
203 /********************************* Functions *********************************/
204 
205 // FOX math functions live here
206 namespace Math {
207 
208 
210 static inline FXuint fpBits(FXfloat x){
211  union{ FXfloat f; FXuint u; } z={x};
212  return z.u;
213  }
214 
216 static inline FXulong fpBits(FXdouble x){
217  union{ FXdouble f; FXulong u; } z={x};
218  return z.u;
219  }
220 
221 
223 static inline FXint fpSign(FXfloat x){
224  FXint sign=fpBits(x)>>31;
225  return sign;
226  }
227 
229 static inline FXlong fpSign(FXdouble x){
230  FXlong sign=fpBits(x)>>63;
231  return sign;
232  }
233 
234 
236 static inline FXint fpExponent(FXfloat x){
237  FXint exponent=(fpBits(x)>>23)&0xff;
238  FXint bias=126-(-exponent>>31);
239  return exponent-bias;
240  }
241 
243 static inline FXlong fpExponent(FXdouble x){
244  FXlong exponent=(fpBits(x)>>52)&0x7ff;
245  FXlong bias=1022-(-exponent>>63);
246  return exponent-bias;
247  }
248 
249 
251 static inline FXint fpMantissa(FXfloat x){
252  FXint mantissa=fpBits(x)&0x007fffff;
253  FXint exponent=fpBits(x)&0x7f800000;
254  FXint extrabit=-(-exponent>>31); // 1 if exponent!=0
255  return mantissa|(extrabit<<23);
256  }
257 
259 static inline FXlong fpMantissa(FXdouble x){
260  FXlong mantissa=fpBits(x)&FXLONG(0x000fffffffffffff);
261  FXlong exponent=fpBits(x)&FXLONG(0x7ff0000000000000);
262  FXlong extrabit=-(-exponent>>63); // 1 if exponent!=0
263  return mantissa|(extrabit<<52);
264  }
265 
266 
268 static inline FXbool fpFinite(FXfloat x){
269  return ((fpBits(x)&0x7fffffff)<0x7f800000);
270  }
271 
273 static inline FXbool fpFinite(FXdouble x){
274  return ((fpBits(x)&FXULONG(0x7fffffffffffffff))<FXULONG(0x7ff0000000000000));
275  }
276 
277 
279 static inline FXbool fpInfinite(FXfloat x){
280  return ((fpBits(x)&0x7fffffff)==0x7f800000);
281  }
282 
284 static inline FXbool fpInfinite(FXdouble x){
285  return ((fpBits(x)&FXULONG(0x7fffffffffffffff))==FXULONG(0x7ff0000000000000));
286  }
287 
288 
290 static inline FXbool fpNan(FXfloat x){
291  return (0x7f800000<(fpBits(x)&0x7fffffff));
292  }
293 
295 static inline FXbool fpNan(FXdouble x){
296  return (FXULONG(0x7ff0000000000000)<(fpBits(x)&FXULONG(0x7fffffffffffffff)));
297  }
298 
299 
301 static inline FXbool fpNormal(FXfloat x){
302  FXuint bits=fpBits(x)&0x7fffffff;
303  return bits==0 || (0x00800000<=bits && bits<0x7f800000);
304  }
305 
307 static inline FXbool fpNormal(FXdouble x){
308  FXulong bits=fpBits(x)&FXULONG(0x7fffffffffffffff);
309  return (bits==0) || ((FXULONG(0x0010000000000000)<=bits) && (bits<FXULONG(0x7ff0000000000000)));
310  }
311 
312 
314 static inline FXint iblend(FXint a,FXint b,FXint x,FXint y){
315  return a<b ? x : y;
316  }
317 
319 static inline FXlong iblend(FXlong a,FXlong b,FXlong x,FXlong y){
320  return a<b ? x : y;
321  }
322 
323 
325 static inline FXint imin(FXint x,FXint y){
326  return (x<y)?x:y;
327  }
328 
330 static inline FXuint imin(FXuint x,FXuint y){
331  return (x<y)?x:y;
332  }
333 
335 static inline FXlong imin(FXlong x,FXlong y){
336  return (x<y)?x:y;
337  }
338 
340 static inline FXulong imin(FXulong x,FXulong y){
341  return (x<y)?x:y;
342  }
343 
344 
346 static inline FXint imax(FXint x,FXint y){
347  return (x>y)?x:y;
348  }
349 
351 static inline FXuint imax(FXuint x,FXuint y){
352  return (x>y)?x:y;
353  }
354 
355 
357 static inline FXlong imax(FXlong x,FXlong y){
358  return (x>y)?x:y;
359  }
360 
362 static inline FXulong imax(FXulong x,FXulong y){
363  return (x>y)?x:y;
364  }
365 
366 
368 static inline FXshort iabs(FXshort x){
369  return 0<x?x:-x;
370  }
371 
373 static inline FXint iabs(FXint x){
374  return 0<x?x:-x;
375  }
376 
378 static inline FXlong iabs(FXlong x){
379  return 0<x?x:-x;
380  }
381 
382 
384 static inline FXint iclamp(FXint lo,FXint x,FXint hi){
385  return Math::imin(Math::imax(x,lo),hi);
386  }
387 
389 static inline FXlong iclamp(FXlong lo,FXlong x,FXlong hi){
390  return Math::imin(Math::imax(x,lo),hi);
391  }
392 
393 
395 static inline FXint iclamp(FXint x,FXint lim){
396  return imin(imax(x,-lim),lim);
397  }
398 
400 static inline FXlong iclamp(FXlong x,FXlong lim){
401  return imin(imax(x,-lim),lim);
402  }
403 
404 
406 static inline FXint isign(FXint x){
407  return (x>0)-(x<0);
408  }
409 
411 static inline FXlong isign(FXlong x){
412  return (x>0)-(x<0);
413  }
414 
415 
417 static inline FXfloat fmin(FXfloat x,FXfloat y){
418 #if defined(NO_FMINF)
419  return (x<y)?x:y;
420 #else
421  return ::fminf(x,y);
422 #endif
423  }
424 
425 
427 static inline FXdouble fmin(FXdouble x,FXdouble y){
428 #if defined(NO_FMIN)
429  return (x<y)?x:y;
430 #else
431  return ::fmin(x,y);
432 #endif
433  }
434 
435 
437 static inline FXfloat fmax(FXfloat x,FXfloat y){
438 #if defined(NO_FMAXF)
439  return (x>y)?x:y;
440 #else
441  return ::fmaxf(x,y);
442 #endif
443  }
444 
446 static inline FXdouble fmax(FXdouble x,FXdouble y){
447 #if defined(NO_FMAX)
448  return (x>y)?x:y;
449 #else
450  return ::fmax(x,y);
451 #endif
452  }
453 
454 
456 static inline FXfloat fabs(FXfloat x){
457 #if defined(NO_FABSF)
458  return (x<0.0f) ? -x : x;
459 #else
460  return ::fabsf(x);
461 #endif
462  }
463 
465 static inline FXdouble fabs(FXdouble x){
466  return ::fabs(x);
467  }
468 
469 
471 static inline FXfloat fclamp(FXfloat lo,FXfloat x,FXfloat hi){
472  return Math::fmin(Math::fmax(x,lo),hi);
473  }
474 
476 static inline FXdouble fclamp(FXdouble lo,FXdouble x,FXdouble hi){
477  return Math::fmin(Math::fmax(x,lo),hi);
478  }
479 
480 
482 static inline FXfloat fclamp(FXfloat x,FXfloat lim){
483  return fmin(fmax(x,-lim),lim);
484  }
485 
487 static inline FXdouble fclamp(FXdouble x,FXdouble lim){
488  return fmin(fmax(x,-lim),lim);
489  }
490 
491 
493 static inline FXfloat fdim(FXfloat x,FXfloat y){
494 #if defined(NO_FDIMF)
495  return Math::fmax(x-y,0.0f);
496 #else
497  return ::fdimf(x,y);
498 #endif
499  }
500 
502 static inline FXdouble fdim(FXdouble x,FXdouble y){
503 #if defined(NO_FDIM)
504  return Math::fmax(x-y,0.0);
505 #else
506  return ::fdim(x,y);
507 #endif
508  }
509 
510 
512 static inline FXfloat fmod(FXfloat x,FXfloat y){
513  return ::fmodf(x,y);
514  }
515 
517 static inline FXdouble fmod(FXdouble x,FXdouble y){
518  return ::fmod(x,y);
519  }
520 
521 
523 static inline FXfloat fblend(FXfloat a,FXfloat b,FXfloat x,FXfloat y){
524  return a<b ? x : y;
525  }
526 
527 
529 static inline FXdouble fblend(FXdouble a,FXdouble b,FXdouble x,FXdouble y){
530  return a<b ? x : y;
531  }
532 
533 
535 static inline FXfloat copysign(FXfloat x,FXfloat y){
536 #if defined(NO_COPYSIGNF)
537  union{ FXfloat f; FXuint u; } xx={x},yy={y};
538  xx.u&=0x7fffffff;
539  xx.u|=(yy.u&0x80000000);
540  return xx.f;
541 #else
542  return ::copysignf(x,y);
543 #endif
544  }
545 
547 static inline FXdouble copysign(FXdouble x,FXdouble y){
548 #if defined(NO_COPYSIGN)
549  union{ FXdouble f; FXulong u; } xx={x},yy={y};
550  xx.u&=FXULONG(0x7fffffffffffffff);
551  xx.u|=(yy.u&FXULONG(0x8000000000000000));
552  return xx.f;
553 #else
554  return ::copysign(x,y);
555 #endif
556  }
557 
558 
560 #if defined(NO_CEILF)
561 extern FXAPI FXfloat ceil(FXfloat x);
562 #else
563 static inline FXfloat ceil(FXfloat x){ return ::ceilf(x); }
564 #endif
565 
567 static inline FXdouble ceil(FXdouble x){ return ::ceil(x); }
568 
569 
571 #if defined(NO_FLOORF)
572 extern FXAPI FXfloat floor(FXfloat x);
573 #else
574 static inline FXfloat floor(FXfloat x){ return ::floorf(x); }
575 #endif
576 
578 static inline FXdouble floor(FXdouble x){ return ::floor(x); }
579 
581 #if defined(NO_ROUNDF)
582 extern FXAPI FXfloat round(FXfloat x);
583 #else
584 static inline FXfloat round(FXfloat x){ return ::roundf(x); }
585 #endif
586 
588 #if defined(NO_ROUND)
589 extern FXAPI FXdouble round(FXdouble x);
590 #else
591 static inline FXdouble round(FXdouble x){ return ::round(x); }
592 #endif
593 
594 
596 #if defined(NO_TRUNCF)
597 extern FXAPI FXfloat trunc(FXfloat x);
598 #else
599 static inline FXfloat trunc(FXfloat x){ return ::truncf(x); }
600 #endif
601 
603 #if defined(NO_TRUNC)
604 extern FXAPI FXdouble trunc(FXdouble x);
605 #else
606 static inline FXdouble trunc(FXdouble x){ return ::trunc(x); }
607 #endif
608 
609 
611 #if defined(NO_NEARBYINTF)
612 extern FXAPI FXfloat nearbyint(FXfloat x);
613 #else
614 static inline FXfloat nearbyint(FXfloat x){ return ::nearbyintf(x); }
615 #endif
616 
618 #if defined(NO_NEARBYINT)
619 extern FXAPI FXdouble nearbyint(FXdouble x);
620 #else
621 static inline FXdouble nearbyint(FXdouble x){ return ::nearbyint(x); }
622 #endif
623 
625 #if defined(NO_RINTF)
626 extern FXAPI FXfloat rint(FXfloat x);
627 #else
628 static inline FXfloat rint(FXfloat x){ return ::rintf(x); }
629 #endif
630 
632 #if defined(NO_RINT)
633 extern FXAPI FXdouble rint(FXdouble x);
634 #else
635 static inline FXdouble rint(FXdouble x){ return ::rint(x); }
636 #endif
637 
638 
640 static inline FXint lrint(FXfloat x){
641 #if defined(NO_LRINTF)
642  return (FXint)(x+Math::copysign(0.5f,x));
643 #else
644  return (FXint)::lrintf(x);
645 #endif
646  }
647 
649 static inline FXlong lrint(FXdouble x){
650 #if defined(NO_LRINT)
651  return (FXlong)(x+Math::copysign(0.5,x));
652 #else
653  return (FXlong)::lrint(x);
654 #endif
655  }
656 
657 
659 static inline FXfloat wrap(FXfloat x){
660 #if defined(__SSE4_1__)
661  return x-Math::nearbyint(x*0.159154943091895335768883763373f)*6.28318530717958647692528676656f;
662 #else
663  return x-Math::lrint(x*0.159154943091895335768883763373f)*6.28318530717958647692528676656f;
664 #endif
665  }
666 
668 static inline FXdouble wrap(FXdouble x){
669 #if defined(__SSE4_1__)
670  return x-Math::nearbyint(x*0.159154943091895335768883763373)*6.28318530717958647692528676656;
671 #else
672  return x-Math::lrint(x*0.159154943091895335768883763373)*6.28318530717958647692528676656;
673 #endif
674  }
675 
676 
678 static inline FXfloat wrap4(FXfloat x){
679  return x-Math::floor(x*0.159154943091895335768883763373f)*6.28318530717958647692528676656f;
680  }
681 
682 
684 static inline FXdouble wrap4(FXdouble x){
685  return x-Math::floor(x*0.159154943091895335768883763373)*6.28318530717958647692528676656;
686  }
687 
688 
690 static inline FXfloat stepify(FXfloat x,FXfloat s){
691  return Math::nearbyint(x/s)*s;
692  }
693 
695 static inline FXdouble stepify(FXdouble x,FXdouble s){
696  return Math::nearbyint(x/s)*s;
697  }
698 
699 
701 static inline FXfloat zigzag(FXfloat x){
702  return Math::fabs(2.0f*(x-Math::nearbyint(x)));
703  }
704 
706 static inline FXdouble zigzag(FXdouble x){
707  return Math::fabs(2.0*(x-Math::nearbyint(x)));
708  }
709 
710 
712 static inline FXfloat sawtooth(FXfloat x){
713  return x-Math::floor(x);
714  }
715 
717 static inline FXdouble sawtooth(FXdouble x){
718  return x-Math::floor(x);
719  }
720 
721 
723 static inline FXfloat rsawtooth(FXfloat x){
724  return Math::ceil(x)-x;
725  }
726 
728 static inline FXdouble rsawtooth(FXdouble x){
729  return Math::ceil(x)-x;
730  }
731 
732 
734 static inline FXfloat sin(FXfloat x){
735  return ::sinf(x);
736  }
737 
739 static inline FXdouble sin(FXdouble x){
740  return ::sin(x);
741  }
742 
743 
745 static inline FXfloat cos(FXfloat x){
746  return ::cosf(x);
747  }
748 
750 static inline FXdouble cos(FXdouble x){
751  return ::cos(x);
752  }
753 
754 
756 static inline FXfloat tan(FXfloat x){
757  return ::tanf(x);
758  }
759 
761 static inline FXdouble tan(FXdouble x){
762  return ::tan(x);
763  }
764 
765 
767 static inline FXfloat asin(FXfloat x){
768  return ::asinf(x);
769  }
770 
772 static inline FXdouble asin(FXdouble x){
773  return ::asin(x);
774  }
775 
776 
778 static inline FXfloat acos(FXfloat x){
779  return ::acosf(x);
780  }
781 
783 static inline FXdouble acos(FXdouble x){
784  return ::acos(x);
785  }
786 
787 
789 static inline FXfloat atan(FXfloat x){
790  return ::atanf(x);
791  }
792 
794 static inline FXdouble atan(FXdouble x){
795  return ::atan(x);
796  }
797 
798 
800 static inline FXfloat atan2(FXfloat y,FXfloat x){
801  return ::atan2f(y,x);
802  }
803 
805 static inline FXdouble atan2(FXdouble y,FXdouble x){
806  return ::atan2(y,x);
807  }
808 
809 
811 static inline void sincos(FXfloat x,FXfloat& s,FXfloat& c){
812 #if defined(NO_SINCOSF)
813  s=Math::sin(x);
814  c=Math::cos(x);
815 #else
816  ::sincosf(x,&s,&c);
817 #endif
818  }
819 
820 
822 static inline void sincos(FXdouble x,FXdouble& s,FXdouble& c){
823 #if defined(NO_SINCOS)
824  s=Math::sin(x);
825  c=Math::cos(x);
826 #else
827  ::sincos(x,&s,&c);
828 #endif
829  }
830 
831 
833 #if defined(NO_SINHF)
834 extern FXAPI FXfloat sinh(FXfloat x);
835 #else
836 static inline FXfloat sinh(FXfloat x){ return ::sinhf(x); }
837 #endif
838 
840 #if defined(NO_SINH)
841 extern FXAPI FXdouble sinh(FXdouble x);
842 #else
843 static inline FXdouble sinh(FXdouble x){ return ::sinh(x); }
844 #endif
845 
846 
848 #if defined(NO_COSHF)
849 extern FXAPI FXfloat cosh(FXfloat x);
850 #else
851 static inline FXfloat cosh(FXfloat x){ return ::coshf(x); }
852 #endif
853 
855 #if defined(NO_COSH)
856 extern FXAPI FXdouble cosh(FXdouble x);
857 #else
858 static inline FXdouble cosh(FXdouble x){ return ::cosh(x); }
859 #endif
860 
861 
863 #if defined(NO_TANHF)
864 extern FXAPI FXfloat tanh(FXfloat x);
865 #else
866 static inline FXfloat tanh(FXfloat x){ return ::tanhf(x); }
867 #endif
868 
870 #if defined(NO_TANH)
871 extern FXAPI FXdouble tanh(FXdouble x);
872 #else
873 static inline FXdouble tanh(FXdouble x){ return ::tanh(x); }
874 #endif
875 
876 
878 #if defined(NO_ASINHF)
879 extern FXAPI FXfloat asinh(FXfloat x);
880 #else
881 static inline FXfloat asinh(FXfloat x){ return ::asinhf(x); }
882 #endif
883 
885 #if defined(NO_ASINH)
886 extern FXAPI FXdouble asinh(FXdouble x);
887 #else
888 static inline FXdouble asinh(FXdouble x){ return ::asinh(x); }
889 #endif
890 
891 
893 #if defined(NO_ACOSHF)
894 extern FXAPI FXfloat acosh(FXfloat x);
895 #else
896 static inline FXfloat acosh(FXfloat x){ return ::acoshf(x); }
897 #endif
898 
900 #if defined(NO_ACOSH)
901 extern FXAPI FXdouble acosh(FXdouble x);
902 #else
903 static inline FXdouble acosh(FXdouble x){ return ::acosh(x); }
904 #endif
905 
906 
908 #if defined(NO_ATANHF)
909 extern FXAPI FXfloat atanh(FXfloat x);
910 #else
911 static inline FXfloat atanh(FXfloat x){ return ::atanhf(x); }
912 #endif
913 
915 #if defined(NO_ATANH)
916 extern FXAPI FXdouble atanh(FXdouble x);
917 #else
918 static inline FXdouble atanh(FXdouble x){ return ::atanh(x); }
919 #endif
920 
921 
923 static inline FXfloat sqrt(FXfloat x){
924  return ::sqrtf(x);
925  }
926 
928 static inline FXdouble sqrt(FXdouble x){
929  return ::sqrt(x);
930  }
931 
932 
934 static inline FXfloat safesqrt(FXfloat x){
935  return Math::sqrt(Math::fmax(x,0.0f));
936  }
937 
939 static inline FXdouble safesqrt(FXdouble x){
940  return Math::sqrt(Math::fmax(x,0.0));
941  }
942 
943 
945 static inline FXfloat cbrt(FXfloat x){
946 #if defined(NO_CBRTF)
947  return ::powf(x,0.333333333333333333333333333333f);
948 #else
949  return ::cbrtf(x);
950 #endif
951  }
952 
954 static inline FXdouble cbrt(FXdouble x){
955 #if defined(NO_CBRT)
956  return ::pow(x,0.333333333333333333333333333333);
957 #else
958  return ::cbrt(x);
959 #endif
960  }
961 
962 
964 static inline FXfloat sqr(FXfloat x){
965  return x*x;
966  }
967 
969 static inline FXdouble sqr(FXdouble x){
970  return x*x;
971  }
972 
973 
975 static inline FXfloat cub(FXfloat x){
976  return x*x*x;
977  }
978 
980 static inline FXdouble cub(FXdouble x){
981  return x*x*x;
982  }
983 
984 
986 static inline FXfloat rsqrt(FXfloat x){
987  return 1.0f/Math::sqrt(x);
988  }
989 
990 
992 static inline FXdouble rsqrt(FXdouble x){
993  return 1.0/Math::sqrt(x);
994  }
995 
996 
998 static inline FXfloat recip(FXfloat x){
999  return 1.0f/x;
1000  }
1001 
1002 
1004 static inline FXdouble recip(FXdouble x){
1005  return 1.0/x;
1006  }
1007 
1008 
1010 static inline FXfloat hypot(FXfloat x,FXfloat y){
1011 #if defined(NO_HYPOTF)
1012  return Math::sqrt(Math::sqr(x)+Math::sqr(y));
1013 #else
1014  return ::hypotf(x,y);
1015 #endif
1016  }
1017 
1019 static inline FXdouble hypot(FXdouble x,FXdouble y){
1020 #if defined(NO_HYPOT)
1021  return Math::sqrt(Math::sqr(x)+Math::sqr(y));
1022 #else
1023  return ::hypot(x,y);
1024 #endif
1025  }
1026 
1027 
1029 static inline FXfloat lerp(FXfloat u,FXfloat v,FXfloat f){
1030  return (v-u)*f+u;
1031  }
1032 
1033 
1035 static inline FXdouble lerp(FXdouble u,FXdouble v,FXdouble f){
1036  return (v-u)*f+u;
1037  }
1038 
1039 
1041 static inline FXfloat smoothstep(FXfloat f){
1042  return (3.0f-2.0f*f)*f*f;
1043  }
1044 
1046 static inline FXdouble smoothstep(FXdouble f){
1047  return (3.0-2.0*f)*f*f;
1048  }
1049 
1050 
1052 static inline FXfloat exp(FXfloat x){
1053  return ::expf(x);
1054  }
1055 
1057 static inline FXdouble exp(FXdouble x){
1058  return ::exp(x);
1059  }
1060 
1061 
1063 static inline FXfloat expm1(FXfloat x){
1064 #if defined(NO_EXPM1F)
1065  return ::expf(x)-1.0f;
1066 #else
1067  return ::expm1f(x);
1068 #endif
1069  }
1070 
1072 static inline FXdouble expm1(FXdouble x){
1073 #if defined(NO_EXPM1)
1074  return ::exp(x)-1.0;
1075 #else
1076  return ::expm1(x);
1077 #endif
1078  }
1079 
1080 
1082 static inline FXfloat pow(FXfloat x,FXfloat y){
1083  return ::powf(x,y);
1084  }
1085 
1087 static inline FXdouble pow(FXdouble x,FXdouble y){
1088  return ::pow(x,y);
1089  }
1090 
1091 
1093 static inline FXfloat exp2(FXfloat x){
1094 #if defined(NO_EXP2F)
1095  return Math::pow(2.0f,x);
1096 #else
1097  return ::exp2f(x);
1098 #endif
1099  }
1100 
1101 
1103 static inline FXdouble exp2(FXdouble x){
1104 #if defined(NO_EXP2)
1105  return Math::pow(2.0,x);
1106 #else
1107  return ::exp2(x);
1108 #endif
1109  }
1110 
1111 
1113 static inline FXfloat exp10(FXfloat x){
1114 #if defined(NO_EXP10F)
1115  return Math::pow(10.0f,x);
1116 #else
1117  return ::exp10f(x);
1118 #endif
1119  }
1120 
1121 
1123 static inline FXdouble exp10(FXdouble x){
1124 #if defined(NO_EXP10)
1125  return Math::pow(10.0,x);
1126 #else
1127  return ::exp10(x);
1128 #endif
1129  }
1130 
1131 
1133 static inline FXfloat pow10(FXfloat x){
1134  return Math::exp10(x);
1135  }
1136 
1138 static inline FXdouble pow10(FXdouble x){
1139  return Math::exp10(x);
1140  }
1141 
1142 
1144 extern FXAPI FXdouble pow10i(FXint ex);
1145 
1146 
1148 extern FXAPI FXfloat powi(FXfloat base,FXint ex);
1149 
1150 
1152 extern FXAPI FXdouble powi(FXdouble base,FXint ex);
1153 
1154 
1156 static inline FXfloat log(FXfloat x){
1157  return ::logf(x);
1158  }
1159 
1161 static inline FXdouble log(FXdouble x){
1162  return ::log(x);
1163  }
1164 
1165 
1167 static inline FXfloat log1p(FXfloat x){
1168 #if defined(NO_LOG1PF)
1169  return Math::log(1.0f+x);
1170 #else
1171  return ::log1pf(x);
1172 #endif
1173  }
1174 
1175 
1177 static inline FXdouble log1p(FXdouble x){
1178 #if defined(NO_LOG1P)
1179  return Math::log(1.0+x);
1180 #else
1181  return ::log1p(x);
1182 #endif
1183  }
1184 
1185 
1187 static inline FXfloat log2(FXfloat x){
1188 #if defined(NO_LOG2F)
1189  return Math::log(x)*1.442695040888963407359924681001892137f;
1190 #else
1191  return ::log2f(x);
1192 #endif
1193  }
1194 
1195 
1197 static inline FXdouble log2(FXdouble x){
1198 #if defined(NO_LOG2)
1199  return Math::log(x)*1.442695040888963407359924681001892137;
1200 #else
1201  return ::log2(x);
1202 #endif
1203  }
1204 
1205 
1207 static inline FXfloat log10(FXfloat x){
1208  return ::log10f(x);
1209  }
1210 
1212 static inline FXdouble log10(FXdouble x){
1213  return ::log10(x);
1214  }
1215 
1216 
1218 extern FXAPI FXfloat erf(FXfloat x);
1219 
1221 extern FXAPI FXdouble erf(FXdouble x);
1222 
1223 
1225 extern FXAPI FXfloat erfc(FXfloat x);
1226 
1228 extern FXAPI FXdouble erfc(FXdouble x);
1229 
1230 
1232 extern FXAPI FXfloat inverf(FXfloat x);
1233 
1235 extern FXAPI FXdouble inverf(FXdouble x);
1236 
1237 
1239 extern FXAPI FXfloat inverfc(FXfloat x);
1240 
1242 extern FXAPI FXdouble inverfc(FXdouble x);
1243 
1244 
1245 }
1246 
1247 }
1248 
1249 #endif
FX
Definition: FX4Splitter.h:28

Copyright © 1997-2022 Jeroen van der Zijp