Изменение функций нормализации, переименование make функий в set values, добавление внутренних restrict функций, гарантирующих оптимизальное выполнение открытых функций, независимо от компилятора

basic-geometry-dev/affine3.c

@@ -40,7 +40,7 @@ BGC_FP32_Affine3* _create_bgc_affine3_random_list(int affine_amount)
     BGC_FP32_Position3 position;
 
     for (int i = 0; i < affine_amount; i++) {
-        bgc_fp32_turn3_set_raw_values(
+        bgc_fp32_turn3_set_values(
             &position.turn,
             get_random_value_fp32(),
             get_random_value_fp32(),

basic-geometry-dev/main.c

@@ -29,7 +29,7 @@ structure_fp32_t* make_structures(const unsigned int amount)
     const float multiplier = 2.0f / RAND_MAX;
 
     for (unsigned int i = 0; i < amount; i++) {
-        bgc_fp32_turn3_set_raw_values(
+        bgc_fp32_turn3_set_values(
             &list[i].versor1,
             rand() * multiplier - 1.0f,
             rand() * multiplier - 1.0f,
@@ -37,7 +37,7 @@ structure_fp32_t* make_structures(const unsigned int amount)
             rand() * multiplier - 1.0f
         );
 
-        bgc_fp32_turn3_set_raw_values(
+        bgc_fp32_turn3_set_values(
             &list[i].versor2,
             rand() * multiplier - 1.0f,
             rand() * multiplier - 1.0f,
@@ -127,9 +127,9 @@ int main()
 int main() {
     BGC_FP32_Complex complex, exponent, result;
 
-    bgc_fp32_complex_make(0, 1, &complex);
+    bgc_fp32_complex_set_values(0, 1, &complex);
 
-    bgc_fp32_complex_make(4, 0, &exponent);
+    bgc_fp32_complex_set_values(4, 0, &exponent);
 
     bgc_fp32_complex_get_exponation(&complex, exponent.real, exponent.imaginary, &result);
 
@@ -157,11 +157,11 @@ void test_pair_difference_fp32()
     BGC_FP32_Turn3 turn;
 
     // No turn
-    bgc_fp32_vector3_make(&initial_main,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, 0.0f, 1.0f, 0.0f);
 
-    bgc_fp32_vector3_make(&final_main,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main,   1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch, 0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_branch, 0.0f, 1.0f, 0.0f);
 
     bgc_fp32_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -169,11 +169,11 @@ void test_pair_difference_fp32()
     print_quaternion_fp32(&turn._versor);
 
     // Turn around (1, 1, 0) axis on 180 degrees
-    bgc_fp32_vector3_make(&initial_main,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, 0.0f, 1.0f, 0.0f);
 
-    bgc_fp32_vector3_make(&final_main,   0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main,   0.0f, 1.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch, 1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_branch, 1.0f, 0.0f, 0.0f);
 
     bgc_fp32_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -181,11 +181,11 @@ void test_pair_difference_fp32()
     print_quaternion_fp32(&turn._versor);
 
     // 180 degree turn
-    bgc_fp32_vector3_make(&initial_main,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, 0.0f, 1.0f, 0.0f);
 
-    bgc_fp32_vector3_make(&final_main,  -1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main,  -1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch, 0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_branch, 0.0f, 1.0f, 0.0f);
 
     bgc_fp32_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -193,11 +193,11 @@ void test_pair_difference_fp32()
     print_quaternion_fp32(&turn._versor);
 
     // 90 degree turn around x3 axis
-    bgc_fp32_vector3_make(&initial_main,   2.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   2.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 0.0f, 3.1f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, 0.0f, 3.1f, 0.0f);
 
-    bgc_fp32_vector3_make(&final_main,  0.0f, 10.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main,  0.0f, 10.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch,-1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_branch,-1.0f, 0.0f, 0.0f);
 
     bgc_fp32_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -205,11 +205,11 @@ void test_pair_difference_fp32()
     print_quaternion_fp32(&turn._versor);
 
     // Unorthogonal pairs turn at 90 degrees around x3 axis
-    bgc_fp32_vector3_make(&initial_main,    2.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,    2.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, -2.0f, 3.1f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, -2.0f, 3.1f, 0.0f);
 
-    bgc_fp32_vector3_make(&final_main, 0.0f, 10.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main, 0.0f, 10.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch, -1.0f, 5.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_branch, -1.0f, 5.0f, 0.0f);
 
     bgc_fp32_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -217,10 +217,10 @@ void test_pair_difference_fp32()
     print_quaternion_fp32(&turn._versor);
 
     // Zero vectors
-    bgc_fp32_vector3_make(&initial_main,   0.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   0.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, 0.0f, 1.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_main,     1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main,     1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch,   0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_branch,   0.0f, 1.0f, 0.0f);
 
     int code;
 
@@ -235,10 +235,10 @@ void test_pair_difference_fp32()
     }
 
     // Parallel vectors
-    bgc_fp32_vector3_make(&initial_main,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 2.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, 2.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_main,     1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main,     1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch,   0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_branch,   0.0f, 1.0f, 0.0f);
 
     code = bgc_fp32_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -251,11 +251,11 @@ void test_pair_difference_fp32()
     }
 
     // Small angle turn (about 1 degree):
-    bgc_fp32_vector3_make(&initial_main,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, 0.0f, 1.0f, 0.0f);
 
-    bgc_fp32_vector3_make(&final_main,    0.999848f, 0.017452f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main,    0.999848f, 0.017452f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch, -0.017452f, 0.999848f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_branch, -0.017452f, 0.999848f, 0.0f);
 
     bgc_fp32_turn3_find_pair_difference(&turn , &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -263,11 +263,11 @@ void test_pair_difference_fp32()
     print_quaternion_fp32(&turn._versor);
 
     // About 179 degrees turn
-    bgc_fp32_vector3_make(&initial_main,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, 0.0f, 1.0f, 0.0f);
 
-    bgc_fp32_vector3_make(&final_main,  -0.999848f, -0.017452f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main,  -0.999848f, -0.017452f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch, 0.017452f, -0.999848f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_branch, 0.017452f, -0.999848f, 0.0f);
 
     bgc_fp32_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -275,11 +275,11 @@ void test_pair_difference_fp32()
     print_quaternion_fp32(&turn._versor);
 
     // 120 degrees around (-1, -1, 1)
-    bgc_fp32_vector3_make(&initial_main,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, 0.0f, 1.0f, 0.0f);
 
-    bgc_fp32_vector3_make(&final_main,   0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main,   0.0f, 1.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch, 0.0f, 0.0f, -1.0f);
+    bgc_fp32_vector3_set_values(&final_branch, 0.0f, 0.0f, -1.0f);
 
     bgc_fp32_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -288,10 +288,10 @@ void test_pair_difference_fp32()
 
 
     // About 1 degree turn difference between initial_main and initial_branch directions
-    bgc_fp32_vector3_make(&initial_main,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 0.999848f, 0.017452f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, 0.999848f, 0.017452f, 0.0f);
-    bgc_fp32_vector3_make(&final_main, 0.0f, 1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main, 0.0f, 1.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch, -1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_branch, -1.0f, 0.0f, 0.0f);
 
     bgc_fp32_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -299,35 +299,35 @@ void test_pair_difference_fp32()
     print_quaternion_fp32(&turn._versor);
 
     // About 0.01 degree turn difference between initial_main and initial_branch directions
-    bgc_fp32_vector3_make(&initial_main,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 1.0f, 0.000001f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_branch, 1.0f, 0.000001f, 0.0f);
-    bgc_fp32_vector3_make(&final_main,     0.0f, -1.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_main,     0.0f, -1.0f, 0.0f);
-    bgc_fp32_vector3_make(&final_branch,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&final_branch,   1.0f, 0.0f, 0.0f);
 
     bgc_fp32_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
     printf("\nAbout 0.01 degree turn difference between initial_main and initial_branch directions:\n");
     print_quaternion_fp32(&turn._versor);
 
-    bgc_fp32_vector3_make(&initial_main,   1.0f, 0.0f, 0.0f);
+    bgc_fp32_vector3_set_values(&initial_main,   1.0f, 0.0f, 0.0f);
-    bgc_fp32_vector3_make(&initial_branch, 0.0f, 0.999999f, 0.00014142f); // почти (0,1,0), но крошечный z
+    bgc_fp32_vector3_set_values(&initial_branch, 0.0f, 0.999999f, 0.00014142f); // почти (0,1,0), но крошечный z
 
-    bgc_fp32_vector3_make(&final_main,    -0.999999f, 0.0f, 0.00014142f);
+    bgc_fp32_vector3_set_values(&final_main,    -0.999999f, 0.0f, 0.00014142f);
-    bgc_fp32_vector3_make(&final_branch,   0.0f, 0.999999f, -0.00014142f);
+    bgc_fp32_vector3_set_values(&final_branch,   0.0f, 0.999999f, -0.00014142f);
 
     bgc_fp32_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
     printf("\nNear 180° with tiny branch deviation:\n");
     print_quaternion_fp32(&turn._versor);
 
-    bgc_fp32_vector3_make(&initial_main,   1.0f, 0.2f, 0.1f);
+    bgc_fp32_vector3_set_values(&initial_main,   1.0f, 0.2f, 0.1f);
-    bgc_fp32_vector3_make(&initial_branch, 0.1f, 1.0f, 0.3f); // почти (0,1,0), но крошечный z
+    bgc_fp32_vector3_set_values(&initial_branch, 0.1f, 1.0f, 0.3f); // почти (0,1,0), но крошечный z
 
     BGC_FP32_Turn3 known;
 
     bgc_fp32_turn3_set_rotation(&known, 0.0f, 0.0f, 1.0f, 90.0f, BGC_ANGLE_UNIT_DEGREES);
 
-    bgc_fp32_vector3_make(&initial_main,    -0.999999f, 0.0f, 0.00014142f);
+    bgc_fp32_vector3_set_values(&initial_main,    -0.999999f, 0.0f, 0.00014142f);
-    bgc_fp32_vector3_make(&initial_branch,   0.0f, 0.999999f, -0.00014142f);
+    bgc_fp32_vector3_set_values(&initial_branch,   0.0f, 0.999999f, -0.00014142f);
 
     bgc_fp32_turn3_vector(&final_main,   &known, &initial_main);
     bgc_fp32_turn3_vector(&final_branch, &known, &initial_branch);
@@ -348,10 +348,10 @@ void test_pair_difference_fp64()
     BGC_FP64_Turn3 turn;
 
     // No turn
-    bgc_fp64_vector3_make(&initial_main,   1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,   1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, 0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, 0.0, 1.0, 0.0);
-    bgc_fp64_vector3_make(&final_main,     1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_main,     1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&final_branch,   0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_branch,   0.0, 1.0, 0.0);
 
     bgc_fp64_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -359,10 +359,10 @@ void test_pair_difference_fp64()
     print_quaternion_fp64(&turn._versor);
 
     // Turn around (1, 1, 0) axis on 180 degrees
-    bgc_fp64_vector3_make(&initial_main,   1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,   1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, 0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, 0.0, 1.0, 0.0);
-    bgc_fp64_vector3_make(&final_main,     0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_main,     0.0, 1.0, 0.0);
-    bgc_fp64_vector3_make(&final_branch,   1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_branch,   1.0, 0.0, 0.0);
 
     bgc_fp64_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -370,11 +370,11 @@ void test_pair_difference_fp64()
     print_quaternion_fp64(&turn._versor);
 
     // 180 degree turn
-    bgc_fp64_vector3_make(&initial_main,   1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,   1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, 0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, 0.0, 1.0, 0.0);
 
-    bgc_fp64_vector3_make(&initial_branch, -1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, -1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&final_branch,    0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_branch,    0.0, 1.0, 0.0);
 
     bgc_fp64_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -382,11 +382,11 @@ void test_pair_difference_fp64()
     print_quaternion_fp64(&turn._versor);
 
     // 90 degree turn around x3 axis
-    bgc_fp64_vector3_make(&initial_main,   2.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,   2.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, 0.0, 3.1, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, 0.0, 3.1, 0.0);
 
-    bgc_fp64_vector3_make(&final_main,   0.0, 10.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_main,   0.0, 10.0, 0.0);
-    bgc_fp64_vector3_make(&final_branch, -1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_branch, -1.0, 0.0, 0.0);
 
     bgc_fp64_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -394,11 +394,11 @@ void test_pair_difference_fp64()
     print_quaternion_fp64(&turn._versor);
 
     // Unorthogonal pairs turn at 90 degrees around x3 axis
-    bgc_fp64_vector3_make(&initial_main,    2.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,    2.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, -2.0, 3.1, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, -2.0, 3.1, 0.0);
 
-    bgc_fp64_vector3_make(&final_main,   0.0, 10.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_main,   0.0, 10.0, 0.0);
-    bgc_fp64_vector3_make(&final_branch, -1.0, 5.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_branch, -1.0, 5.0, 0.0);
 
     bgc_fp64_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -406,10 +406,10 @@ void test_pair_difference_fp64()
     print_quaternion_fp64(&turn._versor);
 
     // Zero vectors
-    bgc_fp64_vector3_make(&initial_main,   0.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,   0.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, 0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, 0.0, 1.0, 0.0);
-    bgc_fp64_vector3_make(&final_main,     1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_main,     1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&final_branch,   0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_branch,   0.0, 1.0, 0.0);
 
     int code;
 
@@ -424,10 +424,10 @@ void test_pair_difference_fp64()
     }
 
     // Parallel vectors
-    bgc_fp64_vector3_make(&initial_main,   1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,   1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, 2.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, 2.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&final_main,     1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_main,     1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&final_branch,   0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_branch,   0.0, 1.0, 0.0);
 
     code = bgc_fp64_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -440,11 +440,11 @@ void test_pair_difference_fp64()
     }
 
     // Small angle turn (about 1 degree):
-    bgc_fp64_vector3_make(&initial_main,   1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,   1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, 0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, 0.0, 1.0, 0.0);
 
-    bgc_fp64_vector3_make(&final_main,    0.999848, 0.017452, 0.0);
+    bgc_fp64_vector3_set_values(&final_main,    0.999848, 0.017452, 0.0);
-    bgc_fp64_vector3_make(&final_branch, -0.017452, 0.999848, 0.0);
+    bgc_fp64_vector3_set_values(&final_branch, -0.017452, 0.999848, 0.0);
 
     bgc_fp64_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -452,11 +452,11 @@ void test_pair_difference_fp64()
     print_quaternion_fp64(&turn._versor);
 
     // About 179 degrees turn
-    bgc_fp64_vector3_make(&initial_main,   1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,   1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, 0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, 0.0, 1.0, 0.0);
 
-    bgc_fp64_vector3_make(&final_main,  -0.999848, -0.017452, 0.0);
+    bgc_fp64_vector3_set_values(&final_main,  -0.999848, -0.017452, 0.0);
-    bgc_fp64_vector3_make(&final_branch, 0.017452, -0.999848, 0.0);
+    bgc_fp64_vector3_set_values(&final_branch, 0.017452, -0.999848, 0.0);
 
     bgc_fp64_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -464,11 +464,11 @@ void test_pair_difference_fp64()
     print_quaternion_fp64(&turn._versor);
 
     // 120 degrees around (-1, -1, 1)
-    bgc_fp64_vector3_make(&initial_main,   1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,   1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, 0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, 0.0, 1.0, 0.0);
 
-    bgc_fp64_vector3_make(&final_main,   0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_main,   0.0, 1.0, 0.0);
-    bgc_fp64_vector3_make(&final_branch, 0.0, 0.0, -1.0);
+    bgc_fp64_vector3_set_values(&final_branch, 0.0, 0.0, -1.0);
 
     bgc_fp64_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -477,10 +477,10 @@ void test_pair_difference_fp64()
 
 
     // About 1 degree turn difference between initial_main and initial_branch directions
-    bgc_fp64_vector3_make(&initial_main,   1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,   1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, 0.999848, 0.017452, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, 0.999848, 0.017452, 0.0);
-    bgc_fp64_vector3_make(&final_main,     0.0, 1.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_main,     0.0, 1.0, 0.0);
-    bgc_fp64_vector3_make(&final_branch,  -1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_branch,  -1.0, 0.0, 0.0);
 
     bgc_fp64_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 
@@ -488,10 +488,10 @@ void test_pair_difference_fp64()
     print_quaternion_fp64(&turn._versor);
 
     // About 0.001 degree turn difference between initial_main and initial_branch directions
-    bgc_fp64_vector3_make(&initial_main,   1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&initial_main,   1.0, 0.0, 0.0);
-    bgc_fp64_vector3_make(&initial_branch, 1.0, 0.000001, 0.0);
+    bgc_fp64_vector3_set_values(&initial_branch, 1.0, 0.000001, 0.0);
-    bgc_fp64_vector3_make(&final_main,     0.0, -1.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_main,     0.0, -1.0, 0.0);
-    bgc_fp64_vector3_make(&final_branch,   1.0, 0.0, 0.0);
+    bgc_fp64_vector3_set_values(&final_branch,   1.0, 0.0, 0.0);
 
     bgc_fp64_turn3_find_pair_difference(&turn, &initial_main, &initial_branch, &final_main, &final_branch);
 

basic-geometry/affine2.h

@@ -133,17 +133,17 @@ inline int bgc_fp64_affine2_get_inverse(BGC_FP64_Affine2* const inverse, const B
 inline void bgc_fp32_affine2_combine(BGC_FP32_Affine2* const combination, const BGC_FP32_Affine2* const first, const BGC_FP32_Affine2* const second)
 {
     BGC_FP32_Vector2 first_shift;
-    bgc_fp32_matrix2x2_multiply_by_vector2(&first_shift, &second->distortion, &first->shift);
+    _bgc_fp32_restrict_matrix2x2_multiply_by_vector2(&first_shift, &second->distortion, &first->shift);
-    bgc_fp32_matrix2x2_multiply_by_matrix2x2(&combination->distortion, &second->distortion, &first->distortion);
     bgc_fp32_vector2_add(&combination->shift, &second->shift, &first_shift);
+    bgc_fp32_matrix2x2_multiply_by_matrix2x2(&combination->distortion, &second->distortion, &first->distortion);
 }
 
 inline void bgc_fp64_affine2_combine(BGC_FP64_Affine2* const combination, const BGC_FP64_Affine2* const first, const BGC_FP64_Affine2* const second)
 {
     BGC_FP64_Vector2 first_shift;
-    bgc_fp64_matrix2x2_multiply_by_vector2(&first_shift, &second->distortion, &first->shift);
+    _bgc_fp64_restrict_matrix2x2_multiply_by_vector2(&first_shift, &second->distortion, &first->shift);
-    bgc_fp64_matrix2x2_multiply_by_matrix2x2(&combination->distortion, &second->distortion, &first->distortion);
     bgc_fp64_vector2_add(&combination->shift, &second->shift, &first_shift);
+    bgc_fp64_matrix2x2_multiply_by_matrix2x2(&combination->distortion, &second->distortion, &first->distortion);
 }
 
 // =============== Transform Point =============== //
@@ -151,14 +151,14 @@ inline void bgc_fp64_affine2_combine(BGC_FP64_Affine2* const combination, const
 inline void bgc_fp32_affine2_transform_point(BGC_FP32_Vector2* const transformed_point, const BGC_FP32_Affine2* const affine, const BGC_FP32_Vector2* const initial_point)
 {
     BGC_FP32_Vector2 distorted;
-    bgc_fp32_matrix2x2_multiply_by_vector2(&distorted, &affine->distortion, initial_point);
+    _bgc_fp32_restrict_matrix2x2_multiply_by_vector2(&distorted, &affine->distortion, initial_point);
     bgc_fp32_vector2_add(transformed_point, &affine->shift, &distorted);
 }
 
 inline void bgc_fp64_affine2_transform_point(BGC_FP64_Vector2* const transformed_point, const BGC_FP64_Affine2* const affine, const BGC_FP64_Vector2* const initial_point)
 {
     BGC_FP64_Vector2 distorted;
-    bgc_fp64_matrix2x2_multiply_by_vector2(&distorted, &affine->distortion, initial_point);
+    _bgc_fp64_restrict_matrix2x2_multiply_by_vector2(&distorted, &affine->distortion, initial_point);
     bgc_fp64_vector2_add(transformed_point, &affine->shift, &distorted);
 }
 

basic-geometry/affine3.h

@@ -132,17 +132,17 @@ inline int bgc_fp64_affine3_get_inverse(BGC_FP64_Affine3* const destination, con
 inline void bgc_fp32_affine3_combine(BGC_FP32_Affine3* const combination, const BGC_FP32_Affine3* const first, const BGC_FP32_Affine3* const second)
 {
     BGC_FP32_Vector3 first_shift;
-    bgc_fp32_matrix3x3_multiply_by_vector3(&first_shift, &second->distortion, &first->shift);
+    _bgc_fp32_restrict_matrix3x3_multiply_by_vector3(&first_shift, &second->distortion, &first->shift);
-    bgc_fp32_matrix3x3_multiply_by_matrix3x3(&combination->distortion, &second->distortion, &first->distortion);
     bgc_fp32_vector3_add(&combination->shift, &first_shift, &second->shift);
+    bgc_fp32_matrix3x3_multiply_by_matrix3x3(&combination->distortion, &second->distortion, &first->distortion);
 }
 
 inline void bgc_fp64_affine3_combine(BGC_FP64_Affine3* const combination, const BGC_FP64_Affine3* const first, const BGC_FP64_Affine3* const second)
 {
     BGC_FP64_Vector3 first_shift;
-    bgc_fp64_matrix3x3_multiply_by_vector3(&first_shift, &second->distortion, &first->shift);
+    _bgc_fp64_restrict_matrix3x3_multiply_by_vector3(&first_shift, &second->distortion, &first->shift);
-    bgc_fp64_matrix3x3_multiply_by_matrix3x3(&combination->distortion, &second->distortion, &first->distortion);
     bgc_fp64_vector3_add(&combination->shift, &first_shift, &second->shift);
+    bgc_fp64_matrix3x3_multiply_by_matrix3x3(&combination->distortion, &second->distortion, &first->distortion);
 }
 
 // =============== Transform Point =============== //
@@ -150,14 +150,14 @@ inline void bgc_fp64_affine3_combine(BGC_FP64_Affine3* const combination, const
 inline void bgc_fp32_affine3_transform_point(BGC_FP32_Vector3* const transformed_point, const BGC_FP32_Affine3* const affine, const BGC_FP32_Vector3* const initial_point)
 {
     BGC_FP32_Vector3 distorted;
-    bgc_fp32_matrix3x3_multiply_by_vector3(&distorted, &affine->distortion, initial_point);
+    _bgc_fp32_restrict_matrix3x3_multiply_by_vector3(&distorted, &affine->distortion, initial_point);
     bgc_fp32_vector3_add(transformed_point, &affine->shift, &distorted);
 }
 
 inline void bgc_fp64_affine3_transform_point(BGC_FP64_Vector3* const transformed_point, const BGC_FP64_Affine3* const affine, const BGC_FP64_Vector3* const initial_point)
 {
     BGC_FP64_Vector3 distorted;
-    bgc_fp64_matrix3x3_multiply_by_vector3(&distorted, &affine->distortion, initial_point);
+    _bgc_fp64_restrict_matrix3x3_multiply_by_vector3(&distorted, &affine->distortion, initial_point);
     bgc_fp64_vector3_add(transformed_point, &affine->shift, &distorted);
 }
 

basic-geometry/complex.c

@@ -3,8 +3,8 @@
 extern inline void bgc_fp32_complex_reset(BGC_FP32_Complex* const complex);
 extern inline void bgc_fp64_complex_reset(BGC_FP64_Complex* const complex);
 
-extern inline void bgc_fp32_complex_make(BGC_FP32_Complex* const complex, const float real, const float imaginary);
+extern inline void bgc_fp32_complex_set_values(BGC_FP32_Complex* const complex, const float real, const float imaginary);
-extern inline void bgc_fp64_complex_make(BGC_FP64_Complex* const complex, const double real, const double imaginary);
+extern inline void bgc_fp64_complex_set_values(BGC_FP64_Complex* const complex, const double real, const double imaginary);
 
 extern inline float bgc_fp32_complex_get_square_modulus(const BGC_FP32_Complex* const number);
 extern inline double bgc_fp64_complex_get_square_modulus(const BGC_FP64_Complex* const number);

basic-geometry/complex.h

@@ -23,13 +23,13 @@ inline void bgc_fp64_complex_reset(BGC_FP64_Complex* const complex)
 
 // ==================== Set ===================== //
 
-inline void bgc_fp32_complex_make(BGC_FP32_Complex* const complex, const float real, const float imaginary)
+inline void bgc_fp32_complex_set_values(BGC_FP32_Complex* const complex, const float real, const float imaginary)
 {
     complex->real = real;
     complex->imaginary = imaginary;
 }
 
-inline void bgc_fp64_complex_make(BGC_FP64_Complex* const complex, const double real, const double imaginary)
+inline void bgc_fp64_complex_set_values(BGC_FP64_Complex* const complex, const double real, const double imaginary)
 {
     complex->real = real;
     complex->imaginary = imaginary;

basic-geometry/matrix2x2.c

@@ -75,6 +75,9 @@ extern inline void bgc_fp64_matrix2x2_multiply_by_real(BGC_FP64_Matrix2x2* const
 extern inline void bgc_fp32_matrix2x2_multiply_by_vector2(BGC_FP32_Vector2* const product, const BGC_FP32_Matrix2x2* const matrix, const BGC_FP32_Vector2* const vector);
 extern inline void bgc_fp64_matrix2x2_multiply_by_vector2(BGC_FP64_Vector2* const product, const BGC_FP64_Matrix2x2* const matrix, const BGC_FP64_Vector2* const vector);
 
+extern inline void _bgc_fp32_restrict_matrix2x2_multiply_by_vector2(BGC_FP32_Vector2* restrict const product, const BGC_FP32_Matrix2x2* const matrix, const BGC_FP32_Vector2* const vector);
+extern inline void _bgc_fp64_restrict_matrix2x2_multiply_by_vector2(BGC_FP64_Vector2* restrict const product, const BGC_FP64_Matrix2x2* const matrix, const BGC_FP64_Vector2* const vector);
+
 extern inline void bgc_fp32_matrix2x2_multiply_by_matrix2x2(BGC_FP32_Matrix2x2* const product, const BGC_FP32_Matrix2x2* const matrix1, const BGC_FP32_Matrix2x2* const matrix2);
 extern inline void bgc_fp64_matrix2x2_multiply_by_matrix2x2(BGC_FP64_Matrix2x2* const product, const BGC_FP64_Matrix2x2* const matrix1, const BGC_FP64_Matrix2x2* const matrix2);
 

basic-geometry/matrix2x2.h

@@ -597,6 +597,20 @@ inline void bgc_fp64_matrix2x2_multiply_by_vector2(BGC_FP64_Vector2* const produ
     product->x2 = x2;
 }
 
+// ======= Restrict Right Vector Product ======== //
+
+inline void _bgc_fp32_restrict_matrix2x2_multiply_by_vector2(BGC_FP32_Vector2* restrict const product, const BGC_FP32_Matrix2x2* const matrix, const BGC_FP32_Vector2* const vector)
+{
+    product->x1 = matrix->r1c1 * vector->x1 + matrix->r1c2 * vector->x2;
+    product->x2 = matrix->r2c1 * vector->x1 + matrix->r2c2 * vector->x2;
+}
+
+inline void _bgc_fp64_restrict_matrix2x2_multiply_by_vector2(BGC_FP64_Vector2* restrict const product, const BGC_FP64_Matrix2x2* const matrix, const BGC_FP64_Vector2* const vector)
+{
+    product->x1 = matrix->r1c1 * vector->x1 + matrix->r1c2 * vector->x2;
+    product->x2 = matrix->r2c1 * vector->x1 + matrix->r2c2 * vector->x2;
+}
+
 // ========== Matrix Product 2x2 at 2x2 ========= //
 
 inline void bgc_fp32_matrix2x2_multiply_by_matrix2x2(BGC_FP32_Matrix2x2* const product, const BGC_FP32_Matrix2x2* const matrix1, const BGC_FP32_Matrix2x2* const matrix2)

basic-geometry/matrix3x3.c

@@ -69,6 +69,9 @@ extern inline void bgc_fp64_matrix3x3_multiply_by_real(BGC_FP64_Matrix3x3* const
 extern inline void bgc_fp32_matrix3x3_multiply_by_vector3(BGC_FP32_Vector3* const product, const BGC_FP32_Matrix3x3* const matrix, const BGC_FP32_Vector3* const vector);
 extern inline void bgc_fp64_matrix3x3_multiply_by_vector3(BGC_FP64_Vector3* const product, const BGC_FP64_Matrix3x3* const matrix, const BGC_FP64_Vector3* const vector);
 
+extern inline void _bgc_fp32_restrict_matrix3x3_multiply_by_vector3(BGC_FP32_Vector3* restrict const product, const BGC_FP32_Matrix3x3* const matrix, const BGC_FP32_Vector3* const vector);
+extern inline void _bgc_fp64_restrict_matrix3x3_multiply_by_vector3(BGC_FP64_Vector3* restrict const product, const BGC_FP64_Matrix3x3* const matrix, const BGC_FP64_Vector3* const vector);
+
 extern inline void bgc_fp32_matrix3x3_multiply_by_matrix2x3(BGC_FP32_Matrix2x3* const product, const BGC_FP32_Matrix3x3* const matrix1, const BGC_FP32_Matrix2x3* const matrix2);
 extern inline void bgc_fp64_matrix3x3_multiply_by_matrix2x3(BGC_FP64_Matrix2x3* const product, const BGC_FP64_Matrix3x3* const matrix1, const BGC_FP64_Matrix2x3* const matrix2);
 

basic-geometry/matrix3x3.h

@@ -840,6 +840,21 @@ inline void bgc_fp64_matrix3x3_multiply_by_vector3(BGC_FP64_Vector3* const produ
     product->x3 = x3;
 }
 
+// ======= Restrict Right Vector Product ======== //
+
+inline void _bgc_fp32_restrict_matrix3x3_multiply_by_vector3(BGC_FP32_Vector3* restrict const product, const BGC_FP32_Matrix3x3* const matrix, const BGC_FP32_Vector3* const vector)
+{
+    product->x1 = matrix->r1c1 * vector->x1 + matrix->r1c2 * vector->x2 + matrix->r1c3 * vector->x3;
+    product->x2 = matrix->r2c1 * vector->x1 + matrix->r2c2 * vector->x2 + matrix->r2c3 * vector->x3;
+    product->x3 = matrix->r3c1 * vector->x1 + matrix->r3c2 * vector->x2 + matrix->r3c3 * vector->x3;
+}
+
+inline void _bgc_fp64_restrict_matrix3x3_multiply_by_vector3(BGC_FP64_Vector3* restrict const product, const BGC_FP64_Matrix3x3* const matrix, const BGC_FP64_Vector3* const vector)
+{
+    product->x1 = matrix->r1c1 * vector->x1 + matrix->r1c2 * vector->x2 + matrix->r1c3 * vector->x3;
+    product->x2 = matrix->r2c1 * vector->x1 + matrix->r2c2 * vector->x2 + matrix->r2c3 * vector->x3;
+    product->x3 = matrix->r3c1 * vector->x1 + matrix->r3c2 * vector->x2 + matrix->r3c3 * vector->x3;
+}
 
 // ========== Matrix Product 3x3 at 2x3 ========= //
 

basic-geometry/quaternion.c

@@ -7,8 +7,8 @@ extern inline void bgc_fp64_quaternion_reset(BGC_FP64_Quaternion* const quaterni
 extern inline void bgc_fp32_quaternion_make_unit(BGC_FP32_Quaternion* const quaternion);
 extern inline void bgc_fp64_quaternion_make_unit(BGC_FP64_Quaternion* const quaternion);
 
-extern inline void bgc_fp32_quaternion_make(BGC_FP32_Quaternion* const quaternion, const float s0, const float x1, const float x2, const float x3);
+extern inline void bgc_fp32_quaternion_set_values(BGC_FP32_Quaternion* const quaternion, const float s0, const float x1, const float x2, const float x3);
-extern inline void bgc_fp64_quaternion_make(BGC_FP64_Quaternion* const quaternion, const double s0, const double x1, const double x2, const double x3);
+extern inline void bgc_fp64_quaternion_set_values(BGC_FP64_Quaternion* const quaternion, const double s0, const double x1, const double x2, const double x3);
 
 extern inline float bgc_fp32_quaternion_get_square_magnitude(const BGC_FP32_Quaternion* const quaternion);
 extern inline double bgc_fp64_quaternion_get_square_magnitude(const BGC_FP64_Quaternion* const quaternion);

basic-geometry/quaternion.h

@@ -46,7 +46,7 @@ inline void bgc_fp64_quaternion_make_unit(BGC_FP64_Quaternion* const quaternion)
 
 // ==================== Set ===================== //
 
-inline void bgc_fp32_quaternion_make(BGC_FP32_Quaternion* const quaternion, const float s0, const float x1, const float x2, const float x3)
+inline void bgc_fp32_quaternion_set_values(BGC_FP32_Quaternion* const quaternion, const float s0, const float x1, const float x2, const float x3)
 {
     quaternion->s0 = s0;
     quaternion->x1 = x1;
@@ -54,7 +54,7 @@ inline void bgc_fp32_quaternion_make(BGC_FP32_Quaternion* const quaternion, cons
     quaternion->x3 = x3;
 }
 
-inline void bgc_fp64_quaternion_make(BGC_FP64_Quaternion* const quaternion, const double s0, const double x1, const double x2, const double x3)
+inline void bgc_fp64_quaternion_set_values(BGC_FP64_Quaternion* const quaternion, const double s0, const double x1, const double x2, const double x3)
 {
     quaternion->s0 = s0;
     quaternion->x1 = x1;

basic-geometry/turn2.c

@@ -7,11 +7,14 @@ const BGC_FP64_Turn2 BGC_FP64_IDLE_TURN2 = { 1.0, 0.0 };
 extern inline void bgc_fp32_turn2_reset(BGC_FP32_Turn2* const turn);
 extern inline void bgc_fp64_turn2_reset(BGC_FP64_Turn2* const turn);
 
-extern inline void bgc_fp32_turn2_make(BGC_FP32_Turn2* const turn, const float x1, const float x2);
+extern void _bgc_fp32_turn2_normalize(BGC_FP32_Turn2* const turn);
-extern inline void bgc_fp64_turn2_make(BGC_FP64_Turn2* const turn, const double x1, const double x2);
+extern void _bgc_fp64_turn2_normalize(BGC_FP64_Turn2* const turn);
 
-extern inline void bgc_fp32_turn2_make_for_angle(BGC_FP32_Turn2* const turn, const float angle, const int angle_unit);
+extern inline void bgc_fp32_turn2_set_values(BGC_FP32_Turn2* const turn, const float x1, const float x2);
-extern inline void bgc_fp64_turn2_make_for_angle(BGC_FP64_Turn2* const turn, const double angle, const int angle_unit);
+extern inline void bgc_fp64_turn2_set_values(BGC_FP64_Turn2* const turn, const double x1, const double x2);
+
+extern inline void bgc_fp32_turn2_set_angle(BGC_FP32_Turn2* const turn, const float angle, const int angle_unit);
+extern inline void bgc_fp64_turn2_set_angle(BGC_FP64_Turn2* const turn, const double angle, const int angle_unit);
 
 extern inline int bgc_fp32_turn2_is_idle(const BGC_FP32_Turn2* const turn);
 extern inline int bgc_fp64_turn2_is_idle(const BGC_FP64_Turn2* const turn);
@@ -57,35 +60,3 @@ extern inline void bgc_fp64_turn2_vector_back(BGC_FP64_Vector2* const turned_vec
 
 extern inline int bgc_fp32_turn2_are_close(const BGC_FP32_Turn2* const turn1, const BGC_FP32_Turn2* const turn2);
 extern inline int bgc_fp64_turn2_are_close(const BGC_FP64_Turn2* const turn1, const BGC_FP64_Turn2* const turn2);
-
-void _bgc_fp32_turn2_normalize(BGC_FP32_Turn2* const turn)
-{
-    const float square_modulus = turn->_cos * turn->_cos + turn->_sin * turn->_sin;
-
-    if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
-        turn->_cos = 1.0f;
-        turn->_sin = 0.0f;
-        return;
-    }
-
-    const float multiplier = sqrtf(1.0f / square_modulus);
-
-    turn->_cos *= multiplier;
-    turn->_sin *= multiplier;
-}
-
-void _bgc_fp64_turn2_normalize(BGC_FP64_Turn2* const turn)
-{
-    const double square_modulus = turn->_cos * turn->_cos + turn->_sin * turn->_sin;
-
-    if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
-        turn->_cos = 1.0;
-        turn->_sin = 0.0;
-        return;
-    }
-
-    const double multiplier = sqrt(1.0 / square_modulus);
-
-    turn->_cos *= multiplier;
-    turn->_sin *= multiplier;
-}

basic-geometry/turn2.h

@@ -26,9 +26,51 @@ inline void bgc_fp64_turn2_reset(BGC_FP64_Turn2* const turn)
     turn->_sin = 0.0;
 }
 
+// ================= Normalize ================== //
+
+inline void _bgc_fp32_turn2_normalize(BGC_FP32_Turn2* const turn)
+{
+    const float square_modulus = turn->_cos * turn->_cos + turn->_sin * turn->_sin;
+
+    if (bgc_fp32_is_square_unit(square_modulus)) {
+        return;
+    }
+
+    if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
+        turn->_cos = 1.0f;
+        turn->_sin = 0.0f;
+        return;
+    }
+
+    const float multiplier = sqrtf(1.0f / square_modulus);
+
+    turn->_cos *= multiplier;
+    turn->_sin *= multiplier;
+}
+
+inline void _bgc_fp64_turn2_normalize(BGC_FP64_Turn2* const turn)
+{
+    const double square_modulus = turn->_cos * turn->_cos + turn->_sin * turn->_sin;
+
+    if (bgc_fp64_is_square_unit(square_modulus)) {
+        return;
+    }
+
+    if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
+        turn->_cos = 1.0;
+        turn->_sin = 0.0;
+        return;
+    }
+
+    const double multiplier = sqrt(1.0 / square_modulus);
+
+    turn->_cos *= multiplier;
+    turn->_sin *= multiplier;
+}
+
 // ================== Set Turn ================== //
 
-inline void bgc_fp32_turn2_make_for_angle(BGC_FP32_Turn2* const turn, const float angle, const int angle_unit)
+inline void bgc_fp32_turn2_set_angle(BGC_FP32_Turn2* const turn, const float angle, const int angle_unit)
 {
     const float radians = bgc_fp32_angle_to_radians(angle, angle_unit);
 
@@ -36,7 +78,7 @@ inline void bgc_fp32_turn2_make_for_angle(BGC_FP32_Turn2* const turn, const floa
     turn->_sin = sinf(radians);
 }
 
-inline void bgc_fp64_turn2_make_for_angle(BGC_FP64_Turn2* const turn, const double angle, const int angle_unit)
+inline void bgc_fp64_turn2_set_angle(BGC_FP64_Turn2* const turn, const double angle, const int angle_unit)
 {
     const double radians = bgc_fp64_angle_to_radians(angle, angle_unit);
 
@@ -59,32 +101,20 @@ inline int bgc_fp64_turn2_is_idle(const BGC_FP64_Turn2* const turn)
 
 // ==================== Set ===================== //
 
-void _bgc_fp32_turn2_normalize(BGC_FP32_Turn2* const twin);
+inline void bgc_fp32_turn2_set_values(BGC_FP32_Turn2* const turn, const float x1, const float x2)
-
-void _bgc_fp64_turn2_normalize(BGC_FP64_Turn2* const twin);
-
-inline void bgc_fp32_turn2_make(BGC_FP32_Turn2* const turn, const float x1, const float x2)
 {
-    const float square_modulus = x1 * x1 + x2 * x2;
-
     turn->_cos = x1;
     turn->_sin = x2;
 
-    if (!bgc_fp32_is_square_unit(square_modulus)) {
+    _bgc_fp32_turn2_normalize(turn);
-        _bgc_fp32_turn2_normalize(turn);
-    }
 }
 
-inline void bgc_fp64_turn2_make(BGC_FP64_Turn2* const turn, const double x1, const double x2)
+inline void bgc_fp64_turn2_set_values(BGC_FP64_Turn2* const turn, const double x1, const double x2)
 {
-    const double square_modulus = x1 * x1 + x2 * x2;
-
     turn->_cos = x1;
     turn->_sin = x2;
 
-    if (!bgc_fp64_is_square_unit(square_modulus)) {
+    _bgc_fp64_turn2_normalize(turn);
-        _bgc_fp64_turn2_normalize(turn);
-    }
 }
 
 // =================== Angle =================== //
@@ -143,12 +173,12 @@ inline void bgc_fp64_turn2_swap(BGC_FP64_Turn2* const turn1, BGC_FP64_Turn2* con
 
 inline void bgc_fp64_turn2_convert_to_fp32(BGC_FP32_Turn2* const destination, const BGC_FP64_Turn2* const source)
 {
-    bgc_fp32_turn2_make(destination, (float)source->_cos, (float)source->_sin);
+    bgc_fp32_turn2_set_values(destination, (float)source->_cos, (float)source->_sin);
 }
 
 inline void bgc_fp32_turn2_convert_to_fp64(BGC_FP64_Turn2* const destination, const BGC_FP32_Turn2* const source)
 {
-    bgc_fp64_turn2_make(destination, (double)source->_cos, (double)source->_sin);
+    bgc_fp64_turn2_set_values(destination, (double)source->_cos, (double)source->_sin);
 }
 
 // =================== Revert =================== //
@@ -197,7 +227,7 @@ inline void bgc_fp64_turn2_get_power(BGC_FP64_Turn2* const power, const BGC_FP64
 
 inline void bgc_fp32_turn2_combine(BGC_FP32_Turn2* const combination, const BGC_FP32_Turn2* const turn1, const BGC_FP32_Turn2* const turn2)
 {
-    bgc_fp32_turn2_make(
+    bgc_fp32_turn2_set_values(
         combination,
         turn1->_cos * turn2->_cos - turn1->_sin * turn2->_sin,
         turn1->_cos * turn2->_sin + turn1->_sin * turn2->_cos
@@ -206,7 +236,7 @@ inline void bgc_fp32_turn2_combine(BGC_FP32_Turn2* const combination, const BGC_
 
 inline void bgc_fp64_turn2_combine(BGC_FP64_Turn2* const combination, const BGC_FP64_Turn2* const turn1, const BGC_FP64_Turn2* const turn2)
 {
-    bgc_fp64_turn2_make(
+    bgc_fp64_turn2_set_values(
         combination,
         turn1->_cos * turn2->_cos - turn1->_sin * turn2->_sin,
         turn1->_cos * turn2->_sin + turn1->_sin * turn2->_cos
@@ -217,7 +247,7 @@ inline void bgc_fp64_turn2_combine(BGC_FP64_Turn2* const combination, const BGC_
 
 inline void bgc_fp32_turn2_exclude(BGC_FP32_Turn2* const difference, const BGC_FP32_Turn2* const base, const BGC_FP32_Turn2* const excludant)
 {
-    bgc_fp32_turn2_make(
+    bgc_fp32_turn2_set_values(
         difference,
         base->_cos * excludant->_cos + base->_sin * excludant->_sin,
         base->_sin * excludant->_cos - base->_cos * excludant->_sin
@@ -226,7 +256,7 @@ inline void bgc_fp32_turn2_exclude(BGC_FP32_Turn2* const difference, const BGC_F
 
 inline void bgc_fp64_turn2_exclude(BGC_FP64_Turn2* const difference, const BGC_FP64_Turn2* const base, const BGC_FP64_Turn2* const excludant)
 {
-    bgc_fp64_turn2_make(
+    bgc_fp64_turn2_set_values(
         difference,
         base->_cos * excludant->_cos + base->_sin * excludant->_sin,
         base->_sin * excludant->_cos - base->_cos * excludant->_sin

basic-geometry/turn3.c

@@ -1,5 +1,3 @@
-#include <math.h>
-
 #include "./angle.h"
 #include "./vector3.h"
 #include "./turn3.h"
@@ -11,8 +9,11 @@ const BGC_FP64_Turn3 BGC_FP64_IDLE_TURN3 = {{ 1.0, 0.0, 0.0, 0.0 }};
 extern inline void bgc_fp32_turn3_reset(BGC_FP32_Turn3* const turn);
 extern inline void bgc_fp64_turn3_reset(BGC_FP64_Turn3* const turn);
 
-extern inline void bgc_fp32_turn3_set_raw_values(BGC_FP32_Turn3* const turn, const float s0, const float x1, const float x2, const float x3);
+extern inline void _bgc_fp32_turn3_normalize(BGC_FP32_Turn3* const turn);
-extern inline void bgc_fp64_turn3_set_raw_values(BGC_FP64_Turn3* const turn, const double s0, const double x1, const double x2, const double x3);
+extern inline void _bgc_fp64_turn3_normalize(BGC_FP64_Turn3* const turn);
+
+extern inline void bgc_fp32_turn3_set_values(BGC_FP32_Turn3* const turn, const float s0, const float x1, const float x2, const float x3);
+extern inline void bgc_fp64_turn3_set_values(BGC_FP64_Turn3* const turn, const double s0, const double x1, const double x2, const double x3);
 
 extern inline void bgc_fp32_turn3_get_quaternion(BGC_FP32_Quaternion* const quaternion, const BGC_FP32_Turn3* const turn);
 extern inline void bgc_fp64_turn3_get_quaternion(BGC_FP64_Quaternion* const quaternion, const BGC_FP64_Turn3* const turn);
@@ -77,29 +78,6 @@ extern inline void bgc_fp64_turn3_vector_back(BGC_FP64_Vector3* const turned_vec
 extern inline int bgc_fp32_turn3_are_close(const BGC_FP32_Turn3* const turn1, const BGC_FP32_Turn3* const turn2);
 extern inline int bgc_fp64_turn3_are_close(const BGC_FP64_Turn3* const turn1, const BGC_FP64_Turn3* const turn2);
 
-// ================= Normalize ================== //
-
-void _bgc_fp32_turn3_normalize(BGC_FP32_Turn3* const turn, const float square_modulus)
-{
-    if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
-        bgc_fp32_turn3_reset(turn);
-        return;
-    }
-
-    bgc_fp32_quaternion_multiply_by_real_number(&turn->_versor, &turn->_versor, sqrtf(1.0f / square_modulus));
-}
-
-void _bgc_fp64_turn3_normalize(BGC_FP64_Turn3* const turn, const double square_modulus)
-{
-    if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
-        bgc_fp64_turn3_reset(turn);
-        return;
-    }
-
-    bgc_fp64_quaternion_multiply_by_real_number(&turn->_versor, &turn->_versor, sqrt(1.0 / square_modulus));
-}
-
-
 // ================ Get Rotation ================ //
 
 float bgc_fp32_turn3_get_rotation(BGC_FP32_Vector3* const axis, const BGC_FP32_Turn3* const turn, const int angle_unit)
@@ -164,13 +142,9 @@ void bgc_fp32_turn3_set_rotation(BGC_FP32_Turn3* const turn, const float x1, con
 
     const float multiplier = sine / sqrtf(square_vector);
 
-    bgc_fp32_quaternion_make(&turn->_versor, cosf(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier);
+    bgc_fp32_quaternion_set_values(&turn->_versor, cosf(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier);
 
-    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&turn->_versor);
+    _bgc_fp32_turn3_normalize(turn);
-
-    if (!bgc_fp32_is_square_unit(square_modulus)) {
-        _bgc_fp32_turn3_normalize(turn, square_modulus);
-    }
 }
 
 void bgc_fp64_turn3_set_rotation(BGC_FP64_Turn3* const turn, const double x1, const double x2, const double x3, const double angle, const int angle_unit)
@@ -193,13 +167,9 @@ void bgc_fp64_turn3_set_rotation(BGC_FP64_Turn3* const turn, const double x1, co
 
     const double multiplier = sine / sqrt(square_vector);
 
-    bgc_fp64_quaternion_make(&turn->_versor, cos(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier);
+    bgc_fp64_quaternion_set_values(&turn->_versor, cos(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier);
 
-    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&turn->_versor);
+    _bgc_fp64_turn3_normalize(turn);
-
-    if (!bgc_fp64_is_square_unit(square_modulus)) {
-        _bgc_fp64_turn3_normalize(turn, square_modulus);
-    }
 }
 
 // ========= Find Direction Difference ========== //
@@ -229,11 +199,8 @@ int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* const turn, const B
     const float axis_square_modulus = bgc_fp32_vector3_get_squared_length(&axis);
 
     if (axis_square_modulus <= BGC_FP32_SQUARE_EPSILON * square_product) {
-        if (dot_product < 0.0f) {
+        bgc_fp32_turn3_reset(turn);
-            return BGC_ERROR_TURN3_VECTORS_OPPOSITE;
+        return dot_product < 0.0f ? BGC_ERROR_TURN3_VECTORS_OPPOSITE : BGC_SUCCESS;
-        }
-
-        return BGC_SUCCESS;
     }
 
     const float axis_modulus = sqrtf(axis_square_modulus);
@@ -243,7 +210,7 @@ int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* const turn, const B
 
     const float vector_multiplier = sinf(angle) / axis_modulus;
 
-    bgc_fp32_turn3_set_raw_values(turn, cosf(angle), axis.x1 * vector_multiplier, axis.x2 * vector_multiplier, axis.x3 * vector_multiplier);
+    bgc_fp32_turn3_set_values(turn, cosf(angle), axis.x1 * vector_multiplier, axis.x2 * vector_multiplier, axis.x3 * vector_multiplier);
 
     return BGC_SUCCESS;
 }
@@ -274,11 +241,7 @@ int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* const turn, const B
 
     if (axis_square_modulus <= BGC_FP64_SQUARE_EPSILON * square_product) {
         bgc_fp64_turn3_reset(turn);
-        if (dot_product < 0.0) {
+        return dot_product < 0.0 ? BGC_ERROR_TURN3_VECTORS_OPPOSITE : BGC_SUCCESS;
-            return BGC_ERROR_TURN3_VECTORS_OPPOSITE;
-        }
-
-        return BGC_SUCCESS;
     }
 
     const double axis_modulus = sqrt(axis_square_modulus);
@@ -288,7 +251,7 @@ int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* const turn, const B
 
     const double vector_multiplier = sin(angle) / axis_modulus;
 
-    bgc_fp64_turn3_set_raw_values(turn, cos(angle), axis.x1 * vector_multiplier, axis.x2 * vector_multiplier, axis.x3 * vector_multiplier);
+    bgc_fp64_turn3_set_values(turn, cos(angle), axis.x1 * vector_multiplier, axis.x2 * vector_multiplier, axis.x3 * vector_multiplier);
 
     return BGC_SUCCESS;
 }
@@ -477,11 +440,7 @@ int bgc_fp32_turn3_find_pair_difference(
     bgc_fp32_quaternion_multiply_by_quaternion(&turn->_versor, &q2, &q1);
 
     // Making a final versor (a normalized quaternion)
-    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&turn->_versor);
+    _bgc_fp32_turn3_normalize(turn);
-
-    if (!bgc_fp32_is_square_unit(square_modulus)) {
-        _bgc_fp32_turn3_normalize(turn, square_modulus);
-    }
 
     return BGC_SUCCESS;
 }
@@ -524,11 +483,7 @@ int bgc_fp64_turn3_find_pair_difference(
     bgc_fp64_quaternion_multiply_by_quaternion(&turn->_versor, &q2, &q1);
 
     // Making a final versor (a normalized quaternion)
-    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&turn->_versor);
+    _bgc_fp64_turn3_normalize(turn);
-
-    if (!bgc_fp64_is_square_unit(square_modulus)) {
-        _bgc_fp64_turn3_normalize(turn, square_modulus);
-    }
 
     return BGC_SUCCESS;
 }
@@ -550,7 +505,7 @@ void bgc_fp32_turn3_get_power(BGC_FP32_Turn3* const power, const BGC_FP32_Turn3*
 
     const float multiplier = sinf(angle) / vector_modulus;
 
-    bgc_fp32_turn3_set_raw_values(power, cosf(angle), base->_versor.x1 * multiplier, base->_versor.x2 * multiplier, base->_versor.x3 * multiplier);
+    bgc_fp32_turn3_set_values(power, cosf(angle), base->_versor.x1 * multiplier, base->_versor.x2 * multiplier, base->_versor.x3 * multiplier);
 }
 
 void bgc_fp64_turn3_get_power(BGC_FP64_Turn3* const power, const BGC_FP64_Turn3* const base, const double exponent)
@@ -568,7 +523,7 @@ void bgc_fp64_turn3_get_power(BGC_FP64_Turn3* const power, const BGC_FP64_Turn3*
 
     const double multiplier = sin(angle) / vector_modulus;
 
-    bgc_fp64_turn3_set_raw_values(power, cos(angle), base->_versor.x1 * multiplier, base->_versor.x2 * multiplier, base->_versor.x3 * multiplier);
+    bgc_fp64_turn3_set_values(power, cos(angle), base->_versor.x1 * multiplier, base->_versor.x2 * multiplier, base->_versor.x3 * multiplier);
 }
 
 // ============ Sphere Interpolation ============ //
@@ -599,7 +554,7 @@ void bgc_fp32_turn3_spherically_interpolate(BGC_FP32_Turn3* const interpolation,
     const float turn_x3 = delta_x3 * multiplier;
 
     // Combining of starting orientation with the turning
-    bgc_fp32_turn3_set_raw_values(
+    bgc_fp32_turn3_set_values(
         interpolation,
         (turn_s0 * start->_versor.s0 - turn_x1 * start->_versor.x1) - (turn_x2 * start->_versor.x2 + turn_x3 * start->_versor.x3),
         (turn_x1 * start->_versor.s0 + turn_s0 * start->_versor.x1) - (turn_x3 * start->_versor.x2 - turn_x2 * start->_versor.x3),
@@ -634,7 +589,7 @@ void bgc_fp64_turn3_spherically_interpolate(BGC_FP64_Turn3* const interpolation,
     const double turn_x3 = delta_x3 * multiplier;
 
     // Combining of starting orientation with the turning
-    bgc_fp64_turn3_set_raw_values(
+    bgc_fp64_turn3_set_values(
         interpolation,
         (turn_s0 * start->_versor.s0 - turn_x1 * start->_versor.x1) - (turn_x2 * start->_versor.x2 + turn_x3 * start->_versor.x3),
         (turn_x1 * start->_versor.s0 + turn_s0 * start->_versor.x1) - (turn_x3 * start->_versor.x2 - turn_x2 * start->_versor.x3),

basic-geometry/turn3.h

@@ -2,6 +2,7 @@
 #define _BGC_TURN3_H_INCLUDED_
 
 #include <stdint.h>
+#include <math.h>
 
 #include "./utilities.h"
 #include "./types.h"
@@ -35,42 +36,82 @@ extern const BGC_FP64_Turn3 BGC_FP64_IDLE_TURN3;
 
 inline void bgc_fp32_turn3_reset(BGC_FP32_Turn3* const turn)
 {
-    bgc_fp32_quaternion_make(&turn->_versor, 1.0f, 0.0f, 0.0f, 0.0f);
+    turn->_versor.s0 = 1.0f;
+    turn->_versor.x1 = 0.0f;
+    turn->_versor.x2 = 0.0f;
+    turn->_versor.x3 = 0.0f;
 }
 
 inline void bgc_fp64_turn3_reset(BGC_FP64_Turn3* const turn)
 {
-    bgc_fp64_quaternion_make(&turn->_versor, 1.0, 0.0, 0.0, 0.0);
+    turn->_versor.s0 = 1.0;
+    turn->_versor.x1 = 0.0;
+    turn->_versor.x2 = 0.0;
+    turn->_versor.x3 = 0.0;
 }
 
 // ============= Private: Normalize ============= //
 
-void _bgc_fp32_turn3_normalize(BGC_FP32_Turn3* const turn, const float square_modulus);
+inline void _bgc_fp32_turn3_normalize(BGC_FP32_Turn3* const turn)
+{
+    const float square_magnitude = bgc_fp32_quaternion_get_square_magnitude(&turn->_versor);
 
-void _bgc_fp64_turn3_normalize(BGC_FP64_Turn3* const turn, const double square_modulus);
+    if (bgc_fp32_is_square_unit(square_magnitude)) {
+        return;
+    }
+
+    if (square_magnitude <= BGC_FP32_SQUARE_EPSILON || isnan(square_magnitude)) {
+        turn->_versor.s0 = 1.0f;
+        turn->_versor.x1 = 0.0f;
+        turn->_versor.x2 = 0.0f;
+        turn->_versor.x3 = 0.0f;
+        return;
+    }
+
+    const float multiplier = sqrtf(1.0f / square_magnitude);
+
+    turn->_versor.s0 *= multiplier;
+    turn->_versor.x1 *= multiplier;
+    turn->_versor.x2 *= multiplier;
+    turn->_versor.x3 *= multiplier;
+}
+
+inline void _bgc_fp64_turn3_normalize(BGC_FP64_Turn3* const turn)
+{
+    const double square_magnitude = bgc_fp64_quaternion_get_square_magnitude(&turn->_versor);
+
+    if (bgc_fp64_is_square_unit(square_magnitude)) {
+        return;
+    }
+
+    if (square_magnitude <= BGC_FP64_SQUARE_EPSILON || isnan(square_magnitude)) {
+        turn->_versor.s0 = 1.0;
+        turn->_versor.x1 = 0.0;
+        turn->_versor.x2 = 0.0;
+        turn->_versor.x3 = 0.0;
+        return;
+    }
+
+    const double multiplier = sqrt(1.0 / square_magnitude);
+
+    turn->_versor.s0 *= multiplier;
+    turn->_versor.x1 *= multiplier;
+    turn->_versor.x2 *= multiplier;
+    turn->_versor.x3 *= multiplier;
+}
 
 // ================= Set Values ================= //
 
-inline void bgc_fp32_turn3_set_raw_values(BGC_FP32_Turn3* const turn, const float s0, const float x1, const float x2, const float x3)
+inline void bgc_fp32_turn3_set_values(BGC_FP32_Turn3* const turn, const float s0, const float x1, const float x2, const float x3)
 {
-    bgc_fp32_quaternion_make(&turn->_versor, s0, x1, x2, x3);
+    bgc_fp32_quaternion_set_values(&turn->_versor, s0, x1, x2, x3);
-
+    _bgc_fp32_turn3_normalize(turn);
-    const float square_modulus = (s0 * s0 + x1 * x1) + (x2 * x2 + x3 * x3);
-
-    if (!bgc_fp32_is_square_unit(square_modulus)) {
-        _bgc_fp32_turn3_normalize(turn, square_modulus);
-    }
 }
 
-inline void bgc_fp64_turn3_set_raw_values(BGC_FP64_Turn3* const turn, const double s0, const double x1, const double x2, const double x3)
+inline void bgc_fp64_turn3_set_values(BGC_FP64_Turn3* const turn, const double s0, const double x1, const double x2, const double x3)
 {
-    bgc_fp64_quaternion_make(&turn->_versor, s0, x1, x2, x3);
+    bgc_fp64_quaternion_set_values(&turn->_versor, s0, x1, x2, x3);
-
+    _bgc_fp64_turn3_normalize(turn);
-    const double square_modulus = (s0 * s0 + x1 * x1) + (x2 * x2 + x3 * x3);
-
-    if (!bgc_fp64_is_square_unit(square_modulus)) {
-        _bgc_fp64_turn3_normalize(turn, square_modulus);
-    }
 }
 
 // =============== Get Quaternion =============== //
@@ -90,23 +131,13 @@ inline void bgc_fp64_turn3_get_quaternion(BGC_FP64_Quaternion* const quaternion,
 inline void bgc_fp32_turn3_set_quaternion(BGC_FP32_Turn3* const turn, const BGC_FP32_Quaternion* const quaternion)
 {
     bgc_fp32_quaternion_copy(&turn->_versor, quaternion);
-
+    _bgc_fp32_turn3_normalize(turn);
-    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
-
-    if (!bgc_fp32_is_square_unit(square_modulus)) {
-        _bgc_fp32_turn3_normalize(turn, square_modulus);
-    }
 }
 
 inline void bgc_fp64_turn3_set_quaternion(BGC_FP64_Turn3* const turn, const BGC_FP64_Quaternion* const quaternion)
 {
     bgc_fp64_quaternion_copy(&turn->_versor, quaternion);
-
+    _bgc_fp64_turn3_normalize(turn);
-    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
-
-    if (!bgc_fp64_is_square_unit(square_modulus)) {
-        _bgc_fp64_turn3_normalize(turn, square_modulus);
-    }
 }
 
 // ================ Get Rotation ================ //
@@ -186,23 +217,14 @@ inline int bgc_fp64_turn3_is_idle(const BGC_FP64_Turn3* const turn)
 inline void bgc_fp32_turn3_convert_to_fp64(BGC_FP64_Turn3* const destination, const BGC_FP32_Turn3* const source)
 {
     bgc_fp32_quaternion_convert_to_fp64(&destination->_versor, &source->_versor);
+    _bgc_fp64_turn3_normalize(destination);
 
-    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&destination->_versor);
-
-    if (!bgc_fp64_is_square_unit(square_modulus)) {
-        _bgc_fp64_turn3_normalize(destination, square_modulus);
-    }
 }
 
 inline void bgc_fp64_turn3_convert_to_fp32(BGC_FP32_Turn3* const destination, const BGC_FP64_Turn3* const source)
 {
     bgc_fp64_quaternion_convert_to_fp32(&destination->_versor, &source->_versor);
-
+    _bgc_fp32_turn3_normalize(destination);
-    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&destination->_versor);
-
-    if (!bgc_fp32_is_square_unit(square_modulus)) {
-        _bgc_fp32_turn3_normalize(destination, square_modulus);
-    }
 }
 
 // ================== Shorten =================== //
@@ -296,23 +318,13 @@ void bgc_fp64_turn3_get_power(BGC_FP64_Turn3* const power, const BGC_FP64_Turn3*
 inline void bgc_fp32_turn3_combine(BGC_FP32_Turn3* const combination, const BGC_FP32_Turn3* const first, const BGC_FP32_Turn3* const second)
 {
     bgc_fp32_quaternion_multiply_by_quaternion(&combination->_versor, &second->_versor, &first->_versor);
-
+    _bgc_fp32_turn3_normalize(combination);
-    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&combination->_versor);
-
-    if (!bgc_fp32_is_square_unit(square_modulus)) {
-        _bgc_fp32_turn3_normalize(combination, square_modulus);
-    }
 }
 
 inline void bgc_fp64_turn3_combine(BGC_FP64_Turn3* const combination, const BGC_FP64_Turn3* const first, const BGC_FP64_Turn3* const second)
 {
     bgc_fp64_quaternion_multiply_by_quaternion(&combination->_versor, &second->_versor, &first->_versor);
-
+    _bgc_fp64_turn3_normalize(combination);
-    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&combination->_versor);
-
-    if (!bgc_fp64_is_square_unit(square_modulus)) {
-        _bgc_fp64_turn3_normalize(combination, square_modulus);
-    }
 }
 
 // ============ Combination of three ============ //
@@ -325,11 +337,7 @@ inline void bgc_fp32_turn3_combine3(BGC_FP32_Turn3* const combination, const BGC
 
     bgc_fp32_quaternion_multiply_by_quaternion(&combination->_versor, &third->_versor, &product);
 
-    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&combination->_versor);
+    _bgc_fp32_turn3_normalize(combination);
-
-    if (!bgc_fp32_is_square_unit(square_modulus)) {
-        _bgc_fp32_turn3_normalize(combination, square_modulus);
-    }
 }
 
 inline void bgc_fp64_turn3_combine3(BGC_FP64_Turn3* const combination, const BGC_FP64_Turn3* const first, const BGC_FP64_Turn3* const second, const BGC_FP64_Turn3* const third)
@@ -340,11 +348,7 @@ inline void bgc_fp64_turn3_combine3(BGC_FP64_Turn3* const combination, const BGC
 
     bgc_fp64_quaternion_multiply_by_quaternion(&combination->_versor, &third->_versor, &product);
 
-    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&combination->_versor);
+    _bgc_fp64_turn3_normalize(combination);
-
-    if (!bgc_fp64_is_square_unit(square_modulus)) {
-        _bgc_fp64_turn3_normalize(combination, square_modulus);
-    }
 }
 
 // ================= Exclusion ================== //
@@ -353,22 +357,14 @@ inline void bgc_fp32_turn3_exclude(BGC_FP32_Turn3* const difference, const BGC_F
 {
     bgc_fp32_quaternion_multiply_by_conjugate(&difference->_versor, &base->_versor, &excludant->_versor);
 
-    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&difference->_versor);
+    _bgc_fp32_turn3_normalize(difference);
-
-    if (!bgc_fp32_is_square_unit(square_modulus)) {
-        _bgc_fp32_turn3_normalize(difference, square_modulus);
-    }
 }
 
 inline void bgc_fp64_turn3_exclude(BGC_FP64_Turn3* const difference, const BGC_FP64_Turn3* const base, const BGC_FP64_Turn3* const excludant)
 {
     bgc_fp64_quaternion_multiply_by_conjugate(&difference->_versor, &base->_versor, &excludant->_versor);
 
-    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&difference->_versor);
+    _bgc_fp64_turn3_normalize(difference);
-
-    if (!bgc_fp64_is_square_unit(square_modulus)) {
-        _bgc_fp64_turn3_normalize(difference, square_modulus);
-    }
 }
 
 // ============ Sphere Interpolation ============ //

basic-geometry/vector2.c

@@ -3,8 +3,8 @@
 extern inline void bgc_fp32_vector2_reset(BGC_FP32_Vector2* const vector);
 extern inline void bgc_fp64_vector2_reset(BGC_FP64_Vector2* const vector);
 
-extern inline void bgc_fp32_vector2_make(BGC_FP32_Vector2* const destination, const float x1, const float x2);
+extern inline void bgc_fp32_vector2_set_values(BGC_FP32_Vector2* const destination, const float x1, const float x2);
-extern inline void bgc_fp64_vector2_make(BGC_FP64_Vector2* const destination, const double x1, const double x2);
+extern inline void bgc_fp64_vector2_set_values(BGC_FP64_Vector2* const destination, const double x1, const double x2);
 
 extern inline float bgc_fp32_vector2_get_squared_length(const BGC_FP32_Vector2* const vector);
 extern inline double bgc_fp64_vector2_get_squared_length(const BGC_FP64_Vector2* const vector);

basic-geometry/vector2.h

@@ -23,13 +23,13 @@ inline void bgc_fp64_vector2_reset(BGC_FP64_Vector2* const vector)
 
 // ==================== Set ===================== //
 
-inline void bgc_fp32_vector2_make(BGC_FP32_Vector2* const destination, const float x1, const float x2)
+inline void bgc_fp32_vector2_set_values(BGC_FP32_Vector2* const destination, const float x1, const float x2)
 {
     destination->x1 = x1;
     destination->x2 = x2;
 }
 
-inline void bgc_fp64_vector2_make(BGC_FP64_Vector2* const destination, const double x1, const double x2)
+inline void bgc_fp64_vector2_set_values(BGC_FP64_Vector2* const destination, const double x1, const double x2)
 {
     destination->x1 = x1;
     destination->x2 = x2;

basic-geometry/vector3.c

@@ -3,8 +3,8 @@
 extern inline void bgc_fp32_vector3_reset(BGC_FP32_Vector3* const vector);
 extern inline void bgc_fp64_vector3_reset(BGC_FP64_Vector3* const vector);
 
-extern inline void bgc_fp32_vector3_make(BGC_FP32_Vector3* const destination, const float x1, const float x2, const float x3);
+extern inline void bgc_fp32_vector3_set_values(BGC_FP32_Vector3* const destination, const float x1, const float x2, const float x3);
-extern inline void bgc_fp64_vector3_make(BGC_FP64_Vector3* const destination, const double x1, const double x2, const double x3);
+extern inline void bgc_fp64_vector3_set_values(BGC_FP64_Vector3* const destination, const double x1, const double x2, const double x3);
 
 extern inline float bgc_fp32_vector3_get_squared_length(const BGC_FP32_Vector3* const vector);
 extern inline double bgc_fp64_vector3_get_squared_length(const BGC_FP64_Vector3* const vector);

basic-geometry/vector3.h

@@ -25,14 +25,14 @@ inline void bgc_fp64_vector3_reset(BGC_FP64_Vector3* const vector)
 
 // ==================== Set ===================== //
 
-inline void bgc_fp32_vector3_make(BGC_FP32_Vector3* const destination, const float x1, const float x2, const float x3)
+inline void bgc_fp32_vector3_set_values(BGC_FP32_Vector3* const destination, const float x1, const float x2, const float x3)
 {
     destination->x1 = x1;
     destination->x2 = x2;
     destination->x3 = x3;
 }
 
-inline void bgc_fp64_vector3_make(BGC_FP64_Vector3* const destination, const double x1, const double x2, const double x3)
+inline void bgc_fp64_vector3_set_values(BGC_FP64_Vector3* const destination, const double x1, const double x2, const double x3)
 {
     destination->x1 = x1;
     destination->x2 = x2;