Развитие SLERP для трёхмерных пространств, а также развитие дуальных чисел, векторов и кватернионов
This commit is contained in:
parent
053af33444
commit
86ea23de7d
23 changed files with 1063 additions and 830 deletions
|
|
@ -60,30 +60,26 @@
|
|||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="complex.h" />
|
||||
<Unit filename="dual-number.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="dual-number.h" />
|
||||
<Unit filename="dual-quaternion.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="dual-quaternion.h" />
|
||||
<Unit filename="dual-scalar.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="dual-scalar.h" />
|
||||
<Unit filename="dual-vector3.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="dual-vector3.h" />
|
||||
<Unit filename="hg-matrix3x3.c">
|
||||
<Unit filename="hmg-matrix3x3.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="hg-matrix3x3.h" />
|
||||
<Unit filename="hg-vector3.c">
|
||||
<Unit filename="hmg-matrix3x3.h" />
|
||||
<Unit filename="hmg-vector3.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="hg-vector3.h" />
|
||||
<Unit filename="matrices.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="matrices.h" />
|
||||
<Unit filename="hmg-vector3.h" />
|
||||
<Unit filename="matrix2x2.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
|
|
@ -112,10 +108,10 @@
|
|||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="quaternion.h" />
|
||||
<Unit filename="slerp.c">
|
||||
<Unit filename="slerp3.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="slerp.h" />
|
||||
<Unit filename="slerp3.h" />
|
||||
<Unit filename="turn2.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
|
|
@ -124,6 +120,7 @@
|
|||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="turn3.h" />
|
||||
<Unit filename="types.h" />
|
||||
<Unit filename="utilities.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
|
|
|
|||
|
|
@ -24,9 +24,9 @@
|
|||
#include "./turn2.h"
|
||||
#include "./turn3.h"
|
||||
|
||||
#include "./slerp3.h"
|
||||
|
||||
#include "./position2.h"
|
||||
#include "./position3.h"
|
||||
|
||||
#include "./slerp.h"
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -24,11 +24,11 @@
|
|||
<ClInclude Include="angle.h" />
|
||||
<ClInclude Include="basic-geometry.h" />
|
||||
<ClInclude Include="complex.h" />
|
||||
<ClInclude Include="dual-number.h" />
|
||||
<ClInclude Include="dual-scalar.h" />
|
||||
<ClInclude Include="dual-quaternion.h" />
|
||||
<ClInclude Include="dual-vector3.h" />
|
||||
<ClInclude Include="hg-matrix3x3.h" />
|
||||
<ClInclude Include="hg-vector3.h" />
|
||||
<ClInclude Include="hmg-matrix3x3.h" />
|
||||
<ClInclude Include="hmg-vector3.h" />
|
||||
<ClInclude Include="matrix2x2.h" />
|
||||
<ClInclude Include="matrix2x3.h" />
|
||||
<ClInclude Include="matrix3x2.h" />
|
||||
|
|
@ -40,7 +40,7 @@
|
|||
<ClInclude Include="turn2.h" />
|
||||
<ClInclude Include="turn3.h" />
|
||||
<ClInclude Include="utilities.h" />
|
||||
<ClInclude Include="slerp.h" />
|
||||
<ClInclude Include="slerp3.h" />
|
||||
<ClInclude Include="vector2.h" />
|
||||
<ClInclude Include="vector3.h" />
|
||||
</ItemGroup>
|
||||
|
|
@ -49,11 +49,11 @@
|
|||
<ClCompile Include="affine3.c" />
|
||||
<ClCompile Include="angle.c" />
|
||||
<ClInclude Include="complex.c" />
|
||||
<ClCompile Include="dual-number.c" />
|
||||
<ClCompile Include="dual-scalar.c" />
|
||||
<ClCompile Include="dual-quaternion.c" />
|
||||
<ClCompile Include="dual-vector3.c" />
|
||||
<ClCompile Include="hg-matrix3x3.c" />
|
||||
<ClCompile Include="hg-vector3.c" />
|
||||
<ClCompile Include="hmg-matrix3x3.c" />
|
||||
<ClCompile Include="hmg-vector3.c" />
|
||||
<ClCompile Include="position2.c" />
|
||||
<ClCompile Include="position3.c" />
|
||||
<ClCompile Include="turn2.c" />
|
||||
|
|
@ -64,7 +64,7 @@
|
|||
<ClCompile Include="matrix3x2.c" />
|
||||
<ClCompile Include="matrix3x3.c" />
|
||||
<ClCompile Include="quaternion.c" />
|
||||
<ClCompile Include="slerp.c" />
|
||||
<ClCompile Include="slerp3.c" />
|
||||
<ClCompile Include="vector2.c" />
|
||||
<ClCompile Include="vector3.c" />
|
||||
</ItemGroup>
|
||||
|
|
|
|||
|
|
@ -1,55 +0,0 @@
|
|||
#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, const float dual);
|
||||
extern inline void bgc_fp64_dual_number_make(BGC_FP64_DualNumber* number, const double real, const double dual);
|
||||
|
||||
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_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_number_get_reverse(BGC_FP32_DualNumber* reverse, const BGC_FP32_DualNumber* number);
|
||||
extern inline void bgc_fp64_number_get_reverse(BGC_FP64_DualNumber* reverse, 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_multiply_by_real_number(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_dual_number_multiply_by_real_number(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* multiplicand, const double multiplier);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_multiply_by_dual_number(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second);
|
||||
extern inline void bgc_fp64_dual_number_multiply_by_dual_number(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_divide_by_real_number(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const float divisor);
|
||||
extern inline void bgc_fp64_dual_number_divide_by_real_number(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const double divisor);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_divide_by_dual_number(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const BGC_FP32_DualNumber* divisor);
|
||||
extern inline void bgc_fp64_dual_number_divide_by_dual_number(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const BGC_FP64_DualNumber* divisor);
|
||||
|
||||
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);
|
||||
|
|
@ -1,273 +0,0 @@
|
|||
#ifndef _BGC_DUAL_NUMBER_H_INCLUDED_
|
||||
#define _BGC_DUAL_NUMBER_H_INCLUDED_
|
||||
|
||||
#include "./utilities.h"
|
||||
#include "./types.h"
|
||||
|
||||
// =================== Reset ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_reset(BGC_FP32_DualNumber* number)
|
||||
{
|
||||
number->real = 0.0f;
|
||||
number->dual = 0.0f;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_reset(BGC_FP64_DualNumber* number)
|
||||
{
|
||||
number->real = 0.0;
|
||||
number->dual = 0.0;
|
||||
}
|
||||
|
||||
// ==================== Make ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_make(BGC_FP32_DualNumber* number, const float real, const float dual)
|
||||
{
|
||||
number->real = real;
|
||||
number->dual = dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_make(BGC_FP64_DualNumber* number, const double real, const double dual)
|
||||
{
|
||||
number->real = real;
|
||||
number->dual = dual;
|
||||
}
|
||||
|
||||
// ==================== Copy ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_copy(BGC_FP32_DualNumber* destination, const BGC_FP32_DualNumber* source)
|
||||
{
|
||||
destination->real = source->real;
|
||||
destination->dual = source->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_copy(BGC_FP64_DualNumber* destination, const BGC_FP64_DualNumber* source)
|
||||
{
|
||||
destination->real = source->real;
|
||||
destination->dual = source->dual;
|
||||
}
|
||||
|
||||
// ==================== Swap ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_swap(BGC_FP32_DualNumber* first, BGC_FP32_DualNumber* second)
|
||||
{
|
||||
first->real = second->real;
|
||||
first->dual = second->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_swap(BGC_FP64_DualNumber* first, BGC_FP64_DualNumber* second)
|
||||
{
|
||||
first->real = second->real;
|
||||
first->dual = second->dual;
|
||||
}
|
||||
|
||||
// ================== Convert =================== //
|
||||
|
||||
inline void bgc_fp64_dual_number_convert_to_fp32(BGC_FP32_DualNumber* first, BGC_FP64_DualNumber* second)
|
||||
{
|
||||
first->real = (float) second->real;
|
||||
first->dual = (float) second->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp32_dual_number_convert_to_fp64(BGC_FP64_DualNumber* first, BGC_FP32_DualNumber* second)
|
||||
{
|
||||
first->real = second->real;
|
||||
first->dual = second->dual;
|
||||
}
|
||||
|
||||
// =================== Revert =================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_revert(BGC_FP32_DualNumber* number)
|
||||
{
|
||||
number->real = -number->real;
|
||||
number->dual = -number->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_revert(BGC_FP64_DualNumber* number)
|
||||
{
|
||||
number->real = -number->real;
|
||||
number->dual = -number->dual;
|
||||
}
|
||||
|
||||
// ================ Get Reverse ================= //
|
||||
|
||||
inline void bgc_fp32_number_get_reverse(BGC_FP32_DualNumber* reverse, const BGC_FP32_DualNumber* number)
|
||||
{
|
||||
reverse->real = -number->real;
|
||||
reverse->dual = -number->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_number_get_reverse(BGC_FP64_DualNumber* reverse, const BGC_FP64_DualNumber* number)
|
||||
{
|
||||
reverse->real = -number->real;
|
||||
reverse->dual = -number->dual;
|
||||
}
|
||||
|
||||
// ================= Conjugate ================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_conjugate(BGC_FP32_DualNumber* number)
|
||||
{
|
||||
number->dual = -number->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_conjugate(BGC_FP64_DualNumber* number)
|
||||
{
|
||||
number->dual = -number->dual;
|
||||
}
|
||||
|
||||
// =============== Get Conjugate ================ //
|
||||
|
||||
inline void bgc_fp32_dual_number_get_conjugate(BGC_FP32_DualNumber* conjugate, const BGC_FP32_DualNumber* number)
|
||||
{
|
||||
conjugate->real = number->real;
|
||||
conjugate->dual = -number->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_get_conjugate(BGC_FP64_DualNumber* conjugate, const BGC_FP64_DualNumber* number)
|
||||
{
|
||||
conjugate->real = number->real;
|
||||
conjugate->dual = -number->dual;
|
||||
}
|
||||
|
||||
// ==================== Add ===================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_add(BGC_FP32_DualNumber* sum, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second)
|
||||
{
|
||||
sum->real = first->real + second->real;
|
||||
sum->dual = first->dual + second->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_add(BGC_FP64_DualNumber* sum, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second)
|
||||
{
|
||||
sum->real = first->real + second->real;
|
||||
sum->dual = first->dual + second->dual;
|
||||
}
|
||||
|
||||
// ================= Add Scaled ================= //
|
||||
|
||||
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 = base_number->real + scalable_number->real * scale;
|
||||
sum->dual = base_number->dual + scalable_number->dual * 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 = base_number->real + scalable_number->real * scale;
|
||||
sum->dual = base_number->dual + scalable_number->dual * scale;
|
||||
}
|
||||
|
||||
// ================== Subtract ================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_subtract(BGC_FP32_DualNumber* difference, const BGC_FP32_DualNumber* minuend, const BGC_FP32_DualNumber* subtrahend)
|
||||
{
|
||||
difference->real = minuend->real - subtrahend->real;
|
||||
difference->dual = minuend->dual - subtrahend->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_subtract(BGC_FP64_DualNumber* difference, const BGC_FP64_DualNumber* minuend, const BGC_FP64_DualNumber* subtrahend)
|
||||
{
|
||||
difference->real = minuend->real - subtrahend->real;
|
||||
difference->dual = minuend->dual - subtrahend->dual;
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_multiply_by_real_number(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* multiplicand, const float multiplier)
|
||||
{
|
||||
product->real = multiplicand->real * multiplier;
|
||||
product->dual = multiplicand->dual * multiplier;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_multiply_by_real_number(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* multiplicand, const double multiplier)
|
||||
{
|
||||
product->real = multiplicand->real * multiplier;
|
||||
product->dual = multiplicand->dual * multiplier;
|
||||
}
|
||||
|
||||
inline void bgc_fp32_dual_number_multiply_by_dual_number(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second)
|
||||
{
|
||||
product->real = first->real * second->real;
|
||||
product->dual = first->dual * second->real + first->real * second->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_multiply_by_dual_number(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second)
|
||||
{
|
||||
product->real = first->real * second->real;
|
||||
product->dual = first->dual * second->real + first->real * second->dual;
|
||||
}
|
||||
|
||||
// =================== Divide =================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_divide_by_real_number(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const float divisor)
|
||||
{
|
||||
bgc_fp32_dual_number_multiply_by_real_number(quotient, dividend, 1.0f / divisor);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_divide_by_real_number(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const double divisor)
|
||||
{
|
||||
bgc_fp64_dual_number_multiply_by_real_number(quotient, dividend, 1.0 / divisor);
|
||||
}
|
||||
|
||||
inline void bgc_fp32_dual_number_divide_by_dual_number(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const BGC_FP32_DualNumber* divisor)
|
||||
{
|
||||
const float mutliplier_real = 1 / divisor->real;
|
||||
|
||||
quotient->real = dividend->real * mutliplier_real;
|
||||
quotient->dual = dividend->dual * mutliplier_real - dividend->real * divisor->dual / (divisor->real * divisor->real);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_divide_by_dual_number(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const BGC_FP64_DualNumber* divisor)
|
||||
{
|
||||
const double mutliplier_real = 1 / divisor->real;
|
||||
|
||||
quotient->real = dividend->real * mutliplier_real;
|
||||
quotient->dual = dividend->dual * mutliplier_real - dividend->real * divisor->dual / (divisor->real * divisor->real);
|
||||
}
|
||||
|
||||
// ================ Mean of Two ================= //
|
||||
|
||||
inline void bgc_fp32_dual_number_get_mean2(BGC_FP32_DualNumber* mean, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second)
|
||||
{
|
||||
mean->real = (first->real + second->real) * 0.5f;
|
||||
mean->dual = (first->dual + second->dual) * 0.5f;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_get_mean2(BGC_FP64_DualNumber* mean, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second)
|
||||
{
|
||||
mean->real = (first->real + second->real) * 0.5;
|
||||
mean->dual = (first->dual + second->dual) * 0.5;
|
||||
}
|
||||
|
||||
// =============== Mean of Three ================ //
|
||||
|
||||
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 = (first->real + second->real + third->real) * BGC_FP32_ONE_THIRD;
|
||||
mean->dual = (first->dual + second->dual + third->dual) * BGC_FP32_ONE_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 = (first->real + second->real + third->real) * BGC_FP64_ONE_THIRD;
|
||||
mean->dual = (first->dual + second->dual + third->dual) * BGC_FP64_ONE_THIRD;
|
||||
}
|
||||
|
||||
// ============ Linear Interpolation ============ //
|
||||
|
||||
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;
|
||||
|
||||
interpolation->real = first->real *counter_phase + second->real * phase;
|
||||
interpolation->dual = first->dual *counter_phase + second->dual * 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;
|
||||
|
||||
interpolation->real = first->real * counter_phase + second->real * phase;
|
||||
interpolation->dual = first->dual * counter_phase + second->dual * phase;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -8,112 +8,112 @@
|
|||
|
||||
inline void bgc_fp32_dual_quaternion_reset(BGC_FP32_DualQuaternion* quaternion)
|
||||
{
|
||||
bgc_fp32_quaternion_reset(&quaternion->real);
|
||||
bgc_fp32_quaternion_reset(&quaternion->dual);
|
||||
bgc_fp32_quaternion_reset(&quaternion->real_part);
|
||||
bgc_fp32_quaternion_reset(&quaternion->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_reset(BGC_FP64_DualQuaternion* quaternion)
|
||||
{
|
||||
bgc_fp64_quaternion_reset(&quaternion->real);
|
||||
bgc_fp64_quaternion_reset(&quaternion->dual);
|
||||
bgc_fp64_quaternion_reset(&quaternion->real_part);
|
||||
bgc_fp64_quaternion_reset(&quaternion->dual_part);
|
||||
}
|
||||
|
||||
// ==================== Copy ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_copy(BGC_FP32_DualQuaternion* destination, const BGC_FP32_DualQuaternion* source)
|
||||
{
|
||||
bgc_fp32_quaternion_copy(&destination->real, &source->real);
|
||||
bgc_fp32_quaternion_copy(&destination->dual, &source->dual);
|
||||
bgc_fp32_quaternion_copy(&destination->real_part, &source->real_part);
|
||||
bgc_fp32_quaternion_copy(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_copy(BGC_FP64_DualQuaternion* destination, const BGC_FP64_DualQuaternion* source)
|
||||
{
|
||||
bgc_fp64_quaternion_copy(&destination->real, &source->real);
|
||||
bgc_fp64_quaternion_copy(&destination->dual, &source->dual);
|
||||
bgc_fp64_quaternion_copy(&destination->real_part, &source->real_part);
|
||||
bgc_fp64_quaternion_copy(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
// ==================== Swap ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_swap(BGC_FP32_DualQuaternion* first, BGC_FP32_DualQuaternion* second)
|
||||
{
|
||||
bgc_fp32_quaternion_swap(&first->real, &second->real);
|
||||
bgc_fp32_quaternion_swap(&first->dual, &second->dual);
|
||||
bgc_fp32_quaternion_swap(&first->real_part, &second->real_part);
|
||||
bgc_fp32_quaternion_swap(&first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_swap(BGC_FP64_DualQuaternion* first, BGC_FP64_DualQuaternion* second)
|
||||
{
|
||||
bgc_fp64_quaternion_swap(&first->real, &second->real);
|
||||
bgc_fp64_quaternion_swap(&first->dual, &second->dual);
|
||||
bgc_fp64_quaternion_swap(&first->real_part, &second->real_part);
|
||||
bgc_fp64_quaternion_swap(&first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
// ================== Convert =================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_convert_to_fp64(BGC_FP64_DualQuaternion* destination, const BGC_FP32_DualQuaternion* source)
|
||||
{
|
||||
bgc_fp32_quaternion_convert_to_fp64(&destination->real, &source->real);
|
||||
bgc_fp32_quaternion_convert_to_fp64(&destination->dual, &source->dual);
|
||||
bgc_fp32_quaternion_convert_to_fp64(&destination->real_part, &source->real_part);
|
||||
bgc_fp32_quaternion_convert_to_fp64(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_convert_to_fp32(BGC_FP32_DualQuaternion* destination, const BGC_FP64_DualQuaternion* source)
|
||||
{
|
||||
bgc_fp64_quaternion_convert_to_fp32(&destination->real, &source->real);
|
||||
bgc_fp64_quaternion_convert_to_fp32(&destination->dual, &source->dual);
|
||||
bgc_fp64_quaternion_convert_to_fp32(&destination->real_part, &source->real_part);
|
||||
bgc_fp64_quaternion_convert_to_fp32(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
// ==================== Add ===================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_add(BGC_FP32_DualQuaternion* sum, const BGC_FP32_DualQuaternion* first, const BGC_FP32_DualQuaternion* second)
|
||||
{
|
||||
bgc_fp32_quaternion_add(&sum->real, &first->real, &second->real);
|
||||
bgc_fp32_quaternion_add(&sum->dual, &first->dual, &second->dual);
|
||||
bgc_fp32_quaternion_add(&sum->real_part, &first->real_part, &second->real_part);
|
||||
bgc_fp32_quaternion_add(&sum->dual_part, &first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_add(BGC_FP64_DualQuaternion* sum, const BGC_FP64_DualQuaternion* first, const BGC_FP64_DualQuaternion* second)
|
||||
{
|
||||
bgc_fp64_quaternion_add(&sum->real, &first->real, &second->real);
|
||||
bgc_fp64_quaternion_add(&sum->dual, &first->dual, &second->dual);
|
||||
bgc_fp64_quaternion_add(&sum->real_part, &first->real_part, &second->real_part);
|
||||
bgc_fp64_quaternion_add(&sum->dual_part, &first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
// ================= Add Scaled ================= //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_add_scaled(BGC_FP32_DualQuaternion* sum, const BGC_FP32_DualQuaternion* base_quaternion, const BGC_FP32_DualQuaternion* scalable_quaternion, const float scale)
|
||||
{
|
||||
bgc_fp32_quaternion_add_scaled(&sum->real, &base_quaternion->real, &scalable_quaternion->real, scale);
|
||||
bgc_fp32_quaternion_add_scaled(&sum->dual, &base_quaternion->dual, &scalable_quaternion->dual, scale);
|
||||
bgc_fp32_quaternion_add_scaled(&sum->real_part, &base_quaternion->real_part, &scalable_quaternion->real_part, scale);
|
||||
bgc_fp32_quaternion_add_scaled(&sum->dual_part, &base_quaternion->dual_part, &scalable_quaternion->dual_part, scale);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_add_scaled(BGC_FP64_DualQuaternion* sum, const BGC_FP64_DualQuaternion* base_quaternion, const BGC_FP64_DualQuaternion* scalable_quaternion, const double scale)
|
||||
{
|
||||
bgc_fp64_quaternion_add_scaled(&sum->real, &base_quaternion->real, &scalable_quaternion->real, scale);
|
||||
bgc_fp64_quaternion_add_scaled(&sum->dual, &base_quaternion->dual, &scalable_quaternion->dual, scale);
|
||||
bgc_fp64_quaternion_add_scaled(&sum->real_part, &base_quaternion->real_part, &scalable_quaternion->real_part, scale);
|
||||
bgc_fp64_quaternion_add_scaled(&sum->dual_part, &base_quaternion->dual_part, &scalable_quaternion->dual_part, scale);
|
||||
}
|
||||
|
||||
// ================== Subtract ================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_subtract(BGC_FP32_DualQuaternion* difference, const BGC_FP32_DualQuaternion* minuend, const BGC_FP32_DualQuaternion* subtrahend)
|
||||
{
|
||||
bgc_fp32_quaternion_subtract(&difference->real, &minuend->real, &subtrahend->real);
|
||||
bgc_fp32_quaternion_subtract(&difference->dual, &minuend->dual, &subtrahend->dual);
|
||||
bgc_fp32_quaternion_subtract(&difference->real_part, &minuend->real_part, &subtrahend->real_part);
|
||||
bgc_fp32_quaternion_subtract(&difference->dual_part, &minuend->dual_part, &subtrahend->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_subtract(BGC_FP64_DualQuaternion* difference, const BGC_FP64_DualQuaternion* minuend, const BGC_FP64_DualQuaternion* subtrahend)
|
||||
{
|
||||
bgc_fp64_quaternion_subtract(&difference->real, &minuend->real, &subtrahend->real);
|
||||
bgc_fp64_quaternion_subtract(&difference->dual, &minuend->dual, &subtrahend->dual);
|
||||
bgc_fp64_quaternion_subtract(&difference->real_part, &minuend->real_part, &subtrahend->real_part);
|
||||
bgc_fp64_quaternion_subtract(&difference->dual_part, &minuend->dual_part, &subtrahend->dual_part);
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multipier)
|
||||
{
|
||||
bgc_fp32_quaternion_multiply_by_real(&product->real, &multiplicand->real, multipier);
|
||||
bgc_fp32_quaternion_multiply_by_real(&product->dual, &multiplicand->dual, multipier);
|
||||
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);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_multiply_by_real(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const double multipier)
|
||||
{
|
||||
bgc_fp64_quaternion_multiply_by_real(&product->real, &multiplicand->real, multipier);
|
||||
bgc_fp64_quaternion_multiply_by_real(&product->dual, &multiplicand->dual, multipier);
|
||||
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);
|
||||
}
|
||||
|
||||
// =================== Divide =================== //
|
||||
|
|
@ -132,70 +132,70 @@ inline void bgc_fp64_dual_quaternion_divide_by_real(BGC_FP64_DualQuaternion* quo
|
|||
|
||||
inline void bgc_fp32_dual_quaternion_get_mean2(BGC_FP32_DualQuaternion* mean, const BGC_FP32_DualQuaternion* quaternion1, const BGC_FP32_DualQuaternion* quaternion2)
|
||||
{
|
||||
bgc_fp32_quaternion_get_mean2(&mean->real, &quaternion1->real, &quaternion2->real);
|
||||
bgc_fp32_quaternion_get_mean2(&mean->dual, &quaternion1->dual, &quaternion2->dual);
|
||||
bgc_fp32_quaternion_get_mean2(&mean->real_part, &quaternion1->real_part, &quaternion2->real_part);
|
||||
bgc_fp32_quaternion_get_mean2(&mean->dual_part, &quaternion1->dual_part, &quaternion2->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_get_mean2(BGC_FP64_DualQuaternion* mean, const BGC_FP64_DualQuaternion* quaternion1, const BGC_FP64_DualQuaternion* quaternion2)
|
||||
{
|
||||
bgc_fp64_quaternion_get_mean2(&mean->real, &quaternion1->real, &quaternion2->real);
|
||||
bgc_fp64_quaternion_get_mean2(&mean->dual, &quaternion1->dual, &quaternion2->dual);
|
||||
bgc_fp64_quaternion_get_mean2(&mean->real_part, &quaternion1->real_part, &quaternion2->real_part);
|
||||
bgc_fp64_quaternion_get_mean2(&mean->dual_part, &quaternion1->dual_part, &quaternion2->dual_part);
|
||||
}
|
||||
|
||||
// =============== Mean of Three ================ //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_get_mean3(BGC_FP32_DualQuaternion* mean, const BGC_FP32_DualQuaternion* quaternion1, const BGC_FP32_DualQuaternion* quaternion2, const BGC_FP32_DualQuaternion* quaternion3)
|
||||
{
|
||||
bgc_fp32_quaternion_get_mean3(&mean->real, &quaternion1->real, &quaternion2->real, &quaternion3->real);
|
||||
bgc_fp32_quaternion_get_mean3(&mean->dual, &quaternion1->dual, &quaternion2->dual, &quaternion3->dual);
|
||||
bgc_fp32_quaternion_get_mean3(&mean->real_part, &quaternion1->real_part, &quaternion2->real_part, &quaternion3->real_part);
|
||||
bgc_fp32_quaternion_get_mean3(&mean->dual_part, &quaternion1->dual_part, &quaternion2->dual_part, &quaternion3->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_get_mean3(BGC_FP64_DualQuaternion* mean, const BGC_FP64_DualQuaternion* quaternion1, const BGC_FP64_DualQuaternion* quaternion2, const BGC_FP64_DualQuaternion* quaternion3)
|
||||
{
|
||||
bgc_fp64_quaternion_get_mean3(&mean->real, &quaternion1->real, &quaternion2->real, &quaternion3->real);
|
||||
bgc_fp64_quaternion_get_mean3(&mean->dual, &quaternion1->dual, &quaternion2->dual, &quaternion3->dual);
|
||||
bgc_fp64_quaternion_get_mean3(&mean->real_part, &quaternion1->real_part, &quaternion2->real_part, &quaternion3->real_part);
|
||||
bgc_fp64_quaternion_get_mean3(&mean->dual_part, &quaternion1->dual_part, &quaternion2->dual_part, &quaternion3->dual_part);
|
||||
}
|
||||
|
||||
// ============ Linear Interpolation ============ //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_interpolate(BGC_FP32_DualQuaternion* interpolation, const BGC_FP32_DualQuaternion* first, const BGC_FP32_DualQuaternion* second, const float phase)
|
||||
{
|
||||
bgc_fp32_quaternion_interpolate(&interpolation->real, &first->real, &second->real, phase);
|
||||
bgc_fp32_quaternion_interpolate(&interpolation->dual, &first->dual, &second->dual, phase);
|
||||
bgc_fp32_quaternion_interpolate(&interpolation->real_part, &first->real_part, &second->real_part, phase);
|
||||
bgc_fp32_quaternion_interpolate(&interpolation->dual_part, &first->dual_part, &second->dual_part, phase);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_interpolate(BGC_FP64_DualQuaternion* interpolation, const BGC_FP64_DualQuaternion* first, const BGC_FP64_DualQuaternion* second, const double phase)
|
||||
{
|
||||
bgc_fp64_quaternion_interpolate(&interpolation->real, &first->real, &second->real, phase);
|
||||
bgc_fp64_quaternion_interpolate(&interpolation->dual, &first->dual, &second->dual, phase);
|
||||
bgc_fp64_quaternion_interpolate(&interpolation->real_part, &first->real_part, &second->real_part, phase);
|
||||
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);
|
||||
bgc_fp32_quaternion_revert(&quaternion->dual);
|
||||
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);
|
||||
bgc_fp64_quaternion_revert(&quaternion->dual);
|
||||
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, &quaternion->real);
|
||||
bgc_fp32_quaternion_get_reverse(&reverse->dual, &quaternion->dual);
|
||||
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, &quaternion->real);
|
||||
bgc_fp64_quaternion_get_reverse(&reverse->dual, &quaternion->dual);
|
||||
bgc_fp64_quaternion_get_reverse(&reverse->real_part, &quaternion->real_part);
|
||||
bgc_fp64_quaternion_get_reverse(&reverse->dual_part, &quaternion->dual_part);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
61
basic-geometry/dual-scalar.c
Normal file
61
basic-geometry/dual-scalar.c
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
#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);
|
||||
360
basic-geometry/dual-scalar.h
Normal file
360
basic-geometry/dual-scalar.h
Normal file
|
|
@ -0,0 +1,360 @@
|
|||
#ifndef _BGC_DUAL_NUMBER_H_INCLUDED_
|
||||
#define _BGC_DUAL_NUMBER_H_INCLUDED_
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#include "./utilities.h"
|
||||
#include "./types.h"
|
||||
|
||||
// =================== Reset ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_scalar_reset(BGC_FP32_DualScalar* number)
|
||||
{
|
||||
number->real_part = 0.0f;
|
||||
number->dual_part = 0.0f;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_scalar_reset(BGC_FP64_DualScalar* number)
|
||||
{
|
||||
number->real_part = 0.0;
|
||||
number->dual_part = 0.0;
|
||||
}
|
||||
|
||||
// ==================== Make ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_scalar_make(BGC_FP32_DualScalar* 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)
|
||||
{
|
||||
number->real_part = real_part;
|
||||
number->dual_part = dual_part;
|
||||
}
|
||||
|
||||
// ==================== Copy ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_scalar_copy(BGC_FP32_DualScalar* destination, const BGC_FP32_DualScalar* 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)
|
||||
{
|
||||
destination->real_part = source->real_part;
|
||||
destination->dual_part = source->dual_part;
|
||||
}
|
||||
|
||||
// ==================== Swap ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_scalar_swap(BGC_FP32_DualScalar* first, BGC_FP32_DualScalar* 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)
|
||||
{
|
||||
first->real_part = second->real_part;
|
||||
first->dual_part = second->dual_part;
|
||||
}
|
||||
|
||||
// ================== Convert =================== //
|
||||
|
||||
inline void bgc_fp64_dual_scalar_convert_to_fp32(BGC_FP32_DualScalar* first, BGC_FP64_DualScalar* 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)
|
||||
{
|
||||
first->real_part = second->real_part;
|
||||
first->dual_part = second->dual_part;
|
||||
}
|
||||
|
||||
// =================== Revert =================== //
|
||||
|
||||
inline void bgc_fp32_dual_scalar_revert(BGC_FP32_DualScalar* number)
|
||||
{
|
||||
number->real_part = -number->real_part;
|
||||
number->dual_part = -number->dual_part;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_scalar_revert(BGC_FP64_DualScalar* number)
|
||||
{
|
||||
number->real_part = -number->real_part;
|
||||
number->dual_part = -number->dual_part;
|
||||
}
|
||||
|
||||
// ================ Get Reverse ================= //
|
||||
|
||||
inline void bgc_fp32_number_get_reverse(BGC_FP32_DualScalar* reverse, const BGC_FP32_DualScalar* 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)
|
||||
{
|
||||
reverse->real_part = -number->real_part;
|
||||
reverse->dual_part = -number->dual_part;
|
||||
}
|
||||
|
||||
// ================= Conjugate ================== //
|
||||
|
||||
inline void bgc_fp32_dual_scalar_conjugate(BGC_FP32_DualScalar* number)
|
||||
{
|
||||
number->dual_part = -number->dual_part;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_scalar_conjugate(BGC_FP64_DualScalar* 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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
conjugate->real_part = number->real_part;
|
||||
conjugate->dual_part = -number->dual_part;
|
||||
}
|
||||
|
||||
// ==================== Add ===================== //
|
||||
|
||||
inline void bgc_fp32_dual_scalar_add(BGC_FP32_DualScalar* sum, const BGC_FP32_DualScalar* first, const BGC_FP32_DualScalar* 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)
|
||||
{
|
||||
sum->real_part = first->real_part + second->real_part;
|
||||
sum->dual_part = first->dual_part + second->dual_part;
|
||||
}
|
||||
|
||||
// ================= 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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
sum->real_part = base_number->real_part + scalable_number->real_part * scale;
|
||||
sum->dual_part = base_number->dual_part + scalable_number->dual_part * scale;
|
||||
}
|
||||
|
||||
// ================== Subtract ================== //
|
||||
|
||||
inline void bgc_fp32_dual_scalar_subtract(BGC_FP32_DualScalar* difference, const BGC_FP32_DualScalar* minuend, const BGC_FP32_DualScalar* 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)
|
||||
{
|
||||
difference->real_part = minuend->real_part - subtrahend->real_part;
|
||||
difference->dual_part = minuend->dual_part - subtrahend->dual_part;
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_dual_scalar_multiply_by_real(BGC_FP32_DualScalar* product, const BGC_FP32_DualScalar* 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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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;
|
||||
|
||||
product->real_part = real_part;
|
||||
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)
|
||||
{
|
||||
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;
|
||||
|
||||
product->real_part = real_part;
|
||||
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)
|
||||
{
|
||||
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;
|
||||
|
||||
product->real_part = real_part;
|
||||
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)
|
||||
{
|
||||
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;
|
||||
|
||||
product->real_part = real_part;
|
||||
product->dual_part = dual_part;
|
||||
}
|
||||
// =================== Divide =================== //
|
||||
|
||||
inline int bgc_fp32_dual_scalar_divide_by_real(BGC_FP32_DualScalar* quotient, const BGC_FP32_DualScalar* 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);
|
||||
return BGC_SUCCESS;
|
||||
}
|
||||
|
||||
inline int bgc_fp64_dual_scalar_divide_by_real(BGC_FP64_DualScalar* quotient, const BGC_FP64_DualScalar* 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);
|
||||
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)
|
||||
{
|
||||
if (bgc_fp32_is_zero(divisor->real_part)) {
|
||||
return BGC_FAILURE;
|
||||
}
|
||||
|
||||
const float multiplier = 1.0f / divisor->real_part;
|
||||
|
||||
const float real_part = dividend->real_part * multiplier;
|
||||
const float dual_part = dividend->dual_part * multiplier - (dividend->real_part * multiplier) * (divisor->dual_part * multiplier);
|
||||
|
||||
quotient->real_part = real_part;
|
||||
quotient->dual_part = dual_part;
|
||||
|
||||
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)
|
||||
{
|
||||
if (bgc_fp64_is_zero(divisor->real_part)) {
|
||||
return BGC_FAILURE;
|
||||
}
|
||||
|
||||
const double multiplier = 1.0 / divisor->real_part;
|
||||
|
||||
const double real_part = dividend->real_part * multiplier;
|
||||
const double dual_part = dividend->dual_part * multiplier - (dividend->real_part * multiplier) * (divisor->dual_part * multiplier);
|
||||
|
||||
quotient->real_part = real_part;
|
||||
quotient->dual_part = dual_part;
|
||||
|
||||
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)
|
||||
{
|
||||
if (bgc_fp32_is_zero(divisor_to_conjugate->real_part)) {
|
||||
return BGC_FAILURE;
|
||||
}
|
||||
|
||||
const float multiplier = 1.0f / divisor_to_conjugate->real_part;
|
||||
|
||||
const float real_part = dividend->real_part * multiplier;
|
||||
const float dual_part = dividend->dual_part * multiplier + (dividend->real_part * multiplier) * (divisor_to_conjugate->dual_part * multiplier);
|
||||
|
||||
quotient->real_part = real_part;
|
||||
quotient->dual_part = dual_part;
|
||||
|
||||
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)
|
||||
{
|
||||
if (bgc_fp64_is_zero(divisor_to_conjugate->real_part)) {
|
||||
return BGC_FAILURE;
|
||||
}
|
||||
|
||||
const double multiplier = 1.0 / divisor_to_conjugate->real_part;
|
||||
|
||||
const double real_part = dividend->real_part * multiplier;
|
||||
const double dual_part = dividend->dual_part * multiplier + (dividend->real_part * multiplier) * (divisor_to_conjugate->dual_part * multiplier);
|
||||
|
||||
quotient->real_part = real_part;
|
||||
quotient->dual_part = dual_part;
|
||||
|
||||
return BGC_SUCCESS;
|
||||
}
|
||||
|
||||
// ================ 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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
mean->real_part = (first->real_part + second->real_part) * 0.5;
|
||||
mean->dual_part = (first->dual_part + second->dual_part) * 0.5;
|
||||
}
|
||||
|
||||
// =============== 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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
// ============ 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)
|
||||
{
|
||||
const float counter_phase = 1.0f - phase;
|
||||
|
||||
interpolation->real_part = first->real_part * counter_phase + second->real_part * phase;
|
||||
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)
|
||||
{
|
||||
const double counter_phase = 1.0 - phase;
|
||||
|
||||
interpolation->real_part = first->real_part * counter_phase + second->real_part * phase;
|
||||
interpolation->dual_part = first->dual_part * counter_phase + second->dual_part * phase;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -12,12 +12,6 @@ extern inline void bgc_fp64_dual_vector3_copy(BGC_FP64_DualVector3* destination,
|
|||
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_set_real_values(BGC_FP32_DualVector3* vector, const float x1, const float x2, const float x3);
|
||||
extern inline void bgc_fp64_dual_vector3_set_real_values(BGC_FP64_DualVector3* vector, const double x1, const double x2, const double x3);
|
||||
|
||||
extern inline void bgc_fp32_dual_vector3_set_dual_values(BGC_FP32_DualVector3* vector, const float x1, const float x2, const float x3);
|
||||
extern inline void bgc_fp64_dual_vector3_set_dual_values(BGC_FP64_DualVector3* vector, const double x1, const double x2, const double x3);
|
||||
|
||||
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);
|
||||
|
||||
|
|
@ -27,11 +21,17 @@ 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_multiply(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_dual_vector3_multiply(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const double multiplier);
|
||||
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 int bgc_fp32_dual_vector3_divide(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* dividend, const float divisor);
|
||||
extern inline int bgc_fp64_dual_vector3_divide(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const double divisor);
|
||||
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_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 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);
|
||||
|
|
|
|||
|
|
@ -8,172 +8,216 @@
|
|||
|
||||
inline void bgc_fp32_dual_vector3_reset(BGC_FP32_DualVector3* vector)
|
||||
{
|
||||
bgc_fp32_vector3_reset(&vector->real);
|
||||
bgc_fp32_vector3_reset(&vector->dual);
|
||||
bgc_fp32_vector3_reset(&vector->real_part);
|
||||
bgc_fp32_vector3_reset(&vector->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_reset(BGC_FP64_DualVector3* vector)
|
||||
{
|
||||
bgc_fp64_vector3_reset(&vector->real);
|
||||
bgc_fp64_vector3_reset(&vector->dual);
|
||||
bgc_fp64_vector3_reset(&vector->real_part);
|
||||
bgc_fp64_vector3_reset(&vector->dual_part);
|
||||
}
|
||||
|
||||
// ==================== Make ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_make(BGC_FP32_DualVector3* vector, const BGC_FP32_Vector3* real, const BGC_FP32_Vector3* dual)
|
||||
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, real);
|
||||
bgc_fp32_vector3_copy(&vector->dual, dual);
|
||||
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, const BGC_FP64_Vector3* dual)
|
||||
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, real);
|
||||
bgc_fp64_vector3_copy(&vector->dual, dual);
|
||||
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)
|
||||
{
|
||||
bgc_fp32_vector3_copy(&destination->real, &source->real);
|
||||
bgc_fp32_vector3_copy(&destination->dual, &source->dual);
|
||||
bgc_fp32_vector3_copy(&destination->real_part, &source->real_part);
|
||||
bgc_fp32_vector3_copy(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_copy(BGC_FP64_DualVector3* destination, const BGC_FP64_DualVector3* source)
|
||||
{
|
||||
bgc_fp64_vector3_copy(&destination->real, &source->real);
|
||||
bgc_fp64_vector3_copy(&destination->dual, &source->dual);
|
||||
bgc_fp64_vector3_copy(&destination->real_part, &source->real_part);
|
||||
bgc_fp64_vector3_copy(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
// ==================== Swap ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_swap(BGC_FP32_DualVector3* first, BGC_FP32_DualVector3* second)
|
||||
{
|
||||
bgc_fp32_vector3_swap(&first->real, &second->real);
|
||||
bgc_fp32_vector3_swap(&first->dual, &second->dual);
|
||||
bgc_fp32_vector3_swap(&first->real_part, &second->real_part);
|
||||
bgc_fp32_vector3_swap(&first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_swap(BGC_FP64_DualVector3* first, BGC_FP64_DualVector3* second)
|
||||
{
|
||||
bgc_fp64_vector3_swap(&first->real, &second->real);
|
||||
bgc_fp64_vector3_swap(&first->dual, &second->dual);
|
||||
}
|
||||
|
||||
// ================== Set Real ================== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_set_real_values(BGC_FP32_DualVector3* vector, const float x1, const float x2, const float x3)
|
||||
{
|
||||
vector->real.x1 = x1;
|
||||
vector->real.x2 = x2;
|
||||
vector->real.x3 = x3;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_vector3_set_real_values(BGC_FP64_DualVector3* vector, const double x1, const double x2, const double x3)
|
||||
{
|
||||
vector->real.x1 = x1;
|
||||
vector->real.x2 = x2;
|
||||
vector->real.x3 = x3;
|
||||
}
|
||||
|
||||
// ================== Set Dual ================== //
|
||||
|
||||
inline void bgc_fp32_dual_vector3_set_dual_values(BGC_FP32_DualVector3* vector, const float x1, const float x2, const float x3)
|
||||
{
|
||||
vector->dual.x1 = x1;
|
||||
vector->dual.x2 = x2;
|
||||
vector->dual.x3 = x3;
|
||||
}
|
||||
|
||||