From fc784bdb54feaf906938c9889274ac109f9811a0 Mon Sep 17 00:00:00 2001 From: Mateusz Bloch Date: Wed, 26 Jul 2023 11:39:39 +0200 Subject: [PATCH 1/2] marking elements to investigate or issue | basic tests will still be rewritten libc: add math.h tests JIRA CI-277 --- .github/workflows/ci.yml | 7 +- libc/Makefile | 8 +- libc/math/exp_power.c | 648 +++++++++++++++++++++++++++++++++++++++ libc/math/main.c | 34 ++ libc/math/trig_hyper.c | 538 ++++++++++++++++++++++++++++++++ libc/test.yaml | 5 + 6 files changed, 1236 insertions(+), 4 deletions(-) create mode 100644 libc/math/exp_power.c create mode 100644 libc/math/main.c create mode 100644 libc/math/trig_hyper.c diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index bb9b1748..c739b0a1 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -15,6 +15,7 @@ on: jobs: call-ci: uses: phoenix-rtos/phoenix-rtos-project/.github/workflows/ci-submodule.yml@master - secrets: - CI_BOT_EMAIL_USERNAME: ${{ secrets.CI_BOT_EMAIL_USERNAME }} - CI_BOT_EMAIL_PASSWORD: ${{ secrets.CI_BOT_EMAIL_PASSWORD }} + # Temporary disabled | Before merge will be uncommented + # secrets: + # CI_BOT_EMAIL_USERNAME: ${{ secrets.CI_BOT_EMAIL_USERNAME }} + # CI_BOT_EMAIL_PASSWORD: ${{ secrets.CI_BOT_EMAIL_PASSWORD }} diff --git a/libc/Makefile b/libc/Makefile index 01dd5905..6b2de505 100644 --- a/libc/Makefile +++ b/libc/Makefile @@ -11,8 +11,13 @@ NAME := test-libc-$(1) LIBC_UNIT_TESTS += test-libc-$(1) SRCS := $(wildcard $(MY_LOCAL_DIR)$(1)/*.c) $(COMMON_SRCS) DEP_LIBS := unity -LOCAL_CFLAGS := -I$(MY_LOCAL_DIR) +LOCAL_CFLAGS := -I$(MY_LOCAL_DIR) -fno-builtin LOCAL_LDFLAGS := -z stack-size=12288 $(2) + +ifeq ($(TARGET), host-generic-pc) + LOCAL_LDFLAGS += -lm +endif + include $(binary.mk) endef @@ -22,3 +27,4 @@ $(eval $(call add_test_libc,misc)) $(eval $(call add_test_libc,stdio)) $(eval $(call add_test_libc,stdlib)) $(eval $(call add_test_libc,string)) +$(eval $(call add_test_libc,math)) diff --git a/libc/math/exp_power.c b/libc/math/exp_power.c new file mode 100644 index 00000000..e9887866 --- /dev/null +++ b/libc/math/exp_power.c @@ -0,0 +1,648 @@ +/* + * Phoenix-RTOS + * + * POSIX.1-2017 standard library functions tests + * + * HEADER: + * - math.h + * + * TESTED: + * - modf(), modff(), fmod() + * - exp(), frexp(), ldexp() + * - log(), log2(), log10() + * - fabs(), pow(), sqrt() + * - ceil, floor() + * + * Copyright 2023 Phoenix Systems + * Author: Mateusz Bloch + * + * This file is part of Phoenix-RTOS. + * + * %LICENSE% + */ + +#include +#include +#include +#include +#include + +#define M_SQRT3 1.73205080756887719318 + + +TEST_GROUP(math_mod); +TEST_GROUP(math_exp); +TEST_GROUP(math_power); + + +TEST_SETUP(math_mod) +{ +} + + +TEST_TEAR_DOWN(math_mod) +{ +} + + +TEST(math_mod, modf_basic) +{ + double intd; + float intf; + + TEST_ASSERT_EQUAL_DOUBLE(0.5, modf(10.5, &intd)); + TEST_ASSERT_EQUAL_DOUBLE(10.0, intd); + + TEST_ASSERT_EQUAL_FLOAT(0.5, modff(10.5, &intf)); + TEST_ASSERT_EQUAL_FLOAT(10.0, intf); + + TEST_ASSERT_EQUAL_DOUBLE(-0.5, modf(-10.5, &intd)); + TEST_ASSERT_EQUAL_DOUBLE(-10.0, intd); + + TEST_ASSERT_EQUAL_FLOAT(-0.5, modff(-10.5, &intf)); + TEST_ASSERT_EQUAL_FLOAT(-10.0, intf); + + TEST_ASSERT_EQUAL_DOUBLE(0.000000123, modf(0.000000123, &intd)); + TEST_ASSERT_EQUAL_DOUBLE(0.0, intd); + + TEST_ASSERT_EQUAL_FLOAT(0.000000123, modff(0.000000123, &intf)); + TEST_ASSERT_EQUAL_FLOAT(0.0, intf); +} + + +TEST(math_mod, modf_zero) +{ + double intd; + float intf; + + TEST_ASSERT_EQUAL_DOUBLE(0.0, modf(0.0, &intd)); + TEST_ASSERT_EQUAL_DOUBLE(0.0, intd); + + TEST_ASSERT_EQUAL_FLOAT(0.0, modff(0.0, &intf)); + TEST_ASSERT_EQUAL_FLOAT(0.0, intf); +} + + +TEST(math_mod, modf_min_max) +{ + double intd; + float intf; + + TEST_ASSERT_EQUAL_DOUBLE(0.0, modf(DBL_MAX, &intd)); + TEST_ASSERT_EQUAL_DOUBLE(DBL_MAX, intd); + + TEST_ASSERT_EQUAL_FLOAT(0.0, modff(FLT_MAX, &intf)); + TEST_ASSERT_EQUAL_FLOAT(FLT_MAX, intf); + + TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, modf(DBL_MIN, &intd)); + TEST_ASSERT_EQUAL_DOUBLE(0.0, intd); + + TEST_ASSERT_EQUAL_FLOAT(FLT_MIN, modff(FLT_MIN, &intf)); + TEST_ASSERT_EQUAL_FLOAT(0.0, intf); +} + + +TEST(math_mod, modf_nan_inf) +{ + double intd; + float intf; + + // TEST_ASSERT_DOUBLE_IS_NAN(modf(NAN, &intd)); + // TEST_ASSERT_DOUBLE_IS_NAN(intd); + + // TEST_ASSERT_FLOAT_IS_NAN(modff(NAN, &intf)); + // TEST_ASSERT_FLOAT_IS_NAN(intf); + + TEST_ASSERT_EQUAL_DOUBLE(0.0, modf(INFINITY, &intd)); + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, intd); + + TEST_ASSERT_EQUAL_FLOAT(0.0, modff(INFINITY, &intf)); + TEST_ASSERT_EQUAL_FLOAT(INFINITY, intf); + + TEST_ASSERT_EQUAL_DOUBLE(-0.0, modf(-INFINITY, &intd)); + TEST_ASSERT_EQUAL_DOUBLE(-INFINITY, intd); + + TEST_ASSERT_EQUAL_FLOAT(-0.0, modff(-INFINITY, &intf)); + TEST_ASSERT_EQUAL_FLOAT(-INFINITY, intf); +} + + +TEST(math_mod, fmod_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(0.288872, fmod(1.523372, 1.2345)); + TEST_ASSERT_EQUAL_DOUBLE(-0.288872, fmod(-1.523372, -1.2345)); + TEST_ASSERT_EQUAL_DOUBLE(-0.288872, fmod(-1.523372, 1.2345)); + TEST_ASSERT_EQUAL_DOUBLE(0.288872, fmod(1.523372, -1.2345)); + + TEST_ASSERT_EQUAL_FLOAT(0.288872, fmodf(1.523372, 1.2345)); + TEST_ASSERT_EQUAL_FLOAT(-0.288872, fmodf(-1.523372, -1.2345)); + TEST_ASSERT_EQUAL_FLOAT(-0.288872, fmodf(-1.523372, 1.2345)); + TEST_ASSERT_EQUAL_FLOAT(0.288872, fmodf(1.523372, -1.2345)); +} + + +TEST(math_mod, fmod_zero) +{ + TEST_ASSERT_EQUAL_DOUBLE(0, fmod(0, 1)); + TEST_ASSERT_EQUAL_DOUBLE(0, fmod(-0, 1)); + + TEST_ASSERT_EQUAL_FLOAT(0, fmodf(0, 1)); + TEST_ASSERT_EQUAL_FLOAT(0, fmodf(-0, 1)); +} + + +TEST(math_mod, fmod_min_max) +{ + TEST_ASSERT_EQUAL_DOUBLE(0.0, fmod(DBL_MAX, DBL_MAX)); + TEST_ASSERT_EQUAL_DOUBLE(0.0, fmod(DBL_MIN, DBL_MIN)); + + TEST_ASSERT_EQUAL_FLOAT(0.0, fmodf(FLT_MAX, FLT_MAX)); + TEST_ASSERT_EQUAL_FLOAT(0.0, fmodf(FLT_MIN, FLT_MIN)); +} + + +TEST(math_mod, fmod_special_cond) +{ + TEST_ASSERT_DOUBLE_IS_NAN(fmod(NAN, 1)); + TEST_ASSERT_DOUBLE_IS_NAN(fmod(1, NAN)); + TEST_ASSERT_DOUBLE_IS_NAN(fmod(NAN, NAN)); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(fmod(1, 0.0)); + // TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(fmod(INFINITY, 1)); + // TEST_ASSERT_EQUAL_INT(EDOM, errno); + + TEST_ASSERT_EQUAL_DOUBLE(DBL_MAX, fmod(DBL_MAX, INFINITY)); + TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, fmod(DBL_MIN, INFINITY)); + + TEST_ASSERT_EQUAL_DOUBLE(1.0e-35, fmod(1.0e-35, 1.0e-30)); + + + TEST_ASSERT_FLOAT_IS_NAN(fmodf(NAN, 1)); + TEST_ASSERT_FLOAT_IS_NAN(fmodf(1, NAN)); + TEST_ASSERT_FLOAT_IS_NAN(fmodf(NAN, NAN)); + + errno = 0; + TEST_ASSERT_FLOAT_IS_NAN(fmodf(1, 0.0)); + // TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_FLOAT_IS_NAN(fmodf(INFINITY, 1)); + // TEST_ASSERT_EQUAL_INT(EDOM, errno); + + TEST_ASSERT_EQUAL_FLOAT(FLT_MAX, fmodf(FLT_MAX, INFINITY)); + TEST_ASSERT_EQUAL_FLOAT(FLT_MIN, fmodf(FLT_MIN, INFINITY)); + + TEST_ASSERT_EQUAL_FLOAT(1.0e-35, fmodf(1.0e-35, 1.0e-30)); +} + + +TEST_SETUP(math_exp) +{ +} + + +TEST_TEAR_DOWN(math_exp) +{ +} + + +TEST(math_exp, exp_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(1.0, exp(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, exp(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(M_E, exp(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(1 / M_E, exp(-1.0)); + + TEST_ASSERT_EQUAL_DOUBLE(M_E * M_E, exp(2.0)); +} + + +TEST(math_exp, exp_special_cond) +{ + // TEST_ASSERT_DOUBLE_IS_NAN(exp(NAN)); + + TEST_ASSERT_EQUAL_DOUBLE(1, exp(DBL_MIN)); + + TEST_ASSERT_EQUAL_DOUBLE(0, exp(-INFINITY)); + TEST_ASSERT_EQUAL_DOUBLE(0, exp(-1000.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, exp(INT_MIN)); + + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, exp(INFINITY)); + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, exp(DBL_MAX)); + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, exp(1000.0)); +} + + +TEST(math_exp, frexp_basic) +{ + int exponent; + + TEST_ASSERT_EQUAL_DOUBLE(0.0, frexp(0.0, &exponent)); + TEST_ASSERT_EQUAL_INT(0, exponent); + + TEST_ASSERT_EQUAL_DOUBLE(-0.0, frexp(-0.0, &exponent)); + TEST_ASSERT_EQUAL_INT(0, exponent); + + TEST_ASSERT_EQUAL_DOUBLE(0.5, frexp(8.0, &exponent)); + TEST_ASSERT_EQUAL_INT(4, exponent); + + TEST_ASSERT_EQUAL_DOUBLE(-0.5, frexp(-0.125, &exponent)); + TEST_ASSERT_EQUAL_INT(-2, exponent); + + TEST_ASSERT_EQUAL_DOUBLE(0.5, frexp(DBL_MIN, &exponent)); + TEST_ASSERT_EQUAL_INT(-1021, exponent); + + TEST_ASSERT_EQUAL_DOUBLE(1, frexp(DBL_MAX, &exponent)); + TEST_ASSERT_EQUAL_INT(1024, exponent); +} + + +TEST(math_exp, frexp_special_cond) +{ + // int exponent; + + // TEST_ASSERT_DOUBLE_IS_NAN(frexp(NAN, &exponent)); + + // TEST_ASSERT_EQUAL_DOUBLE(INFINITY, frexp(INFINITY, &exponent)); + // TEST_ASSERT_EQUAL_DOUBLE(-INFINITY, frexp(-INFINITY, &exponent)); +} + + +TEST(math_exp, ldexp_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(0.0, ldexp(0.0, 1)); + TEST_ASSERT_EQUAL_DOUBLE(-0.0, ldexp(-0.0, 1)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI, ldexp(M_PI, 0)); + TEST_ASSERT_EQUAL_DOUBLE(M_PI, ldexp(M_PI, -0)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI * 8, ldexp(M_PI, 3)); + TEST_ASSERT_EQUAL_DOUBLE(M_PI * 8, ldexp(M_PI, 3)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI * 0.125, ldexp(M_PI, -3)); + TEST_ASSERT_EQUAL_DOUBLE(M_PI * 0.125, ldexp(M_PI, -3)); + + TEST_ASSERT_EQUAL_DOUBLE(1024.0, ldexp(0.5, 11)); + TEST_ASSERT_EQUAL_DOUBLE(1.0 / 4096.0, ldexp(0.5, -11)); +} + + +TEST(math_exp, ldexp_special_cond) +{ + // TEST_ASSERT_DOUBLE_IS_NAN(ldexp(NAN, 1)); + + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, ldexp(INFINITY, 1)); + TEST_ASSERT_EQUAL_DOUBLE(-INFINITY, ldexp(-INFINITY, 1)); +} + + +TEST(math_exp, log_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(-HUGE_VAL, log(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(-HUGE_VAL, log(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(0, log(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(M_LN2, log(2.0)); + TEST_ASSERT_EQUAL_DOUBLE(M_LN10, log(10.0)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, log(M_E)); + + TEST_ASSERT_DOUBLE_WITHIN(1e-6, -708.396419, log(DBL_MIN)); + TEST_ASSERT_DOUBLE_WITHIN(1e-6, 709.782713, log(DBL_MAX)); +} + + +TEST(math_exp, log_special_cond) +{ + // TEST_ASSERT_DOUBLE_IS_NAN(log(NAN)); + + // TEST_ASSERT_EQUAL_DOUBLE(INFINITY, log(INFINITY)); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(log(-1.0)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(log(-INFINITY)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); +} + + +TEST(math_exp, log2_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(-HUGE_VAL, log2(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(-HUGE_VAL, log2(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(0.0, log2(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, log2(2.0)); + TEST_ASSERT_EQUAL_DOUBLE(8, log2(256)); + + TEST_ASSERT_EQUAL_DOUBLE(-1022, log2(DBL_MIN)); + TEST_ASSERT_EQUAL_DOUBLE(1024, log2(DBL_MAX)); +} + + +TEST(math_exp, log2_special_cond) +{ + // TEST_ASSERT_DOUBLE_IS_NAN(log2(NAN)); + + // TEST_ASSERT_EQUAL_DOUBLE(INFINITY, log2(INFINITY)); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(log2(-1.0)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(log2(-INFINITY)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); +} + + +TEST(math_exp, log10_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(-HUGE_VAL, log10(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(-HUGE_VAL, log10(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(0, log10(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(1, log10(10)); + TEST_ASSERT_EQUAL_DOUBLE(100, log10(1e+100)); + + TEST_ASSERT_DOUBLE_WITHIN(1e-6, -307.652656, log10(DBL_MIN)); + TEST_ASSERT_DOUBLE_WITHIN(1e-6, 308.254716, log10(DBL_MAX)); +} + + +TEST(math_exp, log10_special_cond) +{ + // TEST_ASSERT_DOUBLE_IS_NAN(log10(NAN)); + + // TEST_ASSERT_EQUAL_DOUBLE(INFINITY, log10(INFINITY)); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(log10(-1.0)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(log10(-INFINITY)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); +} + + +TEST(math_exp, fabs_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(0, fabs(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, fabs(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(1, fabs(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(1, fabs(-1.0)); + + TEST_ASSERT_EQUAL_DOUBLE(10, fabs(10)); + TEST_ASSERT_EQUAL_DOUBLE(10, fabs(-10)); + + TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, fabs(DBL_MIN)); + TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, fabs(-DBL_MIN)); + + TEST_ASSERT_EQUAL_DOUBLE(DBL_MAX, fabs(DBL_MAX)); + TEST_ASSERT_EQUAL_DOUBLE(DBL_MAX, fabs(-DBL_MAX)); + + TEST_ASSERT_EQUAL_INT(INT_MAX, fabs(INT_MAX)); + TEST_ASSERT_EQUAL_INT(INT_MAX, fabs(-INT_MAX)); +} + + +TEST(math_exp, fabs_special_cond) +{ + TEST_ASSERT_DOUBLE_IS_NAN(fabs(NAN)); + + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, fabs(-INFINITY)); + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, fabs(INFINITY)); +} + + +TEST(math_exp, ceil_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(1, ceil(1)); + + TEST_ASSERT_EQUAL_DOUBLE(123456790, ceil(123456789.123456789)); + TEST_ASSERT_EQUAL_DOUBLE(1, ceil(0.000000123456789)); + + TEST_ASSERT_EQUAL_DOUBLE(DBL_MAX, ceil(DBL_MAX)); + TEST_ASSERT_EQUAL_DOUBLE(1, ceil(DBL_MIN)); +} + + +TEST(math_exp, ceil_special_cond) +{ + TEST_ASSERT_DOUBLE_IS_NAN(ceil(NAN)); + + TEST_ASSERT_EQUAL_DOUBLE(-0, ceil(-0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, ceil(0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, ceil(INFINITY)); + TEST_ASSERT_EQUAL_DOUBLE(-INFINITY, ceil(-INFINITY)); +} + + +TEST(math_exp, floor_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(1, floor(1)); + + TEST_ASSERT_EQUAL_DOUBLE(123456789, floor(123456789.123456789)); + TEST_ASSERT_EQUAL_DOUBLE(0, floor(0.000000123456789)); + + TEST_ASSERT_EQUAL_DOUBLE(DBL_MAX, floor(DBL_MAX)); + TEST_ASSERT_EQUAL_DOUBLE(0, floor(DBL_MIN)); +} + + +TEST(math_exp, floor_special_cond) +{ + TEST_ASSERT_DOUBLE_IS_NAN(floor(NAN)); + + TEST_ASSERT_EQUAL_DOUBLE(-0, floor(-0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, floor(0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, floor(INFINITY)); + TEST_ASSERT_EQUAL_DOUBLE(-INFINITY, floor(-INFINITY)); +} + + +TEST_SETUP(math_power) +{ +} + + +TEST_TEAR_DOWN(math_power) +{ +} + + +TEST(math_power, pow_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(1, pow(2, 0)); + TEST_ASSERT_EQUAL_DOUBLE(2, pow(2, 1)); + + TEST_ASSERT_EQUAL_DOUBLE(M_SQRT2, pow(2, 0.5)); + TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3, pow(3, 0.5)); + + TEST_ASSERT_DOUBLE_WITHIN(1e+2, INT_MAX, pow(2, 31)); + // TEST_ASSERT_DOUBLE_WITHIN(1e+2, INT_MIN, pow(-2, 31)); +} + + +TEST(math_power, pow_special_cond) +{ + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(pow(-2, 0.125)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_EQUAL_DOUBLE(HUGE_VAL, pow(0, -2)); + // TEST_ASSERT_EQUAL_INT(ERANGE, errno); + + TEST_ASSERT_DOUBLE_IS_NAN(pow(NAN, 2)); + // TEST_ASSERT_DOUBLE_IS_NAN(pow(2, NAN)); + // TEST_ASSERT_DOUBLE_IS_NAN(pow(NAN, NAN)); + + TEST_ASSERT_EQUAL_DOUBLE(1.0, pow(1, DBL_MIN)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, pow(1, DBL_MAX)); + // TEST_ASSERT_EQUAL_DOUBLE(1.0, pow(1, NAN)); + + TEST_ASSERT_EQUAL_DOUBLE(1.0, pow(DBL_MIN, 0)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, pow(DBL_MAX, 0)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, pow(NAN, 0)); + + TEST_ASSERT_EQUAL_DOUBLE(1.0, pow(DBL_MIN, -0)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, pow(DBL_MAX, -0)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, pow(NAN, -0)); + + TEST_ASSERT_EQUAL_DOUBLE(0, pow(0, 2)); + TEST_ASSERT_EQUAL_DOUBLE(-0, pow(-0, 2)); + TEST_ASSERT_EQUAL_DOUBLE(0, pow(0, 3)); + TEST_ASSERT_EQUAL_DOUBLE(0, pow(-0, 3)); + + // TEST_ASSERT_EQUAL_DOUBLE(1.0, pow(-1, INFINITY)); + // TEST_ASSERT_EQUAL_DOUBLE(1.0, pow(-1, -INFINITY)); + + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, pow(0.5, -INFINITY)); + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, pow(-0.5, -INFINITY)); + + TEST_ASSERT_EQUAL_DOUBLE(0, pow(2, -INFINITY)); + TEST_ASSERT_EQUAL_DOUBLE(0, pow(2, -INFINITY)); + + TEST_ASSERT_EQUAL_DOUBLE(0, pow(0.5, INFINITY)); + TEST_ASSERT_EQUAL_DOUBLE(0, pow(-0.5, INFINITY)); + + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, pow(2, INFINITY)); + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, pow(2, INFINITY)); + + TEST_ASSERT_EQUAL_DOUBLE(-0, pow(-INFINITY, -3)); + TEST_ASSERT_EQUAL_DOUBLE(0, pow(-INFINITY, -2)); + + // TEST_ASSERT_EQUAL_DOUBLE(-INFINITY, pow(-INFINITY, 3)); + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, pow(-INFINITY, 2)); + + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, pow(INFINITY, 2)); + TEST_ASSERT_EQUAL_DOUBLE(0, pow(INFINITY, -2)); +} + + +TEST(math_power, sqrt_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(0, sqrt(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, sqrt(-0.0)); + + // TEST_ASSERT_EQUAL_DOUBLE(M_SQRT1_2, sqrt(0.5)); + // TEST_ASSERT_EQUAL_DOUBLE(1, sqrt(1.0)); + // TEST_ASSERT_EQUAL_DOUBLE(M_SQRT2, sqrt(2.0)); + // TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3, sqrt(3.0)); + + // TEST_ASSERT_EQUAL_DOUBLE(2e+10, sqrt(4.0e+20)); + // TEST_ASSERT_EQUAL_DOUBLE(2e-10, sqrt(4.0e-20)); + + // TEST_ASSERT_EQUAL_DOUBLE(1.49166814624004134866e-154, sqrt(DBL_MIN)); + // TEST_ASSERT_EQUAL_DOUBLE(1.34078079299425956110e+154, sqrt(DBL_MAX)); + + // TEST_ASSERT_EQUAL_DOUBLE(2.22275874948507748344e-162, sqrt(5.0e-324)); +} + + +TEST(math_power, sqrt_special_cond) +{ + TEST_ASSERT_DOUBLE_IS_NAN(sqrt(NAN)); + + // TEST_ASSERT_EQUAL_DOUBLE(INFINITY, sqrt(INFINITY)); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(sqrt(-INFINITY)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(sqrt(-1.0)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(sqrt(INT_MIN)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(sqrt(-DBL_MIN)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(sqrt(-DBL_MAX)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); +} + + +TEST_GROUP_RUNNER(math_mod) +{ + RUN_TEST_CASE(math_mod, modf_basic); + RUN_TEST_CASE(math_mod, modf_zero); + RUN_TEST_CASE(math_mod, modf_min_max); + RUN_TEST_CASE(math_mod, modf_nan_inf); + + RUN_TEST_CASE(math_mod, fmod_basic); + RUN_TEST_CASE(math_mod, fmod_zero); + RUN_TEST_CASE(math_mod, fmod_min_max); + RUN_TEST_CASE(math_mod, fmod_special_cond); +} + + +TEST_GROUP_RUNNER(math_exp) +{ + RUN_TEST_CASE(math_exp, exp_basic); + RUN_TEST_CASE(math_exp, exp_special_cond); + RUN_TEST_CASE(math_exp, frexp_basic); + RUN_TEST_CASE(math_exp, frexp_special_cond); + RUN_TEST_CASE(math_exp, ldexp_basic); + RUN_TEST_CASE(math_exp, ldexp_special_cond); + + RUN_TEST_CASE(math_exp, log_basic); + RUN_TEST_CASE(math_exp, log_special_cond); + RUN_TEST_CASE(math_exp, log2_basic); + RUN_TEST_CASE(math_exp, log2_special_cond); + RUN_TEST_CASE(math_exp, log10_basic); + RUN_TEST_CASE(math_exp, log10_special_cond); + + RUN_TEST_CASE(math_exp, fabs_basic); + RUN_TEST_CASE(math_exp, fabs_special_cond); + + RUN_TEST_CASE(math_exp, ceil_basic); + RUN_TEST_CASE(math_exp, ceil_special_cond); + RUN_TEST_CASE(math_exp, floor_basic); + RUN_TEST_CASE(math_exp, floor_special_cond); +} + + +TEST_GROUP_RUNNER(math_power) +{ + RUN_TEST_CASE(math_power, pow_basic); + RUN_TEST_CASE(math_power, pow_special_cond); + RUN_TEST_CASE(math_power, sqrt_basic); + RUN_TEST_CASE(math_power, sqrt_special_cond); +} diff --git a/libc/math/main.c b/libc/math/main.c new file mode 100644 index 00000000..af3d1e51 --- /dev/null +++ b/libc/math/main.c @@ -0,0 +1,34 @@ +/* + * Phoenix-RTOS + * + * test-libc-math + * + * Main entry point. + * + * Copyright 2023 Phoenix Systems + * Author: Mateusz Bloch + * + * This file is part of Phoenix-RTOS. + * + * %LICENSE% + */ + +#include "unity_fixture.h" + +/* no need for forward declarations, RUN_TEST_GROUP does it by itself */ +void runner(void) +{ + RUN_TEST_GROUP(math_mod); + RUN_TEST_GROUP(math_exp); + RUN_TEST_GROUP(math_power); + RUN_TEST_GROUP(math_trig); + RUN_TEST_GROUP(math_hyper); +} + + +int main(int argc, char *argv[]) +{ + UnityMain(argc, (const char **)argv, runner); + + return 0; +} diff --git a/libc/math/trig_hyper.c b/libc/math/trig_hyper.c new file mode 100644 index 00000000..42c046f3 --- /dev/null +++ b/libc/math/trig_hyper.c @@ -0,0 +1,538 @@ +/* + * Phoenix-RTOS + * + * POSIX.1-2017 standard library functions tests + * + * HEADER: + * - math.h + * + * TESTED: + * - tan(), atan(), tanh(), atan2() + * - sin(), asin(), sinh() + * - cos(), acos(), cosh() + * + * Copyright 2023 Phoenix Systems + * Author: Mateusz Bloch + * + * This file is part of Phoenix-RTOS. + * + * %LICENSE% + */ + +#include +#include +#include +#include +#include + + +#define M_SQRT3 1.73205080756887719318 +#define DELTA 1e-05 + + +static double dblSubnormal(void) +{ + union { + double doubleValue; + uint64_t integerValue; + } representation; + representation.integerValue = 0x000fffffffffffffULL; + return representation.doubleValue; +} + + +TEST_GROUP(math_trig); +TEST_GROUP(math_hyper); + + +TEST_SETUP(math_trig) +{ +} + + +TEST_TEAR_DOWN(math_trig) +{ +} + + +TEST(math_trig, tan_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(0, tan(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, tan(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3 / 3, tan(M_PI / 6)); + TEST_ASSERT_EQUAL_DOUBLE(-M_SQRT3 / 3, tan(-M_PI / 6)); + + TEST_ASSERT_EQUAL_DOUBLE(1, tan(M_PI_4)); + TEST_ASSERT_EQUAL_DOUBLE(-1, tan(-M_PI_4)); + + TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3, tan(M_PI / 3)); + TEST_ASSERT_EQUAL_DOUBLE(-M_SQRT3, tan(-M_PI / 3)); + + TEST_ASSERT_EQUAL_DOUBLE(1.55740772465490229237, tan(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(-1.55740772465490229237, tan(-1.0)); +} + + +TEST(math_trig, tan_huge_x) +{ + // TEST_ASSERT_EQUAL_DOUBLE(-0.37362445398759902560, tan(1.0e+6)); // Sprawdź do którego bitu ma być uwzględnione + // TEST_ASSERT_EQUAL_DOUBLE(0.37362445398759902560, tan(-1.0e+6)); // Sprawdź do którego bitu ma być uwzględnione + + TEST_ASSERT_DOUBLE_WITHIN(DELTA, 1e-06, tan(1.0e-6)); + TEST_ASSERT_DOUBLE_WITHIN(DELTA, -1e-06, tan(-1.0e-6)); + + TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, tan(DBL_MIN)); +} + +TEST(math_trig, tan_eq_sin_div_cos) +{ + TEST_ASSERT_EQUAL_DOUBLE(sin(0) / cos(0), tan(0)); + TEST_ASSERT_EQUAL_DOUBLE(sin(M_PI / 6) / cos(M_PI / 6), tan(M_PI / 6)); + TEST_ASSERT_EQUAL_DOUBLE(sin(M_PI_4) / cos(M_PI_4), tan(M_PI_4)); + TEST_ASSERT_EQUAL_DOUBLE(sin(DBL_MIN) / cos(DBL_MIN), tan(DBL_MIN)); +} + + +TEST(math_trig, tan_special_cond) +{ + TEST_ASSERT_DOUBLE_IS_NAN(tan(NAN)); + + TEST_ASSERT_EQUAL_DOUBLE(dblSubnormal(), tan(dblSubnormal())); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(tan(INFINITY)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(tan(-INFINITY)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); +} + + +TEST(math_trig, atan_basic) +{ + + TEST_ASSERT_EQUAL_DOUBLE(0, atan(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, atan(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI / 6, atan(M_SQRT3 / 3)); + TEST_ASSERT_EQUAL_DOUBLE(-M_PI / 6, atan(-M_SQRT3 / 3)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI_4, atan(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(-M_PI_4, atan(-1.0)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI / 3, atan(M_SQRT3)); + TEST_ASSERT_EQUAL_DOUBLE(-M_PI / 3, atan(-M_SQRT3)); +} + + +TEST(math_trig, atan_huge_x) +{ + TEST_ASSERT_DOUBLE_WITHIN(DELTA, M_PI / 2, atan(1.0e+6)); + TEST_ASSERT_DOUBLE_WITHIN(DELTA, -M_PI / 2, atan(-1.0e+6)); + + TEST_ASSERT_EQUAL_DOUBLE(1e-10, atan(1.0e-10)); + TEST_ASSERT_EQUAL_DOUBLE(-1e-10, atan(-1.0e-10)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, atan(DBL_MAX)); + TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, atan(DBL_MIN)); +} + + +TEST(math_trig, atan_special_cond) +{ + TEST_ASSERT_DOUBLE_IS_NAN(atan(NAN)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, atan(INFINITY)); + TEST_ASSERT_EQUAL_DOUBLE(-M_PI_2, atan(-INFINITY)); + + TEST_ASSERT_EQUAL_DOUBLE(dblSubnormal(), atan(dblSubnormal())); +} + + +TEST(math_trig, sin_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(0, sin(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, sin(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(0.5, sin(M_PI / 6)); + TEST_ASSERT_EQUAL_DOUBLE(-0.5, sin(-M_PI / 6)); + + TEST_ASSERT_EQUAL_DOUBLE(M_SQRT1_2, sin(M_PI_4)); + TEST_ASSERT_EQUAL_DOUBLE(-M_SQRT1_2, sin(-M_PI_4)); + + TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3 / 2, sin(M_PI / 3)); + TEST_ASSERT_EQUAL_DOUBLE(-M_SQRT3 / 2, sin(-M_PI / 3)); + + TEST_ASSERT_EQUAL_DOUBLE(1, sin(M_PI_2)); + TEST_ASSERT_EQUAL_DOUBLE(-1, sin(-M_PI_2)); + + TEST_ASSERT_EQUAL_DOUBLE(0.84147098480789650488, sin(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(-0.84147098480789650488, sin(-1.0)); +} + + +TEST(math_trig, sin_huge_x) +{ + // TEST_ASSERT_EQUAL_DOUBLE(-0.34999350217129293616, sin(1.0e+6)); // Sprawdź do którego bitu ma być uwzględnione + // TEST_ASSERT_EQUAL_DOUBLE(0.34999350217129293616, sin(-1.0e+6)); // Sprawdź do którego bitu ma być uwzględnione + + TEST_ASSERT_DOUBLE_WITHIN(DELTA, 1e-06, sin(1.0e-6)); + TEST_ASSERT_DOUBLE_WITHIN(DELTA, -1e-06, sin(-1.0e-6)); + + TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, sin(DBL_MIN)); +} + + +TEST(math_trig, sin_special_cond) +{ + TEST_ASSERT_DOUBLE_IS_NAN(sin(NAN)); + + TEST_ASSERT_EQUAL_DOUBLE(dblSubnormal(), sin(dblSubnormal())); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(sin(INFINITY)); + // TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(sin(-INFINITY)); + // TEST_ASSERT_EQUAL_INT(EDOM, errno); +} + + +TEST(math_trig, asin_basic) +{ + // TEST_ASSERT_EQUAL_DOUBLE(0, asin(0.0)); + // TEST_ASSERT_EQUAL_DOUBLE(0, asin(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, asin(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(-M_PI_2, asin(-1.0)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI / 6, asin(0.5)); + TEST_ASSERT_EQUAL_DOUBLE(-M_PI / 6, asin(-0.5)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI_4, asin(M_SQRT1_2)); + TEST_ASSERT_EQUAL_DOUBLE(-M_PI_4, asin(-M_SQRT1_2)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI / 3, asin(M_SQRT3 / 2)); + TEST_ASSERT_EQUAL_DOUBLE(-M_PI / 3, asin(-M_SQRT3 / 2)); +} + + +TEST(math_trig, asin_huge_x) +{ + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(asin(1.0e+6)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(asin(-1.0e+6)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + TEST_ASSERT_DOUBLE_WITHIN(DELTA, 1e-06, asin(1.0e-6)); + TEST_ASSERT_DOUBLE_WITHIN(DELTA, -1e-06, asin(-1.0e-6)); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(asin(DBL_MAX)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + // TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, asin(DBL_MIN)); +} + + +TEST(math_trig, asin_special_cond) +{ + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(asin(M_PI)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(asin(-M_PI)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + TEST_ASSERT_DOUBLE_IS_NAN(asin(NAN)); + + // TEST_ASSERT_EQUAL_DOUBLE(dblSubnormal(), asin(dblSubnormal())); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(asin(INFINITY)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(asin(-INFINITY)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); +} + + +TEST(math_trig, cos_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(1, cos(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(1, cos(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3 / 2, cos(M_PI / 6)); + TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3 / 2, cos(-M_PI / 6)); + + TEST_ASSERT_EQUAL_DOUBLE(M_SQRT1_2, cos(M_PI_4)); + TEST_ASSERT_EQUAL_DOUBLE(M_SQRT1_2, cos(-M_PI_4)); + + TEST_ASSERT_EQUAL_DOUBLE(0.5, cos(M_PI / 3)); + TEST_ASSERT_EQUAL_DOUBLE(0.5, cos(-M_PI / 3)); + + TEST_ASSERT_DOUBLE_WITHIN(DELTA, 0, cos(M_PI_2)); + TEST_ASSERT_DOUBLE_WITHIN(DELTA, 0, cos(-M_PI_2)); + + TEST_ASSERT_EQUAL_DOUBLE(0.54030230586813976501, cos(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(0.54030230586813976501, cos(-1.0)); +} + + +TEST(math_trig, cos_huge_x) +{ + // TEST_ASSERT_EQUAL_DOUBLE(0.93675212753314474057, cos(1.0e+6)); // Sprawdź do którego bitu ma być uwzględnione + // TEST_ASSERT_EQUAL_DOUBLE(0.93675212753314474057, cos(-1.0e+6)); // Sprawdź do którego bitu ma być uwzględnione + + TEST_ASSERT_DOUBLE_WITHIN(DELTA, 1, cos(1.0e-6)); + TEST_ASSERT_DOUBLE_WITHIN(DELTA, 1, cos(-1.0e-6)); + + // TEST_ASSERT_DOUBLE_WITHIN(DELTA, -0.999987, cos(DBL_MAX)); Sprwadź !!! + TEST_ASSERT_EQUAL_DOUBLE(1, cos(DBL_MIN)); +} + + +TEST(math_trig, cos_special_cond) +{ + TEST_ASSERT_DOUBLE_IS_NAN(cos(NAN)); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(cos(INFINITY)); + // TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(cos(-INFINITY)); + // TEST_ASSERT_EQUAL_INT(EDOM, errno); +} + + +TEST(math_trig, acos_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, acos(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, acos(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI / 6, acos(M_SQRT3 / 2)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI_4, acos(M_SQRT1_2)); + + TEST_ASSERT_EQUAL_DOUBLE(M_PI / 3, acos(0.5)); + + TEST_ASSERT_EQUAL_DOUBLE(0, acos(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(M_PI, acos(-1.0)); +} + + +TEST(math_trig, acos_huge_x) +{ + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(acos(1.0e+6)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(acos(-1.0e+6)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + TEST_ASSERT_DOUBLE_WITHIN(DELTA, M_PI_2, acos(1.0e-6)); + TEST_ASSERT_DOUBLE_WITHIN(DELTA, M_PI_2, acos(-1.0e-6)); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(acos(DBL_MAX)); + TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, acos(DBL_MIN)); +} + + +TEST(math_trig, acos_special_cond) +{ + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(acos(M_PI)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(acos(-M_PI)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + TEST_ASSERT_DOUBLE_IS_NAN(acos(NAN)); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(acos(INFINITY)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); + + errno = 0; + TEST_ASSERT_DOUBLE_IS_NAN(acos(-INFINITY)); + TEST_ASSERT_EQUAL_INT(EDOM, errno); +} + + +TEST_SETUP(math_hyper) +{ +} + + +TEST_TEAR_DOWN(math_hyper) +{ +} + + +TEST(math_hyper, tanh_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(0, tanh(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, tanh(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(0.761594155955764851029, tanh(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(-0.761594155955764851029, tanh(-1.0)); + + // TEST_ASSERT_EQUAL_DOUBLE(1, tanh(INT_MAX)); + // TEST_ASSERT_EQUAL_DOUBLE(-1, tanh(INT_MIN)); +} + + +TEST(math_hyper, tanh_huge_x) +{ + // TEST_ASSERT_EQUAL_DOUBLE(1, tanh(1.0e+6)); + // TEST_ASSERT_EQUAL_DOUBLE(-1, tanh(-1.0e+6)); + + // TEST_ASSERT_EQUAL_DOUBLE(1e-10, tanh(1.0e-10)); // Sprawdź do którego bitu ma być uwzględnione + // TEST_ASSERT_EQUAL_DOUBLE(-1e-10, tanh(-1.0e-10)); // Sprawdź do którego bitu ma być uwzględnione + + // TEST_ASSERT_EQUAL_DOUBLE(1, tanh(DBL_MAX)); + // TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, tanh(DBL_MIN)); +} + + +TEST(math_hyper, tanh_special_cond) +{ + // TEST_ASSERT_EQUAL_DOUBLE(NAN, tanh(NAN)); IMX, ZYNQ-QEMU + + // TEST_ASSERT_EQUAL_DOUBLE(1, tanh(INFINITY)); + // TEST_ASSERT_EQUAL_DOUBLE(-1, tanh(-INFINITY)); + + // TEST_ASSERT_EQUAL_DOUBLE(dblSubnormal(), tanh(dblSubnormal())); +} + + +TEST(math_hyper, sinh_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(0, sinh(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, sinh(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(1.17520119364380137839, sinh(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(-1.17520119364380137839, sinh(-1.0)); + + TEST_ASSERT_EQUAL_DOUBLE(11.5487393572577463630, sinh(M_PI)); + TEST_ASSERT_EQUAL_DOUBLE(-11.5487393572577463630, sinh(-M_PI)); +} + + +TEST(math_hyper, sinh_huge_x) +{ + TEST_ASSERT_EQUAL_DOUBLE(HUGE_VAL, sinh(1.0e+6)); + TEST_ASSERT_EQUAL_DOUBLE(-HUGE_VAL, sinh(-1.0e+6)); + + TEST_ASSERT_DOUBLE_WITHIN(DELTA, 1e-06, sinh(1.0e-6)); + TEST_ASSERT_DOUBLE_WITHIN(DELTA, -1e-06, sinh(-1.0e-6)); + + + // TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, sinh(DBL_MIN)); + TEST_ASSERT_EQUAL_DOUBLE(HUGE_VAL, sinh(DBL_MAX)); +} + + +TEST(math_hyper, sinh_special_cond) +{ + // TEST_ASSERT_DOUBLE_IS_NAN(sinh(NAN)); + + // TEST_ASSERT_EQUAL_DOUBLE(dblSubnormal(), sinh(dblSubnormal())); + + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, sinh(INFINITY)); + + TEST_ASSERT_EQUAL_DOUBLE(-INFINITY, sinh(-INFINITY)); +} + + +TEST(math_hyper, cosh_basic) +{ + TEST_ASSERT_EQUAL_DOUBLE(1.0, cosh(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, cosh(-0.0)); + + TEST_ASSERT_EQUAL_DOUBLE(1.54308063481524371241, cosh(1.0)); + TEST_ASSERT_EQUAL_DOUBLE(1.54308063481524371241, cosh(-1.0)); + + TEST_ASSERT_EQUAL_DOUBLE(11.5919532755215186626, cosh(M_PI)); + TEST_ASSERT_EQUAL_DOUBLE(11.5919532755215186626, cosh(-M_PI)); +} + + +TEST(math_hyper, cosh_huge_x) +{ + TEST_ASSERT_EQUAL_DOUBLE(HUGE_VAL, cosh(1.0e+6)); + TEST_ASSERT_EQUAL_DOUBLE(HUGE_VAL, cosh(-1.0e+6)); + + TEST_ASSERT_EQUAL_DOUBLE(1, cosh(1.0e-6)); + TEST_ASSERT_EQUAL_DOUBLE(1, cosh(-1.0e-6)); + + TEST_ASSERT_EQUAL_DOUBLE(1, cosh(DBL_MIN)); + TEST_ASSERT_EQUAL_DOUBLE(HUGE_VAL, cosh(DBL_MAX)); +} + + +TEST(math_hyper, cosh_special_cond) +{ + // TEST_ASSERT_DOUBLE_IS_NAN(cosh(NAN)); + + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, cosh(INFINITY)); + + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, cosh(-INFINITY)); +} + + +TEST_GROUP_RUNNER(math_trig) +{ + RUN_TEST_CASE(math_trig, tan_basic); + RUN_TEST_CASE(math_trig, tan_huge_x); + RUN_TEST_CASE(math_trig, tan_eq_sin_div_cos); + RUN_TEST_CASE(math_trig, tan_special_cond); + + RUN_TEST_CASE(math_trig, atan_basic); + RUN_TEST_CASE(math_trig, atan_huge_x); + RUN_TEST_CASE(math_trig, atan_special_cond); + + RUN_TEST_CASE(math_trig, sin_basic); + RUN_TEST_CASE(math_trig, sin_huge_x); + RUN_TEST_CASE(math_trig, sin_special_cond); + + RUN_TEST_CASE(math_trig, asin_basic); + RUN_TEST_CASE(math_trig, asin_huge_x); + RUN_TEST_CASE(math_trig, asin_special_cond); + + RUN_TEST_CASE(math_trig, cos_basic); + RUN_TEST_CASE(math_trig, cos_huge_x); + RUN_TEST_CASE(math_trig, cos_special_cond); + + RUN_TEST_CASE(math_trig, acos_basic); + RUN_TEST_CASE(math_trig, acos_huge_x); + RUN_TEST_CASE(math_trig, acos_special_cond); +} + + +TEST_GROUP_RUNNER(math_hyper) +{ + RUN_TEST_CASE(math_hyper, tanh_basic); + RUN_TEST_CASE(math_hyper, tanh_huge_x); + RUN_TEST_CASE(math_hyper, tanh_special_cond); + + RUN_TEST_CASE(math_hyper, sinh_basic); + RUN_TEST_CASE(math_hyper, sinh_huge_x); + RUN_TEST_CASE(math_hyper, sinh_special_cond); + + RUN_TEST_CASE(math_hyper, cosh_basic); + RUN_TEST_CASE(math_hyper, cosh_huge_x); + RUN_TEST_CASE(math_hyper, cosh_special_cond); +} diff --git a/libc/test.yaml b/libc/test.yaml index 32cbe4bf..e538014c 100644 --- a/libc/test.yaml +++ b/libc/test.yaml @@ -39,3 +39,8 @@ test: execute: test-libc-string targets: include: [host-generic-pc] + + - name: math + execute: test-libc-math + targets: + include: [host-generic-pc] From 48ae7f81f01c8ebc34805e03fe63a18731e19e0f Mon Sep 17 00:00:00 2001 From: Mateusz Bloch Date: Fri, 28 Jul 2023 13:08:21 +0200 Subject: [PATCH 2/2] change trig_hyper basic tests --- libc/math/trig_hyper.c | 236 ++++++++++++++++++++++------------------- 1 file changed, 127 insertions(+), 109 deletions(-) diff --git a/libc/math/trig_hyper.c b/libc/math/trig_hyper.c index 42c046f3..f53499fc 100644 --- a/libc/math/trig_hyper.c +++ b/libc/math/trig_hyper.c @@ -57,20 +57,18 @@ TEST_TEAR_DOWN(math_trig) TEST(math_trig, tan_basic) { - TEST_ASSERT_EQUAL_DOUBLE(0, tan(0.0)); - TEST_ASSERT_EQUAL_DOUBLE(0, tan(-0.0)); - - TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3 / 3, tan(M_PI / 6)); - TEST_ASSERT_EQUAL_DOUBLE(-M_SQRT3 / 3, tan(-M_PI / 6)); - - TEST_ASSERT_EQUAL_DOUBLE(1, tan(M_PI_4)); - TEST_ASSERT_EQUAL_DOUBLE(-1, tan(-M_PI_4)); - - TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3, tan(M_PI / 3)); - TEST_ASSERT_EQUAL_DOUBLE(-M_SQRT3, tan(-M_PI / 3)); + int i; + int iterates = 2000; + double start = -DBL_MAX; + double end = DBL_MAX; + double step = (end - start) / (iterates - 1); + double x, y; - TEST_ASSERT_EQUAL_DOUBLE(1.55740772465490229237, tan(1.0)); - TEST_ASSERT_EQUAL_DOUBLE(-1.55740772465490229237, tan(-1.0)); + for (i = 0; i <= iterates; i++) { + x = start + i * step; + y = tan(x / 2.0); + TEST_ASSERT_EQUAL_DOUBLE(tan(x), (2.0 * y) / (1.0 + y * y)); + } } @@ -85,19 +83,14 @@ TEST(math_trig, tan_huge_x) TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, tan(DBL_MIN)); } -TEST(math_trig, tan_eq_sin_div_cos) -{ - TEST_ASSERT_EQUAL_DOUBLE(sin(0) / cos(0), tan(0)); - TEST_ASSERT_EQUAL_DOUBLE(sin(M_PI / 6) / cos(M_PI / 6), tan(M_PI / 6)); - TEST_ASSERT_EQUAL_DOUBLE(sin(M_PI_4) / cos(M_PI_4), tan(M_PI_4)); - TEST_ASSERT_EQUAL_DOUBLE(sin(DBL_MIN) / cos(DBL_MIN), tan(DBL_MIN)); -} - TEST(math_trig, tan_special_cond) { TEST_ASSERT_DOUBLE_IS_NAN(tan(NAN)); + TEST_ASSERT_EQUAL_DOUBLE(0, tan(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, tan(-0.0)); + TEST_ASSERT_EQUAL_DOUBLE(dblSubnormal(), tan(dblSubnormal())); errno = 0; @@ -112,18 +105,17 @@ TEST(math_trig, tan_special_cond) TEST(math_trig, atan_basic) { + int i; + int iterates = 2000; + double start = -1.0; + double end = 1.0; + double step = (end - start) / (iterates - 1); + double x; - TEST_ASSERT_EQUAL_DOUBLE(0, atan(0.0)); - TEST_ASSERT_EQUAL_DOUBLE(0, atan(-0.0)); - - TEST_ASSERT_EQUAL_DOUBLE(M_PI / 6, atan(M_SQRT3 / 3)); - TEST_ASSERT_EQUAL_DOUBLE(-M_PI / 6, atan(-M_SQRT3 / 3)); - - TEST_ASSERT_EQUAL_DOUBLE(M_PI_4, atan(1.0)); - TEST_ASSERT_EQUAL_DOUBLE(-M_PI_4, atan(-1.0)); - - TEST_ASSERT_EQUAL_DOUBLE(M_PI / 3, atan(M_SQRT3)); - TEST_ASSERT_EQUAL_DOUBLE(-M_PI / 3, atan(-M_SQRT3)); + for (i = 0; i <= iterates; i++) { + x = start + i * step; + TEST_ASSERT_EQUAL_DOUBLE(x, tan(atan(x))); + } } @@ -144,6 +136,9 @@ TEST(math_trig, atan_special_cond) { TEST_ASSERT_DOUBLE_IS_NAN(atan(NAN)); + TEST_ASSERT_EQUAL_DOUBLE(0, atan(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, atan(-0.0)); + TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, atan(INFINITY)); TEST_ASSERT_EQUAL_DOUBLE(-M_PI_2, atan(-INFINITY)); @@ -153,23 +148,18 @@ TEST(math_trig, atan_special_cond) TEST(math_trig, sin_basic) { - TEST_ASSERT_EQUAL_DOUBLE(0, sin(0.0)); - TEST_ASSERT_EQUAL_DOUBLE(0, sin(-0.0)); - - TEST_ASSERT_EQUAL_DOUBLE(0.5, sin(M_PI / 6)); - TEST_ASSERT_EQUAL_DOUBLE(-0.5, sin(-M_PI / 6)); - - TEST_ASSERT_EQUAL_DOUBLE(M_SQRT1_2, sin(M_PI_4)); - TEST_ASSERT_EQUAL_DOUBLE(-M_SQRT1_2, sin(-M_PI_4)); - - TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3 / 2, sin(M_PI / 3)); - TEST_ASSERT_EQUAL_DOUBLE(-M_SQRT3 / 2, sin(-M_PI / 3)); - - TEST_ASSERT_EQUAL_DOUBLE(1, sin(M_PI_2)); - TEST_ASSERT_EQUAL_DOUBLE(-1, sin(-M_PI_2)); + int i; + int iterates = 2000; + double start = -DBL_MAX; + double end = DBL_MAX; + double step = (end - start) / (iterates - 1); + double x, y; - TEST_ASSERT_EQUAL_DOUBLE(0.84147098480789650488, sin(1.0)); - TEST_ASSERT_EQUAL_DOUBLE(-0.84147098480789650488, sin(-1.0)); + for (i = 0; i <= iterates; i++) { + x = start + i * step; + y = sinh(x / 3.0); + TEST_ASSERT_EQUAL_DOUBLE(sinh(x), (3.0 * y) + (4.0 * y * y * y)); + } } @@ -189,6 +179,9 @@ TEST(math_trig, sin_special_cond) { TEST_ASSERT_DOUBLE_IS_NAN(sin(NAN)); + TEST_ASSERT_EQUAL_DOUBLE(0, sin(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, sin(-0.0)); + TEST_ASSERT_EQUAL_DOUBLE(dblSubnormal(), sin(dblSubnormal())); errno = 0; @@ -203,20 +196,17 @@ TEST(math_trig, sin_special_cond) TEST(math_trig, asin_basic) { - // TEST_ASSERT_EQUAL_DOUBLE(0, asin(0.0)); - // TEST_ASSERT_EQUAL_DOUBLE(0, asin(-0.0)); + int i; + int iterates = 2000; + double start = -0.99; + double end = 0.99; + double step = (end - start) / (iterates - 1); + double x; - TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, asin(1.0)); - TEST_ASSERT_EQUAL_DOUBLE(-M_PI_2, asin(-1.0)); - - TEST_ASSERT_EQUAL_DOUBLE(M_PI / 6, asin(0.5)); - TEST_ASSERT_EQUAL_DOUBLE(-M_PI / 6, asin(-0.5)); - - TEST_ASSERT_EQUAL_DOUBLE(M_PI_4, asin(M_SQRT1_2)); - TEST_ASSERT_EQUAL_DOUBLE(-M_PI_4, asin(-M_SQRT1_2)); - - TEST_ASSERT_EQUAL_DOUBLE(M_PI / 3, asin(M_SQRT3 / 2)); - TEST_ASSERT_EQUAL_DOUBLE(-M_PI / 3, asin(-M_SQRT3 / 2)); + for (i = 0; i <= iterates; i++) { + x = start + i * step; + TEST_ASSERT_EQUAL_DOUBLE(x, sin(asin(x))); + } } @@ -253,6 +243,9 @@ TEST(math_trig, asin_special_cond) TEST_ASSERT_DOUBLE_IS_NAN(asin(NAN)); + // TEST_ASSERT_EQUAL_DOUBLE(0, asin(0.0)); + // TEST_ASSERT_EQUAL_DOUBLE(0, asin(-0.0)); + // TEST_ASSERT_EQUAL_DOUBLE(dblSubnormal(), asin(dblSubnormal())); errno = 0; @@ -267,23 +260,18 @@ TEST(math_trig, asin_special_cond) TEST(math_trig, cos_basic) { - TEST_ASSERT_EQUAL_DOUBLE(1, cos(0.0)); - TEST_ASSERT_EQUAL_DOUBLE(1, cos(-0.0)); - - TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3 / 2, cos(M_PI / 6)); - TEST_ASSERT_EQUAL_DOUBLE(M_SQRT3 / 2, cos(-M_PI / 6)); + int i; + int iterates = 2000; + double start = -DBL_MAX; + double end = DBL_MAX; + double step = (end - start) / (iterates - 1); + double x, y; - TEST_ASSERT_EQUAL_DOUBLE(M_SQRT1_2, cos(M_PI_4)); - TEST_ASSERT_EQUAL_DOUBLE(M_SQRT1_2, cos(-M_PI_4)); - - TEST_ASSERT_EQUAL_DOUBLE(0.5, cos(M_PI / 3)); - TEST_ASSERT_EQUAL_DOUBLE(0.5, cos(-M_PI / 3)); - - TEST_ASSERT_DOUBLE_WITHIN(DELTA, 0, cos(M_PI_2)); - TEST_ASSERT_DOUBLE_WITHIN(DELTA, 0, cos(-M_PI_2)); - - TEST_ASSERT_EQUAL_DOUBLE(0.54030230586813976501, cos(1.0)); - TEST_ASSERT_EQUAL_DOUBLE(0.54030230586813976501, cos(-1.0)); + for (i = 0; i <= iterates; i++) { + x = start + i * step; + y = cos(x / 2.0); + TEST_ASSERT_EQUAL_DOUBLE(cos(x), ((2.0 * y * y) - 1.0)); + } } @@ -304,6 +292,9 @@ TEST(math_trig, cos_special_cond) { TEST_ASSERT_DOUBLE_IS_NAN(cos(NAN)); + TEST_ASSERT_EQUAL_DOUBLE(1, cos(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(1, cos(-0.0)); + errno = 0; TEST_ASSERT_DOUBLE_IS_NAN(cos(INFINITY)); // TEST_ASSERT_EQUAL_INT(EDOM, errno); @@ -316,17 +307,17 @@ TEST(math_trig, cos_special_cond) TEST(math_trig, acos_basic) { - TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, acos(0.0)); - TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, acos(-0.0)); - - TEST_ASSERT_EQUAL_DOUBLE(M_PI / 6, acos(M_SQRT3 / 2)); - - TEST_ASSERT_EQUAL_DOUBLE(M_PI_4, acos(M_SQRT1_2)); + int i; + int iterates = 2000; + double start = -0.99; + double end = 0.99; + double step = (end - start) / (iterates - 1); + double x; - TEST_ASSERT_EQUAL_DOUBLE(M_PI / 3, acos(0.5)); - - TEST_ASSERT_EQUAL_DOUBLE(0, acos(1.0)); - TEST_ASSERT_EQUAL_DOUBLE(M_PI, acos(-1.0)); + for (i = 0; i <= iterates; i++) { + x = start + i * step; + TEST_ASSERT_EQUAL_DOUBLE(x, cos(acos(x))); + } } @@ -340,6 +331,10 @@ TEST(math_trig, acos_huge_x) TEST_ASSERT_DOUBLE_IS_NAN(acos(-1.0e+6)); TEST_ASSERT_EQUAL_INT(EDOM, errno); + TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, acos(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(M_PI_2, acos(-0.0)); + + TEST_ASSERT_DOUBLE_WITHIN(DELTA, M_PI_2, acos(1.0e-6)); TEST_ASSERT_DOUBLE_WITHIN(DELTA, M_PI_2, acos(-1.0e-6)); @@ -383,14 +378,18 @@ TEST_TEAR_DOWN(math_hyper) TEST(math_hyper, tanh_basic) { - TEST_ASSERT_EQUAL_DOUBLE(0, tanh(0.0)); - TEST_ASSERT_EQUAL_DOUBLE(0, tanh(-0.0)); + int i; + int iterates = 2000; + double start = -DBL_MAX; + double end = DBL_MAX; + double step = (end - start) / (iterates - 1); + double x, y; - TEST_ASSERT_EQUAL_DOUBLE(0.761594155955764851029, tanh(1.0)); - TEST_ASSERT_EQUAL_DOUBLE(-0.761594155955764851029, tanh(-1.0)); - - // TEST_ASSERT_EQUAL_DOUBLE(1, tanh(INT_MAX)); - // TEST_ASSERT_EQUAL_DOUBLE(-1, tanh(INT_MIN)); + for (i = 0; i <= iterates; i++) { + x = start + i * step; + y = tanh(x / 2.0); + TEST_ASSERT_EQUAL_DOUBLE(tanh(x), (2.0 * y) / (1.0 + y * y)); + } } @@ -402,6 +401,9 @@ TEST(math_hyper, tanh_huge_x) // TEST_ASSERT_EQUAL_DOUBLE(1e-10, tanh(1.0e-10)); // Sprawdź do którego bitu ma być uwzględnione // TEST_ASSERT_EQUAL_DOUBLE(-1e-10, tanh(-1.0e-10)); // Sprawdź do którego bitu ma być uwzględnione + // TEST_ASSERT_EQUAL_DOUBLE(1, tanh(INT_MAX)); + // TEST_ASSERT_EQUAL_DOUBLE(-1, tanh(INT_MIN)); + // TEST_ASSERT_EQUAL_DOUBLE(1, tanh(DBL_MAX)); // TEST_ASSERT_EQUAL_DOUBLE(DBL_MIN, tanh(DBL_MIN)); } @@ -411,6 +413,9 @@ TEST(math_hyper, tanh_special_cond) { // TEST_ASSERT_EQUAL_DOUBLE(NAN, tanh(NAN)); IMX, ZYNQ-QEMU + TEST_ASSERT_EQUAL_DOUBLE(0, tanh(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, tanh(-0.0)); + // TEST_ASSERT_EQUAL_DOUBLE(1, tanh(INFINITY)); // TEST_ASSERT_EQUAL_DOUBLE(-1, tanh(-INFINITY)); @@ -420,14 +425,18 @@ TEST(math_hyper, tanh_special_cond) TEST(math_hyper, sinh_basic) { - TEST_ASSERT_EQUAL_DOUBLE(0, sinh(0.0)); - TEST_ASSERT_EQUAL_DOUBLE(0, sinh(-0.0)); - - TEST_ASSERT_EQUAL_DOUBLE(1.17520119364380137839, sinh(1.0)); - TEST_ASSERT_EQUAL_DOUBLE(-1.17520119364380137839, sinh(-1.0)); + int i; + int iterates = 2000; + double start = -DBL_MAX; + double end = DBL_MAX; + double step = (end - start) / (iterates - 1); + double x, y; - TEST_ASSERT_EQUAL_DOUBLE(11.5487393572577463630, sinh(M_PI)); - TEST_ASSERT_EQUAL_DOUBLE(-11.5487393572577463630, sinh(-M_PI)); + for (i = 0; i <= iterates; i++) { + x = start + i * step; + y = sinh(x / 3.0); + TEST_ASSERT_EQUAL_DOUBLE(sinh(x), (3.0 * y) + (4.0 * y * y * y)); + } } @@ -449,6 +458,9 @@ TEST(math_hyper, sinh_special_cond) { // TEST_ASSERT_DOUBLE_IS_NAN(sinh(NAN)); + TEST_ASSERT_EQUAL_DOUBLE(0, sinh(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0, sinh(-0.0)); + // TEST_ASSERT_EQUAL_DOUBLE(dblSubnormal(), sinh(dblSubnormal())); TEST_ASSERT_EQUAL_DOUBLE(INFINITY, sinh(INFINITY)); @@ -459,14 +471,18 @@ TEST(math_hyper, sinh_special_cond) TEST(math_hyper, cosh_basic) { - TEST_ASSERT_EQUAL_DOUBLE(1.0, cosh(0.0)); - TEST_ASSERT_EQUAL_DOUBLE(1.0, cosh(-0.0)); + int i; + int iterates = 2000; + double start = -DBL_MAX; + double end = DBL_MAX; + double step = (end - start) / (iterates - 1); + double x, y; - TEST_ASSERT_EQUAL_DOUBLE(1.54308063481524371241, cosh(1.0)); - TEST_ASSERT_EQUAL_DOUBLE(1.54308063481524371241, cosh(-1.0)); - - TEST_ASSERT_EQUAL_DOUBLE(11.5919532755215186626, cosh(M_PI)); - TEST_ASSERT_EQUAL_DOUBLE(11.5919532755215186626, cosh(-M_PI)); + for (i = 0; i <= iterates; i++) { + x = start + i * step; + y = cosh(x / 2.0); + TEST_ASSERT_EQUAL_DOUBLE(cosh(x), ((2.0 * y * y) - 1.0)); + } } @@ -487,6 +503,9 @@ TEST(math_hyper, cosh_special_cond) { // TEST_ASSERT_DOUBLE_IS_NAN(cosh(NAN)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, cosh(0.0)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, cosh(-0.0)); + TEST_ASSERT_EQUAL_DOUBLE(INFINITY, cosh(INFINITY)); TEST_ASSERT_EQUAL_DOUBLE(INFINITY, cosh(-INFINITY)); @@ -497,7 +516,6 @@ TEST_GROUP_RUNNER(math_trig) { RUN_TEST_CASE(math_trig, tan_basic); RUN_TEST_CASE(math_trig, tan_huge_x); - RUN_TEST_CASE(math_trig, tan_eq_sin_div_cos); RUN_TEST_CASE(math_trig, tan_special_cond); RUN_TEST_CASE(math_trig, atan_basic);