Отказ от restrict функций для упрощения библиотеки. Компиляторы достаточно хорошо оптимизируют не-restrict inline-функции

basic-geometry-dev/main.c

@@ -504,9 +504,9 @@ void test_pair_difference_fp64()
 int main()
 {
     //test_pair_difference_fp32();
-    test_pair_difference_fp64();
+    //test_pair_difference_fp64();
 
-    //printf("Affine3 performance test: %f\n", test_bgc_affine3_performance(10000000, 10));
+    printf("Affine3 performance test: %f\n", test_bgc_affine3_performance(10000000, 10));
 
     //printf("sizeof(BGC_FP32_Affine3)   = %zu\n", sizeof(BGC_FP32_Affine3));
     //printf("offsetof(shift)         = %zu\n", offsetof(BGC_FP32_Affine3, shift));

basic-geometry/affine2.h

@@ -133,7 +133,7 @@ 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_restrict_matrix2x2_multiply_by_vector2(&first_shift, &second->distortion, &first->shift);
+    bgc_fp32_matrix2x2_multiply_by_vector2(&first_shift, &second->distortion, &first->shift);
     bgc_fp32_vector2_add(&combination->shift, &second->shift, &first_shift);
     bgc_fp32_matrix2x2_multiply_by_matrix2x2(&combination->distortion, &second->distortion, &first->distortion);
 }
@@ -141,7 +141,7 @@ inline void bgc_fp32_affine2_combine(BGC_FP32_Affine2* const combination, const
 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_restrict_matrix2x2_multiply_by_vector2(&first_shift, &second->distortion, &first->shift);
+    bgc_fp64_matrix2x2_multiply_by_vector2(&first_shift, &second->distortion, &first->shift);
     bgc_fp64_vector2_add(&combination->shift, &second->shift, &first_shift);
     bgc_fp64_matrix2x2_multiply_by_matrix2x2(&combination->distortion, &second->distortion, &first->distortion);
 }
@@ -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_restrict_matrix2x2_multiply_by_vector2(&distorted, &affine->distortion, initial_point);
+    bgc_fp32_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_restrict_matrix2x2_multiply_by_vector2(&distorted, &affine->distortion, initial_point);
+    bgc_fp64_matrix2x2_multiply_by_vector2(&distorted, &affine->distortion, initial_point);
     bgc_fp64_vector2_add(transformed_point, &affine->shift, &distorted);
 }
 

basic-geometry/affine3.h

@@ -132,7 +132,7 @@ 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_restrict_matrix3x3_multiply_by_vector3(&first_shift, &second->distortion, &first->shift);
+    bgc_fp32_matrix3x3_multiply_by_vector3(&first_shift, &second->distortion, &first->shift);
     bgc_fp32_vector3_add(&combination->shift, &first_shift, &second->shift);
     bgc_fp32_matrix3x3_multiply_by_matrix3x3(&combination->distortion, &second->distortion, &first->distortion);
 }
@@ -140,7 +140,7 @@ inline void bgc_fp32_affine3_combine(BGC_FP32_Affine3* const combination, const
 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_restrict_matrix3x3_multiply_by_vector3(&first_shift, &second->distortion, &first->shift);
+    bgc_fp64_matrix3x3_multiply_by_vector3(&first_shift, &second->distortion, &first->shift);
     bgc_fp64_vector3_add(&combination->shift, &first_shift, &second->shift);
     bgc_fp64_matrix3x3_multiply_by_matrix3x3(&combination->distortion, &second->distortion, &first->distortion);
 }
@@ -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_restrict_matrix3x3_multiply_by_vector3(&distorted, &affine->distortion, initial_point);
+    bgc_fp32_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_restrict_matrix3x3_multiply_by_vector3(&distorted, &affine->distortion, initial_point);
+    bgc_fp64_matrix3x3_multiply_by_vector3(&distorted, &affine->distortion, initial_point);
     bgc_fp64_vector3_add(transformed_point, &affine->shift, &distorted);
 }
 

basic-geometry/dual-quaternion.h

@@ -98,8 +98,8 @@ inline int bgc_fp32_dual_quaternion_invert(BGC_FP32_DualQuaternion* const quater
 
     BGC_FP32_Quaternion temporary;
 
-    _bgc_fp32_restrict_quaternion_multiply_by_quaternion(&temporary, &quaternion->real_part, &quaternion->dual_part);
+    bgc_fp32_quaternion_multiply_by_quaternion(&temporary, &quaternion->real_part, &quaternion->dual_part);
-    _bgc_fp32_restrict_quaternion_multiply_by_quaternion(&quaternion->dual_part, &temporary, &quaternion->real_part);
+    bgc_fp32_quaternion_multiply_by_quaternion(&quaternion->dual_part, &temporary, &quaternion->real_part);
 
     bgc_fp32_quaternion_revert(&quaternion->dual_part);
 
@@ -114,8 +114,8 @@ inline int bgc_fp64_dual_quaternion_invert(BGC_FP64_DualQuaternion* const quater
 
     BGC_FP64_Quaternion temporary;
 
-    _bgc_fp64_restrict_quaternion_multiply_by_quaternion(&temporary, &quaternion->real_part, &quaternion->dual_part);
+    bgc_fp64_quaternion_multiply_by_quaternion(&temporary, &quaternion->real_part, &quaternion->dual_part);
-    _bgc_fp64_restrict_quaternion_multiply_by_quaternion(&quaternion->dual_part, &temporary, &quaternion->real_part);
+    bgc_fp64_quaternion_multiply_by_quaternion(&quaternion->dual_part, &temporary, &quaternion->real_part);
 
     bgc_fp64_quaternion_revert(&quaternion->dual_part);
 
@@ -132,8 +132,8 @@ inline int bgc_fp32_dual_quaternion_get_inverse(BGC_FP32_DualQuaternion* const i
 
     BGC_FP32_Quaternion temporary;
 
-    _bgc_fp32_restrict_quaternion_multiply_by_quaternion(&temporary, &inverse->real_part, &quaternion->dual_part);
+    bgc_fp32_quaternion_multiply_by_quaternion(&temporary, &inverse->real_part, &quaternion->dual_part);
-    _bgc_fp32_restrict_quaternion_multiply_by_quaternion(&inverse->dual_part, &temporary, &inverse->real_part);
+    bgc_fp32_quaternion_multiply_by_quaternion(&inverse->dual_part, &temporary, &inverse->real_part);
 
     bgc_fp32_quaternion_revert(&inverse->dual_part);
 
@@ -148,8 +148,8 @@ inline int bgc_fp64_dual_quaternion_get_inverse(BGC_FP64_DualQuaternion* const i
 
     BGC_FP64_Quaternion temporary;
 
-    _bgc_fp64_restrict_quaternion_multiply_by_quaternion(&temporary, &inverse->real_part, &quaternion->dual_part);
+    bgc_fp64_quaternion_multiply_by_quaternion(&temporary, &inverse->real_part, &quaternion->dual_part);
-    _bgc_fp64_restrict_quaternion_multiply_by_quaternion(&inverse->dual_part, &temporary, &inverse->real_part);
+    bgc_fp64_quaternion_multiply_by_quaternion(&inverse->dual_part, &temporary, &inverse->real_part);
 
     bgc_fp64_quaternion_revert(&inverse->dual_part);
 
@@ -510,8 +510,8 @@ inline void bgc_fp32_dual_quaternion_multiply_by_dual_quaternion(BGC_FP32_DualQu
 {
     BGC_FP32_Quaternion dual_part1, dual_part2;
 
-    _bgc_fp32_restrict_quaternion_multiply_by_quaternion(&dual_part1, &left->real_part, &right->dual_part);
+    bgc_fp32_quaternion_multiply_by_quaternion(&dual_part1, &left->real_part, &right->dual_part);
-    _bgc_fp32_restrict_quaternion_multiply_by_quaternion(&dual_part2, &left->dual_part, &right->real_part);
+    bgc_fp32_quaternion_multiply_by_quaternion(&dual_part2, &left->dual_part, &right->real_part);
 
     bgc_fp32_quaternion_multiply_by_quaternion(&product->real_part, &left->real_part, &right->real_part);
     bgc_fp32_quaternion_add(&product->dual_part, &dual_part1, &dual_part2);

basic-geometry/dual-vector3.c

@@ -42,9 +42,6 @@ extern inline void bgc_fp64_dual_vector3_multiply_by_conjugate_dual_number(BGC_F
 extern inline void bgc_fp32_dual_vector3_multiply_by_matrix3x3(BGC_FP32_DualVector3* const product, const BGC_FP32_DualVector3* const vector, const BGC_FP32_Matrix3x3* const matrix);
 extern inline void bgc_fp64_dual_vector3_multiply_by_matrix3x3(BGC_FP64_DualVector3* const product, const BGC_FP64_DualVector3* const vector, const BGC_FP64_Matrix3x3* const matrix);
 
-extern inline void _bgc_fp32_restrict_dual_vector3_multiply_by_matrix3x3(BGC_FP32_DualVector3* restrict const product, const BGC_FP32_DualVector3* const vector, const BGC_FP32_Matrix3x3* const matrix);
-extern inline void _bgc_fp64_restrict_dual_vector3_multiply_by_matrix3x3(BGC_FP64_DualVector3* restrict const product, const BGC_FP64_DualVector3* const vector, const BGC_FP64_Matrix3x3* const matrix);
-
 extern inline int bgc_fp32_dual_vector3_divide_by_real_number(BGC_FP32_DualVector3* const quotient, const BGC_FP32_DualVector3* const dividend, const float divisor);
 extern inline int bgc_fp64_dual_vector3_divide_by_real_number(BGC_FP64_DualVector3* const quotient, const BGC_FP64_DualVector3* const dividend, const double divisor);
 

basic-geometry/dual-vector3.h

@@ -222,9 +222,9 @@ inline void bgc_fp32_dual_vector3_multiply_by_matrix3x3(BGC_FP32_DualVector3* co
     product->real_part.y = real_y;
     product->real_part.z = real_z;
 
-    product->real_part.x = real_x;
+    product->real_part.x = dual_x;
-    product->real_part.y = real_y;
+    product->real_part.y = dual_y;
-    product->real_part.z = real_z;
+    product->real_part.z = dual_z;
 }
 
 inline void bgc_fp64_dual_vector3_multiply_by_matrix3x3(BGC_FP64_DualVector3* const product, const BGC_FP64_DualVector3* const vector, const BGC_FP64_Matrix3x3* const matrix)
@@ -241,33 +241,9 @@ inline void bgc_fp64_dual_vector3_multiply_by_matrix3x3(BGC_FP64_DualVector3* co
     product->real_part.y = real_y;
     product->real_part.z = real_z;
 
-    product->real_part.x = real_x;
+    product->real_part.x = dual_x;
-    product->real_part.y = real_y;
+    product->real_part.y = dual_y;
-    product->real_part.z = real_z;
+    product->real_part.z = dual_z;
-}
-
-// ===== Restrict Left Dual Vector Product ====== //
-
-inline void _bgc_fp32_restrict_dual_vector3_multiply_by_matrix3x3(BGC_FP32_DualVector3* restrict const product, const BGC_FP32_DualVector3* const vector, const BGC_FP32_Matrix3x3* const matrix)
-{
-    product->real_part.x = vector->real_part.x * matrix->r1c1 + vector->real_part.y * matrix->r2c1 + vector->real_part.z * matrix->r3c1;
-    product->real_part.y = vector->real_part.x * matrix->r1c2 + vector->real_part.y * matrix->r2c2 + vector->real_part.z * matrix->r3c2;
-    product->real_part.z = vector->real_part.x * matrix->r1c3 + vector->real_part.y * matrix->r2c3 + vector->real_part.z * matrix->r3c3;
-
-    product->real_part.x = vector->real_part.x * matrix->r1c1 + vector->real_part.y * matrix->r2c1 + vector->real_part.z * matrix->r3c1;
-    product->real_part.y = vector->real_part.x * matrix->r1c2 + vector->real_part.y * matrix->r2c2 + vector->real_part.z * matrix->r3c2;
-    product->real_part.z = vector->real_part.x * matrix->r1c3 + vector->real_part.y * matrix->r2c3 + vector->real_part.z * matrix->r3c3;
-}
-
-inline void _bgc_fp64_restrict_dual_vector3_multiply_by_matrix3x3(BGC_FP64_DualVector3* restrict const product, const BGC_FP64_DualVector3* const vector, const BGC_FP64_Matrix3x3* const matrix)
-{
-    product->real_part.x = vector->real_part.x * matrix->r1c1 + vector->real_part.y * matrix->r2c1 + vector->real_part.z * matrix->r3c1;
-    product->real_part.y = vector->real_part.x * matrix->r1c2 + vector->real_part.y * matrix->r2c2 + vector->real_part.z * matrix->r3c2;
-    product->real_part.z = vector->real_part.x * matrix->r1c3 + vector->real_part.y * matrix->r2c3 + vector->real_part.z * matrix->r3c3;
-
-    product->real_part.x = vector->real_part.x * matrix->r1c1 + vector->real_part.y * matrix->r2c1 + vector->real_part.z * matrix->r3c1;
-    product->real_part.y = vector->real_part.x * matrix->r1c2 + vector->real_part.y * matrix->r2c2 + vector->real_part.z * matrix->r3c2;
-    product->real_part.z = vector->real_part.x * matrix->r1c3 + vector->real_part.y * matrix->r2c3 + vector->real_part.z * matrix->r3c3;
 }
 
 // =================== Divide =================== //
@@ -422,8 +398,8 @@ inline void bgc_fp32_dual_vector3_get_cross_product(BGC_FP32_DualVector3* const
 {
     BGC_FP32_Vector3 part1, part2;
 
-    _bgc_fp32_restrict_vector3_get_cross_product(&part1, &first->dual_part, &second->real_part);
+    bgc_fp32_vector3_get_cross_product(&part1, &first->dual_part, &second->real_part);
-    _bgc_fp32_restrict_vector3_get_cross_product(&part2, &first->real_part, &second->dual_part);
+    bgc_fp32_vector3_get_cross_product(&part2, &first->real_part, &second->dual_part);
 
     bgc_fp32_vector3_get_cross_product(&product->real_part, &first->real_part, &second->real_part);
     bgc_fp32_vector3_add(&product->dual_part, &part1, &part2);
@@ -433,8 +409,8 @@ inline void bgc_fp64_dual_vector3_get_cross_product(BGC_FP64_DualVector3* const
 {
     BGC_FP64_Vector3 part1, part2;
 
-    _bgc_fp64_restrict_vector3_get_cross_product(&part1, &first->dual_part, &second->real_part);
+    bgc_fp64_vector3_get_cross_product(&part1, &first->dual_part, &second->real_part);
-    _bgc_fp64_restrict_vector3_get_cross_product(&part2, &first->real_part, &second->dual_part);
+    bgc_fp64_vector3_get_cross_product(&part2, &first->real_part, &second->dual_part);
 
     bgc_fp64_vector3_get_cross_product(&product->real_part, &first->real_part, &second->real_part);
     bgc_fp64_vector3_add(&product->dual_part, &part1, &part2);

basic-geometry/matrix2x2.c

@@ -75,9 +75,6 @@ extern inline void bgc_fp64_matrix2x2_multiply_by_real_number(BGC_FP64_Matrix2x2
 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 matrix, const BGC_FP32_Matrix2x2* const matriy);
 extern inline void bgc_fp64_matrix2x2_multiply_by_matrix2x2(BGC_FP64_Matrix2x2* const product, const BGC_FP64_Matrix2x2* const matrix, const BGC_FP64_Matrix2x2* const matriy);
 

basic-geometry/matrix2x2.h

@@ -597,20 +597,6 @@ inline void bgc_fp64_matrix2x2_multiply_by_vector2(BGC_FP64_Vector2* const produ
     product->y = y;
 }
 
-// ======= 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->x = matrix->r1c1 * vector->x + matrix->r1c2 * vector->y;
-    product->y = matrix->r2c1 * vector->x + matrix->r2c2 * vector->y;
-}
-
-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->x = matrix->r1c1 * vector->x + matrix->r1c2 * vector->y;
-    product->y = matrix->r2c1 * vector->x + matrix->r2c2 * vector->y;
-}
-
 // ========== Matrix Product 2y at 2y ========= //
 
 inline void bgc_fp32_matrix2x2_multiply_by_matrix2x2(BGC_FP32_Matrix2x2* const product, const BGC_FP32_Matrix2x2* const matrix, const BGC_FP32_Matrix2x2* const matriy)

basic-geometry/matrix3x3.c

@@ -72,12 +72,6 @@ extern inline void bgc_fp64_matrix3x3_multiply_by_vector3(BGC_FP64_Vector3* cons
 extern inline void bgc_fp32_matrix3x3_multiply_by_dual_vector3(BGC_FP32_DualVector3* const product, const BGC_FP32_Matrix3x3* const matrix, const BGC_FP32_DualVector3* const vector);
 extern inline void bgc_fp64_matrix3x3_multiply_by_dual_vector3(BGC_FP64_DualVector3* const product, const BGC_FP64_Matrix3x3* const matrix, const BGC_FP64_DualVector3* 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_restrict_matrix3x3_multiply_by_dual_vector3(BGC_FP32_DualVector3* restrict const product, const BGC_FP32_Matrix3x3* const matrix, const BGC_FP32_DualVector3* const vector);
-extern inline void _bgc_fp64_restrict_matrix3x3_multiply_by_dual_vector3(BGC_FP64_DualVector3* restrict const product, const BGC_FP64_Matrix3x3* const matrix, const BGC_FP64_DualVector3* const vector);
-
 extern inline void bgc_fp32_matrix3x3_multiply_by_matrix2x3(BGC_FP32_Matrix2x3* const product, const BGC_FP32_Matrix3x3* const matrix, const BGC_FP32_Matrix2x3* const matriy);
 extern inline void bgc_fp64_matrix3x3_multiply_by_matrix2x3(BGC_FP64_Matrix2x3* const product, const BGC_FP64_Matrix3x3* const matrix, const BGC_FP64_Matrix2x3* const matriy);
 

basic-geometry/matrix3x3.h

@@ -856,9 +856,9 @@ inline void bgc_fp32_matrix3x3_multiply_by_dual_vector3(BGC_FP32_DualVector3* co
     product->real_part.y = real_y;
     product->real_part.z = real_z;
 
-    product->real_part.x = real_x;
+    product->real_part.x = dual_x;
-    product->real_part.y = real_y;
+    product->real_part.y = dual_y;
-    product->real_part.z = real_z;
+    product->real_part.z = dual_z;
 }
 
 inline void bgc_fp64_matrix3x3_multiply_by_dual_vector3(BGC_FP64_DualVector3* const product, const BGC_FP64_Matrix3x3* const matrix, const BGC_FP64_DualVector3* const vector)
@@ -875,49 +875,9 @@ inline void bgc_fp64_matrix3x3_multiply_by_dual_vector3(BGC_FP64_DualVector3* co
     product->real_part.y = real_y;
     product->real_part.z = real_z;
 
-    product->real_part.x = real_x;
+    product->real_part.x = dual_x;
-    product->real_part.y = real_y;
+    product->real_part.y = dual_y;
-    product->real_part.z = real_z;
+    product->real_part.z = dual_z;
-}
-
-// ======= 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->x = matrix->r1c1 * vector->x + matrix->r1c2 * vector->y + matrix->r1c3 * vector->z;
-    product->y = matrix->r2c1 * vector->x + matrix->r2c2 * vector->y + matrix->r2c3 * vector->z;
-    product->z = matrix->r3c1 * vector->x + matrix->r3c2 * vector->y + matrix->r3c3 * vector->z;
-}
-
-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->x = matrix->r1c1 * vector->x + matrix->r1c2 * vector->y + matrix->r1c3 * vector->z;
-    product->y = matrix->r2c1 * vector->x + matrix->r2c2 * vector->y + matrix->r2c3 * vector->z;
-    product->z = matrix->r3c1 * vector->x + matrix->r3c2 * vector->y + matrix->r3c3 * vector->z;
-}
-
-// ========= Right Dual Vector Product ========== //
-
-inline void _bgc_fp32_restrict_matrix3x3_multiply_by_dual_vector3(BGC_FP32_DualVector3* restrict const product, const BGC_FP32_Matrix3x3* const matrix, const BGC_FP32_DualVector3* const vector)
-{
-    product->real_part.x = matrix->r1c1 * vector->real_part.x + matrix->r1c2 * vector->real_part.y + matrix->r1c3 * vector->real_part.z;
-    product->real_part.y = matrix->r2c1 * vector->real_part.x + matrix->r2c2 * vector->real_part.y + matrix->r2c3 * vector->real_part.z;
-    product->real_part.z = matrix->r3c1 * vector->real_part.x + matrix->r3c2 * vector->real_part.y + matrix->r3c3 * vector->real_part.z;
-
-    product->real_part.x = matrix->r1c1 * vector->dual_part.x + matrix->r1c2 * vector->dual_part.y + matrix->r1c3 * vector->dual_part.z;
-    product->real_part.y = matrix->r2c1 * vector->dual_part.x + matrix->r2c2 * vector->dual_part.y + matrix->r2c3 * vector->dual_part.z;
-    product->real_part.z = matrix->r3c1 * vector->dual_part.x + matrix->r3c2 * vector->dual_part.y + matrix->r3c3 * vector->dual_part.z;
-}
-
-inline void _bgc_fp64_restrict_matrix3x3_multiply_by_dual_vector3(BGC_FP64_DualVector3* restrict const product, const BGC_FP64_Matrix3x3* const matrix, const BGC_FP64_DualVector3* const vector)
-{
-    product->real_part.x = matrix->r1c1 * vector->real_part.x + matrix->r1c2 * vector->real_part.y + matrix->r1c3 * vector->real_part.z;
-    product->real_part.y = matrix->r2c1 * vector->real_part.x + matrix->r2c2 * vector->real_part.y + matrix->r2c3 * vector->real_part.z;
-    product->real_part.z = matrix->r3c1 * vector->real_part.x + matrix->r3c2 * vector->real_part.y + matrix->r3c3 * vector->real_part.z;
-
-    product->real_part.x = matrix->r1c1 * vector->dual_part.x + matrix->r1c2 * vector->dual_part.y + matrix->r1c3 * vector->dual_part.z;
-    product->real_part.y = matrix->r2c1 * vector->dual_part.x + matrix->r2c2 * vector->dual_part.y + matrix->r2c3 * vector->dual_part.z;
-    product->real_part.z = matrix->r3c1 * vector->dual_part.x + matrix->r3c2 * vector->dual_part.y + matrix->r3c3 * vector->dual_part.z;
 }
 
 // ========== Matrix Product 3z at 2z ========= //

basic-geometry/quaternion.c

@@ -55,9 +55,6 @@ extern inline void bgc_fp64_quaternion_multiply_by_real_number(BGC_FP64_Quaterni
 extern inline void bgc_fp32_quaternion_multiply_by_dual_number(BGC_FP32_DualQuaternion* const product, const BGC_FP32_Quaternion* const multiplicand, const BGC_FP32_DualNumber* const multiplier);
 extern inline void bgc_fp64_quaternion_multiply_by_dual_number(BGC_FP64_DualQuaternion* const product, const BGC_FP64_Quaternion* const multiplicand, const BGC_FP64_DualNumber* const multiplier);
 
-extern inline void _bgc_fp32_restrict_quaternion_multiply_by_dual_number(BGC_FP32_DualQuaternion* restrict const product, const BGC_FP32_Quaternion* const multiplicand, const BGC_FP32_DualNumber* const multiplier);
-extern inline void _bgc_fp64_restrict_quaternion_multiply_by_dual_number(BGC_FP64_DualQuaternion* restrict const product, const BGC_FP64_Quaternion* const multiplicand, const BGC_FP64_DualNumber* const multiplier);
-
 extern inline void bgc_fp32_quaternion_multiply_by_quaternion(BGC_FP32_Quaternion* const product, const BGC_FP32_Quaternion* const left, const BGC_FP32_Quaternion* const right);
 extern inline void bgc_fp64_quaternion_multiply_by_quaternion(BGC_FP64_Quaternion* const product, const BGC_FP64_Quaternion* const left, const BGC_FP64_Quaternion* const right);
 
@@ -73,12 +70,6 @@ extern inline void bgc_fp64_conjugate_quaternion_multiply_by_quaternion(BGC_FP64
 extern inline void bgc_fp32_conjugate_quaternion_multiply_by_conjugate(BGC_FP32_Quaternion* const product, const BGC_FP32_Quaternion* const left, const BGC_FP32_Quaternion* const right);
 extern inline void bgc_fp64_conjugate_quaternion_multiply_by_conjugate(BGC_FP64_Quaternion* const product, const BGC_FP64_Quaternion* const left, const BGC_FP64_Quaternion* const right);
 
-extern inline void _bgc_fp32_restrict_quaternion_multiply_by_quaternion(BGC_FP32_Quaternion* restrict const product, const BGC_FP32_Quaternion* const left, const BGC_FP32_Quaternion* const right);
-extern inline void _bgc_fp64_restrict_quaternion_multiply_by_quaternion(BGC_FP64_Quaternion* restrict const product, const BGC_FP64_Quaternion* const left, const BGC_FP64_Quaternion* const right);
-
-extern inline void _bgc_fp32_restrict_quaternion_multiply_by_conjugate(BGC_FP32_Quaternion* restrict const product, const BGC_FP32_Quaternion* const left, const BGC_FP32_Quaternion* const right);
-extern inline void _bgc_fp64_restrict_quaternion_multiply_by_conjugate(BGC_FP64_Quaternion* restrict const product, const BGC_FP64_Quaternion* const left, const BGC_FP64_Quaternion* const right);
-
 extern inline int bgc_fp32_quaternion_divide_by_real_number(BGC_FP32_Quaternion* const quotient, const BGC_FP32_Quaternion* const dividend, const float divisor);
 extern inline int bgc_fp64_quaternion_divide_by_real_number(BGC_FP64_Quaternion* const quotient, const BGC_FP64_Quaternion* const dividend, const double divisor);
 

basic-geometry/quaternion.h

@@ -346,34 +346,6 @@ inline void bgc_fp64_quaternion_multiply_by_dual_number(BGC_FP64_DualQuaternion*
     product->dual_part.z = dual_z;
 }
 
-// ====== Restrict Multiply By Dual Number ====== //
-
-inline void _bgc_fp32_restrict_quaternion_multiply_by_dual_number(BGC_FP32_DualQuaternion* restrict const product, const BGC_FP32_Quaternion* const multiplicand, const BGC_FP32_DualNumber* const multiplier)
-{
-    product->real_part.s = multiplicand->s * multiplier->real_part;
-    product->real_part.x = multiplicand->x * multiplier->real_part;
-    product->real_part.y = multiplicand->y * multiplier->real_part;
-    product->real_part.z = multiplicand->z * multiplier->real_part;
-
-    product->dual_part.s = multiplicand->s * multiplier->dual_part;
-    product->dual_part.x = multiplicand->x * multiplier->dual_part;
-    product->dual_part.y = multiplicand->y * multiplier->dual_part;
-    product->dual_part.z = multiplicand->z * multiplier->dual_part;
-}
-
-inline void _bgc_fp64_restrict_quaternion_multiply_by_dual_number(BGC_FP64_DualQuaternion* restrict const product, const BGC_FP64_Quaternion* const multiplicand, const BGC_FP64_DualNumber* const multiplier)
-{
-    product->real_part.s = multiplicand->s * multiplier->real_part;
-    product->real_part.x = multiplicand->x * multiplier->real_part;
-    product->real_part.y = multiplicand->y * multiplier->real_part;
-    product->real_part.z = multiplicand->z * multiplier->real_part;
-
-    product->dual_part.s = multiplicand->s * multiplier->dual_part;
-    product->dual_part.x = multiplicand->x * multiplier->dual_part;
-    product->dual_part.y = multiplicand->y * multiplier->dual_part;
-    product->dual_part.z = multiplicand->z * multiplier->dual_part;
-}
-
 // =========== Multiply By Quaternion =========== //
 
 inline void bgc_fp32_quaternion_multiply_by_quaternion(BGC_FP32_Quaternion* const product, const BGC_FP32_Quaternion* const left, const BGC_FP32_Quaternion* const right)
@@ -486,42 +458,6 @@ inline void bgc_fp64_conjugate_quaternion_multiply_by_conjugate(BGC_FP64_Quatern
     product->z = z;
 }
 
-// ====== Restrict Multiply By Quaternion ======= //
-
-inline void _bgc_fp32_restrict_quaternion_multiply_by_quaternion(BGC_FP32_Quaternion* restrict const product, const BGC_FP32_Quaternion* const left, const BGC_FP32_Quaternion* const right)
-{
-    product->s = (left->s * right->s - left->x * right->x) - (left->y * right->y + left->z * right->z);
-    product->x = (left->x * right->s + left->s * right->x) - (left->z * right->y - left->y * right->z);
-    product->y = (left->y * right->s + left->s * right->y) - (left->x * right->z - left->z * right->x);
-    product->z = (left->z * right->s + left->s * right->z) - (left->y * right->x - left->x * right->y);
-}
-
-inline void _bgc_fp64_restrict_quaternion_multiply_by_quaternion(BGC_FP64_Quaternion* restrict const product, const BGC_FP64_Quaternion* const left, const BGC_FP64_Quaternion* const right)
-{
-    product->s = (left->s * right->s - left->x * right->x) - (left->y * right->y + left->z * right->z);
-    product->x = (left->x * right->s + left->s * right->x) - (left->z * right->y - left->y * right->z);
-    product->y = (left->y * right->s + left->s * right->y) - (left->x * right->z - left->z * right->x);
-    product->z = (left->z * right->s + left->s * right->z) - (left->y * right->x - left->x * right->y);
-}
-
-// = Restrict Multiply By Conjugate Quaternion == //
-
-inline void _bgc_fp32_restrict_quaternion_multiply_by_conjugate(BGC_FP32_Quaternion* restrict const product, const BGC_FP32_Quaternion* const left, const BGC_FP32_Quaternion* const right)
-{
-    product->s = (left->s * right->s + left->x * right->x) + (left->y * right->y + left->z * right->z);
-    product->x = (left->x * right->s + left->z * right->y) - (left->s * right->x + left->y * right->z);
-    product->y = (left->y * right->s + left->x * right->z) - (left->s * right->y + left->z * right->x);
-    product->z = (left->z * right->s + left->y * right->x) - (left->s * right->z + left->x * right->y);
-}
-
-inline void _bgc_fp64_restrict_quaternion_multiply_by_conjugate(BGC_FP64_Quaternion* restrict const product, const BGC_FP64_Quaternion* const left, const BGC_FP64_Quaternion* const right)
-{
-    product->s = (left->s * right->s + left->x * right->x) + (left->y * right->y + left->z * right->z);
-    product->x = (left->x * right->s + left->z * right->y) - (left->s * right->x + left->y * right->z);
-    product->y = (left->y * right->s + left->x * right->z) - (left->s * right->y + left->z * right->x);