diff --git a/basic-geometry-test/basic-geometry-test.cbp b/basic-geometry-test/basic-geometry-test.cbp index 6a52f6a..0141096 100644 --- a/basic-geometry-test/basic-geometry-test.cbp +++ b/basic-geometry-test/basic-geometry-test.cbp @@ -49,6 +49,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/basic-geometry-test/basic-geometry-test.vcxproj b/basic-geometry-test/basic-geometry-test.vcxproj index 2895814..d89a31e 100644 --- a/basic-geometry-test/basic-geometry-test.vcxproj +++ b/basic-geometry-test/basic-geometry-test.vcxproj @@ -150,6 +150,14 @@ + + + + + + + + @@ -190,6 +198,14 @@ + + + + + + + + diff --git a/basic-geometry-test/basic-geometry-test.vcxproj.filters b/basic-geometry-test/basic-geometry-test.vcxproj.filters index a91ee1d..eb13dc2 100644 --- a/basic-geometry-test/basic-geometry-test.vcxproj.filters +++ b/basic-geometry-test/basic-geometry-test.vcxproj.filters @@ -114,6 +114,30 @@ tests\quaternion + + tests\complex + + + tests\complex + + + tests\complex + + + tests\complex + + + tests\complex + + + tests\complex + + + tests\complex + + + tests + @@ -228,6 +252,30 @@ tests\quaternion + + tests\complex + + + tests\complex + + + tests\complex + + + tests\complex + + + tests\complex + + + tests\complex + + + tests\complex + + + tests + @@ -248,5 +296,8 @@ {e8bafdb8-66e5-4393-bc89-8bff83bcccd6} + + {e025e123-45aa-44f9-aab4-f1705844b211} + \ No newline at end of file diff --git a/basic-geometry-test/main.c b/basic-geometry-test/main.c index 2022099..9bb59b6 100644 --- a/basic-geometry-test/main.c +++ b/basic-geometry-test/main.c @@ -6,6 +6,7 @@ #include "tests/utilities.h" #include "tests/vector2.h" #include "tests/vector3.h" +#include "tests/complex.h" #include "tests/quaternion.h" #include "tests/versor.h" @@ -17,6 +18,8 @@ int main() test_vector3(); + test_complex(); + test_quaternion(); test_versor(); diff --git a/basic-geometry-test/tests/complex.c b/basic-geometry-test/tests/complex.c new file mode 100644 index 0000000..10ea9a6 --- /dev/null +++ b/basic-geometry-test/tests/complex.c @@ -0,0 +1,14 @@ +#include "./complex.h" + +void test_complex() +{ + print_testing_section("BGC Complex"); + + test_complex_reset(); + test_complex_set_values(); + test_complex_copy(); + test_complex_swap(); + test_complex_is_zero(); + test_complex_is_unit(); + test_complex_modulus(); +} diff --git a/basic-geometry-test/tests/complex.h b/basic-geometry-test/tests/complex.h new file mode 100644 index 0000000..2eab35e --- /dev/null +++ b/basic-geometry-test/tests/complex.h @@ -0,0 +1,15 @@ +#ifndef _TEST_COMPLEX_H_ +#define _TEST_COMPLEX_H_ + +#include "./../helpers.h" +#include "./complex/complex_reset.h" +#include "./complex/complex_set_values.h" +#include "./complex/complex_copy.h" +#include "./complex/complex_swap.h" +#include "./complex/complex_is_zero.h" +#include "./complex/complex_is_unit.h" +#include "./complex/complex_modulus.h" + +void test_complex(); + +#endif diff --git a/basic-geometry-test/tests/complex/complex_copy.c b/basic-geometry-test/tests/complex/complex_copy.c new file mode 100644 index 0000000..84ed825 --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_copy.c @@ -0,0 +1,71 @@ +#include "./complex_copy.h" + +#include + +#include "./../../helpers.h" + +// ==================== FP32 ==================== // + +static const int _TEST_FP32_COMPLEX_AMOUNT = 4; +static const BgcComplexFP32 _TEST_FP32_COMPLEX_LIST[] = { + { 1.0f, 2.0f }, + { -4.0f, -3.0f }, + { -0.001f, 100.0f }, + { 0.001f, -100.0f } +}; + +void test_complex_copy_fp32() +{ + BgcComplexFP32 vector; + + print_testing_name("bgc_complex_copy_fp32"); + + for (int i = 0; i < _TEST_FP32_COMPLEX_AMOUNT; i++) { + + bgc_complex_copy_fp32(&_TEST_FP32_COMPLEX_LIST[i], &vector); + + if (vector.real != _TEST_FP32_COMPLEX_LIST[i].real || + vector.imaginary != _TEST_FP32_COMPLEX_LIST[i].imaginary) { + print_testing_failed(); + return; + } + } + + print_testing_success(); +} + +// ==================== FP64 ==================== // + +static const int _TEST_FP64_COMPLEX_AMOUNT = 4; +static const BgcComplexFP64 _TEST_FP64_COMPLEX_LIST[] = { + { 1.0, 2.0 }, + { -4.0, -3.0 }, + { -0.001, 100.0 }, + { 0.001, -100.0 } +}; + +void test_complex_copy_fp64() +{ + BgcComplexFP64 vector; + + print_testing_name("bgc_complex_copy_fp64"); + + for (int i = 0; i < _TEST_FP64_COMPLEX_AMOUNT; i++) { + + bgc_complex_copy_fp64(&_TEST_FP64_COMPLEX_LIST[i], &vector); + + if (vector.real != _TEST_FP64_COMPLEX_LIST[i].real || + vector.imaginary != _TEST_FP64_COMPLEX_LIST[i].imaginary) { + print_testing_failed(); + return; + } + } + + print_testing_success(); +} + +void test_complex_copy() +{ + test_complex_copy_fp32(); + test_complex_copy_fp64(); +} diff --git a/basic-geometry-test/tests/complex/complex_copy.h b/basic-geometry-test/tests/complex/complex_copy.h new file mode 100644 index 0000000..d35db2c --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_copy.h @@ -0,0 +1,10 @@ +#ifndef _TEST_COMPLEX_COPY_H_ +#define _TEST_COMPLEX_COPY_H_ + +void test_complex_copy_fp32(); + +void test_complex_copy_fp64(); + +void test_complex_copy(); + +#endif diff --git a/basic-geometry-test/tests/complex/complex_is_unit.c b/basic-geometry-test/tests/complex/complex_is_unit.c new file mode 100644 index 0000000..f06ca66 --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_is_unit.c @@ -0,0 +1,109 @@ +#include "./complex_is_unit.h" + +#include "./../../helpers.h" + +// ==================== FP32 ==================== // + +static const int _TEST_FP32_UNIT_COMPLEX_AMOUNT = 10; +static const int _TEST_FP32_NONUNIT_COMPLEX_AMOUNT = 6; + +static const BgcComplexFP32 _TEST_FP32_UNIT_COMPLEX_LIST[] = { + { 1.0f, 0.0f }, + { -1.0f, 0.0f }, + { 0.6f, -0.8f }, + { 1.0f + 0.75f * BGC_EPSYLON_FP32, 0.0f }, + { 1.0f - 0.75f * BGC_EPSYLON_FP32, 0.0f }, + { 0.0f, 1.0f + 0.75f * BGC_EPSYLON_FP32 }, + { 0.0f, 1.0f - 0.75f * BGC_EPSYLON_FP32 }, + { 0.7071067812f, 0.7071067812f }, + { 0.7071067812f + 0.75f * BGC_EPSYLON_FP32, 0.7071067812f }, + { 0.7071067812f, 0.7071067812f - 0.75f * BGC_EPSYLON_FP32 } +}; + +static const BgcComplexFP32 _TEST_FP32_NONUNIT_QUATERION_LIST[] = { + { 1.0f + 1.25f * BGC_EPSYLON_FP32, 0.0f }, + { 1.0f - 1.25f * BGC_EPSYLON_FP32, 0.0f }, + { 0.0f, 1.0f + 1.25f * BGC_EPSYLON_FP32 }, + { 0.0f, 1.0f - 1.25f * BGC_EPSYLON_FP32 }, + { 0.7071067812f + 1.25f * BGC_EPSYLON_FP32, 0.7071067812f + 1.25f * BGC_EPSYLON_FP32 }, + { 0.7071067812f - 1.25f * BGC_EPSYLON_FP32, 0.7071067812f - 1.25f * BGC_EPSYLON_FP32 } +}; + +void test_complex_is_unit_fp32() +{ + print_testing_name("bgc_complex_is_unit_fp32"); + + // Testing zero values: + for (int i = 0; i < _TEST_FP32_UNIT_COMPLEX_AMOUNT; i++) { + if (!bgc_complex_is_unit_fp32(&_TEST_FP32_UNIT_COMPLEX_LIST[i])) { + print_testing_error("A unit complex number was not recognized"); + return; + } + } + + // Testing non-zero values: + for (int i = 0; i < _TEST_FP32_NONUNIT_COMPLEX_AMOUNT; i++) { + if (bgc_complex_is_unit_fp32(&_TEST_FP32_NONUNIT_QUATERION_LIST[i])) { + print_testing_error("A non-unit complex number was recognized a unit complex number"); + return; + } + } + + print_testing_success(); +} + +// ==================== FP64 ==================== // + +static const int _TEST_FP64_UNIT_COMPLEX_AMOUNT = 10; +static const int _TEST_FP64_NONUNIT_COMPLEX_AMOUNT = 6; + +static const BgcComplexFP64 _TEST_FP64_UNIT_COMPLEX_LIST[] = { + { 1.0, 0.0 }, + { -1.0, 0.0 }, + { -0.6, 0.8 }, + { 1.0 + 0.75 * BGC_EPSYLON_FP64, 0.0 }, + { 1.0 - 0.75 * BGC_EPSYLON_FP64, 0.0 }, + { 0.0, 1.0 + 0.75 * BGC_EPSYLON_FP64 }, + { 0.0, 1.0 - 0.75 * BGC_EPSYLON_FP64 }, + { 0.7071067811865475244, 0.7071067811865475244 }, + { 0.7071067811865475244 + 0.75 * BGC_EPSYLON_FP64, 0.7071067811865475244 }, + { 0.7071067811865475244, 0.7071067811865475244 - 0.75 * BGC_EPSYLON_FP64 } +}; + +static const BgcComplexFP64 _TEST_FP64_NONUNIT_QUATERION_LIST[] = { + { 1.0 + 1.25 * BGC_EPSYLON_FP64, 0.0 }, + { 1.0 - 1.25 * BGC_EPSYLON_FP64, 0.0 }, + { 0.0, 1.0 + 1.25 * BGC_EPSYLON_FP64 }, + { 0.0, 1.0 - 1.25 * BGC_EPSYLON_FP64 }, + { 0.7071067811865475244 + 1.25 * BGC_EPSYLON_FP64, 0.7071067811865475244 + 1.25 * BGC_EPSYLON_FP64 }, + { 0.7071067811865475244 - 1.25 * BGC_EPSYLON_FP64, 0.7071067811865475244 - 1.25 * BGC_EPSYLON_FP64 } +}; + +void test_complex_is_unit_fp64() +{ + print_testing_name("bgc_complex_is_unit_fp64"); + + // Testing zero values: + for (int i = 0; i < _TEST_FP64_UNIT_COMPLEX_AMOUNT; i++) { + if (!bgc_complex_is_unit_fp64(&_TEST_FP64_UNIT_COMPLEX_LIST[i])) { + print_testing_error("A unit complex number was not recognized"); + return; + } + } + + // Testing non-zero values: + for (int i = 0; i < _TEST_FP64_NONUNIT_COMPLEX_AMOUNT; i++) { + if (bgc_complex_is_unit_fp64(&_TEST_FP64_NONUNIT_QUATERION_LIST[i])) { + print_testing_error("A non-unit complex number was recognized a unit complex number"); + return; + } + } + + print_testing_success(); +} + +void test_complex_is_unit() +{ + test_complex_is_unit_fp32(); + test_complex_is_unit_fp64(); +} diff --git a/basic-geometry-test/tests/complex/complex_is_unit.h b/basic-geometry-test/tests/complex/complex_is_unit.h new file mode 100644 index 0000000..d434d41 --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_is_unit.h @@ -0,0 +1,10 @@ +#ifndef _TEST_COMPLEX_IS_UNIT_H_ +#define _TEST_COMPLEX_IS_UNIT_H_ + +void test_complex_is_unit_fp32(); + +void test_complex_is_unit_fp64(); + +void test_complex_is_unit(); + +#endif diff --git a/basic-geometry-test/tests/complex/complex_is_zero.c b/basic-geometry-test/tests/complex/complex_is_zero.c new file mode 100644 index 0000000..1f658e3 --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_is_zero.c @@ -0,0 +1,101 @@ +#include "./complex_is_zero.h" + +#include "./../../helpers.h" + +// ==================== FP32 ==================== // + +static const int _TEST_FP32_ZERO_COMPLEX_AMOUNT = 4; +static const int _TEST_FP32_NONZERO_COMPLEX_AMOUNT = 7; + +static const BgcComplexFP32 _TEST_FP32_ZERO_COMPLEX_LIST[] = { + { 0.0f, 0.0f }, + { 0.75f * BGC_EPSYLON_FP32, 0.0f }, + { -0.75f * BGC_EPSYLON_FP32, 0.0f }, + { 0.0f, 0.75f * BGC_EPSYLON_FP32 }, + { 0.0f, -0.75f * BGC_EPSYLON_FP32 } +}; + +static const BgcComplexFP32 _TEST_FP32_NONZERO_QUATERION_LIST[] = { + { 0.0f, 1.0f }, + { 1.25f * BGC_EPSYLON_FP32 }, + { -1.25f * BGC_EPSYLON_FP32 }, + { 0.0f, 1.25f * BGC_EPSYLON_FP32 }, + { 0.0f, -1.25f * BGC_EPSYLON_FP32 }, + { 1.25f * BGC_EPSYLON_FP32, 1.25f * BGC_EPSYLON_FP32 }, + { -1.25f * BGC_EPSYLON_FP32, -1.25f * BGC_EPSYLON_FP32 } +}; + +void test_complex_is_zero_fp32() +{ + print_testing_name("bgc_complex_is_zero_fp32"); + + // Testing zero values: + for (int i = 0; i < _TEST_FP32_ZERO_COMPLEX_AMOUNT; i++) { + if (!bgc_complex_is_zero_fp32(&_TEST_FP32_ZERO_COMPLEX_LIST[i])) { + print_testing_error("A zero complex number was not recognized"); + return; + } + } + + // Testing non-zero values: + for (int i = 0; i < _TEST_FP32_NONZERO_COMPLEX_AMOUNT; i++) { + if (bgc_complex_is_zero_fp32(&_TEST_FP32_NONZERO_QUATERION_LIST[i])) { + print_testing_error("A non-zero complex number was recognized as a zero complex number"); + return; + } + } + + print_testing_success(); +} + +// ==================== FP64 ==================== // + +static const int _TEST_FP64_ZERO_COMPLEX_AMOUNT = 4; +static const int _TEST_FP64_NONZERO_COMPLEX_AMOUNT = 7; + +static const BgcComplexFP64 _TEST_FP64_ZERO_COMPLEX_LIST[] = { + { 0.0, 0.0 }, + { 0.75 * BGC_EPSYLON_FP64, 0.0 }, + { -0.75 * BGC_EPSYLON_FP64, 0.0 }, + { 0.0, 0.75 * BGC_EPSYLON_FP64 }, + { 0.0, -0.75 * BGC_EPSYLON_FP64 } +}; + +static const BgcComplexFP64 _TEST_FP64_NONZERO_QUATERION_LIST[] = { + { 0.0, 1.0 }, + { 1.25 * BGC_EPSYLON_FP64, 0.0 }, + { -1.25 * BGC_EPSYLON_FP64, 0.0 }, + { 0.0, 1.25 * BGC_EPSYLON_FP64 }, + { 0.0, -1.25 * BGC_EPSYLON_FP64 }, + { 1.25 * BGC_EPSYLON_FP64, 1.25 * BGC_EPSYLON_FP64 }, + { -1.25 * BGC_EPSYLON_FP64, -1.25 * BGC_EPSYLON_FP64 } +}; + +void test_complex_is_zero_fp64() +{ + print_testing_name("bgc_complex_is_zero_fp64"); + + // Testing zero values: + for (int i = 0; i < _TEST_FP64_ZERO_COMPLEX_AMOUNT; i++) { + if (!bgc_complex_is_zero_fp64(&_TEST_FP64_ZERO_COMPLEX_LIST[i])) { + print_testing_error("A zero complex number was not recognized"); + return; + } + } + + // Testing non-zero values: + for (int i = 0; i < _TEST_FP64_NONZERO_COMPLEX_AMOUNT; i++) { + if (bgc_complex_is_zero_fp64(&_TEST_FP64_NONZERO_QUATERION_LIST[i])) { + print_testing_error("A non-zero complex number was recognized as a zero complex number"); + return; + } + } + + print_testing_success(); +} + +void test_complex_is_zero() +{ + test_complex_is_zero_fp32(); + test_complex_is_zero_fp64(); +} diff --git a/basic-geometry-test/tests/complex/complex_is_zero.h b/basic-geometry-test/tests/complex/complex_is_zero.h new file mode 100644 index 0000000..9153446 --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_is_zero.h @@ -0,0 +1,10 @@ +#ifndef _TEST_COMPLEX_IS_ZERO_H_ +#define _TEST_COMPLEX_IS_ZERO_H_ + +void test_complex_is_zero_fp32(); + +void test_complex_is_zero_fp64(); + +void test_complex_is_zero(); + +#endif diff --git a/basic-geometry-test/tests/complex/complex_modulus.c b/basic-geometry-test/tests/complex/complex_modulus.c new file mode 100644 index 0000000..20c0495 --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_modulus.c @@ -0,0 +1,117 @@ +#include "./complex_modulus.h" + +#include "./../../helpers.h" + +// ==================== FP32 ==================== // + +static const int _TEST_FP32_COMPLEX_AMOUNT = 4; + +static const BgcComplexFP32 _TEST_FP32_COMPLEX_LIST[] = { + { 4.0f, 3.0f }, + { -1.0f, 1.0f }, + { 100.0f, -100.0f }, + { -0.86602540378f, 0.5f } +}; + +static const float _TEST_FP32_SQUARE_MODULUS_LIST[] = { + 25.0f, + 2.0f, + 20000.0f, + 1.0f +}; + +static const float _TEST_FP32_MODULUS_LIST[] = { + 5.0f, + 1.414213562373f, + 141.4213562373f, + 1.0f +}; + +void test_complex_square_modulus_fp32() +{ + print_testing_name("bgc_complex_get_square_modulus_fp32"); + + for (int i = 0; i < _TEST_FP32_COMPLEX_AMOUNT; i++) { + if (!bgc_are_close_fp32(bgc_complex_get_square_modulus_fp32(&_TEST_FP32_COMPLEX_LIST[i]), _TEST_FP32_SQUARE_MODULUS_LIST[i])) { + print_testing_failed(); + return; + } + } + + print_testing_success(); +} + +void test_complex_modulus_fp32() +{ + print_testing_name("bgc_complex_get_modulus_fp32"); + + for (int i = 0; i < _TEST_FP32_COMPLEX_AMOUNT; i++) { + if (!bgc_are_close_fp32(bgc_complex_get_modulus_fp32(&_TEST_FP32_COMPLEX_LIST[i]), _TEST_FP32_MODULUS_LIST[i])) { + print_testing_failed(); + return; + } + } + + print_testing_success(); +} + +// ==================== FP64 ==================== // + +static const int _TEST_FP64_COMPLEX_AMOUNT = 4; + +static const BgcComplexFP64 _TEST_FP64_COMPLEX_LIST[] = { + { 4.0, 3.0 }, + { -1.0, -1.0 }, + { -100.0, 100.0 }, + { -0.5, 0.866025403784438647 } +}; + +static const double _TEST_FP64_SQUARE_MODULUS_LIST[] = { + 25.0, + 2.0, + 20000.0, + 1.0 +}; + +static const double _TEST_FP64_MODULUS_LIST[] = { + 5.0, + 1.4142135623730950488, + 141.42135623730950488, + 1.0 +}; + +void test_complex_square_modulus_fp64() +{ + print_testing_name("bgc_complex_get_square_modulus_fp64"); + + for (int i = 0; i < _TEST_FP64_COMPLEX_AMOUNT; i++) { + if (!bgc_are_close_fp64(bgc_complex_get_square_modulus_fp64(&_TEST_FP64_COMPLEX_LIST[i]), _TEST_FP64_SQUARE_MODULUS_LIST[i])) { + print_testing_failed(); + return; + } + } + + print_testing_success(); +} + +void test_complex_modulus_fp64() +{ + print_testing_name("bgc_complex_get_modulus_fp64"); + + for (int i = 0; i < _TEST_FP64_COMPLEX_AMOUNT; i++) { + if (!bgc_are_close_fp64(bgc_complex_get_modulus_fp64(&_TEST_FP64_COMPLEX_LIST[i]), _TEST_FP64_MODULUS_LIST[i])) { + print_testing_failed(); + return; + } + } + + print_testing_success(); +} + +void test_complex_modulus() +{ + test_complex_square_modulus_fp32(); + test_complex_square_modulus_fp64(); + test_complex_modulus_fp32(); + test_complex_modulus_fp64(); +} diff --git a/basic-geometry-test/tests/complex/complex_modulus.h b/basic-geometry-test/tests/complex/complex_modulus.h new file mode 100644 index 0000000..9d62f3d --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_modulus.h @@ -0,0 +1,14 @@ +#ifndef _TEST_COMPLEX_MODULUS_H_ +#define _TEST_COMPLEX_MODULUS_H_ + +void test_complex_square_modulus_fp32(); + +void test_complex_square_modulus_fp64(); + +void test_complex_modulus_fp32(); + +void test_complex_modulus_fp64(); + +void test_complex_modulus(); + +#endif diff --git a/basic-geometry-test/tests/complex/complex_reset.c b/basic-geometry-test/tests/complex/complex_reset.c new file mode 100644 index 0000000..6c8b11f --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_reset.c @@ -0,0 +1,41 @@ +#include "./complex_reset.h" + +#include "./../../helpers.h" + +void test_complex_reset_fp32() +{ + BgcComplexFP32 vector; + + print_testing_name("bgc_complex_reset_fp32"); + + bgc_complex_reset_fp32(&vector); + + if (vector.real != 0.0f || vector.imaginary != 0.0f) { + print_testing_failed(); + return; + } + + print_testing_success(); +} + +void test_complex_reset_fp64() +{ + BgcComplexFP64 vector; + + print_testing_name("bgc_complex_reset_fp64"); + + bgc_complex_reset_fp64(&vector); + + if (vector.real != 0.0 || vector.imaginary != 0.0) { + print_testing_failed(); + return; + } + + print_testing_success(); +} + +void test_complex_reset() +{ + test_complex_reset_fp32(); + test_complex_reset_fp64(); +} diff --git a/basic-geometry-test/tests/complex/complex_reset.h b/basic-geometry-test/tests/complex/complex_reset.h new file mode 100644 index 0000000..f76683b --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_reset.h @@ -0,0 +1,10 @@ +#ifndef _TEST_COMPLEX_RESET_H_ +#define _TEST_COMPLEX_RESET_H_ + +void test_complex_reset_fp32(); + +void test_complex_reset_fp64(); + +void test_complex_reset(); + +#endif diff --git a/basic-geometry-test/tests/complex/complex_set_values.c b/basic-geometry-test/tests/complex/complex_set_values.c new file mode 100644 index 0000000..9f20beb --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_set_values.c @@ -0,0 +1,75 @@ +#include "./complex_set_values.h" + +#include + +#include "./../../helpers.h" + +// ==================== FP32 ==================== // + +void test_complex_set_values_fp32() +{ + BgcComplexFP32 vector; + + print_testing_name("bgc_complex_set_values_fp32"); + + bgc_complex_set_values_fp32(1.0f, 2.0f, &vector); + + if (vector.real != 1.0f || vector.imaginary != 2.0f) { + print_testing_error("First step failed"); + return; + } + + bgc_complex_set_values_fp32(-1.0f, -3.0f, &vector); + + if (vector.real != -1.0f || vector.imaginary != -3.0f) { + print_testing_error("Second step failed"); + return; + } + + bgc_complex_set_values_fp32(-8.0f, -2.0f, &vector); + + if (vector.real != -8.0f || vector.imaginary != -2.0f) { + print_testing_error("Third step failed"); + return; + } + + print_testing_success(); +} + +// ==================== FP64 ==================== // + +void test_complex_set_values_fp64() +{ + BgcComplexFP64 vector; + + print_testing_name("bgc_complex_set_values_fp64"); + + bgc_complex_set_values_fp64(1.0, 2.0, &vector); + + if (vector.real != 1.0 || vector.imaginary != 2.0) { + print_testing_error("First step failed"); + return; + } + + bgc_complex_set_values_fp64(-1.0, -3.0, &vector); + + if (vector.real != -1.0 || vector.imaginary != -3.0) { + print_testing_error("Second step failed"); + return; + } + + bgc_complex_set_values_fp64(-8.0, -2.0, &vector); + + if (vector.real != -8.0 || vector.imaginary != -2.0) { + print_testing_error("Third step failed"); + return; + } + + print_testing_success(); +} + +void test_complex_set_values() +{ + test_complex_set_values_fp32(); + test_complex_set_values_fp64(); +} diff --git a/basic-geometry-test/tests/complex/complex_set_values.h b/basic-geometry-test/tests/complex/complex_set_values.h new file mode 100644 index 0000000..dc5296d --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_set_values.h @@ -0,0 +1,10 @@ +#ifndef _TEST_COMPLEX_SET_VALUES_H_ +#define _TEST_COMPLEX_SET_VALUES_H_ + +void test_complex_set_values_fp32(); + +void test_complex_set_values_fp64(); + +void test_complex_set_values(); + +#endif diff --git a/basic-geometry-test/tests/complex/complex_swap.c b/basic-geometry-test/tests/complex/complex_swap.c new file mode 100644 index 0000000..bec0546 --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_swap.c @@ -0,0 +1,95 @@ +#include "./complex_swap.h" + +#include + +#include "./../../helpers.h" + +// ==================== FP32 ==================== // + +static const int _TEST_FP32_COMPLEX_AMOUNT = 4; + +static const BgcComplexFP32 _TEST_FP32_COMPLEX_LIST1[] = { + { 3.0f, 4.0f }, + { -2.0f, -1.0f }, + { -244.8f, 100.0f }, + { 1000.32f, -100.1f } +}; + +static const BgcComplexFP32 _TEST_FP32_COMPLEX_LIST2[] = { + { 5.3f, 1003.28f }, + { -0.0032f, 891.3f }, + { 5.322f, 0.9275f }, + { 1000.0f, -0.00025f } +}; + +void test_complex_swap_fp32() +{ + BgcComplexFP32 compleimaginary, complex2; + + print_testing_name("bgc_complex_swap_fp32"); + + for (int i = 0; i < _TEST_FP32_COMPLEX_AMOUNT; i++) { + bgc_complex_copy_fp32(&_TEST_FP32_COMPLEX_LIST1[i], &compleimaginary); + bgc_complex_copy_fp32(&_TEST_FP32_COMPLEX_LIST2[i], &complex2); + + bgc_complex_swap_fp32(&compleimaginary, &complex2); + + if (compleimaginary.real != _TEST_FP32_COMPLEX_LIST2[i].real || + compleimaginary.imaginary != _TEST_FP32_COMPLEX_LIST2[i].imaginary || + complex2.real != _TEST_FP32_COMPLEX_LIST1[i].real || + complex2.imaginary != _TEST_FP32_COMPLEX_LIST1[i].imaginary) { + print_testing_failed(); + return; + } + } + + print_testing_success(); +} + +// ==================== FP64 ==================== // + +static const int _TEST_FP64_COMPLEX_AMOUNT = 4; + +static const BgcComplexFP64 _TEST_FP64_COMPLEX_LIST1[] = { + { 1.0, 4.0 }, + { -4.0, -3.0 }, + { -244.8, 344.7 }, + { 1000.32, -271.3 } +}; + +static const BgcComplexFP64 _TEST_FP64_COMPLEX_LIST2[] = { + { -0.123, 1003.28 }, + { 204.07, -781.89 }, + { 5.322, 0.9275 }, + { -0.419, 0.844 } +}; + +void test_complex_swap_fp64() +{ + BgcComplexFP64 compleimaginary, complex2; + + print_testing_name("bgc_complex_swap_fp64"); + + for (int i = 0; i < _TEST_FP64_COMPLEX_AMOUNT; i++) { + bgc_complex_copy_fp64(&_TEST_FP64_COMPLEX_LIST1[i], &compleimaginary); + bgc_complex_copy_fp64(&_TEST_FP64_COMPLEX_LIST2[i], &complex2); + + bgc_complex_swap_fp64(&compleimaginary, &complex2); + + if (compleimaginary.real != _TEST_FP64_COMPLEX_LIST2[i].real || + compleimaginary.imaginary != _TEST_FP64_COMPLEX_LIST2[i].imaginary || + complex2.real != _TEST_FP64_COMPLEX_LIST1[i].real || + complex2.imaginary != _TEST_FP64_COMPLEX_LIST1[i].imaginary) { + print_testing_failed(); + return; + } + } + + print_testing_success(); +} + +void test_complex_swap() +{ + test_complex_swap_fp32(); + test_complex_swap_fp64(); +} diff --git a/basic-geometry-test/tests/complex/complex_swap.h b/basic-geometry-test/tests/complex/complex_swap.h new file mode 100644 index 0000000..94ae0ed --- /dev/null +++ b/basic-geometry-test/tests/complex/complex_swap.h @@ -0,0 +1,10 @@ +#ifndef _TEST_COMPLEX_SWAP_H_ +#define _TEST_COMPLEX_SWAP_H_ + +void test_complex_swap_fp32(); + +void test_complex_swap_fp64(); + +void test_complex_swap(); + +#endif diff --git a/basic-geometry/basic-geometry.vcxproj b/basic-geometry/basic-geometry.vcxproj index 6c60d06..94fb723 100644 --- a/basic-geometry/basic-geometry.vcxproj +++ b/basic-geometry/basic-geometry.vcxproj @@ -47,7 +47,6 @@ - diff --git a/basic-geometry/versor.h b/basic-geometry/versor.h index 895d249..8215daa 100644 --- a/basic-geometry/versor.h +++ b/basic-geometry/versor.h @@ -184,12 +184,12 @@ inline void bgc_versor_swap_fp64(BgcVersorFP64* versor1, BgcVersorFP64* versor2) inline int bgc_versor_is_identity_fp32(const BgcVersorFP32* versor) { - return 1.0f - BGC_EPSYLON_FP32 <= versor->s0 || versor->s0 <= -(1.0 - BGC_EPSYLON_FP32); + return versor->x1 * versor->x1 + versor->x2 * versor->x2 + versor->x3 * versor->x3 <= BGC_SQUARE_EPSYLON_FP32; } inline int bgc_versor_is_identity_fp64(const BgcVersorFP64* versor) { - return 1.0 - BGC_EPSYLON_FP64 <= versor->s0 || versor->s0 <= -(1.0 - BGC_EPSYLON_FP64); + return versor->x1 * versor->x1 + versor->x2 * versor->x2 + versor->x3 * versor->x3 <= BGC_SQUARE_EPSYLON_FP64; } // ================== Convert =================== //