Добавление новых функций, возвращение функций subtract_scaled
This commit is contained in:
parent
727961ad98
commit
1075624d05
26 changed files with 836 additions and 292 deletions
|
|
@ -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" />
|
||||
|
|
|
|||
|
|
@ -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">
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
73
basic-geometry/dual-number.c
Normal file
73
basic-geometry/dual-number.c
Normal file
|
|
@ -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);
|
||||
|
|
@ -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;
|
||||
|
||||
|
|
@ -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_fp64_dual_quaternion_multiply_by_real(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const double 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_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_fp64_dual_quaternion_divide_by_real(BGC_FP64_DualQuaternion* quotient, const BGC_FP64_DualQuaternion* divident, const double 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_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);
|
||||
|
|
|
|||
|
|
@ -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_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multipier);
|
||||
bgc_fp32_quaternion_subtract_scaled(&difference->real_part, &base_quaternion->real_part, &scalable_quaternion->real_part, scale);
|
||||
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_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multipier);
|
||||
bgc_fp64_quaternion_subtract_scaled(&difference->real_part, &base_quaternion->real_part, &scalable_quaternion->real_part, scale);
|
||||
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;
|
||||
}
|
||||
|
||||
const float multiplier = 1.0f / divisor;
|
||||
|
||||
bgc_fp32_quaternion_multiply_by_real("ient->real_part, ÷nd->real_part, multiplier);
|
||||
bgc_fp32_quaternion_multiply_by_real("ient->dual_part, ÷nd->dual_part, multiplier);
|
||||
|
||||
return BGC_SUCCESS;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_divide_by_real(BGC_FP64_DualQuaternion* quotient, const BGC_FP64_DualQuaternion* divident, const double divisor)
|
||||
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("ient->real_part, ÷nd->real_part, multiplier);
|
||||
bgc_fp64_quaternion_multiply_by_real("ient->dual_part, ÷nd->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)
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,61 +0,0 @@
|
|||
#include "./dual-scalar.h"
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_reset(BGC_FP32_DualScalar* number);
|
||||
extern inline void bgc_fp64_dual_scalar_reset(BGC_FP64_DualScalar* number);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_make(BGC_FP32_DualScalar* number, const float real_part, const float dual_part);
|
||||
extern inline void bgc_fp64_dual_scalar_make(BGC_FP64_DualScalar* number, const double real_part, const double dual_part);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_copy(BGC_FP32_DualScalar* destination, const BGC_FP32_DualScalar* source);
|
||||
extern inline void bgc_fp64_dual_scalar_copy(BGC_FP64_DualScalar* destination, const BGC_FP64_DualScalar* source);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_swap(BGC_FP32_DualScalar* first, BGC_FP32_DualScalar* second);
|
||||
extern inline void bgc_fp64_dual_scalar_swap(BGC_FP64_DualScalar* first, BGC_FP64_DualScalar* second);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_revert(BGC_FP32_DualScalar* number);
|
||||
extern inline void bgc_fp64_dual_scalar_revert(BGC_FP64_DualScalar* number);
|
||||
|
||||
extern inline void bgc_fp32_number_get_reverse(BGC_FP32_DualScalar* reverse, const BGC_FP32_DualScalar* number);
|
||||
extern inline void bgc_fp64_number_get_reverse(BGC_FP64_DualScalar* reverse, const BGC_FP64_DualScalar* number);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_conjugate(BGC_FP32_DualScalar* number);
|
||||
extern inline void bgc_fp64_dual_scalar_conjugate(BGC_FP64_DualScalar* number);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_get_conjugate(BGC_FP32_DualScalar* conjugate, const BGC_FP32_DualScalar* number);
|
||||
extern inline void bgc_fp64_dual_scalar_get_conjugate(BGC_FP64_DualScalar* conjugate, const BGC_FP64_DualScalar* number);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_add(BGC_FP32_DualScalar* sum, const BGC_FP32_DualScalar* first, const BGC_FP32_DualScalar* second);
|
||||
extern inline void bgc_fp64_dual_scalar_add(BGC_FP64_DualScalar* sum, const BGC_FP64_DualScalar* first, const BGC_FP64_DualScalar* second);
|
||||
|
||||
extern 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);
|
||||
extern 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);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_subtract(BGC_FP32_DualScalar* difference, const BGC_FP32_DualScalar* minuend, const BGC_FP32_DualScalar* subtrahend);
|
||||
extern inline void bgc_fp64_dual_scalar_subtract(BGC_FP64_DualScalar* difference, const BGC_FP64_DualScalar* minuend, const BGC_FP64_DualScalar* subtrahend);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_multiply_by_real(BGC_FP32_DualScalar* product, const BGC_FP32_DualScalar* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_dual_scalar_multiply_by_real(BGC_FP64_DualScalar* product, const BGC_FP64_DualScalar* multiplicand, const double multiplier);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_multiply_by_dual(BGC_FP32_DualScalar* product, const BGC_FP32_DualScalar* multiplicand, const BGC_FP32_DualScalar* multiplier);
|
||||
extern inline void bgc_fp64_dual_scalar_multiply_by_dual(BGC_FP64_DualScalar* product, const BGC_FP64_DualScalar* multiplicand, const BGC_FP64_DualScalar* multiplier);
|
||||
|
||||
extern 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);
|
||||
extern 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);
|
||||
|
||||
extern inline int bgc_fp32_dual_scalar_divide_by_real(BGC_FP32_DualScalar* quotient, const BGC_FP32_DualScalar* dividend, const float divisor);
|
||||
extern inline int bgc_fp64_dual_scalar_divide_by_real(BGC_FP64_DualScalar* quotient, const BGC_FP64_DualScalar* dividend, const double divisor);
|
||||
|
||||
extern inline int bgc_fp32_dual_scalar_divide_by_dual(BGC_FP32_DualScalar* quotient, const BGC_FP32_DualScalar* dividend, const BGC_FP32_DualScalar* divisor);
|
||||
extern inline int bgc_fp64_dual_scalar_divide_by_dual(BGC_FP64_DualScalar* quotient, const BGC_FP64_DualScalar* dividend, const BGC_FP64_DualScalar* divisor);
|
||||
|
||||
extern 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);
|
||||
extern 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);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_get_mean2(BGC_FP32_DualScalar* mean, const BGC_FP32_DualScalar* first, const BGC_FP32_DualScalar* second);
|
||||
extern inline void bgc_fp64_dual_scalar_get_mean2(BGC_FP64_DualScalar* mean, const BGC_FP64_DualScalar* first, const BGC_FP64_DualScalar* second);
|
||||
|
||||
extern 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);
|
||||
extern 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);
|
||||
|
||||
extern inline void bgc_fp32_dual_scalar_interpolate(BGC_FP32_DualScalar* interpolation, const BGC_FP32_DualScalar* first, const BGC_FP32_DualScalar* second, const float phase);
|
||||
extern inline void bgc_fp64_dual_scalar_interpolate(BGC_FP64_DualScalar* interpolation, const BGC_FP64_DualScalar* first, const BGC_FP64_DualScalar* second, const double phase);
|
||||
|
|
@ -3,15 +3,21 @@
|
|||
extern inline void bgc_fp32_dual_vector3_reset(BGC_FP32_DualVector3* vector);
|
||||
extern inline void bgc_fp64_dual_vector3_reset(BGC_FP64_DualVector3* vector);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_make(BGC_FP32_DualVector3* vector, const BGC_FP32_Vector3* real, const BGC_FP32_Vector3* dual);
|
||||
extern inline void bgc_fp64_dual_vector3_make(BGC_FP64_DualVector3* vector, const BGC_FP64_Vector3* real, const BGC_FP64_Vector3* dual);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_copy(BGC_FP32_DualVector3* destination, const BGC_FP32_DualVector3* source);
|
||||
extern inline void bgc_fp64_dual_vector3_copy(BGC_FP64_DualVector3* destination, const BGC_FP64_DualVector3* source);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_swap(BGC_FP32_DualVector3* first, BGC_FP32_DualVector3* second);
|
||||
extern inline void bgc_fp64_dual_vector3_swap(BGC_FP64_DualVector3* first, BGC_FP64_DualVector3* second);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_convert_to_fp64(BGC_FP64_DualVector3* destination, const BGC_FP32_DualVector3* source);
|
||||
extern inline void bgc_fp64_dual_vector3_convert_to_fp32(BGC_FP32_DualVector3* destination, const BGC_FP64_DualVector3* source);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_revert(BGC_FP32_DualVector3* vector);
|
||||
extern inline void bgc_fp64_dual_vector3_revert(BGC_FP64_DualVector3* vector);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_get_reverse(BGC_FP32_DualVector3* reverse, const BGC_FP32_DualVector3* vector);
|
||||
extern inline void bgc_fp64_dual_vector3_get_reverse(BGC_FP64_DualVector3* reverse, const BGC_FP64_DualVector3* vector);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_add(BGC_FP32_DualVector3* sum, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second);
|
||||
extern inline void bgc_fp64_dual_vector3_add(BGC_FP64_DualVector3* sum, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second);
|
||||
|
||||
|
|
@ -21,29 +27,38 @@ extern inline void bgc_fp64_dual_vector3_add_scaled(BGC_FP64_DualVector3* sum, c
|
|||
extern inline void bgc_fp32_dual_vector3_subtract(BGC_FP32_DualVector3* difference, const BGC_FP32_DualVector3* minuend, const BGC_FP32_DualVector3* subtrahend);
|
||||
extern inline void bgc_fp64_dual_vector3_subtract(BGC_FP64_DualVector3* difference, const BGC_FP64_DualVector3* minuend, const BGC_FP64_DualVector3* subtrahend);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_subtract_scaled(BGC_FP32_DualVector3* difference, const BGC_FP32_DualVector3* base_vector, const BGC_FP32_DualVector3* scalable_vector, const float scale);
|
||||
extern inline void bgc_fp64_dual_vector3_subtract_scaled(BGC_FP64_DualVector3* difference, const BGC_FP64_DualVector3* base_vector, const BGC_FP64_DualVector3* scalable_vector, const double scale);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_multiply_by_real(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_dual_vector3_multiply_by_real(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const double multiplier);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_multiply_by_dual(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const BGC_FP32_DualScalar* multiplier);
|
||||
extern inline void bgc_fp64_dual_vector3_multiply_by_dual(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const BGC_FP64_DualScalar* multiplier);
|
||||
extern inline void bgc_fp32_dual_vector3_multiply_by_dual(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const BGC_FP32_DualNumber* multiplier);
|
||||
extern inline void bgc_fp64_dual_vector3_multiply_by_dual(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const BGC_FP64_DualNumber* multiplier);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_multiply_by_conjugate(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const BGC_FP32_DualScalar* multiplier_to_conjugate);
|
||||
extern inline void bgc_fp64_dual_vector3_multiply_by_conjugate(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const BGC_FP64_DualScalar* multiplier_to_conjugate);
|
||||
extern inline void bgc_fp32_dual_vector3_multiply_by_conjugate(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const BGC_FP32_DualNumber* multiplier_to_conjugate);
|
||||
extern inline void bgc_fp64_dual_vector3_multiply_by_conjugate(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const BGC_FP64_DualNumber* multiplier_to_conjugate);
|
||||
|
||||
extern inline int bgc_fp32_dual_vector3_divide_by_real(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* dividend, const float divisor);
|
||||
extern inline int bgc_fp64_dual_vector3_divide_by_real(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const double divisor);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_get_mean2(BGC_FP32_DualVector3* mean, const BGC_FP32_DualVector3* vector1, const BGC_FP32_DualVector3* vector2);
|
||||
extern inline void bgc_fp64_dual_vector3_get_mean2(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* vector1, const BGC_FP64_DualVector3* vector2);
|
||||
extern inline int bgc_fp32_dual_vector3_divide_by_dual(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* dividend, const BGC_FP32_DualNumber* divisor);
|
||||
extern inline int bgc_fp64_dual_vector3_divide_by_dual(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const BGC_FP64_DualNumber* divisor);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_get_mean3(BGC_FP32_DualVector3* mean, const BGC_FP32_DualVector3* vector1, const BGC_FP32_DualVector3* vector2, const BGC_FP32_DualVector3* vector3);
|
||||
extern inline void bgc_fp64_dual_vector3_get_mean3(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* vector1, const BGC_FP64_DualVector3* vector2, const BGC_FP64_DualVector3* vector3);
|
||||
extern inline int bgc_fp32_dual_vector3_divide_by_conjugate(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* dividend, const BGC_FP32_DualNumber* divisor_to_conjugate);
|
||||
extern inline int bgc_fp64_dual_vector3_divide_by_conjugate(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const BGC_FP64_DualNumber* divisor_to_conjugate);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_get_mean2(BGC_FP32_DualVector3* mean, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second);
|
||||
extern inline void bgc_fp64_dual_vector3_get_mean2(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_get_mean3(BGC_FP32_DualVector3* mean, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second, const BGC_FP32_DualVector3* third);
|
||||
extern inline void bgc_fp64_dual_vector3_get_mean3(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second, const BGC_FP64_DualVector3* third);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_interpolate(BGC_FP32_DualVector3* interpolation, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second, const float phase);
|
||||
extern inline void bgc_fp64_dual_vector3_interpolate(BGC_FP64_DualVector3* interpolation, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second, const double phase);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_revert(BGC_FP32_DualVector3* vector);
|
||||
extern inline void bgc_fp64_dual_vector3_revert(BGC_FP64_DualVector3* vector);
|
||||
extern inline void bgc_fp32_dual_vector3_get_dot_product(BGC_FP32_DualNumber* product, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second);
|
||||
extern inline void bgc_fp64_dual_vector3_get_dot_product(BGC_FP64_DualNumber* product, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_get_reverse(BGC_FP32_DualVector3* reverse, const BGC_FP32_DualVector3* vector);
|
||||
extern inline void bgc_fp64_dual_vector3_get_reverse(BGC_FP64_DualVector3* reverse, const BGC_FP64_DualVector3* vector);
|
||||
extern inline void bgc_fp32_dual_vector3_get_cross_product(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second);
|
||||
extern inline void bgc_fp64_dual_vector3_get_cross_product(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second);
|
||||
|
|
|
|||
|
|
@ -18,20 +18,6 @@ inline void bgc_fp64_dual_vector3_reset(BGC_FP64_DualVector3* vector)
|
|||
bgc_fp64_vector3_reset(&vector->dual_part);
|
||||
}
|
||||
|
||||
// ==================== Make ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_make(BGC_FP32_DualVector3* vector, const BGC_FP32_Vector3* real_part, const BGC_FP32_Vector3* dual_part)
|
||||
{
|
||||
bgc_fp32_vector3_copy(&vector->real_part, real_part);
|
||||
bgc_fp32_vector3_copy(&vector->dual_part, dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_make(BGC_FP64_DualVector3* vector, const BGC_FP64_Vector3* real_part, const BGC_FP64_Vector3* dual_part)
|
||||
{
|
||||
bgc_fp64_vector3_copy(&vector->real_part, real_part);
|
||||
bgc_fp64_vector3_copy(&vector->dual_part, dual_part);
|
||||
}
|
||||
|
||||
// ==================== Copy ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_copy(BGC_FP32_DualVector3* destination, const BGC_FP32_DualVector3* source)
|
||||
|
|
@ -60,6 +46,48 @@ inline void bgc_fp64_dual_vector3_swap(BGC_FP64_DualVector3* first, BGC_FP64_Dua
|
|||
bgc_fp64_vector3_swap(&first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
// ================== Convert =================== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_convert_to_fp64(BGC_FP64_DualVector3* destination, const BGC_FP32_DualVector3* source)
|
||||
{
|
||||
bgc_fp32_vector3_convert_to_fp64(&destination->real_part, &source->real_part);
|
||||
bgc_fp32_vector3_convert_to_fp64(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_convert_to_fp32(BGC_FP32_DualVector3* destination, const BGC_FP64_DualVector3* source)
|
||||
{
|
||||
bgc_fp64_vector3_convert_to_fp32(&destination->real_part, &source->real_part);
|
||||
bgc_fp64_vector3_convert_to_fp32(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
// =================== Revert =================== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_revert(BGC_FP32_DualVector3* vector)
|
||||
{
|
||||
bgc_fp32_vector3_revert(&vector->real_part);
|
||||
bgc_fp32_vector3_revert(&vector->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_revert(BGC_FP64_DualVector3* vector)
|
||||
{
|
||||
bgc_fp64_vector3_revert(&vector->real_part);
|
||||
bgc_fp64_vector3_revert(&vector->dual_part);
|
||||
}
|
||||
|
||||
// ================ Get Reverse ================= //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_get_reverse(BGC_FP32_DualVector3* reverse, const BGC_FP32_DualVector3* vector)
|
||||
{
|
||||
bgc_fp32_vector3_get_reverse(&reverse->real_part, &vector->real_part);
|
||||
bgc_fp32_vector3_get_reverse(&reverse->dual_part, &vector->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_get_reverse(BGC_FP64_DualVector3* reverse, const BGC_FP64_DualVector3* vector)
|
||||
{
|
||||
bgc_fp64_vector3_get_reverse(&reverse->real_part, &vector->real_part);
|
||||
bgc_fp64_vector3_get_reverse(&reverse->dual_part, &vector->dual_part);
|
||||
}
|
||||
|
||||
// ==================== Add ===================== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_add(BGC_FP32_DualVector3* sum, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second)
|
||||
|
|
@ -102,6 +130,20 @@ inline void bgc_fp64_dual_vector3_subtract(BGC_FP64_DualVector3* difference, con
|
|||
bgc_fp64_vector3_subtract(&difference->dual_part, &minuend->dual_part, &subtrahend->dual_part);
|
||||
}
|
||||
|
||||
// ============== Subtract Scaled =============== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_subtract_scaled(BGC_FP32_DualVector3* difference, const BGC_FP32_DualVector3* base_vector, const BGC_FP32_DualVector3* scalable_vector, const float scale)
|
||||
{
|
||||
bgc_fp32_vector3_subtract_scaled(&difference->real_part, &base_vector->real_part, &scalable_vector->real_part, scale);
|
||||
bgc_fp32_vector3_subtract_scaled(&difference->dual_part, &base_vector->dual_part, &scalable_vector->dual_part, scale);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_subtract_scaled(BGC_FP64_DualVector3* difference, const BGC_FP64_DualVector3* base_vector, const BGC_FP64_DualVector3* scalable_vector, const double scale)
|
||||
{
|
||||
bgc_fp64_vector3_subtract_scaled(&difference->real_part, &base_vector->real_part, &scalable_vector->real_part, scale);
|
||||
bgc_fp64_vector3_subtract_scaled(&difference->dual_part, &base_vector->dual_part, &scalable_vector->dual_part, scale);
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_multiply_by_real(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const float multiplier)
|
||||
|
|
@ -116,80 +158,52 @@ inline void bgc_fp64_dual_vector3_multiply_by_real(BGC_FP64_DualVector3* product
|
|||
bgc_fp64_vector3_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multiplier);
|
||||
}
|
||||
|
||||
inline void bgc_fp32_dual_vector3_multiply_by_dual(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const BGC_FP32_DualScalar* multiplier)
|
||||
// ========== Multiply by Dual Number =========== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_multiply_by_dual(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const BGC_FP32_DualNumber* multiplier)
|
||||
{
|
||||
const float real_x1 = multiplicand->real_part.x1 * multiplier->real_part;
|
||||
const float real_x2 = multiplicand->real_part.x2 * multiplier->real_part;
|
||||
const float real_x3 = multiplicand->real_part.x3 * multiplier->real_part;
|
||||
BGC_FP32_Vector3 dual_part;
|
||||
|
||||
const float dual_x1 = multiplicand->dual_part.x1 * multiplier->real_part + multiplicand->real_part.x1 * multiplier->dual_part;
|
||||
const float dual_x2 = multiplicand->dual_part.x2 * multiplier->real_part + multiplicand->real_part.x2 * multiplier->dual_part;
|
||||
const float dual_x3 = multiplicand->dual_part.x3 * multiplier->real_part + multiplicand->real_part.x3 * multiplier->dual_part;
|
||||
bgc_fp32_vector3_multiply_by_real(&dual_part, &multiplicand->dual_part, multiplier->real_part);
|
||||
bgc_fp32_vector3_add_scaled(&dual_part, &dual_part, &multiplicand->real_part, multiplier->dual_part);
|
||||
|
||||
product->real_part.x1 = real_x1;
|
||||
product->real_part.x2 = real_x2;
|
||||
product->real_part.x3 = real_x3;
|
||||
|
||||
product->dual_part.x1 = dual_x1;
|
||||
product->dual_part.x2 = dual_x2;
|
||||
product->dual_part.x3 = dual_x3;
|
||||
bgc_fp32_vector3_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier->real_part);
|
||||
bgc_fp32_vector3_copy(&product->dual_part, &dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_multiply_by_dual(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const BGC_FP64_DualScalar* multiplier)
|
||||
inline void bgc_fp64_dual_vector3_multiply_by_dual(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const BGC_FP64_DualNumber* multiplier)
|
||||
{
|
||||
const double real_x1 = multiplicand->real_part.x1 * multiplier->real_part;
|
||||
const double real_x2 = multiplicand->real_part.x2 * multiplier->real_part;
|
||||
const double real_x3 = multiplicand->real_part.x3 * multiplier->real_part;
|
||||
BGC_FP64_Vector3 dual_part;
|
||||
|
||||
const double dual_x1 = multiplicand->dual_part.x1 * multiplier->real_part + multiplicand->real_part.x1 * multiplier->dual_part;
|
||||
const double dual_x2 = multiplicand->dual_part.x2 * multiplier->real_part + multiplicand->real_part.x2 * multiplier->dual_part;
|
||||
const double dual_x3 = multiplicand->dual_part.x3 * multiplier->real_part + multiplicand->real_part.x3 * multiplier->dual_part;
|
||||
bgc_fp64_vector3_multiply_by_real(&dual_part, &multiplicand->dual_part, multiplier->real_part);
|
||||
bgc_fp64_vector3_add_scaled(&dual_part, &dual_part, &multiplicand->real_part, multiplier->dual_part);
|
||||
|
||||
product->real_part.x1 = real_x1;
|
||||
product->real_part.x2 = real_x2;
|
||||
product->real_part.x3 = real_x3;
|
||||
|
||||
product->dual_part.x1 = dual_x1;
|
||||
product->dual_part.x2 = dual_x2;
|
||||
product->dual_part.x3 = dual_x3;
|
||||
bgc_fp64_vector3_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier->real_part);
|
||||
bgc_fp64_vector3_copy(&product->dual_part, &dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp32_dual_vector3_multiply_by_conjugate(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const BGC_FP32_DualScalar* multiplier_to_conjugate)
|
||||
// ===== Multiply by Conjugate Dual Number ====== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_multiply_by_conjugate(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const BGC_FP32_DualNumber* multiplier_to_conjugate)
|
||||
{
|
||||
const float real_x1 = multiplicand->real_part.x1 * multiplier_to_conjugate->real_part;
|
||||
const float real_x2 = multiplicand->real_part.x2 * multiplier_to_conjugate->real_part;
|
||||
const float real_x3 = multiplicand->real_part.x3 * multiplier_to_conjugate->real_part;
|
||||
BGC_FP32_Vector3 dual_part;
|
||||
|
||||
const float dual_x1 = multiplicand->dual_part.x1 * multiplier_to_conjugate->real_part - multiplicand->real_part.x1 * multiplier_to_conjugate->dual_part;
|
||||
const float dual_x2 = multiplicand->dual_part.x2 * multiplier_to_conjugate->real_part - multiplicand->real_part.x2 * multiplier_to_conjugate->dual_part;
|
||||
const float dual_x3 = multiplicand->dual_part.x3 * multiplier_to_conjugate->real_part - multiplicand->real_part.x3 * multiplier_to_conjugate->dual_part;
|
||||
bgc_fp32_vector3_multiply_by_real(&dual_part, &multiplicand->dual_part, multiplier_to_conjugate->real_part);
|
||||
bgc_fp32_vector3_subtract_scaled(&dual_part, &dual_part, &multiplicand->real_part, multiplier_to_conjugate->dual_part);
|
||||
|
||||
product->real_part.x1 = real_x1;
|
||||
product->real_part.x2 = real_x2;
|
||||
product->real_part.x3 = real_x3;
|
||||
|
||||
product->dual_part.x1 = dual_x1;
|
||||
product->dual_part.x2 = dual_x2;
|
||||
product->dual_part.x3 = dual_x3;
|
||||
bgc_fp32_vector3_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier_to_conjugate->real_part);
|
||||
bgc_fp32_vector3_copy(&product->dual_part, &dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_multiply_by_conjugate(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const BGC_FP64_DualScalar* multiplier_to_conjugate)
|
||||
inline void bgc_fp64_dual_vector3_multiply_by_conjugate(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const BGC_FP64_DualNumber* multiplier_to_conjugate)
|
||||
{
|
||||
const double real_x1 = multiplicand->real_part.x1 * multiplier_to_conjugate->real_part;
|
||||
const double real_x2 = multiplicand->real_part.x2 * multiplier_to_conjugate->real_part;
|
||||
const double real_x3 = multiplicand->real_part.x3 * multiplier_to_conjugate->real_part;
|
||||
BGC_FP64_Vector3 dual_part;
|
||||
|
||||
const double dual_x1 = multiplicand->dual_part.x1 * multiplier_to_conjugate->real_part - multiplicand->real_part.x1 * multiplier_to_conjugate->dual_part;
|
||||
const double dual_x2 = multiplicand->dual_part.x2 * multiplier_to_conjugate->real_part - multiplicand->real_part.x2 * multiplier_to_conjugate->dual_part;
|
||||
const double dual_x3 = multiplicand->dual_part.x3 * multiplier_to_conjugate->real_part - multiplicand->real_part.x3 * multiplier_to_conjugate->dual_part;
|
||||
bgc_fp64_vector3_multiply_by_real(&dual_part, &multiplicand->dual_part, multiplier_to_conjugate->real_part);
|
||||
bgc_fp64_vector3_subtract_scaled(&dual_part, &dual_part, &multiplicand->real_part, multiplier_to_conjugate->dual_part);
|
||||
|
||||
product->real_part.x1 = real_x1;
|
||||
product->real_part.x2 = real_x2;
|
||||
product->real_part.x3 = real_x3;
|
||||
|
||||
product->dual_part.x1 = dual_x1;
|
||||
product->dual_part.x2 = dual_x2;
|
||||
product->dual_part.x3 = dual_x3;
|
||||
bgc_fp64_vector3_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier_to_conjugate->real_part);
|
||||
bgc_fp64_vector3_copy(&product->dual_part, &dual_part);
|
||||
}
|
||||
|
||||
// =================== Divide =================== //
|
||||
|
|
@ -222,32 +236,92 @@ inline int bgc_fp64_dual_vector3_divide_by_real(BGC_FP64_DualVector3* quotient,
|
|||
return BGC_SUCCESS;
|
||||
}
|
||||
|
||||
// ================ Mean of Two ================= //
|
||||
// =========== Divide by Dual Number ============ //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_get_mean2(BGC_FP32_DualVector3* mean, const BGC_FP32_DualVector3* vector1, const BGC_FP32_DualVector3* vector2)
|
||||
inline int bgc_fp32_dual_vector3_divide_by_dual(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* dividend, const BGC_FP32_DualNumber* divisor)
|
||||
{
|
||||
bgc_fp32_vector3_get_mean2(&mean->real_part, &vector1->real_part, &vector2->real_part);
|
||||
bgc_fp32_vector3_get_mean2(&mean->dual_part, &vector1->dual_part, &vector2->dual_part);
|
||||
const float square_modulus = divisor->real_part * divisor->real_part;
|
||||
|
||||
if (square_modulus <= BGC_FP32_SQUARE_EPSILON) {
|
||||
return BGC_FAILURE;
|
||||
}
|
||||
|
||||
bgc_fp32_dual_vector3_multiply_by_conjugate(quotient, dividend, divisor);
|
||||
bgc_fp32_dual_vector3_multiply_by_real(quotient, quotient, 1.0f / square_modulus);
|
||||
|
||||
return BGC_SUCCESS;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_get_mean2(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* vector1, const BGC_FP64_DualVector3* vector2)
|
||||
inline int bgc_fp64_dual_vector3_divide_by_dual(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const BGC_FP64_DualNumber* divisor)
|
||||
{
|
||||
bgc_fp64_vector3_get_mean2(&mean->real_part, &vector1->real_part, &vector2->real_part);
|
||||
bgc_fp64_vector3_get_mean2(&mean->dual_part, &vector1->dual_part, &vector2->dual_part);
|
||||
const double square_modulus = divisor->real_part * divisor->real_part;
|
||||
|
||||
if (square_modulus <= BGC_FP64_SQUARE_EPSILON) {
|
||||
return BGC_FAILURE;
|
||||
}
|
||||
|
||||
bgc_fp64_dual_vector3_multiply_by_conjugate(quotient, dividend, divisor);
|
||||
bgc_fp64_dual_vector3_multiply_by_real(quotient, quotient, 1.0 / square_modulus);
|
||||
|
||||
return BGC_SUCCESS;
|
||||
}
|
||||
|
||||
// ====== Divide by Conjugate Dual Number ======= //
|
||||
|
||||
inline int bgc_fp32_dual_vector3_divide_by_conjugate(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* 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_vector3_multiply_by_dual(quotient, dividend, divisor_to_conjugate);
|
||||
bgc_fp32_dual_vector3_multiply_by_real(quotient, quotient, 1.0f / square_modulus);
|
||||
|
||||
return BGC_SUCCESS;
|
||||
}
|
||||
|
||||
inline int bgc_fp64_dual_vector3_divide_by_conjugate(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* 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_vector3_multiply_by_dual(quotient, dividend, divisor_to_conjugate);
|
||||
bgc_fp64_dual_vector3_multiply_by_real(quotient, quotient, 1.0 / square_modulus);
|
||||
|
||||
return BGC_SUCCESS;
|
||||
}
|
||||
|
||||
// ================ Mean of Two ================= //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_get_mean2(BGC_FP32_DualVector3* mean, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second)
|
||||
{
|
||||
bgc_fp32_vector3_get_mean2(&mean->real_part, &first->real_part, &second->real_part);
|
||||
bgc_fp32_vector3_get_mean2(&mean->dual_part, &first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_get_mean2(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second)
|
||||
{
|
||||
bgc_fp64_vector3_get_mean2(&mean->real_part, &first->real_part, &second->real_part);
|
||||
bgc_fp64_vector3_get_mean2(&mean->dual_part, &first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
// =============== Mean of Three ================ //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_get_mean3(BGC_FP32_DualVector3* mean, const BGC_FP32_DualVector3* vector1, const BGC_FP32_DualVector3* vector2, const BGC_FP32_DualVector3* vector3)
|
||||
inline void bgc_fp32_dual_vector3_get_mean3(BGC_FP32_DualVector3* mean, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second, const BGC_FP32_DualVector3* third)
|
||||
{
|
||||
bgc_fp32_vector3_get_mean3(&mean->real_part, &vector1->real_part, &vector2->real_part, &vector3->real_part);
|
||||
bgc_fp32_vector3_get_mean3(&mean->dual_part, &vector1->dual_part, &vector2->dual_part, &vector3->dual_part);
|
||||
bgc_fp32_vector3_get_mean3(&mean->real_part, &first->real_part, &second->real_part, &third->real_part);
|
||||
bgc_fp32_vector3_get_mean3(&mean->dual_part, &first->dual_part, &second->dual_part, &third->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_get_mean3(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* vector1, const BGC_FP64_DualVector3* vector2, const BGC_FP64_DualVector3* vector3)
|
||||
inline void bgc_fp64_dual_vector3_get_mean3(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second, const BGC_FP64_DualVector3* third)
|
||||
{
|
||||
bgc_fp64_vector3_get_mean3(&mean->real_part, &vector1->real_part, &vector2->real_part, &vector3->real_part);
|
||||
bgc_fp64_vector3_get_mean3(&mean->dual_part, &vector1->dual_part, &vector2->dual_part, &vector3->dual_part);
|
||||
bgc_fp64_vector3_get_mean3(&mean->real_part, &first->real_part, &second->real_part, &third->real_part);
|
||||
bgc_fp64_vector3_get_mean3(&mean->dual_part, &first->dual_part, &second->dual_part, &third->dual_part);
|
||||
}
|
||||
|
||||
// ============ Linear Interpolation ============ //
|
||||
|
|
@ -264,32 +338,42 @@ inline void bgc_fp64_dual_vector3_interpolate(BGC_FP64_DualVector3* interpolatio
|
|||
bgc_fp64_vector3_interpolate(&interpolation->dual_part, &first->dual_part, &second->dual_part, phase);
|
||||
}
|
||||
|
||||
// =================== Revert =================== //
|
||||
// ================ Dot Product ================= //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_revert(BGC_FP32_DualVector3* vector)
|
||||
inline void bgc_fp32_dual_vector3_get_dot_product(BGC_FP32_DualNumber* product, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second)
|
||||
{
|
||||
bgc_fp32_vector3_revert(&vector->real_part);
|
||||
bgc_fp32_vector3_revert(&vector->dual_part);
|
||||
product->real_part = bgc_fp32_vector3_get_dot_product(&first->real_part, &second->real_part);
|
||||
product->dual_part = bgc_fp32_vector3_get_dot_product(&first->dual_part, &second->real_part) + bgc_fp32_vector3_get_dot_product(&first->real_part, &second->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_revert(BGC_FP64_DualVector3* vector)
|
||||
inline void bgc_fp64_dual_vector3_get_dot_product(BGC_FP64_DualNumber* product, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second)
|
||||
{
|
||||
bgc_fp64_vector3_revert(&vector->real_part);
|
||||
bgc_fp64_vector3_revert(&vector->dual_part);
|
||||
product->real_part = bgc_fp64_vector3_get_dot_product(&first->real_part, &second->real_part);
|
||||
product->dual_part = bgc_fp64_vector3_get_dot_product(&first->dual_part, &second->real_part) + bgc_fp64_vector3_get_dot_product(&first->real_part, &second->dual_part);
|
||||
}
|
||||
|
||||
// ================ Get Reverse ================= //
|
||||
// =============== Cross Product ================ //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_get_reverse(BGC_FP32_DualVector3* reverse, const BGC_FP32_DualVector3* vector)
|
||||
inline void bgc_fp32_dual_vector3_get_cross_product(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second)
|
||||
{
|
||||
bgc_fp32_vector3_get_reverse(&reverse->real_part, &vector->real_part);
|
||||
bgc_fp32_vector3_get_reverse(&reverse->dual_part, &vector->dual_part);
|
||||
BGC_FP32_Vector3 part1, part2;
|
||||
|
||||
bgc_fp32_vector3_get_cross_product(&part1, &first->dual_part, &second->real_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);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_get_reverse(BGC_FP64_DualVector3* reverse, const BGC_FP64_DualVector3* vector)
|
||||
inline void bgc_fp64_dual_vector3_get_cross_product(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second)
|
||||
{
|
||||
bgc_fp64_vector3_get_reverse(&reverse->real_part, &vector->real_part);
|
||||
bgc_fp64_vector3_get_reverse(&reverse->dual_part, &vector->dual_part);
|
||||
BGC_FP64_Vector3 part1, part2;
|
||||
|
||||
bgc_fp64_vector3_get_cross_product(&part1, &first->dual_part, &second->real_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);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -66,6 +66,9 @@ extern inline void bgc_fp64_matrix2x2_add_scaled(BGC_FP64_Matrix2x2* sum, const
|
|||
extern inline void bgc_fp32_matrix2x2_subtract(BGC_FP32_Matrix2x2* difference, const BGC_FP32_Matrix2x2* minuend, const BGC_FP32_Matrix2x2* subtrahend);
|
||||
extern inline void bgc_fp64_matrix2x2_subtract(BGC_FP64_Matrix2x2* difference, const BGC_FP64_Matrix2x2* minuend, const BGC_FP64_Matrix2x2* subtrahend);
|
||||
|
||||
extern inline void bgc_fp32_matrix2x2_subtract_scaled(BGC_FP32_Matrix2x2* difference, const BGC_FP32_Matrix2x2* basic_matrix, const BGC_FP32_Matrix2x2* scalable_matrix, const float scale);
|
||||
extern inline void bgc_fp64_matrix2x2_subtract_scaled(BGC_FP64_Matrix2x2* difference, const BGC_FP64_Matrix2x2* basic_matrix, const BGC_FP64_Matrix2x2* scalable_matrix, const double scale);
|
||||
|
||||
extern inline void bgc_fp32_matrix2x2_multiply_by_real(BGC_FP32_Matrix2x2* product, const BGC_FP32_Matrix2x2* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_matrix2x2_multiply_by_real(BGC_FP64_Matrix2x2* product, const BGC_FP64_Matrix2x2* multiplicand, const double multiplier);
|
||||
|
||||
|
|
|
|||
|
|
@ -497,7 +497,7 @@ inline void bgc_fp64_matrix2x2_add(BGC_FP64_Matrix2x2* sum, const BGC_FP64_Matri
|
|||
sum->r2c2 = matrix1->r2c2 + matrix2->r2c2;
|
||||
}
|
||||
|
||||
// ================= Add scaled ================= //
|
||||
// ================= Add Scaled ================= //
|
||||
|
||||
inline void bgc_fp32_matrix2x2_add_scaled(BGC_FP32_Matrix2x2* sum, const BGC_FP32_Matrix2x2* basic_matrix, const BGC_FP32_Matrix2x2* scalable_matrix, const float scale)
|
||||
{
|
||||
|
|
@ -537,6 +537,26 @@ inline void bgc_fp64_matrix2x2_subtract(BGC_FP64_Matrix2x2* difference, const BG
|
|||
difference->r2c2 = minuend->r2c2 - subtrahend->r2c2;
|
||||
}
|
||||
|
||||
// ============== Subtract Scaled =============== //
|
||||
|
||||
inline void bgc_fp32_matrix2x2_subtract_scaled(BGC_FP32_Matrix2x2* difference, const BGC_FP32_Matrix2x2* basic_matrix, const BGC_FP32_Matrix2x2* scalable_matrix, const float scale)
|
||||
{
|
||||
difference->r1c1 = basic_matrix->r1c1 - scalable_matrix->r1c1 * scale;
|
||||
difference->r1c2 = basic_matrix->r1c2 - scalable_matrix->r1c2 * scale;
|
||||
|
||||
difference->r2c1 = basic_matrix->r2c1 - scalable_matrix->r2c1 * scale;
|
||||
difference->r2c2 = basic_matrix->r2c2 - scalable_matrix->r2c2 * scale;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_matrix2x2_subtract_scaled(BGC_FP64_Matrix2x2* difference, const BGC_FP64_Matrix2x2* basic_matrix, const BGC_FP64_Matrix2x2* scalable_matrix, const double scale)
|
||||
{
|
||||
difference->r1c1 = basic_matrix->r1c1 - scalable_matrix->r1c1 * scale;
|
||||
difference->r1c2 = basic_matrix->r1c2 - scalable_matrix->r1c2 * scale;
|
||||
|
||||
difference->r2c1 = basic_matrix->r2c1 - scalable_matrix->r2c1 * scale;
|
||||
difference->r2c2 = basic_matrix->r2c2 - scalable_matrix->r2c2 * scale;
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_matrix2x2_multiply_by_real(BGC_FP32_Matrix2x2* product, const BGC_FP32_Matrix2x2* multiplicand, const float multiplier)
|
||||
|
|
|
|||
|
|
@ -36,6 +36,9 @@ extern inline void bgc_fp64_matrix2x3_add_scaled(BGC_FP64_Matrix2x3* sum, const
|
|||
extern inline void bgc_fp32_matrix2x3_subtract(BGC_FP32_Matrix2x3* difference, const BGC_FP32_Matrix2x3* minuend, const BGC_FP32_Matrix2x3* subtrahend);
|
||||
extern inline void bgc_fp64_matrix2x3_subtract(BGC_FP64_Matrix2x3* difference, const BGC_FP64_Matrix2x3* minuend, const BGC_FP64_Matrix2x3* subtrahend);
|
||||
|
||||
extern inline void bgc_fp32_matrix2x3_subtract_scaled(BGC_FP32_Matrix2x3* sum, const BGC_FP32_Matrix2x3* basic_matrix, const BGC_FP32_Matrix2x3* scalable_matrix, const float scale);
|
||||
extern inline void bgc_fp64_matrix2x3_subtract_scaled(BGC_FP64_Matrix2x3* sum, const BGC_FP64_Matrix2x3* basic_matrix, const BGC_FP64_Matrix2x3* scalable_matrix, const double scale);
|
||||
|
||||
extern inline void bgc_fp32_matrix2x3_multiply_by_real(BGC_FP32_Matrix2x3* product, const BGC_FP32_Matrix2x3* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_matrix2x3_multiply_by_real(BGC_FP64_Matrix2x3* product, const BGC_FP64_Matrix2x3* multiplicand, const double multiplier);
|
||||
|
||||
|
|
|
|||
|
|
@ -358,7 +358,7 @@ inline void bgc_fp64_matrix2x3_add(BGC_FP64_Matrix2x3* sum, const BGC_FP64_Matri
|
|||
sum->r3c2 = matrix1->r3c2 + matrix2->r3c2;
|
||||
}
|
||||
|
||||
// ================= Add scaled ================= //
|
||||
// ================= Add Scaled ================= //
|
||||
|
||||
inline void bgc_fp32_matrix2x3_add_scaled(BGC_FP32_Matrix2x3* sum, const BGC_FP32_Matrix2x3* basic_matrix, const BGC_FP32_Matrix2x3* scalable_matrix, const float scale)
|
||||
{
|
||||
|
|
@ -410,6 +410,32 @@ inline void bgc_fp64_matrix2x3_subtract(BGC_FP64_Matrix2x3* difference, const BG
|
|||
difference->r3c2 = minuend->r3c2 - subtrahend->r3c2;
|
||||
}
|
||||
|
||||
// ============== Subtract scaled =============== //
|
||||
|
||||
inline void bgc_fp32_matrix2x3_subtract_scaled(BGC_FP32_Matrix2x3* sum, const BGC_FP32_Matrix2x3* basic_matrix, const BGC_FP32_Matrix2x3* scalable_matrix, const float scale)
|
||||
{
|
||||
sum->r1c1 = basic_matrix->r1c1 - scalable_matrix->r1c1 * scale;
|
||||
sum->r1c2 = basic_matrix->r1c2 - scalable_matrix->r1c2 * scale;
|
||||
|
||||
sum->r2c1 = basic_matrix->r2c1 - scalable_matrix->r2c1 * scale;
|
||||
sum->r2c2 = basic_matrix->r2c2 - scalable_matrix->r2c2 * scale;
|
||||
|
||||
sum->r3c1 = basic_matrix->r3c1 - scalable_matrix->r3c1 * scale;
|
||||
sum->r3c2 = basic_matrix->r3c2 - scalable_matrix->r3c2 * scale;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_matrix2x3_subtract_scaled(BGC_FP64_Matrix2x3* sum, const BGC_FP64_Matrix2x3* basic_matrix, const BGC_FP64_Matrix2x3* scalable_matrix, const double scale)
|
||||
{
|
||||
sum->r1c1 = basic_matrix->r1c1 - scalable_matrix->r1c1 * scale;
|
||||
sum->r1c2 = basic_matrix->r1c2 - scalable_matrix->r1c2 * scale;
|
||||
|
||||
sum->r2c1 = basic_matrix->r2c1 - scalable_matrix->r2c1 * scale;
|
||||
sum->r2c2 = basic_matrix->r2c2 - scalable_matrix->r2c2 * scale;
|
||||
|
||||
sum->r3c1 = basic_matrix->r3c1 - scalable_matrix->r3c1 * scale;
|
||||
sum->r3c2 = basic_matrix->r3c2 - scalable_matrix->r3c2 * scale;
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_matrix2x3_multiply_by_real(BGC_FP32_Matrix2x3* product, const BGC_FP32_Matrix2x3* multiplicand, const float multiplier)
|
||||
|
|
|
|||
|
|
@ -36,6 +36,9 @@ extern inline void bgc_fp64_matrix3x2_add_scaled(BGC_FP64_Matrix3x2* sum, const
|
|||
extern inline void bgc_fp32_matrix3x2_subtract(BGC_FP32_Matrix3x2* difference, const BGC_FP32_Matrix3x2* minuend, const BGC_FP32_Matrix3x2* subtrahend);
|
||||
extern inline void bgc_fp64_matrix3x2_subtract(BGC_FP64_Matrix3x2* difference, const BGC_FP64_Matrix3x2* minuend, const BGC_FP64_Matrix3x2* subtrahend);
|
||||
|
||||
extern inline void bgc_fp32_matrix3x2_subtract_scaled(BGC_FP32_Matrix3x2* difference, const BGC_FP32_Matrix3x2* basic_matrix, const BGC_FP32_Matrix3x2* scalable_matrix, const float scale);
|
||||
extern inline void bgc_fp64_matrix3x2_subtract_scaled(BGC_FP64_Matrix3x2* difference, const BGC_FP64_Matrix3x2* basic_matrix, const BGC_FP64_Matrix3x2* scalable_matrix, const double scale);
|
||||
|
||||
extern inline void bgc_fp32_matrix3x2_multiply_by_real(BGC_FP32_Matrix3x2* product, const BGC_FP32_Matrix3x2* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_matrix3x2_multiply_by_real(BGC_FP64_Matrix3x2* product, const BGC_FP64_Matrix3x2* multiplicand, const double multiplier);
|
||||
|
||||
|
|
|
|||
|
|
@ -372,7 +372,7 @@ inline void bgc_fp64_matrix3x2_add(BGC_FP64_Matrix3x2* sum, const BGC_FP64_Matri
|
|||
sum->r2c3 = matrix1->r2c3 + matrix2->r2c3;
|
||||
}
|
||||
|
||||
// ================= Add scaled ================= //
|
||||
// ================= Add Scaled ================= //
|
||||
|
||||
inline void bgc_fp32_matrix3x2_add_scaled(BGC_FP32_Matrix3x2* sum, const BGC_FP32_Matrix3x2* basic_matrix, const BGC_FP32_Matrix3x2* scalable_matrix, const float scale)
|
||||
{
|
||||
|
|
@ -420,6 +420,30 @@ inline void bgc_fp64_matrix3x2_subtract(BGC_FP64_Matrix3x2* difference, const BG
|
|||
difference->r2c3 = minuend->r2c3 - subtrahend->r2c3;
|
||||
}
|
||||
|
||||
// ============== Subtract Scaled =============== //
|
||||
|
||||
inline void bgc_fp32_matrix3x2_subtract_scaled(BGC_FP32_Matrix3x2* difference, const BGC_FP32_Matrix3x2* basic_matrix, const BGC_FP32_Matrix3x2* scalable_matrix, const float scale)
|
||||
{
|
||||
difference->r1c1 = basic_matrix->r1c1 - scalable_matrix->r1c1 * scale;
|
||||
difference->r1c2 = basic_matrix->r1c2 - scalable_matrix->r1c2 * scale;
|
||||
difference->r1c3 = basic_matrix->r1c3 - scalable_matrix->r1c3 * scale;
|
||||
|
||||
difference->r2c1 = basic_matrix->r2c1 - scalable_matrix->r2c1 * scale;
|
||||
difference->r2c2 = basic_matrix->r2c2 - scalable_matrix->r2c2 * scale;
|
||||
difference->r2c3 = basic_matrix->r2c3 - scalable_matrix->r2c3 * scale;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_matrix3x2_subtract_scaled(BGC_FP64_Matrix3x2* difference, const BGC_FP64_Matrix3x2* basic_matrix, const BGC_FP64_Matrix3x2* scalable_matrix, const double scale)
|
||||
{
|
||||
difference->r1c1 = basic_matrix->r1c1 - scalable_matrix->r1c1 * scale;
|
||||
difference->r1c2 = basic_matrix->r1c2 - scalable_matrix->r1c2 * scale;
|
||||
difference->r1c3 = basic_matrix->r1c3 - scalable_matrix->r1c3 * scale;
|
||||
|
||||
difference->r2c1 = basic_matrix->r2c1 - scalable_matrix->r2c1 * scale;
|
||||
difference->r2c2 = basic_matrix->r2c2 - scalable_matrix->r2c2 * scale;
|
||||
difference->r2c3 = basic_matrix->r2c3 - scalable_matrix->r2c3 * scale;
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_matrix3x2_multiply_by_real(BGC_FP32_Matrix3x2* product, const BGC_FP32_Matrix3x2* multiplicand, const float multiplier)
|
||||
|
|
|
|||
|
|
@ -60,6 +60,9 @@ extern inline void bgc_fp64_matrix3x3_add_scaled(BGC_FP64_Matrix3x3* sum, const
|
|||
extern inline void bgc_fp32_matrix3x3_subtract(BGC_FP32_Matrix3x3* difference, const BGC_FP32_Matrix3x3* minuend, const BGC_FP32_Matrix3x3* subtrahend);
|
||||
extern inline void bgc_fp64_matrix3x3_subtract(BGC_FP64_Matrix3x3* difference, const BGC_FP64_Matrix3x3* minuend, const BGC_FP64_Matrix3x3* subtrahend);
|
||||
|
||||
extern inline void bgc_fp32_matrix3x3_subtract_scaled(BGC_FP32_Matrix3x3* difference, const BGC_FP32_Matrix3x3* basic_matrix, const BGC_FP32_Matrix3x3* scalable_matrix, const float scale);
|
||||
extern inline void bgc_fp64_matrix3x3_subtract_scaled(BGC_FP64_Matrix3x3* difference, const BGC_FP64_Matrix3x3* basic_matrix, const BGC_FP64_Matrix3x3* scalable_matrix, const double scale);
|
||||
|
||||
extern inline void bgc_fp32_matrix3x3_multiply_by_real(BGC_FP32_Matrix3x3* product, const BGC_FP32_Matrix3x3* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_matrix3x3_multiply_by_real(BGC_FP64_Matrix3x3* product, const BGC_FP64_Matrix3x3* multiplicand, const double multiplier);
|
||||
|
||||
|
|
|
|||
|
|
@ -688,7 +688,7 @@ inline void bgc_fp64_matrix3x3_add(BGC_FP64_Matrix3x3* sum, const BGC_FP64_Matri
|
|||
sum->r3c3 = matrix1->r3c3 + matrix2->r3c3;
|
||||
}
|
||||
|
||||
// ================= Add scaled ================= //
|
||||
// ================= Add Scaled ================= //
|
||||
|
||||
inline void bgc_fp32_matrix3x3_add_scaled(BGC_FP32_Matrix3x3* sum, const BGC_FP32_Matrix3x3* basic_matrix, const BGC_FP32_Matrix3x3* scalable_matrix, const float scale)
|
||||
{
|
||||
|
|
@ -752,6 +752,38 @@ inline void bgc_fp64_matrix3x3_subtract(BGC_FP64_Matrix3x3* difference, const BG
|
|||
difference->r3c3 = minuend->r3c3 - subtrahend->r3c3;
|
||||
}
|
||||
|
||||
// ============== Subtract Scaled =============== //
|
||||
|
||||
inline void bgc_fp32_matrix3x3_subtract_scaled(BGC_FP32_Matrix3x3* difference, const BGC_FP32_Matrix3x3* basic_matrix, const BGC_FP32_Matrix3x3* scalable_matrix, const float scale)
|
||||
{
|
||||
difference->r1c1 = basic_matrix->r1c1 - scalable_matrix->r1c1 * scale;
|
||||
difference->r1c2 = basic_matrix->r1c2 - scalable_matrix->r1c2 * scale;
|
||||
difference->r1c3 = basic_matrix->r1c3 - scalable_matrix->r1c3 * scale;
|
||||
|
||||
difference->r2c1 = basic_matrix->r2c1 - scalable_matrix->r2c1 * scale;
|
||||
difference->r2c2 = basic_matrix->r2c2 - scalable_matrix->r2c2 * scale;
|
||||
difference->r2c3 = basic_matrix->r2c3 - scalable_matrix->r2c3 * scale;
|
||||
|
||||
difference->r3c1 = basic_matrix->r3c1 - scalable_matrix->r3c1 * scale;
|
||||
difference->r3c2 = basic_matrix->r3c2 - scalable_matrix->r3c2 * scale;
|
||||
difference->r3c3 = basic_matrix->r3c3 - scalable_matrix->r3c3 * scale;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_matrix3x3_subtract_scaled(BGC_FP64_Matrix3x3* difference, const BGC_FP64_Matrix3x3* basic_matrix, const BGC_FP64_Matrix3x3* scalable_matrix, const double scale)
|
||||
{
|
||||
difference->r1c1 = basic_matrix->r1c1 - scalable_matrix->r1c1 * scale;
|
||||
difference->r1c2 = basic_matrix->r1c2 - scalable_matrix->r1c2 * scale;
|
||||
difference->r1c3 = basic_matrix->r1c3 - scalable_matrix->r1c3 * scale;
|
||||
|
||||
difference->r2c1 = basic_matrix->r2c1 - scalable_matrix->r2c1 * scale;
|
||||
difference->r2c2 = basic_matrix->r2c2 - scalable_matrix->r2c2 * scale;
|
||||
difference->r2c3 = basic_matrix->r2c3 - scalable_matrix->r2c3 * scale;
|
||||
|
||||
difference->r3c1 = basic_matrix->r3c1 - scalable_matrix->r3c1 * scale;
|
||||
difference->r3c2 = basic_matrix->r3c2 - scalable_matrix->r3c2 * scale;
|
||||
difference->r3c3 = basic_matrix->r3c3 - scalable_matrix->r3c3 * scale;
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_matrix3x3_multiply_by_real(BGC_FP32_Matrix3x3* product, const BGC_FP32_Matrix3x3* multiplicand, const float multiplier)
|
||||
|
|
|
|||
|
|
@ -40,8 +40,11 @@ extern inline void bgc_fp64_quaternion_add_scaled(BGC_FP64_Quaternion* sum, cons
|
|||
extern inline void bgc_fp32_quaternion_subtract(BGC_FP32_Quaternion* difference, const BGC_FP32_Quaternion* minuend, const BGC_FP32_Quaternion* subtrahend);
|
||||
extern inline void bgc_fp64_quaternion_subtract(BGC_FP64_Quaternion* difference, const BGC_FP64_Quaternion* minuend, const BGC_FP64_Quaternion* subtrahend);
|
||||
|
||||
extern inline void bgc_fp32_quaternion_multiply_by_real(BGC_FP32_Quaternion* product, const BGC_FP32_Quaternion* multiplicand, const float multipier);
|
||||
extern inline void bgc_fp64_quaternion_multiply_by_real(BGC_FP64_Quaternion* product, const BGC_FP64_Quaternion* multiplicand, const double multipier);
|
||||
extern inline void bgc_fp32_quaternion_subtract_scaled(BGC_FP32_Quaternion* difference, const BGC_FP32_Quaternion* basic_quaternion, const BGC_FP32_Quaternion* scalable_quaternion, const float scale);
|
||||
extern inline void bgc_fp64_quaternion_subtract_scaled(BGC_FP64_Quaternion* difference, const BGC_FP64_Quaternion* basic_quaternion, const BGC_FP64_Quaternion* scalable_quaternion, const double scale);
|
||||
|
||||
extern inline void bgc_fp32_quaternion_multiply_by_real(BGC_FP32_Quaternion* product, const BGC_FP32_Quaternion* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_quaternion_multiply_by_real(BGC_FP64_Quaternion* product, const BGC_FP64_Quaternion* multiplicand, const double multiplier);
|
||||
|
||||
extern inline void bgc_fp32_quaternion_multiply_by_quaternion(BGC_FP32_Quaternion* product, const BGC_FP32_Quaternion* left, const BGC_FP32_Quaternion* right);
|
||||
extern inline void bgc_fp64_quaternion_multiply_by_quaternion(BGC_FP64_Quaternion* product, const BGC_FP64_Quaternion* left, const BGC_FP64_Quaternion* right);
|
||||
|
|
|
|||
|
|
@ -238,22 +238,40 @@ inline void bgc_fp64_quaternion_subtract(BGC_FP64_Quaternion* difference, const
|
|||
difference->x3 = minuend->x3 - subtrahend->x3;
|
||||
}
|
||||
|
||||
// ============= Multiply By Number ============= //
|
||||
// ============== Subtract Scaled =============== //
|
||||
|
||||
inline void bgc_fp32_quaternion_multiply_by_real(BGC_FP32_Quaternion* product, const BGC_FP32_Quaternion* multiplicand, const float multipier)
|
||||
inline void bgc_fp32_quaternion_subtract_scaled(BGC_FP32_Quaternion* difference, const BGC_FP32_Quaternion* basic_quaternion, const BGC_FP32_Quaternion* scalable_quaternion, const float scale)
|
||||
{
|
||||
product->s0 = multiplicand->s0 * multipier;
|
||||
product->x1 = multiplicand->x1 * multipier;
|
||||
product->x2 = multiplicand->x2 * multipier;
|
||||
product->x3 = multiplicand->x3 * multipier;
|
||||
difference->s0 = basic_quaternion->s0 - scalable_quaternion->s0 * scale;
|
||||
difference->x1 = basic_quaternion->x1 - scalable_quaternion->x1 * scale;
|
||||
difference->x2 = basic_quaternion->x2 - scalable_quaternion->x2 * scale;
|
||||
difference->x3 = basic_quaternion->x3 - scalable_quaternion->x3 * scale;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_quaternion_multiply_by_real(BGC_FP64_Quaternion* product, const BGC_FP64_Quaternion* multiplicand, const double multipier)
|
||||
inline void bgc_fp64_quaternion_subtract_scaled(BGC_FP64_Quaternion* difference, const BGC_FP64_Quaternion* basic_quaternion, const BGC_FP64_Quaternion* scalable_quaternion, const double scale)
|
||||
{
|
||||
product->s0 = multiplicand->s0 * multipier;
|
||||
product->x1 = multiplicand->x1 * multipier;
|
||||
product->x2 = multiplicand->x2 * multipier;
|
||||
product->x3 = multiplicand->x3 * multipier;
|
||||
difference->s0 = basic_quaternion->s0 - scalable_quaternion->s0 * scale;
|
||||
difference->x1 = basic_quaternion->x1 - scalable_quaternion->x1 * scale;
|
||||
difference->x2 = basic_quaternion->x2 - scalable_quaternion->x2 * scale;
|
||||
difference->x3 = basic_quaternion->x3 - scalable_quaternion->x3 * scale;
|
||||
}
|
||||
|
||||
// ============= Multiply By Number ============= //
|
||||
|
||||
inline void bgc_fp32_quaternion_multiply_by_real(BGC_FP32_Quaternion* product, const BGC_FP32_Quaternion* multiplicand, const float multiplier)
|
||||
{
|
||||
product->s0 = multiplicand->s0 * multiplier;
|
||||
product->x1 = multiplicand->x1 * multiplier;
|
||||
product->x2 = multiplicand->x2 * multiplier;
|
||||
product->x3 = multiplicand->x3 * multiplier;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_quaternion_multiply_by_real(BGC_FP64_Quaternion* product, const BGC_FP64_Quaternion* multiplicand, const double multiplier)
|
||||
{
|
||||
product->s0 = multiplicand->s0 * multiplier;
|
||||
product->x1 = multiplicand->x1 * multiplier;
|
||||
product->x2 = multiplicand->x2 * multiplier;
|
||||
product->x3 = multiplicand->x3 * multiplier;
|
||||
}
|
||||
|
||||
// =========== Multiply By Quaternion =========== //
|
||||
|
|
|
|||
|
|
@ -181,15 +181,15 @@ typedef struct {
|
|||
BGC_FP64_Vector3 shift;
|
||||
} BGC_FP64_Position3;
|
||||
|
||||
// ================ Dual Scalar ================= //
|
||||
// ================ Dual Number ================= //
|
||||
|
||||
typedef struct {
|
||||
float real_part, dual_part;
|
||||
} BGC_FP32_DualScalar;
|
||||
} BGC_FP32_DualNumber;
|
||||
|
||||
typedef struct {
|
||||
double real_part, dual_part;
|
||||
} BGC_FP64_DualScalar;
|
||||
} BGC_FP64_DualNumber;
|
||||
|
||||
// ================ Dual Vector ================= //
|
||||
|
||||
|
|
|
|||
|
|
@ -36,6 +36,9 @@ extern inline void bgc_fp64_vector2_add_scaled(BGC_FP64_Vector2* sum, const BGC_
|
|||
extern inline void bgc_fp32_vector2_subtract(BGC_FP32_Vector2* difference, const BGC_FP32_Vector2* minuend, const BGC_FP32_Vector2* subtrahend);
|
||||
extern inline void bgc_fp64_vector2_subtract(BGC_FP64_Vector2* difference, const BGC_FP64_Vector2* minuend, const BGC_FP64_Vector2* subtrahend);
|
||||
|
||||
extern inline void bgc_fp32_vector2_subtract_scaled(BGC_FP32_Vector2* difference, const BGC_FP32_Vector2* basic_vector, const BGC_FP32_Vector2* scalable_vector, const float scale);
|
||||
extern inline void bgc_fp64_vector2_subtract_scaled(BGC_FP64_Vector2* difference, const BGC_FP64_Vector2* basic_vector, const BGC_FP64_Vector2* scalable_vector, const double scale);
|
||||
|
||||
extern inline void bgc_fp32_vector2_multiply_by_real(BGC_FP32_Vector2* product, const BGC_FP32_Vector2* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_vector2_multiply_by_real(BGC_FP64_Vector2* product, const BGC_FP64_Vector2* multiplicand, const double multiplier);
|
||||
|
||||
|
|
|
|||
|
|
@ -147,7 +147,7 @@ inline void bgc_fp64_vector2_add(BGC_FP64_Vector2* sum, const BGC_FP64_Vector2*
|
|||
sum->x2 = vector1->x2 + vector2->x2;
|
||||
}
|
||||
|
||||
// ================= Add scaled ================= //
|
||||
// ================= Add Scaled ================= //
|
||||
|
||||
inline void bgc_fp32_vector2_add_scaled(BGC_FP32_Vector2* sum, const BGC_FP32_Vector2* basic_vector, const BGC_FP32_Vector2* scalable_vector, const float scale)
|
||||
{
|
||||
|
|
@ -175,6 +175,20 @@ inline void bgc_fp64_vector2_subtract(BGC_FP64_Vector2* difference, const BGC_FP
|
|||
difference->x2 = minuend->x2 - subtrahend->x2;
|
||||
}
|
||||
|
||||
// ============== Subtract Scaled =============== //
|
||||
|
||||
inline void bgc_fp32_vector2_subtract_scaled(BGC_FP32_Vector2* difference, const BGC_FP32_Vector2* basic_vector, const BGC_FP32_Vector2* scalable_vector, const float scale)
|
||||
{
|
||||
difference->x1 = basic_vector->x1 - scalable_vector->x1 * scale;
|
||||
difference->x2 = basic_vector->x2 - scalable_vector->x2 * scale;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_vector2_subtract_scaled(BGC_FP64_Vector2* difference, const BGC_FP64_Vector2* basic_vector, const BGC_FP64_Vector2* scalable_vector, const double scale)
|
||||
{
|
||||
difference->x1 = basic_vector->x1 - scalable_vector->x1 * scale;
|
||||
difference->x2 = basic_vector->x2 - scalable_vector->x2 * scale;
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_vector2_multiply_by_real(BGC_FP32_Vector2* product, const BGC_FP32_Vector2* multiplicand, const float multiplier)
|
||||
|
|
|
|||
|
|
@ -36,6 +36,9 @@ extern inline void bgc_fp64_vector3_add_scaled(BGC_FP64_Vector3* sum, const BGC_
|
|||
extern inline void bgc_fp32_vector3_subtract(BGC_FP32_Vector3* difference, const BGC_FP32_Vector3* minuend, const BGC_FP32_Vector3* subtrahend);
|
||||
extern inline void bgc_fp64_vector3_subtract(BGC_FP64_Vector3* difference, const BGC_FP64_Vector3* minuend, const BGC_FP64_Vector3* subtrahend);
|
||||
|
||||
extern inline void bgc_fp32_vector3_subtract_scaled(BGC_FP32_Vector3* difference, const BGC_FP32_Vector3* basic_vector, const BGC_FP32_Vector3* scalable_vector, const float scale);
|
||||
extern inline void bgc_fp64_vector3_subtract_scaled(BGC_FP64_Vector3* difference, const BGC_FP64_Vector3* basic_vector, const BGC_FP64_Vector3* scalable_vector, const double scale);
|
||||
|
||||
extern inline void bgc_fp32_vector3_multiply_by_real(BGC_FP32_Vector3* product, const BGC_FP32_Vector3* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_vector3_multiply_by_real(BGC_FP64_Vector3* product, const BGC_FP64_Vector3* multiplicand, const double multiplier);
|
||||
|
||||
|
|
|
|||
|
|
@ -195,6 +195,22 @@ inline void bgc_fp64_vector3_subtract(BGC_FP64_Vector3* difference, const BGC_FP
|
|||
difference->x3 = minuend->x3 - subtrahend->x3;
|
||||
}
|
||||
|
||||
// ============== Subtract Scaled =============== //
|
||||
|
||||
inline void bgc_fp32_vector3_subtract_scaled(BGC_FP32_Vector3* difference, const BGC_FP32_Vector3* basic_vector, const BGC_FP32_Vector3* scalable_vector, const float scale)
|
||||
{
|
||||
difference->x1 = basic_vector->x1 - scalable_vector->x1 * scale;
|
||||
difference->x2 = basic_vector->x2 - scalable_vector->x2 * scale;
|
||||
difference->x3 = basic_vector->x3 - scalable_vector->x3 * scale;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_vector3_subtract_scaled(BGC_FP64_Vector3* difference, const BGC_FP64_Vector3* basic_vector, const BGC_FP64_Vector3* scalable_vector, const double scale)
|
||||
{
|
||||
difference->x1 = basic_vector->x1 - scalable_vector->x1 * scale;
|
||||
difference->x2 = basic_vector->x2 - scalable_vector->x2 * scale;
|
||||
difference->x3 = basic_vector->x3 - scalable_vector->x3 * scale;
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_vector3_multiply_by_real(BGC_FP32_Vector3* product, const BGC_FP32_Vector3* multiplicand, const float multiplier)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue