merge sources into single tree

88 files changed, 1533 insertions, 0 deletions

diff --git a/src/math/FP_FAST_FMA.c b/src/math/FP_FAST_FMA.c
new file mode 100644
index 00000000..868c9455
--- /dev/null
+++ b/src/math/FP_FAST_FMA.c
@@ -0,0 +1,12 @@
+#include <math.h>
+
+#if 0          /* if fma is generally as fast or faster than multiply and add */
+#define FP_FAST_FMA
+#else
+#undef FP_FAST_FMA
+#endif
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/FP_FAST_FMAF.c b/src/math/FP_FAST_FMAF.c
new file mode 100644
index 00000000..7b7b88a4
--- /dev/null
+++ b/src/math/FP_FAST_FMAF.c
@@ -0,0 +1,12 @@
+#include <math.h>
+
+#if 0         /* if fmaf is generally as fast or faster than multiply and add */
+#define FP_FAST_FMAF
+#else
+#undef FP_FAST_FMAF
+#endif
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/FP_FAST_FMAL.c b/src/math/FP_FAST_FMAL.c
new file mode 100644
index 00000000..1437ad56
--- /dev/null
+++ b/src/math/FP_FAST_FMAL.c
@@ -0,0 +1,12 @@
+#include <math.h>
+
+#if 0         /* if fmal is generally as fast or faster than multiply and add */
+#define FP_FAST_FMAL
+#else
+#undef FP_FAST_FMAL
+#endif
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/FP_ILOGB0.c b/src/math/FP_ILOGB0.c
new file mode 100644
index 00000000..1c3f0e28
--- /dev/null
+++ b/src/math/FP_ILOGB0.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define FP_ILOGB0                                                        INT_MIN
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/FP_ILOGBNAN.c b/src/math/FP_ILOGBNAN.c
new file mode 100644
index 00000000..65aa04f1
--- /dev/null
+++ b/src/math/FP_ILOGBNAN.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define FP_ILOGBNAN                                                      INT_MAX
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/FP_INFINITE.c b/src/math/FP_INFINITE.c
new file mode 100644
index 00000000..e5aadaf8
--- /dev/null
+++ b/src/math/FP_INFINITE.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define FP_INFINITE                                                            0
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/FP_NAN.c b/src/math/FP_NAN.c
new file mode 100644
index 00000000..804765cd
--- /dev/null
+++ b/src/math/FP_NAN.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define FP_NAN                                                                 1
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/FP_NORMAL.c b/src/math/FP_NORMAL.c
new file mode 100644
index 00000000..171ca6bf
--- /dev/null
+++ b/src/math/FP_NORMAL.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define FP_NORMAL                                                              2
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/FP_SUBNORMAL.c b/src/math/FP_SUBNORMAL.c
new file mode 100644
index 00000000..500ecd14
--- /dev/null
+++ b/src/math/FP_SUBNORMAL.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define FP_SUBNORMAL                                                           3
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/FP_ZERO.c b/src/math/FP_ZERO.c
new file mode 100644
index 00000000..54e5d323
--- /dev/null
+++ b/src/math/FP_ZERO.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define FP_ZERO                                                                4
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/HUGE_VAL.c b/src/math/HUGE_VAL.c
new file mode 100644
index 00000000..f72afacf
--- /dev/null
+++ b/src/math/HUGE_VAL.c
@@ -0,0 +1,13 @@
+#include <math.h>
+#define HUGE_VAL                       (1.0) /* TODO: massive positive double */
+
+/** a huge value **/
+
+/***
+is a large positive TYPE(double), not necessarily representable as a
+TYPE(float). It is used as a sentinel value by several functions in the
+standard library.
+***/
+/*
+STDC(1)
+*/
diff --git a/src/math/HUGE_VALF.c b/src/math/HUGE_VALF.c
new file mode 100644
index 00000000..41ea0f3e
--- /dev/null
+++ b/src/math/HUGE_VALF.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define HUGE_VALF                             /* TODO: massive positive float */
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/HUGE_VALL.c b/src/math/HUGE_VALL.c
new file mode 100644
index 00000000..7745a373
--- /dev/null
+++ b/src/math/HUGE_VALL.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define HUGE_VALL                       /* TODO: massive positive long double */
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/INFINITY.c b/src/math/INFINITY.c
new file mode 100644
index 00000000..64e3ac95
--- /dev/null
+++ b/src/math/INFINITY.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define INFINITY                /* TODO: positive or unsigned float infinity */
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/MATH_ERREXCEPT.c b/src/math/MATH_ERREXCEPT.c
new file mode 100644
index 00000000..1ad3a6d6
--- /dev/null
+++ b/src/math/MATH_ERREXCEPT.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define MATH_ERREXCEPT                                                         2
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/MATH_ERRNO.c b/src/math/MATH_ERRNO.c
new file mode 100644
index 00000000..07cb5815
--- /dev/null
+++ b/src/math/MATH_ERRNO.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define MATH_ERRNO                                                             1
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/NAN.c b/src/math/NAN.c
new file mode 100644
index 00000000..6c5d778f
--- /dev/null
+++ b/src/math/NAN.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define NAN                                         /* TODO: float quiet NaN */
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/acos.c b/src/math/acos.c
new file mode 100644
index 00000000..a610fe2e
--- /dev/null
+++ b/src/math/acos.c
@@ -0,0 +1,35 @@
+# define TGSOURCE "std/9899-1990/math/acos.c"
+#include <math.h>
+#include "errno.h"
+#include "nonstd/tgmath.h"
+
+/** arc cosine **/
+TYPE TGFN(acos)(TYPE x)
+{
+	if (x < -1 || x > 1) {
+		errno = EDOM;	/* ARGUMENT(x) not in the range [-1, +1] */
+		return TGHUGE;
+	}
+
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(a value in range `[0, PI()]'); */
+	return (TYPE)0.0;
+}
+
+/***
+compute the principal value of the arc cosine of ARGUMENT(x), which must be in
+the range [-1, +1].
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/acosh.c b/src/math/acosh.c
new file mode 100644
index 00000000..3e64e9d1
--- /dev/null
+++ b/src/math/acosh.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "acosh.c"
+#include "nontstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(acosh)(TYPE x)
+{
+	return 0.0;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/asin.c b/src/math/asin.c
new file mode 100644
index 00000000..4c1599fe
--- /dev/null
+++ b/src/math/asin.c
@@ -0,0 +1,35 @@
+# define TGSOURCE "asin.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** arc sine **/
+TYPE TGFN(asin)(TYPE x)
+{
+	if (x < -1.0 || x > 1.0) {
+		errno = EDOM;	/* ARGUMENT(x) is not in the range [-1, +1] */
+		return TGHUGE;
+	}
+
+	if (0) {
+		errno = ERANGE;	/* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(a value in range `[-PI()/2, +PI()/2]'); */
+	return (TYPE)0.0;
+}
+
+/***
+compute the principal value of the arc sine of ARGUMENT(x), which must be in
+the range [-1, +1].
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/asinh.c b/src/math/asinh.c
new file mode 100644
index 00000000..e4086844
--- /dev/null
+++ b/src/math/asinh.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "asinh.c"
+#include "nontsd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(asinh)(TYPE x)
+{
+	return 0.0;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/atan.c b/src/math/atan.c
new file mode 100644
index 00000000..5b4b0330
--- /dev/null
+++ b/src/math/atan.c
@@ -0,0 +1,48 @@
+# define TGSOURCE "atan.c"
+#include <math.h>
+#include "errno.h"
+#include "nonstd/tgmath.h"
+
+/** arc tangent **/
+TYPE TGFN(atan)(TYPE x)
+{
+	int MAXLOOPS = 10;
+	TYPE arctan = 0.0;
+	TYPE power = 1.0;
+	int i;
+
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* TODO: correct input domain */
+	/* TODO: tweak number of loops */
+
+	/* arctan x = x - x^3/3 + x^5/5 - x^7/7 ... */
+	for (i = 1; i < MAXLOOPS; i++) {
+		power *= x;
+
+		if (i % 4 == 1) {
+			arctan += power / i;
+		} else if (i % 4 == 3) {
+			arctan -= power / i;
+		}
+	}
+
+	/* RETURN_SUCCESS(a value in the range `[-PI()/2, +PI()/2]'); */
+	return arctan;
+}
+
+/***
+compute the principal value of the arc tangent of ARGUMENT(x).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/atan2.c b/src/math/atan2.c
new file mode 100644
index 00000000..be5b9dd6
--- /dev/null
+++ b/src/math/atan2.c
@@ -0,0 +1,41 @@
+# define TGSOURCE "atan2.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+#include "nonstd/assert.h"
+
+/** arc tangent **/
+TYPE TGFN(atan2)(TYPE y, TYPE x)
+{
+	ASSERT_NONZERO(x);
+
+	if (y == 0 && x == 0) {
+		errno = EDOM; /* ARGUMENT(y) and ARGUMENT(x) are both LITERAL(0)) */
+		return TGHUGE;
+	}
+
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	TYPE ret = TGFN(tan)(y / x);
+	/* FIXME: quadrant */
+	/* RETURN_SUCCESS(a value in range `[-PI(), +PI()]'); */
+	return ret;
+}
+
+/***
+functions compute the principal value of the arc tangent of
+ARGUMENT(y)/ARGUMENT(x), using the signs of both to place the return value in
+the correct quadrant.
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/atanh.c b/src/math/atanh.c
new file mode 100644
index 00000000..2f5f62f1
--- /dev/null
+++ b/src/math/atanh.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "atanh.c"
+#include "nontstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(atanh)(TYPE x)
+{
+	return 0.0;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/cbrt.c b/src/math/cbrt.c
new file mode 100644
index 00000000..596cabd2
--- /dev/null
+++ b/src/math/cbrt.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "cbrt.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(cbrt)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/ceil.c b/src/math/ceil.c
new file mode 100644
index 00000000..e9f950c8
--- /dev/null
+++ b/src/math/ceil.c
@@ -0,0 +1,30 @@
+# define TGSOURCE "ceil.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** round up to nearest integer **/
+TYPE TGFN(ceil)(TYPE x)
+{
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(CEIL(ARGUMENT(x))); */
+	return x;
+}
+
+/***
+compute the smallest integral value that is not less
+than ARGUMENT(x), returning it as the same floating-point type as ARGUMENT(x).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/copysign.c b/src/math/copysign.c
new file mode 100644
index 00000000..d070036b
--- /dev/null
+++ b/src/math/copysign.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "copysign.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(copysign)(TYPE x, TYPE y)
+{
+	return 0.0;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/cos.c b/src/math/cos.c
new file mode 100644
index 00000000..0690b6ee
--- /dev/null
+++ b/src/math/cos.c
@@ -0,0 +1,51 @@
+# define TGSOURCE "cos.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** cosine **/
+TYPE TGFN(cos)(TYPE x)
+{
+	int MAXLOOPS = 10;
+	int factorial = 1;
+	int i;
+	TYPE cosine = 1.0;
+	TYPE power = 1.0;
+
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* TODO: make sure x is in the right domain */
+	/* TODO: tweak number of loops */
+
+	/* cos x = 1 - x^2/2! + x^4/4! -x^6/6! ... */
+	for (i = 1; i < MAXLOOPS; i++) {
+		power = power * x;
+		factorial = factorial * i;
+
+		if (i % 4 == 0) {
+			cosine += power / factorial;
+		} else if (i % 4 == 2) {
+			cosine -= power / factorial;
+		}
+	}
+
+	/* RETURN_SUCCESS(the cosine of ARGUMENT(x)); */
+	return cosine;
+}
+
+/***
+compute cosine of ARGUMENT(x), in radians.
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
+
diff --git a/src/math/cosh.c b/src/math/cosh.c
new file mode 100644
index 00000000..75301cf1
--- /dev/null
+++ b/src/math/cosh.c
@@ -0,0 +1,29 @@
+# define TGSOURCE "cosh.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** hyperbolic cosine **/
+TYPE TGFN(cosh)(TYPE x)
+{
+	if (0) {
+		errno = ERANGE; /* The magnitude of ARGUMENT(x) is too large */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(the hyperbolic cosine of ARGUMENT(x)); */
+	return x;
+}
+
+/***
+compute the hyperbolic cosine of ARGUMENT(x).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/double_t.c b/src/math/double_t.c
new file mode 100644
index 00000000..47b1fb36
--- /dev/null
+++ b/src/math/double_t.c
@@ -0,0 +1,16 @@
+#include <math.h>
+
+#if FLT_EVAL_METHOD == 0
+typedef double double_t;
+#elif FLT_EVAL_METHOD == 1
+typedef double double_t;
+#elif FLT_EVAL_METHOD == 2
+typedef long double double_t;
+#else
+ /* implementation defined */
+#endif
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/erf.c b/src/math/erf.c
new file mode 100644
index 00000000..63525700
--- /dev/null
+++ b/src/math/erf.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "erf.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(erf)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/erfc.c b/src/math/erfc.c
new file mode 100644
index 00000000..3aef20d3
--- /dev/null
+++ b/src/math/erfc.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "erfc.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(erfc)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/exp.c b/src/math/exp.c
new file mode 100644
index 00000000..b63ecf4f
--- /dev/null
+++ b/src/math/exp.c
@@ -0,0 +1,44 @@
+# define TGSOURCE "exp.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** exponential function **/
+TYPE TGFN(exp)(TYPE x)
+{
+	int MAXLOOPS = 10;
+	int i;
+	int factorial = 1;
+	TYPE exponent = 1.0;
+	TYPE power = 1.0;
+
+	if (0) {
+		errno = ERANGE; /* The magnitude of ARGUMENT(x) is too large */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* TODO: tweak max loops */
+
+	/* exp x = 1 + x + x^2/2! + x^3/3! + x^4/4! ... */
+	for (i = 1; i < MAXLOOPS; i++) {
+		power *= x;
+		factorial *= i;
+		exponent += power / factorial;
+	}
+
+	/* RETURN_SUCCESS(the exponential function of ARGUMENT(x)); */
+	return exponent;
+}
+
+/***
+compute the exponential function of ARGUMENT(x).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/exp2.c b/src/math/exp2.c
new file mode 100644
index 00000000..7f67294d
--- /dev/null
+++ b/src/math/exp2.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "exp2.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(exp2)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/expm1.c b/src/math/expm1.c
new file mode 100644
index 00000000..f50c43a4
--- /dev/null
+++ b/src/math/expm1.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "expm1.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(exmp1)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/fabs.c b/src/math/fabs.c
new file mode 100644
index 00000000..abd71bb7
--- /dev/null
+++ b/src/math/fabs.c
@@ -0,0 +1,29 @@
+# define TGSOURCE "fabs.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** absolute value **/
+TYPE TGFN(fabs)(TYPE x)
+{
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(ABS(ARGUMENT(x))); */
+	return x < 0.0 ? -x : x;
+}
+
+/***
+compute the absolute value of a floating-point number ARGUMENT(x).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/fdim.c b/src/math/fdim.c
new file mode 100644
index 00000000..922c5040
--- /dev/null
+++ b/src/math/fdim.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "fdim.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(fdim)(TYPE x, TYPE y)
+{
+	return x - y;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/float_t.c b/src/math/float_t.c
new file mode 100644
index 00000000..251f5b2e
--- /dev/null
+++ b/src/math/float_t.c
@@ -0,0 +1,16 @@
+#include <math.h>
+
+#if FLT_EVAL_METHOD == 0
+typedef float float_t;
+#elif FLT_EVAL_METHOD == 1
+typedef double float_t;
+#elif FLT_EVAL_METHOD == 2
+typedef long double float_t;
+#else
+ /* implementation defined */
+#endif
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/floor.c b/src/math/floor.c
new file mode 100644
index 00000000..2b2e07ab
--- /dev/null
+++ b/src/math/floor.c
@@ -0,0 +1,30 @@
+# define TGSOURCE "floor.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** round down to nearest integer **/
+TYPE TGFN(floor)(TYPE x)
+{
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(FLOOR(ARGUMENT(x))); */
+	return x;
+}
+
+/***
+compute the largest integral value that is not greater
+than ARGUMENT(x), returning it as the same floating-point type as ARGUMENT(x).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/fma.c b/src/math/fma.c
new file mode 100644
index 00000000..e2827918
--- /dev/null
+++ b/src/math/fma.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "fma.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(fma)(TYPE x, TYPE y, TYPE z)
+{
+	return x - y - z;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/fmax.c b/src/math/fmax.c
new file mode 100644
index 00000000..6b056b2b
--- /dev/null
+++ b/src/math/fmax.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "fmax.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(fmax)(TYPE x, TYPE y)
+{
+	return x - y;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/fmin.c b/src/math/fmin.c
new file mode 100644
index 00000000..56966432
--- /dev/null
+++ b/src/math/fmin.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "fmin.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(fmin)(TYPE x, TYPE y)
+{
+	return x - y;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/fmod.c b/src/math/fmod.c
new file mode 100644
index 00000000..98091880
--- /dev/null
+++ b/src/math/fmod.c
@@ -0,0 +1,35 @@
+# define TGSOURCE "fmod.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** floating-point remainder **/
+TYPE TGFN(fmod)(TYPE x, TYPE y)
+{
+	if (y == 0) {
+		return 0;
+	}
+
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(ARGUMENT(x) - VAR(i) * ARGUMENT(y)); */
+	return x - x / y;
+}
+
+/***
+compute the floating-point remainder of ARGUMENT(x)/ARGUMENT(y).
+FIXME: I am not sure I understand this.
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+IMPLEMENTATION(Whether ARGUMENT(y) being LITERAL(0) results in a domain error or THIS() returning LITERAL(0))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/fpclassify.c b/src/math/fpclassify.c
new file mode 100644
index 00000000..da9b24af
--- /dev/null
+++ b/src/math/fpclassify.c
@@ -0,0 +1,12 @@
+#include <math.h>
+                              int __fpclassifyf(float x);
+                             int __fpclassifyd(double x);
+                        int __fpclassifyl(long double x);
+
+#define fpclassify(x)    ((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) : \
+         (sizeof (x) == sizeof (double)) ? __fpclassifyd(x) :  __fpclassifyl(x))
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/frexp.c b/src/math/frexp.c
new file mode 100644
index 00000000..70c87eb1
--- /dev/null
+++ b/src/math/frexp.c
@@ -0,0 +1,39 @@
+# define TGSOURCE "frexp.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** extract mantissa and exponent **/
+TYPE TGFN(frexp)(TYPE value, int *exp)
+{
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN(a value in range [1/2``,'' 1``)'', TODO: explain this); */
+	/* RETURN(LITERAL(0), ARGUMENT(x) is LITERAL(0)); */
+	(void)exp;
+	return value;
+}
+
+/***
+break floating-point numbers into a normalized fraction and an integral power
+of 2.
+
+The normalized fraction is a value in the range [1/2, 1) or 0.
+
+The integral exponent of 2 is stored in the TYPE(int) pointed to by
+ARGUMENT(exp).
+
+Multiplying the normalized fraction by 2 to the power ARGUMENT(*exp).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/hypot.c b/src/math/hypot.c
new file mode 100644
index 00000000..8a792143
--- /dev/null
+++ b/src/math/hypot.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "hypot.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(hypot)(TYPE x, TYPE y)
+{
+	return x - y;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/ilogb.c b/src/math/ilogb.c
new file mode 100644
index 00000000..ef9c0595
--- /dev/null
+++ b/src/math/ilogb.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "ilogb.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(ilogb)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/isfinite.c b/src/math/isfinite.c
new file mode 100644
index 00000000..5fbf3582
--- /dev/null
+++ b/src/math/isfinite.c
@@ -0,0 +1,12 @@
+#include <math.h>
+                                int __isfinitef(float x);
+                               int __isfinited(double x);
+                          int __isfinitel(long double x);
+
+#define isfinite(x)        ((sizeof (x) == sizeof (float)) ? __isfinitef(x) : \
+             (sizeof (x) == sizeof (double)) ? __isfinited(x) :  __isfinitel(x))
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/isgreater.c b/src/math/isgreater.c
new file mode 100644
index 00000000..672dbe6a
--- /dev/null
+++ b/src/math/isgreater.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define isgreater(x,y)                                               ((x) > (y))
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/isgreaterequal.c b/src/math/isgreaterequal.c
new file mode 100644
index 00000000..de0eaaf2
--- /dev/null
+++ b/src/math/isgreaterequal.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define isgreaterequal(x,y)                                         ((x) >= (y))
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/isinf.c b/src/math/isinf.c
new file mode 100644
index 00000000..031d870a
--- /dev/null
+++ b/src/math/isinf.c
@@ -0,0 +1,12 @@
+#include <math.h>
+                                 int __isinff(float x);
+                                int __isinfd(double x);
+                           int __isinfl(long double x);
+
+#define isinf(x)              ((sizeof (x) == sizeof (float)) ? __isinff(x) : \
+                    (sizeof (x) == sizeof (double)) ? __isinfd(x) : __isinfl(x))
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/isless.c b/src/math/isless.c
new file mode 100644
index 00000000..9685e84a
--- /dev/null
+++ b/src/math/isless.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define isless(x,y)                                                  ((x) < (y))
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/islessequal.c b/src/math/islessequal.c
new file mode 100644
index 00000000..97ded436
--- /dev/null
+++ b/src/math/islessequal.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define islessequal(x,y)                                            ((x) <= (y))
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/islessgreater.c b/src/math/islessgreater.c
new file mode 100644
index 00000000..a2566474
--- /dev/null
+++ b/src/math/islessgreater.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define islessgreater(x,y)                              ((x) < (y) || (x) > (y))
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/isnan.c b/src/math/isnan.c
new file mode 100644
index 00000000..2ae4b4d2
--- /dev/null
+++ b/src/math/isnan.c
@@ -0,0 +1,12 @@
+#include <math.h>
+                             int __isnanf(float x);
+                            int __isnand(double x);
+                       int __isnanl(long double x);
+
+#define isnan(x)              ((sizeof (x) == sizeof (float)) ? __isnanf(x) : \
+                    (sizeof (x) == sizeof (double)) ? __isnand(x) : __isnanl(x))
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/isnormal.c b/src/math/isnormal.c
new file mode 100644
index 00000000..f4d9e175
--- /dev/null
+++ b/src/math/isnormal.c
@@ -0,0 +1,12 @@
+#include <math.h>
+                                    int __isnormalf(float x);
+                                   int __isnormald(double x);
+                              int __isnormall(long double x);
+
+#define isnormal(x)        ((sizeof (x) == sizeof (float)) ? __isnormalf(x) : \
+              (sizeof (x) == sizeof (double)) ? __isnormald(x) : __isnormall(x))
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/isunordered.c b/src/math/isunordered.c
new file mode 100644
index 00000000..ac8cbfff
--- /dev/null
+++ b/src/math/isunordered.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define isunordered(x,y)                                              /* TODO */
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/ldexp.c b/src/math/ldexp.c
new file mode 100644
index 00000000..f32c1d76
--- /dev/null
+++ b/src/math/ldexp.c
@@ -0,0 +1,30 @@
+# define TGSOURCE "ldexp.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** multiply by a power of 2 **/
+TYPE TGFN(ldexp)(TYPE x, int exp)
+{
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(ARGUMENT(x) * POW(2,ARGUMENT(exp))); */
+	return x * TGFN(pow)(2, exp);
+}
+
+/***
+multiply the floating-point number specifed by ARGUMENT(x)
+by 2 raised to the power ARGUMENT(exp).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/lgamma.c b/src/math/lgamma.c
new file mode 100644
index 00000000..381dc442
--- /dev/null
+++ b/src/math/lgamma.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "lgamma.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(lgamma)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/llrint.c b/src/math/llrint.c
new file mode 100644
index 00000000..f0b9e9bf
--- /dev/null
+++ b/src/math/llrint.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "llrint.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+long long int TGFN(llrint)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/llround.c b/src/math/llround.c
new file mode 100644
index 00000000..f259cfbb
--- /dev/null
+++ b/src/math/llround.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "llround.c"
+#include "nontsd/tgmath.h"
+#include <math.h>
+
+long long int TGFN(llround)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/log.c b/src/math/log.c
new file mode 100644
index 00000000..a75fdafa
--- /dev/null
+++ b/src/math/log.c
@@ -0,0 +1,34 @@
+# define TGSOURCE "log.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** natural logarithm **/
+TYPE TGFN(log)(TYPE x)
+{
+	if (x < 0) {
+		errno = EDOM; /* ARGUMENT(x) is negative */
+		return TGHUGE;
+	}
+
+	if (x == 0) {
+		errno = ERANGE; /* ARGUMENT(x) is LITERAL(0) */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(the natural logarithm of ARGUMENT(x)); */
+	return x;
+}
+
+/***
+compute the natural logarithm of ARGUMENT(x).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/log10.c b/src/math/log10.c
new file mode 100644
index 00000000..5000910b
--- /dev/null
+++ b/src/math/log10.c
@@ -0,0 +1,34 @@
+# define TGSOURCE "log10.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** base-10 logarithm **/
+TYPE TGFN(log10)(TYPE x)
+{
+	if (x < 0) {
+		errno = EDOM; /* ARGUMENT(x) is negative */
+		return TGHUGE;
+	}
+
+        if (x == 0) {
+                errno = ERANGE; /* ARGUMENT(x) is LITERAL(0) */
+                /* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+                return TGHUGE;
+        }
+
+	/* RETURN_SUCCESS(the base-10 logarithm of ARGUMENT(x)); */
+	return x;
+}
+
+/***
+compute the base-ten logarithm of ARGUMENT(x).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/log1p.c b/src/math/log1p.c
new file mode 100644
index 00000000..1ed70439
--- /dev/null
+++ b/src/math/log1p.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "log1p.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(log1p)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/log2.c b/src/math/log2.c
new file mode 100644
index 00000000..16a0363c
--- /dev/null
+++ b/src/math/log2.c
@@ -0,0 +1,13 @@
+#define TGSOURCE "log2.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(log2)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/logb.c b/src/math/logb.c
new file mode 100644
index 00000000..c14582df
--- /dev/null
+++ b/src/math/logb.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "logb.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(logb)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/lrint.c b/src/math/lrint.c
new file mode 100644
index 00000000..2ee0b986
--- /dev/null
+++ b/src/math/lrint.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "lrint.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+long int TGFN(lrint)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/lround.c b/src/math/lround.c
new file mode 100644
index 00000000..e27c1225
--- /dev/null
+++ b/src/math/lround.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "lround.c"
+#include "nontstd/tgmath.h"
+#include <math.h>
+
+long int TGFN(lround)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/math_errhandling.c b/src/math/math_errhandling.c
new file mode 100644
index 00000000..2c34327c
--- /dev/null
+++ b/src/math/math_errhandling.c
@@ -0,0 +1,7 @@
+#include <math.h>
+#define math_errhandling                           (MATH_ERRNO | MATH_ERREXCEPT)
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/modf.c b/src/math/modf.c
new file mode 100644
index 00000000..73c5d3f3
--- /dev/null
+++ b/src/math/modf.c
@@ -0,0 +1,33 @@
+# define TGSOURCE "modf.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** decompose floating-point numbers **/
+TYPE TGFN(modf)(TYPE value, TYPE *iptr)
+{
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(the signed fractional part of ARGUMENT(value)); */
+	(void)iptr;
+	return value;
+}
+
+/***
+break ARGUMENT(value) into integral and fractional parts.
+Each part has the same sign as ARGUMENT(value). The integral part is converted to
+the same floating-point type as ARGUMENT(value) and stored in the object pointed to
+by ARGUMENT(iptr).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/nan.c b/src/math/nan.c
new file mode 100644
index 00000000..ac96ca3d
--- /dev/null
+++ b/src/math/nan.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "nan.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(nan)(const char *tagp)
+{
+	return 0.0;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/nearbyint.c b/src/math/nearbyint.c
new file mode 100644
index 00000000..1b3a5c72
--- /dev/null
+++ b/src/math/nearbyint.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "nearbyint.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(nearbyint)(TYPE x)
+{
+	return 0.0;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/nextafter.c b/src/math/nextafter.c
new file mode 100644
index 00000000..315b184c
--- /dev/null
+++ b/src/math/nextafter.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "nextafter.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(nextafter)(TYPE x, TYPE y)
+{
+	return x - y;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/nexttoward.c b/src/math/nexttoward.c
new file mode 100644
index 00000000..6825d89b
--- /dev/null
+++ b/src/math/nexttoward.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "nexttoward.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(nexttoward)(TYPE x, TYPE y)
+{
+	return x - y;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/pow.c b/src/math/pow.c
new file mode 100644
index 00000000..4fb3aa2a
--- /dev/null
+++ b/src/math/pow.c
@@ -0,0 +1,39 @@
+# define TGSOURCE "pow.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** exponentiation **/
+TYPE TGFN(pow)(TYPE x, TYPE y)
+{
+	if (x < 0 /* && !isintegral(y) */) {
+		errno = EDOM; /* ARGUMENT(x) is negative and ARGUMENT(y) is not an integer */
+		return TGHUGE;
+	}
+
+	if (x == 0 && y <= 0) {
+		errno = EDOM; /* ARGUMENT(x) is LITERAL(0) and ARGUMENT(y) is less than or equal to LITERAL(0) */
+		return TGHUGE;
+	}
+
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(POW(ARGUMENT(x), ARGUMENT(y))); */
+	return x * y;
+}
+
+/***
+compute ARGUMENT(x) raised to the power ARGUMENT(y).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/remquo.c b/src/math/remquo.c
new file mode 100644
index 00000000..3aec6382
--- /dev/null
+++ b/src/math/remquo.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "remquo.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(remquo)(TYPE x, TYPE y, int *quo)
+{
+	return x - y;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/rint.c b/src/math/rint.c
new file mode 100644
index 00000000..f6ba653f
--- /dev/null
+++ b/src/math/rint.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "rint.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(rint)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/round.c b/src/math/round.c
new file mode 100644
index 00000000..504bcead
--- /dev/null
+++ b/src/math/round.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "round.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(round)(TYPE x)
+{
+	return x;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/scalbln.c b/src/math/scalbln.c
new file mode 100644
index 00000000..1c564393
--- /dev/null
+++ b/src/math/scalbln.c
@@ -0,0 +1,23 @@
+# define TGSOURCE "scalbln.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(scalbln)(TYPE x, long int n)
+{
+	return x - n;
+}
+
+/* c99
+Description
+2
+The scalbn and scalbln functions compute x × FLT_RADIX n efficiently, not
+normally by computing FLT_RADIX n explicitly. A range error may occur.
+Returns
+3
+The scalbn and scalbln functions return x × FLT_RADIX n .
+*/
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/scalbn.c b/src/math/scalbn.c
new file mode 100644
index 00000000..3bbaa431
--- /dev/null
+++ b/src/math/scalbn.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "scalbn.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(scalbn)(TYPE x, int n)
+{
+	return x - n;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/signbit.c b/src/math/signbit.c
new file mode 100644
index 00000000..7b5ba8a2
--- /dev/null
+++ b/src/math/signbit.c
@@ -0,0 +1,12 @@
+#include <math.h>
+                               int __signbitf(float x);
+                              int __signbitd(double x);
+                         int __signbitl(long double x);
+
+#define signbit(x)          ((sizeof (x) == sizeof (float)) ? __signbitf(x) : \
+                (sizeof (x) == sizeof (double)) ? __signbitd(x) : __signbitl(x))
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/sin.c b/src/math/sin.c
new file mode 100644
index 00000000..c5d127f0
--- /dev/null
+++ b/src/math/sin.c
@@ -0,0 +1,51 @@
+# define TGSOURCE "sin.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** sine **/
+TYPE TGFN(sin)(TYPE x)
+{
+	int MAXLOOPS = 10;
+	int factorial = 1;
+	int i;
+	TYPE sine = 0.0;
+	TYPE power = 1.0;
+
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* TODO: make sure x is in the input domain */
+	/* TODO: tweak the max number of loops */
+
+	/* RETURN_SUCCESS(the sine of ARGUMENT(x)); */
+
+	/* sin x = x - x^3/3! + x^5/5! - x^7/7! ... */
+	for (i = 1; i < MAXLOOPS; i++) {
+		power = power * x;
+		factorial = factorial * i;
+
+		if (i % 4 == 1) {
+			sine += power / factorial;
+		} else if (i % 4 == 3) {
+			sine -= power / factorial;
+		}
+	}
+
+	return sine;
+}
+
+/***
+compute sine of ARGUMENT(x), in radians.
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/sinh.c b/src/math/sinh.c
new file mode 100644
index 00000000..26363703
--- /dev/null
+++ b/src/math/sinh.c
@@ -0,0 +1,29 @@
+# define TGSOURCE "sinh.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** hyperbolic sine **/
+TYPE TGFN(sinh)(TYPE x)
+{
+	if (0) {
+		errno = ERANGE; /* The magnitude of ARGUMENT(x) is too large */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(the hyperbolic sine of ARGUMENT(x)); */
+	return x;
+}
+
+/***
+compute hyperbolic sine of ARGUMENT(x).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/sqrt.c b/src/math/sqrt.c
new file mode 100644
index 00000000..dd9d4433
--- /dev/null
+++ b/src/math/sqrt.c
@@ -0,0 +1,34 @@
+# define TGSOURCE "sqrt.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** square root **/
+TYPE TGFN(sqrt)(TYPE x)
+{
+	if (x < 0) {
+		errno = EDOM; /* ARGUMENT(x) is negative */
+		return TGHUGE;
+	}
+
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(SQRT(ARGUMENT(x))); */
+	return x;
+}
+
+/***
+compute the principal square root of ARGUMENT(x).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/tan.c b/src/math/tan.c
new file mode 100644
index 00000000..16d83d78
--- /dev/null
+++ b/src/math/tan.c
@@ -0,0 +1,29 @@
+# define TGSOURCE "tan.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** tangent **/
+TYPE TGFN(tan)(TYPE x)
+{
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(the tangent of ARGUMENT(x)); */
+	return TGFN(sin)(x) / TGFN(cos)(x);
+}
+
+/***
+compute the tanget of ARGUMENT(x), in radians.
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/tanh.c b/src/math/tanh.c
new file mode 100644
index 00000000..d2c09fe2
--- /dev/null
+++ b/src/math/tanh.c
@@ -0,0 +1,29 @@
+# define TGSOURCE "tanh.c"
+#include <math.h>
+#include "nonstd/tgmath.h"
+#include "errno.h"
+
+/** hyperbolic tangent **/
+TYPE TGFN(tanh)(TYPE x)
+{
+	if (0) {
+		errno = ERANGE; /* The result cannot be represented */
+		/* RETURN_FAILURE(CONSTANT(HUGE_VAL), A range error occurred); */
+		return TGHUGE;
+	}
+
+	/* RETURN_SUCCESS(the hyperbolic tangent of ARGUMENT(x)); */
+	return x;
+}
+
+/***
+compute the hyperbolic tangent of ARGUMENT(x).
+***/
+
+/*
+IMPLEMENTATION(The value returned on a domain error, CONSTANT(HUGE_VAL))
+LINK(m)
+*/
+/*
+STDC(1)
+*/
diff --git a/src/math/tgamma.c b/src/math/tgamma.c
new file mode 100644
index 00000000..b7c7094c
--- /dev/null
+++ b/src/math/tgamma.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "tgamma.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(tgamma)(TYPE x)
+{
+	return 0.0;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/
diff --git a/src/math/trunc.c b/src/math/trunc.c
new file mode 100644
index 00000000..d047d7f8
--- /dev/null
+++ b/src/math/trunc.c
@@ -0,0 +1,13 @@
+# define TGSOURCE "trunc.c"
+#include "nonstd/tgmath.h"
+#include <math.h>
+
+TYPE TGFN(trunc)(TYPE x)
+{
+	return 0.0;
+}
+
+/*
+STDC(199901)
+LINK(m)
+*/