Добавление новых функций, возвращение функций subtract_scaled

basic-geometry/basic-geometry.vcxproj

@@ -24,7 +24,7 @@
     <ClInclude Include="angle.h" />
     <ClInclude Include="basic-geometry.h" />
     <ClInclude Include="complex.h" />
-    <ClInclude Include="dual-scalar.h" />
+    <ClInclude Include="dual-number.h" />
     <ClInclude Include="dual-quaternion.h" />
     <ClInclude Include="dual-vector3.h" />
     <ClInclude Include="matrix2x2.h" />
@@ -47,7 +47,7 @@
     <ClCompile Include="affine3.c" />
     <ClCompile Include="angle.c" />
     <ClInclude Include="complex.c" />
-    <ClCompile Include="dual-scalar.c" />
+    <ClCompile Include="dual-number.c" />
     <ClCompile Include="dual-quaternion.c" />
     <ClCompile Include="dual-vector3.c" />
     <ClCompile Include="position2.c" />

basic-geometry/basic-geometry.vcxproj.filters

@@ -78,7 +78,7 @@
     <ClInclude Include="turn3.h">
       <Filter>Файлы заголовков</Filter>
     </ClInclude>
-    <ClInclude Include="dual-scalar.h">
+    <ClInclude Include="dual-number.h">
       <Filter>Файлы заголовков</Filter>
     </ClInclude>
     <ClInclude Include="slerp3.h">
@@ -137,7 +137,7 @@
     <ClCompile Include="turn3.c">
       <Filter>Исходные файлы</Filter>
     </ClCompile>
-    <ClCompile Include="dual-scalar.c">
+    <ClCompile Include="dual-number.c">
       <Filter>Исходные файлы</Filter>
     </ClCompile>
     <ClCompile Include="slerp3.c">

basic-geometry/complex.c

@@ -60,6 +60,9 @@ extern inline void bgc_fp64_complex_add_scaled(BGC_FP64_Complex* sum, const BGC_
 extern inline void bgc_fp32_complex_subtract(BGC_FP32_Complex* difference, const BGC_FP32_Complex* minuend, const BGC_FP32_Complex* subtrahend);
 extern inline void bgc_fp64_complex_subtract(BGC_FP64_Complex* difference, const BGC_FP64_Complex* minuend, const BGC_FP64_Complex* subtrahend);
 
+extern inline void bgc_fp32_complex_subtract_scaled(BGC_FP32_Complex* difference, const BGC_FP32_Complex* basic_number, const BGC_FP32_Complex* scalable_number, const float scale);
+extern inline void bgc_fp64_complex_subtract_scaled(BGC_FP64_Complex* difference, const BGC_FP64_Complex* basic_number, const BGC_FP64_Complex* scalable_number, const double scale);
+
 extern inline void bgc_fp32_complex_multiply_by_real(BGC_FP32_Complex* product, const BGC_FP32_Complex* multiplicand, const float multiplier);
 extern inline void bgc_fp64_complex_multiply_by_real(BGC_FP64_Complex* product, const BGC_FP64_Complex* multiplicand, const double multiplier);
 

basic-geometry/complex.h

@@ -337,7 +337,7 @@ inline void bgc_fp64_complex_add(BGC_FP64_Complex* sum, const BGC_FP64_Complex*
     sum->imaginary = number1->imaginary + number2->imaginary;
 }
 
-// ================= Add scaled ================= //
+// ================= Add Scaled ================= //
 
 inline void bgc_fp32_complex_add_scaled(BGC_FP32_Complex* sum, const BGC_FP32_Complex* basic_number, const BGC_FP32_Complex* scalable_number, const float scale)
 {
@@ -365,6 +365,20 @@ inline void bgc_fp64_complex_subtract(BGC_FP64_Complex* difference, const BGC_FP
     difference->imaginary = minuend->imaginary - subtrahend->imaginary;
 }
 
+// ============== Subtract Scaled =============== //
+
+inline void bgc_fp32_complex_subtract_scaled(BGC_FP32_Complex* difference, const BGC_FP32_Complex* basic_number, const BGC_FP32_Complex* scalable_number, const float scale)
+{
+    difference->real = basic_number->real - scalable_number->real * scale;
+    difference->imaginary = basic_number->imaginary - scalable_number->imaginary * scale;
+}
+
+inline void bgc_fp64_complex_subtract_scaled(BGC_FP64_Complex* difference, const BGC_FP64_Complex* basic_number, const BGC_FP64_Complex* scalable_number, const double scale)
+{
+    difference->real = basic_number->real - scalable_number->real * scale;
+    difference->imaginary = basic_number->imaginary - scalable_number->imaginary * scale;
+}
+
 // ========== Multiply By Real Number =========== //
 
 inline void bgc_fp32_complex_multiply_by_real(BGC_FP32_Complex* product, const BGC_FP32_Complex* multiplicand, const float multiplier)

basic-geometry/dual-number.c

@@ -0,0 +1,73 @@
+#include "./dual-number.h"
+
+extern inline void bgc_fp32_dual_number_reset(BGC_FP32_DualNumber* number);
+extern inline void bgc_fp64_dual_number_reset(BGC_FP64_DualNumber* number);
+
+extern inline void bgc_fp32_dual_number_make(BGC_FP32_DualNumber* number, const float real_part, const float dual_part);
+extern inline void bgc_fp64_dual_number_make(BGC_FP64_DualNumber* number, const double real_part, const double dual_part);
+
+extern inline void bgc_fp32_dual_number_copy(BGC_FP32_DualNumber* destination, const BGC_FP32_DualNumber* source);
+extern inline void bgc_fp64_dual_number_copy(BGC_FP64_DualNumber* destination, const BGC_FP64_DualNumber* source);
+
+extern inline void bgc_fp32_dual_number_swap(BGC_FP32_DualNumber* first, BGC_FP32_DualNumber* second);
+extern inline void bgc_fp64_dual_number_swap(BGC_FP64_DualNumber* first, BGC_FP64_DualNumber* second);
+
+extern inline void bgc_fp64_dual_number_convert_to_fp32(BGC_FP32_DualNumber* first, BGC_FP64_DualNumber* second);
+extern inline void bgc_fp32_dual_number_convert_to_fp64(BGC_FP64_DualNumber* first, BGC_FP32_DualNumber* second);
+
+extern inline void bgc_fp32_dual_number_revert(BGC_FP32_DualNumber* number);
+extern inline void bgc_fp64_dual_number_revert(BGC_FP64_DualNumber* number);
+
+extern inline void bgc_fp32_dual_number_get_reverse(BGC_FP32_DualNumber* reverse, const BGC_FP32_DualNumber* number);
+extern inline void bgc_fp64_dual_number_get_reverse(BGC_FP64_DualNumber* reverse, const BGC_FP64_DualNumber* number);
+
+extern inline int bgc_fp32_dual_number_invert(BGC_FP32_DualNumber* number);
+extern inline int bgc_fp64_dual_number_invert(BGC_FP64_DualNumber* number);
+
+extern inline int bgc_fp32_dual_number_get_inverse(BGC_FP32_DualNumber* inverse, const BGC_FP32_DualNumber* number);
+extern inline int bgc_fp64_dual_number_get_inverse(BGC_FP64_DualNumber* inverse, const BGC_FP64_DualNumber* number);
+
+extern inline void bgc_fp32_dual_number_conjugate(BGC_FP32_DualNumber* number);
+extern inline void bgc_fp64_dual_number_conjugate(BGC_FP64_DualNumber* number);
+
+extern inline void bgc_fp32_dual_number_get_conjugate(BGC_FP32_DualNumber* conjugate, const BGC_FP32_DualNumber* number);
+extern inline void bgc_fp64_dual_number_get_conjugate(BGC_FP64_DualNumber* conjugate, const BGC_FP64_DualNumber* number);
+
+extern inline void bgc_fp32_dual_number_add(BGC_FP32_DualNumber* sum, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second);
+extern inline void bgc_fp64_dual_number_add(BGC_FP64_DualNumber* sum, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second);
+
+extern inline void bgc_fp32_dual_number_add_scaled(BGC_FP32_DualNumber* sum, const BGC_FP32_DualNumber* base_number, const BGC_FP32_DualNumber* scalable_number, const float scale);
+extern inline void bgc_fp64_dual_number_add_scaled(BGC_FP64_DualNumber* sum, const BGC_FP64_DualNumber* base_number, const BGC_FP64_DualNumber* scalable_number, const double scale);
+
+extern inline void bgc_fp32_dual_number_subtract(BGC_FP32_DualNumber* difference, const BGC_FP32_DualNumber* minuend, const BGC_FP32_DualNumber* subtrahend);
+extern inline void bgc_fp64_dual_number_subtract(BGC_FP64_DualNumber* difference, const BGC_FP64_DualNumber* minuend, const BGC_FP64_DualNumber* subtrahend);
+
+extern inline void bgc_fp32_dual_number_subtract_scaled(BGC_FP32_DualNumber* difference, const BGC_FP32_DualNumber* base_number, const BGC_FP32_DualNumber* scalable_number, const float scale);
+extern inline void bgc_fp64_dual_number_subtract_scaled(BGC_FP64_DualNumber* difference, const BGC_FP64_DualNumber* base_number, const BGC_FP64_DualNumber* scalable_number, const double scale);
+
+extern inline void bgc_fp32_dual_number_multiply_by_real(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* multiplicand, const float multiplier);
+extern inline void bgc_fp64_dual_number_multiply_by_real(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* multiplicand, const double multiplier);
+
+extern inline void bgc_fp32_dual_number_multiply_by_dual(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* multiplicand, const BGC_FP32_DualNumber* multiplier);
+extern inline void bgc_fp64_dual_number_multiply_by_dual(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* multiplicand, const BGC_FP64_DualNumber* multiplier);
+
+extern inline void bgc_fp32_dual_number_multiply_by_conjugate(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* multiplicand, const BGC_FP32_DualNumber* multiplier_to_conjugate);
+extern inline void bgc_fp64_dual_number_multiply_by_conjugate(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* multiplicand, const BGC_FP64_DualNumber* multiplier_to_conjugate);
+
+extern inline int bgc_fp32_dual_number_divide_by_real(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const float divisor);
+extern inline int bgc_fp64_dual_number_divide_by_real(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const double divisor);
+
+extern inline int bgc_fp32_dual_number_divide_by_dual(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const BGC_FP32_DualNumber* divisor);
+extern inline int bgc_fp64_dual_number_divide_by_dual(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const BGC_FP64_DualNumber* divisor);
+
+extern inline int bgc_fp32_dual_number_divide_by_conjugate(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const BGC_FP32_DualNumber* divisor_to_conjugate);
+extern inline int bgc_fp64_dual_number_divide_by_conjugate(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const BGC_FP64_DualNumber* divisor_to_conjugate);
+
+extern inline void bgc_fp32_dual_number_get_mean2(BGC_FP32_DualNumber* mean, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second);
+extern inline void bgc_fp64_dual_number_get_mean2(BGC_FP64_DualNumber* mean, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second);
+
+extern inline void bgc_fp32_dual_number_get_mean3(BGC_FP32_DualNumber* mean, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second, const BGC_FP32_DualNumber* third);
+extern inline void bgc_fp64_dual_number_get_mean3(BGC_FP64_DualNumber* mean, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second, const BGC_FP64_DualNumber* third);
+
+extern inline void bgc_fp32_dual_number_interpolate(BGC_FP32_DualNumber* interpolation, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second, const float phase);
+extern inline void bgc_fp64_dual_number_interpolate(BGC_FP64_DualNumber* interpolation, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second, const double phase);

basic-geometry/dual-number.h

@@ -8,13 +8,13 @@
 
 // =================== Reset ==================== //
 
-inline void bgc_fp32_dual_scalar_reset(BGC_FP32_DualScalar* number)
+inline void bgc_fp32_dual_number_reset(BGC_FP32_DualNumber* number)
 {
     number->real_part = 0.0f;
     number->dual_part = 0.0f;
 }
 
-inline void bgc_fp64_dual_scalar_reset(BGC_FP64_DualScalar* number)
+inline void bgc_fp64_dual_number_reset(BGC_FP64_DualNumber* number)
 {
     number->real_part = 0.0;
     number->dual_part = 0.0;
@@ -22,13 +22,13 @@ inline void bgc_fp64_dual_scalar_reset(BGC_FP64_DualScalar* number)
 
 // ==================== Make ==================== //
 
-inline void bgc_fp32_dual_scalar_make(BGC_FP32_DualScalar* number, const float real_part, const float dual_part)
+inline void bgc_fp32_dual_number_make(BGC_FP32_DualNumber* number, const float real_part, const float dual_part)
 {
     number->real_part = real_part;
     number->dual_part = dual_part;
 }
 
-inline void bgc_fp64_dual_scalar_make(BGC_FP64_DualScalar* number, const double real_part, const double dual_part)
+inline void bgc_fp64_dual_number_make(BGC_FP64_DualNumber* number, const double real_part, const double dual_part)
 {
     number->real_part = real_part;
     number->dual_part = dual_part;
@@ -36,13 +36,13 @@ inline void bgc_fp64_dual_scalar_make(BGC_FP64_DualScalar* number, const double
 
 // ==================== Copy ==================== //
 
-inline void bgc_fp32_dual_scalar_copy(BGC_FP32_DualScalar* destination, const BGC_FP32_DualScalar* source)
+inline void bgc_fp32_dual_number_copy(BGC_FP32_DualNumber* destination, const BGC_FP32_DualNumber* source)
 {
     destination->real_part = source->real_part;
     destination->dual_part = source->dual_part;
 }
 
-inline void bgc_fp64_dual_scalar_copy(BGC_FP64_DualScalar* destination, const BGC_FP64_DualScalar* source)
+inline void bgc_fp64_dual_number_copy(BGC_FP64_DualNumber* destination, const BGC_FP64_DualNumber* source)
 {
     destination->real_part = source->real_part;
     destination->dual_part = source->dual_part;
@@ -50,27 +50,39 @@ inline void bgc_fp64_dual_scalar_copy(BGC_FP64_DualScalar* destination, const BG
 
 // ==================== Swap ==================== //
 
-inline void bgc_fp32_dual_scalar_swap(BGC_FP32_DualScalar* first, BGC_FP32_DualScalar* second)
+inline void bgc_fp32_dual_number_swap(BGC_FP32_DualNumber* first, BGC_FP32_DualNumber* second)
 {
     first->real_part = second->real_part;
     first->dual_part = second->dual_part;
 }
 
-inline void bgc_fp64_dual_scalar_swap(BGC_FP64_DualScalar* first, BGC_FP64_DualScalar* second)
+inline void bgc_fp64_dual_number_swap(BGC_FP64_DualNumber* first, BGC_FP64_DualNumber* second)
 {
     first->real_part = second->real_part;
     first->dual_part = second->dual_part;
 }
 
+// ================== Modulus =================== //
+
+inline double bgc_fp32_dual_number_get_modulus(const BGC_FP32_DualNumber* number)
+{
+    return fabsf(number->real_part);
+}
+
+inline double bgc_fp64_dual_number_get_modulus(const BGC_FP64_DualNumber* number)
+{
+    return fabs(number->real_part);
+}
+
 // ================== Convert =================== //
 
-inline void bgc_fp64_dual_scalar_convert_to_fp32(BGC_FP32_DualScalar* first, BGC_FP64_DualScalar* second)
+inline void bgc_fp64_dual_number_convert_to_fp32(BGC_FP32_DualNumber* first, BGC_FP64_DualNumber* second)
 {
     first->real_part = (float) second->real_part;
     first->dual_part = (float) second->dual_part;
 }
 
-inline void bgc_fp32_dual_scalar_convert_to_fp64(BGC_FP64_DualScalar* first, BGC_FP32_DualScalar* second)
+inline void bgc_fp32_dual_number_convert_to_fp64(BGC_FP64_DualNumber* first, BGC_FP32_DualNumber* second)
 {
     first->real_part = second->real_part;
     first->dual_part = second->dual_part;
@@ -78,13 +90,13 @@ inline void bgc_fp32_dual_scalar_convert_to_fp64(BGC_FP64_DualScalar* first, BGC
 
 // =================== Revert =================== //
 
-inline void bgc_fp32_dual_scalar_revert(BGC_FP32_DualScalar* number)
+inline void bgc_fp32_dual_number_revert(BGC_FP32_DualNumber* number)
 {
     number->real_part = -number->real_part;
     number->dual_part = -number->dual_part;
 }
 
-inline void bgc_fp64_dual_scalar_revert(BGC_FP64_DualScalar* number)
+inline void bgc_fp64_dual_number_revert(BGC_FP64_DualNumber* number)
 {
     number->real_part = -number->real_part;
     number->dual_part = -number->dual_part;
@@ -92,39 +104,103 @@ inline void bgc_fp64_dual_scalar_revert(BGC_FP64_DualScalar* number)
 
 // ================ Get Reverse ================= //
 
-inline void bgc_fp32_number_get_reverse(BGC_FP32_DualScalar* reverse, const BGC_FP32_DualScalar* number)
+inline void bgc_fp32_dual_number_get_reverse(BGC_FP32_DualNumber* reverse, const BGC_FP32_DualNumber* number)
 {
     reverse->real_part = -number->real_part;
     reverse->dual_part = -number->dual_part;
 }
 
-inline void bgc_fp64_number_get_reverse(BGC_FP64_DualScalar* reverse, const BGC_FP64_DualScalar* number)
+inline void bgc_fp64_dual_number_get_reverse(BGC_FP64_DualNumber* reverse, const BGC_FP64_DualNumber* number)
 {
     reverse->real_part = -number->real_part;
     reverse->dual_part = -number->dual_part;
 }
 
+// =================== Invert =================== //
+
+inline int bgc_fp32_dual_number_invert(BGC_FP32_DualNumber* number)
+{
+    if (bgc_fp32_is_zero(number->real_part) || isnan(number->real_part)) {
+        return BGC_FAILURE;
+    }
+
+    const float multiplicator = 1.0f / (number->real_part * number->real_part);
+
+    number->real_part =  number->real_part * multiplicator;
+    number->dual_part = -number->dual_part * multiplicator;
+
+    return BGC_SUCCESS;
+}
+
+inline int bgc_fp64_dual_number_invert(BGC_FP64_DualNumber* number)
+{
+    if (bgc_fp64_is_zero(number->real_part) || isnan(number->real_part)) {
+        return BGC_FAILURE;
+    }
+
+    const double multiplicator = 1.0 / (number->real_part * number->real_part);
+
+    number->real_part =  number->real_part * multiplicator;
+    number->dual_part = -number->dual_part * multiplicator;
+
+    return BGC_SUCCESS;
+}
+
+// ================ Get Inverse ================= //
+
+inline int bgc_fp32_dual_number_get_inverse(BGC_FP32_DualNumber* inverse, const BGC_FP32_DualNumber* number)
+{
+    if (bgc_fp32_is_zero(number->real_part) || isnan(number->real_part)) {
+        inverse->real_part = 0.0f;
+        inverse->dual_part = 0.0f;
+        return BGC_FAILURE;
+    }
+
+    const float multiplicator = 1.0f / (number->real_part * number->real_part);
+
+    inverse->real_part =  number->real_part * multiplicator;
+    inverse->dual_part = -number->dual_part * multiplicator;
+
+    return BGC_SUCCESS;
+}
+
+inline int bgc_fp64_dual_number_get_inverse(BGC_FP64_DualNumber* inverse, const BGC_FP64_DualNumber* number)
+{
+    if (bgc_fp64_is_zero(number->real_part) || isnan(number->real_part)) {
+        inverse->real_part = 0.0;
+        inverse->dual_part = 0.0;
+        return BGC_FAILURE;
+    }
+
+    const double multiplicator = 1.0 / (number->real_part * number->real_part);
+
+    inverse->real_part =  number->real_part * multiplicator;
+    inverse->dual_part = -number->dual_part * multiplicator;
+
+    return BGC_SUCCESS;
+}
+
 // ================= Conjugate ================== //
 
-inline void bgc_fp32_dual_scalar_conjugate(BGC_FP32_DualScalar* number)
+inline void bgc_fp32_dual_number_conjugate(BGC_FP32_DualNumber* number)
 {
     number->dual_part = -number->dual_part;
 }
 
-inline void bgc_fp64_dual_scalar_conjugate(BGC_FP64_DualScalar* number)
+inline void bgc_fp64_dual_number_conjugate(BGC_FP64_DualNumber* number)
 {
     number->dual_part = -number->dual_part;
 }
 
 // =============== Get Conjugate ================ //
 
-inline void bgc_fp32_dual_scalar_get_conjugate(BGC_FP32_DualScalar* conjugate, const BGC_FP32_DualScalar* number)
+inline void bgc_fp32_dual_number_get_conjugate(BGC_FP32_DualNumber* conjugate, const BGC_FP32_DualNumber* number)
 {
     conjugate->real_part =  number->real_part;
     conjugate->dual_part = -number->dual_part;
 }
 
-inline void bgc_fp64_dual_scalar_get_conjugate(BGC_FP64_DualScalar* conjugate, const BGC_FP64_DualScalar* number)
+inline void bgc_fp64_dual_number_get_conjugate(BGC_FP64_DualNumber* conjugate, const BGC_FP64_DualNumber* number)
 {
     conjugate->real_part =  number->real_part;
     conjugate->dual_part = -number->dual_part;
@@ -132,13 +208,13 @@ inline void bgc_fp64_dual_scalar_get_conjugate(BGC_FP64_DualScalar* conjugate, c
 
 // ==================== Add ===================== //
 
-inline void bgc_fp32_dual_scalar_add(BGC_FP32_DualScalar* sum, const BGC_FP32_DualScalar* first, const BGC_FP32_DualScalar* second)
+inline void bgc_fp32_dual_number_add(BGC_FP32_DualNumber* sum, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second)
 {
     sum->real_part = first->real_part + second->real_part;
     sum->dual_part = first->dual_part + second->dual_part;
 }
 
-inline void bgc_fp64_dual_scalar_add(BGC_FP64_DualScalar* sum, const BGC_FP64_DualScalar* first, const BGC_FP64_DualScalar* second)
+inline void bgc_fp64_dual_number_add(BGC_FP64_DualNumber* sum, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second)
 {
     sum->real_part = first->real_part + second->real_part;
     sum->dual_part = first->dual_part + second->dual_part;
@@ -146,13 +222,13 @@ inline void bgc_fp64_dual_scalar_add(BGC_FP64_DualScalar* sum, const BGC_FP64_Du
 
 // ================= Add Scaled ================= //
 
-inline void bgc_fp32_dual_scalar_add_scaled(BGC_FP32_DualScalar* sum, const BGC_FP32_DualScalar* base_number, const BGC_FP32_DualScalar* scalable_number, const float scale)
+inline void bgc_fp32_dual_number_add_scaled(BGC_FP32_DualNumber* sum, const BGC_FP32_DualNumber* base_number, const BGC_FP32_DualNumber* scalable_number, const float scale)
 {
     sum->real_part = base_number->real_part + scalable_number->real_part * scale;
     sum->dual_part = base_number->dual_part + scalable_number->dual_part * scale;
 }
 
-inline void bgc_fp64_dual_scalar_add_scaled(BGC_FP64_DualScalar* sum, const BGC_FP64_DualScalar* base_number, const BGC_FP64_DualScalar* scalable_number, const double scale)
+inline void bgc_fp64_dual_number_add_scaled(BGC_FP64_DualNumber* sum, const BGC_FP64_DualNumber* base_number, const BGC_FP64_DualNumber* scalable_number, const double scale)
 {
     sum->real_part = base_number->real_part + scalable_number->real_part * scale;
     sum->dual_part = base_number->dual_part + scalable_number->dual_part * scale;
@@ -160,33 +236,47 @@ inline void bgc_fp64_dual_scalar_add_scaled(BGC_FP64_DualScalar* sum, const BGC_
 
 // ================== Subtract ================== //
 
-inline void bgc_fp32_dual_scalar_subtract(BGC_FP32_DualScalar* difference, const BGC_FP32_DualScalar* minuend, const BGC_FP32_DualScalar* subtrahend)
+inline void bgc_fp32_dual_number_subtract(BGC_FP32_DualNumber* difference, const BGC_FP32_DualNumber* minuend, const BGC_FP32_DualNumber* subtrahend)
 {
     difference->real_part = minuend->real_part - subtrahend->real_part;
     difference->dual_part = minuend->dual_part - subtrahend->dual_part;
 }
 
-inline void bgc_fp64_dual_scalar_subtract(BGC_FP64_DualScalar* difference, const BGC_FP64_DualScalar* minuend, const BGC_FP64_DualScalar* subtrahend)
+inline void bgc_fp64_dual_number_subtract(BGC_FP64_DualNumber* difference, const BGC_FP64_DualNumber* minuend, const BGC_FP64_DualNumber* subtrahend)
 {
     difference->real_part = minuend->real_part - subtrahend->real_part;
     difference->dual_part = minuend->dual_part - subtrahend->dual_part;
 }
 
+// ============== Subtract Scaled =============== //
+
+inline void bgc_fp32_dual_number_subtract_scaled(BGC_FP32_DualNumber* difference, const BGC_FP32_DualNumber* base_number, const BGC_FP32_DualNumber* scalable_number, const float scale)
+{
+    difference->real_part = base_number->real_part - scalable_number->real_part * scale;
+    difference->dual_part = base_number->dual_part - scalable_number->dual_part * scale;
+}
+
+inline void bgc_fp64_dual_number_subtract_scaled(BGC_FP64_DualNumber* difference, const BGC_FP64_DualNumber* base_number, const BGC_FP64_DualNumber* scalable_number, const double scale)
+{
+    difference->real_part = base_number->real_part - scalable_number->real_part * scale;
+    difference->dual_part = base_number->dual_part - scalable_number->dual_part * scale;
+}
+
 // ================== Multiply ================== //
 
-inline void bgc_fp32_dual_scalar_multiply_by_real(BGC_FP32_DualScalar* product, const BGC_FP32_DualScalar* multiplicand, const float multiplier)
+inline void bgc_fp32_dual_number_multiply_by_real(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* multiplicand, const float multiplier)
 {
     product->real_part = multiplicand->real_part * multiplier;
     product->dual_part = multiplicand->dual_part * multiplier;
 }
 
-inline void bgc_fp64_dual_scalar_multiply_by_real(BGC_FP64_DualScalar* product, const BGC_FP64_DualScalar* multiplicand, const double multiplier)
+inline void bgc_fp64_dual_number_multiply_by_real(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* multiplicand, const double multiplier)
 {
     product->real_part = multiplicand->real_part * multiplier;
     product->dual_part = multiplicand->dual_part * multiplier;
 }
 
-inline void bgc_fp32_dual_scalar_multiply_by_dual(BGC_FP32_DualScalar* product, const BGC_FP32_DualScalar* multiplicand, const BGC_FP32_DualScalar* multiplier)
+inline void bgc_fp32_dual_number_multiply_by_dual(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* multiplicand, const BGC_FP32_DualNumber* multiplier)
 {
     const float real_part = multiplicand->real_part * multiplier->real_part;
     const float dual_part = multiplicand->dual_part * multiplier->real_part + multiplicand->real_part * multiplier->dual_part;
@@ -195,7 +285,7 @@ inline void bgc_fp32_dual_scalar_multiply_by_dual(BGC_FP32_DualScalar* product,
     product->dual_part = dual_part;
 }
 
-inline void bgc_fp64_dual_scalar_multiply_by_dual(BGC_FP64_DualScalar* product, const BGC_FP64_DualScalar* multiplicand, const BGC_FP64_DualScalar* multiplier)
+inline void bgc_fp64_dual_number_multiply_by_dual(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* multiplicand, const BGC_FP64_DualNumber* multiplier)
 {
     const double real_part = multiplicand->real_part * multiplier->real_part;
     const double dual_part = multiplicand->dual_part * multiplier->real_part + multiplicand->real_part * multiplier->dual_part;
@@ -204,7 +294,7 @@ inline void bgc_fp64_dual_scalar_multiply_by_dual(BGC_FP64_DualScalar* product,
     product->dual_part = dual_part;
 }
 
-inline void bgc_fp32_dual_scalar_multiply_by_conjugate(BGC_FP32_DualScalar* product, const BGC_FP32_DualScalar* multiplicand, const BGC_FP32_DualScalar* multiplier_to_conjugate)
+inline void bgc_fp32_dual_number_multiply_by_conjugate(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* multiplicand, const BGC_FP32_DualNumber* multiplier_to_conjugate)
 {
     const float real_part = multiplicand->real_part * multiplier_to_conjugate->real_part;
     const float dual_part = multiplicand->dual_part * multiplier_to_conjugate->real_part - multiplicand->real_part * multiplier_to_conjugate->dual_part;
@@ -213,7 +303,7 @@ inline void bgc_fp32_dual_scalar_multiply_by_conjugate(BGC_FP32_DualScalar* prod
     product->dual_part = dual_part;
 }
 
-inline void bgc_fp64_dual_scalar_multiply_by_conjugate(BGC_FP64_DualScalar* product, const BGC_FP64_DualScalar* multiplicand, const BGC_FP64_DualScalar* multiplier_to_conjugate)
+inline void bgc_fp64_dual_number_multiply_by_conjugate(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* multiplicand, const BGC_FP64_DualNumber* multiplier_to_conjugate)
 {
     const double real_part = multiplicand->real_part * multiplier_to_conjugate->real_part;
     const double dual_part = multiplicand->dual_part * multiplier_to_conjugate->real_part - multiplicand->real_part * multiplier_to_conjugate->dual_part;
@@ -223,27 +313,27 @@ inline void bgc_fp64_dual_scalar_multiply_by_conjugate(BGC_FP64_DualScalar* prod
 }
 // =================== Divide =================== //
 
-inline int bgc_fp32_dual_scalar_divide_by_real(BGC_FP32_DualScalar* quotient, const BGC_FP32_DualScalar* dividend, const float divisor)
+inline int bgc_fp32_dual_number_divide_by_real(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const float divisor)
 {
     if (bgc_fp32_is_zero(divisor) || isnan(divisor)) {
         return BGC_FAILURE;
     }
 
-    bgc_fp32_dual_scalar_multiply_by_real(quotient, dividend, 1.0f / divisor);
+    bgc_fp32_dual_number_multiply_by_real(quotient, dividend, 1.0f / divisor);
     return BGC_SUCCESS;
 }
 
-inline int bgc_fp64_dual_scalar_divide_by_real(BGC_FP64_DualScalar* quotient, const BGC_FP64_DualScalar* dividend, const double divisor)
+inline int bgc_fp64_dual_number_divide_by_real(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const double divisor)
 {
     if (bgc_fp64_is_zero(divisor) || isnan(divisor)) {
         return BGC_FAILURE;
     }
 
-    bgc_fp64_dual_scalar_multiply_by_real(quotient, dividend, 1.0 / divisor);
+    bgc_fp64_dual_number_multiply_by_real(quotient, dividend, 1.0 / divisor);
     return BGC_SUCCESS;
 }
 
-inline int bgc_fp32_dual_scalar_divide_by_dual(BGC_FP32_DualScalar* quotient, const BGC_FP32_DualScalar* dividend, const BGC_FP32_DualScalar* divisor)
+inline int bgc_fp32_dual_number_divide_by_dual(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const BGC_FP32_DualNumber* divisor)
 {
     if (bgc_fp32_is_zero(divisor->real_part)) {
         return BGC_FAILURE;
@@ -260,7 +350,7 @@ inline int bgc_fp32_dual_scalar_divide_by_dual(BGC_FP32_DualScalar* quotient, co
     return BGC_SUCCESS;
 }
 
-inline int bgc_fp64_dual_scalar_divide_by_dual(BGC_FP64_DualScalar* quotient, const BGC_FP64_DualScalar* dividend, const BGC_FP64_DualScalar* divisor)
+inline int bgc_fp64_dual_number_divide_by_dual(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const BGC_FP64_DualNumber* divisor)
 {
     if (bgc_fp64_is_zero(divisor->real_part)) {
         return BGC_FAILURE;
@@ -277,7 +367,7 @@ inline int bgc_fp64_dual_scalar_divide_by_dual(BGC_FP64_DualScalar* quotient, co
     return BGC_SUCCESS;
 }
 
-inline int bgc_fp32_dual_scalar_divide_by_conjugate(BGC_FP32_DualScalar* quotient, const BGC_FP32_DualScalar* dividend, const BGC_FP32_DualScalar* divisor_to_conjugate)
+inline int bgc_fp32_dual_number_divide_by_conjugate(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const BGC_FP32_DualNumber* divisor_to_conjugate)
 {
     if (bgc_fp32_is_zero(divisor_to_conjugate->real_part)) {
         return BGC_FAILURE;
@@ -294,7 +384,7 @@ inline int bgc_fp32_dual_scalar_divide_by_conjugate(BGC_FP32_DualScalar* quotien
     return BGC_SUCCESS;
 }
 
-inline int bgc_fp64_dual_scalar_divide_by_conjugate(BGC_FP64_DualScalar* quotient, const BGC_FP64_DualScalar* dividend, const BGC_FP64_DualScalar* divisor_to_conjugate)
+inline int bgc_fp64_dual_number_divide_by_conjugate(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const BGC_FP64_DualNumber* divisor_to_conjugate)
 {
     if (bgc_fp64_is_zero(divisor_to_conjugate->real_part)) {
         return BGC_FAILURE;
@@ -313,13 +403,13 @@ inline int bgc_fp64_dual_scalar_divide_by_conjugate(BGC_FP64_DualScalar* quotien
 
 // ================ Mean of Two ================= //
 
-inline void bgc_fp32_dual_scalar_get_mean2(BGC_FP32_DualScalar* mean, const BGC_FP32_DualScalar* first, const BGC_FP32_DualScalar* second)
+inline void bgc_fp32_dual_number_get_mean2(BGC_FP32_DualNumber* mean, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second)
 {
     mean->real_part = (first->real_part + second->real_part) * 0.5f;
     mean->dual_part = (first->dual_part + second->dual_part) * 0.5f;
 }
 
-inline void bgc_fp64_dual_scalar_get_mean2(BGC_FP64_DualScalar* mean, const BGC_FP64_DualScalar* first, const BGC_FP64_DualScalar* second)
+inline void bgc_fp64_dual_number_get_mean2(BGC_FP64_DualNumber* mean, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second)
 {
     mean->real_part = (first->real_part + second->real_part) * 0.5;
     mean->dual_part = (first->dual_part + second->dual_part) * 0.5;
@@ -327,13 +417,13 @@ inline void bgc_fp64_dual_scalar_get_mean2(BGC_FP64_DualScalar* mean, const BGC_
 
 // =============== Mean of Three ================ //
 
-inline void bgc_fp32_dual_scalar_get_mean3(BGC_FP32_DualScalar* mean, const BGC_FP32_DualScalar* first, const BGC_FP32_DualScalar* second, const BGC_FP32_DualScalar* third)
+inline void bgc_fp32_dual_number_get_mean3(BGC_FP32_DualNumber* mean, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second, const BGC_FP32_DualNumber* third)
 {
     mean->real_part = (first->real_part + second->real_part + third->real_part) * BGC_FP32_ONE_THIRD;
     mean->dual_part = (first->dual_part + second->dual_part + third->dual_part) * BGC_FP32_ONE_THIRD;
 }
 
-inline void bgc_fp64_dual_scalar_get_mean3(BGC_FP64_DualScalar* mean, const BGC_FP64_DualScalar* first, const BGC_FP64_DualScalar* second, const BGC_FP64_DualScalar* third)
+inline void bgc_fp64_dual_number_get_mean3(BGC_FP64_DualNumber* mean, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second, const BGC_FP64_DualNumber* third)
 {
     mean->real_part = (first->real_part + second->real_part + third->real_part) * BGC_FP64_ONE_THIRD;
     mean->dual_part = (first->dual_part + second->dual_part + third->dual_part) * BGC_FP64_ONE_THIRD;
@@ -341,7 +431,7 @@ inline void bgc_fp64_dual_scalar_get_mean3(BGC_FP64_DualScalar* mean, const BGC_
 
 // ============ Linear Interpolation ============ //
 
-inline void bgc_fp32_dual_scalar_interpolate(BGC_FP32_DualScalar* interpolation, const BGC_FP32_DualScalar* first, const BGC_FP32_DualScalar* second, const float phase)
+inline void bgc_fp32_dual_number_interpolate(BGC_FP32_DualNumber* interpolation, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second, const float phase)
 {
     const float counter_phase = 1.0f - phase;
 
@@ -349,7 +439,7 @@ inline void bgc_fp32_dual_scalar_interpolate(BGC_FP32_DualScalar* interpolation,
     interpolation->dual_part = first->dual_part * counter_phase + second->dual_part * phase;
 }
 
-inline void bgc_fp64_dual_scalar_interpolate(BGC_FP64_DualScalar* interpolation, const BGC_FP64_DualScalar* first, const BGC_FP64_DualScalar* second, const double phase)
+inline void bgc_fp64_dual_number_interpolate(BGC_FP64_DualNumber* interpolation, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second, const double phase)
 {
     const double counter_phase = 1.0 - phase;
 

basic-geometry/dual-quaternion.c

@@ -12,6 +12,12 @@ extern inline void bgc_fp64_dual_quaternion_swap(BGC_FP64_DualQuaternion* first,
 extern inline void bgc_fp32_dual_quaternion_convert_to_fp64(BGC_FP64_DualQuaternion* destination, const BGC_FP32_DualQuaternion* source);
 extern inline void bgc_fp64_dual_quaternion_convert_to_fp32(BGC_FP32_DualQuaternion* destination, const BGC_FP64_DualQuaternion* source);
 
+extern inline void bgc_fp32_dual_quaternion_revert(BGC_FP32_DualQuaternion* quaternion);
+extern inline void bgc_fp64_dual_quaternion_revert(BGC_FP64_DualQuaternion* quaternion);
+
+extern inline void bgc_fp32_dual_quaternion_get_reverse(BGC_FP32_DualQuaternion* reverse, const BGC_FP32_DualQuaternion* quaternion);
+extern inline void bgc_fp64_dual_quaternion_get_reverse(BGC_FP64_DualQuaternion* reverse, const BGC_FP64_DualQuaternion* quaternion);
+
 extern inline void bgc_fp32_dual_quaternion_add(BGC_FP32_DualQuaternion* sum, const BGC_FP32_DualQuaternion* first, const BGC_FP32_DualQuaternion* second);
 extern inline void bgc_fp64_dual_quaternion_add(BGC_FP64_DualQuaternion* sum, const BGC_FP64_DualQuaternion* first, const BGC_FP64_DualQuaternion* second);
 
@@ -21,11 +27,26 @@ extern inline void bgc_fp64_dual_quaternion_add_scaled(BGC_FP64_DualQuaternion*
 extern inline void bgc_fp32_dual_quaternion_subtract(BGC_FP32_DualQuaternion* difference, const BGC_FP32_DualQuaternion* minuend, const BGC_FP32_DualQuaternion* subtrahend);
 extern inline void bgc_fp64_dual_quaternion_subtract(BGC_FP64_DualQuaternion* difference, const BGC_FP64_DualQuaternion* minuend, const BGC_FP64_DualQuaternion* subtrahend);
 
-extern inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multipier);
+extern inline void bgc_fp32_dual_quaternion_subtract_scaled(BGC_FP32_DualQuaternion* difference, const BGC_FP32_DualQuaternion* base_quaternion, const BGC_FP32_DualQuaternion* scalable_quaternion, const float scale);
-extern inline void bgc_fp64_dual_quaternion_multiply_by_real(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const double multipier);
+extern inline void bgc_fp64_dual_quaternion_subtract_scaled(BGC_FP64_DualQuaternion* difference, const BGC_FP64_DualQuaternion* base_quaternion, const BGC_FP64_DualQuaternion* scalable_quaternion, const double scale);
 
-extern inline void bgc_fp32_dual_quaternion_divide_by_real(BGC_FP32_DualQuaternion* quotient, const BGC_FP32_DualQuaternion* divident, const float divisor);
+extern inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier);
-extern inline void bgc_fp64_dual_quaternion_divide_by_real(BGC_FP64_DualQuaternion* quotient, const BGC_FP64_DualQuaternion* divident, const double divisor);
+extern inline void bgc_fp64_dual_quaternion_multiply_by_real(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const double multiplier);
+
+extern inline void bgc_fp32_dual_quaternion_multiply_by_dual_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const BGC_FP32_DualNumber* multiplier);
+extern inline void bgc_fp64_dual_quaternion_multiply_by_dual_number(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const BGC_FP64_DualNumber* multiplier);
+
+extern inline void bgc_fp32_dual_quaternion_multiply_by_conjugate_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const BGC_FP32_DualNumber* multiplier_to_conjugate);
+extern inline void bgc_fp64_dual_quaternion_multiply_by_conjugate_number(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const BGC_FP64_DualNumber* multiplier_to_conjugate);
+
+extern inline int bgc_fp32_dual_quaternion_divide_by_real(BGC_FP32_DualQuaternion* quotient, const BGC_FP32_DualQuaternion* divident, const float divisor);
+extern inline int bgc_fp64_dual_quaternion_divide_by_real(BGC_FP64_DualQuaternion* quotient, const BGC_FP64_DualQuaternion* divident, const double divisor);
+
+extern inline int bgc_fp32_dual_quaternion_divide_by_dual_number(BGC_FP32_DualQuaternion* quotient, const BGC_FP32_DualQuaternion* dividend, const BGC_FP32_DualNumber* divisor);
+extern inline int bgc_fp64_dual_quaternion_divide_by_dual_number(BGC_FP64_DualQuaternion* quotient, const BGC_FP64_DualQuaternion* dividend, const BGC_FP64_DualNumber* divisor);
+
+extern inline int bgc_fp32_dual_quaternion_divide_by_conjugate_number(BGC_FP32_DualQuaternion* quotient, const BGC_FP32_DualQuaternion* dividend, const BGC_FP32_DualNumber* divisor_to_conjugate);
+extern inline int bgc_fp64_dual_quaternion_divide_by_conjugate_number(BGC_FP64_DualQuaternion* quotient, const BGC_FP64_DualQuaternion* dividend, const BGC_FP64_DualNumber* divisor_to_conjugate);
 
 extern inline void bgc_fp32_dual_quaternion_get_mean2(BGC_FP32_DualQuaternion* mean, const BGC_FP32_DualQuaternion* quaternion1, const BGC_FP32_DualQuaternion* quaternion2);
 extern inline void bgc_fp64_dual_quaternion_get_mean2(BGC_FP64_DualQuaternion* mean, const BGC_FP64_DualQuaternion* quaternion1, const BGC_FP64_DualQuaternion* quaternion2);
@@ -35,9 +56,3 @@ extern inline void bgc_fp64_dual_quaternion_get_mean3(BGC_FP64_DualQuaternion* m
 
 extern inline void bgc_fp32_dual_quaternion_interpolate(BGC_FP32_DualQuaternion* interpolation, const BGC_FP32_DualQuaternion* first, const BGC_FP32_DualQuaternion* second, const float phase);
 extern inline void bgc_fp64_dual_quaternion_interpolate(BGC_FP64_DualQuaternion* interpolation, const BGC_FP64_DualQuaternion* first, const BGC_FP64_DualQuaternion* second, const double phase);
-
-extern inline void bgc_fp32_dual_quaternion_revert(BGC_FP32_DualQuaternion* quaternion);
-extern inline void bgc_fp64_dual_quaternion_revert(BGC_FP64_DualQuaternion* quaternion);
-
-extern inline void bgc_fp32_dual_quaternion_get_reverse(BGC_FP32_DualQuaternion* reverse, const BGC_FP32_DualQuaternion* quaternion);
-extern inline void bgc_fp64_dual_quaternion_get_reverse(BGC_FP64_DualQuaternion* reverse, const BGC_FP64_DualQuaternion* quaternion);

basic-geometry/dual-quaternion.h

@@ -60,6 +60,34 @@ inline void bgc_fp64_dual_quaternion_convert_to_fp32(BGC_FP32_DualQuaternion* de
     bgc_fp64_quaternion_convert_to_fp32(&destination->dual_part, &source->dual_part);
 }
 
+// =================== Revert =================== //
+
+inline void bgc_fp32_dual_quaternion_revert(BGC_FP32_DualQuaternion* quaternion)
+{
+    bgc_fp32_quaternion_revert(&quaternion->real_part);
+    bgc_fp32_quaternion_revert(&quaternion->dual_part);
+}
+
+inline void bgc_fp64_dual_quaternion_revert(BGC_FP64_DualQuaternion* quaternion)
+{
+    bgc_fp64_quaternion_revert(&quaternion->real_part);
+    bgc_fp64_quaternion_revert(&quaternion->dual_part);
+}
+
+// ================ Get Reverse ================= //
+
+inline void bgc_fp32_dual_quaternion_get_reverse(BGC_FP32_DualQuaternion* reverse, const BGC_FP32_DualQuaternion* quaternion)
+{
+    bgc_fp32_quaternion_get_reverse(&reverse->real_part, &quaternion->real_part);
+    bgc_fp32_quaternion_get_reverse(&reverse->dual_part, &quaternion->dual_part);
+}
+
+inline void bgc_fp64_dual_quaternion_get_reverse(BGC_FP64_DualQuaternion* reverse, const BGC_FP64_DualQuaternion* quaternion)
+{
+    bgc_fp64_quaternion_get_reverse(&reverse->real_part, &quaternion->real_part);
+    bgc_fp64_quaternion_get_reverse(&reverse->dual_part, &quaternion->dual_part);
+}
+
 // ==================== Add ===================== //
 
 inline void bgc_fp32_dual_quaternion_add(BGC_FP32_DualQuaternion* sum, const BGC_FP32_DualQuaternion* first, const BGC_FP32_DualQuaternion* second)
@@ -102,30 +130,170 @@ inline void bgc_fp64_dual_quaternion_subtract(BGC_FP64_DualQuaternion* differenc
     bgc_fp64_quaternion_subtract(&difference->dual_part, &minuend->dual_part, &subtrahend->dual_part);
 }
 
-// ================== Multiply ================== //
+// ============== Subtract Scaled =============== //
 
-inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multipier)
+inline void bgc_fp32_dual_quaternion_subtract_scaled(BGC_FP32_DualQuaternion* difference, const BGC_FP32_DualQuaternion* base_quaternion, const BGC_FP32_DualQuaternion* scalable_quaternion, const float scale)
 {
-    bgc_fp32_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multipier);
+    bgc_fp32_quaternion_subtract_scaled(&difference->real_part, &base_quaternion->real_part, &scalable_quaternion->real_part, scale);
-    bgc_fp32_quaternion_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multipier);
+    bgc_fp32_quaternion_subtract_scaled(&difference->dual_part, &base_quaternion->dual_part, &scalable_quaternion->dual_part, scale);
 }
 
-inline void bgc_fp64_dual_quaternion_multiply_by_real(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const double multipier)
+inline void bgc_fp64_dual_quaternion_subtract_scaled(BGC_FP64_DualQuaternion* difference, const BGC_FP64_DualQuaternion* base_quaternion, const BGC_FP64_DualQuaternion* scalable_quaternion, const double scale)
 {
-    bgc_fp64_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multipier);
+    bgc_fp64_quaternion_subtract_scaled(&difference->real_part, &base_quaternion->real_part, &scalable_quaternion->real_part, scale);
-    bgc_fp64_quaternion_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multipier);
+    bgc_fp64_quaternion_subtract_scaled(&difference->dual_part, &base_quaternion->dual_part, &scalable_quaternion->dual_part, scale);
+}
+
+// ================== Multiply ================== //
+
+inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier)
+{
+    bgc_fp32_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier);
+    bgc_fp32_quaternion_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multiplier);
+}
+
+inline void bgc_fp64_dual_quaternion_multiply_by_real(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const double multiplier)
+{
+    bgc_fp64_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier);
+    bgc_fp64_quaternion_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multiplier);
+}
+
+// ========== Multiply by Dual Number =========== //
+
+inline void bgc_fp32_dual_quaternion_multiply_by_dual_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const BGC_FP32_DualNumber* multiplier)
+{
+    BGC_FP32_Quaternion dual_part;
+
+    bgc_fp32_quaternion_multiply_by_real(&dual_part, &multiplicand->dual_part, multiplier->real_part);
+    bgc_fp32_quaternion_add_scaled(&dual_part, &dual_part, &multiplicand->real_part, multiplier->dual_part);
+
+    bgc_fp32_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier->real_part);
+    bgc_fp32_quaternion_copy(&product->dual_part, &dual_part);
+}
+
+inline void bgc_fp64_dual_quaternion_multiply_by_dual_number(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const BGC_FP64_DualNumber* multiplier)
+{
+    BGC_FP64_Quaternion dual_part;
+
+    bgc_fp64_quaternion_multiply_by_real(&dual_part, &multiplicand->dual_part, multiplier->real_part);
+    bgc_fp64_quaternion_add_scaled(&dual_part, &dual_part, &multiplicand->real_part, multiplier->dual_part);
+
+    bgc_fp64_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier->real_part);
+    bgc_fp64_quaternion_copy(&product->dual_part, &dual_part);
+}
+
+// ===== Multiply by Conjugate Dual Number ====== //
+
+inline void bgc_fp32_dual_quaternion_multiply_by_conjugate_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const BGC_FP32_DualNumber* multiplier_to_conjugate)
+{
+    BGC_FP32_Quaternion dual_part;
+
+    bgc_fp32_quaternion_multiply_by_real(&dual_part, &multiplicand->dual_part, multiplier_to_conjugate->real_part);
+    bgc_fp32_quaternion_subtract_scaled(&dual_part, &dual_part, &multiplicand->real_part, multiplier_to_conjugate->dual_part);
+
+    bgc_fp32_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier_to_conjugate->real_part);
+    bgc_fp32_quaternion_copy(&product->dual_part, &dual_part);
+}
+
+inline void bgc_fp64_dual_quaternion_multiply_by_conjugate_number(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const BGC_FP64_DualNumber* multiplier_to_conjugate)
+{
+    BGC_FP64_Quaternion dual_part;
+
+    bgc_fp64_quaternion_multiply_by_real(&dual_part, &multiplicand->dual_part, multiplier_to_conjugate->real_part);
+    bgc_fp64_quaternion_subtract_scaled(&dual_part, &dual_part, &multiplicand->real_part, multiplier_to_conjugate->dual_part);
+
+    bgc_fp64_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier_to_conjugate->real_part);
+    bgc_fp64_quaternion_copy(&product->dual_part, &dual_part);
 }
 
 // =================== Divide =================== //
 
-inline void bgc_fp32_dual_quaternion_divide_by_real(BGC_FP32_DualQuaternion* quotient, const BGC_FP32_DualQuaternion* divident, const float divisor)
+inline int bgc_fp32_dual_quaternion_divide_by_real(BGC_FP32_DualQuaternion* quotient, const BGC_FP32_DualQuaternion* dividend, const float divisor)
 {
-    bgc_fp32_dual_quaternion_multiply_by_real(quotient, divident, 1.0f / divisor);
+    if (bgc_fp32_is_zero(divisor)) {
+        return BGC_FAILURE;
     }
 
-inline void bgc_fp64_dual_quaternion_divide_by_real(BGC_FP64_DualQuaternion* quotient, const BGC_FP64_DualQuaternion* divident, const double divisor)
+    const float multiplier = 1.0f / divisor;
+
+    bgc_fp32_quaternion_multiply_by_real(&quotient->real_part, &dividend->real_part, multiplier);
+    bgc_fp32_quaternion_multiply_by_real(&quotient->dual_part, &dividend->dual_part, multiplier);
+
+    return BGC_SUCCESS;
+}
+
+inline int bgc_fp64_dual_quaternion_divide_by_real(BGC_FP64_DualQuaternion* quotient, const BGC_FP64_DualQuaternion* dividend, const double divisor)
 {
-    bgc_fp64_dual_quaternion_multiply_by_real(quotient, divident, 1.0 / divisor);
+    if (bgc_fp64_is_zero(divisor)) {
+        return BGC_FAILURE;
+    }
+
+    const double multiplier = 1.0 / divisor;
+
+    bgc_fp64_quaternion_multiply_by_real(&quotient->real_part, &dividend->real_part, multiplier);
+    bgc_fp64_quaternion_multiply_by_real(&quotient->dual_part, &dividend->dual_part, multiplier);
+
+    return BGC_SUCCESS;
+}
+
+// =========== Divide by Dual Number ============ //
+
+inline int bgc_fp32_dual_quaternion_divide_by_dual_number(BGC_FP32_DualQuaternion* quotient, const BGC_FP32_DualQuaternion* dividend, const BGC_FP32_DualNumber* divisor)
+{
+    const float square_modulus = divisor->real_part * divisor->real_part;
+
+    if (square_modulus <= BGC_FP32_SQUARE_EPSILON) {
+        return BGC_FAILURE;
+    }
+
+    bgc_fp32_dual_quaternion_multiply_by_conjugate_number(quotient, dividend, divisor);
+    bgc_fp32_dual_quaternion_multiply_by_real(quotient, quotient, 1.0f / square_modulus);
+
+    return BGC_SUCCESS;
+}
+
+inline int bgc_fp64_dual_quaternion_divide_by_dual_number(BGC_FP64_DualQuaternion* quotient, const BGC_FP64_DualQuaternion* dividend, const BGC_FP64_DualNumber* divisor)
+{
+    const double square_modulus = divisor->real_part * divisor->real_part;
+
+    if (square_modulus <= BGC_FP64_SQUARE_EPSILON) {
+        return BGC_FAILURE;
+    }
+
+    bgc_fp64_dual_quaternion_multiply_by_conjugate_number(quotient, dividend, divisor);
+    bgc_fp64_dual_quaternion_multiply_by_real(quotient, quotient, 1.0 / square_modulus);
+
+    return BGC_SUCCESS;
+}
+
+// ====== Divide by Conjugate Dual Number ======= //
+
+inline int bgc_fp32_dual_quaternion_divide_by_conjugate_number(BGC_FP32_DualQuaternion* quotient, const BGC_FP32_DualQuaternion* dividend, const BGC_FP32_DualNumber* divisor_to_conjugate)
+{
+    const float square_modulus = divisor_to_conjugate->real_part * divisor_to_conjugate->real_part;
+
+    if (square_modulus <= BGC_FP32_SQUARE_EPSILON) {
+        return BGC_FAILURE;
+    }
+
+    bgc_fp32_dual_quaternion_multiply_by_dual_number(quotient, dividend, divisor_to_conjugate);
+    bgc_fp32_dual_quaternion_multiply_by_real(quotient, quotient, 1.0f / square_modulus);
+
+    return BGC_SUCCESS;
+}
+
+inline int bgc_fp64_dual_quaternion_divide_by_conjugate_number(BGC_FP64_DualQuaternion* quotient, const BGC_FP64_DualQuaternion* dividend, const BGC_FP64_DualNumber* divisor_to_conjugate)
+{
+    const double square_modulus = divisor_to_conjugate->real_part * divisor_to_conjugate->real_part;
+
+    if (square_modulus <= BGC_FP64_SQUARE_EPSILON) {
+        return BGC_FAILURE;
+    }
+
+    bgc_fp64_dual_quaternion_multiply_by_dual_number(quotient, dividend, divisor_to_conjugate);
+    bgc_fp64_dual_quaternion_multiply_by_real(quotient, quotient, 1.0 / square_modulus);
+
+    return BGC_SUCCESS;
 }
 
 // ================ Mean of Two ================= //
@@ -170,32 +338,4 @@ inline void bgc_fp64_dual_quaternion_interpolate(BGC_FP64_DualQuaternion* interp
     bgc_fp64_quaternion_interpolate(&interpolation->dual_part, &first->dual_part, &second->dual_part, phase);
 }
 
-// =================== Revert =================== //
-
-inline void bgc_fp32_dual_quaternion_revert(BGC_FP32_DualQuaternion* quaternion)
-{
-    bgc_fp32_quaternion_revert(&quaternion->real_part);
-    bgc_fp32_quaternion_revert(&quaternion->dual_part);
-}
-
-inline void bgc_fp64_dual_quaternion_revert(BGC_FP64_DualQuaternion* quaternion)
-{
-    bgc_fp64_quaternion_revert(&quaternion->real_part);
-    bgc_fp64_quaternion_revert(&quaternion->dual_part);
-}
-
-// ================ Get Reverse ================= //
-
-inline void bgc_fp32_dual_quaternion_get_reverse(BGC_FP32_DualQuaternion* reverse, const BGC_FP32_DualQuaternion* quaternion)
-{