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 +#include +#include +#include #include +#include #include +#include #include +#include +#include +#include #include +#include #include -#include +#include #include +#include +#include +#include +#include +#include #include -#include + +#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 +#include +#include +#include #include +#include #include +#include #include +#include +#include +#include #include +#include #include -#include +#include #include +#include +#include +#include +#include +#include #include -#include + +#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 +#include +#include +#include #include +#include #include +#include #include +#include +#include +#include #include +#include #include -#include +#include #include +#include +#include +#include +#include +#include #include -#include + +#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 +#include +#include +#include #include +#include #include +#include #include +#include +#include +#include #include +#include #include -#include +#include #include +#include +#include +#include +#include +#include #include -#include + +#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 +#include +#include +#include #include +#include #include +#include #include +#include +#include +#include #include +#include #include -#include +#include #include +#include +#include +#include +#include +#include #include -#include + +#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 +#include +#include +#include #include +#include #include +#include #include +#include +#include +#include #include +#include #include -#include +#include #include +#include +#include +#include +#include +#include #include -#include + +#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 +#include +#include +#include #include +#include #include +#include #include +#include +#include +#include #include +#include #include -#include +#include #include +#include +#include +#include +#include +#include #include -#include + +#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 +#include +#include +#include #include +#include #include +#include #include +#include +#include +#include #include +#include #include -#include +#include #include +#include +#include +#include +#include +#include #include -#include + +#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 +#include +#include +#include #include +#include #include +#include #include +#include +#include +#include #include +#include #include -#include +#include #include +#include +#include +#include +#include +#include #include -#include + +#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 +#include +#include +#include #include +#include #include +#include #include +#include +#include +#include #include +#include #include -#include +#include #include +#include +#include +#include +#include +#include #include -#include + +#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 +#include +#include + +/** 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 +#include +#include + +/** 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 +#include +#include + +#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 +#include +#include + +/** 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 +#include + +/** 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 #include -#include #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 +#include + +/** 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 +#include + +/** 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 +#include + +/** 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 +#include +#include + +/** 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 +#include + +/** 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: uspace/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 -#include - -/** 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 +#include + +/** 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 -#include #include #include 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 +#include + +/** 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 +#include + +/** 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 +#include + +/** 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 +#include + +/** 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 + +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 + +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 + +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 + +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 + +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 + +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 + +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 + +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 + +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 + +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 +#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: uspace/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 + +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 + +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 + +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 + +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 + +extern float32_t float32_tanh(float32_t); +extern float64_t float64_tanh(float64_t); + +#endif + +/** @} + */