/* * Copyright (c) 1987, 1997, 2006, * Vrije Universiteit, Amsterdam, The Netherlands. * All rights reserved. Redistribution and use of the MINIX 3 operating system * in source and binary forms, with or without modification, are permitted * provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the Vrije Universiteit nor the names of the software * authors or contributors may be used to endorse or promote products * derived from this software without specific prior written permission. * * Any deviations from these conditions require written permission from the * copyright holder in advance * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, AND * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PRENTICE HALL OR ANY * AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Contributions by Matt Thomas. */ #ifndef _TGMATH_H_ #define _TGMATH_H_ #include #include /* * C99 Type-generic math (7.22) */ #ifdef __GNUC__ #define __TG_CHOOSE(p, a, b) __builtin_choose_expr((p), (a), (b)) #define __TG_IS_EQUIV_TYPE_P(v, t) \ __builtin_types_compatible_p(__typeof__(v), t) #else #error how does this compler do type-generic macros? #endif #define __TG_IS_FCOMPLEX_P(t) __TG_IS_EQUIV_TYPE_P(t, float complex) #define __TG_IS_DCOMPLEX_P(t) __TG_IS_EQUIV_TYPE_P(t, double complex) #define __TG_IS_LCOMPLEX_P(t) __TG_IS_EQUIV_TYPE_P(t, long double complex) #define __TG_IS_FLOAT_P(t) __TG_IS_EQUIV_TYPE_P(t, float) #define __TG_IS_LDOUBLE_P(t) __TG_IS_EQUIV_TYPE_P(t, long double) #define __TG_IS_FREAL_P(t) (__TG_IS_FLOAT_P(t) || __TG_IS_FCOMPLEX_P(t)) #define __TG_IS_LREAL_P(t) (__TG_IS_LDOUBLE_P(t) || __TG_IS_LCOMPLEX_P(t)) #define __TG_IS_COMPLEX_P(t) \ (__TG_IS_FCOMPLEX_P(t) || __TG_IS_DCOMPLEX_P(t) || __TG_IS_LCOMPLEX_P(t)) #define __TG_GFN1(fn, a, ftype, ltype) \ __TG_CHOOSE(__TG_IS_##ftype##_P(a), fn##f(a), \ __TG_CHOOSE(__TG_IS_##ltype##_P(a), fn##l(a), fn(a))) #define __TG_GFN1x(fn, a, b, ftype, ltype) \ __TG_CHOOSE( \ __TG_IS_##ftype##_P(a), fn##f((a), (b)), \ __TG_CHOOSE(__TG_IS_##ltype##_P(a), fn##l((a), (b)), fn((a), (b)))) #define __TG_GFN2(fn, a, b, ftype, ltype) \ __TG_CHOOSE(__TG_IS_##ftype##_P(a) && __TG_IS_##ftype##_P(b), \ fn##f((a), (b)), \ __TG_CHOOSE(__TG_IS_##ltype##_P(a) || __TG_IS_##ltype##_P(b), \ fn##l((a), (b)), fn((a), (b)))) #define __TG_GFN2x(fn, a, b, c, ftype, ltype) \ __TG_CHOOSE(__TG_IS_##ftype##_P(a) && __TG_IS_##ftype##_P(b), \ fn##f((a), (b), (c)), \ __TG_CHOOSE(__TG_IS_##ltype##_P(a) || __TG_IS_##ltype##_P(b), \ fn##l((a), (b), (c)), fn((a), (b), (c)))) #define __TG_GFN3(fn, a, b, c, ftype, ltype) \ __TG_CHOOSE(__TG_IS_##ftype##_P(a) && __TG_IS_##ftype##_P(b) && \ __TG_IS_##ftype##_P(c), \ fn##f((a), (b), (c)), \ __TG_CHOOSE(__TG_IS_##ltype##_P(a) || __TG_IS_##ltype##_P(b) || \ __TG_IS_##ltype##_P(c), \ fn##l((a), (b), (c)), fn((a), (b), (c)))) #define __TG_CFN1(cfn, a) __TG_GFN1(cfn, a, FREAL, LREAL) #define __TG_CFN2(cfn, a, b) __TG_GFN2(cfn, a, b, FREAL, LREAL) #define __TG_FN1(fn, a) __TG_GFN1(fn, a, FLOAT, LDOUBLE) #define __TG_FN1x(fn, a, b) __TG_GFN1x(fn, a, b, FLOAT, LDOUBLE) #define __TG_FN2(fn, a, b) __TG_GFN2(fn, a, b, FLOAT, LDOUBLE) #define __TG_FN2x(fn, a, b, c) __TG_GFN2x(fn, a, b, c, FLOAT, LDOUBLE) #define __TG_FN3(fn, a, b, c) __TG_GFN3(fn, a, b, c, FLOAT, LDOUBLE) #define __TG_COMPLEX(a, fn) \ __TG_CHOOSE(__TG_IS_COMPLEX_P(a), __TG_CFN1(c##fn, (a)), __TG_FN1(fn, (a))) #define __TG_COMPLEX1(a, cfn, fn) \ __TG_CHOOSE(__TG_IS_COMPLEX_P(a), __TG_CFN1(cfn, (a)), __TG_FN1(fn, (a))) #define __TG_COMPLEX2(a, b, fn) \ __TG_CHOOSE(__TG_IS_COMPLEX_P(a) || __TG_IS_COMPLEX_P(b), \ __TG_CFN2(c##fn, (a), (b)), __TG_FN2(fn, (a), (b))) #define acos(a) __TG_COMPLEX((a), acos) #define asin(a) __TG_COMPLEX((a), asin) #define atan(a) __TG_COMPLEX((a), atan) #define acosh(a) __TG_COMPLEX((a), acosh) #define asinh(a) __TG_COMPLEX((a), asinh) #define atanh(a) __TG_COMPLEX((a), atanh) #define cos(a) __TG_COMPLEX((a), cos) #define sin(a) __TG_COMPLEX((a), sin) #define tan(a) __TG_COMPLEX((a), tan) #define cosh(a) __TG_COMPLEX((a), cosh) #define sinh(a) __TG_COMPLEX((a), sinh) #define tanh(a) __TG_COMPLEX((a), tanh) #define exp(a) __TG_COMPLEX((a), exp) #define log(a) __TG_COMPLEX((a), log) #define pow(a, b) __TG_COMPLEX2((a), (b), pow) #define sqrt(a) __TG_COMPLEX((a), sqrt) #define fabs(a) __TG_COMPLEX1((a), cabs, fabs) #define atan2(a, b) __TG_FN2(atan2, (a), (b)) #define cbrt(a) __TG_FN1(cbrt, (a)) #define ceil(a) __TG_FN1(ceil, (a)) #define copysign(a, b) __TG_FN2(copysign, (a), (b)) #define erf(a) __TG_FN1(erf, (a)) #define erfc(a) __TG_FN1(erfc, (a)) #define exp2(a) __TG_FN1(exp2, (a)) #define expm1(a) __TG_FN1(expm1, (a)) #define fdim(a, b) __TG_FN2(fdim, (a), (b)) #define floor(a) __TG_FN1(floor, (a)) #define fma(a, b, c) __TG_FN3(fma, (a), (b), (c)) #define fmax(a, b) __TG_FN2(fmax, (a), (b)) #define fmin(a, b) __TG_FN2(fmin, (a), (b)) #define fmod(a, b) __TG_FN2(fmod, (a), (b)) #define frexp(a, b) __TG_FN1x(frexp, (a), (b)) #define hypot(a, b) __TG_FN2(hypot, (a), (b)) #define ilogb(a) __TG_FN1(ilogb, (a)) #define ldexp(a, b) __TG_FN1x(ldexp, (a), (b)) #define lgamma(a) __TG_FN1(lgamma, (a)) #define llrint(a) __TG_FN1(llrint, (a)) #define llround(a) __TG_FN1(llround, (a)) #define log10(a) __TG_FN1(log10, (a)) #define log1p(a) __TG_FN1(log1p, (a)) #define log2(a) __TG_FN1(log2, (a)) #define logb(a) __TG_FN1(logb, (a)) #define lrint(a) __TG_FN1(lrint, (a)) #define lround(a) __TG_FN1(lround, (a)) #define nearbyint(a) __TG_FN1(nearbyint, (a)) #define nextafter(a, b) __TG_FN2(nextafter, (a), (b)) #define nexttoward(a, b) __TG_FN2(nexttoward, (a), (b)) #define remainder(a, b) __TG_FN2(remainder, (a), (b)) #define remquo(a, b, c) __TG_FN2x(remquo, (a), (b), (c)) #define rint(a) __TG_FN1(rint, (a)) #define round(a) __TG_FN1(round, (a)) #define scalbn(a, b) __TG_FN1x(scalbn, (a), (b)) #define scalb1n(a, b) __TG_FN1x(scalb1n, (a), (b)) #define tgamma(a) __TG_FN1(tgamma, (a)) #define trunc(a) __TG_FN1(trunc, (a)) #define carg(a) __TG_CFN1(carg, (a)) #define cimag(a) __TG_CFN1(cimag, (a)) #define conj(a) __TG_CFN1(conj, (a)) #define cproj(a) __TG_CFN1(cproj, (a)) #define creal(a) __TG_CFN1(creal, (a)) #endif /* !_TGMATH_H_ */