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

@ -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;
mean->imaginary = (number1->imaginary + number2->imaginary + number3->imaginary) * BGC_ONE_THIRD_FP64;
}
// =================== Linear =================== //
inline void bgc_complex_interpolate_linearly_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2, const float phase, BgcComplexFP32* interpolation)
{
const float counterphase = 1.0f - phase;
interpolation->real = number1->real * counterphase + number2->real * phase;
interpolation->imaginary = number1->imaginary * counterphase + number2->imaginary * phase;
}
inline void bgc_complex_interpolate_linearly_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2, const double phase, BgcComplexFP64* interpolation)
{
const double counterphase = 1.0 - phase;
interpolation->real = number1->real * counterphase + number2->real * phase;
interpolation->imaginary = number1->imaginary * counterphase + number2->imaginary * phase;
}
// ================== Minimal =================== //
inline void bgc_complex_minimize_fp32(const BgcComplexFP32* number, BgcComplexFP32* minimal)
{
if (number->real < minimal->real) {
minimal->real = number->real;
}
if (number->imaginary < minimal->imaginary) {
minimal->imaginary = number->imaginary;
}
}
inline void bgc_complex_minimize_fp64(const BgcComplexFP64* number, BgcComplexFP64* minimal)
{
if (number->real < minimal->real) {
minimal->real = number->real;
}
if (number->imaginary < minimal->imaginary) {
minimal->imaginary = number->imaginary;
}
}
// ================== Maximal =================== //
inline void bgc_complex_maximize_fp32(const BgcComplexFP32* number, BgcComplexFP32* maximal)
{
if (number->real > maximal->real) {
maximal->real = number->real;
}
if (number->imaginary > maximal->imaginary) {
maximal->imaginary = number->imaginary;
}
}
inline void bgc_complex_maximize_fp64(const BgcComplexFP64* number, BgcComplexFP64* maximal)
{
if (number->real > maximal->real) {
maximal->real = number->real;
}
if (number->imaginary > maximal->imaginary) {
maximal->imaginary = number->imaginary;
}
}
// ================== Are Close ================= //
inline int bgc_complex_are_close_fp32(const BgcComplexFP32* number1, const BgcComplexFP32* number2)
{
const float square_modulus1 = bgc_complex_get_square_modulus_fp32(number1);
const float square_modulus2 = bgc_complex_get_square_modulus_fp32(number2);
const float d_real = number1->real - number2->real;
const float d_imaginary = number1->imaginary - number2->imaginary;
const float square_distance = d_real * d_real + d_imaginary * d_imaginary;
if (square_modulus1 <= BGC_EPSYLON_EFFECTIVENESS_LIMIT_FP32 || square_modulus2 <= BGC_EPSYLON_EFFECTIVENESS_LIMIT_FP32) {
return square_distance <= BGC_SQUARE_EPSYLON_FP32;
}
return square_distance <= BGC_SQUARE_EPSYLON_FP32 * square_modulus1 && square_distance <= BGC_SQUARE_EPSYLON_FP32 * square_modulus2;
}
inline int bgc_complex_are_close_fp64(const BgcComplexFP64* number1, const BgcComplexFP64* number2)
{
const double square_modulus1 = bgc_complex_get_square_modulus_fp64(number1);
const double square_modulus2 = bgc_complex_get_square_modulus_fp64(number2);
const double d_real = number1->real - number2->real;
const double d_imaginary = number1->imaginary - number2->imaginary;
const double square_distance = d_real * d_real + d_imaginary * d_imaginary;
if (square_modulus1 <= BGC_EPSYLON_EFFECTIVENESS_LIMIT_FP64 || square_modulus2 <= BGC_EPSYLON_EFFECTIVENESS_LIMIT_FP64) {
return square_distance <= BGC_SQUARE_EPSYLON_FP64;
}
return square_distance <= BGC_SQUARE_EPSYLON_FP32 * square_modulus1 && square_distance <= BGC_SQUARE_EPSYLON_FP32 * square_modulus2;
}
#endif

85
basic-geometry/cotes-number.c
View file

@ -1,85 +0,0 @@
#include "./cotes-number.h"
const BgcCotesNumberFP32 BGC_IDLE_COTES_NUMBER_FP32 = { 1.0f, 0.0f };
const BgcCotesNumberFP64 BGC_IDLE_COTES_NUMBER_FP64 = { 1.0, 0.0 };
extern inline void bgc_cotes_number_reset_fp32(BgcCotesNumberFP32* number);
extern inline void bgc_cotes_number_reset_fp64(BgcCotesNumberFP64* number);
extern inline void bgc_cotes_number_set_values_fp32(const float x1, const float x2, BgcCotesNumberFP32* number);
extern inline void bgc_cotes_number_set_values_fp64(const double x1, const double x2, BgcCotesNumberFP64* number);
extern inline void bgc_cotes_number_set_turn_fp32(const float angle, const BgcAngleUnitEnum unit, BgcCotesNumberFP32* number);
extern inline void bgc_cotes_number_set_turn_fp64(const double angle, const BgcAngleUnitEnum unit, BgcCotesNumberFP64* number);
extern inline float bgc_cotes_number_get_angle_fp32(const BgcCotesNumberFP32* number, const BgcAngleUnitEnum unit);
extern inline double bgc_cotes_number_get_angle_fp64(const BgcCotesNumberFP64* number, const BgcAngleUnitEnum unit);
extern inline void bgc_cotes_number_copy_fp32(const BgcCotesNumberFP32* source, BgcCotesNumberFP32* destination);
extern inline void bgc_cotes_number_copy_fp64(const BgcCotesNumberFP64* source, BgcCotesNumberFP64* destination);
extern inline void bgc_cotes_number_swap_fp32(BgcCotesNumberFP32* number1, BgcCotesNumberFP32* number2);
extern inline void bgc_cotes_number_swap_fp64(BgcCotesNumberFP64* number1, BgcCotesNumberFP64* number2);
extern inline void bgc_cotes_number_convert_fp64_to_fp32(const BgcCotesNumberFP64* source, BgcCotesNumberFP32* destination);
extern inline void bgc_cotes_number_convert_fp32_to_fp64(const BgcCotesNumberFP32* source, BgcCotesNumberFP64* destination);
extern inline void bgc_cotes_number_invert_fp32(const BgcCotesNumberFP32* number, BgcCotesNumberFP32* inverted);
extern inline void bgc_cotes_number_invert_fp64(const BgcCotesNumberFP64* number, BgcCotesNumberFP64* inverted);
extern inline void bgc_cotes_number_get_exponation_fp32(const BgcCotesNumberFP32* base, const float exponent, BgcCotesNumberFP32* power);
extern inline void bgc_cotes_number_get_exponation_fp64(const BgcCotesNumberFP64* base, const double exponent, BgcCotesNumberFP64* power);
extern inline void bgc_cotes_number_combine_fp32(const BgcCotesNumberFP32* number1, const BgcCotesNumberFP32* number2, BgcCotesNumberFP32* result);
extern inline void bgc_cotes_number_combine_fp64(const BgcCotesNumberFP64* number1, const BgcCotesNumberFP64* number2, BgcCotesNumberFP64* result);
extern inline void bgc_cotes_number_exclude_fp32(const BgcCotesNumberFP32* base, const BgcCotesNumberFP32* excludant, BgcCotesNumberFP32* difference);
extern inline void bgc_cotes_number_exclude_fp64(const BgcCotesNumberFP64* base, const BgcCotesNumberFP64* excludant, BgcCotesNumberFP64* difference);
extern inline void bgc_cotes_number_get_rotation_matrix_fp32(const BgcCotesNumberFP32* number, BgcMatrix2x2FP32* matrix);
extern inline void bgc_cotes_number_get_rotation_matrix_fp64(const BgcCotesNumberFP64* number, BgcMatrix2x2FP64* matrix);
extern inline void bgc_cotes_number_get_reverse_matrix_fp32(const BgcCotesNumberFP32* number, BgcMatrix2x2FP32* matrix);
extern inline void bgc_cotes_number_get_reverse_matrix_fp64(const BgcCotesNumberFP64* number, BgcMatrix2x2FP64* matrix);
extern inline void bgc_cotes_number_turn_vector_fp32(const BgcCotesNumberFP32* number, const BgcVector2FP32* vector, BgcVector2FP32* result);
extern inline void bgc_cotes_number_turn_vector_fp64(const BgcCotesNumberFP64* number, const BgcVector2FP64* vector, BgcVector2FP64* result);
extern inline void bgc_cotes_number_turn_vector_back_fp32(const BgcCotesNumberFP32* number, const BgcVector2FP32* vector, BgcVector2FP32* result);
extern inline void bgc_cotes_number_turn_vector_back_fp64(const BgcCotesNumberFP64* number, const BgcVector2FP64* vector, BgcVector2FP64* result);
extern inline int bgc_cotes_number_are_close_fp32(const BgcCotesNumberFP32* number1, const BgcCotesNumberFP32* number2);
extern inline int bgc_cotes_number_are_close_fp64(const BgcCotesNumberFP64* number1, const BgcCotesNumberFP64* number2);
void _bgc_cotes_number_normalize_fp32(const float square_modulus, _BgcTwinCotesNumberFP32* twin)
{
// (square_modulus != square_modulus) is true when square_modulus is NaN
if (square_modulus <= BGC_SQUARE_EPSYLON_FP32 || square_modulus != square_modulus) {
twin->cos = 1.0f;
twin->sin = 0.0f;
return;
}
const float multiplier = sqrtf(1.0f / square_modulus);
twin->cos *= multiplier;
twin->sin *= multiplier;
}
void _bgc_cotes_number_normalize_fp64(const double square_modulus, _BgcTwinCotesNumberFP64* twin)
{
// (square_modulus != square_modulus) is true when square_modulus is NaN
if (square_modulus <= BGC_SQUARE_EPSYLON_FP64 || square_modulus != square_modulus) {
twin->cos = 1.0;
twin->sin = 0.0;
return;
}
const double multiplier = sqrt(1.0 / square_modulus);
twin->cos *= multiplier;
twin->sin *= multiplier;
}

394
basic-geometry/cotes-number.h
View file

@ -1,394 +0,0 @@
#ifndef _BGC_COTES_NUMBER_H_
#define _BGC_COTES_NUMBER_H_
#include <math.h>
#include "utilities.h"
#include "angle.h"
#include "vector2.h"
#include "matrix2x2.h"
// =================== Types ==================== //
typedef struct
{
const float cos, sin;
} BgcCotesNumberFP32;
typedef struct
{
const double cos, sin;
} BgcCotesNumberFP64;
// ================= Dark Twins ================= //
typedef struct {
float cos, sin;
} _BgcTwinCotesNumberFP32;
typedef struct {
double cos, sin;
} _BgcTwinCotesNumberFP64;
// ================= Constants ================== //
extern const BgcCotesNumberFP32 BGC_IDLE_COTES_NUMBER_FP32;
extern const BgcCotesNumberFP64 BGC_IDLE_COTES_NUMBER_FP64;
// =================== Reset ==================== //
inline void bgc_cotes_number_reset_fp32(BgcCotesNumberFP32* number)
{
_BgcTwinCotesNumberFP32* twin = (_BgcTwinCotesNumberFP32*)number;
twin->cos = 1.0f;
twin->sin = 0.0f;
}
inline void bgc_cotes_number_reset_fp64(BgcCotesNumberFP64* number)
{
_BgcTwinCotesNumberFP64* twin = (_BgcTwinCotesNumberFP64*)number;
twin->cos = 1.0;
twin->sin = 0.0;
}
// ==================== Set ===================== //
void _bgc_cotes_number_normalize_fp32(const float square_modulus, _BgcTwinCotesNumberFP32* twin);
void _bgc_cotes_number_normalize_fp64(const double square_modulus, _BgcTwinCotesNumberFP64* twin);
inline void bgc_cotes_number_set_values_fp32(const float x1, const float x2, BgcCotesNumberFP32* number)
{
const float square_modulus = x1 * x1 + x2 * x2;
_BgcTwinCotesNumberFP32* twin = (_BgcTwinCotesNumberFP32*)number;
twin->cos = x1;
twin->sin = x2;
if (!bgc_is_sqare_unit_fp32(square_modulus)) {
_bgc_cotes_number_normalize_fp32(square_modulus, twin);
}
}
inline void bgc_cotes_number_set_values_fp64(const double x1, const double x2, BgcCotesNumberFP64* number)
{
const double square_modulus = x1 * x1 + x2 * x2;
_BgcTwinCotesNumberFP64* twin = (_BgcTwinCotesNumberFP64*)number;
twin->cos = x1;
twin->sin = x2;
if (!bgc_is_sqare_unit_fp64(square_modulus)) {
_bgc_cotes_number_normalize_fp64(square_modulus, twin);
}
}
// ================== Set Turn ================== //
inline void bgc_cotes_number_set_turn_fp32(const float angle, const BgcAngleUnitEnum unit, BgcCotesNumberFP32* number)
{
const float radians = bgc_angle_to_radians_fp32(angle, unit);
_BgcTwinCotesNumberFP32* twin = (_BgcTwinCotesNumberFP32*)number;
twin->cos = cosf(radians);
twin->sin = sinf(radians);
}
inline void bgc_cotes_number_set_turn_fp64(const double angle, const BgcAngleUnitEnum unit, BgcCotesNumberFP64* number)
{
const double radians = bgc_angle_to_radians_fp64(angle, unit);
_BgcTwinCotesNumberFP64* twin = (_BgcTwinCotesNumberFP64*)number;
twin->cos = cos(radians);
twin->sin = sin(radians);
}
// =================== Angle =================== //
inline float bgc_cotes_number_get_angle_fp32(const BgcCotesNumberFP32* number, const BgcAngleUnitEnum unit)
{
if (number->cos >= 1.0f - BGC_EPSYLON_FP32) {
return 0.0f;
}
if (number->cos <= -1.0f + BGC_EPSYLON_FP32) {
return bgc_angle_get_half_circle_fp32(unit);
}
if (number->sin >= 1.0f - BGC_EPSYLON_FP32) {
return bgc_angle_get_quater_circle_fp32(unit);
}
if (number->sin <= -1.0f + BGC_EPSYLON_FP32) {
return 0.75f * bgc_angle_get_full_circle_fp32(unit);
}
return bgc_radians_to_units_fp32(atan2f(number->sin, number->cos), unit);
}
inline double bgc_cotes_number_get_angle_fp64(const BgcCotesNumberFP64* number, const BgcAngleUnitEnum unit)
{
if (number->cos >= 1.0 - BGC_EPSYLON_FP64) {
return 0.0;
}
if (number->cos <= -1.0 + BGC_EPSYLON_FP64) {
return bgc_angle_get_half_circle_fp64(unit);
}
if (number->sin >= 1.0 - BGC_EPSYLON_FP64) {
return bgc_angle_get_quater_circle_fp64(unit);
}
if (number->sin <= -1.0 + BGC_EPSYLON_FP64) {
return 0.75 * bgc_angle_get_full_circle_fp64(unit);
}
return bgc_radians_to_units_fp64(atan2(number->sin, number->cos), unit);
}
// ==================== Copy ==================== //
inline void bgc_cotes_number_copy_fp32(const BgcCotesNumberFP32* source, BgcCotesNumberFP32* destination)
{
_BgcTwinCotesNumberFP32* twin = (_BgcTwinCotesNumberFP32*)destination;
twin->cos = source->cos;
twin->sin = source->sin;
}
inline void bgc_cotes_number_copy_fp64(const BgcCotesNumberFP64* source, BgcCotesNumberFP64* destination)
{
_BgcTwinCotesNumberFP64* twin = (_BgcTwinCotesNumberFP64*)destination;
twin->cos = source->cos;
twin->sin = source->sin;
}
// ==================== Swap ==================== //
inline void bgc_cotes_number_swap_fp32(BgcCotesNumberFP32* number1, BgcCotesNumberFP32* number2)
{
const float cos = number1->cos;
const float sin = number1->sin;
_BgcTwinCotesNumberFP32* twin1 = (_BgcTwinCotesNumberFP32*)number1;
twin1->cos = number2->cos;
twin1->sin = number2->sin;
_BgcTwinCotesNumberFP32* twin2 = (_BgcTwinCotesNumberFP32*)number2;
twin2->cos = cos;
twin2->sin = sin;
}
inline void bgc_cotes_number_swap_fp64(BgcCotesNumberFP64* number1, BgcCotesNumberFP64* number2)
{
const double cos = number1->cos;
const double sin = number1->sin;
_BgcTwinCotesNumberFP64* twin1 = (_BgcTwinCotesNumberFP64*)number1;
twin1->cos = number2->cos;
twin1->sin = number2->sin;
_BgcTwinCotesNumberFP64* twin2 = (_BgcTwinCotesNumberFP64*)number2;
twin2->cos = cos;
twin2->sin = sin;
}
// ================== Convert =================== //
inline void bgc_cotes_number_convert_fp64_to_fp32(const BgcCotesNumberFP64* source, BgcCotesNumberFP32* destination)
{
bgc_cotes_number_set_values_fp32((float)source->cos, (float)source->sin, destination);
}
inline void bgc_cotes_number_convert_fp32_to_fp64(const BgcCotesNumberFP32* source, BgcCotesNumberFP64* destination)
{
bgc_cotes_number_set_values_fp64((double)source->cos, (double)source->sin, destination);
}
// =================== Invert =================== //
inline void bgc_cotes_number_invert_fp32(const BgcCotesNumberFP32* number, BgcCotesNumberFP32* inverted)
{
_BgcTwinCotesNumberFP32* twin = (_BgcTwinCotesNumberFP32*)inverted;
twin->cos = number->cos;
twin->sin = -number->sin;
}
inline void bgc_cotes_number_invert_fp64(const BgcCotesNumberFP64* number, BgcCotesNumberFP64* inverted)
{
_BgcTwinCotesNumberFP64* twin = (_BgcTwinCotesNumberFP64*)inverted;
twin->cos = number->cos;
twin->sin = -number->sin;
}
// ================= Exponation ================= //
inline void bgc_cotes_number_get_exponation_fp32(const BgcCotesNumberFP32* base, const float exponent, BgcCotesNumberFP32* power)
{
const float power_angle = exponent * atan2f(base->sin, base->cos);
_BgcTwinCotesNumberFP32* twin = (_BgcTwinCotesNumberFP32*)power;
twin->cos = cosf(power_angle);
twin->sin = sinf(power_angle);
}
inline void bgc_cotes_number_get_exponation_fp64(const BgcCotesNumberFP64* base, const double exponent, BgcCotesNumberFP64* power)
{
const double power_angle = exponent * atan2(base->sin, base->cos);
_BgcTwinCotesNumberFP64* twin = (_BgcTwinCotesNumberFP64*)power;
twin->cos = cos(power_angle);
twin->sin = sin(power_angle);
}
// ================ Combination ================= //
inline void bgc_cotes_number_combine_fp32(const BgcCotesNumberFP32* number1, const BgcCotesNumberFP32* number2, BgcCotesNumberFP32* result)
{
bgc_cotes_number_set_values_fp32(
number1->cos * number2->cos - number1->sin * number2->sin,
number1->cos * number2->sin + number1->sin * number2->cos,
result
);
}
inline void bgc_cotes_number_combine_fp64(const BgcCotesNumberFP64* number1, const BgcCotesNumberFP64* number2, BgcCotesNumberFP64* result)
{
bgc_cotes_number_set_values_fp64(
number1->cos * number2->cos - number1->sin * number2->sin,
number1->cos * number2->sin + number1->sin * number2->cos,
result
);
}
// ================= Exclusion ================== //
inline void bgc_cotes_number_exclude_fp32(const BgcCotesNumberFP32* base, const BgcCotesNumberFP32* excludant, BgcCotesNumberFP32* difference)
{
bgc_cotes_number_set_values_fp32(
base->cos * excludant->cos + base->sin * excludant->sin,
base->sin * excludant->cos - base->cos * excludant->sin,
difference
);
}
inline void bgc_cotes_number_exclude_fp64(const BgcCotesNumberFP64* base, const BgcCotesNumberFP64* excludant, BgcCotesNumberFP64* difference)
{
bgc_cotes_number_set_values_fp64(
base->cos * excludant->cos + base->sin * excludant->sin,
base->sin * excludant->cos - base->cos * excludant->sin,
difference
);
}
// ============== Rotation Matrix =============== //
inline void bgc_cotes_number_get_rotation_matrix_fp32(const BgcCotesNumberFP32* number, BgcMatrix2x2FP32* matrix)
{
matrix->r1c1 = number->cos;
matrix->r1c2 = -number->sin;
matrix->r2c1 = number->sin;
matrix->r2c2 = number->cos;
}
inline void bgc_cotes_number_get_rotation_matrix_fp64(const BgcCotesNumberFP64* number, BgcMatrix2x2FP64* matrix)
{
matrix->r1c1 = number->cos;
matrix->r1c2 = -number->sin;
matrix->r2c1 = number->sin;
matrix->r2c2 = number->cos;
}
// ============== Reverse Matrix ================ //
inline void bgc_cotes_number_get_reverse_matrix_fp32(const BgcCotesNumberFP32* number, BgcMatrix2x2FP32* matrix)
{
matrix->r1c1 = number->cos;
matrix->r1c2 = number->sin;
matrix->r2c1 = -number->sin;
matrix->r2c2 = number->cos;
}
inline void bgc_cotes_number_get_reverse_matrix_fp64(const BgcCotesNumberFP64* number, BgcMatrix2x2FP64* matrix)
{
matrix->r1c1 = number->cos;
matrix->r1c2 = number->sin;
matrix->r2c1 = -number->sin;
matrix->r2c2 = number->cos;
}
// ================ Turn Vector ================= //
inline void bgc_cotes_number_turn_vector_fp32(const BgcCotesNumberFP32* number, const BgcVector2FP32* vector, BgcVector2FP32* result)
{
const float x1 = number->cos * vector->x1 - number->sin * vector->x2;
const float x2 = number->sin * vector->x1 + number->cos * vector->x2;
result->x1 = x1;
result->x2 = x2;
}
inline void bgc_cotes_number_turn_vector_fp64(const BgcCotesNumberFP64* number, const BgcVector2FP64* vector, BgcVector2FP64* result)
{
const double x1 = number->cos * vector->x1 - number->sin * vector->x2;
const double x2 = number->sin * vector->x1 + number->cos * vector->x2;
result->x1 = x1;
result->x2 = x2;
}
// ============ Turn Vector Backward ============ //
inline void bgc_cotes_number_turn_vector_back_fp32(const BgcCotesNumberFP32* number, const BgcVector2FP32* vector, BgcVector2FP32* result)
{
const float x1 = number->sin * vector->x2 + number->cos * vector->x1;
const float x2 = number->cos * vector->x2 - number->sin * vector->x1;
result->x1 = x1;
result->x2 = x2;
}
inline void bgc_cotes_number_turn_vector_back_fp64(const BgcCotesNumberFP64* number, const BgcVector2FP64* vector, BgcVector2FP64* result)
{
const double x1 = number->sin * vector->x2 + number->cos * vector->x1;
const double x2 = number->cos * vector->x2 - number->sin * vector->x1;
result->x1 = x1;
result->x2 = x2;
}
// ================== Are Close ================= //
inline int bgc_cotes_number_are_close_fp32(const BgcCotesNumberFP32* number1, const BgcCotesNumberFP32* number2)
{
const float d_cos = number1->cos - number2->cos;
const float d_sin = number1->sin - number2->sin;
return d_cos * d_cos + d_sin * d_sin <= BGC_SQUARE_EPSYLON_FP32;
}
inline int bgc_cotes_number_are_close_fp64(const BgcCotesNumberFP64* number1, const BgcCotesNumberFP64* number2)
{
const double d_cos = number1->cos - number2->cos;
const double d_sin = number1->sin - number2->sin;
return d_cos * d_cos + d_sin * d_sin <= BGC_SQUARE_EPSYLON_FP64;
}
#endif

92
basic-geometry/quaternion.c
View file

@ -1,4 +1,3 @@
#include <math.h>
#include "quaternion.h"
extern inline void bgc_quaternion_reset_fp32(BgcQuaternionFP32* quaternion);
@ -64,8 +63,8 @@ extern inline void bgc_quaternion_multiply_fp64(const BgcQuaternionFP64* multipl
extern inline void bgc_quaternion_divide_fp32(const BgcQuaternionFP32* dividend, const float divisor, BgcQuaternionFP32* quotient);
extern inline void bgc_quaternion_divide_fp64(const BgcQuaternionFP64* dividend, const double divisor, BgcQuaternionFP64* quotient);
extern inline void bgc_quaternion_interpolate_linearly_fp32(const BgcQuaternionFP32* vector1, const BgcQuaternionFP32* vector2, const float phase, BgcQuaternionFP32* interpolation);
extern inline void bgc_quaternion_interpolate_linearly_fp64(const BgcQuaternionFP64* vector1, const BgcQuaternionFP64* vector2, const double phase, BgcQuaternionFP64* interpolation);
extern inline void bgc_quaternion_get_linear_interpolation_fp32(const BgcQuaternionFP32* vector1, const BgcQuaternionFP32* vector2, const float phase, BgcQuaternionFP32* interpolation);
extern inline void bgc_quaternion_get_linear_interpolation_fp64(const BgcQuaternionFP64* vector1, const BgcQuaternionFP64* vector2, const double phase, BgcQuaternionFP64* interpolation);
extern inline int bgc_quaternion_get_rotation_matrix_fp32(const BgcQuaternionFP32* quaternion, BgcMatrix3x3FP32* rotation);
extern inline int bgc_quaternion_get_rotation_matrix_fp64(const BgcQuaternionFP64* quaternion, BgcMatrix3x3FP64* rotation);
@ -73,92 +72,5 @@ extern inline int bgc_quaternion_get_rotation_matrix_fp64(const BgcQuaternionFP6
extern inline int bgc_quaternion_get_reverse_matrix_fp32(const BgcQuaternionFP32* quaternion, BgcMatrix3x3FP32* reverse);
extern inline int bgc_quaternion_get_reverse_matrix_fp64(const BgcQuaternionFP64* quaternion, BgcMatrix3x3FP64* reverse);
extern inline int bgc_quaternion_get_both_matrixes_fp32(const BgcQuaternionFP32* quaternion, BgcMatrix3x3FP32* rotation, BgcMatrix3x3FP32* reverse);
extern inline int bgc_quaternion_get_both_matrixes_fp64(const BgcQuaternionFP64* quaternion, BgcMatrix3x3FP64* rotation, BgcMatrix3x3FP64* reverse);
extern inline int bgc_quaternion_are_close_fp32(const BgcQuaternionFP32* quaternion1, const BgcQuaternionFP32* quaternion2);
extern inline int bgc_quaternion_are_close_fp32(const BgcQuaternionFP32* quaternion1, const BgcQuaternionFP32* quaternion2);
// =============== Get Exponation =============== //
int bgc_quaternion_get_exponation_fp32(const BgcQuaternionFP32* base, const float exponent, BgcQuaternionFP32* power)
{
const float s0s0 = base->s0 * base->s0;
const float x1x1 = base->x1 * base->x1;
const float x2x2 = base->x2 * base->x2;
const float x3x3 = base->x3 * base->x3;
const float square_vector = x1x1 + (x2x2 + x3x3);
const float square_modulus = (s0s0 + x1x1) + (x2x2 + x3x3);
// square_modulus != square_modulus means checking for NaN value at square_modulus
if (square_modulus != square_modulus) {
return 0;
}
if (square_vector <= BGC_SQUARE_EPSYLON_FP32) {
if (base->s0 < 0.0f) {
return 0;
}
power->s0 = powf(base->s0, exponent);
power->x1 = 0.0f;
power->x2 = 0.0f;
power->x3 = 0.0f;
return 1;
}
const float vector_modulus = sqrtf(square_vector);
const float power_angle = atan2f(vector_modulus, base->s0) * exponent;
const float power_modulus = powf(square_modulus, 0.5f * exponent);
const float multiplier = power_modulus * sinf(power_angle) / vector_modulus;
power->s0 = power_modulus * cosf(power_angle);
power->x1 = base->x1 * multiplier;
power->x2 = base->x2 * multiplier;
power->x3 = base->x3 * multiplier;
return 1;
}
int bgc_quaternion_get_exponation_fp64(const BgcQuaternionFP64* base, const double exponent, BgcQuaternionFP64* power)
{
const double s0s0 = base->s0 * base->s0;
const double x1x1 = base->x1 * base->x1;
const double x2x2 = base->x2 * base->x2;
const double x3x3 = base->x3 * base->x3;
const double square_vector = x1x1 + (x2x2 + x3x3);
const double square_modulus = (s0s0 + x1x1) + (x2x2 + x3x3);
// square_modulus != square_modulus means checking for NaN value at square_modulus
if (square_modulus != square_modulus) {
return 0;
}
if (square_vector <= BGC_SQUARE_EPSYLON_FP64) {
if (base->s0 < 0.0) {
return 0;
}
power->s0 = pow(base->s0, exponent);
power->x1 = 0.0;
power->x2 = 0.0;
power->x3 = 0.0;
return 1;
}
const double vector_modulus = sqrt(square_vector);
const double power_angle = atan2(vector_modulus, base->s0) * exponent;
const double power_modulus = pow(square_modulus, 0.5 * exponent);
const double multiplier = power_modulus * sin(power_angle) / vector_modulus;
power->s0 = power_modulus * cos(power_angle);
power->x1 = base->x1 * multiplier;
power->x2 = base->x2 * multiplier;
power->x3 = base->x3 * multiplier;
return 1;
}

14
basic-geometry/quaternion.h
View file

@ -473,9 +473,9 @@ inline void bgc_quaternion_divide_fp64(const BgcQuaternionFP64* dividend, const
bgc_quaternion_multiply_fp64(dividend, 1.0 / divisor, quotient);
}
// ============ Linear Interpolation ============ //
// =================== Linear =================== //
inline void bgc_quaternion_interpolate_linearly_fp32(const BgcQuaternionFP32* quaternion1, const BgcQuaternionFP32* quaternion2, const float phase, BgcQuaternionFP32* interpolation)
inline void bgc_quaternion_get_linear_interpolation_fp32(const BgcQuaternionFP32* quaternion1, const BgcQuaternionFP32* quaternion2, const float phase, BgcQuaternionFP32* interpolation)
{
const float counterphase = 1.0f - phase;
@ -485,7 +485,7 @@ inline void bgc_quaternion_interpolate_linearly_fp32(const BgcQuaternionFP32* qu
interpolation->x3 = quaternion1->x3 * counterphase + quaternion2->x3 * phase;
}
inline void bgc_quaternion_interpolate_linearly_fp64(const BgcQuaternionFP64* quaternion1, const BgcQuaternionFP64* quaternion2, const double phase, BgcQuaternionFP64* interpolation)
inline void bgc_quaternion_get_linear_interpolation_fp64(const BgcQuaternionFP64* quaternion1, const BgcQuaternionFP64* quaternion2, const double phase, BgcQuaternionFP64* interpolation)
{
const double counterphase = 1.0 - phase;
@ -495,12 +495,6 @@ inline void bgc_quaternion_interpolate_linearly_fp64(const BgcQuaternionFP64* qu
interpolation->x3 = quaternion1->x3 * counterphase + quaternion2->x3 * phase;
}
// =============== Get Exponation =============== //
int bgc_quaternion_get_exponation_fp32(const BgcQuaternionFP32* base, const float exponent, BgcQuaternionFP32* power);
int bgc_quaternion_get_exponation_fp64(const BgcQuaternionFP64* base, const double exponent, BgcQuaternionFP64* power);
// ============ Get Rotation Matrix ============= //
inline int bgc_quaternion_get_rotation_matrix_fp32(const BgcQuaternionFP32* quaternion, BgcMatrix3x3FP32* rotation)
@ -665,8 +659,6 @@ inline int bgc_quaternion_get_reverse_matrix_fp64(const BgcQuaternionFP64* quate
return 1;
}
// ============= Get Both Matrixes ============== //
inline int bgc_quaternion_get_both_matrixes_fp32(const BgcQuaternionFP32* quaternion, BgcMatrix3x3FP32* rotation, BgcMatrix3x3FP32* reverse)
{
if (bgc_quaternion_get_reverse_matrix_fp32(quaternion, reverse)) {

16
basic-geometry/rotation3.h
View file

@ -47,7 +47,7 @@ inline void bgc_rotation3_set_values_fp32(const float x1, const float x2, const
rotation->axis.x2 = x2;
rotation->axis.x3 = x3;
if (bgc_vector3_normalize_fp32(&rotation->axis)) {
if (bgc_vector3_normalize_fp32(&rotation->axis, &rotation->axis)) {
rotation->radians = bgc_angle_to_radians_fp32(angle, unit);
}
else {
@ -62,7 +62,7 @@ inline void bgc_rotation3_set_values_fp64(const double x1, const double x2, cons
rotation->axis.x2 = x2;
rotation->axis.x3 = x3;
if (bgc_vector3_normalize_fp64(&rotation->axis)) {
if (bgc_vector3_normalize_fp64(&rotation->axis, &rotation->axis)) {
rotation->radians = bgc_angle_to_radians_fp64(angle, unit);
}
else {
@ -72,9 +72,11 @@ inline void bgc_rotation3_set_values_fp64(const double x1, const double x2, cons
inline void bgc_rotation3_set_with_axis_fp32(const BgcVector3FP32* axis, const float angle, const BgcAngleUnitEnum unit, BgcRotation3FP32* rotation)
{
bgc_vector3_copy_fp32(axis, &rotation->axis);
rotation->axis.x1 = axis->x1;
rotation->axis.x2 = axis->x2;
rotation->axis.x3 = axis->x3;
if (bgc_vector3_normalize_fp32(&rotation->axis)) {
if (bgc_vector3_normalize_fp32(&rotation->axis, &rotation->axis)) {
rotation->radians = bgc_angle_to_radians_fp32(angle, unit);
}
else {
@ -84,9 +86,11 @@ inline void bgc_rotation3_set_with_axis_fp32(const BgcVector3FP32* axis, const f
inline void bgc_rotation3_set_with_axis_fp64(const BgcVector3FP64* axis, const double angle, const BgcAngleUnitEnum unit, BgcRotation3FP64* rotation)
{
bgc_vector3_copy_fp64(axis, &rotation->axis);
rotation->axis.x1 = axis->x1;
rotation->axis.x2 = axis->x2;
rotation->axis.x3 = axis->x3;
if (bgc_vector3_normalize_fp64(&rotation->axis)) {
if (bgc_vector3_normalize_fp64(&rotation->axis, &rotation->axis)) {
rotation->radians = bgc_angle_to_radians_fp64(angle, unit);
}
else {

129
basic-geometry/slerp.c
View file

@ -1,129 +0,0 @@
#include "./slerp.h"
extern inline void bgc_slerp_reset_fp32(BgcSlerpFP32* slerp);
extern inline void bgc_slerp_reset_fp64(BgcSlerpFP64* slerp);
extern inline bgc_slerp_get_turn_for_phase_fp32(const BgcSlerpFP32* slerp, const float phase, BgcVersorFP32* result);
extern inline bgc_slerp_get_turn_for_phase_fp64(const BgcSlerpFP64* slerp, const double phase, BgcVersorFP64* result);
void bgc_slerp_make_full_fp32(const BgcVersorFP32* start, const BgcVersorFP32* end, BgcSlerpFP32* slerp)
{
BgcVersorFP32 delta;
bgc_versor_exclude_fp32(end, start, &delta);
const float square_vector = delta.x1 * delta.x1 + delta.x2 * delta.x2 + delta.x3 * delta.x3;
if (square_vector <= BGC_SQUARE_EPSYLON_FP32 || square_vector != square_vector) {
bgc_slerp_reset_fp32(slerp);
return;
}
const float vector_modulus = sqrtf(square_vector);
slerp->radians = atan2f(vector_modulus, delta.s0);
const float mutliplier = 1.0f / vector_modulus;
slerp->s0_cos_weight = start->s0;
slerp->x1_cos_weight = start->x1;
slerp->x2_cos_weight = start->x2;
slerp->x3_cos_weight = start->x3;
slerp->s0_sin_weight = -mutliplier * (delta.x1 * start->x1 + delta.x2 * start->x2 + delta.x3 * start->x3);
slerp->x1_sin_weight = mutliplier * (delta.x1 * start->s0 + delta.x2 * start->x3 - delta.x3 * start->x2);
slerp->x2_sin_weight = mutliplier * (delta.x2 * start->s0 - delta.x1 * start->x3 + delta.x3 * start->x1);
slerp->x3_sin_weight = mutliplier * (delta.x3 * start->s0 - delta.x2 * start->x1 + delta.x1 * start->x2);
}
void bgc_slerp_make_full_fp64(const BgcVersorFP64* start, const BgcVersorFP64* end, BgcSlerpFP64* slerp)
{
BgcVersorFP64 delta;
bgc_versor_exclude_fp64(end, start, &delta);
const double square_vector = delta.x1 * delta.x1 + delta.x2 * delta.x2 + delta.x3 * delta.x3;
if (square_vector <= BGC_SQUARE_EPSYLON_FP64 || square_vector != square_vector) {
bgc_slerp_reset_fp64(slerp);
return;
}
const double vector_modulus = sqrt(square_vector);
slerp->radians = atan2(vector_modulus, delta.s0);
const double mutliplier = 1.0 / vector_modulus;
slerp->s0_cos_weight = start->s0;
slerp->x1_cos_weight = start->x1;
slerp->x2_cos_weight = start->x2;
slerp->x3_cos_weight = start->x3;
slerp->s0_sin_weight = -mutliplier * (delta.x1 * start->x1 + delta.x2 * start->x2 + delta.x3 * start->x3);
slerp->x1_sin_weight = mutliplier * (delta.x1 * start->s0 + delta.x2 * start->x3 - delta.x3 * start->x2);
slerp->x2_sin_weight = mutliplier * (delta.x2 * start->s0 - delta.x1 * start->x3 + delta.x3 * start->x1);
slerp->x3_sin_weight = mutliplier * (delta.x3 * start->s0 - delta.x2 * start->x1 + delta.x1 * start->x2);
}
void bgc_slerp_make_shortened_fp32(const BgcVersorFP32* start, const BgcVersorFP32* end, BgcSlerpFP32* slerp)
{
BgcVersorFP32 delta;
bgc_versor_exclude_fp32(end, start, &delta);
bgc_versor_shorten_fp32(&delta, &delta);
const float square_vector = delta.x1 * delta.x1 + delta.x2 * delta.x2 + delta.x3 * delta.x3;
if (square_vector <= BGC_SQUARE_EPSYLON_FP32 || square_vector != square_vector) {
bgc_slerp_reset_fp32(slerp);
return;
}
const float vector_modulus = sqrtf(square_vector);
slerp->radians = atan2f(vector_modulus, delta.s0);
const float mutliplier = 1.0f / vector_modulus;
slerp->s0_cos_weight = start->s0;
slerp->x1_cos_weight = start->x1;
slerp->x2_cos_weight = start->x2;
slerp->x3_cos_weight = start->x3;
slerp->s0_sin_weight = -mutliplier * (delta.x1 * start->x1 + delta.x2 * start->x2 + delta.x3 * start->x3);
slerp->x1_sin_weight = mutliplier * (delta.x1 * start->s0 + delta.x2 * start->x3 - delta.x3 * start->x2);
slerp->x2_sin_weight = mutliplier * (delta.x2 * start->s0 - delta.x1 * start->x3 + delta.x3 * start->x1);
slerp->x3_sin_weight = mutliplier * (delta.x3 * start->s0 - delta.x2 * start->x1 + delta.x1 * start->x2);
}
void bgc_slerp_make_shortened_fp64(const BgcVersorFP64* start, const BgcVersorFP64* end, BgcSlerpFP64* slerp)
{
BgcVersorFP64 delta;
bgc_versor_exclude_fp64(end, start, &delta);
bgc_versor_shorten_fp64(&delta, &delta);
const double square_vector = delta.x1 * delta.x1 + delta.x2 * delta.x2 + delta.x3 * delta.x3;
if (square_vector <= BGC_SQUARE_EPSYLON_FP64 || square_vector != square_vector) {
bgc_slerp_reset_fp64(slerp);
return;
}
const double vector_modulus = sqrt(square_vector);
slerp->radians = atan2(vector_modulus, delta.s0);
const double mutliplier = 1.0 / vector_modulus;
slerp->s0_cos_weight = start->s0;
slerp->x1_cos_weight = start->x1;
slerp->x2_cos_weight = start->x2;
slerp->x3_cos_weight = start->x3;
slerp->s0_sin_weight = -mutliplier * (delta.x1 * start->x1 + delta.x2 * start->x2 + delta.x3 * start->x3);
slerp->x1_sin_weight = mutliplier * (delta.x1 * start->s0 + delta.x2 * start->x3 - delta.x3 * start->x2);
slerp->x2_sin_weight = mutliplier * (delta.x2 * start->s0 - delta.x1 * start->x3 + delta.x3 * start->x1);
slerp->x3_sin_weight = mutliplier * (delta.x3 * start->s0 - delta.x2 * start->x1 + delta.x1 * start->x2);
}

94
basic-geometry/slerp.h
View file

@ -1,94 +0,0 @@
#ifndef _BGC_VERSOR_SLERP_H_
#define _BGC_VERSOR_SLERP_H_
#include "./versor.h"
typedef struct {
float s0_cos_weight, s0_sin_weight;
float x1_cos_weight, x1_sin_weight;
float x2_cos_weight, x2_sin_weight;
float x3_cos_weight, x3_sin_weight;
float radians;
} BgcSlerpFP32;
typedef struct {
double s0_cos_weight, s0_sin_weight;
double x1_cos_weight, x1_sin_weight;
double x2_cos_weight, x2_sin_weight;
double x3_cos_weight, x3_sin_weight;
double radians;
} BgcSlerpFP64;
inline void bgc_slerp_reset_fp32(BgcSlerpFP32* slerp)
{
slerp->s0_cos_weight = 1.0f;
slerp->s0_sin_weight = 0.0f;
slerp->x1_cos_weight = 0.0f;
slerp->x1_sin_weight = 0.0f;
slerp->x2_cos_weight = 0.0f;
slerp->x2_sin_weight = 0.0f;
slerp->x3_cos_weight = 0.0f;
slerp->x3_sin_weight = 0.0f;
slerp->radians = 0.0f;
}
inline void bgc_slerp_reset_fp64(BgcSlerpFP64* slerp)
{
slerp->s0_cos_weight = 1.0;
slerp->s0_sin_weight = 0.0;
slerp->x1_cos_weight = 0.0;
slerp->x1_sin_weight = 0.0;
slerp->x2_cos_weight = 0.0;
slerp->x2_sin_weight = 0.0;
slerp->x3_cos_weight = 0.0;
slerp->x3_sin_weight = 0.0;
slerp->radians = 0.0;
}
void bgc_slerp_make_full_fp32(const BgcVersorFP32* start, const BgcVersorFP32* end, BgcSlerpFP32* slerp);
void bgc_slerp_make_full_fp64(const BgcVersorFP64* start, const BgcVersorFP64* end, BgcSlerpFP64* slerp);
void bgc_slerp_make_shortened_fp32(const BgcVersorFP32* start, const BgcVersorFP32* end, BgcSlerpFP32* slerp);
void bgc_slerp_make_shortened_fp64(const BgcVersorFP64* start, const BgcVersorFP64* end, BgcSlerpFP64* slerp);
inline bgc_slerp_get_turn_for_phase_fp32(const BgcSlerpFP32* slerp, const float phase, BgcVersorFP32* result)
{
const float angle = slerp->radians * phase;
const float cosine = cosf(angle);
const float sine = sinf(angle);
bgc_versor_set_values_fp32(
slerp->s0_cos_weight * cosine + slerp->s0_sin_weight * sine,
slerp->x1_cos_weight * cosine + slerp->x1_sin_weight * sine,
slerp->x2_cos_weight * cosine + slerp->x2_sin_weight * sine,
slerp->x3_cos_weight * cosine + slerp->x3_sin_weight * sine,
result
);
}
inline bgc_slerp_get_turn_for_phase_fp64(const BgcSlerpFP64* slerp, const double phase, BgcVersorFP64* result)
{
const double angle = slerp->radians * phase;
const double cosine = cos(angle);
const double sine = sin(angle);
bgc_versor_set_values_fp64(
slerp->s0_cos_weight * cosine + slerp->s0_sin_weight * sine,
slerp->x1_cos_weight * cosine + slerp->x1_sin_weight * sine,
slerp->x2_cos_weight * cosine + slerp->x2_sin_weight * sine,
slerp->x3_cos_weight * cosine + slerp->x3_sin_weight * sine,
result
);
}
#endif

79
basic-geometry/tangent-pair.c Normal file
View file

@ -0,0 +1,79 @@
#include "tangent-pair.h"
const BgcTangentPairFP32 BGC_IDLE_TANGENT_PAIR_FP32 = { 1.0f, 0.0f };
const BgcTangentPairFP64 BGC_IDLE_TANGENT_PAIR_FP64 = { 1.0, 0.0 };
extern inline void bgc_tangent_pair_reset_fp32(BgcTangentPairFP32* tangent);
extern inline void bgc_tangent_pair_reset_fp64(BgcTangentPairFP64* tangent);
extern inline void bgc_tangent_pair_set_values_fp32(const float x1, const float x2, BgcTangentPairFP32* tangent);
extern inline void bgc_tangent_pair_set_values_fp64(const double x1, const double x2, BgcTangentPairFP64* tangent);
extern inline void bgc_tangent_pair_set_turn_fp32(const float angle, const BgcAngleUnitEnum unit, BgcTangentPairFP32* tangent);
extern inline void bgc_tangent_pair_set_turn_fp64(const double angle, const BgcAngleUnitEnum unit, BgcTangentPairFP64* tangent);
extern inline float bgc_tangent_pair_get_angle_fp32(const BgcTangentPairFP32* tangent, const BgcAngleUnitEnum unit);
extern inline double bgc_tangent_pair_get_angle_fp64(const BgcTangentPairFP64* tangent, const BgcAngleUnitEnum unit);
extern inline void bgc_tangent_pair_copy_fp32(const BgcTangentPairFP32* source, BgcTangentPairFP32* destination);
extern inline void bgc_tangent_pair_copy_fp64(const BgcTangentPairFP64* source, BgcTangentPairFP64* destination);
extern inline void bgc_tangent_pair_swap_fp32(BgcTangentPairFP32* tangent1, BgcTangentPairFP32* tangent2);
extern inline void bgc_tangent_pair_swap_fp64(BgcTangentPairFP64* tangent1, BgcTangentPairFP64* tangent2);
extern inline void bgc_tangent_pair_convert_fp64_to_fp32(const BgcTangentPairFP64* source, BgcTangentPairFP32* destination);
extern inline void bgc_tangent_pair_convert_fp32_to_fp64(const BgcTangentPairFP32* source, BgcTangentPairFP64* destination);
extern inline void bgc_tangent_pair_invert_fp32(const BgcTangentPairFP32* tangent, BgcTangentPairFP32* inverted);
extern inline void bgc_tangent_pair_invert_fp64(const BgcTangentPairFP64* tangent, BgcTangentPairFP64* inverted);
extern inline void bgc_tangent_pair_combine_fp32(const BgcTangentPairFP32* tangent1, const BgcTangentPairFP32* tangent2, BgcTangentPairFP32* result);
extern inline void bgc_tangent_pair_combine_fp64(const BgcTangentPairFP64* tangent1, const BgcTangentPairFP64* tangent2, BgcTangentPairFP64* result);
extern inline void bgc_tangent_pair_get_rotation_matrix_fp32(const BgcTangentPairFP32* tangent, BgcMatrix2x2FP32* matrix);
extern inline void bgc_tangent_pair_get_rotation_matrix_fp64(const BgcTangentPairFP64* tangent, BgcMatrix2x2FP64* matrix);
extern inline void bgc_tangent_pair_get_reverse_matrix_fp32(const BgcTangentPairFP32* tangent, BgcMatrix2x2FP32* matrix);
extern inline void bgc_tangent_pair_get_reverse_matrix_fp64(const BgcTangentPairFP64* tangent, BgcMatrix2x2FP64* matrix);
extern inline void bgc_tangent_pair_turn_vector_fp32(const BgcTangentPairFP32* tangent, const BgcVector2FP32* vector, BgcVector2FP32* result);
extern inline void bgc_tangent_pair_turn_vector_fp64(const BgcTangentPairFP64* tangent, const BgcVector2FP64* vector, BgcVector2FP64* result);
extern inline void bgc_tangent_pair_turn_vector_back_fp32(const BgcTangentPairFP32* tangent, const BgcVector2FP32* vector, BgcVector2FP32* result);
extern inline void bgc_tangent_pair_turn_vector_back_fp64(const BgcTangentPairFP64* tangent, const BgcVector2FP64* vector, BgcVector2FP64* result);
extern inline int bgc_tangent_pair_are_close_fp32(const BgcTangentPairFP32* tangent1, const BgcTangentPairFP32* tangent2);
extern inline int bgc_tangent_pair_are_close_fp64(const BgcTangentPairFP64* tangent1, const BgcTangentPairFP64* tangent2);
void _bgc_tangent_pair_normalize_fp32(const float square_modulus, _BgcTwinTangentPairFP32* twin)
{
// (square_modulus != square_modulus) is true when square_modulus is NaN
if (square_modulus <= BGC_SQUARE_EPSYLON_FP32 || square_modulus != square_modulus) {
twin->cos = 1.0f;
twin->sin = 0.0f;
return;
}
const float multiplier = sqrtf(1.0f / square_modulus);
twin->cos *= multiplier;
twin->sin *= multiplier;
}
void _bgc_tangent_pair_normalize_fp64(const double square_modulus, _BgcTwinTangentPairFP64* twin)
{
// (square_modulus != square_modulus) is true when square_modulus is NaN
if (square_modulus <= BGC_SQUARE_EPSYLON_FP64 || square_modulus != square_modulus) {
twin->cos = 1.0;
twin->sin = 0.0;
return;
}
const double multiplier = sqrt(1.0 / square_modulus);
twin->cos *= multiplier;
twin->sin *= multiplier;
}

352
basic-geometry/tangent-pair.h Normal file
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

 @ -0,0 +1,352 @@
#ifndef _bgc_tangent_pair_H_
#define _bgc_tangent_pair_H_
#include <math.h>
#include "utilities.h"
#include "angle.h"
#include "vector2.h"
#include "matrix2x2.h"
// =================== Types ==================== //
typedef struct
{
const float cos, sin;
} BgcTangentPairFP32;
typedef struct
{
const double cos, sin;
} BgcTangentPairFP64;
// ================= Dark Twins ================= //
typedef struct {
float cos, sin;
} _BgcTwinTangentPairFP32;
typedef struct {
double cos, sin;
} _BgcTwinTangentPairFP64;
// ================= Constants ================== //
extern const BgcTangentPairFP32 BGC_IDLE_TANGENT_PAIR_FP32;
extern const BgcTangentPairFP64 BGC_IDLE_TANGENT_PAIR_FP64;
// =================== Reset ==================== //
inline void bgc_tangent_pair_reset_fp32(BgcTangentPairFP32* tangent)
{
_BgcTwinTangentPairFP32* twin = (_BgcTwinTangentPairFP32*)tangent;
twin->cos = 1.0f;
twin->sin = 0.0f;
}
inline void bgc_tangent_pair_reset_fp64(BgcTangentPairFP64* tangent)
{
_BgcTwinTangentPairFP64* twin = (_BgcTwinTangentPairFP64*)tangent;
twin->cos = 1.0;
twin->sin = 0.0;
}
// ==================== Set ===================== //
void _bgc_tangent_pair_normalize_fp32(const float square_modulus, _BgcTwinTangentPairFP32* twin);
void _bgc_tangent_pair_normalize_fp64(const double square_modulus, _BgcTwinTangentPairFP64* twin);
inline void bgc_tangent_pair_set_values_fp32(const float x1, const float x2, BgcTangentPairFP32* tangent)
{
const float square_modulus = x1 * x1 + x2 * x2;
_BgcTwinTangentPairFP32* twin = (_BgcTwinTangentPairFP32*)tangent;
twin->cos = x1;
twin->sin = x2;
if (!bgc_is_sqare_unit_fp32(square_modulus)) {
_bgc_tangent_pair_normalize_fp32(square_modulus, twin);