Index: uspace/app/tester/float/float2.c
===================================================================
--- uspace/app/tester/float/float2.c	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/app/tester/float/float2.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -42,4 +42,21 @@
 };
 
+static double arguments_acos[OPERANDS] = {
+	-0.936456687291, -0.504846104600, 0.862318872288, 0.964966028492,
+	0.987353618220, 1.0, -0.194939922623, 0.978471923925, -0.999023478833,
+	0.540302305868
+};
+
+static double arguments_asin[OPERANDS] = {
+	-0.350783227690, -0.863209366649, -0.506365641110, -0.262374853704,
+	0.158533380044, 0.0, 0.980815184715, -0.206379975025, -0.044182448332,
+	0.841470984808
+};
+
+static double arguments_atan[OPERANDS] = {
+	3.5, 100.0, 50.0, 768.3156, 1080.499999, 1.0, 66.0,
+	2.718281828459045, 9.9, 0.001
+};
+
 static double arguments_exp[OPERANDS] = {
 	3.5, -2.1, 50.0, 0.0, 1.0, 13.2, -1.1, -5.5, 0.1, -66.0
@@ -51,4 +68,30 @@
 };
 
+static double arguments_sqrt[OPERANDS] = {
+	3.5, 100.0, 50.0, 768.3156, 1080.499999, 1.0, 66.0,
+	2.718281828459045, 9.9, 0.001
+};
+
+static double arguments_tanh[OPERANDS] = {
+	3.5, -2.1, 50.0, 0.0, 1.0, 13.2, -1.1, -5.5, 0.000001, -66000000.0
+};
+
+static double results_acos[OPERANDS] = {
+	2.783185307180, 2.100000000000, 0.530964914873, 0.265482457437,
+	0.159205070272, 0.000000000000, 1.766992524091, 0.207873834887,
+	3.097395817941, 1.000000000000
+};
+
+static double results_asin[OPERANDS] = {
+	-0.358407346411, -1.041592653590, -0.530964914874, -0.265482457437,
+	0.159205070273, 0.000000000000, 1.374600129498, -0.207873834889,
+	-0.044196835651, 1.000000000000
+};
+
+static double results_atan[OPERANDS] = {
+	1.292496667790, 1.560796660108, 1.550798992822, 1.569494779052,
+	1.569870829603, 0.785398163397, 1.555645970920, 1.218282905017,
+	1.470127674637, 0.000999999667
+};
 
 static double results_ceil[OPERANDS] = {
@@ -56,10 +99,40 @@
 };
 
+static double results_cos[OPERANDS] = {
+	-0.936456687291, -0.504846104600, 0.862318872288, 0.964966028492,
+	0.987353618220, 1.0, -0.194939922623, 0.978471923925, -0.999023478833,
+	0.540302305868
+};
+
+static double results_cosh[OPERANDS] = {
+	16.572824671057, 4.144313170410, 2592352764293536022528.000000000000,
+	1.000000000000, 1.543080634815, 270182.468624271103, 1.668518553822,
+	122.348009517829, 1.005004168056, 23035933171656458903220125696.0
+};
+
+static double results_fabs[OPERANDS] = {
+	3.5, 2.1, 100.0, 50.0, 1024.0, 0.0, 768.3156, 1080.499999, 600.0, 1.0
+};
+
 static double results_floor[OPERANDS] = {
 	3.0, -3.0, 100.0, 50.0, -1024.0, 0.0, 768.0, 1080.0, -600.0, 1.0
 };
 
-static double results_trunc[OPERANDS] = {
-	3.0, -2.0, 100.0, 50.0, -1024.0, 0.0, 768.0, 1080.0, -600.0, 1.0
+static double results_exp[OPERANDS] = {
+	33.115451958692, 0.122456428253, 5184705528587072045056.0,
+	1.000000000000, 2.718281828459, 540364.937246691552, 0.332871083698,
+	0.004086771438, 1.105170918076, 0.000000000000
+};
+
+static double results_log[OPERANDS] = {
+	1.252762968495, 4.605170185988, 3.912023005428, 6.644200586236,
+	6.985179175021, 0.000000000000, 4.189654742026, 1.000000000000,
+	2.292534757141, -6.907755278982
+};
+
+static double results_log10[OPERANDS] = {
+	0.544068044350, 2.000000000000, 1.698970004336, 2.885539651261,
+	3.033624770817, 0.000000000000, 1.819543935542, 0.434294481903,
+	0.995635194598, -3.000000000000
 };
 
@@ -70,20 +143,30 @@
 };
 
-static double results_cos[OPERANDS] = {
-	-0.936456687291, -0.504846104600, 0.862318872288, 0.964966028492,
-	0.987353618220, 1.0, -0.194939922623, 0.978471923925, -0.999023478833,
-	0.540302305868
-};
-
-static double results_log[OPERANDS] = {
-	1.252762968495, 4.605170185988, 3.912023005428, 6.644200586236,
-	6.985179175021, 0.000000000000, 4.189654742026, 1.000000000000,
-	2.292534757141, -6.907755278982
-};
-
-static double results_exp[OPERANDS] = {
-	33.115451958692, 0.122456428253, 5184705528587072045056.0,
-	1.000000000000, 2.718281828459, 540364.937246691552, 0.332871083698,
-	0.004086771438, 1.105170918076, 0.000000000000
+static double results_sinh[OPERANDS] = {
+	16.542627287635, -4.021856742157, 2592352764293536022528.000000000000,
+	0.000000000000, 1.175201193644, 270182.468622420449, -1.335647470124,
+	-122.343922746391, 0.100166750020, -23035933171656458903220125696.0
+};
+
+static double results_sqrt[OPERANDS] = {
+	1.870828693387, 10.000000000000, 7.071067811865, 27.718506453271,
+	32.870959812576, 1.000000000000, 8.124038404636, 1.648721270700,
+	3.146426544510, 0.031622776602
+};
+
+static double results_tan[OPERANDS] = {
+	0.374585640159, 1.709846542905, -0.587213915157, -0.271900611998,
+	0.160563932839, 0.000000000000, -5.031371570891, -0.210920691722,
+	0.044225635601, 1.557407724655
+};
+
+static double results_tanh[OPERANDS] = {
+	0.998177897611, -0.970451936613, 1.000000000000, 0.000000000000,
+	0.761594155956, 0.999999999993, -0.800499021761, -0.999966597156,
+	0.000001000000, -1.000000000000
+};
+
+static double results_trunc[OPERANDS] = {
+	3.0, -2.0, 100.0, 50.0, -1024.0, 0.0, 768.0, 1080.0, -600.0, 1.0
 };
 
@@ -125,4 +208,64 @@
 {
 	bool fail = false;
+if (0) {
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = acos(arguments_acos[i]);
+
+		if (!cmp_double(res, results_acos[i])) {
+			TPRINTF("Double precision acos failed "
+			    "(%lf != %lf, arg %u)\n", res, results_acos[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = acosf(arguments_acos[i]);
+
+		if (!cmp_float(res, results_acos[i])) {
+			TPRINTF("Single precision acos failed "
+			    "(%f != %lf, arg %u)\n", res, results_acos[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = asin(arguments_asin[i]);
+
+		if (!cmp_double(res, results_asin[i])) {
+			TPRINTF("Double precision asin failed "
+			    "(%lf != %lf, arg %u)\n", res, results_asin[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = asinf(arguments_asin[i]);
+
+		if (!cmp_float(res, results_asin[i])) {
+			TPRINTF("Single precision asin failed "
+			    "(%f != %lf, arg %u)\n", res, results_asin[i], i);
+			fail = true;
+		}
+	}
+}
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = atan(arguments_atan[i]);
+
+		if (!cmp_double(res, results_atan[i])) {
+			TPRINTF("Double precision atan failed "
+			    "(%.12lf != %.12lf, arg %u)\n", res, results_atan[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = atanf(arguments_atan[i]);
+
+		if (!cmp_float(res, results_atan[i])) {
+			TPRINTF("Single precision atan failed "
+			    "(%f != %lf, arg %u)\n", res, results_atan[i], i);
+			fail = true;
+		}
+	}
 
 	for (unsigned int i = 0; i < OPERANDS; i++) {
@@ -167,4 +310,24 @@
 
 	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = cosh(arguments_exp[i]);
+
+		if (!cmp_double(res, results_cosh[i])) {
+			TPRINTF("Double precision cosh failed "
+			    "(%lf != %lf, arg %u)\n", res, results_cosh[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = coshf(arguments_exp[i]);
+
+		if (!cmp_float(res, results_cosh[i])) {
+			TPRINTF("Single precision cosh failed "
+			    "(%f != %lf, arg %u)\n", res, results_cosh[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
 		double res = exp(arguments_exp[i]);
 
@@ -187,4 +350,24 @@
 
 	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = fabs(arguments[i]);
+
+		if (!cmp_double(res, results_fabs[i])) {
+			TPRINTF("Double precision fabs failed "
+			    "(%lf != %lf, arg %u)\n", res, results_fabs[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = fabsf(arguments[i]);
+
+		if (!cmp_float(res, results_fabs[i])) {
+			TPRINTF("Single precision fabs failed "
+			    "(%f != %lf, arg %u)\n", res, results_fabs[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
 		double res = floor(arguments[i]);
 
@@ -227,4 +410,24 @@
 
 	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = log10(arguments_log[i]);
+
+		if (!cmp_double(res, results_log10[i])) {
+			TPRINTF("Double precision log10 failed "
+			    "(%lf != %lf, arg %u)\n", res, results_log10[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = log10f(arguments_log[i]);
+
+		if (!cmp_float(res, results_log10[i])) {
+			TPRINTF("Single precision log10 failed "
+			    "(%f != %lf, arg %u)\n", res, results_log10[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
 		double res = sin(arguments[i]);
 
@@ -245,4 +448,84 @@
 		}
 	}
+;
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = sinh(arguments_exp[i]);
+
+		if (!cmp_double(res, results_sinh[i])) {
+			TPRINTF("Double precision sinh failed "
+			    "(%lf != %lf, arg %u)\n", res, results_sinh[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = sinhf(arguments_exp[i]);
+
+		if (!cmp_float(res, results_sinh[i])) {
+			TPRINTF("Single precision sinh failed "
+			    "(%f != %lf, arg %u)\n", res, results_sinh[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = sqrt(arguments_sqrt[i]);
+
+		if (!cmp_double(res, results_sqrt[i])) {
+			TPRINTF("Double precision sqrt failed "
+			    "(%lf != %lf, arg %u)\n", res, results_sqrt[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = sqrtf(arguments_sqrt[i]);
+
+		if (!cmp_float(res, results_sqrt[i])) {
+			TPRINTF("Single precision sqrt failed "
+			    "(%f != %lf, arg %u)\n", res, results_sqrt[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = tan(arguments[i]);
+
+		if (!cmp_double(res, results_tan[i])) {
+			TPRINTF("Double precision tan failed "
+			    "(%lf != %lf, arg %u)\n", res, results_tan[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = tanf(arguments[i]);
+
+		if (!cmp_float(res, results_tan[i])) {
+			TPRINTF("Single precision tan failed "
+			    "(%f != %lf, arg %u)\n", res, results_tan[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		double res = tanh(arguments_tanh[i]);
+
+		if (!cmp_double(res, results_tanh[i])) {
+			TPRINTF("Double precision tanh failed "
+			    "(%lf != %lf, arg %u)\n", res, results_tanh[i], i);
+			fail = true;
+		}
+	}
+
+	for (unsigned int i = 0; i < OPERANDS; i++) {
+		float res = tanhf(arguments_tanh[i]);
+
+		if (!cmp_float(res, results_tanh[i])) {
+			TPRINTF("Single precision tanh failed "
+			    "(%f != %lf, arg %u)\n", res, results_tanh[i], i);
+			fail = true;
+		}
+	}
 
 	for (unsigned int i = 0; i < OPERANDS; i++) {
@@ -260,5 +543,5 @@
 
 		if (!cmp_float(res, results_trunc[i])) {
-			TPRINTF("truncgle precision trunc failed "
+			TPRINTF("Single precision trunc failed "
 			    "(%f != %lf, arg %u)\n", res, results_trunc[i], i);
 			fail = true;
Index: uspace/app/tester/tester.h
===================================================================
--- uspace/app/tester/tester.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/app/tester/tester.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -60,5 +60,5 @@
 	do { \
 		if (!test_quiet) { \
-			fprintf(stderr, (format), ##__VA_ARGS__); \
+			fprintf(stdout, (format), ##__VA_ARGS__); \
 		} \
 	} while (0)
Index: uspace/lib/c/include/errno.h
===================================================================
--- uspace/lib/c/include/errno.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/c/include/errno.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -50,9 +50,10 @@
 #define ENOTEMPTY     (-261)
 #define EBADF         (-262)
-#define ERANGE        (-263)
-#define EXDEV         (-264)
-#define EIO           (-265)
-#define EMLINK        (-266)
-#define ENXIO         (-267)
+#define EDOM          (-263)
+#define ERANGE        (-264)
+#define EXDEV         (-265)
+#define EIO           (-266)
+#define EMLINK        (-267)
+#define ENXIO         (-268)
 
 /** Bad checksum. */
Index: uspace/lib/math/Makefile
===================================================================
--- uspace/lib/math/Makefile	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/Makefile	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -41,11 +41,25 @@
 
 GENERIC_SOURCES = \
+	generic/acos.c \
+	generic/asin.c \
+	generic/atan.c \
+	generic/atan2.c \
 	generic/ceil.c \
+	generic/cosh.c \
 	generic/exp.c \
+	generic/fabs.c \
 	generic/floor.c \
+	generic/fmod.c \
+	generic/frexp.c \
+	generic/ldexp.c \
 	generic/log.c \
+	generic/log10.c \
+	generic/modf.c \
+	generic/pow.c \
+	generic/sinh.c \
+	generic/sqrt.c \
+	generic/tan.c \
+	generic/tanh.c \
 	generic/trig.c \
-	generic/pow.c \
-	generic/mod.c \
 	generic/trunc.c
 
Index: uspace/lib/math/arch/abs32le/include/libarch/math.h
===================================================================
--- uspace/lib/math/arch/abs32le/include/libarch/math.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/arch/abs32le/include/libarch/math.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -37,13 +37,69 @@
 #define LIBMATH_abs32le_MATH_H_
 
+#include <acos.h>
+#include <asin.h>
+#include <atan.h>
+#include <atan2.h>
 #include <ceil.h>
+#include <cosh.h>
 #include <exp.h>
+#include <fabs.h>
 #include <floor.h>
+#include <fmod.h>
+#include <frexp.h>
+#include <ldexp.h>
 #include <log.h>
+#include <log10.h>
 #include <mathtypes.h>
-#include <mod.h>
+#include <modf.h>
 #include <pow.h>
+#include <sinh.h>
+#include <sqrt.h>
+#include <tan.h>
+#include <tanh.h>
+#include <trig.h>
 #include <trunc.h>
-#include <trig.h>
+
+#define HUGE_VAL FLOAT64_INF
+
+static inline float64_t acos_f64(float64_t val)
+{
+	return float64_acos(val);
+}
+
+static inline float32_t acos_f32(float32_t val)
+{
+	return float32_acos(val);
+}
+
+static inline float64_t asin_f64(float64_t val)
+{
+	return float64_asin(val);
+}
+
+static inline float32_t asin_f32(float32_t val)
+{
+	return float32_asin(val);
+}
+
+static inline float64_t atan_f64(float64_t val)
+{
+	return float64_atan(val);
+}
+
+static inline float32_t atan_f32(float32_t val)
+{
+	return float32_atan(val);
+}
+
+static inline float64_t atan2_f64(float64_t y, float64_t x)
+{
+	return float64_atan2(y, x);
+}
+
+static inline float32_t atan2_f32(float32_t y, float32_t x)
+{
+	return float32_atan2(y, x);
+}
 
 static inline float64_t ceil_f64(float64_t val)
@@ -67,4 +123,14 @@
 }
 
+static inline float64_t cosh_f64(float64_t val)
+{
+	return float64_cosh(val);
+}
+
+static inline float32_t cosh_f32(float32_t val)
+{
+	return float32_cosh(val);
+}
+
 static inline float64_t exp_f64(float64_t val)
 {
@@ -77,4 +143,14 @@
 }
 
+static inline float64_t fabs_f64(float64_t val)
+{
+	return float64_fabs(val);
+}
+
+static inline float32_t fabs_f32(float32_t val)
+{
+	return float32_fabs(val);
+}
+
 static inline float64_t floor_f64(float64_t val)
 {
@@ -86,13 +162,32 @@
 	return float32_floor(val);
 }
-
 static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
 {
-	return float64_mod(dividend, divisor);
+	return float64_fmod(dividend, divisor);
 }
 
 static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
 {
-	return float32_mod(dividend, divisor);
+	return float32_fmod(dividend, divisor);
+}
+
+static inline float64_t frexp_f64(float64_t x, int *exp)
+{
+	return float64_frexp(x, exp);
+}
+
+static inline float64_t frexp_f32(float32_t x, int *exp)
+{
+	return float32_frexp(x, exp);
+}
+
+static inline float64_t ldexp_f64(float64_t x, int exp)
+{
+	return float64_ldexp(x, exp);
+}
+
+static inline float64_t ldexp_f32(float32_t x, int exp)
+{
+	return float32_ldexp(x, exp);
 }
 
@@ -107,4 +202,24 @@
 }
 
+static inline float64_t log10_f64(float64_t val)
+{
+	return float64_log10(val);
+}
+
+static inline float32_t log10_f32(float32_t val)
+{
+	return float32_log10(val);
+}
+
+static inline float64_t modf_f64(float64_t value, float64_t *iptr)
+{
+	return float64_modf(value, iptr);
+}
+
+static inline float64_t modf_f32(float32_t value, float32_t *iptr)
+{
+	return float32_modf(value, iptr);
+}
+
 static inline float64_t pow_f64(float64_t x, float64_t y)
 {
@@ -127,4 +242,44 @@
 }
 
+static inline float64_t sinh_f64(float64_t val)
+{
+	return float64_sinh(val);
+}
+
+static inline float32_t sinh_f32(float32_t val)
+{
+	return float32_sinh(val);
+}
+
+static inline float64_t sqrt_f64(float64_t val)
+{
+	return float64_sqrt(val);
+}
+
+static inline float32_t sqrt_f32(float32_t val)
+{
+	return float32_sqrt(val);
+}
+
+static inline float64_t tan_f64(float64_t val)
+{
+	return float64_tan(val);
+}
+
+static inline float32_t tan_f32(float32_t val)
+{
+	return float32_tan(val);
+}
+
+static inline float64_t tanh_f64(float64_t val)
+{
+	return float64_tanh(val);
+}
+
+static inline float32_t tanh_f32(float32_t val)
+{
+	return float32_tanh(val);
+}
+
 static inline float64_t trunc_f64(float64_t val)
 {
@@ -137,4 +292,44 @@
 }
 
+static inline float64_t acos(float64_t val)
+{
+	return acos_f64(val);
+}
+
+static inline float32_t acosf(float32_t val)
+{
+	return acos_f32(val);
+}
+
+static inline float64_t asin(float64_t val)
+{
+	return asin_f64(val);
+}
+
+static inline float32_t asinf(float32_t val)
+{
+	return asin_f32(val);
+}
+
+static inline float64_t atan(float64_t val)
+{
+	return atan_f64(val);
+}
+
+static inline float32_t atanf(float32_t val)
+{
+	return atan_f32(val);
+}
+
+static inline float64_t atan2(float64_t y, float64_t x)
+{
+	return atan2_f64(y, x);
+}
+
+static inline float32_t atan2f(float32_t y, float32_t x)
+{
+	return atan2_f32(y, x);
+}
+
 static inline float64_t ceil(float64_t val)
 {
@@ -157,4 +352,14 @@
 }
 
+static inline float64_t cosh(float64_t val)
+{
+	return cosh_f64(val);
+}
+
+static inline float32_t coshf(float32_t val)
+{
+	return cosh_f32(val);
+}
+
 static inline float64_t exp(float64_t val)
 {
@@ -167,4 +372,14 @@
 }
 
+static inline float64_t fabs(float64_t val)
+{
+	return fabs_f64(val);
+}
+
+static inline float32_t fabsf(float32_t val)
+{
+	return fabs_f32(val);
+}
+
 static inline float64_t floor(float64_t val)
 {
@@ -187,4 +402,24 @@
 }
 
+static inline float64_t frexp(float64_t x, int *exp)
+{
+	return frexp_f64(x, exp);
+}
+
+static inline float32_t frexpf(float32_t x, int *exp)
+{
+	return frexp_f32(x, exp);
+}
+
+static inline float64_t ldexp(float64_t x, int exp)
+{
+	return ldexp_f64(x, exp);
+}
+
+static inline float32_t ldexpf(float32_t x, int exp)
+{
+	return ldexp_f32(x, exp);
+}
+
 static inline float64_t log(float64_t val)
 {
@@ -197,4 +432,24 @@
 }
 
+static inline float64_t log10(float64_t val)
+{
+	return log10_f64(val);
+}
+
+static inline float32_t log10f(float32_t val)
+{
+	return log10_f32(val);
+}
+
+static inline float64_t modf(float64_t value, float64_t *iptr)
+{
+	return modf_f64(value, iptr);
+}
+
+static inline float32_t modff(float32_t value, float32_t *iptr)
+{
+	return modf_f32(value, iptr);
+}
+
 static inline float64_t pow(float64_t x, float64_t y)
 {
@@ -215,4 +470,44 @@
 {
 	return sin_f32(val);
+}
+
+static inline float64_t sinh(float64_t val)
+{
+	return sinh_f64(val);
+}
+
+static inline float32_t sinhf(float32_t val)
+{
+	return sinh_f32(val);
+}
+
+static inline float64_t sqrt(float64_t val)
+{
+	return sqrt_f64(val);
+}
+
+static inline float32_t sqrtf(float32_t val)
+{
+	return sqrt_f32(val);
+}
+
+static inline float64_t tan(float64_t val)
+{
+	return tan_f64(val);
+}
+
+static inline float32_t tanf(float32_t val)
+{
+	return tan_f32(val);
+}
+
+static inline float64_t tanh(float64_t val)
+{
+	return tanh_f64(val);
+}
+
+static inline float32_t tanhf(float32_t val)
+{
+	return tanh_f32(val);
 }
 
Index: uspace/lib/math/arch/amd64/include/libarch/math.h
===================================================================
--- uspace/lib/math/arch/amd64/include/libarch/math.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/arch/amd64/include/libarch/math.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -37,13 +37,69 @@
 #define LIBMATH_amd64_MATH_H_
 
+#include <acos.h>
+#include <asin.h>
+#include <atan.h>
+#include <atan2.h>
 #include <ceil.h>
+#include <cosh.h>
 #include <exp.h>
+#include <fabs.h>
 #include <floor.h>
+#include <fmod.h>
+#include <frexp.h>
+#include <ldexp.h>
 #include <log.h>
+#include <log10.h>
 #include <mathtypes.h>
-#include <mod.h>
+#include <modf.h>
 #include <pow.h>
+#include <sinh.h>
+#include <sqrt.h>
+#include <tan.h>
+#include <tanh.h>
+#include <trig.h>
 #include <trunc.h>
-#include <trig.h>
+
+#define HUGE_VAL FLOAT64_INF
+
+static inline float64_t acos_f64(float64_t val)
+{
+	return float64_acos(val);
+}
+
+static inline float32_t acos_f32(float32_t val)
+{
+	return float32_acos(val);
+}
+
+static inline float64_t asin_f64(float64_t val)
+{
+	return float64_asin(val);
+}
+
+static inline float32_t asin_f32(float32_t val)
+{
+	return float32_asin(val);
+}
+
+static inline float64_t atan_f64(float64_t val)
+{
+	return float64_atan(val);
+}
+
+static inline float32_t atan_f32(float32_t val)
+{
+	return float32_atan(val);
+}
+
+static inline float64_t atan2_f64(float64_t y, float64_t x)
+{
+	return float64_atan2(y, x);
+}
+
+static inline float32_t atan2_f32(float32_t y, float32_t x)
+{
+	return float32_atan2(y, x);
+}
 
 static inline float64_t ceil_f64(float64_t val)
@@ -64,4 +120,14 @@
 }
 
+static inline float64_t cosh_f64(float64_t val)
+{
+	return float64_cosh(val);
+}
+
+static inline float32_t cosh_f32(float32_t val)
+{
+	return float32_cosh(val);
+}
+
 static inline float64_t exp_f64(float64_t val)
 {
@@ -74,4 +140,14 @@
 }
 
+static inline float64_t fabs_f64(float64_t val)
+{
+	return float64_fabs(val);
+}
+
+static inline float32_t fabs_f32(float32_t val)
+{
+	return float32_fabs(val);
+}
+
 static inline float64_t floor_f64(float64_t val)
 {
@@ -83,13 +159,32 @@
 	return float32_floor(val);
 }
-
 static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
 {
-	return float64_mod(dividend, divisor);
+	return float64_fmod(dividend, divisor);
 }
 
 static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
 {
-	return float32_mod(dividend, divisor);
+	return float32_fmod(dividend, divisor);
+}
+
+static inline float64_t frexp_f64(float64_t x, int *exp)
+{
+	return float64_frexp(x, exp);
+}
+
+static inline float64_t frexp_f32(float32_t x, int *exp)
+{
+	return float32_frexp(x, exp);
+}
+
+static inline float64_t ldexp_f64(float64_t x, int exp)
+{
+	return float64_ldexp(x, exp);
+}
+
+static inline float64_t ldexp_f32(float32_t x, int exp)
+{
+	return float32_ldexp(x, exp);
 }
 
@@ -104,4 +199,24 @@
 }
 
+static inline float64_t log10_f64(float64_t val)
+{
+	return float64_log10(val);
+}
+
+static inline float32_t log10_f32(float32_t val)
+{
+	return float32_log10(val);
+}
+
+static inline float64_t modf_f64(float64_t value, float64_t *iptr)
+{
+	return float64_modf(value, iptr);
+}
+
+static inline float64_t modf_f32(float32_t value, float32_t *iptr)
+{
+	return float32_modf(value, iptr);
+}
+
 static inline float64_t pow_f64(float64_t x, float64_t y)
 {
@@ -121,4 +236,44 @@
 }
 
+static inline float64_t sinh_f64(float64_t val)
+{
+	return float64_sinh(val);
+}
+
+static inline float32_t sinh_f32(float32_t val)
+{
+	return float32_sinh(val);
+}
+
+static inline float64_t sqrt_f64(float64_t val)
+{
+	return float64_sqrt(val);
+}
+
+static inline float32_t sqrt_f32(float32_t val)
+{
+	return float32_sqrt(val);
+}
+
+static inline float64_t tan_f64(float64_t val)
+{
+	return float64_tan(val);
+}
+
+static inline float32_t tan_f32(float32_t val)
+{
+	return float32_tan(val);
+}
+
+static inline float64_t tanh_f64(float64_t val)
+{
+	return float64_tanh(val);
+}
+
+static inline float32_t tanh_f32(float32_t val)
+{
+	return float32_tanh(val);
+}
+
 extern float64_t trunc_f64(float64_t);
 
@@ -128,4 +283,44 @@
 }
 
+static inline float64_t acos(float64_t val)
+{
+	return acos_f64(val);
+}
+
+static inline float32_t acosf(float32_t val)
+{
+	return acos_f32(val);
+}
+
+static inline float64_t asin(float64_t val)
+{
+	return asin_f64(val);
+}
+
+static inline float32_t asinf(float32_t val)
+{
+	return asin_f32(val);
+}
+
+static inline float64_t atan(float64_t val)
+{
+	return atan_f64(val);
+}
+
+static inline float32_t atanf(float32_t val)
+{
+	return atan_f32(val);
+}
+
+static inline float64_t atan2(float64_t y, float64_t x)
+{
+	return atan2_f64(y, x);
+}
+
+static inline float32_t atan2f(float32_t y, float32_t x)
+{
+	return atan2_f32(y, x);
+}
+
 static inline float64_t ceil(float64_t val)
 {
@@ -148,4 +343,14 @@
 }
 
+static inline float64_t cosh(float64_t val)
+{
+	return cosh_f64(val);
+}
+
+static inline float32_t coshf(float32_t val)
+{
+	return cosh_f32(val);
+}
+
 static inline float64_t exp(float64_t val)
 {
@@ -158,4 +363,14 @@
 }
 
+static inline float64_t fabs(float64_t val)
+{
+	return fabs_f64(val);
+}
+
+static inline float32_t fabsf(float32_t val)
+{
+	return fabs_f32(val);
+}
+
 static inline float64_t floor(float64_t val)
 {
@@ -178,4 +393,24 @@
 }
 
+static inline float64_t frexp(float64_t x, int *exp)
+{
+	return frexp_f64(x, exp);
+}
+
+static inline float32_t frexpf(float32_t x, int *exp)
+{
+	return frexp_f32(x, exp);
+}
+
+static inline float64_t ldexp(float64_t x, int exp)
+{
+	return ldexp_f64(x, exp);
+}
+
+static inline float32_t ldexpf(float32_t x, int exp)
+{
+	return ldexp_f32(x, exp);
+}
+
 static inline float64_t log(float64_t val)
 {
@@ -188,4 +423,24 @@
 }
 
+static inline float64_t log10(float64_t val)
+{
+	return log10_f64(val);
+}
+
+static inline float32_t log10f(float32_t val)
+{
+	return log10_f32(val);
+}
+
+static inline float64_t modf(float64_t value, float64_t *iptr)
+{
+	return modf_f64(value, iptr);
+}
+
+static inline float32_t modff(float32_t value, float32_t *iptr)
+{
+	return modf_f32(value, iptr);
+}
+
 static inline float64_t pow(float64_t x, float64_t y)
 {
@@ -206,4 +461,44 @@
 {
 	return sin_f32(val);
+}
+
+static inline float64_t sinh(float64_t val)
+{
+	return sinh_f64(val);
+}
+
+static inline float32_t sinhf(float32_t val)
+{
+	return sinh_f32(val);
+}
+
+static inline float64_t sqrt(float64_t val)
+{
+	return sqrt_f64(val);
+}
+
+static inline float32_t sqrtf(float32_t val)
+{
+	return sqrt_f32(val);
+}
+
+static inline float64_t tan(float64_t val)
+{
+	return tan_f64(val);
+}
+
+static inline float32_t tanf(float32_t val)
+{
+	return tan_f32(val);
+}
+
+static inline float64_t tanh(float64_t val)
+{
+	return tanh_f64(val);
+}
+
+static inline float32_t tanhf(float32_t val)
+{
+	return tanh_f32(val);
 }
 
Index: uspace/lib/math/arch/arm32/include/libarch/math.h
===================================================================
--- uspace/lib/math/arch/arm32/include/libarch/math.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/arch/arm32/include/libarch/math.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -37,13 +37,69 @@
 #define LIBMATH_arm32_MATH_H_
 
+#include <acos.h>
+#include <asin.h>
+#include <atan.h>
+#include <atan2.h>
 #include <ceil.h>
+#include <cosh.h>
 #include <exp.h>
+#include <fabs.h>
 #include <floor.h>
+#include <fmod.h>
+#include <frexp.h>
+#include <ldexp.h>
 #include <log.h>
+#include <log10.h>
 #include <mathtypes.h>
-#include <mod.h>
+#include <modf.h>
 #include <pow.h>
+#include <sinh.h>
+#include <sqrt.h>
+#include <tan.h>
+#include <tanh.h>
+#include <trig.h>
 #include <trunc.h>
-#include <trig.h>
+
+#define HUGE_VAL FLOAT64_INF
+
+static inline float64_t acos_f64(float64_t val)
+{
+	return float64_acos(val);
+}
+
+static inline float32_t acos_f32(float32_t val)
+{
+	return float32_acos(val);
+}
+
+static inline float64_t asin_f64(float64_t val)
+{
+	return float64_asin(val);
+}
+
+static inline float32_t asin_f32(float32_t val)
+{
+	return float32_asin(val);
+}
+
+static inline float64_t atan_f64(float64_t val)
+{
+	return float64_atan(val);
+}
+
+static inline float32_t atan_f32(float32_t val)
+{
+	return float32_atan(val);
+}
+
+static inline float64_t atan2_f64(float64_t y, float64_t x)
+{
+	return float64_atan2(y, x);
+}
+
+static inline float32_t atan2_f32(float32_t y, float32_t x)
+{
+	return float32_atan2(y, x);
+}
 
 static inline float64_t ceil_f64(float64_t val)
@@ -67,4 +123,14 @@
 }
 
+static inline float64_t cosh_f64(float64_t val)
+{
+	return float64_cosh(val);
+}
+
+static inline float32_t cosh_f32(float32_t val)
+{
+	return float32_cosh(val);
+}
+
 static inline float64_t exp_f64(float64_t val)
 {
@@ -77,4 +143,14 @@
 }
 
+static inline float64_t fabs_f64(float64_t val)
+{
+	return float64_fabs(val);
+}
+
+static inline float32_t fabs_f32(float32_t val)
+{
+	return float32_fabs(val);
+}
+
 static inline float64_t floor_f64(float64_t val)
 {
@@ -86,13 +162,32 @@
 	return float32_floor(val);
 }
-
 static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
 {
-	return float64_mod(dividend, divisor);
+	return float64_fmod(dividend, divisor);
 }
 
 static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
 {
-	return float32_mod(dividend, divisor);
+	return float32_fmod(dividend, divisor);
+}
+
+static inline float64_t frexp_f64(float64_t x, int *exp)
+{
+	return float64_frexp(x, exp);
+}
+
+static inline float64_t frexp_f32(float32_t x, int *exp)
+{
+	return float32_frexp(x, exp);
+}
+
+static inline float64_t ldexp_f64(float64_t x, int exp)
+{
+	return float64_ldexp(x, exp);
+}
+
+static inline float64_t ldexp_f32(float32_t x, int exp)
+{
+	return float32_ldexp(x, exp);
 }
 
@@ -107,4 +202,24 @@
 }
 
+static inline float64_t log10_f64(float64_t val)
+{
+	return float64_log10(val);
+}
+
+static inline float32_t log10_f32(float32_t val)
+{
+	return float32_log10(val);
+}
+
+static inline float64_t modf_f64(float64_t value, float64_t *iptr)
+{
+	return float64_modf(value, iptr);
+}
+
+static inline float64_t modf_f32(float32_t value, float32_t *iptr)
+{
+	return float32_modf(value, iptr);
+}
+
 static inline float64_t pow_f64(float64_t x, float64_t y)
 {
@@ -127,4 +242,44 @@
 }
 
+static inline float64_t sinh_f64(float64_t val)
+{
+	return float64_sinh(val);
+}
+
+static inline float32_t sinh_f32(float32_t val)
+{
+	return float32_sinh(val);
+}
+
+static inline float64_t sqrt_f64(float64_t val)
+{
+	return float64_sqrt(val);
+}
+
+static inline float32_t sqrt_f32(float32_t val)
+{
+	return float32_sqrt(val);
+}
+
+static inline float64_t tan_f64(float64_t val)
+{
+	return float64_tan(val);
+}
+
+static inline float32_t tan_f32(float32_t val)
+{
+	return float32_tan(val);
+}
+
+static inline float64_t tanh_f64(float64_t val)
+{
+	return float64_tanh(val);
+}
+
+static inline float32_t tanh_f32(float32_t val)
+{
+	return float32_tanh(val);
+}
+
 static inline float64_t trunc_f64(float64_t val)
 {
@@ -137,4 +292,44 @@
 }
 
+static inline float64_t acos(float64_t val)
+{
+	return acos_f64(val);
+}
+
+static inline float32_t acosf(float32_t val)
+{
+	return acos_f32(val);
+}
+
+static inline float64_t asin(float64_t val)
+{
+	return asin_f64(val);
+}
+
+static inline float32_t asinf(float32_t val)
+{
+	return asin_f32(val);
+}
+
+static inline float64_t atan(float64_t val)
+{
+	return atan_f64(val);
+}
+
+static inline float32_t atanf(float32_t val)
+{
+	return atan_f32(val);
+}
+
+static inline float64_t atan2(float64_t y, float64_t x)
+{
+	return atan2_f64(y, x);
+}
+
+static inline float32_t atan2f(float32_t y, float32_t x)
+{
+	return atan2_f32(y, x);
+}
+
 static inline float64_t ceil(float64_t val)
 {
@@ -157,4 +352,14 @@
 }
 
+static inline float64_t cosh(float64_t val)
+{
+	return cosh_f64(val);
+}
+
+static inline float32_t coshf(float32_t val)
+{
+	return cosh_f32(val);
+}
+
 static inline float64_t exp(float64_t val)
 {
@@ -167,4 +372,14 @@
 }
 
+static inline float64_t fabs(float64_t val)
+{
+	return fabs_f64(val);
+}
+
+static inline float32_t fabsf(float32_t val)
+{
+	return fabs_f32(val);
+}
+
 static inline float64_t floor(float64_t val)
 {
@@ -187,4 +402,24 @@
 }
 
+static inline float64_t frexp(float64_t x, int *exp)
+{
+	return frexp_f64(x, exp);
+}
+
+static inline float32_t frexpf(float32_t x, int *exp)
+{
+	return frexp_f32(x, exp);
+}
+
+static inline float64_t ldexp(float64_t x, int exp)
+{
+	return ldexp_f64(x, exp);
+}
+
+static inline float32_t ldexpf(float32_t x, int exp)
+{
+	return ldexp_f32(x, exp);
+}
+
 static inline float64_t log(float64_t val)
 {
@@ -197,4 +432,24 @@
 }
 
+static inline float64_t log10(float64_t val)
+{
+	return log10_f64(val);
+}
+
+static inline float32_t log10f(float32_t val)
+{
+	return log10_f32(val);
+}
+
+static inline float64_t modf(float64_t value, float64_t *iptr)
+{
+	return modf_f64(value, iptr);
+}
+
+static inline float32_t modff(float32_t value, float32_t *iptr)
+{
+	return modf_f32(value, iptr);
+}
+
 static inline float64_t pow(float64_t x, float64_t y)
 {
@@ -215,4 +470,44 @@
 {
 	return sin_f32(val);
+}
+
+static inline float64_t sinh(float64_t val)
+{
+	return sinh_f64(val);
+}
+
+static inline float32_t sinhf(float32_t val)
+{
+	return sinh_f32(val);
+}
+
+static inline float64_t sqrt(float64_t val)
+{
+	return sqrt_f64(val);
+}
+
+static inline float32_t sqrtf(float32_t val)
+{
+	return sqrt_f32(val);
+}
+
+static inline float64_t tan(float64_t val)
+{
+	return tan_f64(val);
+}
+
+static inline float32_t tanf(float32_t val)
+{
+	return tan_f32(val);
+}
+
+static inline float64_t tanh(float64_t val)
+{
+	return tanh_f64(val);
+}
+
+static inline float32_t tanhf(float32_t val)
+{
+	return tanh_f32(val);
 }
 
Index: uspace/lib/math/arch/ia32/include/libarch/math.h
===================================================================
--- uspace/lib/math/arch/ia32/include/libarch/math.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/arch/ia32/include/libarch/math.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -37,13 +37,69 @@
 #define LIBMATH_ia32_MATH_H_
 
+#include <acos.h>
+#include <asin.h>
+#include <atan.h>
+#include <atan2.h>
 #include <ceil.h>
+#include <cosh.h>
 #include <exp.h>
+#include <fabs.h>
 #include <floor.h>
+#include <fmod.h>
+#include <frexp.h>
+#include <ldexp.h>
 #include <log.h>
+#include <log10.h>
 #include <mathtypes.h>
-#include <mod.h>
+#include <modf.h>
 #include <pow.h>
+#include <sinh.h>
+#include <sqrt.h>
+#include <tan.h>
+#include <tanh.h>
+#include <trig.h>
 #include <trunc.h>
-#include <trig.h>
+
+#define HUGE_VAL FLOAT64_INF
+
+static inline float64_t acos_f64(float64_t val)
+{
+	return float64_acos(val);
+}
+
+static inline float32_t acos_f32(float32_t val)
+{
+	return float32_acos(val);
+}
+
+static inline float64_t asin_f64(float64_t val)
+{
+	return float64_asin(val);
+}
+
+static inline float32_t asin_f32(float32_t val)
+{
+	return float32_asin(val);
+}
+
+static inline float64_t atan_f64(float64_t val)
+{
+	return float64_atan(val);
+}
+
+static inline float32_t atan_f32(float32_t val)
+{
+	return float32_atan(val);
+}
+
+static inline float64_t atan2_f64(float64_t y, float64_t x)
+{
+	return float64_atan2(y, x);
+}
+
+static inline float32_t atan2_f32(float32_t y, float32_t x)
+{
+	return float32_atan2(y, x);
+}
 
 static inline float64_t ceil_f64(float64_t val)
@@ -64,4 +120,14 @@
 }
 
+static inline float64_t cosh_f64(float64_t val)
+{
+	return float64_cosh(val);
+}
+
+static inline float32_t cosh_f32(float32_t val)
+{
+	return float32_cosh(val);
+}
+
 static inline float64_t exp_f64(float64_t val)
 {
@@ -74,4 +140,14 @@
 }
 
+static inline float64_t fabs_f64(float64_t val)
+{
+	return float64_fabs(val);
+}
+
+static inline float32_t fabs_f32(float32_t val)
+{
+	return float32_fabs(val);
+}
+
 static inline float64_t floor_f64(float64_t val)
 {
@@ -83,13 +159,32 @@
 	return float32_floor(val);
 }
-
 static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
 {
-	return float64_mod(dividend, divisor);
+	return float64_fmod(dividend, divisor);
 }
 
 static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
 {
-	return float32_mod(dividend, divisor);
+	return float32_fmod(dividend, divisor);
+}
+
+static inline float64_t frexp_f64(float64_t x, int *exp)
+{
+	return float64_frexp(x, exp);
+}
+
+static inline float64_t frexp_f32(float32_t x, int *exp)
+{
+	return float32_frexp(x, exp);
+}
+
+static inline float64_t ldexp_f64(float64_t x, int exp)
+{
+	return float64_ldexp(x, exp);
+}
+
+static inline float64_t ldexp_f32(float32_t x, int exp)
+{
+	return float32_ldexp(x, exp);
 }
 
@@ -104,4 +199,24 @@
 }
 
+static inline float64_t log10_f64(float64_t val)
+{
+	return float64_log10(val);
+}
+
+static inline float32_t log10_f32(float32_t val)
+{
+	return float32_log10(val);
+}
+
+static inline float64_t modf_f64(float64_t value, float64_t *iptr)
+{
+	return float64_modf(value, iptr);
+}
+
+static inline float64_t modf_f32(float32_t value, float32_t *iptr)
+{
+	return float32_modf(value, iptr);
+}
+
 static inline float64_t pow_f64(float64_t x, float64_t y)
 {
@@ -121,4 +236,44 @@
 }
 
+static inline float64_t sinh_f64(float64_t val)
+{
+	return float64_sinh(val);
+}
+
+static inline float32_t sinh_f32(float32_t val)
+{
+	return float32_sinh(val);
+}
+
+static inline float64_t sqrt_f64(float64_t val)
+{
+	return float64_sqrt(val);
+}
+
+static inline float32_t sqrt_f32(float32_t val)
+{
+	return float32_sqrt(val);
+}
+
+static inline float64_t tan_f64(float64_t val)
+{
+	return float64_tan(val);
+}
+
+static inline float32_t tan_f32(float32_t val)
+{
+	return float32_tan(val);
+}
+
+static inline float64_t tanh_f64(float64_t val)
+{
+	return float64_tanh(val);
+}
+
+static inline float32_t tanh_f32(float32_t val)
+{
+	return float32_tanh(val);
+}
+
 extern float64_t trunc_f64(float64_t);
 
@@ -128,4 +283,44 @@
 }
 
+static inline float64_t acos(float64_t val)
+{
+	return acos_f64(val);
+}
+
+static inline float32_t acosf(float32_t val)
+{
+	return acos_f32(val);
+}
+
+static inline float64_t asin(float64_t val)
+{
+	return asin_f64(val);
+}
+
+static inline float32_t asinf(float32_t val)
+{
+	return asin_f32(val);
+}
+
+static inline float64_t atan(float64_t val)
+{
+	return atan_f64(val);
+}
+
+static inline float32_t atanf(float32_t val)
+{
+	return atan_f32(val);
+}
+
+static inline float64_t atan2(float64_t y, float64_t x)
+{
+	return atan2_f64(y, x);
+}
+
+static inline float32_t atan2f(float32_t y, float32_t x)
+{
+	return atan2_f32(y, x);
+}
+
 static inline float64_t ceil(float64_t val)
 {
@@ -148,4 +343,14 @@
 }
 
+static inline float64_t cosh(float64_t val)
+{
+	return cosh_f64(val);
+}
+
+static inline float32_t coshf(float32_t val)
+{
+	return cosh_f32(val);
+}
+
 static inline float64_t exp(float64_t val)
 {
@@ -158,4 +363,14 @@
 }
 
+static inline float64_t fabs(float64_t val)
+{
+	return fabs_f64(val);
+}
+
+static inline float32_t fabsf(float32_t val)
+{
+	return fabs_f32(val);
+}
+
 static inline float64_t floor(float64_t val)
 {
@@ -178,4 +393,24 @@
 }
 
+static inline float64_t frexp(float64_t x, int *exp)
+{
+	return frexp_f64(x, exp);
+}
+
+static inline float32_t frexpf(float32_t x, int *exp)
+{
+	return frexp_f32(x, exp);
+}
+
+static inline float64_t ldexp(float64_t x, int exp)
+{
+	return ldexp_f64(x, exp);
+}
+
+static inline float32_t ldexpf(float32_t x, int exp)
+{
+	return ldexp_f32(x, exp);
+}
+
 static inline float64_t log(float64_t val)
 {
@@ -188,4 +423,24 @@
 }
 
+static inline float64_t log10(float64_t val)
+{
+	return log10_f64(val);
+}
+
+static inline float32_t log10f(float32_t val)
+{
+	return log10_f32(val);
+}
+
+static inline float64_t modf(float64_t value, float64_t *iptr)
+{
+	return modf_f64(value, iptr);
+}
+
+static inline float32_t modff(float32_t value, float32_t *iptr)
+{
+	return modf_f32(value, iptr);
+}
+
 static inline float64_t pow(float64_t x, float64_t y)
 {
@@ -206,4 +461,44 @@
 {
 	return sin_f32(val);
+}
+
+static inline float64_t sinh(float64_t val)
+{
+	return sinh_f64(val);
+}
+
+static inline float32_t sinhf(float32_t val)
+{
+	return sinh_f32(val);
+}
+
+static inline float64_t sqrt(float64_t val)
+{
+	return sqrt_f64(val);
+}
+
+static inline float32_t sqrtf(float32_t val)
+{
+	return sqrt_f32(val);
+}
+
+static inline float64_t tan(float64_t val)
+{
+	return tan_f64(val);
+}
+
+static inline float32_t tanf(float32_t val)
+{
+	return tan_f32(val);
+}
+
+static inline float64_t tanh(float64_t val)
+{
+	return tanh_f64(val);
+}
+
+static inline float32_t tanhf(float32_t val)
+{
+	return tanh_f32(val);
 }
 
Index: uspace/lib/math/arch/ia64/include/libarch/math.h
===================================================================
--- uspace/lib/math/arch/ia64/include/libarch/math.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/arch/ia64/include/libarch/math.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -37,13 +37,69 @@
 #define LIBMATH_ia64_MATH_H_
 
+#include <acos.h>
+#include <asin.h>
+#include <atan.h>
+#include <atan2.h>
 #include <ceil.h>
+#include <cosh.h>
 #include <exp.h>
+#include <fabs.h>
 #include <floor.h>
+#include <fmod.h>
+#include <frexp.h>
+#include <ldexp.h>
 #include <log.h>
+#include <log10.h>
 #include <mathtypes.h>
-#include <mod.h>
+#include <modf.h>
 #include <pow.h>
+#include <sinh.h>
+#include <sqrt.h>
+#include <tan.h>
+#include <tanh.h>
+#include <trig.h>
 #include <trunc.h>
-#include <trig.h>
+
+#define HUGE_VAL FLOAT64_INF
+
+static inline float64_t acos_f64(float64_t val)
+{
+	return float64_acos(val);
+}
+
+static inline float32_t acos_f32(float32_t val)
+{
+	return float32_acos(val);
+}
+
+static inline float64_t asin_f64(float64_t val)
+{
+	return float64_asin(val);
+}
+
+static inline float32_t asin_f32(float32_t val)
+{
+	return float32_asin(val);
+}
+
+static inline float64_t atan_f64(float64_t val)
+{
+	return float64_atan(val);
+}
+
+static inline float32_t atan_f32(float32_t val)
+{
+	return float32_atan(val);
+}
+
+static inline float64_t atan2_f64(float64_t y, float64_t x)
+{
+	return float64_atan2(y, x);
+}
+
+static inline float32_t atan2_f32(float32_t y, float32_t x)
+{
+	return float32_atan2(y, x);
+}
 
 static inline float64_t ceil_f64(float64_t val)
@@ -67,4 +123,14 @@
 }
 
+static inline float64_t cosh_f64(float64_t val)
+{
+	return float64_cosh(val);
+}
+
+static inline float32_t cosh_f32(float32_t val)
+{
+	return float32_cosh(val);
+}
+
 static inline float64_t exp_f64(float64_t val)
 {
@@ -77,4 +143,14 @@
 }
 
+static inline float64_t fabs_f64(float64_t val)
+{
+	return float64_fabs(val);
+}
+
+static inline float32_t fabs_f32(float32_t val)
+{
+	return float32_fabs(val);
+}
+
 static inline float64_t floor_f64(float64_t val)
 {
@@ -86,13 +162,32 @@
 	return float32_floor(val);
 }
-
 static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
 {
-	return float64_mod(dividend, divisor);
+	return float64_fmod(dividend, divisor);
 }
 
 static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
 {
-	return float32_mod(dividend, divisor);
+	return float32_fmod(dividend, divisor);
+}
+
+static inline float64_t frexp_f64(float64_t x, int *exp)
+{
+	return float64_frexp(x, exp);
+}
+
+static inline float64_t frexp_f32(float32_t x, int *exp)
+{
+	return float32_frexp(x, exp);
+}
+
+static inline float64_t ldexp_f64(float64_t x, int exp)
+{
+	return float64_ldexp(x, exp);
+}
+
+static inline float64_t ldexp_f32(float32_t x, int exp)
+{
+	return float32_ldexp(x, exp);
 }
 
@@ -107,4 +202,24 @@
 }
 
+static inline float64_t log10_f64(float64_t val)
+{
+	return float64_log10(val);
+}
+
+static inline float32_t log10_f32(float32_t val)
+{
+	return float32_log10(val);
+}
+
+static inline float64_t modf_f64(float64_t value, float64_t *iptr)
+{
+	return float64_modf(value, iptr);
+}
+
+static inline float64_t modf_f32(float32_t value, float32_t *iptr)
+{
+	return float32_modf(value, iptr);
+}
+
 static inline float64_t pow_f64(float64_t x, float64_t y)
 {
@@ -127,4 +242,44 @@
 }
 
+static inline float64_t sinh_f64(float64_t val)
+{
+	return float64_sinh(val);
+}
+
+static inline float32_t sinh_f32(float32_t val)
+{
+	return float32_sinh(val);
+}
+
+static inline float64_t sqrt_f64(float64_t val)
+{
+	return float64_sqrt(val);
+}
+
+static inline float32_t sqrt_f32(float32_t val)
+{
+	return float32_sqrt(val);
+}
+
+static inline float64_t tan_f64(float64_t val)
+{
+	return float64_tan(val);
+}
+
+static inline float32_t tan_f32(float32_t val)
+{
+	return float32_tan(val);
+}
+
+static inline float64_t tanh_f64(float64_t val)
+{
+	return float64_tanh(val);
+}
+
+static inline float32_t tanh_f32(float32_t val)
+{
+	return float32_tanh(val);
+}
+
 static inline float64_t trunc_f64(float64_t val)
 {
@@ -137,4 +292,44 @@
 }
 
+static inline float64_t acos(float64_t val)
+{
+	return acos_f64(val);
+}
+
+static inline float32_t acosf(float32_t val)
+{
+	return acos_f32(val);
+}
+
+static inline float64_t asin(float64_t val)
+{
+	return asin_f64(val);
+}
+
+static inline float32_t asinf(float32_t val)
+{
+	return asin_f32(val);
+}
+
+static inline float64_t atan(float64_t val)
+{
+	return atan_f64(val);
+}
+
+static inline float32_t atanf(float32_t val)
+{
+	return atan_f32(val);
+}
+
+static inline float64_t atan2(float64_t y, float64_t x)
+{
+	return atan2_f64(y, x);
+}
+
+static inline float32_t atan2f(float32_t y, float32_t x)
+{
+	return atan2_f32(y, x);
+}
+
 static inline float64_t ceil(float64_t val)
 {
@@ -157,4 +352,14 @@
 }
 
+static inline float64_t cosh(float64_t val)
+{
+	return cosh_f64(val);
+}
+
+static inline float32_t coshf(float32_t val)
+{
+	return cosh_f32(val);
+}
+
 static inline float64_t exp(float64_t val)
 {
@@ -167,4 +372,14 @@
 }
 
+static inline float64_t fabs(float64_t val)
+{
+	return fabs_f64(val);
+}
+
+static inline float32_t fabsf(float32_t val)
+{
+	return fabs_f32(val);
+}
+
 static inline float64_t floor(float64_t val)
 {
@@ -187,4 +402,24 @@
 }
 
+static inline float64_t frexp(float64_t x, int *exp)
+{
+	return frexp_f64(x, exp);
+}
+
+static inline float32_t frexpf(float32_t x, int *exp)
+{
+	return frexp_f32(x, exp);
+}
+
+static inline float64_t ldexp(float64_t x, int exp)
+{
+	return ldexp_f64(x, exp);
+}
+
+static inline float32_t ldexpf(float32_t x, int exp)
+{
+	return ldexp_f32(x, exp);
+}
+
 static inline float64_t log(float64_t val)
 {
@@ -197,4 +432,24 @@
 }
 
+static inline float64_t log10(float64_t val)
+{
+	return log10_f64(val);
+}
+
+static inline float32_t log10f(float32_t val)
+{
+	return log10_f32(val);
+}
+
+static inline float64_t modf(float64_t value, float64_t *iptr)
+{
+	return modf_f64(value, iptr);
+}
+
+static inline float32_t modff(float32_t value, float32_t *iptr)
+{
+	return modf_f32(value, iptr);
+}
+
 static inline float64_t pow(float64_t x, float64_t y)
 {
@@ -215,4 +470,44 @@
 {
 	return sin_f32(val);
+}
+
+static inline float64_t sinh(float64_t val)
+{
+	return sinh_f64(val);
+}
+
+static inline float32_t sinhf(float32_t val)
+{
+	return sinh_f32(val);
+}
+
+static inline float64_t sqrt(float64_t val)
+{
+	return sqrt_f64(val);
+}
+
+static inline float32_t sqrtf(float32_t val)
+{
+	return sqrt_f32(val);
+}
+
+static inline float64_t tan(float64_t val)
+{
+	return tan_f64(val);
+}
+
+static inline float32_t tanf(float32_t val)
+{
+	return tan_f32(val);
+}
+
+static inline float64_t tanh(float64_t val)
+{
+	return tanh_f64(val);
+}
+
+static inline float32_t tanhf(float32_t val)
+{
+	return tanh_f32(val);
 }
 
Index: uspace/lib/math/arch/mips32/include/libarch/math.h
===================================================================
--- uspace/lib/math/arch/mips32/include/libarch/math.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/arch/mips32/include/libarch/math.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -37,13 +37,69 @@
 #define LIBMATH_mips32_MATH_H_
 
+#include <acos.h>
+#include <asin.h>
+#include <atan.h>
+#include <atan2.h>
 #include <ceil.h>
+#include <cosh.h>
 #include <exp.h>
+#include <fabs.h>
 #include <floor.h>
+#include <fmod.h>
+#include <frexp.h>
+#include <ldexp.h>
 #include <log.h>
+#include <log10.h>
 #include <mathtypes.h>
-#include <mod.h>
+#include <modf.h>
 #include <pow.h>
+#include <sinh.h>
+#include <sqrt.h>
+#include <tan.h>
+#include <tanh.h>
+#include <trig.h>
 #include <trunc.h>
-#include <trig.h>
+
+#define HUGE_VAL FLOAT64_INF
+
+static inline float64_t acos_f64(float64_t val)
+{
+	return float64_acos(val);
+}
+
+static inline float32_t acos_f32(float32_t val)
+{
+	return float32_acos(val);
+}
+
+static inline float64_t asin_f64(float64_t val)
+{
+	return float64_asin(val);
+}
+
+static inline float32_t asin_f32(float32_t val)
+{
+	return float32_asin(val);
+}
+
+static inline float64_t atan_f64(float64_t val)
+{
+	return float64_atan(val);
+}
+
+static inline float32_t atan_f32(float32_t val)
+{
+	return float32_atan(val);
+}
+
+static inline float64_t atan2_f64(float64_t y, float64_t x)
+{
+	return float64_atan2(y, x);
+}
+
+static inline float32_t atan2_f32(float32_t y, float32_t x)
+{
+	return float32_atan2(y, x);
+}
 
 static inline float64_t ceil_f64(float64_t val)
@@ -67,4 +123,14 @@
 }
 
+static inline float64_t cosh_f64(float64_t val)
+{
+	return float64_cosh(val);
+}
+
+static inline float32_t cosh_f32(float32_t val)
+{
+	return float32_cosh(val);
+}
+
 static inline float64_t exp_f64(float64_t val)
 {
@@ -77,4 +143,14 @@
 }
 
+static inline float64_t fabs_f64(float64_t val)
+{
+	return float64_fabs(val);
+}
+
+static inline float32_t fabs_f32(float32_t val)
+{
+	return float32_fabs(val);
+}
+
 static inline float64_t floor_f64(float64_t val)
 {
@@ -86,13 +162,32 @@
 	return float32_floor(val);
 }
-
 static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
 {
-	return float64_mod(dividend, divisor);
+	return float64_fmod(dividend, divisor);
 }
 
 static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
 {
-	return float32_mod(dividend, divisor);
+	return float32_fmod(dividend, divisor);
+}
+
+static inline float64_t frexp_f64(float64_t x, int *exp)
+{
+	return float64_frexp(x, exp);
+}
+
+static inline float64_t frexp_f32(float32_t x, int *exp)
+{
+	return float32_frexp(x, exp);
+}
+
+static inline float64_t ldexp_f64(float64_t x, int exp)
+{
+	return float64_ldexp(x, exp);
+}
+
+static inline float64_t ldexp_f32(float32_t x, int exp)
+{
+	return float32_ldexp(x, exp);
 }
 
@@ -107,4 +202,24 @@
 }
 
+static inline float64_t log10_f64(float64_t val)
+{
+	return float64_log10(val);
+}
+
+static inline float32_t log10_f32(float32_t val)
+{
+	return float32_log10(val);
+}
+
+static inline float64_t modf_f64(float64_t value, float64_t *iptr)
+{
+	return float64_modf(value, iptr);
+}
+
+static inline float64_t modf_f32(float32_t value, float32_t *iptr)
+{
+	return float32_modf(value, iptr);
+}
+
 static inline float64_t pow_f64(float64_t x, float64_t y)
 {
@@ -127,4 +242,44 @@
 }
 
+static inline float64_t sinh_f64(float64_t val)
+{
+	return float64_sinh(val);
+}
+
+static inline float32_t sinh_f32(float32_t val)
+{
+	return float32_sinh(val);
+}
+
+static inline float64_t sqrt_f64(float64_t val)
+{
+	return float64_sqrt(val);
+}
+
+static inline float32_t sqrt_f32(float32_t val)
+{
+	return float32_sqrt(val);
+}
+
+static inline float64_t tan_f64(float64_t val)
+{
+	return float64_tan(val);
+}
+
+static inline float32_t tan_f32(float32_t val)
+{
+	return float32_tan(val);
+}
+
+static inline float64_t tanh_f64(float64_t val)
+{
+	return float64_tanh(val);
+}
+
+static inline float32_t tanh_f32(float32_t val)
+{
+	return float32_tanh(val);
+}
+
 static inline float64_t trunc_f64(float64_t val)
 {
@@ -137,4 +292,44 @@
 }
 
+static inline float64_t acos(float64_t val)
+{
+	return acos_f64(val);
+}
+
+static inline float32_t acosf(float32_t val)
+{
+	return acos_f32(val);
+}
+
+static inline float64_t asin(float64_t val)
+{
+	return asin_f64(val);
+}
+
+static inline float32_t asinf(float32_t val)
+{
+	return asin_f32(val);
+}
+
+static inline float64_t atan(float64_t val)
+{
+	return atan_f64(val);
+}
+
+static inline float32_t atanf(float32_t val)
+{
+	return atan_f32(val);
+}
+
+static inline float64_t atan2(float64_t y, float64_t x)
+{
+	return atan2_f64(y, x);
+}
+
+static inline float32_t atan2f(float32_t y, float32_t x)
+{
+	return atan2_f32(y, x);
+}
+
 static inline float64_t ceil(float64_t val)
 {
@@ -157,4 +352,14 @@
 }
 
+static inline float64_t cosh(float64_t val)
+{
+	return cosh_f64(val);
+}
+
+static inline float32_t coshf(float32_t val)
+{
+	return cosh_f32(val);
+}
+
 static inline float64_t exp(float64_t val)
 {
@@ -167,4 +372,14 @@
 }
 
+static inline float64_t fabs(float64_t val)
+{
+	return fabs_f64(val);
+}
+
+static inline float32_t fabsf(float32_t val)
+{
+	return fabs_f32(val);
+}
+
 static inline float64_t floor(float64_t val)
 {
@@ -187,4 +402,24 @@
 }
 
+static inline float64_t frexp(float64_t x, int *exp)
+{
+	return frexp_f64(x, exp);
+}
+
+static inline float32_t frexpf(float32_t x, int *exp)
+{
+	return frexp_f32(x, exp);
+}
+
+static inline float64_t ldexp(float64_t x, int exp)
+{
+	return ldexp_f64(x, exp);
+}
+
+static inline float32_t ldexpf(float32_t x, int exp)
+{
+	return ldexp_f32(x, exp);
+}
+
 static inline float64_t log(float64_t val)
 {
@@ -197,4 +432,24 @@
 }
 
+static inline float64_t log10(float64_t val)
+{
+	return log10_f64(val);
+}
+
+static inline float32_t log10f(float32_t val)
+{
+	return log10_f32(val);
+}
+
+static inline float64_t modf(float64_t value, float64_t *iptr)
+{
+	return modf_f64(value, iptr);
+}
+
+static inline float32_t modff(float32_t value, float32_t *iptr)
+{
+	return modf_f32(value, iptr);
+}
+
 static inline float64_t pow(float64_t x, float64_t y)
 {
@@ -215,4 +470,44 @@
 {
 	return sin_f32(val);
+}
+
+static inline float64_t sinh(float64_t val)
+{
+	return sinh_f64(val);
+}
+
+static inline float32_t sinhf(float32_t val)
+{
+	return sinh_f32(val);
+}
+
+static inline float64_t sqrt(float64_t val)
+{
+	return sqrt_f64(val);
+}
+
+static inline float32_t sqrtf(float32_t val)
+{
+	return sqrt_f32(val);
+}
+
+static inline float64_t tan(float64_t val)
+{
+	return tan_f64(val);
+}
+
+static inline float32_t tanf(float32_t val)
+{
+	return tan_f32(val);
+}
+
+static inline float64_t tanh(float64_t val)
+{
+	return tanh_f64(val);
+}
+
+static inline float32_t tanhf(float32_t val)
+{
+	return tanh_f32(val);
 }
 
Index: uspace/lib/math/arch/mips32eb/include/libarch/math.h
===================================================================
--- uspace/lib/math/arch/mips32eb/include/libarch/math.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/arch/mips32eb/include/libarch/math.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -37,13 +37,69 @@
 #define LIBMATH_mips32eb_MATH_H_
 
+#include <acos.h>
+#include <asin.h>
+#include <atan.h>
+#include <atan2.h>
 #include <ceil.h>
+#include <cosh.h>
 #include <exp.h>
+#include <fabs.h>
 #include <floor.h>
+#include <fmod.h>
+#include <frexp.h>
+#include <ldexp.h>
 #include <log.h>
+#include <log10.h>
 #include <mathtypes.h>
-#include <mod.h>
+#include <modf.h>
 #include <pow.h>
+#include <sinh.h>
+#include <sqrt.h>
+#include <tan.h>
+#include <tanh.h>
+#include <trig.h>
 #include <trunc.h>
-#include <trig.h>
+
+#define HUGE_VAL FLOAT64_INF
+
+static inline float64_t acos_f64(float64_t val)
+{
+	return float64_acos(val);
+}
+
+static inline float32_t acos_f32(float32_t val)
+{
+	return float32_acos(val);
+}
+
+static inline float64_t asin_f64(float64_t val)
+{
+	return float64_asin(val);
+}
+
+static inline float32_t asin_f32(float32_t val)
+{
+	return float32_asin(val);
+}
+
+static inline float64_t atan_f64(float64_t val)
+{
+	return float64_atan(val);
+}
+
+static inline float32_t atan_f32(float32_t val)
+{
+	return float32_atan(val);
+}
+
+static inline float64_t atan2_f64(float64_t y, float64_t x)
+{
+	return float64_atan2(y, x);
+}
+
+static inline float32_t atan2_f32(float32_t y, float32_t x)
+{
+	return float32_atan2(y, x);
+}
 
 static inline float64_t ceil_f64(float64_t val)
@@ -67,4 +123,14 @@
 }
 
+static inline float64_t cosh_f64(float64_t val)
+{
+	return float64_cosh(val);
+}
+
+static inline float32_t cosh_f32(float32_t val)
+{
+	return float32_cosh(val);
+}
+
 static inline float64_t exp_f64(float64_t val)
 {
@@ -77,4 +143,14 @@
 }
 
+static inline float64_t fabs_f64(float64_t val)
+{
+	return float64_fabs(val);
+}
+
+static inline float32_t fabs_f32(float32_t val)
+{
+	return float32_fabs(val);
+}
+
 static inline float64_t floor_f64(float64_t val)
 {
@@ -86,13 +162,32 @@
 	return float32_floor(val);
 }
-
 static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
 {
-	return float64_mod(dividend, divisor);
+	return float64_fmod(dividend, divisor);
 }
 
 static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
 {
-	return float32_mod(dividend, divisor);
+	return float32_fmod(dividend, divisor);
+}
+
+static inline float64_t frexp_f64(float64_t x, int *exp)
+{
+	return float64_frexp(x, exp);
+}
+
+static inline float64_t frexp_f32(float32_t x, int *exp)
+{
+	return float32_frexp(x, exp);
+}
+
+static inline float64_t ldexp_f64(float64_t x, int exp)
+{
+	return float64_ldexp(x, exp);
+}
+
+static inline float64_t ldexp_f32(float32_t x, int exp)
+{
+	return float32_ldexp(x, exp);
 }
 
@@ -107,4 +202,24 @@
 }
 
+static inline float64_t log10_f64(float64_t val)
+{
+	return float64_log10(val);
+}
+
+static inline float32_t log10_f32(float32_t val)
+{
+	return float32_log10(val);
+}
+
+static inline float64_t modf_f64(float64_t value, float64_t *iptr)
+{
+	return float64_modf(value, iptr);
+}
+
+static inline float64_t modf_f32(float32_t value, float32_t *iptr)
+{
+	return float32_modf(value, iptr);
+}
+
 static inline float64_t pow_f64(float64_t x, float64_t y)
 {
@@ -127,4 +242,44 @@
 }
 
+static inline float64_t sinh_f64(float64_t val)
+{
+	return float64_sinh(val);
+}
+
+static inline float32_t sinh_f32(float32_t val)
+{
+	return float32_sinh(val);
+}
+
+static inline float64_t sqrt_f64(float64_t val)
+{
+	return float64_sqrt(val);
+}
+
+static inline float32_t sqrt_f32(float32_t val)
+{
+	return float32_sqrt(val);
+}
+
+static inline float64_t tan_f64(float64_t val)
+{
+	return float64_tan(val);
+}
+
+static inline float32_t tan_f32(float32_t val)
+{
+	return float32_tan(val);
+}
+
+static inline float64_t tanh_f64(float64_t val)
+{
+	return float64_tanh(val);
+}
+
+static inline float32_t tanh_f32(float32_t val)
+{
+	return float32_tanh(val);
+}
+
 static inline float64_t trunc_f64(float64_t val)
 {
@@ -137,4 +292,44 @@
 }
 
+static inline float64_t acos(float64_t val)
+{
+	return acos_f64(val);
+}
+
+static inline float32_t acosf(float32_t val)
+{
+	return acos_f32(val);
+}
+
+static inline float64_t asin(float64_t val)
+{
+	return asin_f64(val);
+}
+
+static inline float32_t asinf(float32_t val)
+{
+	return asin_f32(val);
+}
+
+static inline float64_t atan(float64_t val)
+{
+	return atan_f64(val);
+}
+
+static inline float32_t atanf(float32_t val)
+{
+	return atan_f32(val);
+}
+
+static inline float64_t atan2(float64_t y, float64_t x)
+{
+	return atan2_f64(y, x);
+}
+
+static inline float32_t atan2f(float32_t y, float32_t x)
+{
+	return atan2_f32(y, x);
+}
+
 static inline float64_t ceil(float64_t val)
 {
@@ -157,4 +352,14 @@
 }
 
+static inline float64_t cosh(float64_t val)
+{
+	return cosh_f64(val);
+}
+
+static inline float32_t coshf(float32_t val)
+{
+	return cosh_f32(val);
+}
+
 static inline float64_t exp(float64_t val)
 {
@@ -167,4 +372,14 @@
 }
 
+static inline float64_t fabs(float64_t val)
+{
+	return fabs_f64(val);
+}
+
+static inline float32_t fabsf(float32_t val)
+{
+	return fabs_f32(val);
+}
+
 static inline float64_t floor(float64_t val)
 {
@@ -187,4 +402,24 @@
 }
 
+static inline float64_t frexp(float64_t x, int *exp)
+{
+	return frexp_f64(x, exp);
+}
+
+static inline float32_t frexpf(float32_t x, int *exp)
+{
+	return frexp_f32(x, exp);
+}
+
+static inline float64_t ldexp(float64_t x, int exp)
+{
+	return ldexp_f64(x, exp);
+}
+
+static inline float32_t ldexpf(float32_t x, int exp)
+{
+	return ldexp_f32(x, exp);
+}
+
 static inline float64_t log(float64_t val)
 {
@@ -197,4 +432,24 @@
 }
 
+static inline float64_t log10(float64_t val)
+{
+	return log10_f64(val);
+}
+
+static inline float32_t log10f(float32_t val)
+{
+	return log10_f32(val);
+}
+
+static inline float64_t modf(float64_t value, float64_t *iptr)
+{
+	return modf_f64(value, iptr);
+}
+
+static inline float32_t modff(float32_t value, float32_t *iptr)
+{
+	return modf_f32(value, iptr);
+}
+
 static inline float64_t pow(float64_t x, float64_t y)
 {
@@ -215,4 +470,44 @@
 {
 	return sin_f32(val);
+}
+
+static inline float64_t sinh(float64_t val)
+{
+	return sinh_f64(val);
+}
+
+static inline float32_t sinhf(float32_t val)
+{
+	return sinh_f32(val);
+}
+
+static inline float64_t sqrt(float64_t val)
+{
+	return sqrt_f64(val);
+}
+
+static inline float32_t sqrtf(float32_t val)
+{
+	return sqrt_f32(val);
+}
+
+static inline float64_t tan(float64_t val)
+{
+	return tan_f64(val);
+}
+
+static inline float32_t tanf(float32_t val)
+{
+	return tan_f32(val);
+}
+
+static inline float64_t tanh(float64_t val)
+{
+	return tanh_f64(val);
+}
+
+static inline float32_t tanhf(float32_t val)
+{
+	return tanh_f32(val);
 }
 
Index: uspace/lib/math/arch/ppc32/include/libarch/math.h
===================================================================
--- uspace/lib/math/arch/ppc32/include/libarch/math.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/arch/ppc32/include/libarch/math.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -37,13 +37,69 @@
 #define LIBMATH_ppc32_MATH_H_
 
+#include <acos.h>
+#include <asin.h>
+#include <atan.h>
+#include <atan2.h>
 #include <ceil.h>
+#include <cosh.h>
 #include <exp.h>
+#include <fabs.h>
 #include <floor.h>
+#include <fmod.h>
+#include <frexp.h>
+#include <ldexp.h>
 #include <log.h>
+#include <log10.h>
 #include <mathtypes.h>
-#include <mod.h>
+#include <modf.h>
 #include <pow.h>
+#include <sinh.h>
+#include <sqrt.h>
+#include <tan.h>
+#include <tanh.h>
+#include <trig.h>
 #include <trunc.h>
-#include <trig.h>
+
+#define HUGE_VAL FLOAT64_INF
+
+static inline float64_t acos_f64(float64_t val)
+{
+	return float64_acos(val);
+}
+
+static inline float32_t acos_f32(float32_t val)
+{
+	return float32_acos(val);
+}
+
+static inline float64_t asin_f64(float64_t val)
+{
+	return float64_asin(val);
+}
+
+static inline float32_t asin_f32(float32_t val)
+{
+	return float32_asin(val);
+}
+
+static inline float64_t atan_f64(float64_t val)
+{
+	return float64_atan(val);
+}
+
+static inline float32_t atan_f32(float32_t val)
+{
+	return float32_atan(val);
+}
+
+static inline float64_t atan2_f64(float64_t y, float64_t x)
+{
+	return float64_atan2(y, x);
+}
+
+static inline float32_t atan2_f32(float32_t y, float32_t x)
+{
+	return float32_atan2(y, x);
+}
 
 static inline float64_t ceil_f64(float64_t val)
@@ -67,4 +123,14 @@
 }
 
+static inline float64_t cosh_f64(float64_t val)
+{
+	return float64_cosh(val);
+}
+
+static inline float32_t cosh_f32(float32_t val)
+{
+	return float32_cosh(val);
+}
+
 static inline float64_t exp_f64(float64_t val)
 {
@@ -77,4 +143,14 @@
 }
 
+static inline float64_t fabs_f64(float64_t val)
+{
+	return float64_fabs(val);
+}
+
+static inline float32_t fabs_f32(float32_t val)
+{
+	return float32_fabs(val);
+}
+
 static inline float64_t floor_f64(float64_t val)
 {
@@ -86,13 +162,32 @@
 	return float32_floor(val);
 }
-
 static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
 {
-	return float64_mod(dividend, divisor);
+	return float64_fmod(dividend, divisor);
 }
 
 static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
 {
-	return float32_mod(dividend, divisor);
+	return float32_fmod(dividend, divisor);
+}
+
+static inline float64_t frexp_f64(float64_t x, int *exp)
+{
+	return float64_frexp(x, exp);
+}
+
+static inline float64_t frexp_f32(float32_t x, int *exp)
+{
+	return float32_frexp(x, exp);
+}
+
+static inline float64_t ldexp_f64(float64_t x, int exp)
+{
+	return float64_ldexp(x, exp);
+}
+
+static inline float64_t ldexp_f32(float32_t x, int exp)
+{
+	return float32_ldexp(x, exp);
 }
 
@@ -107,4 +202,24 @@
 }
 
+static inline float64_t log10_f64(float64_t val)
+{
+	return float64_log10(val);
+}
+
+static inline float32_t log10_f32(float32_t val)
+{
+	return float32_log10(val);
+}
+
+static inline float64_t modf_f64(float64_t value, float64_t *iptr)
+{
+	return float64_modf(value, iptr);
+}
+
+static inline float64_t modf_f32(float32_t value, float32_t *iptr)
+{
+	return float32_modf(value, iptr);
+}
+
 static inline float64_t pow_f64(float64_t x, float64_t y)
 {
@@ -127,4 +242,44 @@
 }
 
+static inline float64_t sinh_f64(float64_t val)
+{
+	return float64_sinh(val);
+}
+
+static inline float32_t sinh_f32(float32_t val)
+{
+	return float32_sinh(val);
+}
+
+static inline float64_t sqrt_f64(float64_t val)
+{
+	return float64_sqrt(val);
+}
+
+static inline float32_t sqrt_f32(float32_t val)
+{
+	return float32_sqrt(val);
+}
+
+static inline float64_t tan_f64(float64_t val)
+{
+	return float64_tan(val);
+}
+
+static inline float32_t tan_f32(float32_t val)
+{
+	return float32_tan(val);
+}
+
+static inline float64_t tanh_f64(float64_t val)
+{
+	return float64_tanh(val);
+}
+
+static inline float32_t tanh_f32(float32_t val)
+{
+	return float32_tanh(val);
+}
+
 static inline float64_t trunc_f64(float64_t val)
 {
@@ -137,4 +292,44 @@
 }
 
+static inline float64_t acos(float64_t val)
+{
+	return acos_f64(val);
+}
+
+static inline float32_t acosf(float32_t val)
+{
+	return acos_f32(val);
+}
+
+static inline float64_t asin(float64_t val)
+{
+	return asin_f64(val);
+}
+
+static inline float32_t asinf(float32_t val)
+{
+	return asin_f32(val);
+}
+
+static inline float64_t atan(float64_t val)
+{
+	return atan_f64(val);
+}
+
+static inline float32_t atanf(float32_t val)
+{
+	return atan_f32(val);
+}
+
+static inline float64_t atan2(float64_t y, float64_t x)
+{
+	return atan2_f64(y, x);
+}
+
+static inline float32_t atan2f(float32_t y, float32_t x)
+{
+	return atan2_f32(y, x);
+}
+
 static inline float64_t ceil(float64_t val)
 {
@@ -157,4 +352,14 @@
 }
 
+static inline float64_t cosh(float64_t val)
+{
+	return cosh_f64(val);
+}
+
+static inline float32_t coshf(float32_t val)
+{
+	return cosh_f32(val);
+}
+
 static inline float64_t exp(float64_t val)
 {
@@ -167,4 +372,14 @@
 }
 
+static inline float64_t fabs(float64_t val)
+{
+	return fabs_f64(val);
+}
+
+static inline float32_t fabsf(float32_t val)
+{
+	return fabs_f32(val);
+}
+
 static inline float64_t floor(float64_t val)
 {
@@ -187,4 +402,24 @@
 }
 
+static inline float64_t frexp(float64_t x, int *exp)
+{
+	return frexp_f64(x, exp);
+}
+
+static inline float32_t frexpf(float32_t x, int *exp)
+{
+	return frexp_f32(x, exp);
+}
+
+static inline float64_t ldexp(float64_t x, int exp)
+{
+	return ldexp_f64(x, exp);
+}
+
+static inline float32_t ldexpf(float32_t x, int exp)
+{
+	return ldexp_f32(x, exp);
+}
+
 static inline float64_t log(float64_t val)
 {
@@ -197,4 +432,24 @@
 }
 
+static inline float64_t log10(float64_t val)
+{
+	return log10_f64(val);
+}
+
+static inline float32_t log10f(float32_t val)
+{
+	return log10_f32(val);
+}
+
+static inline float64_t modf(float64_t value, float64_t *iptr)
+{
+	return modf_f64(value, iptr);
+}
+
+static inline float32_t modff(float32_t value, float32_t *iptr)
+{
+	return modf_f32(value, iptr);
+}
+
 static inline float64_t pow(float64_t x, float64_t y)
 {
@@ -215,4 +470,44 @@
 {
 	return sin_f32(val);
+}
+
+static inline float64_t sinh(float64_t val)
+{
+	return sinh_f64(val);
+}
+
+static inline float32_t sinhf(float32_t val)
+{
+	return sinh_f32(val);
+}
+
+static inline float64_t sqrt(float64_t val)
+{
+	return sqrt_f64(val);
+}
+
+static inline float32_t sqrtf(float32_t val)
+{
+	return sqrt_f32(val);
+}
+
+static inline float64_t tan(float64_t val)
+{
+	return tan_f64(val);
+}
+
+static inline float32_t tanf(float32_t val)
+{
+	return tan_f32(val);
+}
+
+static inline float64_t tanh(float64_t val)
+{
+	return tanh_f64(val);
+}
+
+static inline float32_t tanhf(float32_t val)
+{
+	return tanh_f32(val);
 }
 
Index: uspace/lib/math/arch/sparc32/include/libarch/math.h
===================================================================
--- uspace/lib/math/arch/sparc32/include/libarch/math.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/arch/sparc32/include/libarch/math.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -37,13 +37,69 @@
 #define LIBMATH_sparc32_MATH_H_
 
+#include <acos.h>
+#include <asin.h>
+#include <atan.h>
+#include <atan2.h>
 #include <ceil.h>
+#include <cosh.h>
 #include <exp.h>
+#include <fabs.h>
 #include <floor.h>
+#include <fmod.h>
+#include <frexp.h>
+#include <ldexp.h>
 #include <log.h>
+#include <log10.h>
 #include <mathtypes.h>
-#include <mod.h>
+#include <modf.h>
 #include <pow.h>
+#include <sinh.h>
+#include <sqrt.h>
+#include <tan.h>
+#include <tanh.h>
+#include <trig.h>
 #include <trunc.h>
-#include <trig.h>
+
+#define HUGE_VAL FLOAT64_INF
+
+static inline float64_t acos_f64(float64_t val)
+{
+	return float64_acos(val);
+}
+
+static inline float32_t acos_f32(float32_t val)
+{
+	return float32_acos(val);
+}
+
+static inline float64_t asin_f64(float64_t val)
+{
+	return float64_asin(val);
+}
+
+static inline float32_t asin_f32(float32_t val)
+{
+	return float32_asin(val);
+}
+
+static inline float64_t atan_f64(float64_t val)
+{
+	return float64_atan(val);
+}
+
+static inline float32_t atan_f32(float32_t val)
+{
+	return float32_atan(val);
+}
+
+static inline float64_t atan2_f64(float64_t y, float64_t x)
+{
+	return float64_atan2(y, x);
+}
+
+static inline float32_t atan2_f32(float32_t y, float32_t x)
+{
+	return float32_atan2(y, x);
+}
 
 static inline float64_t ceil_f64(float64_t val)
@@ -67,4 +123,14 @@
 }
 
+static inline float64_t cosh_f64(float64_t val)
+{
+	return float64_cosh(val);
+}
+
+static inline float32_t cosh_f32(float32_t val)
+{
+	return float32_cosh(val);
+}
+
 static inline float64_t exp_f64(float64_t val)
 {
@@ -77,4 +143,14 @@
 }
 
+static inline float64_t fabs_f64(float64_t val)
+{
+	return float64_fabs(val);
+}
+
+static inline float32_t fabs_f32(float32_t val)
+{
+	return float32_fabs(val);
+}
+
 static inline float64_t floor_f64(float64_t val)
 {
@@ -86,13 +162,32 @@
 	return float32_floor(val);
 }
-
 static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
 {
-	return float64_mod(dividend, divisor);
+	return float64_fmod(dividend, divisor);
 }
 
 static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
 {
-	return float32_mod(dividend, divisor);
+	return float32_fmod(dividend, divisor);
+}
+
+static inline float64_t frexp_f64(float64_t x, int *exp)
+{
+	return float64_frexp(x, exp);
+}
+
+static inline float64_t frexp_f32(float32_t x, int *exp)
+{
+	return float32_frexp(x, exp);
+}
+
+static inline float64_t ldexp_f64(float64_t x, int exp)
+{
+	return float64_ldexp(x, exp);
+}
+
+static inline float64_t ldexp_f32(float32_t x, int exp)
+{
+	return float32_ldexp(x, exp);
 }
 
@@ -107,4 +202,24 @@
 }
 
+static inline float64_t log10_f64(float64_t val)
+{
+	return float64_log10(val);
+}
+
+static inline float32_t log10_f32(float32_t val)
+{
+	return float32_log10(val);
+}
+
+static inline float64_t modf_f64(float64_t value, float64_t *iptr)
+{
+	return float64_modf(value, iptr);
+}
+
+static inline float64_t modf_f32(float32_t value, float32_t *iptr)
+{
+	return float32_modf(value, iptr);
+}
+
 static inline float64_t pow_f64(float64_t x, float64_t y)
 {
@@ -127,4 +242,44 @@
 }
 
+static inline float64_t sinh_f64(float64_t val)
+{
+	return float64_sinh(val);
+}
+
+static inline float32_t sinh_f32(float32_t val)
+{
+	return float32_sinh(val);
+}
+
+static inline float64_t sqrt_f64(float64_t val)
+{
+	return float64_sqrt(val);
+}
+
+static inline float32_t sqrt_f32(float32_t val)
+{
+	return float32_sqrt(val);
+}
+
+static inline float64_t tan_f64(float64_t val)
+{
+	return float64_tan(val);
+}
+
+static inline float32_t tan_f32(float32_t val)
+{
+	return float32_tan(val);
+}
+
+static inline float64_t tanh_f64(float64_t val)
+{
+	return float64_tanh(val);
+}
+
+static inline float32_t tanh_f32(float32_t val)
+{
+	return float32_tanh(val);
+}
+
 static inline float64_t trunc_f64(float64_t val)
 {
@@ -137,4 +292,44 @@
 }
 
+static inline float64_t acos(float64_t val)
+{
+	return acos_f64(val);
+}
+
+static inline float32_t acosf(float32_t val)
+{
+	return acos_f32(val);
+}
+
+static inline float64_t asin(float64_t val)
+{
+	return asin_f64(val);
+}
+
+static inline float32_t asinf(float32_t val)
+{
+	return asin_f32(val);
+}
+
+static inline float64_t atan(float64_t val)
+{
+	return atan_f64(val);
+}
+
+static inline float32_t atanf(float32_t val)
+{
+	return atan_f32(val);
+}
+
+static inline float64_t atan2(float64_t y, float64_t x)
+{
+	return atan2_f64(y, x);
+}
+
+static inline float32_t atan2f(float32_t y, float32_t x)
+{
+	return atan2_f32(y, x);
+}
+
 static inline float64_t ceil(float64_t val)
 {
@@ -157,4 +352,14 @@
 }
 
+static inline float64_t cosh(float64_t val)
+{
+	return cosh_f64(val);
+}
+
+static inline float32_t coshf(float32_t val)
+{
+	return cosh_f32(val);
+}
+
 static inline float64_t exp(float64_t val)
 {
@@ -167,4 +372,14 @@
 }
 
+static inline float64_t fabs(float64_t val)
+{
+	return fabs_f64(val);
+}
+
+static inline float32_t fabsf(float32_t val)
+{
+	return fabs_f32(val);
+}
+
 static inline float64_t floor(float64_t val)
 {
@@ -187,4 +402,24 @@
 }
 
+static inline float64_t frexp(float64_t x, int *exp)
+{
+	return frexp_f64(x, exp);
+}
+
+static inline float32_t frexpf(float32_t x, int *exp)
+{
+	return frexp_f32(x, exp);
+}
+
+static inline float64_t ldexp(float64_t x, int exp)
+{
+	return ldexp_f64(x, exp);
+}
+
+static inline float32_t ldexpf(float32_t x, int exp)
+{
+	return ldexp_f32(x, exp);
+}
+
 static inline float64_t log(float64_t val)
 {
@@ -197,4 +432,24 @@
 }
 
+static inline float64_t log10(float64_t val)
+{
+	return log10_f64(val);
+}
+
+static inline float32_t log10f(float32_t val)
+{
+	return log10_f32(val);
+}
+
+static inline float64_t modf(float64_t value, float64_t *iptr)
+{
+	return modf_f64(value, iptr);
+}
+
+static inline float32_t modff(float32_t value, float32_t *iptr)
+{
+	return modf_f32(value, iptr);
+}
+
 static inline float64_t pow(float64_t x, float64_t y)
 {
@@ -215,4 +470,44 @@
 {
 	return sin_f32(val);
+}
+
+static inline float64_t sinh(float64_t val)
+{
+	return sinh_f64(val);
+}
+
+static inline float32_t sinhf(float32_t val)
+{
+	return sinh_f32(val);
+}
+
+static inline float64_t sqrt(float64_t val)
+{
+	return sqrt_f64(val);
+}
+
+static inline float32_t sqrtf(float32_t val)
+{
+	return sqrt_f32(val);
+}
+
+static inline float64_t tan(float64_t val)
+{
+	return tan_f64(val);
+}
+
+static inline float32_t tanf(float32_t val)
+{
+	return tan_f32(val);
+}
+
+static inline float64_t tanh(float64_t val)
+{
+	return tanh_f64(val);
+}
+
+static inline float32_t tanhf(float32_t val)
+{
+	return tanh_f32(val);
 }
 
Index: uspace/lib/math/arch/sparc64/include/libarch/math.h
===================================================================
--- uspace/lib/math/arch/sparc64/include/libarch/math.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/arch/sparc64/include/libarch/math.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -37,13 +37,69 @@
 #define LIBMATH_sparc64_MATH_H_
 
+#include <acos.h>
+#include <asin.h>
+#include <atan.h>
+#include <atan2.h>
 #include <ceil.h>
+#include <cosh.h>
 #include <exp.h>
+#include <fabs.h>
 #include <floor.h>
+#include <fmod.h>
+#include <frexp.h>
+#include <ldexp.h>
 #include <log.h>
+#include <log10.h>
 #include <mathtypes.h>
-#include <mod.h>
+#include <modf.h>
 #include <pow.h>
+#include <sinh.h>
+#include <sqrt.h>
+#include <tan.h>
+#include <tanh.h>
+#include <trig.h>
 #include <trunc.h>
-#include <trig.h>
+
+#define HUGE_VAL FLOAT64_INF
+
+static inline float64_t acos_f64(float64_t val)
+{
+	return float64_acos(val);
+}
+
+static inline float32_t acos_f32(float32_t val)
+{
+	return float32_acos(val);
+}
+
+static inline float64_t asin_f64(float64_t val)
+{
+	return float64_asin(val);
+}
+
+static inline float32_t asin_f32(float32_t val)
+{
+	return float32_asin(val);
+}
+
+static inline float64_t atan_f64(float64_t val)
+{
+	return float64_atan(val);
+}
+
+static inline float32_t atan_f32(float32_t val)
+{
+	return float32_atan(val);
+}
+
+static inline float64_t atan2_f64(float64_t y, float64_t x)
+{
+	return float64_atan2(y, x);
+}
+
+static inline float32_t atan2_f32(float32_t y, float32_t x)
+{
+	return float32_atan2(y, x);
+}
 
 static inline float64_t ceil_f64(float64_t val)
@@ -67,4 +123,14 @@
 }
 
+static inline float64_t cosh_f64(float64_t val)
+{
+	return float64_cosh(val);
+}
+
+static inline float32_t cosh_f32(float32_t val)
+{
+	return float32_cosh(val);
+}
+
 static inline float64_t exp_f64(float64_t val)
 {
@@ -77,4 +143,14 @@
 }
 
+static inline float64_t fabs_f64(float64_t val)
+{
+	return float64_fabs(val);
+}
+
+static inline float32_t fabs_f32(float32_t val)
+{
+	return float32_fabs(val);
+}
+
 static inline float64_t floor_f64(float64_t val)
 {
@@ -86,13 +162,32 @@
 	return float32_floor(val);
 }
-
 static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
 {
-	return float64_mod(dividend, divisor);
+	return float64_fmod(dividend, divisor);
 }
 
 static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
 {
-	return float32_mod(dividend, divisor);
+	return float32_fmod(dividend, divisor);
+}
+
+static inline float64_t frexp_f64(float64_t x, int *exp)
+{
+	return float64_frexp(x, exp);
+}
+
+static inline float64_t frexp_f32(float32_t x, int *exp)
+{
+	return float32_frexp(x, exp);
+}
+
+static inline float64_t ldexp_f64(float64_t x, int exp)
+{
+	return float64_ldexp(x, exp);
+}
+
+static inline float64_t ldexp_f32(float32_t x, int exp)
+{
+	return float32_ldexp(x, exp);
 }
 
@@ -107,4 +202,24 @@
 }
 
+static inline float64_t log10_f64(float64_t val)
+{
+	return float64_log10(val);
+}
+
+static inline float32_t log10_f32(float32_t val)
+{
+	return float32_log10(val);
+}
+
+static inline float64_t modf_f64(float64_t value, float64_t *iptr)
+{
+	return float64_modf(value, iptr);
+}
+
+static inline float64_t modf_f32(float32_t value, float32_t *iptr)
+{
+	return float32_modf(value, iptr);
+}
+
 static inline float64_t pow_f64(float64_t x, float64_t y)
 {
@@ -127,4 +242,44 @@
 }
 
+static inline float64_t sinh_f64(float64_t val)
+{
+	return float64_sinh(val);
+}
+
+static inline float32_t sinh_f32(float32_t val)
+{
+	return float32_sinh(val);
+}
+
+static inline float64_t sqrt_f64(float64_t val)
+{
+	return float64_sqrt(val);
+}
+
+static inline float32_t sqrt_f32(float32_t val)
+{
+	return float32_sqrt(val);
+}
+
+static inline float64_t tan_f64(float64_t val)
+{
+	return float64_tan(val);
+}
+
+static inline float32_t tan_f32(float32_t val)
+{
+	return float32_tan(val);
+}
+
+static inline float64_t tanh_f64(float64_t val)
+{
+	return float64_tanh(val);
+}
+
+static inline float32_t tanh_f32(float32_t val)
+{
+	return float32_tanh(val);
+}
+
 static inline float64_t trunc_f64(float64_t val)
 {
@@ -137,4 +292,44 @@
 }
 
+static inline float64_t acos(float64_t val)
+{
+	return acos_f64(val);
+}
+
+static inline float32_t acosf(float32_t val)
+{
+	return acos_f32(val);
+}
+
+static inline float64_t asin(float64_t val)
+{
+	return asin_f64(val);
+}
+
+static inline float32_t asinf(float32_t val)
+{
+	return asin_f32(val);
+}
+
+static inline float64_t atan(float64_t val)
+{
+	return atan_f64(val);
+}
+
+static inline float32_t atanf(float32_t val)
+{
+	return atan_f32(val);
+}
+
+static inline float64_t atan2(float64_t y, float64_t x)
+{
+	return atan2_f64(y, x);
+}
+
+static inline float32_t atan2f(float32_t y, float32_t x)
+{
+	return atan2_f32(y, x);
+}
+
 static inline float64_t ceil(float64_t val)
 {
@@ -157,4 +352,14 @@
 }
 
+static inline float64_t cosh(float64_t val)
+{
+	return cosh_f64(val);
+}
+
+static inline float32_t coshf(float32_t val)
+{
+	return cosh_f32(val);
+}
+
 static inline float64_t exp(float64_t val)
 {
@@ -167,4 +372,14 @@
 }
 
+static inline float64_t fabs(float64_t val)
+{
+	return fabs_f64(val);
+}
+
+static inline float32_t fabsf(float32_t val)
+{
+	return fabs_f32(val);
+}
+
 static inline float64_t floor(float64_t val)
 {
@@ -187,4 +402,24 @@
 }
 
+static inline float64_t frexp(float64_t x, int *exp)
+{
+	return frexp_f64(x, exp);
+}
+
+static inline float32_t frexpf(float32_t x, int *exp)
+{
+	return frexp_f32(x, exp);
+}
+
+static inline float64_t ldexp(float64_t x, int exp)
+{
+	return ldexp_f64(x, exp);
+}
+
+static inline float32_t ldexpf(float32_t x, int exp)
+{
+	return ldexp_f32(x, exp);
+}
+
 static inline float64_t log(float64_t val)
 {
@@ -197,4 +432,24 @@
 }
 
+static inline float64_t log10(float64_t val)
+{
+	return log10_f64(val);
+}
+
+static inline float32_t log10f(float32_t val)
+{
+	return log10_f32(val);
+}
+
+static inline float64_t modf(float64_t value, float64_t *iptr)
+{
+	return modf_f64(value, iptr);
+}
+
+static inline float32_t modff(float32_t value, float32_t *iptr)
+{
+	return modf_f32(value, iptr);
+}
+
 static inline float64_t pow(float64_t x, float64_t y)
 {
@@ -215,4 +470,44 @@
 {
 	return sin_f32(val);
+}
+
+static inline float64_t sinh(float64_t val)
+{
+	return sinh_f64(val);
+}
+
+static inline float32_t sinhf(float32_t val)
+{
+	return sinh_f32(val);
+}
+
+static inline float64_t sqrt(float64_t val)
+{
+	return sqrt_f64(val);
+}
+
+static inline float32_t sqrtf(float32_t val)
+{
+	return sqrt_f32(val);
+}
+
+static inline float64_t tan(float64_t val)
+{
+	return tan_f64(val);
+}
+
+static inline float32_t tanf(float32_t val)
+{
+	return tan_f32(val);
+}
+
+static inline float64_t tanh(float64_t val)
+{
+	return tanh_f64(val);
+}
+
+static inline float32_t tanhf(float32_t val)
+{
+	return tanh_f32(val);
 }
 
Index: uspace/lib/math/generic/acos.c
===================================================================
--- uspace/lib/math/generic/acos.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/acos.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <acos.h>
+#include <errno.h>
+#include <math.h>
+
+/** Inverse cosine (32-bit floating point)
+ *
+ * Compute inverse cosine value.
+ *
+ * @param arg Inversecosine argument.
+ *
+ * @return Inverse cosine value.
+ *
+ */
+float32_t float32_acos(float32_t arg)
+{
+	if (arg < -1.0 || arg > 1.0) {
+		errno = EDOM;
+		return FLOAT32_NAN;
+	}
+
+	return M_PI_2 - asin_f32(arg);
+}
+
+/** Inverse cosine (64-bit floating point)
+ *
+ * Compute inverse cosine value.
+ *
+ * @param arg Inversecosine argument.
+ *
+ * @return Inverse cosine value.
+ *
+ */
+float64_t float64_acos(float64_t arg)
+{
+	if (arg < -1.0 || arg > 1.0) {
+		errno = EDOM;
+		return FLOAT64_NAN;
+	}
+
+	return M_PI_2 - asin_f64(arg);
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/asin.c
===================================================================
--- uspace/lib/math/generic/asin.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/asin.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <asin.h>
+#include <errno.h>
+#include <math.h>
+
+/** Inverse sine (32-bit floating point)
+ *
+ * Compute inverse sine value.
+ *
+ * @param arg Inverse sine argument.
+ *
+ * @return Inverse sine value.
+ *
+ */
+float32_t float32_asin(float32_t arg)
+{
+	float32_t aval;
+	
+	if (arg < -1.0 || arg > 1.0) {
+		errno = EDOM;
+		return FLOAT32_NAN;
+	}
+	
+	aval = 2.0 * atan_f32(arg / (1.0 + sqrt_f32(1.0 - arg*arg)));
+	if (arg > 0.0)
+		return aval;
+	else
+		return -aval;
+}
+
+/** Inverse sine (64-bit floating point)
+ *
+ * Compute inverse sine value.
+ *
+ * @param arg Inverse sine argument.
+ *
+ * @return Inverse sine value.
+ *
+ */
+float64_t float64_asin(float64_t arg)
+{
+	float64_t aval;
+	
+	if (arg < -1.0 || arg > 1.0) {
+		errno = EDOM;
+		return FLOAT64_NAN;
+	}
+	
+	aval = 2.0 * atan_f64(arg / (1.0 + sqrt_f64(1.0 - arg*arg)));
+	if (arg > 0.0)
+		return aval;
+	else
+		return -aval;
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/atan.c
===================================================================
--- uspace/lib/math/generic/atan.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/atan.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <atan.h>
+#include <errno.h>
+#include <math.h>
+
+#define SERIES_DEGREE_32 13
+#define SERIES_DEGREE_64 33
+
+/** Inverse tangent approximation by Euler's series (32-bit floating point)
+ *
+ * Compute the approximation of inverse tangent by a
+ * series found by Leonhard Euler (using the first SERIES_DEGREE terms).
+ *
+ * @param arg Inverse tangent argument.
+ *
+ * @return Inverse tangent value approximation.
+ *
+ */
+static float32_t series_atan_32(float32_t arg)
+{
+	float32_t sum = 0;
+	float32_t a = arg / (1.0 + arg * arg);
+	
+	/*
+	 * atan(z) = sum(n=0, +inf) [ (2^2n) * (n!)^2 / (2n + 1)! *
+	 *    z^(2n+1) / (1 + z^2)^(n+1) ]
+	 */
+	
+	for (unsigned int n = 0; n < SERIES_DEGREE_32; n++) {
+		if (n > 0) {
+			a = a * n * n;
+			a = a / (2.0 * n + 1.0) / (2.0 * n);
+		}
+		sum += a;
+		a = a * 4.0 * arg * arg / (1.0 + arg * arg);
+	}
+	
+	return sum;
+}
+
+/** Inverse tangent approximation by Euler's series (64-bit floating point)
+ *
+ * Compute the approximation of inverse tangent by a
+ * series found by Leonhard Euler (using the first SERIES_DEGREE terms).
+ *
+ * @param arg Inverse tangent argument.
+ *
+ * @return Inverse tangent value approximation.
+ *
+ */
+static float64_t series_atan_64(float64_t arg)
+{
+	float64_t sum = 0;
+	float64_t a = arg / (1.0 + arg * arg);
+	
+	/*
+	 * atan(z) = sum(n=0, +inf) [ (2^2n) * (n!)^2 / (2n + 1)! *
+	 *    z^(2n+1) / (1 + z^2)^(n+1) ]
+	 */
+	
+	for (unsigned int n = 0; n < SERIES_DEGREE_64; n++) {
+		if (n > 0) {
+			a = a * n * n;
+			a = a / (2.0 * n + 1.0) / (2.0 * n);
+		}
+		sum += a;
+		a = a * 4.0 * arg * arg / (1.0 + arg * arg);
+	}
+	
+	return sum;
+}
+
+/** Inverse tangent (32-bit floating point)
+ *
+ * Compute inverse sine value.
+ *
+ * @param arg Inverse sine argument.
+ *
+ * @return Inverse sine value.
+ *
+ */
+float32_t float32_atan(float32_t arg)
+{
+	if (arg < -1.0 || arg > 1.0)
+		return 2.0 * series_atan_32(arg / (1.0 + sqrt_f32(1.0 + arg*arg)));
+	else
+		return series_atan_32(arg);
+}
+
+/** Inverse tangent (64-bit floating point)
+ *
+ * Compute inverse sine value.
+ *
+ * @param arg Inverse sine argument.
+ *
+ * @return Inverse sine value.
+ *
+ */
+float64_t float64_atan(float64_t arg)
+{
+	if (arg < -1.0 || arg > 1.0)
+		return 2.0 * series_atan_64(arg / (1.0 + sqrt_f64(1.0 + arg*arg)));
+	else
+		return series_atan_64(arg);
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/atan2.c
===================================================================
--- uspace/lib/math/generic/atan2.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/atan2.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <atan2.h>
+#include <errno.h>
+#include <math.h>
+
+/** Inverse tangent of two variables (32-bit floating point)
+ *
+ * @param y
+ * @param x
+ *
+ * @return Inverse tangent of @a y / @a x.
+ *
+ */
+float32_t float32_atan2(float32_t y, float32_t x)
+{
+	if (x >= 0)
+		return atan_f32(y / x);
+	else if (y >= 0)
+		return M_PI - atan_f32(y / -x);
+	else
+		return -M_PI + atan_f32(y / -x);
+}
+
+/** Inverse tangent of two variables (64-bit floating point)
+ *
+ * @param y
+ * @param x
+ *
+ * @return Inverse tangent of @a y / @a x.
+ *
+ */
+float64_t float64_atan2(float64_t y, float64_t x)
+{
+	if (x >= 0)
+		return atan_f64(y / x);
+	else if (y >= 0)
+		return M_PI - atan_f64(y / -x);
+	else
+		return -M_PI + atan_f64(y / -x);
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/cosh.c
===================================================================
--- uspace/lib/math/generic/cosh.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/cosh.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <cosh.h>
+#include <math.h>
+
+/** Hyperbolic cosine (32-bit floating point)
+ *
+ * Compute hyperbolic cosine value.
+ *
+ * @param arg Hyperbolic angle
+ *
+ * @return Hyperbolic cosine.
+ *
+ */
+float32_t float32_cosh(float32_t arg)
+{
+	return (exp_f32(arg) + exp_f32(-arg)) / 2.0;
+}
+
+/** Hyperbolic cosine (64-bit floating point)
+ *
+ * Compute hyperbolic cosine value.
+ *
+ * @param arg Hyperbolic angle
+ *
+ * @return Hyperbolic cosine.
+ *
+ */
+float64_t float64_cosh(float64_t arg)
+{
+	return (exp_f64(arg) + exp_f64(-arg)) / 2.0;
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/exp.c
===================================================================
--- uspace/lib/math/generic/exp.c	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/generic/exp.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -36,5 +36,4 @@
 #include <exp.h>
 #include <math.h>
-#include <trunc.h>
 
 #define TAYLOR_DEGREE_32 13
Index: uspace/lib/math/generic/fabs.c
===================================================================
--- uspace/lib/math/generic/fabs.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/fabs.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <math.h>
+#include <fabs.h>
+
+/** Absolute value (32-bit floating point)
+ *
+ * Compute absolute value.
+ *
+ * @param arg Argument.
+ *
+ * @return Absolute value.
+ *
+ */
+float32_t float32_fabs(float32_t arg)
+{
+	if (arg < 0.0)
+		return -arg;
+	else
+		return arg;
+}
+
+/** Absolute value (64-bit floating point)
+ *
+ * Compute absolute value.
+ *
+ * @param arg Argument.
+ *
+ * @return Absolute value.
+ *
+ */
+float64_t float64_fabs(float64_t arg)
+{
+	if (arg < 0.0)
+		return -arg;
+	else
+		return arg;
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/fmod.c
===================================================================
--- uspace/lib/math/generic/fmod.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/fmod.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2014 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <fmod.h>
+#include <math.h>
+
+/** Remainder function (32-bit floating point)
+ *
+ * Calculate the modulo of dividend by divisor.
+ *
+ * This is a very basic implementation that uses
+ * division and multiplication (instead of exact
+ * arithmetics). Thus the result might be very
+ * imprecise (depending on the magnitude of the
+ * arguments).
+ *
+ * @param dividend Dividend.
+ * @param divisor  Divisor.
+ *
+ * @return Modulo.
+ *
+ */
+float32_t float32_fmod(float32_t dividend, float32_t divisor)
+{
+	// FIXME: replace with exact arithmetics
+	
+	float32_t quotient = trunc_f32(dividend / divisor);
+	
+	return (dividend - quotient * divisor);
+}
+
+/** Remainder function (64-bit floating point)
+ *
+ * Calculate the modulo of dividend by divisor.
+ *
+ * This is a very basic implementation that uses
+ * division and multiplication (instead of exact
+ * arithmetics). Thus the result might be very
+ * imprecise (depending on the magnitude of the
+ * arguments).
+ *
+ * @param dividend Dividend.
+ * @param divisor  Divisor.
+ *
+ * @return Modulo.
+ *
+ */
+float64_t float64_fmod(float64_t dividend, float64_t divisor)
+{
+	// FIXME: replace with exact arithmetics
+	
+	float64_t quotient = trunc_f64(dividend / divisor);
+	
+	return (dividend - quotient * divisor);
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/frexp.c
===================================================================
--- uspace/lib/math/generic/frexp.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/frexp.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <frexp.h>
+#include <math.h>
+
+/** Break single precision number into fraction and exponent
+ *
+ * Return f and *exp such that x = f * 2^(*exp) and f is in [0.5,1)
+ *
+ * @param x Number
+ * @param exp Place to store exponent
+ *
+ * @return f
+ *
+ */
+float32_t float32_frexp(float32_t x, int *exp)
+{
+	float32_u u;
+
+	u.val = x;
+	*exp = u.data.parts.exp - FLOAT32_BIAS;
+	u.data.parts.exp = FLOAT32_BIAS;
+
+	return u.val;
+}
+
+/** Break double precision number into fraction and exponent
+ *
+ * Return f and *exp such that x = f * 2^(*exp) and f is in [0.5,1)
+ *
+ * @param x Number
+ * @param exp Place to store exponent
+ *
+ * @return f
+ *
+ */
+float64_t float64_frexp(float64_t x, int *exp)
+{
+	float64_u u;
+
+	u.val = x;
+	*exp = u.data.parts.exp - FLOAT64_BIAS;
+	u.data.parts.exp = FLOAT64_BIAS;
+
+	return u.val;
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/ldexp.c
===================================================================
--- uspace/lib/math/generic/ldexp.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/ldexp.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <errno.h>
+#include <ldexp.h>
+#include <math.h>
+
+/** Single precision multiply by power of two
+ *
+ * Compute x * 2^exp.
+ *
+ * @param x Number
+ * @param exp Exponent
+ *
+ * @return x * 2^exp
+ *
+ */
+float32_t float32_ldexp(float32_t x, int exp)
+{
+	float32_u u;
+	int e;
+
+	u.val = x;
+	e = u.data.parts.exp + exp;
+
+	if (e < 0) {
+		/* XXX Can we return denormalized numbers? */
+		return 0.0;
+	} else if (e > FLOAT32_MAX_EXPONENT) {
+		errno = ERANGE;
+		if (e < 0)
+			return -FLOAT32_INF;
+		else
+			return FLOAT32_INF;
+	} else {
+		/* Adjust exponent */
+		u.data.parts.exp = e;
+		return u.val;
+	}
+}
+
+/** Double precision multiply by power of two
+ *
+ * Compute x * 2^exp.
+ *
+ * @param x Number
+ * @param y Exponent
+ *
+ * @return x * 2^exp
+ *
+ */
+float64_t float64_ldexp(float64_t x, int exp)
+{
+	float64_u u;
+	int e;
+
+	u.val = x;
+	e = u.data.parts.exp + exp;
+
+	if (e < 0) {
+		/* XXX Can we return denormalized numbers? */
+		return 0.0;
+	} else if (e > FLOAT64_MAX_EXPONENT) {
+		errno = ERANGE;
+		if (e < 0)
+			return -FLOAT64_INF;
+		else
+			return FLOAT64_INF;
+	} else {
+		/* Adjust exponent */
+		u.data.parts.exp = e;
+		return u.val;
+	}
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/log10.c
===================================================================
--- uspace/lib/math/generic/log10.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/log10.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <log10.h>
+#include <math.h>
+
+/** Decimal logarithm (32-bit floating point)
+ *
+ * Compute logarithm value.
+ *
+ * @param arg Logarithm argument.
+ *
+ * @return Logarithm value.
+ *
+ */
+float32_t float32_log10(float32_t arg)
+{
+	return log_f32(arg) / M_LN10;
+}
+
+/** Decimal logarithm (64-bit floating point)
+ *
+ * Compute logarithm value.
+ *
+ * @param arg Logarithm argument.
+ *
+ * @return Logarithm value.
+ *
+ */
+float64_t float64_log10(float64_t arg)
+{
+	return log_f64(arg) / M_LN10;
+}
+
+
+/** @}
+ */
Index: pace/lib/math/generic/mod.c
===================================================================
--- uspace/lib/math/generic/mod.c	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ 	(revision )
@@ -1,89 +1,0 @@
-/*
- * Copyright (c) 2014 Martin Decky
- * All rights reserved.
- *
- * Redistribution and use 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.
- * - The name of the author may not be used to endorse or promote products
- *   derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
- */
-
-/** @addtogroup libmath
- * @{
- */
-/** @file
- */
-
-#include <math.h>
-#include <mod.h>
-
-/** Remainder function (32-bit floating point)
- *
- * Calculate the modulo of dividend by divisor.
- *
- * This is a very basic implementation that uses
- * division and multiplication (instead of exact
- * arithmetics). Thus the result might be very
- * imprecise (depending on the magnitude of the
- * arguments).
- *
- * @param dividend Dividend.
- * @param divisor  Divisor.
- *
- * @return Modulo.
- *
- */
-float32_t float32_mod(float32_t dividend, float32_t divisor)
-{
-	// FIXME: replace with exact arithmetics
-	
-	float32_t quotient = trunc_f32(dividend / divisor);
-	
-	return (dividend - quotient * divisor);
-}
-
-/** Remainder function (64-bit floating point)
- *
- * Calculate the modulo of dividend by divisor.
- *
- * This is a very basic implementation that uses
- * division and multiplication (instead of exact
- * arithmetics). Thus the result might be very
- * imprecise (depending on the magnitude of the
- * arguments).
- *
- * @param dividend Dividend.
- * @param divisor  Divisor.
- *
- * @return Modulo.
- *
- */
-float64_t float64_mod(float64_t dividend, float64_t divisor)
-{
-	// FIXME: replace with exact arithmetics
-	
-	float64_t quotient = trunc_f64(dividend / divisor);
-	
-	return (dividend - quotient * divisor);
-}
-
-/** @}
- */
Index: uspace/lib/math/generic/modf.c
===================================================================
--- uspace/lib/math/generic/modf.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/modf.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <math.h>
+#include <modf.h>
+
+/** Remainder function (32-bit floating point)
+ *
+ * Calculate the modulo of dividend by divisor.
+ *
+ * This is a very basic implementation that uses
+ * division and multiplication (instead of exact
+ * arithmetics). Thus the result might be very
+ * imprecise (depending on the magnitude of the
+ * arguments).
+ *
+ * @param dividend Dividend.
+ * @param divisor  Divisor.
+ *
+ * @return Modulo.
+ *
+ */
+float32_t float32_modf(float32_t value, float32_t *iptr)
+{
+	*iptr = trunc_f32(value);
+	return value - *iptr;
+}
+
+/** Remainder function (64-bit floating point)
+ *
+ * Calculate the modulo of dividend by divisor.
+ *
+ * This is a very basic implementation that uses
+ * division and multiplication (instead of exact
+ * arithmetics). Thus the result might be very
+ * imprecise (depending on the magnitude of the
+ * arguments).
+ *
+ * @param dividend Dividend.
+ * @param divisor  Divisor.
+ *
+ * @return Modulo.
+ *
+ */
+float64_t float64_modf(float64_t value, float64_t *iptr)
+{
+	*iptr = trunc_f64(value);
+	return value - *iptr;
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/pow.c
===================================================================
--- uspace/lib/math/generic/pow.c	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/generic/pow.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -34,6 +34,4 @@
  */
 
-#include <exp.h>
-#include <log.h>
 #include <math.h>
 #include <pow.h>
Index: uspace/lib/math/generic/sinh.c
===================================================================
--- uspace/lib/math/generic/sinh.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/sinh.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <math.h>
+#include <sinh.h>
+
+/** Hyperbolic sine (32-bit floating point)
+ *
+ * Compute hyperbolic sine value.
+ *
+ * @param arg Hyperbolic angle
+ *
+ * @return Hyperbolic sine.
+ *
+ */
+float32_t float32_sinh(float32_t arg)
+{
+	return (exp_f32(arg) - exp_f32(-arg)) / 2.0;
+}
+
+/** Hyperbolic sine (64-bit floating point)
+ *
+ * Compute hyperbolic sine value.
+ *
+ * @param arg Hyperbolic angle
+ *
+ * @return Hyperbolic sine.
+ *
+ */
+float64_t float64_sinh(float64_t arg)
+{
+	return (exp_f64(arg) - exp_f64(-arg)) / 2.0;
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/sqrt.c
===================================================================
--- uspace/lib/math/generic/sqrt.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/sqrt.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <math.h>
+#include <sqrt.h>
+
+/** Single precision square root
+ *
+ * Compute square root.
+ *
+ * @param val Value
+ *
+ * @return Square root.
+ *
+ */
+float32_t float32_sqrt(float32_t val)
+{
+	return pow_f32(val, 0.5);
+}
+
+/** Double precision square root
+ *
+ * Compute squre root.
+ *
+ * @param val Value
+ *
+ * @return Square root.
+ *
+ */
+float64_t float64_sqrt(float64_t val)
+{
+	return pow_f64(val, 0.5);
+}
+
+/** @}
+ */
Index: uspace/lib/math/generic/tan.c
===================================================================
--- uspace/lib/math/generic/tan.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/tan.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <math.h>
+#include <tan.h>
+
+/** Tangent (32-bit floating point)
+ *
+ * Compute tangent value.
+ *
+ * @param arg Tangent argument.
+ *
+ * @return Tangent value.
+ *
+ */
+float32_t float32_tan(float32_t arg)
+{
+	return sin_f32(arg) / cos_f32(arg);
+}
+
+/** Sine (64-bit floating point)
+ *
+ * Compute sine value.
+ *
+ * @param arg Sine argument.
+ *
+ * @return Sine value.
+ *
+ */
+float64_t float64_tan(float64_t arg)
+{
+	return sin_f64(arg) / cos_f64(arg);
+}
+
+
+/** @}
+ */
Index: uspace/lib/math/generic/tanh.c
===================================================================
--- uspace/lib/math/generic/tanh.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/generic/tanh.c	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#include <math.h>
+#include <tanh.h>
+
+/** Hyperbolic tangent (32-bit floating point)
+ *
+ * Compute hyperbolic tangent value.
+ *
+ * @param arg Hyperbolic angle
+ *
+ * @return Hyperbolic tangent.
+ *
+ */
+float32_t float32_tanh(float32_t arg)
+{
+	float32_t em2x;
+
+	if (arg > 9.0)
+		return 1.0;
+	if (arg < -9.0)
+		return -1.0;
+
+	em2x = exp_f32(-2.0 * arg);
+	return (1.0 - em2x) / (1.0 + em2x);
+}
+
+/** Hyperbolic tangent (64-bit floating point)
+ *
+ * Compute hyperbolic tangent value.
+ *
+ * @param arg Hyperbolic angle
+ *
+ * @return Hyperbolic tangent.
+ *
+ */
+float64_t float64_tanh(float64_t arg)
+{
+	float64_t em2x;
+
+	if (arg > 19.0)
+		return 1.0;
+	if (arg < -19.0)
+		return -1.0;
+
+	em2x = exp_f64(-2.0 * arg);
+	return (1.0 - em2x) / (1.0 + em2x);
+}
+
+/** @}
+ */
Index: uspace/lib/math/include/acos.h
===================================================================
--- uspace/lib/math/include/acos.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/acos.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_ACOS_H_
+#define LIBMATH_ACOS_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_acos(float32_t);
+extern float64_t float64_acos(float64_t);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/asin.h
===================================================================
--- uspace/lib/math/include/asin.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/asin.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_ASIN_H_
+#define LIBMATH_ASIN_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_asin(float32_t);
+extern float64_t float64_asin(float64_t);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/atan.h
===================================================================
--- uspace/lib/math/include/atan.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/atan.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_ATAN_H_
+#define LIBMATH_ATAN_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_atan(float32_t);
+extern float64_t float64_atan(float64_t);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/atan2.h
===================================================================
--- uspace/lib/math/include/atan2.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/atan2.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_ATAN2_H_
+#define LIBMATH_ATAN2_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_atan2(float32_t, float32_t);
+extern float64_t float64_atan2(float64_t, float64_t);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/cosh.h
===================================================================
--- uspace/lib/math/include/cosh.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/cosh.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_COSH_H_
+#define LIBMATH_COSH_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_cosh(float32_t);
+extern float64_t float64_cosh(float64_t);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/fabs.h
===================================================================
--- uspace/lib/math/include/fabs.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/fabs.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_FABS_H_
+#define LIBMATH_FABS_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_fabs(float32_t);
+extern float64_t float64_fabs(float64_t);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/fmod.h
===================================================================
--- uspace/lib/math/include/fmod.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/fmod.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2014 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_FMOD_H_
+#define LIBMATH_FMOD_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_fmod(float32_t, float32_t);
+extern float64_t float64_fmod(float64_t, float64_t);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/frexp.h
===================================================================
--- uspace/lib/math/include/frexp.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/frexp.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_FREXP_H_
+#define LIBMATH_FREXP_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_frexp(float32_t, int *);
+extern float64_t float64_frexp(float64_t, int *);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/ldexp.h
===================================================================
--- uspace/lib/math/include/ldexp.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/ldexp.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_LDEXP_H_
+#define LIBMATH_LDEXP_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_ldexp(float32_t, int);
+extern float64_t float64_ldexp(float64_t, int);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/log10.h
===================================================================
--- uspace/lib/math/include/log10.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/log10.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_LOG10_H_
+#define LIBMATH_LOG10_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_log10(float32_t);
+extern float64_t float64_log10(float64_t);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/math.h
===================================================================
--- uspace/lib/math/include/math.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ uspace/lib/math/include/math.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -1,4 +1,5 @@
 /*
  * Copyright (c) 2011 Petr Koupy
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -38,7 +39,9 @@
 #include <libarch/math.h>
 
+#define M_LN10 2.30258509299404568402
 #define M_LN2 0.69314718055994530942
 #define M_LOG2E 1.4426950408889634074
 #define M_PI 3.14159265358979323846
+#define M_PI_2 1.57079632679489661923
 
 #endif
Index: pace/lib/math/include/mod.h
===================================================================
--- uspace/lib/math/include/mod.h	(revision ba8eecfd9bdcf09bc411bd28fd884cc399ced4f6)
+++ 	(revision )
@@ -1,44 +1,0 @@
-/*
- * Copyright (c) 2014 Martin Decky
- * All rights reserved.
- *
- * Redistribution and use 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.
- * - The name of the author may not be used to endorse or promote products
- *   derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
- */
-
-/** @addtogroup libmath
- * @{
- */
-/** @file
- */
-
-#ifndef LIBMATH_MOD_H_
-#define LIBMATH_MOD_H_
-
-extern float32_t float32_mod(float32_t, float32_t);
-extern float64_t float64_mod(float64_t, float64_t);
-
-#endif
-
-/** @}
- */
Index: uspace/lib/math/include/modf.h
===================================================================
--- uspace/lib/math/include/modf.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/modf.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_MODF_H_
+#define LIBMATH_MODF_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_modf(float32_t, float32_t *);
+extern float64_t float64_modf(float64_t, float64_t *);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/sinh.h
===================================================================
--- uspace/lib/math/include/sinh.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/sinh.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_SINH_H_
+#define LIBMATH_SINH_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_sinh(float32_t);
+extern float64_t float64_sinh(float64_t);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/sqrt.h
===================================================================
--- uspace/lib/math/include/sqrt.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/sqrt.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_SQRT_H_
+#define LIBMATH_SQRT_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_sqrt(float32_t);
+extern float64_t float64_sqrt(float64_t);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/tan.h
===================================================================
--- uspace/lib/math/include/tan.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/tan.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_TAN_H_
+#define LIBMATH_TAN_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_tan(float32_t);
+extern float64_t float64_tan(float64_t);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/math/include/tanh.h
===================================================================
--- uspace/lib/math/include/tanh.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
+++ uspace/lib/math/include/tanh.h	(revision b69786ea48147d53f94db94d13ac0d9122c0fb09)
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libmath
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBMATH_TANH_H_
+#define LIBMATH_TANH_H_
+
+#include <mathtypes.h>
+
+extern float32_t float32_tanh(float32_t);
+extern float64_t float64_tanh(float64_t);
+
+#endif
+
+/** @}
+ */
