Index: uspace/lib/c/include/errno.h =================================================================== --- uspace/lib/c/include/errno.h (revision 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/c/include/errno.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/Makefile (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/arch/abs32le/include/libarch/math.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/arch/amd64/include/libarch/math.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/arch/arm32/include/libarch/math.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/arch/ia32/include/libarch/math.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/arch/ia64/include/libarch/math.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/arch/mips32/include/libarch/math.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/arch/mips32eb/include/libarch/math.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/arch/ppc32/include/libarch/math.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/arch/sparc32/include/libarch/math.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/arch/sparc64/include/libarch/math.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/acos.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/asin.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/atan.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/atan2.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/cosh.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/generic/exp.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/fabs.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/fmod.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/frexp.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/ldexp.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/log10.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ (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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/modf.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/generic/pow.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -34,6 +34,4 @@ */ -#include -#include #include #include Index: uspace/lib/math/generic/sinh.c =================================================================== --- uspace/lib/math/generic/sinh.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/sinh.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/sqrt.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/tan.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/generic/tanh.c (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/acos.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/asin.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/atan.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/atan2.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/cosh.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/fabs.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/fmod.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/frexp.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/ldexp.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/log10.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ uspace/lib/math/include/math.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9adb61d80bc69044524f4944f7690ac8768a30e0) +++ (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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/modf.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/sinh.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/sqrt.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/tan.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) +++ uspace/lib/math/include/tanh.h (revision 9308dbadbc0cbb2bac23b198dd31abc15ef9c2d1) @@ -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 + +/** @} + */