Kimelas/bgc-c
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Развитие SLERP для трёхмерных пространств, а также развитие дуальных чисел, векторов и кватернионов

Browse source
This commit is contained in:
Andrey Pokidov 2026-02-13 20:34:11 +07:00
parent 053af33444
commit 86ea23de7d
23 changed files with 1063 additions and 830 deletions
Download patch file Download diff file Expand all files Collapse all files

25
basic-geometry/basic-geometry.cbp
View file

@ -60,30 +60,26 @@
<Option compilerVar="CC" /> <Option compilerVar="CC" />
</Unit> </Unit>
<Unit filename="complex.h" /> <Unit filename="complex.h" />
<Unit filename="dual-number.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="dual-number.h" />
<Unit filename="dual-quaternion.c"> <Unit filename="dual-quaternion.c">
<Option compilerVar="CC" /> <Option compilerVar="CC" />
</Unit> </Unit>
<Unit filename="dual-quaternion.h" /> <Unit filename="dual-quaternion.h" />
<Unit filename="dual-scalar.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="dual-scalar.h" />
<Unit filename="dual-vector3.c"> <Unit filename="dual-vector3.c">
<Option compilerVar="CC" /> <Option compilerVar="CC" />
</Unit> </Unit>
<Unit filename="dual-vector3.h" /> <Unit filename="dual-vector3.h" />
<Unit filename="hg-matrix3x3.c"> <Unit filename="hmg-matrix3x3.c">
<Option compilerVar="CC" /> <Option compilerVar="CC" />
</Unit> </Unit>
<Unit filename="hg-matrix3x3.h" /> <Unit filename="hmg-matrix3x3.h" />
<Unit filename="hg-vector3.c"> <Unit filename="hmg-vector3.c">
<Option compilerVar="CC" /> <Option compilerVar="CC" />
</Unit> </Unit>
<Unit filename="hg-vector3.h" /> <Unit filename="hmg-vector3.h" />
<Unit filename="matrices.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="matrices.h" />
<Unit filename="matrix2x2.c"> <Unit filename="matrix2x2.c">
<Option compilerVar="CC" /> <Option compilerVar="CC" />
</Unit> </Unit>
@ -112,10 +108,10 @@
<Option compilerVar="CC" /> <Option compilerVar="CC" />
</Unit> </Unit>
<Unit filename="quaternion.h" /> <Unit filename="quaternion.h" />
<Unit filename="slerp.c"> <Unit filename="slerp3.c">
<Option compilerVar="CC" /> <Option compilerVar="CC" />
</Unit> </Unit>
<Unit filename="slerp.h" /> <Unit filename="slerp3.h" />
<Unit filename="turn2.c"> <Unit filename="turn2.c">
<Option compilerVar="CC" /> <Option compilerVar="CC" />
</Unit> </Unit>
@ -124,6 +120,7 @@
<Option compilerVar="CC" /> <Option compilerVar="CC" />
</Unit> </Unit>
<Unit filename="turn3.h" /> <Unit filename="turn3.h" />
<Unit filename="types.h" />
<Unit filename="utilities.c"> <Unit filename="utilities.c">
<Option compilerVar="CC" /> <Option compilerVar="CC" />
</Unit> </Unit>

4
basic-geometry/basic-geometry.h
View file

@ -24,9 +24,9 @@
#include "./turn2.h" #include "./turn2.h"
#include "./turn3.h" #include "./turn3.h"
#include "./slerp3.h"
#include "./position2.h" #include "./position2.h"
#include "./position3.h" #include "./position3.h"
#include "./slerp.h"
#endif #endif

16
basic-geometry/basic-geometry.vcxproj
View file

@ -24,11 +24,11 @@
<ClInclude Include="angle.h" /> <ClInclude Include="angle.h" />
<ClInclude Include="basic-geometry.h" /> <ClInclude Include="basic-geometry.h" />
<ClInclude Include="complex.h" /> <ClInclude Include="complex.h" />
<ClInclude Include="dual-number.h" /> <ClInclude Include="dual-scalar.h" />
<ClInclude Include="dual-quaternion.h" /> <ClInclude Include="dual-quaternion.h" />
<ClInclude Include="dual-vector3.h" /> <ClInclude Include="dual-vector3.h" />
<ClInclude Include="hg-matrix3x3.h" /> <ClInclude Include="hmg-matrix3x3.h" />
<ClInclude Include="hg-vector3.h" /> <ClInclude Include="hmg-vector3.h" />
<ClInclude Include="matrix2x2.h" /> <ClInclude Include="matrix2x2.h" />
<ClInclude Include="matrix2x3.h" /> <ClInclude Include="matrix2x3.h" />
<ClInclude Include="matrix3x2.h" /> <ClInclude Include="matrix3x2.h" />
@ -40,7 +40,7 @@
<ClInclude Include="turn2.h" /> <ClInclude Include="turn2.h" />
<ClInclude Include="turn3.h" /> <ClInclude Include="turn3.h" />
<ClInclude Include="utilities.h" /> <ClInclude Include="utilities.h" />
<ClInclude Include="slerp.h" /> <ClInclude Include="slerp3.h" />
<ClInclude Include="vector2.h" /> <ClInclude Include="vector2.h" />
<ClInclude Include="vector3.h" /> <ClInclude Include="vector3.h" />
</ItemGroup> </ItemGroup>
@ -49,11 +49,11 @@
<ClCompile Include="affine3.c" /> <ClCompile Include="affine3.c" />
<ClCompile Include="angle.c" /> <ClCompile Include="angle.c" />
<ClInclude Include="complex.c" /> <ClInclude Include="complex.c" />
<ClCompile Include="dual-number.c" /> <ClCompile Include="dual-scalar.c" />
<ClCompile Include="dual-quaternion.c" /> <ClCompile Include="dual-quaternion.c" />
<ClCompile Include="dual-vector3.c" /> <ClCompile Include="dual-vector3.c" />
<ClCompile Include="hg-matrix3x3.c" /> <ClCompile Include="hmg-matrix3x3.c" />
<ClCompile Include="hg-vector3.c" /> <ClCompile Include="hmg-vector3.c" />
<ClCompile Include="position2.c" /> <ClCompile Include="position2.c" />
<ClCompile Include="position3.c" /> <ClCompile Include="position3.c" />
<ClCompile Include="turn2.c" /> <ClCompile Include="turn2.c" />
@ -64,7 +64,7 @@
<ClCompile Include="matrix3x2.c" /> <ClCompile Include="matrix3x2.c" />
<ClCompile Include="matrix3x3.c" /> <ClCompile Include="matrix3x3.c" />
<ClCompile Include="quaternion.c" /> <ClCompile Include="quaternion.c" />
<ClCompile Include="slerp.c" /> <ClCompile Include="slerp3.c" />
<ClCompile Include="vector2.c" /> <ClCompile Include="vector2.c" />
<ClCompile Include="vector3.c" /> <ClCompile Include="vector3.c" />
</ItemGroup> </ItemGroup>

55
basic-geometry/dual-number.c
View file

@ -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);

273
basic-geometry/dual-number.h
View file

@ -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

104
basic-geometry/dual-quaternion.h
View file

@ -8,112 +8,112 @@
inline void bgc_fp32_dual_quaternion_reset(BGC_FP32_DualQuaternion* quaternion) inline void bgc_fp32_dual_quaternion_reset(BGC_FP32_DualQuaternion* quaternion)
{ {
bgc_fp32_quaternion_reset(&quaternion->real); bgc_fp32_quaternion_reset(&quaternion->real_part);
bgc_fp32_quaternion_reset(&quaternion->dual); bgc_fp32_quaternion_reset(&quaternion->dual_part);
} }
inline void bgc_fp64_dual_quaternion_reset(BGC_FP64_DualQuaternion* quaternion) inline void bgc_fp64_dual_quaternion_reset(BGC_FP64_DualQuaternion* quaternion)
{ {
bgc_fp64_quaternion_reset(&quaternion->real); bgc_fp64_quaternion_reset(&quaternion->real_part);
bgc_fp64_quaternion_reset(&quaternion->dual); bgc_fp64_quaternion_reset(&quaternion->dual_part);
} }
// ==================== Copy ==================== // // ==================== Copy ==================== //
inline void bgc_fp32_dual_quaternion_copy(BGC_FP32_DualQuaternion* destination, const BGC_FP32_DualQuaternion* source) 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->real_part, &source->real_part);
bgc_fp32_quaternion_copy(&destination->dual, &source->dual); 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) 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->real_part, &source->real_part);
bgc_fp64_quaternion_copy(&destination->dual, &source->dual); bgc_fp64_quaternion_copy(&destination->dual_part, &source->dual_part);
} }
// ==================== Swap ==================== // // ==================== Swap ==================== //
inline void bgc_fp32_dual_quaternion_swap(BGC_FP32_DualQuaternion* first, BGC_FP32_DualQuaternion* second) 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->real_part, &second->real_part);
bgc_fp32_quaternion_swap(&first->dual, &second->dual); 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) 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->real_part, &second->real_part);
bgc_fp64_quaternion_swap(&first->dual, &second->dual); bgc_fp64_quaternion_swap(&first->dual_part, &second->dual_part);
} }
// ================== Convert =================== // // ================== Convert =================== //
inline void bgc_fp32_dual_quaternion_convert_to_fp64(BGC_FP64_DualQuaternion* destination, const BGC_FP32_DualQuaternion* source) 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->real_part, &source->real_part);
bgc_fp32_quaternion_convert_to_fp64(&destination->dual, &source->dual); 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) 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->real_part, &source->real_part);
bgc_fp64_quaternion_convert_to_fp32(&destination->dual, &source->dual); bgc_fp64_quaternion_convert_to_fp32(&destination->dual_part, &source->dual_part);
} }
// ==================== Add ===================== // // ==================== Add ===================== //
inline void bgc_fp32_dual_quaternion_add(BGC_FP32_DualQuaternion* sum, const BGC_FP32_DualQuaternion* first, const BGC_FP32_DualQuaternion* second) 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->real_part, &first->real_part, &second->real_part);
bgc_fp32_quaternion_add(&sum->dual, &first->dual, &second->dual); 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) 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->real_part, &first->real_part, &second->real_part);
bgc_fp64_quaternion_add(&sum->dual, &first->dual, &second->dual); bgc_fp64_quaternion_add(&sum->dual_part, &first->dual_part, &second->dual_part);
} }
// ================= Add Scaled ================= // // ================= 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) 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->real_part, &base_quaternion->real_part, &scalable_quaternion->real_part, scale);
bgc_fp32_quaternion_add_scaled(&sum->dual, &base_quaternion->dual, &scalable_quaternion->dual, 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) 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->real_part, &base_quaternion->real_part, &scalable_quaternion->real_part, scale);
bgc_fp64_quaternion_add_scaled(&sum->dual, &base_quaternion->dual, &scalable_quaternion->dual, scale); bgc_fp64_quaternion_add_scaled(&sum->dual_part, &base_quaternion->dual_part, &scalable_quaternion->dual_part, scale);
} }
// ================== Subtract ================== // // ================== Subtract ================== //
inline void bgc_fp32_dual_quaternion_subtract(BGC_FP32_DualQuaternion* difference, const BGC_FP32_DualQuaternion* minuend, const BGC_FP32_DualQuaternion* subtrahend) 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->real_part, &minuend->real_part, &subtrahend->real_part);
bgc_fp32_quaternion_subtract(&difference->dual, &minuend->dual, &subtrahend->dual); 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) 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->real_part, &minuend->real_part, &subtrahend->real_part);
bgc_fp64_quaternion_subtract(&difference->dual, &minuend->dual, &subtrahend->dual); bgc_fp64_quaternion_subtract(&difference->dual_part, &minuend->dual_part, &subtrahend->dual_part);
} }
// ================== Multiply ================== // // ================== Multiply ================== //
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_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->real_part, &multiplicand->real_part, multipier);
bgc_fp32_quaternion_multiply_by_real(&product->dual, &multiplicand->dual, 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) 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->real_part, &multiplicand->real_part, multipier);
bgc_fp64_quaternion_multiply_by_real(&product->dual, &multiplicand->dual, multipier); bgc_fp64_quaternion_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multipier);
} }
// =================== Divide =================== // // =================== 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) 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->real_part, &quaternion1->real_part, &quaternion2->real_part);
bgc_fp32_quaternion_get_mean2(&mean->dual, &quaternion1->dual, &quaternion2->dual); 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) 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->real_part, &quaternion1->real_part, &quaternion2->real_part);
bgc_fp64_quaternion_get_mean2(&mean->dual, &quaternion1->dual, &quaternion2->dual); bgc_fp64_quaternion_get_mean2(&mean->dual_part, &quaternion1->dual_part, &quaternion2->dual_part);
} }
// =============== Mean of Three ================ // // =============== 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) 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->real_part, &quaternion1->real_part, &quaternion2->real_part, &quaternion3->real_part);
bgc_fp32_quaternion_get_mean3(&mean->dual, &quaternion1->dual, &quaternion2->dual, &quaternion3->dual); 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) 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->real_part, &quaternion1->real_part, &quaternion2->real_part, &quaternion3->real_part);
bgc_fp64_quaternion_get_mean3(&mean->dual, &quaternion1->dual, &quaternion2->dual, &quaternion3->dual); bgc_fp64_quaternion_get_mean3(&mean->dual_part, &quaternion1->dual_part, &quaternion2->dual_part, &quaternion3->dual_part);
} }
// ============ Linear Interpolation ============ // // ============ 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) 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->real_part, &first->real_part, &second->real_part, phase);
bgc_fp32_quaternion_interpolate(&interpolation->dual, &first->dual, &second->dual, 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) 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->real_part, &first->real_part, &second->real_part, phase);
bgc_fp64_quaternion_interpolate(&interpolation->dual, &first->dual, &second->dual, phase); bgc_fp64_quaternion_interpolate(&interpolation->dual_part, &first->dual_part, &second->dual_part, phase);
} }
// =================== Revert =================== // // =================== Revert =================== //
inline void bgc_fp32_dual_quaternion_revert(BGC_FP32_DualQuaternion* quaternion) inline void bgc_fp32_dual_quaternion_revert(BGC_FP32_DualQuaternion* quaternion)
{ {
bgc_fp32_quaternion_revert(&quaternion->real); bgc_fp32_quaternion_revert(&quaternion->real_part);
bgc_fp32_quaternion_revert(&quaternion->dual); bgc_fp32_quaternion_revert(&quaternion->dual_part);
} }
inline void bgc_fp64_dual_quaternion_revert(BGC_FP64_DualQuaternion* quaternion) inline void bgc_fp64_dual_quaternion_revert(BGC_FP64_DualQuaternion* quaternion)
{ {
bgc_fp64_quaternion_revert(&quaternion->real); bgc_fp64_quaternion_revert(&quaternion->real_part);
bgc_fp64_quaternion_revert(&quaternion->dual); bgc_fp64_quaternion_revert(&quaternion->dual_part);
} }
// ================ Get Reverse ================= // // ================ Get Reverse ================= //
inline void bgc_fp32_dual_quaternion_get_reverse(BGC_FP32_DualQuaternion* reverse, const BGC_FP32_DualQuaternion* quaternion) 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->real_part, &quaternion->real_part);
bgc_fp32_quaternion_get_reverse(&reverse->dual, &quaternion->dual); 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) 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->real_part, &quaternion->real_part);
bgc_fp64_quaternion_get_reverse(&reverse->dual, &quaternion->dual); bgc_fp64_quaternion_get_reverse(&reverse->dual_part, &quaternion->dual_part);
} }
#endif #endif

61
basic-geometry/dual-scalar.c Normal file
View 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
View 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

20
basic-geometry/dual-vector3.c
View file

@ -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_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_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_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); 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_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_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_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(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const double 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 void bgc_fp32_dual_vector3_multiply_by_dual(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const BGC_FP32_DualScalar* multiplier);
extern inline int bgc_fp64_dual_vector3_divide(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const double divisor); 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_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 void bgc_fp64_dual_vector3_get_mean2(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* vector1, const BGC_FP64_DualVector3* vector2);

236
basic-geometry/dual-vector3.h
View file

@ -8,172 +8,216 @@
inline void bgc_fp32_dual_vector3_reset(BGC_FP32_DualVector3* vector) inline void bgc_fp32_dual_vector3_reset(BGC_FP32_DualVector3* vector)
{ {
bgc_fp32_vector3_reset(&vector->real); bgc_fp32_vector3_reset(&vector->real_part);
bgc_fp32_vector3_reset(&vector->dual); bgc_fp32_vector3_reset(&vector->dual_part);
} }
inline void bgc_fp64_dual_vector3_reset(BGC_FP64_DualVector3* vector) inline void bgc_fp64_dual_vector3_reset(BGC_FP64_DualVector3* vector)
{ {
bgc_fp64_vector3_reset(&vector->real); bgc_fp64_vector3_reset(&vector->real_part);
bgc_fp64_vector3_reset(&vector->dual); bgc_fp64_vector3_reset(&vector->dual_part);
} }
// ==================== Make ==================== // // ==================== 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->real_part, real_part);
bgc_fp32_vector3_copy(&vector->dual, dual); 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->real_part, real_part);
bgc_fp64_vector3_copy(&vector->dual, dual); bgc_fp64_vector3_copy(&vector->dual_part, dual_part);
} }
// ==================== Copy ==================== // // ==================== Copy ==================== //
inline void bgc_fp32_dual_vector3_copy(BGC_FP32_DualVector3* destination, const BGC_FP32_DualVector3* source) 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->real_part, &source->real_part);
bgc_fp32_vector3_copy(&destination->dual, &source->dual); 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) 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->real_part, &source->real_part);
bgc_fp64_vector3_copy(&destination->dual, &source->dual); bgc_fp64_vector3_copy(&destination->dual_part, &source->dual_part);
} }
// ==================== Swap ==================== // // ==================== Swap ==================== //
inline void bgc_fp32_dual_vector3_swap(BGC_FP32_DualVector3* first, BGC_FP32_DualVector3* second) 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->real_part, &second->real_part);
bgc_fp32_vector3_swap(&first->dual, &second->dual); 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) 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->real_part, &second->real_part);
bgc_fp64_vector3_swap(&first->dual, &second->dual); bgc_fp64_vector3_swap(&first->dual_part, &second->dual_part);
}
// ================== 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;
}
inline void bgc_fp64_dual_vector3_set_dual_values(BGC_FP64_DualVector3* vector, const double x1, const double x2, const double x3)
{
vector->dual.x1 = x1;
vector->dual.x2 = x2;
vector->dual.x3 = x3;
} }
// ==================== Add ===================== // // ==================== Add ===================== //
inline void bgc_fp32_dual_vector3_add(BGC_FP32_DualVector3* sum, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second) inline void bgc_fp32_dual_vector3_add(BGC_FP32_DualVector3* sum, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second)
{ {
bgc_fp32_vector3_add(&sum->real, &first->real, &second->real); bgc_fp32_vector3_add(&sum->real_part, &first->real_part, &second->real_part);
bgc_fp32_vector3_add(&sum->dual, &first->dual, &second->dual); bgc_fp32_vector3_add(&sum->dual_part, &first->dual_part, &second->dual_part);
} }
inline void bgc_fp64_dual_vector3_add(BGC_FP64_DualVector3* sum, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second) inline void bgc_fp64_dual_vector3_add(BGC_FP64_DualVector3* sum, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second)
{ {
bgc_fp64_vector3_add(&sum->real, &first->real, &second->real); bgc_fp64_vector3_add(&sum->real_part, &first->real_part, &second->real_part);
bgc_fp64_vector3_add(&sum->dual, &first->dual, &second->dual); bgc_fp64_vector3_add(&sum->dual_part, &first->dual_part, &second->dual_part);
} }
// ================= Add Scaled ================= // // ================= Add Scaled ================= //
inline void bgc_fp32_dual_vector3_add_scaled(BGC_FP32_DualVector3* sum, const BGC_FP32_DualVector3* base_vector, const BGC_FP32_DualVector3* scalable_vector, const float scale) inline void bgc_fp32_dual_vector3_add_scaled(BGC_FP32_DualVector3* sum, const BGC_FP32_DualVector3* base_vector, const BGC_FP32_DualVector3* scalable_vector, const float scale)
{ {
bgc_fp32_vector3_add_scaled(&sum->real, &base_vector->real, &scalable_vector->real, scale); bgc_fp32_vector3_add_scaled(&sum->real_part, &base_vector->real_part, &scalable_vector->real_part, scale);
bgc_fp32_vector3_add_scaled(&sum->dual, &base_vector->dual, &scalable_vector->dual, scale); bgc_fp32_vector3_add_scaled(&sum->dual_part, &base_vector->dual_part, &scalable_vector->dual_part, scale);
} }
inline void bgc_fp64_dual_vector3_add_scaled(BGC_FP64_DualVector3* sum, const BGC_FP64_DualVector3* base_vector, const BGC_FP64_DualVector3* scalable_vector, const double scale) inline void bgc_fp64_dual_vector3_add_scaled(BGC_FP64_DualVector3* sum, const BGC_FP64_DualVector3* base_vector, const BGC_FP64_DualVector3* scalable_vector, const double scale)
{ {
bgc_fp64_vector3_add_scaled(&sum->real, &base_vector->real, &scalable_vector->real, scale); bgc_fp64_vector3_add_scaled(&sum->real_part, &base_vector->real_part, &scalable_vector->real_part, scale);
bgc_fp64_vector3_add_scaled(&sum->dual, &base_vector->dual, &scalable_vector->dual, scale); bgc_fp64_vector3_add_scaled(&sum->dual_part, &base_vector->dual_part, &scalable_vector->dual_part, scale);
} }
// ================== Subtract ================== // // ================== Subtract ================== //
inline void bgc_fp32_dual_vector3_subtract(BGC_FP32_DualVector3* difference, const BGC_FP32_DualVector3* minuend, const BGC_FP32_DualVector3* subtrahend) inline void bgc_fp32_dual_vector3_subtract(BGC_FP32_DualVector3* difference, const BGC_FP32_DualVector3* minuend, const BGC_FP32_DualVector3* subtrahend)
{ {
bgc_fp32_vector3_subtract(&difference->real, &minuend->real, &subtrahend->real); bgc_fp32_vector3_subtract(&difference->real_part, &minuend->real_part, &subtrahend->real_part);
bgc_fp32_vector3_subtract(&difference->dual, &minuend->dual, &subtrahend->dual); bgc_fp32_vector3_subtract(&difference->dual_part, &minuend->dual_part, &subtrahend->dual_part);
} }
inline void bgc_fp64_dual_vector3_subtract(BGC_FP64_DualVector3* difference, const BGC_FP64_DualVector3* minuend, const BGC_FP64_DualVector3* subtrahend) inline void bgc_fp64_dual_vector3_subtract(BGC_FP64_DualVector3* difference, const BGC_FP64_DualVector3* minuend, const BGC_FP64_DualVector3* subtrahend)
{ {
bgc_fp64_vector3_subtract(&difference->real, &minuend->real, &subtrahend->real); bgc_fp64_vector3_subtract(&difference->real_part, &minuend->real_part, &subtrahend->real_part);
bgc_fp64_vector3_subtract(&difference->dual, &minuend->dual, &subtrahend->dual); bgc_fp64_vector3_subtract(&difference->dual_part, &minuend->dual_part, &subtrahend->dual_part);
} }
// ================== Multiply ================== // // ================== Multiply ================== //
inline void bgc_fp32_dual_vector3_multiply(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const float multiplier) inline void bgc_fp32_dual_vector3_multiply_by_real(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const float multiplier)
{ {
bgc_fp32_vector3_multiply_by_real(&product->real, &multiplicand->real, multiplier); bgc_fp32_vector3_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier);
bgc_fp32_vector3_multiply_by_real(&product->dual, &multiplicand->dual, multiplier); bgc_fp32_vector3_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multiplier);
} }
inline void bgc_fp64_dual_vector3_multiply(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const double multiplier) inline void bgc_fp64_dual_vector3_multiply_by_real(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const double multiplier)
{ {
bgc_fp64_vector3_multiply_by_real(&product->real, &multiplicand->real, multiplier); bgc_fp64_vector3_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier);
bgc_fp64_vector3_multiply_by_real(&product->dual, &multiplicand->dual, multiplier); 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)
{
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;
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;
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;
}
inline void bgc_fp64_dual_vector3_multiply_by_dual(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const BGC_FP64_DualScalar* 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;
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;
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;
}
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)
{
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;
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;
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;
}
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)
{
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;
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;
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;
} }
// =================== Divide =================== // // =================== Divide =================== //
inline int bgc_fp32_dual_vector3_divide(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* dividend, const float divisor) inline int bgc_fp32_dual_vector3_divide_by_real(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* dividend, const float divisor)
{ {
if (bgc_fp32_is_zero(divisor) || isnan(divisor)) { if (bgc_fp32_is_zero(divisor)) {
return BGC_FAILURE; return BGC_FAILURE;
} }
const float multiplier = 1.0f / divisor; const float multiplier = 1.0f / divisor;
bgc_fp32_vector3_multiply_by_real(&quotient->real, &dividend->real, multiplier); bgc_fp32_vector3_multiply_by_real(&quotient->real_part, &dividend->real_part, multiplier);
bgc_fp32_vector3_multiply_by_real(&quotient->dual, &dividend->dual, multiplier); bgc_fp32_vector3_multiply_by_real(&quotient->dual_part, &dividend->dual_part, multiplier);
return BGC_SUCCESS; return BGC_SUCCESS;
} }
inline int bgc_fp64_dual_vector3_divide(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const double divisor) inline int bgc_fp64_dual_vector3_divide_by_real(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const double divisor)
{ {
if (bgc_fp64_is_zero(divisor) || isnan(divisor)) { if (bgc_fp64_is_zero(divisor)) {
return BGC_FAILURE; return BGC_FAILURE;
} }
const double multiplier = 1.0 / divisor; const double multiplier = 1.0 / divisor;
bgc_fp64_vector3_multiply_by_real(&quotient->real, &dividend->real, multiplier); bgc_fp64_vector3_multiply_by_real(&quotient->real_part, &dividend->real_part, multiplier);
bgc_fp64_vector3_multiply_by_real(&quotient->dual, &dividend->dual, multiplier); bgc_fp64_vector3_multiply_by_real(&quotient->dual_part, &dividend->dual_part, multiplier);
return BGC_SUCCESS; return BGC_SUCCESS;
} }
@ -182,70 +226,70 @@ inline int bgc_fp64_dual_vector3_divide(BGC_FP64_DualVector3* quotient, const BG
inline void bgc_fp32_dual_vector3_get_mean2(BGC_FP32_DualVector3* mean, const BGC_FP32_DualVector3* vector1, const BGC_FP32_DualVector3* vector2) inline void bgc_fp32_dual_vector3_get_mean2(BGC_FP32_DualVector3* mean, const BGC_FP32_DualVector3* vector1, const BGC_FP32_DualVector3* vector2)
{ {
bgc_fp32_vector3_get_mean2(&mean->real, &vector1->real, &vector2->real); bgc_fp32_vector3_get_mean2(&mean->real_part, &vector1->real_part, &vector2->real_part);
bgc_fp32_vector3_get_mean2(&mean->dual, &vector1->dual, &vector2->dual); bgc_fp32_vector3_get_mean2(&mean->dual_part, &vector1->dual_part, &vector2->dual_part);
} }
inline void bgc_fp64_dual_vector3_get_mean2(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* vector1, const BGC_FP64_DualVector3* vector2) inline void bgc_fp64_dual_vector3_get_mean2(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* vector1, const BGC_FP64_DualVector3* vector2)
{ {
bgc_fp64_vector3_get_mean2(&mean->real, &vector1->real, &vector2->real); bgc_fp64_vector3_get_mean2(&mean->real_part, &vector1->real_part, &vector2->real_part);
bgc_fp64_vector3_get_mean2(&mean->dual, &vector1->dual, &vector2->dual); bgc_fp64_vector3_get_mean2(&mean->dual_part, &vector1->dual_part, &vector2->dual_part);
} }
// =============== Mean of Three ================ // // =============== 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* vector1, const BGC_FP32_DualVector3* vector2, const BGC_FP32_DualVector3* vector3)
{ {
bgc_fp32_vector3_get_mean3(&mean->real, &vector1->real, &vector2->real, &vector3->real); bgc_fp32_vector3_get_mean3(&mean->real_part, &vector1->real_part, &vector2->real_part, &vector3->real_part);
bgc_fp32_vector3_get_mean3(&mean->dual, &vector1->dual, &vector2->dual, &vector3->dual); bgc_fp32_vector3_get_mean3(&mean->dual_part, &vector1->dual_part, &vector2->dual_part, &vector3->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* vector1, const BGC_FP64_DualVector3* vector2, const BGC_FP64_DualVector3* vector3)
{ {
bgc_fp64_vector3_get_mean3(&mean->real, &vector1->real, &vector2->real, &vector3->real); bgc_fp64_vector3_get_mean3(&mean->real_part, &vector1->real_part, &vector2->real_part, &vector3->real_part);
bgc_fp64_vector3_get_mean3(&mean->dual, &vector1->dual, &vector2->dual, &vector3->dual); bgc_fp64_vector3_get_mean3(&mean->dual_part, &vector1->dual_part, &vector2->dual_part, &vector3->dual_part);
} }
// ============ Linear Interpolation ============ // // ============ Linear Interpolation ============ //
inline void bgc_fp32_dual_vector3_interpolate(BGC_FP32_DualVector3* interpolation, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second, const float phase) inline void bgc_fp32_dual_vector3_interpolate(BGC_FP32_DualVector3* interpolation, const BGC_FP32_DualVector3* first, const BGC_FP32_DualVector3* second, const float phase)
{ {
bgc_fp32_vector3_interpolate(&interpolation->real, &first->real, &second->real, phase); bgc_fp32_vector3_interpolate(&interpolation->real_part, &first->real_part, &second->real_part, phase);
bgc_fp32_vector3_interpolate(&interpolation->dual, &first->dual, &second->dual, phase); bgc_fp32_vector3_interpolate(&interpolation->dual_part, &first->dual_part, &second->dual_part, phase);
} }
inline void bgc_fp64_dual_vector3_interpolate(BGC_FP64_DualVector3* interpolation, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second, const double phase) inline void bgc_fp64_dual_vector3_interpolate(BGC_FP64_DualVector3* interpolation, const BGC_FP64_DualVector3* first, const BGC_FP64_DualVector3* second, const double phase)
{ {
bgc_fp64_vector3_interpolate(&interpolation->real, &first->real, &second->real, phase); bgc_fp64_vector3_interpolate(&interpolation->real_part, &first->real_part, &second->real_part, phase);
bgc_fp64_vector3_interpolate(&interpolation->dual, &first->dual, &second->dual, phase); bgc_fp64_vector3_interpolate(&interpolation->dual_part, &first->dual_part, &second->dual_part, phase);
} }
// =================== Revert =================== // // =================== Revert =================== //
inline void bgc_fp32_dual_vector3_revert(BGC_FP32_DualVector3* vector) inline void bgc_fp32_dual_vector3_revert(BGC_FP32_DualVector3* vector)
{ {
bgc_fp32_vector3_revert(&vector->real); bgc_fp32_vector3_revert(&vector->real_part);
bgc_fp32_vector3_revert(&vector->dual); bgc_fp32_vector3_revert(&vector->dual_part);
} }
inline void bgc_fp64_dual_vector3_revert(BGC_FP64_DualVector3* vector) inline void bgc_fp64_dual_vector3_revert(BGC_FP64_DualVector3* vector)
{ {
bgc_fp64_vector3_revert(&vector->real); bgc_fp64_vector3_revert(&vector->real_part);
bgc_fp64_vector3_revert(&vector->dual); bgc_fp64_vector3_revert(&vector->dual_part);
} }
// ================ Get Reverse ================= // // ================ Get Reverse ================= //
inline void bgc_fp32_dual_vector3_get_reverse(BGC_FP32_DualVector3* reverse, const BGC_FP32_DualVector3* vector) inline void bgc_fp32_dual_vector3_get_reverse(BGC_FP32_DualVector3* reverse, const BGC_FP32_DualVector3* vector)
{ {
bgc_fp32_vector3_get_reverse(&reverse->real, &vector->real); bgc_fp32_vector3_get_reverse(&reverse->real_part, &vector->real_part);
bgc_fp32_vector3_get_reverse(&reverse->dual, &vector->dual); 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) inline void bgc_fp64_dual_vector3_get_reverse(BGC_FP64_DualVector3* reverse, const BGC_FP64_DualVector3* vector)
{ {
bgc_fp64_vector3_get_reverse(&reverse->real, &vector->real); bgc_fp64_vector3_get_reverse(&reverse->real_part, &vector->real_part);
bgc_fp64_vector3_get_reverse(&reverse->dual, &vector->dual); bgc_fp64_vector3_get_reverse(&reverse->dual_part, &vector->dual_part);
} }
#endif #endif

7
basic-geometry/hg-matrix3x3.c
View file

@ -1,7 +0,0 @@
#include "./hg-matrix3x3.h"
inline void bgc_fp32_hg_matrix3x3_reset(BGC_FP32_HgMatrix3x3* homogeneous_matrix);
inline void bgc_fp64_hg_matrix3x3_reset(BGC_FP64_HgMatrix3x3* homogeneous_matrix);
inline void bgc_fp32_hg_matrix3x3_make(BGC_FP32_HgMatrix3x3* homogeneous_matrix, const BGC_FP32_Matrix3x3* linear_matrix, const BGC_FP32_Vector3* shift);
inline void bgc_fp64_hg_matrix3x3_make(BGC_FP64_HgMatrix3x3* homogeneous_matrix, const BGC_FP64_Matrix3x3* linear_matrix, const BGC_FP64_Vector3* shift);

28
basic-geometry/hg-vector3.c
View file

@ -1,28 +0,0 @@
#include "./hg-vector3.h"
extern inline void bgc_fp32_hg_vector3_reset_point(BGC_FP32_HgVector3* homogeneous_vector);
extern inline void bgc_fp64_hg_vector3_reset_point(BGC_FP64_HgVector3* homogeneous_vector);
extern inline void bgc_fp32_hg_vector3_reset_vector(BGC_FP32_HgVector3* homogeneous_vector);
extern inline void bgc_fp64_hg_vector3_reset_vector(BGC_FP64_HgVector3* homogeneous_vector);
extern inline void bgc_fp32_hg_vector3_make(BGC_FP32_HgVector3* homogeneous_vector, const float x1, const float x2, const float x3, const float ratio);
extern inline void bgc_fp64_hg_vector3_make(BGC_FP64_HgVector3* homogeneous_vector, const double x1, const double x2, const double x3, const double ratio);
extern inline void bgc_fp32_hg_vector3_make_point(BGC_FP32_HgVector3* homogeneous_vector, const BGC_FP32_Vector3* regular_vector);
extern inline void bgc_fp64_hg_vector3_make_point(BGC_FP64_HgVector3* homogeneous_vector, const BGC_FP64_Vector3* regular_vector);
extern inline void bgc_fp32_hg_vector3_make_vector(BGC_FP32_HgVector3* homogeneous_vector, const BGC_FP32_Vector3* regular_vector);
extern inline void bgc_fp64_hg_vector3_make_vector(BGC_FP64_HgVector3* homogeneous_vector, const BGC_FP64_Vector3* regular_vector);
extern inline int bgc_fp32_hg_vector3_is_point(const BGC_FP32_HgVector3* homogeneous_vector);
extern inline int bgc_fp64_hg_vector3_is_point(const BGC_FP64_HgVector3* homogeneous_vector);
extern inline int bgc_fp32_hg_vector3_is_vector(const BGC_FP32_HgVector3* homogeneous_vector);
extern inline int bgc_fp64_hg_vector3_is_vector(const BGC_FP64_HgVector3* homogeneous_vector);
extern inline void bgc_fp32_hg_vector3_copy(BGC_FP32_HgVector3* destination, const BGC_FP32_HgVector3* source);
extern inline void bgc_fp64_hg_vector3_copy(BGC_FP64_HgVector3* destination, const BGC_FP64_HgVector3* source);
extern inline void bgc_fp32_hg_vector3_swap(BGC_FP32_HgVector3* first, BGC_FP32_HgVector3* second);
extern inline void bgc_fp64_hg_vector3_swap(BGC_FP64_HgVector3* first, BGC_FP64_HgVector3* second);

7
basic-geometry/hmg-matrix3x3.c Normal file
View file

@ -0,0 +1,7 @@
#include "./hmg-matrix3x3.h"
inline void bgc_fp32_hg_matrix3x3_reset(BGC_FP32_HmgMatrix3x3* homogeneous_matrix);
inline void bgc_fp64_hg_matrix3x3_reset(BGC_FP64_HmgMatrix3x3* homogeneous_matrix);
inline void bgc_fp32_hg_matrix3x3_make(BGC_FP32_HmgMatrix3x3* homogeneous_matrix, const BGC_FP32_Matrix3x3* linear_matrix, const BGC_FP32_Vector3* shift);
inline void bgc_fp64_hg_matrix3x3_make(BGC_FP64_HmgMatrix3x3* homogeneous_matrix, const BGC_FP64_Matrix3x3* linear_matrix, const BGC_FP64_Vector3* shift);

13
basic-geometry/hg-matrix3x3.h → basic-geometry/hmg-matrix3x3.h
View file

@ -1,14 +1,12 @@
#ifndef _BGC_HG_MATRIX3X3_H_INCLUDED_ #ifndef _BGC_HG_MATRIX3X3_H_INCLUDED_
#define _BGC_HG_MATRIX3X3_H_INCLUDED_ #define _BGC_HG_MATRIX3X3_H_INCLUDED_
#include "./vector3.h"
#include "./types.h" #include "./types.h"
#include "./hmg-vector3.h"
#include "./hg-vector3.h"
// =================== Reset ==================== // // =================== Reset ==================== //
inline void bgc_fp32_hg_matrix3x3_reset(BGC_FP32_HgMatrix3x3* homogeneous_matrix) inline void bgc_fp32_hg_matrix3x3_reset(BGC_FP32_HmgMatrix3x3* homogeneous_matrix)
{ {
homogeneous_matrix->r1c1 = 1.0f; homogeneous_matrix->r1c1 = 1.0f;
homogeneous_matrix->r1c2 = 0.0f; homogeneous_matrix->r1c2 = 0.0f;
@ -31,7 +29,7 @@ inline void bgc_fp32_hg_matrix3x3_reset(BGC_FP32_HgMatrix3x3* homogeneous_matrix
homogeneous_matrix->d0d0 = 1.0f; homogeneous_matrix->d0d0 = 1.0f;
} }
inline void bgc_fp64_hg_matrix3x3_reset(BGC_FP64_HgMatrix3x3* homogeneous_matrix) inline void bgc_fp64_hg_matrix3x3_reset(BGC_FP64_HmgMatrix3x3* homogeneous_matrix)
{ {
homogeneous_matrix->r1c1 = 1.0; homogeneous_matrix->r1c1 = 1.0;
homogeneous_matrix->r1c2 = 0.0; homogeneous_matrix->r1c2 = 0.0;
@ -54,9 +52,10 @@ inline void bgc_fp64_hg_matrix3x3_reset(BGC_FP64_HgMatrix3x3* homogeneous_matrix
homogeneous_matrix->d0d0 = 1.0; homogeneous_matrix->d0d0 = 1.0;
} }
// ==================== Make ==================== //
// ==================== Make ==================== // // ==================== Make ==================== //
inline void bgc_fp32_hg_matrix3x3_make(BGC_FP32_HgMatrix3x3* homogeneous_matrix, const BGC_FP32_Matrix3x3* linear_matrix, const BGC_FP32_Vector3* shift) inline void bgc_fp32_hg_matrix3x3_make(BGC_FP32_HmgMatrix3x3* homogeneous_matrix, const BGC_FP32_Matrix3x3* linear_matrix, const BGC_FP32_Vector3* shift)
{ {
homogeneous_matrix->r1c1 = linear_matrix->r1c1; homogeneous_matrix->r1c1 = linear_matrix->r1c1;
homogeneous_matrix->r1c2 = linear_matrix->r1c2; homogeneous_matrix->r1c2 = linear_matrix->r1c2;
@ -79,7 +78,7 @@ inline void bgc_fp32_hg_matrix3x3_make(BGC_FP32_HgMatrix3x3* homogeneous_matrix,
homogeneous_matrix->d0d0 = 1.0f; homogeneous_matrix->d0d0 = 1.0f;
} }
inline void bgc_fp64_hg_matrix3x3_make(BGC_FP64_HgMatrix3x3* homogeneous_matrix, const BGC_FP64_Matrix3x3* linear_matrix, const BGC_FP64_Vector3* shift) inline void bgc_fp64_hg_matrix3x3_make(BGC_FP64_HmgMatrix3x3* homogeneous_matrix, const BGC_FP64_Matrix3x3* linear_matrix, const BGC_FP64_Vector3* shift)
{ {
homogeneous_matrix->r1c1 = linear_matrix->r1c1; homogeneous_matrix->r1c1 = linear_matrix->r1c1;
homogeneous_matrix->r1c2 = linear_matrix->r1c2; homogeneous_matrix->r1c2 = linear_matrix->r1c2;

28
basic-geometry/hmg-vector3.c Normal file
View file

@ -0,0 +1,28 @@
#include "./hmg-vector3.h"
extern inline void bgc_fp32_hg_vector3_reset_point(BGC_FP32_HmgVector3* homogeneous_vector);
extern inline void bgc_fp64_hg_vector3_reset_point(BGC_FP64_HmgVector3* homogeneous_vector);
extern inline void bgc_fp32_hg_vector3_reset_vector(BGC_FP32_HmgVector3* homogeneous_vector);
extern inline void bgc_fp64_hg_vector3_reset_vector(BGC_FP64_HmgVector3* homogeneous_vector);
extern inline void bgc_fp32_hg_vector3_make(BGC_FP32_HmgVector3* homogeneous_vector, const float x1, const float x2, const float x3, const float ratio);
extern inline void bgc_fp64_hg_vector3_make(BGC_FP64_HmgVector3* homogeneous_vector, const double x1, const double x2, const double x3, const double ratio);
extern inline void bgc_fp32_hg_vector3_make_point(BGC_FP32_HmgVector3* homogeneous_vector, const BGC_FP32_Vector3* regular_vector);
extern inline void bgc_fp64_hg_vector3_make_point(BGC_FP64_HmgVector3* homogeneous_vector, const BGC_FP64_Vector3* regular_vector);
extern inline void bgc_fp32_hg_vector3_make_vector(BGC_FP32_HmgVector3* homogeneous_vector, const BGC_FP32_Vector3* regular_vector);
extern inline void bgc_fp64_hg_vector3_make_vector(BGC_FP64_HmgVector3* homogeneous_vector, const BGC_FP64_Vector3* regular_vector);
extern inline int bgc_fp32_hg_vector3_is_point(const BGC_FP32_HmgVector3* homogeneous_vector);
extern inline int bgc_fp64_hg_vector3_is_point(const BGC_FP64_HmgVector3* homogeneous_vector);
extern inline int bgc_fp32_hg_vector3_is_vector(const BGC_FP32_HmgVector3* homogeneous_vector);
extern inline int bgc_fp64_hg_vector3_is_vector(const BGC_FP64_HmgVector3* homogeneous_vector);
extern inline void bgc_fp32_hg_vector3_copy(BGC_FP32_HmgVector3* destination, const BGC_FP32_HmgVector3* source);
extern inline void bgc_fp64_hg_vector3_copy(BGC_FP64_HmgVector3* destination, const BGC_FP64_HmgVector3* source);
extern inline void bgc_fp32_hg_vector3_swap(BGC_FP32_HmgVector3* first, BGC_FP32_HmgVector3* second);
extern inline void bgc_fp64_hg_vector3_swap(BGC_FP64_HmgVector3* first, BGC_FP64_HmgVector3* second);

40
basic-geometry/hg-vector3.h → basic-geometry/hmg-vector3.h
View file

@ -6,7 +6,7 @@
// ================ Reset Point ================= // // ================ Reset Point ================= //
inline void bgc_fp32_hg_vector3_reset_point(BGC_FP32_HgVector3* homogeneous_vector) inline void bgc_fp32_hg_vector3_reset_point(BGC_FP32_HmgVector3* homogeneous_vector)
{ {
homogeneous_vector->x1 = 0.0f; homogeneous_vector->x1 = 0.0f;
homogeneous_vector->x2 = 0.0f; homogeneous_vector->x2 = 0.0f;
@ -14,7 +14,7 @@ inline void bgc_fp32_hg_vector3_reset_point(BGC_FP32_HgVector3* homogeneous_vect
homogeneous_vector->d0 = 1.0f; homogeneous_vector->d0 = 1.0f;
} }
inline void bgc_fp64_hg_vector3_reset_point(BGC_FP64_HgVector3* homogeneous_vector) inline void bgc_fp64_hg_vector3_reset_point(BGC_FP64_HmgVector3* homogeneous_vector)
{ {
homogeneous_vector->x1 = 0.0; homogeneous_vector->x1 = 0.0;
homogeneous_vector->x2 = 0.0; homogeneous_vector->x2 = 0.0;
@ -24,7 +24,7 @@ inline void bgc_fp64_hg_vector3_reset_point(BGC_FP64_HgVector3* homogeneous_vect
// ================ Reset Point ================= // // ================ Reset Point ================= //
inline void bgc_fp32_hg_vector3_reset_vector(BGC_FP32_HgVector3* homogeneous_vector) inline void bgc_fp32_hg_vector3_reset_vector(BGC_FP32_HmgVector3* homogeneous_vector)
{ {
homogeneous_vector->x1 = 0.0f; homogeneous_vector->x1 = 0.0f;
homogeneous_vector->x2 = 0.0f; homogeneous_vector->x2 = 0.0f;
@ -32,7 +32,7 @@ inline void bgc_fp32_hg_vector3_reset_vector(BGC_FP32_HgVector3* homogeneous_vec
homogeneous_vector->d0 = 0.0f; homogeneous_vector->d0 = 0.0f;
} }
inline void bgc_fp64_hg_vector3_reset_vector(BGC_FP64_HgVector3* homogeneous_vector) inline void bgc_fp64_hg_vector3_reset_vector(BGC_FP64_HmgVector3* homogeneous_vector)
{ {
homogeneous_vector->x1 = 0.0; homogeneous_vector->x1 = 0.0;
homogeneous_vector->x2 = 0.0; homogeneous_vector->x2 = 0.0;
@ -42,7 +42,7 @@ inline void bgc_fp64_hg_vector3_reset_vector(BGC_FP64_HgVector3* homogeneous_vec
// ==================== Make ==================== // // ==================== Make ==================== //
inline void bgc_fp32_hg_vector3_make(BGC_FP32_HgVector3* homogeneous_vector, const float x1, const float x2, const float x3, const float d0) inline void bgc_fp32_hg_vector3_make(BGC_FP32_HmgVector3* homogeneous_vector, const float x1, const float x2, const float x3, const float d0)
{ {
homogeneous_vector->x1 = x1; homogeneous_vector->x1 = x1;
homogeneous_vector->x2 = x2; homogeneous_vector->x2 = x2;
@ -50,7 +50,7 @@ inline void bgc_fp32_hg_vector3_make(BGC_FP32_HgVector3* homogeneous_vector, con
homogeneous_vector->d0 = d0; homogeneous_vector->d0 = d0;
} }
inline void bgc_fp64_hg_vector3_make(BGC_FP64_HgVector3* homogeneous_vector, const double x1, const double x2, const double x3, const double d0) inline void bgc_fp64_hg_vector3_make(BGC_FP64_HmgVector3* homogeneous_vector, const double x1, const double x2, const double x3, const double d0)
{ {
homogeneous_vector->x1 = x1; homogeneous_vector->x1 = x1;
homogeneous_vector->x2 = x2; homogeneous_vector->x2 = x2;
@ -60,7 +60,7 @@ inline void bgc_fp64_hg_vector3_make(BGC_FP64_HgVector3* homogeneous_vector, con
// ================= Make Point ================= // // ================= Make Point ================= //
inline void bgc_fp32_hg_vector3_make_point(BGC_FP32_HgVector3* homogeneous_vector, const BGC_FP32_Vector3* regular_vector) inline void bgc_fp32_hg_vector3_make_point(BGC_FP32_HmgVector3* homogeneous_vector, const BGC_FP32_Vector3* regular_vector)
{ {
homogeneous_vector->x1 = regular_vector->x1; homogeneous_vector->x1 = regular_vector->x1;
homogeneous_vector->x2 = regular_vector->x2; homogeneous_vector->x2 = regular_vector->x2;
@ -68,7 +68,7 @@ inline void bgc_fp32_hg_vector3_make_point(BGC_FP32_HgVector3* homogeneous_vecto
homogeneous_vector->d0 = 1.0f; homogeneous_vector->d0 = 1.0f;
} }
inline void bgc_fp64_hg_vector3_make_point(BGC_FP64_HgVector3* homogeneous_vector, const BGC_FP64_Vector3* regular_vector) inline void bgc_fp64_hg_vector3_make_point(BGC_FP64_HmgVector3* homogeneous_vector, const BGC_FP64_Vector3* regular_vector)
{ {
homogeneous_vector->x1 = regular_vector->x1; homogeneous_vector->x1 = regular_vector->x1;
homogeneous_vector->x2 = regular_vector->x2; homogeneous_vector->x2 = regular_vector->x2;
@ -78,7 +78,7 @@ inline void bgc_fp64_hg_vector3_make_point(BGC_FP64_HgVector3* homogeneous_vecto
// ================ Make Vector ================= // // ================ Make Vector ================= //
inline void bgc_fp32_hg_vector3_make_vector(BGC_FP32_HgVector3* homogeneous_vector, const BGC_FP32_Vector3* regular_vector) inline void bgc_fp32_hg_vector3_make_vector(BGC_FP32_HmgVector3* homogeneous_vector, const BGC_FP32_Vector3* regular_vector)
{ {
homogeneous_vector->x1 = regular_vector->x1; homogeneous_vector->x1 = regular_vector->x1;
homogeneous_vector->x2 = regular_vector->x2; homogeneous_vector->x2 = regular_vector->x2;
@ -86,7 +86,7 @@ inline void bgc_fp32_hg_vector3_make_vector(BGC_FP32_HgVector3* homogeneous_vect
homogeneous_vector->d0 = 0.0f; homogeneous_vector->d0 = 0.0f;
} }
inline void bgc_fp64_hg_vector3_make_vector(BGC_FP64_HgVector3* homogeneous_vector, const BGC_FP64_Vector3* regular_vector) inline void bgc_fp64_hg_vector3_make_vector(BGC_FP64_HmgVector3* homogeneous_vector, const BGC_FP64_Vector3* regular_vector)
{ {
homogeneous_vector->x1 = regular_vector->x1; homogeneous_vector->x1 = regular_vector->x1;
homogeneous_vector->x2 = regular_vector->x2; homogeneous_vector->x2 = regular_vector->x2;
@ -96,31 +96,31 @@ inline void bgc_fp64_hg_vector3_make_vector(BGC_FP64_HgVector3* homogeneous_vect
// ================== Is Point ================== // // ================== Is Point ================== //
inline int bgc_fp32_hg_vector3_is_point(const BGC_FP32_HgVector3* homogeneous_vector) inline int bgc_fp32_hg_vector3_is_point(const BGC_FP32_HmgVector3* homogeneous_vector)
{ {
return !bgc_fp32_is_zero(homogeneous_vector->d0); return !bgc_fp32_is_zero(homogeneous_vector->d0);
} }
inline int bgc_fp64_hg_vector3_is_point(const BGC_FP64_HgVector3* homogeneous_vector) inline int bgc_fp64_hg_vector3_is_point(const BGC_FP64_HmgVector3* homogeneous_vector)
{ {
return !bgc_fp64_is_zero(homogeneous_vector->d0); return !bgc_fp64_is_zero(homogeneous_vector->d0);
} }
// ================= Is Vector ================== // // ================= Is Vector ================== //
inline int bgc_fp32_hg_vector3_is_vector(const BGC_FP32_HgVector3* homogeneous_vector) inline int bgc_fp32_hg_vector3_is_vector(const BGC_FP32_HmgVector3* homogeneous_vector)
{ {
return bgc_fp32_is_zero(homogeneous_vector->d0); return bgc_fp32_is_zero(homogeneous_vector->d0);
} }
inline int bgc_fp64_hg_vector3_is_vector(const BGC_FP64_HgVector3* homogeneous_vector) inline int bgc_fp64_hg_vector3_is_vector(const BGC_FP64_HmgVector3* homogeneous_vector)
{ {
return bgc_fp64_is_zero(homogeneous_vector->d0); return bgc_fp64_is_zero(homogeneous_vector->d0);
} }
// ==================== Copy ==================== // // ==================== Copy ==================== //
inline void bgc_fp32_hg_vector3_copy(BGC_FP32_HgVector3* destination, const BGC_FP32_HgVector3* source) inline void bgc_fp32_hg_vector3_copy(BGC_FP32_HmgVector3* destination, const BGC_FP32_HmgVector3* source)
{ {
destination->x1 = source->x1; destination->x1 = source->x1;
destination->x2 = source->x2; destination->x2 = source->x2;
@ -128,7 +128,7 @@ inline void bgc_fp32_hg_vector3_copy(BGC_FP32_HgVector3* destination, const BGC_
destination->d0 = source->d0; destination->d0 = source->d0;
} }
inline void bgc_fp64_hg_vector3_copy(BGC_FP64_HgVector3* destination, const BGC_FP64_HgVector3* source) inline void bgc_fp64_hg_vector3_copy(BGC_FP64_HmgVector3* destination, const BGC_FP64_HmgVector3* source)
{ {
destination->x1 = source->x1; destination->x1 = source->x1;
destination->x2 = source->x2; destination->x2 = source->x2;
@ -138,7 +138,7 @@ inline void bgc_fp64_hg_vector3_copy(BGC_FP64_HgVector3* destination, const BGC_
// ==================== Swap ==================== // // ==================== Swap ==================== //
inline void bgc_fp32_hg_vector3_swap(BGC_FP32_HgVector3* first, BGC_FP32_HgVector3* second) inline void bgc_fp32_hg_vector3_swap(BGC_FP32_HmgVector3* first, BGC_FP32_HmgVector3* second)
{ {
const float x1 = first->x1; const float x1 = first->x1;
const float x2 = first->x2; const float x2 = first->x2;
@ -156,7 +156,7 @@ inline void bgc_fp32_hg_vector3_swap(BGC_FP32_HgVector3* first, BGC_FP32_HgVecto
second->d0 = d0; second->d0 = d0;
} }
inline void bgc_fp64_hg_vector3_swap(BGC_FP64_HgVector3* first, BGC_FP64_HgVector3* second) inline void bgc_fp64_hg_vector3_swap(BGC_FP64_HmgVector3* first, BGC_FP64_HmgVector3* second)
{ {
const double x1 = first->x1; const double x1 = first->x1;
const double x2 = first->x2; const double x2 = first->x2;
@ -176,7 +176,7 @@ inline void bgc_fp64_hg_vector3_swap(BGC_FP64_HgVector3* first, BGC_FP64_HgVecto
// ================== Rescale =================== // // ================== Rescale =================== //
inline int bgc_fp32_hg_vector3_rescale(BGC_FP32_HgVector3* homogeneous_vector, const float new_ratio) inline int bgc_fp32_hg_vector3_rescale(BGC_FP32_HmgVector3* homogeneous_vector, const float new_ratio)
{ {
if (bgc_fp32_is_zero(homogeneous_vector->d0)) { if (bgc_fp32_is_zero(homogeneous_vector->d0)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -192,7 +192,7 @@ inline int bgc_fp32_hg_vector3_rescale(BGC_FP32_HgVector3* homogeneous_vector, c
return BGC_SUCCESS; return BGC_SUCCESS;
} }
inline int bgc_fp64_hg_vector3_rescale(BGC_FP64_HgVector3* homogeneous_vector, const double new_ratio) inline int bgc_fp64_hg_vector3_rescale(BGC_FP64_HmgVector3* homogeneous_vector, const double new_ratio)
{ {
if (bgc_fp64_is_zero(homogeneous_vector->d0)) { if (bgc_fp64_is_zero(homogeneous_vector->d0)) {
return BGC_FAILURE; return BGC_FAILURE;

15
basic-geometry/position2.h
View file

@ -1,22 +1,11 @@
#ifndef _BGC_POSITION2_H_INCLUDED_ #ifndef _BGC_POSITION2_H_INCLUDED_
#define _BGC_POSITION2_H_INCLUDED_ #define _BGC_POSITION2_H_INCLUDED_
#include "./types.h"
#include "./vector2.h" #include "./vector2.h"
#include "./affine2.h" #include "./matrix2x2.h"
#include "./turn2.h" #include "./turn2.h"
// ==================== Types ==================== //
typedef struct {
BGC_FP32_Turn2 turn;
BGC_FP32_Vector2 shift;
} BGC_FP32_Position2;
typedef struct {
BGC_FP64_Turn2 turn;
BGC_FP64_Vector2 shift;
} BGC_FP64_Position2;
// ==================== Reset ==================== // // ==================== Reset ==================== //
inline void bgc_fp32_position2_reset(BGC_FP32_Position2* position) inline void bgc_fp32_position2_reset(BGC_FP32_Position2* position)

15
basic-geometry/position3.h
View file

@ -1,22 +1,11 @@
#ifndef _BGC_POSITION3_H_INCLUDED_ #ifndef _BGC_POSITION3_H_INCLUDED_
#define _BGC_POSITION3_H_INCLUDED_ #define _BGC_POSITION3_H_INCLUDED_
#include "./types.h"
#include "./vector3.h" #include "./vector3.h"
#include "./affine3.h" #include "./matrix3x3.h"
#include "./turn3.h" #include "./turn3.h"
// ==================== Types ==================== //
typedef struct {
BGC_FP32_Turn3 turn;
BGC_FP32_Vector3 shift;
} BGC_FP32_Position3;
typedef struct {
BGC_FP64_Turn3 turn;
BGC_FP64_Vector3 shift;
} BGC_FP64_Position3;
// ==================== Reset ==================== // // ==================== Reset ==================== //
inline void bgc_fp32_position3_reset(BGC_FP32_Position3 * position) inline void bgc_fp32_position3_reset(BGC_FP32_Position3 * position)

95
basic-geometry/slerp.c
View file

@ -1,95 +0,0 @@
#include "./slerp.h"
extern inline void bgc_fp32_slerp_reset(BGC_FP32_Turn3Slerp* slerp);
extern inline void bgc_fp64_slerp_reset(BGC_FP64_Turn3Slerp* slerp);
extern inline void bgc_fp32_slerp_make_full(BGC_FP32_Turn3Slerp* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
extern inline void bgc_fp64_slerp_make_full(BGC_FP64_Turn3Slerp* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
extern inline void bgc_fp32_slerp_make_shortened(BGC_FP32_Turn3Slerp* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
extern inline void bgc_fp64_slerp_make_shortened(BGC_FP64_Turn3Slerp* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
extern inline void bgc_fp32_slerp_get_phase_versor(BGC_FP32_Turn3* versor, const BGC_FP32_Turn3Slerp* slerp, const float phase);
extern inline void bgc_fp64_slerp_get_phase_versor(BGC_FP64_Turn3* versor, const BGC_FP64_Turn3Slerp* slerp, const double phase);
void bgc_fp32_slerp_make(BGC_FP32_Turn3Slerp* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment)
{
const float square_vector = augment->_versor.x1 * augment->_versor.x1 + augment->_versor.x2 * augment->_versor.x2 + augment->_versor.x3 * augment->_versor.x3;
if (isnan(square_vector)) {
bgc_fp32_slerp_reset(slerp);
return;
}
if (square_vector <= BGC_FP32_SQUARE_EPSILON) {
slerp->_s0_cos_weight = start->_versor.s0;
slerp->_x1_cos_weight = start->_versor.x1;
slerp->_x2_cos_weight = start->_versor.x2;
slerp->_x3_cos_weight = start->_versor.x3;
slerp->_s0_sin_weight = 0.0f;
slerp->_x1_sin_weight = 0.0f;
slerp->_x2_sin_weight = 0.0f;
slerp->_x3_sin_weight = 0.0f;
slerp->radians = 0.0f;
return;
}
const float vector_modulus = sqrtf(square_vector);
slerp->radians = atan2f(vector_modulus, augment->_versor.s0);
const float multiplier = 1.0f / vector_modulus;
slerp->_s0_cos_weight = start->_versor.s0;
slerp->_x1_cos_weight = start->_versor.x1;
slerp->_x2_cos_weight = start->_versor.x2;
slerp->_x3_cos_weight = start->_versor.x3;
slerp->_s0_sin_weight = -multiplier * (augment->_versor.x1 * start->_versor.x1 + augment->_versor.x2 * start->_versor.x2 + augment->_versor.x3 * start->_versor.x3);
slerp->_x1_sin_weight = multiplier * (augment->_versor.x1 * start->_versor.s0 + augment->_versor.x2 * start->_versor.x3 - augment->_versor.x3 * start->_versor.x2);
slerp->_x2_sin_weight = multiplier * (augment->_versor.x2 * start->_versor.s0 - augment->_versor.x1 * start->_versor.x3 + augment->_versor.x3 * start->_versor.x1);
slerp->_x3_sin_weight = multiplier * (augment->_versor.x3 * start->_versor.s0 - augment->_versor.x2 * start->_versor.x1 + augment->_versor.x1 * start->_versor.x2);
}
void bgc_fp64_slerp_make(BGC_FP64_Turn3Slerp* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment)
{
const double square_vector = augment->_versor.x1 * augment->_versor.x1 + augment->_versor.x2 * augment->_versor.x2 + augment->_versor.x3 * augment->_versor.x3;
if (isnan(square_vector)) {
bgc_fp64_slerp_reset(slerp);
return;
}
if (square_vector <= BGC_FP64_SQUARE_EPSILON) {
slerp->_s0_cos_weight = start->_versor.s0;
slerp->_x1_cos_weight = start->_versor.x1;
slerp->_x2_cos_weight = start->_versor.x2;
slerp->_x3_cos_weight = start->_versor.x3;
slerp->_s0_sin_weight = 0.0;
slerp->_x1_sin_weight = 0.0;
slerp->_x2_sin_weight = 0.0;
slerp->_x3_sin_weight = 0.0;
slerp->radians = 0.0;
return;
}
const double vector_modulus = sqrt(square_vector);
slerp->radians = atan2(vector_modulus, augment->_versor.s0);
const double multiplier = 1.0 / vector_modulus;
slerp->_s0_cos_weight = start->_versor.s0;
slerp->_x1_cos_weight = start->_versor.x1;
slerp->_x2_cos_weight = start->_versor.x2;
slerp->_x3_cos_weight = start->_versor.x3;
slerp->_s0_sin_weight = -multiplier * (augment->_versor.x1 * start->_versor.x1 + augment->_versor.x2 * start->_versor.x2 + augment->_versor.x3 * start->_versor.x3);
slerp->_x1_sin_weight = multiplier * (augment->_versor.x1 * start->_versor.s0 + augment->_versor.x2 * start->_versor.x3 - augment->_versor.x3 * start->_versor.x2);
slerp->_x2_sin_weight = multiplier * (augment->_versor.x2 * start->_versor.s0 - augment->_versor.x1 * start->_versor.x3 + augment->_versor.x3 * start->_versor.x1);
slerp->_x3_sin_weight = multiplier * (augment->_versor.x3 * start->_versor.s0 - augment->_versor.x2 * start->_versor.x1 + augment->_versor.x1 * start->_versor.x2);
}

112
basic-geometry/slerp.h
View file

@ -1,112 +0,0 @@
#ifndef _BGC_SLERP_H_INCLUDED_
#define _BGC_SLERP_H_INCLUDED_
#include "./types.h"
#include "./turn3.h"
inline void bgc_fp32_slerp_reset(BGC_FP32_Turn3Slerp* slerp)
{
slerp->_s0_cos_weight = 1.0f;
slerp->_s0_sin_weight = 0.0f;
slerp->_x1_cos_weight = 0.0f;
slerp->_x1_sin_weight = 0.0f;
slerp->_x2_cos_weight = 0.0f;
slerp->_x2_sin_weight = 0.0f;
slerp->_x3_cos_weight = 0.0f;
slerp->_x3_sin_weight = 0.0f;
slerp->radians = 0.0f;
}
inline void bgc_fp64_slerp_reset(BGC_FP64_Turn3Slerp* slerp)
{
slerp->_s0_cos_weight = 1.0;
slerp->_s0_sin_weight = 0.0;
slerp->_x1_cos_weight = 0.0;
slerp->_x1_sin_weight = 0.0;
slerp->_x2_cos_weight = 0.0;
slerp->_x2_sin_weight = 0.0;
slerp->_x3_cos_weight = 0.0;
slerp->_x3_sin_weight = 0.0;
slerp->radians = 0.0;
}
void bgc_fp32_slerp_make(BGC_FP32_Turn3Slerp* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment);
void bgc_fp64_slerp_make(BGC_FP64_Turn3Slerp* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment);
inline void bgc_fp32_slerp_make_full(BGC_FP32_Turn3Slerp* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
{
BGC_FP32_Turn3 augment;
bgc_fp32_turn3_exclude(&augment, end, start);
bgc_fp32_slerp_make(slerp, start, &augment);
}
inline void bgc_fp64_slerp_make_full(BGC_FP64_Turn3Slerp* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
{
BGC_FP64_Turn3 augment;
bgc_fp64_turn3_exclude(&augment, end, start);
bgc_fp64_slerp_make(slerp, start, &augment);
}
inline void bgc_fp32_slerp_make_shortened(BGC_FP32_Turn3Slerp* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
{
BGC_FP32_Turn3 augment;
bgc_fp32_turn3_exclude(&augment, end, start);
bgc_fp32_turn3_shorten(&augment);
bgc_fp32_slerp_make(slerp, start, &augment);
}
inline void bgc_fp64_slerp_make_shortened(BGC_FP64_Turn3Slerp* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
{
BGC_FP64_Turn3 augment;
bgc_fp64_turn3_exclude(&augment, end, start);
bgc_fp64_turn3_shorten(&augment);
bgc_fp64_slerp_make(slerp, start, &augment);
}
inline void bgc_fp32_slerp_get_phase_versor(BGC_FP32_Turn3* versor, const BGC_FP32_Turn3Slerp* slerp, const float phase)
{
const float angle = slerp->radians * phase;
const float cosine = cosf(angle);
const float sine = sinf(angle);
bgc_fp32_turn3_set_raw_values(
versor,
slerp->_s0_cos_weight * cosine + slerp->_s0_sin_weight * sine,
slerp->_x1_cos_weight * cosine + slerp->_x1_sin_weight * sine,
slerp->_x2_cos_weight * cosine + slerp->_x2_sin_weight * sine,
slerp->_x3_cos_weight * cosine + slerp->_x3_sin_weight * sine
);
}
inline void bgc_fp64_slerp_get_phase_versor(BGC_FP64_Turn3* versor, const BGC_FP64_Turn3Slerp* slerp, const double phase)
{
const double angle = slerp->radians * phase;
const double cosine = cos(angle);
const double sine = sin(angle);
bgc_fp64_turn3_set_raw_values(
versor,
slerp->_s0_cos_weight * cosine + slerp->_s0_sin_weight * sine,
slerp->_x1_cos_weight * cosine + slerp->_x1_sin_weight * sine,
slerp->_x2_cos_weight * cosine + slerp->_x2_sin_weight * sine,
slerp->_x3_cos_weight * cosine + slerp->_x3_sin_weight * sine
);
}
#endif

104
basic-geometry/slerp3.c Normal file
View file

@ -0,0 +1,104 @@
#include "./slerp3.h"
extern inline void bgc_fp32_slerp_reset(BGC_FP32_Slerp3* slerp);
extern inline void bgc_fp64_slerp_reset(BGC_FP64_Slerp3* slerp);
extern inline void bgc_fp32_slerp_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
extern inline void bgc_fp64_slerp_make_full(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
extern inline void bgc_fp32_slerp_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
extern inline void bgc_fp64_slerp_make_shortened(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
extern inline void bgc_fp32_slerp_get_phase_turn(BGC_FP32_Turn3* versor, const BGC_FP32_Slerp3* slerp, const float phase);
extern inline void bgc_fp64_slerp_get_phase_turn(BGC_FP64_Turn3* versor, const BGC_FP64_Slerp3* slerp, const double phase);
extern inline void bgc_fp32_slerp_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotation_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
extern inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotation_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
extern inline void bgc_fp32_slerp_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
extern inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
extern inline void bgc_fp32_slerp_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_matrix, BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
extern inline void bgc_fp64_slerp_get_phase_both_matrices(BGC_FP64_Matrix3x3* rotation_matrix, BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
void bgc_fp32_slerp_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment)
{
const float square_vector = augment->_versor.x1 * augment->_versor.x1 + augment->_versor.x2 * augment->_versor.x2 + augment->_versor.x3 * augment->_versor.x3;
if (isnan(square_vector)) {
bgc_fp32_slerp_reset(slerp);
return;
}
if (square_vector <= BGC_FP32_SQUARE_EPSILON) {
slerp->_cosine_weight.s0 = start->_versor.s0;
slerp->_cosine_weight.x1 = start->_versor.x1;
slerp->_cosine_weight.x2 = start->_versor.x2;
slerp->_cosine_weight.x3 = start->_versor.x3;
slerp->_sine_weight.s0 = 0.0f;
slerp->_sine_weight.x1 = 0.0f;
slerp->_sine_weight.x2 = 0.0f;
slerp->_sine_weight.x3 = 0.0f;
slerp->radians = 0.0f;
return;
}
const float vector_modulus = sqrtf(square_vector);
slerp->radians = atan2f(vector_modulus, augment->_versor.s0);
const float multiplier = 1.0f / vector_modulus;
slerp->_cosine_weight.s0 = start->_versor.s0;
slerp->_cosine_weight.x1 = start->_versor.x1;
slerp->_cosine_weight.x2 = start->_versor.x2;
slerp->_cosine_weight.x3 = start->_versor.x3;
slerp->_sine_weight.s0 = -multiplier * (augment->_versor.x1 * start->_versor.x1 + augment->_versor.x2 * start->_versor.x2 + augment->_versor.x3 * start->_versor.x3);
slerp->_sine_weight.x1 = multiplier * (augment->_versor.x1 * start->_versor.s0 + augment->_versor.x2 * start->_versor.x3 - augment->_versor.x3 * start->_versor.x2);
slerp->_sine_weight.x2 = multiplier * (augment->_versor.x2 * start->_versor.s0 - augment->_versor.x1 * start->_versor.x3 + augment->_versor.x3 * start->_versor.x1);
slerp->_sine_weight.x3 = multiplier * (augment->_versor.x3 * start->_versor.s0 - augment->_versor.x2 * start->_versor.x1 + augment->_versor.x1 * start->_versor.x2);
}
void bgc_fp64_slerp_make(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment)
{
const double square_vector = augment->_versor.x1 * augment->_versor.x1 + augment->_versor.x2 * augment->_versor.x2 + augment->_versor.x3 * augment->_versor.x3;
if (isnan(square_vector)) {
bgc_fp64_slerp_reset(slerp);
return;
}
if (square_vector <= BGC_FP64_SQUARE_EPSILON) {
slerp->_cosine_weight.s0 = start->_versor.s0;
slerp->_cosine_weight.x1 = start->_versor.x1;
slerp->_cosine_weight.x2 = start->_versor.x2;
slerp->_cosine_weight.x3 = start->_versor.x3;
slerp->_sine_weight.s0 = 0.0;
slerp->_sine_weight.x1 = 0.0;
slerp->_sine_weight.x2 = 0.0;
slerp->_sine_weight.x3 = 0.0;
slerp->radians = 0.0;
return;
}
const double vector_modulus = sqrt(square_vector);
slerp->radians = atan2(vector_modulus, augment->_versor.s0);
const double multiplier = 1.0 / vector_modulus;
slerp->_cosine_weight.s0 = start->_versor.s0;
slerp->_cosine_weight.x1 = start->_versor.x1;
slerp->_cosine_weight.x2 = start->_versor.x2;
slerp->_cosine_weight.x3 = start->_versor.x3;
slerp->_sine_weight.s0 = -multiplier * (augment->_versor.x1 * start->_versor.x1 + augment->_versor.x2 * start->_versor.x2 + augment->_versor.x3 * start->_versor.x3);
slerp->_sine_weight.x1 = multiplier * (augment->_versor.x1 * start->_versor.s0 + augment->_versor.x2 * start->_versor.x3 - augment->_versor.x3 * start->_versor.x2);
slerp->_sine_weight.x2 = multiplier * (augment->_versor.x2 * start->_versor.s0 - augment->_versor.x1 * start->_versor.x3 + augment->_versor.x3 * start->_versor.x1);
slerp->_sine_weight.x3 = multiplier * (augment->_versor.x3 * start->_versor.s0 - augment->_versor.x2 * start->_versor.x1 + augment->_versor.x1 * start->_versor.x2);
}

207
basic-geometry/slerp3.h Normal file
View file

@ -0,0 +1,207 @@
#ifndef _BGC_SLERP_H_INCLUDED_
#define _BGC_SLERP_H_INCLUDED_
#include "./types.h"
#include "./quaternion.h"
#include "./turn3.h"
// =================== Reset ==================== //
inline void bgc_fp32_slerp_reset(BGC_FP32_Slerp3* slerp)
{
slerp->_cosine_weight.s0 = 1.0f;
slerp->_cosine_weight.x1 = 0.0f;
slerp->_cosine_weight.x2 = 0.0f;
slerp->_cosine_weight.x3 = 0.0f;
slerp->_sine_weight.s0 = 0.0f;
slerp->_sine_weight.x1 = 0.0f;
slerp->_sine_weight.x2 = 0.0f;
slerp->_sine_weight.x3 = 0.0f;
slerp->radians = 0.0f;
}
inline void bgc_fp64_slerp_reset(BGC_FP64_Slerp3* slerp)
{
slerp->_cosine_weight.s0 = 1.0;
slerp->_cosine_weight.x1 = 0.0;
slerp->_cosine_weight.x2 = 0.0;
slerp->_cosine_weight.x3 = 0.0;
slerp->_sine_weight.s0 = 0.0;
slerp->_sine_weight.x1 = 0.0;
slerp->_sine_weight.x2 = 0.0;
slerp->_sine_weight.x3 = 0.0;
slerp->radians = 0.0;
}
// ==================== Make ==================== //
void bgc_fp32_slerp_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment);
void bgc_fp64_slerp_make(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment);
// ================= Make Full ================== //
inline void bgc_fp32_slerp_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
{
BGC_FP32_Turn3 augment;
bgc_fp32_turn3_exclude(&augment, end, start);
bgc_fp32_slerp_make(slerp, start, &augment);
}
inline void bgc_fp64_slerp_make_full(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
{
BGC_FP64_Turn3 augment;
bgc_fp64_turn3_exclude(&augment, end, start);
bgc_fp64_slerp_make(slerp, start, &augment);
}
// =============== Make Shortened =============== //
inline void bgc_fp32_slerp_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
{
BGC_FP32_Turn3 augment;
bgc_fp32_turn3_exclude(&augment, end, start);
bgc_fp32_turn3_shorten(&augment);
bgc_fp32_slerp_make(slerp, start, &augment);
}
inline void bgc_fp64_slerp_make_shortened(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
{
BGC_FP64_Turn3 augment;
bgc_fp64_turn3_exclude(&augment, end, start);
bgc_fp64_turn3_shorten(&augment);
bgc_fp64_slerp_make(slerp, start, &augment);
}
// =============== Get Phase Turn =============== //
inline void bgc_fp32_slerp_get_phase_turn(BGC_FP32_Turn3* turn, const BGC_FP32_Slerp3* slerp, const float phase)
{
const float angle = slerp->radians * phase;
const float cosine = cosf(angle);
const float sine = sinf(angle);
BGC_FP32_Quaternion q;
bgc_fp32_quaternion_multiply_by_real(&q, &slerp->_cosine_weight, cosine);
bgc_fp32_quaternion_add_scaled(&q, &q, &slerp->_sine_weight, sine);
bgc_fp32_turn3_set_quaternion(turn, &q);
}
inline void bgc_fp64_slerp_get_phase_turn(BGC_FP64_Turn3* turn, const BGC_FP64_Slerp3* slerp, const double phase)
{
const double angle = slerp->radians * phase;
const double cosine = cos(angle);
const double sine = sin(angle);
BGC_FP64_Quaternion q;
bgc_fp64_quaternion_multiply_by_real(&q, &slerp->_cosine_weight, cosine);
bgc_fp64_quaternion_add_scaled(&q, &q, &slerp->_sine_weight, sine);
bgc_fp64_turn3_set_quaternion(turn, &q);
}
// ========= Get Phase Rotation Matrix ========== //
inline void bgc_fp32_slerp_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotation_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
{
const float angle = slerp->radians * phase;
const float cosine = cosf(angle);
const float sine = sinf(angle);
BGC_FP32_Quaternion q;
bgc_fp32_quaternion_multiply_by_real(&q, &slerp->_cosine_weight, cosine);
bgc_fp32_quaternion_add_scaled(&q, &q, &slerp->_sine_weight, sine);
bgc_fp32_quaternion_get_rotation_matrix(rotation_matrix, &q);
}
inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotation_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
{
const double angle = slerp->radians * phase;
const double cosine = cos(angle);
const double sine = sin(angle);
BGC_FP64_Quaternion q;
bgc_fp64_quaternion_multiply_by_real(&q, &slerp->_cosine_weight, cosine);
bgc_fp64_quaternion_add_scaled(&q, &q, &slerp->_sine_weight, sine);
bgc_fp64_quaternion_get_rotation_matrix(rotation_matrix, &q);
}
// ========== Get Phase Reverse Matrix ========== //
inline void bgc_fp32_slerp_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
{
const float angle = slerp->radians * phase;
const float cosine = cosf(angle);
const float sine = sinf(angle);
BGC_FP32_Quaternion q;
bgc_fp32_quaternion_multiply_by_real(&q, &slerp->_cosine_weight, cosine);
bgc_fp32_quaternion_add_scaled(&q, &q, &slerp->_sine_weight, sine);
bgc_fp32_quaternion_get_reverse_matrix(reverse_matrix, &q);
}
inline void bgc_fp64_slerp_get_phase_reverse_matrix(BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
{
const double angle = slerp->radians * phase;
const double cosine = cos(angle);
const double sine = sin(angle);
BGC_FP64_Quaternion q;
bgc_fp64_quaternion_multiply_by_real(&q, &slerp->_cosine_weight, cosine);
bgc_fp64_quaternion_add_scaled(&q, &q, &slerp->_sine_weight, sine);
bgc_fp64_quaternion_get_reverse_matrix(reverse_matrix, &q);
}
// ========== Get Phase Both Matrices =========== //
inline void bgc_fp32_slerp_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_matrix, BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
{
const float angle = slerp->radians * phase;
const float cosine = cosf(angle);
const float sine = sinf(angle);
BGC_FP32_Quaternion q;
bgc_fp32_quaternion_multiply_by_real(&q, &slerp->_cosine_weight, cosine);
bgc_fp32_quaternion_add_scaled(&q, &q, &slerp->_sine_weight, sine);
bgc_fp32_quaternion_get_both_matrices(rotation_matrix, reverse_matrix, &q);
}
inline void bgc_fp64_slerp_get_phase_both_matrices(BGC_FP64_Matrix3x3* rotation_matrix, BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
{
const double angle = slerp->radians * phase;
const double cosine = cos(angle);
const double sine = sin(angle);
BGC_FP64_Quaternion q;
bgc_fp64_quaternion_multiply_by_real(&q, &slerp->_cosine_weight, cosine);
bgc_fp64_quaternion_add_scaled(&q, &q, &slerp->_sine_weight, sine);
bgc_fp64_quaternion_get_both_matrices(rotation_matrix, reverse_matrix, &q);
}
#endif

68
basic-geometry/types.h
View file

@ -145,23 +145,41 @@ typedef struct {
BGC_FP64_Quaternion _versor; BGC_FP64_Quaternion _versor;
} BGC_FP64_Turn3; } BGC_FP64_Turn3;
// ================ Turn3 Slerp ================= // // =================== Slerp3 =================== //
typedef struct { typedef struct {
float _s0_cos_weight, _s0_sin_weight; BGC_FP32_Quaternion _cosine_weight, _sine_weight;
float _x1_cos_weight, _x1_sin_weight;
float _x2_cos_weight, _x2_sin_weight;
float _x3_cos_weight, _x3_sin_weight;
float radians; float radians;
} BGC_FP32_Turn3Slerp; } BGC_FP32_Slerp3;
typedef struct { typedef struct {
double _s0_cos_weight, _s0_sin_weight; BGC_FP64_Quaternion _cosine_weight, _sine_weight;
double _x1_cos_weight, _x1_sin_weight;
double _x2_cos_weight, _x2_sin_weight;
double _x3_cos_weight, _x3_sin_weight;
double radians; double radians;
} BGC_FP64_Turn3Slerp; } BGC_FP64_Slerp3;
// ================= Position2 ================== //
typedef struct {
BGC_FP32_Turn2 turn;
BGC_FP32_Vector2 shift;
} BGC_FP32_Position2;
typedef struct {
BGC_FP64_Turn2 turn;
BGC_FP64_Vector2 shift;
} BGC_FP64_Position2;
// ================= Position3 ================== //
typedef struct {
BGC_FP32_Turn3 turn;
BGC_FP32_Vector3 shift;
} BGC_FP32_Position3;
typedef struct {
BGC_FP64_Turn3 turn;
BGC_FP64_Vector3 shift;
} BGC_FP64_Position3;
// =========== Homogeneous 3D Vector ============ // // =========== Homogeneous 3D Vector ============ //
@ -169,13 +187,13 @@ typedef struct {
typedef struct typedef struct
{ {
float x1, x2, x3, d0; float x1, x2, x3, d0;
} BGC_FP32_HgVector3; } BGC_FP32_HmgVector3;
// Homogeneous 3D Vector // Homogeneous 3D Vector
typedef struct typedef struct
{ {
double x1, x2, x3, d0; double x1, x2, x3, d0;
} BGC_FP64_HgVector3; } BGC_FP64_HmgVector3;
// =========== Homogeneous Matrix3x3 ============ // // =========== Homogeneous Matrix3x3 ============ //
@ -186,7 +204,7 @@ typedef struct
float r2c1, r2c2, r2c3, r2d0; float r2c1, r2c2, r2c3, r2d0;
float r3c1, r3c2, r3c3, r3d0; float r3c1, r3c2, r3c3, r3d0;
float d0c1, d0c2, d0c3, d0d0; float d0c1, d0c2, d0c3, d0d0;
} BGC_FP32_HgMatrix3x3; } BGC_FP32_HmgMatrix3x3;
// Homogeneous Matrix3x3 based on double type // Homogeneous Matrix3x3 based on double type
typedef struct typedef struct
@ -195,36 +213,36 @@ typedef struct
double r2c1, r2c2, r2c3, r2d0; double r2c1, r2c2, r2c3, r2d0;
double r3c1, r3c2, r3c3, r3d0; double r3c1, r3c2, r3c3, r3d0;
double d0c1, d0c2, d0c3, d0d0; double d0c1, d0c2, d0c3, d0d0;
} BGC_FP64_HgMatrix3x3; } BGC_FP64_HmgMatrix3x3;
// ================ Dual Number ================= // // ================ Dual Scalar ================= //
typedef struct { typedef struct {
float real, dual; float real_part, dual_part;
} BGC_FP32_DualNumber; } BGC_FP32_DualScalar;
typedef struct { typedef struct {
double real, dual; double real_part, dual_part;
} BGC_FP64_DualNumber; } BGC_FP64_DualScalar;
// ================ Dual Vector ================= // // ================ Dual Vector ================= //
typedef struct { typedef struct {
BGC_FP32_Vector3 real, dual; BGC_FP32_Vector3 real_part, dual_part;
} BGC_FP32_DualVector3; } BGC_FP32_DualVector3;
typedef struct { typedef struct {
BGC_FP64_Vector3 real, dual; BGC_FP64_Vector3 real_part, dual_part;
} BGC_FP64_DualVector3; } BGC_FP64_DualVector3;
// ============== Dual Quaternion =============== // // ============== Dual Quaternion =============== //
typedef struct { typedef struct {
BGC_FP32_Quaternion real, dual; BGC_FP32_Quaternion real_part, dual_part;
} BGC_FP32_DualQuaternion; } BGC_FP32_DualQuaternion;
typedef struct { typedef struct {
BGC_FP64_Quaternion real, dual; BGC_FP64_Quaternion real_part, dual_part;
} BGC_FP64_DualQuaternion; } BGC_FP64_DualQuaternion;
#endif // _BGC_MATRIX_TYPES_H_ #endif