Kimelas/bgc-c
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: Kimelas:2a4d5522d32ff88cf2c66a257022041d518638db
Branches Tags
Kimelas:master
Kimelas:0.2.0-dev
..
compare: Kimelas:34ee460873d0972788e037806bb43d6e643c32fa
Branches Tags
Kimelas:master
Kimelas:0.2.0-dev

No commits in common. "2a4d5522d32ff88cf2c66a257022041d518638db" and "34ee460873d0972788e037806bb43d6e643c32fa" have entirely different histories.
2a4d5522d3 ... 34ee460873

56 changed files with 723 additions and 4768 deletions
Download patch file Download diff file Expand all files Collapse all files

372
basic-geometry-dev/main.c
View file

@ -53,12 +53,12 @@ structure_fp32_t* make_structures(const unsigned int amount)
void print_versor_fp32(const BgcVersorFP32* versor)
{
printf("Versor (s0 = %0.12f, x1 = %0.12f, x2 = %0.12f, x3 = %0.12f)\n", versor->s0, versor->x1, versor->x2, versor->x3);
printf("Versor (%f, %f, %f, %f)\n", versor->s0, versor->x1, versor->x2, versor->x3);
}
void print_versor_fp64(const BgcVersorFP64* versor)
{
printf("Versor (s0 = %0.20f, x1 = %0.20f, x2 = %0.20f, x3 = %0.20f)\n", versor->s0, versor->x1, versor->x2, versor->x3);
printf("Versor (%lf, %lf, %lf, %lf)\n", versor->s0, versor->x1, versor->x2, versor->x3);
}
void print_vector_fp32(const BgcVector3FP32* vector)
@ -79,7 +79,7 @@ void list_work(const uint_fast32_t amount, structure_fp32_t* list)
}
}
}
/*
int main()
{
const unsigned int amount = 1000000;
@ -121,369 +121,3 @@ int main()
return 0;
}
*/
/*
int main() {
BgcComplexFP32 complex, exponent, result;
bgc_complex_set_values_fp32(0, 1, &complex);
bgc_complex_set_values_fp32(4, 0, &exponent);
bgc_complex_get_exponation_fp32(&complex, exponent.real, exponent.imaginary, &result);
printf("(%f, %f) ^ (%f, %f) = (%f, %f)\n", complex.real, complex.imaginary, exponent.real, exponent.imaginary, result.real, result.imaginary);
return 0;
}
*/
/*
int main() {
BgcVersorFP32 start = { 1.0f, 0.0f, 0.0f, 0.0f };
BgcVersorFP32 end = { 0.0f, 1.0f, 0.0f, 0.0f };
BgcVersorFP32 result;
bgc_versor_spherical_interpolation_fp32(&start, &end, 0.5f, &result);
printf("Result: %0.12f, %0.12f, %0.12f, %0.12f\n", result.s0, result.x1, result.x2, result.x3);
return 0;
}
*/
void test_basis_difference_fp32()
{
BgcVector3FP32 initial_primary, initial_auxiliary;
BgcVector3FP32 final_primary, final_auxiliary;
BgcVersorFP32 turn;
// No turn
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &final_auxiliary);
bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nNo turn:\n");
print_versor_fp32(&turn);
// Turn around (1, 1, 0) axis on 180 degrees
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &final_auxiliary);
bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nTurn around (1, 1, 0) axis on 180 degrees:\n");
print_versor_fp32(&turn);
// 180 degree turn
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(-1.0f, 0.0f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &final_auxiliary);
bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\n180 degree turn around (0, 1, 0):\n");
print_versor_fp32(&turn);
// 90 degree turn around x3 axis
bgc_vector3_set_values_fp32(2.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(0.0f, 3.1f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(0.0f, 10.0f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(-1.0f, 0.0f, 0.0f, &final_auxiliary);
bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\n90 degree turn around (0, 0, 1):\n");
print_versor_fp32(&turn);
// Unorthogonal pairs turn at 90 degrees around x3 axis
bgc_vector3_set_values_fp32(2.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(-2.0f, 3.1f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(0.0f, 10.0f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(-1.0f, 5.0f, 0.0f, &final_auxiliary);
bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nUnorthogonal pairs turn at 90 degrees around (0, 0, 1):\n");
print_versor_fp32(&turn);
// Zero vectors
bgc_vector3_set_values_fp32(0.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &final_auxiliary);
int code;
code = bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
if (code >= 0) {
printf("\nZero vectors: this cannot be!\n");
print_versor_fp32(&turn);
}
else {
printf("\nZero vector validation works fine\n");
}
// Parallel vectors
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(2.0f, 0.0f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &final_auxiliary);
code = bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
if (code >= 0) {
printf("\nParallel vectors: this cannot be!\n");
print_versor_fp32(&turn);
}
else {
printf("\nParallelism validation works fine\n");
}
// Small angle turn (about 1 degree):
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(0.999848f, 0.017452f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(-0.017452f, 0.999848f, 0.0f, &final_auxiliary);
bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nSmall angle turn (about 1 degree):\n");
print_versor_fp32(&turn);
// About 179 degrees turn
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(-0.999848f, -0.017452f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(0.017452f, -0.999848f, 0.0f, &final_auxiliary);
bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nAbout 179 degrees turn:\n");
print_versor_fp32(&turn);
// 120 degrees around (-1, -1, 1)
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(0.0f, 0.0f, -1.0f, &final_auxiliary);
bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\n120 degees turn:\n");
print_versor_fp32(&turn);
// About 1 degree turn difference between initial_primary and initial_auxiliary directions
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(0.999848f, 0.017452f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(0.0f, 1.0f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(-1.0f, 0.0f, 0.0f, &final_auxiliary);
bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nAbout 1 degree turn difference between initial_primary and initial_auxiliary directions:\n");
print_versor_fp32(&turn);
// About 0.01 degree turn difference between initial_primary and initial_auxiliary directions
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &initial_primary);
bgc_vector3_set_values_fp32(1.0f, 0.000001f, 0.0f, &initial_auxiliary);
bgc_vector3_set_values_fp32(0.0f, -1.0f, 0.0f, &final_primary);
bgc_vector3_set_values_fp32(1.0f, 0.0f, 0.0f, &final_auxiliary);
bgc_versor_make_basis_difference_fp32(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nAbout 0.01 degree turn difference between initial_primary and initial_auxiliary directions:\n");
print_versor_fp32(&turn);
}
void test_basis_difference_fp64()
{
BgcVector3FP64 initial_primary, initial_auxiliary;
BgcVector3FP64 final_primary, final_auxiliary;
BgcVersorFP64 turn;
// No turn
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &final_primary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &final_auxiliary);
bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nNo turn:\n");
print_versor_fp64(&turn);
// Turn around (1, 1, 0) axis on 180 degrees
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &final_primary);
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &final_auxiliary);
bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nTurn around (1, 1, 0) axis on 180 degrees:\n");
print_versor_fp64(&turn);
// 180 degree turn
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(-1.0, 0.0, 0.0, &final_primary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &final_auxiliary);
bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\n180 degree turn around (0, 1, 0):\n");
print_versor_fp64(&turn);
// 90 degree turn around x3 axis
bgc_vector3_set_values_fp64(2.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(0.0, 3.1, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(0.0, 10.0, 0.0, &final_primary);
bgc_vector3_set_values_fp64(-1.0, 0.0, 0.0, &final_auxiliary);
bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\n90 degree turn around (0, 0, 1):\n");
print_versor_fp64(&turn);
// Unorthogonal pairs turn at 90 degrees around x3 axis
bgc_vector3_set_values_fp64(2.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(-2.0, 3.1, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(0.0, 10.0, 0.0, &final_primary);
bgc_vector3_set_values_fp64(-1.0, 5.0, 0.0, &final_auxiliary);
bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nUnorthogonal pairs turn at 90 degrees around (0, 0, 1):\n");
print_versor_fp64(&turn);
// Zero vectors
bgc_vector3_set_values_fp64(0.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &final_primary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &final_auxiliary);
int code;
code = bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
if (code >= 0) {
printf("\nZero vectors: this cannot be!\n");
print_versor_fp64(&turn);
}
else {
printf("\nZero vector validation works fine\n");
}
// Parallel vectors
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(2.0, 0.0, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &final_primary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &final_auxiliary);
code = bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
if (code >= 0) {
printf("\nParallel vectors: this cannot be!\n");
print_versor_fp64(&turn);
}
else {
printf("\nParallelism validation works fine\n");
}
// Small angle turn (about 1 degree):
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(0.999848, 0.017452, 0.0, &final_primary);
bgc_vector3_set_values_fp64(-0.017452, 0.999848, 0.0, &final_auxiliary);
bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nSmall angle turn (about 1 degree):\n");
print_versor_fp64(&turn);
// About 179 degrees turn
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(-0.999848, -0.017452, 0.0, &final_primary);
bgc_vector3_set_values_fp64(0.017452, -0.999848, 0.0, &final_auxiliary);
bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nAbout 179 degrees turn:\n");
print_versor_fp64(&turn);
// 120 degrees around (-1, -1, 1)
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &final_primary);
bgc_vector3_set_values_fp64(0.0, 0.0, -1.0, &final_auxiliary);
bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\n120 degees turn:\n");
print_versor_fp64(&turn);
// About 1 degree turn difference between initial_primary and initial_auxiliary directions
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(0.999848, 0.017452, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(0.0, 1.0, 0.0, &final_primary);
bgc_vector3_set_values_fp64(-1.0, 0.0, 0.0, &final_auxiliary);
bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nAbout 1 degree turn difference between initial_primary and initial_auxiliary directions:\n");
print_versor_fp64(&turn);
// About 0.001 degree turn difference between initial_primary and initial_auxiliary directions
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &initial_primary);
bgc_vector3_set_values_fp64(1.0, 0.000001, 0.0, &initial_auxiliary);
bgc_vector3_set_values_fp64(0.0, -1.0, 0.0, &final_primary);
bgc_vector3_set_values_fp64(1.0, 0.0, 0.0, &final_auxiliary);
bgc_versor_make_basis_difference_fp64(&initial_primary, &initial_auxiliary, &final_primary, &final_auxiliary, &turn);
printf("\nAbout 0.01 degree turn difference between initial_primary and initial_auxiliary directions:\n");
print_versor_fp64(&turn);
}
int main()
{
//BgcVersorFP32 start = { 1.0f, 0.0f, 0.0f, 0.0f };
//BgcVersorFP32 end = { 0.0f, 1.0f, 0.0f, 0.0f };
/*
BgcVersorFP32 start = { 1.0f, 0.0f, 0.0f, 0.0f };
BgcVersorFP32 end = { 0.9999f, 0.01414f, 0.0f, 0.0f };
BgcSlerpFP32 slerp;
BgcVersorFP32 result;
bgc_slerp_make_fp32(&start, &end, &slerp);
bgc_slerp_get_turn_for_phase_fp32(&slerp, 0.5f, &result);
printf("Result: %0.12f, %0.12f, %0.12f, %0.12f\n", result.s0, result.x1, result.x2, result.x3);
*/
test_basis_difference_fp64();
return 0;
}

32
basic-geometry-test/basic-geometry-test.cbp
View file

@ -49,38 +49,6 @@
<Unit filename="main.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="tests/complex.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="tests/complex.h" />
<Unit filename="tests/complex/complex_copy.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="tests/complex/complex_copy.h" />
<Unit filename="tests/complex/complex_is_unit.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="tests/complex/complex_is_unit.h" />
<Unit filename="tests/complex/complex_is_zero.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="tests/complex/complex_is_zero.h" />
<Unit filename="tests/complex/complex_modulus.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="tests/complex/complex_modulus.h" />
<Unit filename="tests/complex/complex_reset.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="tests/complex/complex_reset.h" />
<Unit filename="tests/complex/complex_set_values.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="tests/complex/complex_set_values.h" />
<Unit filename="tests/complex/complex_swap.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="tests/complex/complex_swap.h" />
<Unit filename="tests/quaternion.c">
<Option compilerVar="CC" />
</Unit>

22
basic-geometry-test/basic-geometry-test.vcxproj
View file

@ -150,15 +150,6 @@
<ItemGroup>
<ClCompile Include="helpers.c" />
<ClCompile Include="main.c" />
<ClCompile Include="tests\complex.c" />
<ClCompile Include="tests\complex\complex_copy.c" />
<ClCompile Include="tests\complex\complex_is_unit.c" />
<ClCompile Include="tests\complex\complex_is_zero.c" />
<ClCompile Include="tests\complex\complex_modulus.c" />
<ClCompile Include="tests\complex\complex_reset.c" />
<ClCompile Include="tests\complex\complex_set_values.c" />
<ClCompile Include="tests\complex\complex_swap.c" />
<ClCompile Include="tests\complex\complex_arithmetics.c" />
<ClCompile Include="tests\quaternion.c" />
<ClCompile Include="tests\quaternion\quaternion_copy.c" />
<ClCompile Include="tests\quaternion\quaternion_is_unit.c" />
@ -173,7 +164,6 @@
<ClCompile Include="tests\utilities\is_unit.c" />
<ClCompile Include="tests\utilities\is_zero.c" />
<ClCompile Include="tests\vector2.c" />
<ClCompile Include="tests\vector2\vector2_arithmetics.c" />
<ClCompile Include="tests\vector2\vector2_is_unit.c" />
<ClCompile Include="tests\vector2\vector2_is_zero.c" />
<ClCompile Include="tests\vector2\vector2_copy.c" />
@ -182,7 +172,6 @@
<ClCompile Include="tests\vector2\vector2_set_values.c" />
<ClCompile Include="tests\vector2\vector2_swap.c" />
<ClCompile Include="tests\vector3.c" />
<ClCompile Include="tests\vector3\vector3_arithmetics.c" />
<ClCompile Include="tests\vector3\vector3_is_unit.c" />
<ClCompile Include="tests\vector3\vector3_is_zero.c" />
<ClCompile Include="tests\vector3\vector3_copy.c" />
@ -201,15 +190,6 @@
</ItemGroup>
<ItemGroup>
<ClInclude Include="helpers.h" />
<ClInclude Include="tests\complex.h" />
<ClInclude Include="tests\complex\complex_copy.h" />
<ClInclude Include="tests\complex\complex_is_unit.h" />
<ClInclude Include="tests\complex\complex_is_zero.h" />
<ClInclude Include="tests\complex\complex_modulus.h" />
<ClInclude Include="tests\complex\complex_reset.h" />
<ClInclude Include="tests\complex\complex_set_values.h" />
<ClInclude Include="tests\complex\complex_swap.h" />
<ClInclude Include="tests\complex\complex_arithmetics.h" />
<ClInclude Include="tests\quaternion.h" />
<ClInclude Include="tests\quaternion\quaternion_copy.h" />
<ClInclude Include="tests\quaternion\quaternion_is_unit.h" />
@ -224,7 +204,6 @@
<ClInclude Include="tests\utilities\is_unit.h" />
<ClInclude Include="tests\utilities\is_zero.h" />
<ClInclude Include="tests\vector2.h" />
<ClInclude Include="tests\vector2\vector2_arithmetics.h" />
<ClInclude Include="tests\vector2\vector2_is_unit.h" />
<ClInclude Include="tests\vector2\vector2_is_zero.h" />
<ClInclude Include="tests\vector2\vector2_copy.h" />
@ -233,7 +212,6 @@
<ClInclude Include="tests\vector2\vector2_set_values.h" />
<ClInclude Include="tests\vector2\vector2_swap.h" />
<ClInclude Include="tests\vector3.h" />
<ClInclude Include="tests\vector3\vector3_arithmetics.h" />
<ClInclude Include="tests\vector3\vector3_is_unit.h" />
<ClInclude Include="tests\vector3\vector3_is_zero.h" />
<ClInclude Include="tests\vector3\vector3_copy.h" />

69
basic-geometry-test/basic-geometry-test.vcxproj.filters
View file

@ -114,39 +114,6 @@
<ClCompile Include="tests\quaternion\quaternion_modulus.c">
<Filter>tests\quaternion</Filter>
</ClCompile>
<ClCompile Include="tests\complex\complex_copy.c">
<Filter>tests\complex</Filter>
</ClCompile>
<ClCompile Include="tests\complex\complex_is_unit.c">
<Filter>tests\complex</Filter>
</ClCompile>
<ClCompile Include="tests\complex\complex_is_zero.c">
<Filter>tests\complex</Filter>
</ClCompile>
<ClCompile Include="tests\complex\complex_modulus.c">
<Filter>tests\complex</Filter>
</ClCompile>
<ClCompile Include="tests\complex\complex_reset.c">
<Filter>tests\complex</Filter>
</ClCompile>
<ClCompile Include="tests\complex\complex_set_values.c">
<Filter>tests\complex</Filter>
</ClCompile>
<ClCompile Include="tests\complex\complex_swap.c">
<Filter>tests\complex</Filter>
</ClCompile>
<ClCompile Include="tests\complex.c">
<Filter>tests</Filter>
</ClCompile>
<ClCompile Include="tests\vector2\vector2_arithmetics.c">
<Filter>tests\vector2</Filter>
</ClCompile>
<ClCompile Include="tests\vector3\vector3_arithmetics.c">
<Filter>tests\vector3</Filter>
</ClCompile>
<ClCompile Include="tests\complex\complex_arithmetics.c">
<Filter>tests\complex</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="helpers.h" />
@ -261,39 +228,6 @@
<ClInclude Include="tests\quaternion\quaternion_modulus.h">
<Filter>tests\quaternion</Filter>
</ClInclude>
<ClInclude Include="tests\complex\complex_copy.h">
<Filter>tests\complex</Filter>
</ClInclude>
<ClInclude Include="tests\complex\complex_is_unit.h">
<Filter>tests\complex</Filter>
</ClInclude>
<ClInclude Include="tests\complex\complex_is_zero.h">
<Filter>tests\complex</Filter>
</ClInclude>
<ClInclude Include="tests\complex\complex_modulus.h">
<Filter>tests\complex</Filter>
</ClInclude>
<ClInclude Include="tests\complex\complex_reset.h">
<Filter>tests\complex</Filter>
</ClInclude>
<ClInclude Include="tests\complex\complex_set_values.h">
<Filter>tests\complex</Filter>
</ClInclude>
<ClInclude Include="tests\complex\complex_swap.h">
<Filter>tests\complex</Filter>
</ClInclude>
<ClInclude Include="tests\complex.h">
<Filter>tests</Filter>
</ClInclude>
<ClInclude Include="tests\vector2\vector2_arithmetics.h">
<Filter>tests\vector2</Filter>
</ClInclude>
<ClInclude Include="tests\vector3\vector3_arithmetics.h">
<Filter>tests\vector3</Filter>
</ClInclude>
<ClInclude Include="tests\complex\complex_arithmetics.h">
<Filter>tests\complex</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<Filter Include="tests">
@ -314,8 +248,5 @@
<Filter Include="tests\quaternion">
<UniqueIdentifier>{e8bafdb8-66e5-4393-bc89-8bff83bcccd6}</UniqueIdentifier>
</Filter>
<Filter Include="tests\complex">
<UniqueIdentifier>{e025e123-45aa-44f9-aab4-f1705844b211}</UniqueIdentifier>
</Filter>
</ItemGroup>
</Project>

3
basic-geometry-test/main.c
View file

@ -6,7 +6,6 @@
#include "tests/utilities.h"
#include "tests/vector2.h"
#include "tests/vector3.h"
#include "tests/complex.h"
#include "tests/quaternion.h"
#include "tests/versor.h"
@ -18,8 +17,6 @@ int main()
test_vector3();
test_complex();
test_quaternion();
test_versor();

19
basic-geometry-test/tests/complex.c
View file

@ -1,19 +0,0 @@
#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();
test_complex_add();
test_complex_subtract();
test_complex_multiply();
test_complex_divide();
}

16
basic-geometry-test/tests/complex.h
View file

@ -1,16 +0,0 @@
#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"
#include "./complex/complex_arithmetics.h"
void test_complex();
#endif

380
basic-geometry-test/tests/complex/complex_arithmetics.c
View file

@ -1,380 +0,0 @@
#include "./complex_arithmetics.h"
#include "./../../helpers.h"
// ==================== Add ===================== //
void test_complex_add_fp32()
{
BgcComplexFP32 vector1, vector2, result;
print_testing_name("bgc_complex_add_fp32");
bgc_complex_set_values_fp32(10.0f, -20.0f, &vector1);
bgc_complex_set_values_fp32(4.0f, 5.0f, &vector2);
bgc_complex_add_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.real, 14.0f) || !bgc_are_close_fp32(result.imaginary, -15.0f)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp32(-0.28f, 100.1f, &vector1);
bgc_complex_set_values_fp32(1.78f, -0.1f, &vector2);
bgc_complex_add_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.real, 1.5f) || !bgc_are_close_fp32(result.imaginary, 100.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_add_scaled_fp32()
{
BgcComplexFP32 vector1, vector2, result;
print_testing_name("bgc_complex_add_scaled_fp32");
bgc_complex_set_values_fp32(10.0f, -20.0f, &vector1);
bgc_complex_set_values_fp32(4.0f, 5.0f, &vector2);
bgc_complex_add_scaled_fp32(&vector1, & vector2, -2.0f, &result);
if (!bgc_are_close_fp32(result.real, 2.0f) || !bgc_are_close_fp32(result.imaginary, -30.0f)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp32(-0.27f, 100.3f, &vector1);
bgc_complex_set_values_fp32(1.59f, -0.1f, &vector2);
bgc_complex_add_scaled_fp32(&vector1, &vector2, 3.0f, &result);
if (!bgc_are_close_fp32(result.real, 4.5f) || !bgc_are_close_fp32(result.imaginary, 100.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_add_fp64()
{
BgcComplexFP64 vector1, vector2, result;
print_testing_name("bgc_complex_add_fp64");
bgc_complex_set_values_fp64(10.0, -20.0, &vector1);
bgc_complex_set_values_fp64(4.0, 8.0, &vector2);
bgc_complex_add_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.real, 14.0) || !bgc_are_close_fp64(result.imaginary, -12.0)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp64(-0.27, 100.3, &vector1);
bgc_complex_set_values_fp64(1.29, -0.2, &vector2);
bgc_complex_add_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.real, 1.02) || !bgc_are_close_fp64(result.imaginary, 100.1)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_add_scaled_fp64()
{
BgcComplexFP64 vector1, vector2, result;
print_testing_name("bgc_complex_add_scaled_fp64");
bgc_complex_set_values_fp64(10.0, -20.0, &vector1);
bgc_complex_set_values_fp64(4.0, 5.0, &vector2);
bgc_complex_add_scaled_fp64(&vector1, &vector2, -2.0, &result);
if (!bgc_are_close_fp64(result.real, 2.0) || !bgc_are_close_fp64(result.imaginary, -30.0)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp64(-0.27, 100.3, &vector1);
bgc_complex_set_values_fp64(1.59, -0.1, &vector2);
bgc_complex_add_scaled_fp64(&vector1, &vector2, 3.0, &result);
if (!bgc_are_close_fp64(result.real, 4.5) || !bgc_are_close_fp64(result.imaginary, 100.0)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_add()
{
test_complex_add_fp32();
test_complex_add_fp64();
test_complex_add_scaled_fp32();
test_complex_add_scaled_fp64();
}
// ================== Subtract ================== //
void test_complex_subtract_fp32()
{
BgcComplexFP32 vector1, vector2, result;
print_testing_name("bgc_complex_subtract_fp32");
bgc_complex_set_values_fp32(10.0f, -20.0f, &vector1);
bgc_complex_set_values_fp32(4.0f, 5.0f, &vector2);
bgc_complex_subtract_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.real, 6.0f) || !bgc_are_close_fp32(result.imaginary, -25.0f)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp32(-0.28f, 99.9f, &vector1);
bgc_complex_set_values_fp32(-1.78f, -0.1f, &vector2);
bgc_complex_subtract_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.real, 1.5f) || !bgc_are_close_fp32(result.imaginary, 100.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_subtract_scaled_fp32()
{
BgcComplexFP32 vector1, vector2, result;
print_testing_name("bgc_complex_subtract_scaled_fp32");
bgc_complex_set_values_fp32(10.0f, -20.0f, &vector1);
bgc_complex_set_values_fp32(4.0f, 5.0f, &vector2);
bgc_complex_subtract_scaled_fp32(&vector1, &vector2, 2.0f, &result);
if (!bgc_are_close_fp32(result.real, 2.0f) || !bgc_are_close_fp32(result.imaginary, -30.0f)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp32(0.36f, 100.4f, &vector1);
bgc_complex_set_values_fp32(1.09f, 0.1f, &vector2);
bgc_complex_subtract_scaled_fp32(&vector1, &vector2, 4.0f, &result);
if (!bgc_are_close_fp32(result.real, -4.0f) || !bgc_are_close_fp32(result.imaginary, 100.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_subtract_fp64()
{
BgcComplexFP64 vector1, vector2, result;
print_testing_name("bgc_complex_subtract_fp64");
bgc_complex_set_values_fp64(10.0, -20.0, &vector1);
bgc_complex_set_values_fp64(4.0, 8.0, &vector2);
bgc_complex_subtract_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.real, 6.0) || !bgc_are_close_fp64(result.imaginary, -28.0)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp64(-0.27, 100.3, &vector1);
bgc_complex_set_values_fp64(1.29, -0.2, &vector2);
bgc_complex_subtract_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.real, -1.56) || !bgc_are_close_fp64(result.imaginary, 100.5)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_subtract_scaled_fp64()
{
BgcComplexFP64 vector1, vector2, result;
print_testing_name("bgc_complex_subtract_scaled_fp64");
bgc_complex_set_values_fp64(10.0, 20.0, &vector1);
bgc_complex_set_values_fp64(4.0, 5.0, &vector2);
bgc_complex_subtract_scaled_fp64(&vector1, &vector2, 2.5, &result);
if (!bgc_are_close_fp64(result.real, 0.0) || !bgc_are_close_fp64(result.imaginary, 7.5)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp64(-0.27, 100.3, &vector1);
bgc_complex_set_values_fp64(-1.29, -0.1, &vector2);
bgc_complex_subtract_scaled_fp64(&vector1, &vector2, 3.0, &result);
if (!bgc_are_close_fp64(result.real, 3.6) || !bgc_are_close_fp64(result.imaginary, 100.6)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_subtract()
{
test_complex_subtract_fp32();
test_complex_subtract_fp64();
test_complex_subtract_scaled_fp32();
test_complex_subtract_scaled_fp64();
}
// ================== Multiply ================== //
void test_complex_multiply_fp32()
{
BgcComplexFP32 vector, result;
print_testing_name("bgc_complex_multiply_fp32");
bgc_complex_set_values_fp32(10.0f, -20.0f, &vector);
bgc_complex_multiply_fp32(&vector, 0.5f, &result);
if (!bgc_are_close_fp32(result.real, 5.0f) || !bgc_are_close_fp32(result.imaginary, -10.0f)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp32(1.78f, -0.1f, &vector);
bgc_complex_multiply_fp32(&vector, 2.0f, &result);
if (!bgc_are_close_fp32(result.real, 3.56f) || !bgc_are_close_fp32(result.imaginary, -0.2f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_multiply_fp64()
{
BgcComplexFP64 vector, result;
print_testing_name("bgc_complex_multiply_fp64");
bgc_complex_set_values_fp64(30.0, -10.0, &vector);
bgc_complex_multiply_fp64(&vector, 0.3, &result);
if (!bgc_are_close_fp64(result.real, 9.0) || !bgc_are_close_fp64(result.imaginary, -3.0)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp64(1.18, -0.25, &vector);
bgc_complex_multiply_fp64(&vector, 4.0, &result);
if (!bgc_are_close_fp64(result.real, 4.72) || !bgc_are_close_fp64(result.imaginary, -1.0)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_multiply()
{
test_complex_multiply_fp32();
test_complex_multiply_fp64();
}
// =================== Divide =================== //
void test_complex_divide_fp32()
{
BgcComplexFP32 vector, result;
print_testing_name("bgc_complex_divide_fp32");
bgc_complex_set_values_fp32(10.0f, -20.0f, &vector);
bgc_complex_divide_fp32(&vector, 10.0f, &result);
if (!bgc_are_close_fp32(result.real, 1.0f) || !bgc_are_close_fp32(result.imaginary, -2.0f)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp32(1.78f, -0.1f, &vector);
bgc_complex_divide_fp32(&vector, 0.2f, &result);
if (!bgc_are_close_fp32(result.real, 8.9f) || !bgc_are_close_fp32(result.imaginary, -0.5f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_divide_fp64()
{
BgcComplexFP64 vector, result;
print_testing_name("bgc_complex_divide_fp64");
bgc_complex_set_values_fp64(30.0, -10.0, &vector);
bgc_complex_divide_fp64(&vector, 5.0, &result);
if (!bgc_are_close_fp64(result.real, 6.0) || !bgc_are_close_fp64(result.imaginary, -2.0)) {
print_testing_error("first test failed");
return;
}
bgc_complex_set_values_fp64(1.18, -0.25, &vector);
bgc_complex_divide_fp64(&vector, 0.5, &result);
if (!bgc_are_close_fp64(result.real, 2.36) || !bgc_are_close_fp64(result.imaginary, -0.5)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_complex_divide()
{
test_complex_divide_fp32();
test_complex_divide_fp64();
}

45
basic-geometry-test/tests/complex/complex_arithmetics.h
View file

@ -1,45 +0,0 @@
#ifndef _TEST_COMPLEX_ARITHMETICS_H_
#define _TEST_COMPLEX_ARITHMETICS_H_
// ==================== Add ===================== //
void test_complex_add_fp32();
void test_complex_add_scaled_fp32();
void test_complex_add_fp64();
void test_complex_add_scaled_fp64();
void test_complex_add();
// ================== Subtract ================== //
void test_complex_subtract_fp32();
void test_complex_subtract_scaled_fp32();
void test_complex_subtract_fp64();
void test_complex_subtract_scaled_fp64();
void test_complex_subtract();
// ================== Multiply ================== //
void test_complex_multiply_fp32();
void test_complex_multiply_fp64();
void test_complex_multiply();
// =================== Divide =================== //
void test_complex_divide_fp32();
void test_complex_divide_fp64();
void test_complex_divide();
#endif

71
basic-geometry-test/tests/complex/complex_copy.c
View file

@ -1,71 +0,0 @@
#include "./complex_copy.h"
#include <math.h>
#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();
}

10
basic-geometry-test/tests/complex/complex_copy.h
View file

@ -1,10 +0,0 @@
#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

109
basic-geometry-test/tests/complex/complex_is_unit.c
View file

@ -1,109 +0,0 @@
#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();
}

10
basic-geometry-test/tests/complex/complex_is_unit.h
View file

@ -1,10 +0,0 @@
#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

101
basic-geometry-test/tests/complex/complex_is_zero.c
View file

@ -1,101 +0,0 @@
#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();
}

10
basic-geometry-test/tests/complex/complex_is_zero.h
View file

@ -1,10 +0,0 @@
#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

117
basic-geometry-test/tests/complex/complex_modulus.c
View file

@ -1,117 +0,0 @@
#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();
}

14
basic-geometry-test/tests/complex/complex_modulus.h
View file

@ -1,14 +0,0 @@
#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

41
basic-geometry-test/tests/complex/complex_reset.c
View file

@ -1,41 +0,0 @@
#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();
}

10
basic-geometry-test/tests/complex/complex_reset.h
View file

@ -1,10 +0,0 @@
#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

75
basic-geometry-test/tests/complex/complex_set_values.c
View file

@ -1,75 +0,0 @@
#include "./complex_set_values.h"
#include <math.h>
#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();
}

10
basic-geometry-test/tests/complex/complex_set_values.h
View file

@ -1,10 +0,0 @@
#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

95
basic-geometry-test/tests/complex/complex_swap.c
View file

@ -1,95 +0,0 @@
#include "./complex_swap.h"
#include <math.h>
#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();
}

10
basic-geometry-test/tests/complex/complex_swap.h
View file

@ -1,10 +0,0 @@
#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

5
basic-geometry-test/tests/vector2.c
View file

@ -11,11 +11,6 @@ void test_vector2()
test_vector2_is_zero();
test_vector2_is_unit();
test_vector2_modulus();
test_vector2_add();
test_vector2_subtract();
test_vector2_multiply();
test_vector2_divide();
}

1
basic-geometry-test/tests/vector2.h
View file

@ -9,7 +9,6 @@
#include "./vector2/vector2_is_zero.h"
#include "./vector2/vector2_is_unit.h"
#include "./vector2/vector2_modulus.h"
#include "./vector2/vector2_arithmetics.h"
void test_vector2();

380
basic-geometry-test/tests/vector2/vector2_arithmetics.c
View file

@ -1,380 +0,0 @@
#include "./vector2_arithmetics.h"
#include "./../../helpers.h"
// ==================== Add ===================== //
void test_vector2_add_fp32()
{
BgcVector2FP32 vector1, vector2, result;
print_testing_name("bgc_vector2_add_fp32");
bgc_vector2_set_values_fp32(10.0f, -20.0f, &vector1);
bgc_vector2_set_values_fp32(4.0f, 5.0f, &vector2);
bgc_vector2_add_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.x1, 14.0f) || !bgc_are_close_fp32(result.x2, -15.0f)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp32(-0.28f, 100.1f, &vector1);
bgc_vector2_set_values_fp32(1.78f, -0.1f, &vector2);
bgc_vector2_add_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.x1, 1.5f) || !bgc_are_close_fp32(result.x2, 100.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_add_scaled_fp32()
{
BgcVector2FP32 vector1, vector2, result;
print_testing_name("bgc_vector2_add_scaled_fp32");
bgc_vector2_set_values_fp32(10.0f, -20.0f, &vector1);
bgc_vector2_set_values_fp32(4.0f, 5.0f, &vector2);
bgc_vector2_add_scaled_fp32(&vector1, & vector2, -2.0f, &result);
if (!bgc_are_close_fp32(result.x1, 2.0f) || !bgc_are_close_fp32(result.x2, -30.0f)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp32(-0.27f, 100.3f, &vector1);
bgc_vector2_set_values_fp32(1.59f, -0.1f, &vector2);
bgc_vector2_add_scaled_fp32(&vector1, &vector2, 3.0f, &result);
if (!bgc_are_close_fp32(result.x1, 4.5f) || !bgc_are_close_fp32(result.x2, 100.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_add_fp64()
{
BgcVector2FP64 vector1, vector2, result;
print_testing_name("bgc_vector2_add_fp64");
bgc_vector2_set_values_fp64(10.0, -20.0, &vector1);
bgc_vector2_set_values_fp64(4.0, 8.0, &vector2);
bgc_vector2_add_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.x1, 14.0) || !bgc_are_close_fp64(result.x2, -12.0)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp64(-0.27, 100.3, &vector1);
bgc_vector2_set_values_fp64(1.29, -0.2, &vector2);
bgc_vector2_add_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.x1, 1.02) || !bgc_are_close_fp64(result.x2, 100.1)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_add_scaled_fp64()
{
BgcVector2FP64 vector1, vector2, result;
print_testing_name("bgc_vector2_add_scaled_fp64");
bgc_vector2_set_values_fp64(10.0, -20.0, &vector1);
bgc_vector2_set_values_fp64(4.0, 5.0, &vector2);
bgc_vector2_add_scaled_fp64(&vector1, &vector2, -2.0, &result);
if (!bgc_are_close_fp64(result.x1, 2.0) || !bgc_are_close_fp64(result.x2, -30.0)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp64(-0.27, 100.3, &vector1);
bgc_vector2_set_values_fp64(1.59, -0.1, &vector2);
bgc_vector2_add_scaled_fp64(&vector1, &vector2, 3.0, &result);
if (!bgc_are_close_fp64(result.x1, 4.5) || !bgc_are_close_fp64(result.x2, 100.0)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_add()
{
test_vector2_add_fp32();
test_vector2_add_fp64();
test_vector2_add_scaled_fp32();
test_vector2_add_scaled_fp64();
}
// ================== Subtract ================== //
void test_vector2_subtract_fp32()
{
BgcVector2FP32 vector1, vector2, result;
print_testing_name("bgc_vector2_subtract_fp32");
bgc_vector2_set_values_fp32(10.0f, -20.0f, &vector1);
bgc_vector2_set_values_fp32(4.0f, 5.0f, &vector2);
bgc_vector2_subtract_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.x1, 6.0f) || !bgc_are_close_fp32(result.x2, -25.0f)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp32(-0.28f, 99.9f, &vector1);
bgc_vector2_set_values_fp32(-1.78f, -0.1f, &vector2);
bgc_vector2_subtract_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.x1, 1.5f) || !bgc_are_close_fp32(result.x2, 100.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_subtract_scaled_fp32()
{
BgcVector2FP32 vector1, vector2, result;
print_testing_name("bgc_vector2_subtract_scaled_fp32");
bgc_vector2_set_values_fp32(10.0f, -20.0f, &vector1);
bgc_vector2_set_values_fp32(4.0f, 5.0f, &vector2);
bgc_vector2_subtract_scaled_fp32(&vector1, &vector2, 2.0f, &result);
if (!bgc_are_close_fp32(result.x1, 2.0f) || !bgc_are_close_fp32(result.x2, -30.0f)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp32(0.36f, 100.4f, &vector1);
bgc_vector2_set_values_fp32(1.09f, 0.1f, &vector2);
bgc_vector2_subtract_scaled_fp32(&vector1, &vector2, 4.0f, &result);
if (!bgc_are_close_fp32(result.x1, -4.0f) || !bgc_are_close_fp32(result.x2, 100.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_subtract_fp64()
{
BgcVector2FP64 vector1, vector2, result;
print_testing_name("bgc_vector2_subtract_fp64");
bgc_vector2_set_values_fp64(10.0, -20.0, &vector1);
bgc_vector2_set_values_fp64(4.0, 8.0, &vector2);
bgc_vector2_subtract_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.x1, 6.0) || !bgc_are_close_fp64(result.x2, -28.0)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp64(-0.27, 100.3, &vector1);
bgc_vector2_set_values_fp64(1.29, -0.2, &vector2);
bgc_vector2_subtract_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.x1, -1.56) || !bgc_are_close_fp64(result.x2, 100.5)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_subtract_scaled_fp64()
{
BgcVector2FP64 vector1, vector2, result;
print_testing_name("bgc_vector2_subtract_scaled_fp64");
bgc_vector2_set_values_fp64(10.0, 20.0, &vector1);
bgc_vector2_set_values_fp64(4.0, 5.0, &vector2);
bgc_vector2_subtract_scaled_fp64(&vector1, &vector2, 2.5, &result);
if (!bgc_are_close_fp64(result.x1, 0.0) || !bgc_are_close_fp64(result.x2, 7.5)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp64(-0.27, 100.3, &vector1);
bgc_vector2_set_values_fp64(-1.29, -0.1, &vector2);
bgc_vector2_subtract_scaled_fp64(&vector1, &vector2, 3.0, &result);
if (!bgc_are_close_fp64(result.x1, 3.6) || !bgc_are_close_fp64(result.x2, 100.6)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_subtract()
{
test_vector2_subtract_fp32();
test_vector2_subtract_fp64();
test_vector2_subtract_scaled_fp32();
test_vector2_subtract_scaled_fp64();
}
// ================== Multiply ================== //
void test_vector2_multiply_fp32()
{
BgcVector2FP32 vector, result;
print_testing_name("bgc_vector2_multiply_fp32");
bgc_vector2_set_values_fp32(10.0f, -20.0f, &vector);
bgc_vector2_multiply_fp32(&vector, 0.5f, &result);
if (!bgc_are_close_fp32(result.x1, 5.0f) || !bgc_are_close_fp32(result.x2, -10.0f)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp32(1.78f, -0.1f, &vector);
bgc_vector2_multiply_fp32(&vector, 2.0f, &result);
if (!bgc_are_close_fp32(result.x1, 3.56f) || !bgc_are_close_fp32(result.x2, -0.2f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_multiply_fp64()
{
BgcVector2FP64 vector, result;
print_testing_name("bgc_vector2_multiply_fp64");
bgc_vector2_set_values_fp64(30.0, -10.0, &vector);
bgc_vector2_multiply_fp64(&vector, 0.3, &result);
if (!bgc_are_close_fp64(result.x1, 9.0) || !bgc_are_close_fp64(result.x2, -3.0)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp64(1.18, -0.25, &vector);
bgc_vector2_multiply_fp64(&vector, 4.0, &result);
if (!bgc_are_close_fp64(result.x1, 4.72) || !bgc_are_close_fp64(result.x2, -1.0)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_multiply()
{
test_vector2_multiply_fp32();
test_vector2_multiply_fp64();
}
// =================== Divide =================== //
void test_vector2_divide_fp32()
{
BgcVector2FP32 vector, result;
print_testing_name("bgc_vector2_divide_fp32");
bgc_vector2_set_values_fp32(10.0f, -20.0f, &vector);
bgc_vector2_divide_fp32(&vector, 10.0f, &result);
if (!bgc_are_close_fp32(result.x1, 1.0f) || !bgc_are_close_fp32(result.x2, -2.0f)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp32(1.78f, -0.1f, &vector);
bgc_vector2_divide_fp32(&vector, 0.2f, &result);
if (!bgc_are_close_fp32(result.x1, 8.9f) || !bgc_are_close_fp32(result.x2, -0.5f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_divide_fp64()
{
BgcVector2FP64 vector, result;
print_testing_name("bgc_vector2_divide_fp64");
bgc_vector2_set_values_fp64(30.0, -10.0, &vector);
bgc_vector2_divide_fp64(&vector, 5.0, &result);
if (!bgc_are_close_fp64(result.x1, 6.0) || !bgc_are_close_fp64(result.x2, -2.0)) {
print_testing_error("first test failed");
return;
}
bgc_vector2_set_values_fp64(1.18, -0.25, &vector);
bgc_vector2_divide_fp64(&vector, 0.5, &result);
if (!bgc_are_close_fp64(result.x1, 2.36) || !bgc_are_close_fp64(result.x2, -0.5)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector2_divide()
{
test_vector2_divide_fp32();
test_vector2_divide_fp64();
}

45
basic-geometry-test/tests/vector2/vector2_arithmetics.h
View file

@ -1,45 +0,0 @@
#ifndef _TEST_VECTOR2_ARITHMETICS_H_
#define _TEST_VECTOR2_ARITHMETICS_H_
// ==================== Add ===================== //
void test_vector2_add_fp32();
void test_vector2_add_scaled_fp32();
void test_vector2_add_fp64();
void test_vector2_add_scaled_fp64();
void test_vector2_add();
// ================== Subtract ================== //
void test_vector2_subtract_fp32();
void test_vector2_subtract_scaled_fp32();
void test_vector2_subtract_fp64();
void test_vector2_subtract_scaled_fp64();
void test_vector2_subtract();
// ================== Multiply ================== //
void test_vector2_multiply_fp32();
void test_vector2_multiply_fp64();
void test_vector2_multiply();
// =================== Divide =================== //
void test_vector2_divide_fp32();
void test_vector2_divide_fp64();
void test_vector2_divide();
#endif

5
basic-geometry-test/tests/vector3.c
View file

@ -11,9 +11,4 @@ void test_vector3()
test_vector3_is_zero();
test_vector3_is_unit();
test_vector3_modulus();
test_vector3_add();
test_vector3_subtract();
test_vector3_multiply();
test_vector3_divide();
}

1
basic-geometry-test/tests/vector3.h
View file

@ -9,7 +9,6 @@
#include "./vector3/vector3_is_zero.h"
#include "./vector3/vector3_is_unit.h"
#include "./vector3/vector3_modulus.h"
#include "./vector3/vector3_arithmetics.h"
void test_vector3();

380
basic-geometry-test/tests/vector3/vector3_arithmetics.c
View file

@ -1,380 +0,0 @@
#include "./vector3_arithmetics.h"
#include "./../../helpers.h"
// ==================== Add ===================== //
void test_vector3_add_fp32()
{
BgcVector3FP32 vector1, vector2, result;
print_testing_name("bgc_vector3_add_fp32");
bgc_vector3_set_values_fp32(10.0f, -20.0f, 30.0f, &vector1);
bgc_vector3_set_values_fp32(4.0f, 5.0f, -6.0f, &vector2);
bgc_vector3_add_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.x1, 14.0f) || !bgc_are_close_fp32(result.x2, -15.0f) || !bgc_are_close_fp32(result.x3, 24.0f)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp32(-0.28f, 100.1f, -1.6f, &vector1);
bgc_vector3_set_values_fp32(1.78f, -0.1f, 0.4f, &vector2);
bgc_vector3_add_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.x1, 1.5f) || !bgc_are_close_fp32(result.x2, 100.0f) || !bgc_are_close_fp32(result.x3, -1.2f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_add_scaled_fp32()
{
BgcVector3FP32 vector1, vector2, result;
print_testing_name("bgc_vector3_add_scaled_fp32");
bgc_vector3_set_values_fp32(10.0f, -20.0f, 24.0f, &vector1);
bgc_vector3_set_values_fp32(4.0f, 5.0f, 6.0f, &vector2);
bgc_vector3_add_scaled_fp32(&vector1, & vector2, -2.0f, &result);
if (!bgc_are_close_fp32(result.x1, 2.0f) || !bgc_are_close_fp32(result.x2, -30.0f) || !bgc_are_close_fp32(result.x3, 12.0f)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp32(-0.27f, 100.3f, -1.2f, &vector1);
bgc_vector3_set_values_fp32(1.59f, -0.1f, 0.4f, &vector2);
bgc_vector3_add_scaled_fp32(&vector1, &vector2, 3.0f, &result);
if (!bgc_are_close_fp32(result.x1, 4.5f) || !bgc_are_close_fp32(result.x2, 100.0f) || !bgc_are_close_fp32(result.x3, 0.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_add_fp64()
{
BgcVector3FP64 vector1, vector2, result;
print_testing_name("bgc_vector3_add_fp64");
bgc_vector3_set_values_fp64(10.0, -20.0, 30.0, &vector1);
bgc_vector3_set_values_fp64(4.0, 8.0, -9.0, &vector2);
bgc_vector3_add_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.x1, 14.0) || !bgc_are_close_fp64(result.x2, -12.0) || !bgc_are_close_fp64(result.x3, 21.0)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp64(-0.27, 100.3, -8.2, &vector1);
bgc_vector3_set_values_fp64(1.29, -0.2, 14.1, &vector2);
bgc_vector3_add_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.x1, 1.02) || !bgc_are_close_fp64(result.x2, 100.1) || !bgc_are_close_fp64(result.x3, 5.9)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_add_scaled_fp64()
{
BgcVector3FP64 vector1, vector2, result;
print_testing_name("bgc_vector3_add_scaled_fp64");
bgc_vector3_set_values_fp64(10.0, -20.0, 7.5, &vector1);
bgc_vector3_set_values_fp64(4.0, 5.0, 1.25, &vector2);
bgc_vector3_add_scaled_fp64(&vector1, &vector2, -2.0, &result);
if (!bgc_are_close_fp64(result.x1, 2.0) || !bgc_are_close_fp64(result.x2, -30.0) || !bgc_are_close_fp64(result.x3, 5.0)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp64(-0.27, 100.3, -20.0, &vector1);
bgc_vector3_set_values_fp64(1.59, -0.1, 5.0, &vector2);
bgc_vector3_add_scaled_fp64(&vector1, &vector2, 3.0, &result);
if (!bgc_are_close_fp64(result.x1, 4.5) || !bgc_are_close_fp64(result.x2, 100.0) || !bgc_are_close_fp64(result.x3, -5.0)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_add()
{
test_vector3_add_fp32();
test_vector3_add_fp64();
test_vector3_add_scaled_fp32();
test_vector3_add_scaled_fp64();
}
// ================== Subtract ================== //
void test_vector3_subtract_fp32()
{
BgcVector3FP32 vector1, vector2, result;
print_testing_name("bgc_vector3_subtract_fp32");
bgc_vector3_set_values_fp32(10.0f, -20.0f, 16.0f, &vector1);
bgc_vector3_set_values_fp32(4.0f, 5.0f, -4.0f, &vector2);
bgc_vector3_subtract_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.x1, 6.0f) || !bgc_are_close_fp32(result.x2, -25.0f) || !bgc_are_close_fp32(result.x3, 20.0f)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp32(-0.28f, 99.9f, -0.2f, &vector1);
bgc_vector3_set_values_fp32(-1.78f, -0.1f, 2.8f, &vector2);
bgc_vector3_subtract_fp32(&vector1, &vector2, &result);
if (!bgc_are_close_fp32(result.x1, 1.5f) || !bgc_are_close_fp32(result.x2, 100.0f) || !bgc_are_close_fp32(result.x3, -3.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_subtract_scaled_fp32()
{
BgcVector3FP32 vector1, vector2, result;
print_testing_name("bgc_vector3_subtract_scaled_fp32");
bgc_vector3_set_values_fp32(10.0f, -20.0f, 1.25f, &vector1);
bgc_vector3_set_values_fp32(4.0f, 5.0f, -0.4f, &vector2);
bgc_vector3_subtract_scaled_fp32(&vector1, &vector2, 2.0f, &result);
if (!bgc_are_close_fp32(result.x1, 2.0f) || !bgc_are_close_fp32(result.x2, -30.0f) || !bgc_are_close_fp32(result.x3, 2.05f)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp32(0.36f, 100.4f, 10, &vector1);
bgc_vector3_set_values_fp32(1.09f, 0.1f, 2.5f, &vector2);
bgc_vector3_subtract_scaled_fp32(&vector1, &vector2, 4.0f, &result);
if (!bgc_are_close_fp32(result.x1, -4.0f) || !bgc_are_close_fp32(result.x2, 100.0f) || !bgc_are_close_fp32(result.x3, 0.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_subtract_fp64()
{
BgcVector3FP64 vector1, vector2, result;
print_testing_name("bgc_vector3_subtract_fp64");
bgc_vector3_set_values_fp64(10.0, -20.0, 15.0, &vector1);
bgc_vector3_set_values_fp64(4.0, 8.0, -5.0, &vector2);
bgc_vector3_subtract_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.x1, 6.0) || !bgc_are_close_fp64(result.x2, -28.0) || !bgc_are_close_fp64(result.x3, 20.0)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp64(-0.27, 100.3, 2.0, &vector1);
bgc_vector3_set_values_fp64(1.29, -0.2, 0.8, &vector2);
bgc_vector3_subtract_fp64(&vector1, &vector2, &result);
if (!bgc_are_close_fp64(result.x1, -1.56) || !bgc_are_close_fp64(result.x2, 100.5) || !bgc_are_close_fp64(result.x3, 1.2)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_subtract_scaled_fp64()
{
BgcVector3FP64 vector1, vector2, result;
print_testing_name("bgc_vector3_subtract_scaled_fp64");
bgc_vector3_set_values_fp64(10.0, 20.0, 0.1, &vector1);
bgc_vector3_set_values_fp64(4.0, 5.0, -4.0, &vector2);
bgc_vector3_subtract_scaled_fp64(&vector1, &vector2, 2.5, &result);
if (!bgc_are_close_fp64(result.x1, 0.0) || !bgc_are_close_fp64(result.x2, 7.5) || !bgc_are_close_fp64(result.x3, 10.1)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp64(-0.27, 100.3, -0.01, &vector1);
bgc_vector3_set_values_fp64(-1.29, -0.1, 0.33, &vector2);
bgc_vector3_subtract_scaled_fp64(&vector1, &vector2, 3.0, &result);
if (!bgc_are_close_fp64(result.x1, 3.6) || !bgc_are_close_fp64(result.x2, 100.6) || !bgc_are_close_fp64(result.x3, -1.0)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_subtract()
{
test_vector3_subtract_fp32();
test_vector3_subtract_fp64();
test_vector3_subtract_scaled_fp32();
test_vector3_subtract_scaled_fp64();
}
// ================== Multiply ================== //
void test_vector3_multiply_fp32()
{
BgcVector3FP32 vector, result;
print_testing_name("bgc_vector3_multiply_fp32");
bgc_vector3_set_values_fp32(10.0f, -20.0f, 3.0f, &vector);
bgc_vector3_multiply_fp32(&vector, 0.5f, &result);
if (!bgc_are_close_fp32(result.x1, 5.0f) || !bgc_are_close_fp32(result.x2, -10.0f) || !bgc_are_close_fp32(result.x3, 1.5f)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp32(1.78f, -0.1f, 3.6f, &vector);
bgc_vector3_multiply_fp32(&vector, 2.0f, &result);
if (!bgc_are_close_fp32(result.x1, 3.56f) || !bgc_are_close_fp32(result.x2, -0.2f) || !bgc_are_close_fp32(result.x3, 7.2f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_multiply_fp64()
{
BgcVector3FP64 vector, result;
print_testing_name("bgc_vector3_multiply_fp64");
bgc_vector3_set_values_fp64(30.0, -10.0, 4.0, &vector);
bgc_vector3_multiply_fp64(&vector, 0.3, &result);
if (!bgc_are_close_fp64(result.x1, 9.0) || !bgc_are_close_fp64(result.x2, -3.0) || !bgc_are_close_fp64(result.x3, 1.2)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp64(1.18, -0.25, 0.02, &vector);
bgc_vector3_multiply_fp64(&vector, 4.0, &result);
if (!bgc_are_close_fp64(result.x1, 4.72) || !bgc_are_close_fp64(result.x2, -1.0) || !bgc_are_close_fp64(result.x3, 0.08)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_multiply()
{
test_vector3_multiply_fp32();
test_vector3_multiply_fp64();
}
// =================== Divide =================== //
void test_vector3_divide_fp32()
{
BgcVector3FP32 vector, result;
print_testing_name("bgc_vector3_divide_fp32");
bgc_vector3_set_values_fp32(10.0f, -20.0f, 40.0f, &vector);
bgc_vector3_divide_fp32(&vector, 10.0f, &result);
if (!bgc_are_close_fp32(result.x1, 1.0f) || !bgc_are_close_fp32(result.x2, -2.0f) || !bgc_are_close_fp32(result.x3, 4.0f)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp32(1.78f, -0.1f, 0.4f, &vector);
bgc_vector3_divide_fp32(&vector, 0.2f, &result);
if (!bgc_are_close_fp32(result.x1, 8.9f) || !bgc_are_close_fp32(result.x2, -0.5f) || !bgc_are_close_fp32(result.x3, 2.0f)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_divide_fp64()
{
BgcVector3FP64 vector, result;
print_testing_name("bgc_vector3_divide_fp64");
bgc_vector3_set_values_fp64(30.0, -10.0, 20.0, &vector);
bgc_vector3_divide_fp64(&vector, 5.0, &result);
if (!bgc_are_close_fp64(result.x1, 6.0) || !bgc_are_close_fp64(result.x2, -2.0) || !bgc_are_close_fp64(result.x3, 4.0)) {
print_testing_error("first test failed");
return;
}
bgc_vector3_set_values_fp64(4.5, -0.25, 1.5, &vector);
bgc_vector3_divide_fp64(&vector, -0.5, &result);
if (!bgc_are_close_fp64(result.x1, -9.0) || !bgc_are_close_fp64(result.x2, 0.5) || !bgc_are_close_fp64(result.x3, -3.0)) {
print_testing_error("second test failed");
return;
}
print_testing_success();
}
void test_vector3_divide()
{
test_vector3_divide_fp32();
test_vector3_divide_fp64();
}

45
basic-geometry-test/tests/vector3/vector3_arithmetics.h
View file

@ -1,45 +0,0 @@
#ifndef _TEST_VECTOR3_ARITHMETICS_H_
#define _TEST_VECTOR3_ARITHMETICS_H_
// ==================== Add ===================== //
void test_vector3_add_fp32();
void test_vector3_add_scaled_fp32();
void test_vector3_add_fp64();
void test_vector3_add_scaled_fp64();
void test_vector3_add();
// ================== Subtract ================== //
void test_vector3_subtract_fp32();
void test_vector3_subtract_scaled_fp32();
void test_vector3_subtract_fp64();
void test_vector3_subtract_scaled_fp64();
void test_vector3_subtract();
// ================== Multiply ================== //
void test_vector3_multiply_fp32();
void test_vector3_multiply_fp64();
void test_vector3_multiply();
// =================== Divide =================== //
void test_vector3_divide_fp32();
void test_vector3_divide_fp64();
void test_vector3_divide();
#endif

4
basic-geometry-test/tests/versor/versor_is_identity.c
View file

@ -24,7 +24,7 @@ static const BgcVersorFP32 _TEST_FP32_NON_IDENTIYTY_VERSOR_LIST[] = {
{ 0.0f, 0.0f, 1.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 1.0f },
{ 0.5f, 0.5f, 0.5f, 0.5f },
{ 1.0f, -1.25f * BGC_EPSYLON_FP32, 0.0f, 0.0f }
{ 1.0f - 1.25f * BGC_EPSYLON_FP32, 0.0f, 0.0f, 0.0f }
};
void test_versor_is_identity_fp32()
@ -72,7 +72,7 @@ static const BgcVersorFP64 _TEST_FP64_NON_IDENTIYTY_VERSOR_LIST[] = {
{ 0.0, 0.0, 1.0, 0.0 },
{ 0.0, 0.0, 0.0, 1.0 },
{ 0.5, 0.5, 0.5, 0.5 },
{ 1.0, 0.0, 1.25 * BGC_EPSYLON_FP64, 0.0 }
{ 1.0 - 1.25 * BGC_EPSYLON_FP64, 0.0, 0.0, 0.0 }
};
void test_versor_is_identity_fp64()

26
basic-geometry/Makefile
View file

@ -1,26 +0,0 @@
CC=gcc
GFLAGS=-c -Wall -O2
SOURCES=utilities.c angle.c vector2.c vector3.c complex.c cotes-number.c \
matrix2x2.c matrix2x3.c matrix3x2.c matrix3x3.c matrixes.c \
rotation3.c quaternion.c versor.c
OBJECTS=$(SOURCES:.c=.o)
OBJECT_DIRECTORY=obj/Release
BINARY_DIRECTORY=bin/Release
BACK_PATH=../..
LIBRARY=libbgc.a
all: directories $(SOURCES) $(LIBRARY)
$(LIBRARY): $(OBJECTS)
cd ./$(OBJECT_DIRECTORY); \
ar -rv -s $(BACK_PATH)/$(BINARY_DIRECTORY)/$@ $(OBJECTS); \
cd $(BACK_PATH)
directories:
mkdir -p $(OBJECT_DIRECTORY)
mkdir -p $(BINARY_DIRECTORY)
.c.o:
$(CC) $(GFLAGS) $< -o $(OBJECT_DIRECTORY)/$@
clean:
rm -rf ./obj ./bin

12
basic-geometry/basic-geometry.cbp
View file

@ -48,14 +48,6 @@
</Unit>
<Unit filename="angle.h" />
<Unit filename="basic-geometry.h" />
<Unit filename="complex.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="complex.h" />
<Unit filename="cotes-number.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="cotes-number.h" />
<Unit filename="matrix2x2.c">
<Option compilerVar="CC" />
</Unit>
@ -84,6 +76,10 @@
<Option compilerVar="CC" />
</Unit>
<Unit filename="rotation3.h" />
<Unit filename="tangent-pair.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="tangent-pair.h" />
<Unit filename="utilities.c">
<Option compilerVar="CC" />
</Unit>

28
basic-geometry/basic-geometry.h
View file

@ -1,26 +1,24 @@
#ifndef _BGC_H_
#define _BGC_H_
#include "./utilities.h"
#include "utilities.h"
#include "./angle.h"
#include "angle.h"
#include "./vector2.h"
#include "./vector3.h"
#include "vector2.h"
#include "vector3.h"
#include "./matrixes.h"
#include "./matrix2x2.h"
#include "./matrix2x3.h"
#include "./matrix3x2.h"
#include "./matrix3x3.h"
#include "matrixes.h"
#include "matrix2x2.h"
#include "matrix2x3.h"
#include "matrix3x2.h"
#include "matrix3x3.h"
#include "./complex.h"
#include "./cotes-number.h"
#include "tangent-pair.h"
#include "./rotation3.h"
#include "rotation3.h"
#include "./quaternion.h"
#include "./versor.h"
#include "./slerp.h"
#include "quaternion.h"
#include "versor.h"
#endif

8
basic-geometry/basic-geometry.vcxproj
View file

@ -21,8 +21,6 @@
<ItemGroup>
<ClInclude Include="angle.h" />
<ClInclude Include="basic-geometry.h" />
<ClInclude Include="complex.h" />
<ClInclude Include="cotes-number.h" />
<ClInclude Include="matrix2x2.h" />
<ClInclude Include="matrix2x3.h" />
<ClInclude Include="matrix3x2.h" />
@ -30,16 +28,14 @@
<ClInclude Include="matrixes.h" />
<ClInclude Include="quaternion.h" />
<ClInclude Include="rotation3.h" />
<ClInclude Include="tangent-pair.h" />
<ClInclude Include="utilities.h" />
<ClInclude Include="slerp.h" />
<ClInclude Include="versor.h" />
<ClInclude Include="vector2.h" />
<ClInclude Include="vector3.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="angle.c" />
<ClInclude Include="complex.c" />
<ClInclude Include="cotes-number.c" />
<ClCompile Include="utilities.c" />
<ClCompile Include="matrix2x2.c" />
<ClCompile Include="matrix2x3.c" />
@ -48,7 +44,7 @@
<ClCompile Include="matrixes.c" />
<ClCompile Include="quaternion.c" />
<ClCompile Include="rotation3.c" />
<ClCompile Include="slerp.c" />
<ClCompile Include="tangent-pair.c" />
<ClCompile Include="versor.c" />
<ClCompile Include="vector2.c" />
<ClCompile Include="vector3.c" />

16
basic-geometry/basic-geometry.vcxproj.filters
View file

@ -18,12 +18,6 @@
<ClInclude Include="angle.h">
<Filter>Файлы заголовков</Filter>
</ClInclude>
<ClInclude Include="complex.h">
<Filter>Файлы заголовков</Filter>
</ClInclude>
<ClInclude Include="cotes-number.h">
<Filter>Файлы заголовков</Filter>
</ClInclude>
<ClInclude Include="utilities.h">
<Filter>Файлы заголовков</Filter>
</ClInclude>
@ -60,13 +54,7 @@
<ClInclude Include="matrixes.h">
<Filter>Файлы заголовков</Filter>
</ClInclude>
<ClInclude Include="complex.c">
<Filter>Исходные файлы</Filter>
</ClInclude>
<ClInclude Include="cotes-number.c">
<Filter>Исходные файлы</Filter>
</ClInclude>
<ClInclude Include="slerp.h">
<ClInclude Include="tangent-pair.h">
<Filter>Файлы заголовков</Filter>
</ClInclude>
</ItemGroup>
@ -107,7 +95,7 @@
<ClCompile Include="matrix3x2.c">
<Filter>Исходные файлы</Filter>
</ClCompile>
<ClCompile Include="slerp.c">
<ClCompile Include="tangent-pair.c">
<Filter>Исходные файлы</Filter>
</ClCompile>
</ItemGroup>

124
basic-geometry/complex.c
View file

@ -1,124 +0,0 @@
#include "./complex.h"
extern inline void bgc_complex_reset_fp32(BgcComplexFP32* complex);
extern inline void bgc_complex_reset_fp64(BgcComplexFP64* complex);
extern inline void bgc_complex_set_values_fp32(const float real, const float imaginary, BgcComplexFP32* destination);
extern inline void bgc_complex_set_values_fp64(const double real, const double imaginary, BgcComplexFP64* destination);
extern inline float bgc_complex_get_square_modulus_fp32(const BgcComplexFP32* number);
extern inline double bgc_complex_get_square_modulus_fp64(const BgcComplexFP64* number);
extern inline float bgc_complex_get_modulus_fp32(const BgcComplexFP32* number);
extern inline double bgc_complex_get_modulus_fp64(const BgcComplexFP64* number);
extern inline int bgc_complex_is_zero_fp32(const BgcComplexFP32* number);
extern inline int bgc_complex_is_zero_fp64(const BgcComplexFP64* number);
extern inline int bgc_complex_is_unit_fp32(const BgcComplexFP32* number);
extern inline int bgc_complex_is_unit_fp64(const BgcComplexFP64* number);
extern inline void bgc_complex_copy_fp32(const BgcComplexFP32* source, BgcComplexFP32* destination);
extern inline void bgc_complex_copy_fp64(const BgcComplexFP64* source, BgcComplexFP64* destination);
extern inline void bgc_complex_swap_fp32(BgcComplexFP32* number1, BgcComplexFP32* number2);
extern inline void bgc_complex_swap_fp64(BgcComplexFP64* number1, BgcComplexFP64* number2);
extern inline void bgc_complex_convert_fp64_to_fp32(const BgcComplexFP64* source, BgcComplexFP32* destination);
extern inline void bgc_complex_convert_fp32_to_fp64(const BgcComplexFP32* source, BgcComplexFP64* destination);
extern inline void bgc_complex_reverse_fp32(const BgcComplexFP32* number, BgcComplexFP32* reverse);
extern inline void bgc_complex_reverse_fp64(const BgcComplexFP64* number, BgcComplexFP64* reverse);
extern inline int bgc_complex_normalize_fp32(const BgcComplexFP32* number, BgcComplexFP32* normalized);
extern inline int bgc_complex_normalize_fp64(const BgcComplexFP64* number, BgcComplexFP64* normalized);
extern inline void bgc_complex_conjugate_fp32(const BgcComplexFP32* number, BgcComplexFP32* conjugate);
extern inline void bgc_complex_conjugate_fp64(const BgcComplexFP64* number, BgcComplexFP64* conjugate);
extern inline int bgc_complex_invert_fp32(const BgcComplexFP32* number, BgcComplexFP32* inverted);
extern inline int bgc_complex_invert_fp64(const BgcComplexFP64* number, BgcComplexFP64* inverted);
extern inline void bgc_complex_get_product_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2, BgcComplexFP32* result);
extern inline void bgc_complex_get_product_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2, BgcComplexFP64* result);
extern inline int bgc_complex_get_ratio_fp32(const BgcComplexFP32* divident, const BgcComplexFP32* divisor, BgcComplexFP32* quotient);
extern inline int bgc_complex_get_ratio_fp64(const BgcComplexFP64* divident, const BgcComplexFP64* divisor, BgcComplexFP64* quotient);
extern inline void bgc_complex_add_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2, BgcComplexFP32* sum);
extern inline void bgc_complex_add_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2, BgcComplexFP64* sum);
extern inline void bgc_complex_add_scaled_fp32(const BgcComplexFP32* basic_number, const BgcComplexFP32* scalable_number, const float scale, BgcComplexFP32* sum);
extern inline void bgc_complex_add_scaled_fp64(const BgcComplexFP64* basic_number, const BgcComplexFP64* scalable_number, const double scale, BgcComplexFP64* sum);
extern inline void bgc_complex_subtract_fp32(const BgcComplexFP32* minuend, const BgcComplexFP32* subtrahend, BgcComplexFP32* difference);
extern inline void bgc_complex_subtract_fp64(const BgcComplexFP64* minuend, const BgcComplexFP64* subtrahend, BgcComplexFP64* difference);
extern inline void bgc_complex_subtract_scaled_fp32(const BgcComplexFP32* basic_number, const BgcComplexFP32* scalable_number, const float scale, BgcComplexFP32* difference);
extern inline void bgc_complex_subtract_scaled_fp64(const BgcComplexFP64* basic_number, const BgcComplexFP64* scalable_number, const double scale, BgcComplexFP64* difference);
extern inline void bgc_complex_multiply_fp32(const BgcComplexFP32* multiplicand, const float multiplier, BgcComplexFP32* product);
extern inline void bgc_complex_multiply_fp64(const BgcComplexFP64* multiplicand, const double multiplier, BgcComplexFP64* product);
extern inline void bgc_complex_divide_fp32(const BgcComplexFP32* dividend, const float divisor, BgcComplexFP32* quotient);
extern inline void bgc_complex_divide_fp64(const BgcComplexFP64* dividend, const double divisor, BgcComplexFP64* quotient);
extern inline void bgc_complex_get_mean_of_two_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2, BgcComplexFP32* mean);
extern inline void bgc_complex_get_mean_of_two_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2, BgcComplexFP64* mean);
extern inline void bgc_complex_get_mean_of_three_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2, const BgcComplexFP32* number3, BgcComplexFP32* mean);
extern inline void bgc_complex_get_mean_of_three_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2, const BgcComplexFP64* number3, BgcComplexFP64* mean);
extern inline void bgc_complex_interpolate_linearly_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2, const float phase, BgcComplexFP32* interpolation);
extern inline void bgc_complex_interpolate_linearly_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2, const double phase, BgcComplexFP64* interpolation);
extern inline void bgc_complex_minimize_fp32(const BgcComplexFP32* number, BgcComplexFP32* minimal);
extern inline void bgc_complex_minimize_fp64(const BgcComplexFP64* number, BgcComplexFP64* minimal);
extern inline void bgc_complex_maximize_fp32(const BgcComplexFP32* number, BgcComplexFP32* maximal);
extern inline void bgc_complex_maximize_fp64(const BgcComplexFP64* number, BgcComplexFP64* maximal);
extern inline int bgc_complex_are_close_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2);
extern inline int bgc_complex_are_close_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2);
// =============== Get Exponation =============== //
void bgc_complex_get_exponation_fp32(const BgcComplexFP32* base, const float real_exponent, const float imaginary_exponent, BgcComplexFP32* power)
{
const float square_modulus = bgc_complex_get_square_modulus_fp32(base);
if (square_modulus <= BGC_SQUARE_EPSYLON_FP32) {
power->real = 0.0f;
power->imaginary = 0.0f;
return;
}
const float log_modulus = logf(square_modulus) * 0.5f;
const float angle = atan2f(base->imaginary, base->real);
const float power_modulus = expf(real_exponent * log_modulus - imaginary_exponent * angle);
const float power_angle = real_exponent * angle + imaginary_exponent * log_modulus;
power->real = power_modulus * cosf(power_angle);
power->imaginary = power_modulus * sinf(power_angle);
}
void bgc_complex_get_exponation_fp64(const BgcComplexFP64* base, const double real_exponent, const double imaginary_exponent, BgcComplexFP64* power)
{
const double square_modulus = bgc_complex_get_square_modulus_fp64(base);
if (square_modulus <= BGC_SQUARE_EPSYLON_FP64) {
power->real = 0.0;
power->imaginary = 0.0;
return;
}
const double log_modulus = log(square_modulus) * 0.5;
const double angle = atan2(base->imaginary, base->real);
const double power_modulus = exp(real_exponent * log_modulus - imaginary_exponent * angle);
const double power_angle = real_exponent * angle + imaginary_exponent * log_modulus;
power->real = power_modulus * cos(power_angle);
power->imaginary = power_modulus * sin(power_angle);
}

531
basic-geometry/complex.h
View file

Internal server error - Personal Git Server: Beyond coding. We Forge.

500

Internal server error

Forgejo version: 11.0.1+gitea-1.22.0

 @ -1,531 +0,0 @@
#ifndef _BGC_COMPLEX_H_
#define _BGC_COMPLEX_H_
#include "utilities.h"
#include "angle.h"
#include <math.h>
typedef struct
{
float real, imaginary;
} BgcComplexFP32;
typedef struct
{
double real, imaginary;
} BgcComplexFP64;
// =================== Reset ==================== //
inline void bgc_complex_reset_fp32(BgcComplexFP32* complex)
{
complex->real = 0.0f;
complex->imaginary = 0.0f;
}
inline void bgc_complex_reset_fp64(BgcComplexFP64* complex)
{
complex->real = 0.0;
complex->imaginary = 0.0;
}
// ==================== Set ===================== //
inline void bgc_complex_set_values_fp32(const float real, const float imaginary, BgcComplexFP32* destination)
{
destination->real = real;
destination->imaginary = imaginary;
}
inline void bgc_complex_set_values_fp64(const double real, const double imaginary, BgcComplexFP64* destination)
{
destination->real = real;
destination->imaginary = imaginary;
}
// ================== Modulus =================== //
inline float bgc_complex_get_square_modulus_fp32(const BgcComplexFP32* number)
{
return number->real * number->real + number->imaginary * number->imaginary;
}
inline double bgc_complex_get_square_modulus_fp64(const BgcComplexFP64* number)
{
return number->real * number->real + number->imaginary * number->imaginary;
}
inline float bgc_complex_get_modulus_fp32(const BgcComplexFP32* number)
{
return sqrtf(bgc_complex_get_square_modulus_fp32(number));
}
inline double bgc_complex_get_modulus_fp64(const BgcComplexFP64* number)
{
return sqrt(bgc_complex_get_square_modulus_fp64(number));
}
// ================= Comparison ================= //
inline int bgc_complex_is_zero_fp32(const BgcComplexFP32* number)
{
return bgc_complex_get_square_modulus_fp32(number) <= BGC_SQUARE_EPSYLON_FP32;
}
inline int bgc_complex_is_zero_fp64(const BgcComplexFP64* number)
{
return bgc_complex_get_square_modulus_fp64(number) <= BGC_SQUARE_EPSYLON_FP64;
}
inline int bgc_complex_is_unit_fp32(const BgcComplexFP32* number)
{
return bgc_is_sqare_unit_fp32(bgc_complex_get_square_modulus_fp32(number));
}
inline int bgc_complex_is_unit_fp64(const BgcComplexFP64* number)
{
return bgc_is_sqare_unit_fp64(bgc_complex_get_square_modulus_fp64(number));
}
// ==================== Copy ==================== //
inline void bgc_complex_copy_fp32(const BgcComplexFP32* source, BgcComplexFP32* destination)
{
destination->real = source->real;
destination->imaginary = source->imaginary;
}
inline void bgc_complex_copy_fp64(const BgcComplexFP64* source, BgcComplexFP64* destination)
{
destination->real = source->real;
destination->imaginary = source->imaginary;
}
// ==================== Swap ==================== //
inline void bgc_complex_swap_fp32(BgcComplexFP32* number1, BgcComplexFP32* number2)
{
const float real = number2->real;
const float imaginary = number2->imaginary;
number2->real = number1->real;
number2->imaginary = number1->imaginary;
number1->real = real;
number1->imaginary = imaginary;
}
inline void bgc_complex_swap_fp64(BgcComplexFP64* number1, BgcComplexFP64* number2)
{
const double real = number2->real;
const double imaginary = number2->imaginary;
number2->real = number1->real;
number2->imaginary = number1->imaginary;
number1->real = real;
number1->imaginary = imaginary;
}
// ================== Convert =================== //
inline void bgc_complex_convert_fp64_to_fp32(const BgcComplexFP64* source, BgcComplexFP32* destination)
{
destination->real = (float)source->real;
destination->imaginary = (float)source->imaginary;
}
inline void bgc_complex_convert_fp32_to_fp64(const BgcComplexFP32* source, BgcComplexFP64* destination)
{
destination->real = source->real;
destination->imaginary = source->imaginary;
}
// ================== Reverse =================== //
inline void bgc_complex_reverse_fp32(const BgcComplexFP32* number, BgcComplexFP32* reverse)
{
reverse->real = -number->real;
reverse->imaginary = -number->imaginary;
}
inline void bgc_complex_reverse_fp64(const BgcComplexFP64* number, BgcComplexFP64* reverse)
{
reverse->real = -number->real;
reverse->imaginary = -number->imaginary;
}
// ================= Normalize ================== //
inline int bgc_complex_normalize_fp32(const BgcComplexFP32* number, BgcComplexFP32* normalized)
{
const float square_modulus = bgc_complex_get_square_modulus_fp32(number);
if (bgc_is_sqare_unit_fp32(square_modulus)) {
normalized->real = number->real;
normalized->imaginary = number->imaginary;
return 1;
}
if (square_modulus <= BGC_SQUARE_EPSYLON_FP32 || square_modulus != square_modulus) {
return 0;
}
const float multiplicand = sqrtf(1.0f / square_modulus);
normalized->real = number->real * multiplicand;
normalized->imaginary = number->imaginary * multiplicand;
return 1;
}
inline int bgc_complex_normalize_fp64(const BgcComplexFP64* number, BgcComplexFP64* normalized)
{
const double square_modulus = bgc_complex_get_square_modulus_fp64(number);
if (bgc_is_sqare_unit_fp64(square_modulus)) {
normalized->real = number->real;
normalized->imaginary = number->imaginary;
return 1;
}
if (square_modulus <= BGC_SQUARE_EPSYLON_FP64 || square_modulus != square_modulus) {
return 0;
}
const double multiplicand = sqrt(1.0 / square_modulus);
normalized->real = number->real * multiplicand;
normalized->imaginary = number->imaginary * multiplicand;
return 1;
}
// ================= Conjugate ================== //
inline void bgc_complex_conjugate_fp32(const BgcComplexFP32* number, BgcComplexFP32* conjugate)
{
conjugate->real = number->real;
conjugate->imaginary = -number->imaginary;
}
inline void bgc_complex_conjugate_fp64(const BgcComplexFP64* number, BgcComplexFP64* conjugate)
{
conjugate->real = number->real;
conjugate->imaginary = -number->imaginary;
}
// =================== Invert =================== //
inline int bgc_complex_invert_fp32(const BgcComplexFP32* number, BgcComplexFP32* inverted)
{
const float square_modulus = bgc_complex_get_square_modulus_fp32(number);
if (square_modulus <= BGC_SQUARE_EPSYLON_FP32 || square_modulus != square_modulus) {
return 0;
}
const float multiplicand = 1.0f / square_modulus;
inverted->real = number->real * multiplicand;
inverted->imaginary = -number->imaginary * multiplicand;
return 1;
}
inline int bgc_complex_invert_fp64(const BgcComplexFP64* number, BgcComplexFP64* inverted)
{
const double square_modulus = bgc_complex_get_square_modulus_fp64(number);
if (square_modulus <= BGC_SQUARE_EPSYLON_FP64 || square_modulus != square_modulus) {
return 0;
}
const double multiplicand = 1.0 / square_modulus;
inverted->real = number->real * multiplicand;
inverted->imaginary = -number->imaginary * multiplicand;
return 1;
}
// ================ Get Product ================= //
inline void bgc_complex_get_product_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2, BgcComplexFP32* result)
{
const float real = number1->real * number2->real - number1->imaginary * number2->imaginary;
const float imaginary = number1->real * number2->imaginary + number1->imaginary * number2->real;
result->real = real;
result->imaginary = imaginary;
}
inline void bgc_complex_get_product_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2, BgcComplexFP64* result)
{
const double real = number1->real * number2->real - number1->imaginary * number2->imaginary;
const double imaginary = number1->real * number2->imaginary + number1->imaginary * number2->real;
result->real = real;
result->imaginary = imaginary;
}
// ================= Get Ratio ================== //
inline int bgc_complex_get_ratio_fp32(const BgcComplexFP32* divident, const BgcComplexFP32* divisor, BgcComplexFP32* quotient)
{
const float square_modulus = bgc_complex_get_square_modulus_fp32(divisor);
if (square_modulus <= BGC_SQUARE_EPSYLON_FP32) {
return 0;
}
const float real = divident->real * divisor->real + divident->imaginary * divisor->imaginary;
const float imaginary = divident->imaginary * divisor->real - divident->real * divisor->imaginary;
const float multiplier = 1.0f / square_modulus;
quotient->real = real * multiplier;
quotient->imaginary = imaginary * multiplier;
return 1;
}
inline int bgc_complex_get_ratio_fp64(const BgcComplexFP64* divident, const BgcComplexFP64* divisor, BgcComplexFP64* quotient)
{
const double square_modulus = bgc_complex_get_square_modulus_fp64(divisor);
if (square_modulus <= BGC_SQUARE_EPSYLON_FP64) {
return 0;
}
const double real = divident->real * divisor->real + divident->imaginary * divisor->imaginary;
const double imaginary = divident->imaginary * divisor->real - divident->real * divisor->imaginary;
const double multiplier = 1.0 / square_modulus;
quotient->real = real * multiplier;
quotient->imaginary = imaginary * multiplier;
return 1;
}
// =============== Get Exponation =============== //
void bgc_complex_get_exponation_fp32(const BgcComplexFP32* base, const float real_exponent, const float imaginary_exponent, BgcComplexFP32* power);
void bgc_complex_get_exponation_fp64(const BgcComplexFP64* base, const double real_exponent, const double imaginary_exponent, BgcComplexFP64* power);
// ==================== Add ===================== //
inline void bgc_complex_add_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2, BgcComplexFP32* sum)
{
sum->real = number1->real + number2->real;
sum->imaginary = number1->imaginary + number2->imaginary;
}
inline void bgc_complex_add_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2, BgcComplexFP64* sum)
{
sum->real = number1->real + number2->real;
sum->imaginary = number1->imaginary + number2->imaginary;
}
// ================= Add scaled ================= //
inline void bgc_complex_add_scaled_fp32(const BgcComplexFP32* basic_number, const BgcComplexFP32* scalable_number, const float scale, BgcComplexFP32* sum)
{
sum->real = basic_number->real + scalable_number->real * scale;
sum->imaginary = basic_number->imaginary + scalable_number->imaginary * scale;
}
inline void bgc_complex_add_scaled_fp64(const BgcComplexFP64* basic_number, const BgcComplexFP64* scalable_number, const double scale, BgcComplexFP64* sum)
{
sum->real = basic_number->real + scalable_number->real * scale;
sum->imaginary = basic_number->imaginary + scalable_number->imaginary * scale;
}
// ================== Subtract ================== //
inline void bgc_complex_subtract_fp32(const BgcComplexFP32* minuend, const BgcComplexFP32* subtrahend, BgcComplexFP32* difference)
{
difference->real = minuend->real - subtrahend->real;
difference->imaginary = minuend->imaginary - subtrahend->imaginary;
}
inline void bgc_complex_subtract_fp64(const BgcComplexFP64* minuend, const BgcComplexFP64* subtrahend, BgcComplexFP64* difference)
{
difference->real = minuend->real - subtrahend->real;
difference->imaginary = minuend->imaginary - subtrahend->imaginary;
}
// ============== Subtract scaled =============== //
inline void bgc_complex_subtract_scaled_fp32(const BgcComplexFP32* basic_number, const BgcComplexFP32* scalable_number, const float scale, BgcComplexFP32* difference)
{
difference->real = basic_number->real - scalable_number->real * scale;
difference->imaginary = basic_number->imaginary - scalable_number->imaginary * scale;
}
inline void bgc_complex_subtract_scaled_fp64(const BgcComplexFP64* basic_number, const BgcComplexFP64* scalable_number, const double scale, BgcComplexFP64* difference)
{
difference->real = basic_number->real - scalable_number->real * scale;
difference->imaginary = basic_number->imaginary - scalable_number->imaginary * scale;
}
// ================== Multiply ================== //
inline void bgc_complex_multiply_fp32(const BgcComplexFP32* multiplicand, const float multiplier, BgcComplexFP32* product)
{
product->real = multiplicand->real * multiplier;
product->imaginary = multiplicand->imaginary * multiplier;
}
inline void bgc_complex_multiply_fp64(const BgcComplexFP64* multiplicand, const double multiplier, BgcComplexFP64* product)
{
product->real = multiplicand->real * multiplier;
product->imaginary = multiplicand->imaginary * multiplier;
}
// =================== Divide =================== //
inline void bgc_complex_divide_fp32(const BgcComplexFP32* dividend, const float divisor, BgcComplexFP32* quotient)
{
bgc_complex_multiply_fp32(dividend, 1.0f / divisor, quotient);
}
inline void bgc_complex_divide_fp64(const BgcComplexFP64* dividend, const double divisor, BgcComplexFP64* quotient)
{
bgc_complex_multiply_fp64(dividend, 1.0 / divisor, quotient);
}
// ================== Average2 ================== //
inline void bgc_complex_get_mean_of_two_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2, BgcComplexFP32* mean)
{
mean->real = (number1->real + number2->real) * 0.5f;
mean->imaginary = (number1->imaginary + number2->imaginary) * 0.5f;
}
inline void bgc_complex_get_mean_of_two_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2, BgcComplexFP64* mean)
{
mean->real = (number1->real + number2->real) * 0.5;
mean->imaginary = (number1->imaginary + number2->imaginary) * 0.5;
}
// ================== Average3 ================== //
inline void bgc_complex_get_mean_of_three_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2, const BgcComplexFP32* number3, BgcComplexFP32* mean)
{
mean->real = (number1->real + number2->real + number3->real) * BGC_ONE_THIRD_FP32;
mean->imaginary = (number1->imaginary + number2->imaginary + number3->imaginary) * BGC_ONE_THIRD_FP32;
}
inline void bgc_complex_get_mean_of_three_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2, const BgcComplexFP64* number3, BgcComplexFP64* mean)
{
mean->real = (number1->real + number2->real + number3->real) * BGC_ONE_THIRD_FP64;