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

Internal server error - Personal Git Server: Beyond coding. We Forge.

500

Internal server error

Forgejo version: 11.0.1+gitea-1.22.0

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