Добавление функций определения поворотов (versor) между направлениями и базисами

basic-geometry-dev/main.c

@@ -53,12 +53,12 @@ structure_fp32_t* make_structures(const unsigned int amount)
 
 void print_versor_fp32(const BgcVersorFP32* versor)
 {
-    printf("Versor (%f, %f, %f, %f)\n", versor->s0, versor->x1, versor->x2, versor->x3);
+    printf("Versor (s0 = %0.12f, x1 = %0.12f, x2 = %0.12f, x3 = %0.12f)\n", versor->s0, versor->x1, versor->x2, versor->x3);
 }
 
 void print_versor_fp64(const BgcVersorFP64* versor)
 {
-    printf("Versor (%lf, %lf, %lf, %lf)\n", versor->s0, versor->x1, versor->x2, versor->x3);
+    printf("Versor (s0 = %0.20f, x1 = %0.20f, x2 = %0.20f, x3 = %0.20f)\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,3 +121,369 @@ 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;
+}

basic-geometry-test/basic-geometry-test.cbp

@@ -49,6 +49,38 @@
 		<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>

basic-geometry-test/basic-geometry-test.vcxproj

@@ -150,6 +150,15 @@
   <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" />
@@ -164,6 +173,7 @@
     <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" />
@@ -172,6 +182,7 @@
     <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" />
@@ -190,6 +201,15 @@
   </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" />
@@ -204,6 +224,7 @@
     <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" />
@@ -212,6 +233,7 @@
     <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" />

basic-geometry-test/basic-geometry-test.vcxproj.filters

@@ -114,6 +114,39 @@
     <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" />
@@ -228,6 +261,39 @@
     <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">
@@ -248,5 +314,8 @@
     <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>

basic-geometry-test/main.c

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

basic-geometry-test/tests/complex.c

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

basic-geometry-test/tests/complex.h

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

basic-geometry-test/tests/complex/complex_arithmetics.c

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

basic-geometry-test/tests/complex/complex_arithmetics.h

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

basic-geometry-test/tests/complex/complex_copy.c

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

basic-geometry-test/tests/complex/complex_copy.h

@@ -0,0 +1,10 @@
+#ifndef _TEST_COMPLEX_COPY_H_
+#define _TEST_COMPLEX_COPY_H_
+
+void test_complex_copy_fp32();
+
+void test_complex_copy_fp64();
+
+void test_complex_copy();
+
+#endif

basic-geometry-test/tests/complex/complex_is_unit.c

@@ -0,0 +1,109 @@
+#include "./complex_is_unit.h"
+
+#include "./../../helpers.h"
+
+// ==================== FP32 ==================== //
+
+static const int _TEST_FP32_UNIT_COMPLEX_AMOUNT = 10;
+static const int _TEST_FP32_NONUNIT_COMPLEX_AMOUNT = 6;
+
+static const BgcComplexFP32 _TEST_FP32_UNIT_COMPLEX_LIST[] = {
+    { 1.0f, 0.0f },
+    { -1.0f, 0.0f },
+    { 0.6f, -0.8f },
+    { 1.0f + 0.75f * BGC_EPSYLON_FP32, 0.0f },
+    { 1.0f - 0.75f * BGC_EPSYLON_FP32, 0.0f },
+    { 0.0f, 1.0f + 0.75f * BGC_EPSYLON_FP32 },
+    { 0.0f, 1.0f - 0.75f * BGC_EPSYLON_FP32 },
+    { 0.7071067812f, 0.7071067812f },
+    { 0.7071067812f + 0.75f * BGC_EPSYLON_FP32, 0.7071067812f },
+    { 0.7071067812f, 0.7071067812f - 0.75f * BGC_EPSYLON_FP32 }
+};
+
+static const BgcComplexFP32 _TEST_FP32_NONUNIT_QUATERION_LIST[] = {
+    { 1.0f + 1.25f * BGC_EPSYLON_FP32, 0.0f },
+    { 1.0f - 1.25f * BGC_EPSYLON_FP32, 0.0f },
+    { 0.0f, 1.0f + 1.25f * BGC_EPSYLON_FP32 },
+    { 0.0f, 1.0f - 1.25f * BGC_EPSYLON_FP32 },
+    { 0.7071067812f + 1.25f * BGC_EPSYLON_FP32, 0.7071067812f + 1.25f * BGC_EPSYLON_FP32 },
+    { 0.7071067812f - 1.25f * BGC_EPSYLON_FP32, 0.7071067812f - 1.25f * BGC_EPSYLON_FP32 }
+};
+
+void test_complex_is_unit_fp32()
+{
+    print_testing_name("bgc_complex_is_unit_fp32");
+
+    // Testing zero values:
+    for (int i = 0; i < _TEST_FP32_UNIT_COMPLEX_AMOUNT; i++) {
+        if (!bgc_complex_is_unit_fp32(&_TEST_FP32_UNIT_COMPLEX_LIST[i])) {
+            print_testing_error("A unit complex number was not recognized");
+            return;
+        }
+    }
+
+    // Testing non-zero values:
+    for (int i = 0; i < _TEST_FP32_NONUNIT_COMPLEX_AMOUNT; i++) {
+        if (bgc_complex_is_unit_fp32(&_TEST_FP32_NONUNIT_QUATERION_LIST[i])) {
+            print_testing_error("A non-unit complex number was recognized a unit complex number");
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+// ==================== FP64 ==================== //
+
+static const int _TEST_FP64_UNIT_COMPLEX_AMOUNT = 10;
+static const int _TEST_FP64_NONUNIT_COMPLEX_AMOUNT = 6;
+
+static const BgcComplexFP64 _TEST_FP64_UNIT_COMPLEX_LIST[] = {
+    { 1.0, 0.0 },
+    { -1.0, 0.0 },
+    { -0.6, 0.8 },
+    { 1.0 + 0.75 * BGC_EPSYLON_FP64, 0.0 },
+    { 1.0 - 0.75 * BGC_EPSYLON_FP64, 0.0 },
+    { 0.0, 1.0 + 0.75 * BGC_EPSYLON_FP64 },
+    { 0.0, 1.0 - 0.75 * BGC_EPSYLON_FP64 },
+    { 0.7071067811865475244, 0.7071067811865475244 },
+    { 0.7071067811865475244 + 0.75 * BGC_EPSYLON_FP64, 0.7071067811865475244 },
+    { 0.7071067811865475244, 0.7071067811865475244 - 0.75 * BGC_EPSYLON_FP64 }
+};
+
+static const BgcComplexFP64 _TEST_FP64_NONUNIT_QUATERION_LIST[] = {
+    { 1.0 + 1.25 * BGC_EPSYLON_FP64, 0.0 },
+    { 1.0 - 1.25 * BGC_EPSYLON_FP64, 0.0 },
+    { 0.0, 1.0 + 1.25 * BGC_EPSYLON_FP64 },
+    { 0.0, 1.0 - 1.25 * BGC_EPSYLON_FP64 },
+    { 0.7071067811865475244 + 1.25 * BGC_EPSYLON_FP64, 0.7071067811865475244 + 1.25 * BGC_EPSYLON_FP64 },
+    { 0.7071067811865475244 - 1.25 * BGC_EPSYLON_FP64, 0.7071067811865475244 - 1.25 * BGC_EPSYLON_FP64 }
+};
+
+void test_complex_is_unit_fp64()
+{
+    print_testing_name("bgc_complex_is_unit_fp64");
+
+    // Testing zero values:
+    for (int i = 0; i < _TEST_FP64_UNIT_COMPLEX_AMOUNT; i++) {
+        if (!bgc_complex_is_unit_fp64(&_TEST_FP64_UNIT_COMPLEX_LIST[i])) {
+            print_testing_error("A unit complex number was not recognized");
+            return;
+        }
+    }
+
+    // Testing non-zero values:
+    for (int i = 0; i < _TEST_FP64_NONUNIT_COMPLEX_AMOUNT; i++) {
+        if (bgc_complex_is_unit_fp64(&_TEST_FP64_NONUNIT_QUATERION_LIST[i])) {
+            print_testing_error("A non-unit complex number was recognized a unit complex number");
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_complex_is_unit()
+{
+    test_complex_is_unit_fp32();
+    test_complex_is_unit_fp64();
+}

basic-geometry-test/tests/complex/complex_is_unit.h

@@ -0,0 +1,10 @@
+#ifndef _TEST_COMPLEX_IS_UNIT_H_
+#define _TEST_COMPLEX_IS_UNIT_H_
+
+void test_complex_is_unit_fp32();
+
+void test_complex_is_unit_fp64();
+
+void test_complex_is_unit();
+
+#endif

basic-geometry-test/tests/complex/complex_is_zero.c

@@ -0,0 +1,101 @@
+#include "./complex_is_zero.h"
+
+#include "./../../helpers.h"
+
+// ==================== FP32 ==================== //
+
+static const int _TEST_FP32_ZERO_COMPLEX_AMOUNT = 4;
+static const int _TEST_FP32_NONZERO_COMPLEX_AMOUNT = 7;
+
+static const BgcComplexFP32 _TEST_FP32_ZERO_COMPLEX_LIST[] = {
+    { 0.0f, 0.0f },
+    { 0.75f * BGC_EPSYLON_FP32, 0.0f },
+    { -0.75f * BGC_EPSYLON_FP32, 0.0f },
+    { 0.0f, 0.75f * BGC_EPSYLON_FP32 },
+    { 0.0f, -0.75f * BGC_EPSYLON_FP32 }
+};
+
+static const BgcComplexFP32 _TEST_FP32_NONZERO_QUATERION_LIST[] = {
+    { 0.0f, 1.0f },
+    { 1.25f * BGC_EPSYLON_FP32 },
+    { -1.25f * BGC_EPSYLON_FP32 },
+    { 0.0f, 1.25f * BGC_EPSYLON_FP32 },
+    { 0.0f, -1.25f * BGC_EPSYLON_FP32 },
+    { 1.25f * BGC_EPSYLON_FP32, 1.25f * BGC_EPSYLON_FP32 },
+    { -1.25f * BGC_EPSYLON_FP32, -1.25f * BGC_EPSYLON_FP32 }
+};
+
+void test_complex_is_zero_fp32()
+{
+    print_testing_name("bgc_complex_is_zero_fp32");
+
+    // Testing zero values:
+    for (int i = 0; i < _TEST_FP32_ZERO_COMPLEX_AMOUNT; i++) {
+        if (!bgc_complex_is_zero_fp32(&_TEST_FP32_ZERO_COMPLEX_LIST[i])) {
+            print_testing_error("A zero complex number was not recognized");
+            return;
+        }
+    }
+
+    // Testing non-zero values:
+    for (int i = 0; i < _TEST_FP32_NONZERO_COMPLEX_AMOUNT; i++) {
+        if (bgc_complex_is_zero_fp32(&_TEST_FP32_NONZERO_QUATERION_LIST[i])) {
+            print_testing_error("A non-zero complex number was recognized as a zero complex number");
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+// ==================== FP64 ==================== //
+
+static const int _TEST_FP64_ZERO_COMPLEX_AMOUNT = 4;
+static const int _TEST_FP64_NONZERO_COMPLEX_AMOUNT = 7;
+
+static const BgcComplexFP64 _TEST_FP64_ZERO_COMPLEX_LIST[] = {
+    { 0.0, 0.0 },
+    { 0.75 * BGC_EPSYLON_FP64, 0.0 },
+    { -0.75 * BGC_EPSYLON_FP64, 0.0 },
+    { 0.0, 0.75 * BGC_EPSYLON_FP64 },
+    { 0.0, -0.75 * BGC_EPSYLON_FP64 }
+};
+
+static const BgcComplexFP64 _TEST_FP64_NONZERO_QUATERION_LIST[] = {
+    { 0.0, 1.0 },
+    { 1.25 * BGC_EPSYLON_FP64, 0.0 },
+    { -1.25 * BGC_EPSYLON_FP64, 0.0 },
+    { 0.0, 1.25 * BGC_EPSYLON_FP64 },
+    { 0.0, -1.25 * BGC_EPSYLON_FP64 },
+    { 1.25 * BGC_EPSYLON_FP64, 1.25 * BGC_EPSYLON_FP64 },
+    { -1.25 * BGC_EPSYLON_FP64, -1.25 * BGC_EPSYLON_FP64 }
+};
+
+void test_complex_is_zero_fp64()
+{
+    print_testing_name("bgc_complex_is_zero_fp64");
+
+    // Testing zero values:
+    for (int i = 0; i < _TEST_FP64_ZERO_COMPLEX_AMOUNT; i++) {
+        if (!bgc_complex_is_zero_fp64(&_TEST_FP64_ZERO_COMPLEX_LIST[i])) {
+            print_testing_error("A zero complex number was not recognized");
+            return;
+        }
+    }
+
+    // Testing non-zero values:
+    for (int i = 0; i < _TEST_FP64_NONZERO_COMPLEX_AMOUNT; i++) {
+        if (bgc_complex_is_zero_fp64(&_TEST_FP64_NONZERO_QUATERION_LIST[i])) {
+            print_testing_error("A non-zero complex number was recognized as a zero complex number");
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_complex_is_zero()
+{
+    test_complex_is_zero_fp32();
+    test_complex_is_zero_fp64();
+}

basic-geometry-test/tests/complex/complex_is_zero.h

@@ -0,0 +1,10 @@
+#ifndef _TEST_COMPLEX_IS_ZERO_H_
+#define _TEST_COMPLEX_IS_ZERO_H_
+
+void test_complex_is_zero_fp32();
+
+void test_complex_is_zero_fp64();
+
+void test_complex_is_zero();
+
+#endif

basic-geometry-test/tests/complex/complex_modulus.c

@@ -0,0 +1,117 @@
+#include "./complex_modulus.h"
+
+#include "./../../helpers.h"
+
+// ==================== FP32 ==================== //
+
+static const int _TEST_FP32_COMPLEX_AMOUNT = 4;
+
+static const BgcComplexFP32 _TEST_FP32_COMPLEX_LIST[] = {
+    { 4.0f, 3.0f },
+    { -1.0f, 1.0f },
+    { 100.0f, -100.0f },
+    { -0.86602540378f, 0.5f }
+};
+
+static const float _TEST_FP32_SQUARE_MODULUS_LIST[] = {
+    25.0f,
+    2.0f,
+    20000.0f,
+    1.0f
+};
+
+static const float _TEST_FP32_MODULUS_LIST[] = {
+    5.0f,
+    1.414213562373f,
+    141.4213562373f,
+    1.0f
+};
+
+void test_complex_square_modulus_fp32()
+{
+    print_testing_name("bgc_complex_get_square_modulus_fp32");
+
+    for (int i = 0; i < _TEST_FP32_COMPLEX_AMOUNT; i++) {
+        if (!bgc_are_close_fp32(bgc_complex_get_square_modulus_fp32(&_TEST_FP32_COMPLEX_LIST[i]), _TEST_FP32_SQUARE_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_complex_modulus_fp32()
+{
+    print_testing_name("bgc_complex_get_modulus_fp32");
+
+    for (int i = 0; i < _TEST_FP32_COMPLEX_AMOUNT; i++) {
+        if (!bgc_are_close_fp32(bgc_complex_get_modulus_fp32(&_TEST_FP32_COMPLEX_LIST[i]), _TEST_FP32_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+// ==================== FP64 ==================== //
+
+static const int _TEST_FP64_COMPLEX_AMOUNT = 4;
+
+static const BgcComplexFP64 _TEST_FP64_COMPLEX_LIST[] = {
+    { 4.0, 3.0 },
+    { -1.0, -1.0 },
+    { -100.0, 100.0 },
+    { -0.5, 0.866025403784438647 }
+};
+
+static const double _TEST_FP64_SQUARE_MODULUS_LIST[] = {
+    25.0,
+    2.0,
+    20000.0,
+    1.0
+};
+
+static const double _TEST_FP64_MODULUS_LIST[] = {
+    5.0,
+    1.4142135623730950488,
+    141.42135623730950488,
+    1.0
+};
+
+void test_complex_square_modulus_fp64()
+{
+    print_testing_name("bgc_complex_get_square_modulus_fp64");
+
+    for (int i = 0; i < _TEST_FP64_COMPLEX_AMOUNT; i++) {
+        if (!bgc_are_close_fp64(bgc_complex_get_square_modulus_fp64(&_TEST_FP64_COMPLEX_LIST[i]), _TEST_FP64_SQUARE_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_complex_modulus_fp64()
+{
+    print_testing_name("bgc_complex_get_modulus_fp64");
+
+    for (int i = 0; i < _TEST_FP64_COMPLEX_AMOUNT; i++) {
+        if (!bgc_are_close_fp64(bgc_complex_get_modulus_fp64(&_TEST_FP64_COMPLEX_LIST[i]), _TEST_FP64_MODULUS_LIST[i])) {
+            print_testing_failed();
+            return;
+        }
+    }
+
+    print_testing_success();
+}
+
+void test_complex_modulus()
+{
+    test_complex_square_modulus_fp32();
+    test_complex_square_modulus_fp64();
+    test_complex_modulus_fp32();
+    test_complex_modulus_fp64();
+}

basic-geometry-test/tests/complex/complex_modulus.h

@@ -0,0 +1,14 @@
+#ifndef _TEST_COMPLEX_MODULUS_H_
+#define _TEST_COMPLEX_MODULUS_H_
+
+void test_complex_square_modulus_fp32();
+
+void test_complex_square_modulus_fp64();
+
+void test_complex_modulus_fp32();
+
+void test_complex_modulus_fp64();
+
+void test_complex_modulus();
+
+#endif

basic-geometry-test/tests/complex/complex_reset.c

@@ -0,0 +1,41 @@
+#include "./complex_reset.h"
+
+#include "./../../helpers.h"
+
+void test_complex_reset_fp32()
+{
+    BgcComplexFP32 vector;
+
+    print_testing_name("bgc_complex_reset_fp32");
+
+    bgc_complex_reset_fp32(&vector);
+
+    if (vector.real != 0.0f || vector.imaginary != 0.0f) {
+        print_testing_failed();
+        return;
+    }
+
+    print_testing_success();
+}
+
+void test_complex_reset_fp64()
+{
+    BgcComplexFP64 vector;
+
+    print_testing_name("bgc_complex_reset_fp64");
+
+    bgc_complex_reset_fp64(&vector);
+
+    if (vector.real != 0.0 || vector.imaginary != 0.0) {
+        print_testing_failed();
+        return;
+    }
+
+    print_testing_success();
+}
+
+void test_complex_reset()
+{
+    test_complex_reset_fp32();
+    test_complex_reset_fp64();
+}

basic-geometry-test/tests/complex/complex_reset.h

@@ -0,0 +1,10 @@
+#ifndef _TEST_COMPLEX_RESET_H_
+#define _TEST_COMPLEX_RESET_H_
+
+void test_complex_reset_fp32();
+
+void test_complex_reset_fp64();
+
+void test_complex_reset();
+
+#endif

basic-geometry-test/tests/complex/complex_set_values.c

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

basic-geometry-test/tests/complex/complex_set_values.h

@@ -0,0 +1,10 @@
+#ifndef _TEST_COMPLEX_SET_VALUES_H_
+#define _TEST_COMPLEX_SET_VALUES_H_
+
+void test_complex_set_values_fp32();
+
+void test_complex_set_values_fp64();
+
+void test_complex_set_values();
+
+#endif

basic-geometry-test/tests/complex/complex_swap.c

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

basic-geometry-test/tests/complex/complex_swap.h

@@ -0,0 +1,10 @@
+#ifndef _TEST_COMPLEX_SWAP_H_
+#define _TEST_COMPLEX_SWAP_H_
+
+void test_complex_swap_fp32();
+
+void test_complex_swap_fp64();
+
+void test_complex_swap();
+
+#endif

basic-geometry-test/tests/vector2.c

@@ -11,6 +11,11 @@ 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();
 }
 
 

basic-geometry-test/tests/vector2.h

@@ -9,6 +9,7 @@
 #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();
 

basic-geometry-test/tests/vector2/vector2_arithmetics.c

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

basic-geometry-test/tests/vector2/vector2_arithmetics.h

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

basic-geometry-test/tests/vector3.c

@@ -11,4 +11,9 @@ 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();
 }

basic-geometry-test/tests/vector3.h

@@ -9,6 +9,7 @@
 #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();
 

basic-geometry-test/tests/vector3/vector3_arithmetics.c

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

basic-geometry-test/tests/vector3/vector3_arithmetics.h

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

basic-geometry-test/tests/versor/versor_is_identity.c

@@ -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, 0.0f }
+    { 1.0f, -1.25f * BGC_EPSYLON_FP32, 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 - 1.25 * BGC_EPSYLON_FP64, 0.0, 0.0, 0.0 }
+    { 1.0, 0.0, 1.25 * BGC_EPSYLON_FP64, 0.0 }
 };
 
 void test_versor_is_identity_fp64()

basic-geometry/Makefile

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

basic-geometry/basic-geometry.cbp

@@ -48,6 +48,14 @@
 		</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>
@@ -76,10 +84,6 @@
 			<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>

basic-geometry/basic-geometry.h

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

basic-geometry/basic-geometry.vcxproj

@@ -21,6 +21,8 @@
   <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" />
@@ -28,14 +30,16 @@
     <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" />
@@ -44,7 +48,7 @@
     <ClCompile Include="matrixes.c" />
     <ClCompile Include="quaternion.c" />
     <ClCompile Include="rotation3.c" />
-    <ClCompile Include="tangent-pair.c" />
+    <ClCompile Include="slerp.c" />
     <ClCompile Include="versor.c" />
     <ClCompile Include="vector2.c" />
     <ClCompile Include="vector3.c" />

basic-geometry/basic-geometry.vcxproj.filters

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

basic-geometry/complex.c

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

basic-geometry/complex.h

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

basic-geometry/cotes-number.c

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

basic-geometry/cotes-number.h

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

basic-geometry/quaternion.c

@@ -1,3 +1,4 @@
+#include <math.h>
 #include "quaternion.h"
 
 extern inline void bgc_quaternion_reset_fp32(BgcQuaternionFP32* quaternion);
@@ -63,8 +64,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_get_linear_interpolation_fp32(const BgcQuaternionFP32* vector1, const BgcQuaternionFP32* vector2, const float phase, BgcQuaternionFP32* interpolation);
+extern inline void bgc_quaternion_interpolate_linearly_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 void bgc_quaternion_interpolate_linearly_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);
@@ -72,5 +73,92 @@ 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;
+}

basic-geometry/quaternion.h

@@ -473,9 +473,9 @@ inline void bgc_quaternion_divide_fp64(const BgcQuaternionFP64* dividend, const
     bgc_quaternion_multiply_fp64(dividend, 1.0 / divisor, quotient);
 }
 
-// =================== Linear =================== //
+// ============ Linear Interpolation ============ //
 
-inline void bgc_quaternion_get_linear_interpolation_fp32(const BgcQuaternionFP32* quaternion1, const BgcQuaternionFP32* quaternion2, const float phase, BgcQuaternionFP32* interpolation)
+inline void bgc_quaternion_interpolate_linearly_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_get_linear_interpolation_fp32(const BgcQuaternionFP32
     interpolation->x3 = quaternion1->x3 * counterphase + quaternion2->x3 * phase;
 }
 
-inline void bgc_quaternion_get_linear_interpolation_fp64(const BgcQuaternionFP64* quaternion1, const BgcQuaternionFP64* quaternion2, const double phase, BgcQuaternionFP64* interpolation)
+inline void bgc_quaternion_interpolate_linearly_fp64(const BgcQuaternionFP64* quaternion1, const BgcQuaternionFP64* quaternion2, const double phase, BgcQuaternionFP64* interpolation)
 {
     const double counterphase = 1.0 - phase;
 
@@ -495,6 +495,12 @@ inline void bgc_quaternion_get_linear_interpolation_fp64(const BgcQuaternionFP64
     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)
@@ -659,6 +665,8 @@ 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)) {

basic-geometry/rotation3.h

@@ -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, &rotation->axis)) {
+    if (bgc_vector3_normalize_fp32(&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;