summaryrefslogtreecommitdiff
path: root/include
diff options
context:
space:
mode:
authormatt <matt@NetBSD.org>2008-09-28 14:57:41 +0000
committermatt <matt@NetBSD.org>2008-09-28 14:57:41 +0000
commit99a8c5ca1cf6255f6b370933dffeb5cc0e67b554 (patch)
treef9fca5da29bb70f5df1a13360c6ca16bfe51ac9e /include
parentd3676b59781374327e522657871517cdd1b91559 (diff)
Add the C99 header <tgmath.h> (Type-generic math.h)
Until IEEE libm support *l (long double) we can't install it.
Diffstat (limited to 'include')
-rw-r--r--include/tgmath.h192
1 files changed, 192 insertions, 0 deletions
diff --git a/include/tgmath.h b/include/tgmath.h
new file mode 100644
index 00000000000..9961303ce8f
--- /dev/null
+++ b/include/tgmath.h
@@ -0,0 +1,192 @@
+/*-
+ * Copyright (c) 2008 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Matt Thomas <matt@3am-software.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 THE FOUNDATION 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.
+ */
+
+#ifndef _TGMATH_H_
+#define _TGMATH_H_
+
+#include <math.h>
+#include <complex.h>
+
+/*
+ * 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_ */