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

Переименование методов на распространённые названия

Browse source
This commit is contained in:
Andrey Pokidov 2026-02-16 20:41:45 +07:00
parent 039b26305a
commit b621191698
14 changed files with 192 additions and 192 deletions
Download patch file Download diff file Expand all files Collapse all files

4
basic-geometry-dev/main.c
View file

@ -63,12 +63,12 @@ void print_quaternion_fp64(const BGC_FP64_Quaternion* quaternion)
void print_vector_fp32(const BGC_FP32_Vector3* vector) void print_vector_fp32(const BGC_FP32_Vector3* vector)
{ {
printf("(%f, %f, %f) / %f\n", vector->x1, vector->x2, vector->x3, bgc_fp32_vector3_get_modulus(vector)); printf("(%f, %f, %f) / %f\n", vector->x1, vector->x2, vector->x3, bgc_fp32_vector3_get_length(vector));
} }
void print_vector_fp64(const BGC_FP64_Vector3* vector) void print_vector_fp64(const BGC_FP64_Vector3* vector)
{ {
printf("(%lf, %lf, %lf) / %lf\n", vector->x1, vector->x2, vector->x3, bgc_fp64_vector3_get_modulus(vector)); printf("(%lf, %lf, %lf) / %lf\n", vector->x1, vector->x2, vector->x3, bgc_fp64_vector3_get_length(vector));
} }
void list_work(const uint_fast32_t amount, structure_fp32_t* list) void list_work(const uint_fast32_t amount, structure_fp32_t* list)

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

@ -60,14 +60,14 @@
<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>

2
basic-geometry/dual-quaternion.c
View file

@ -30,7 +30,7 @@ extern inline void bgc_fp64_dual_quaternion_subtract(BGC_FP64_DualQuaternion* di
extern inline void bgc_fp32_dual_quaternion_subtract_scaled(BGC_FP32_DualQuaternion* difference, const BGC_FP32_DualQuaternion* base_quaternion, const BGC_FP32_DualQuaternion* scalable_quaternion, const float scale); extern inline void bgc_fp32_dual_quaternion_subtract_scaled(BGC_FP32_DualQuaternion* difference, const BGC_FP32_DualQuaternion* base_quaternion, const BGC_FP32_DualQuaternion* scalable_quaternion, const float scale);
extern inline void bgc_fp64_dual_quaternion_subtract_scaled(BGC_FP64_DualQuaternion* difference, const BGC_FP64_DualQuaternion* base_quaternion, const BGC_FP64_DualQuaternion* scalable_quaternion, const double scale); extern inline void bgc_fp64_dual_quaternion_subtract_scaled(BGC_FP64_DualQuaternion* difference, const BGC_FP64_DualQuaternion* base_quaternion, const BGC_FP64_DualQuaternion* scalable_quaternion, const double scale);
extern inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier); extern inline void bgc_fp32_dual_quaternion_multiply_by_real_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier);
extern inline void bgc_fp64_dual_quaternion_multiply_by_real(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const double multiplier); extern inline void bgc_fp64_dual_quaternion_multiply_by_real(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const double multiplier);
extern inline void bgc_fp32_dual_quaternion_multiply_by_dual_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const BGC_FP32_DualNumber* multiplier); extern inline void bgc_fp32_dual_quaternion_multiply_by_dual_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const BGC_FP32_DualNumber* multiplier);

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

@ -146,7 +146,7 @@ inline void bgc_fp64_dual_quaternion_subtract_scaled(BGC_FP64_DualQuaternion* di
// ================== Multiply ================== // // ================== Multiply ================== //
inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier) inline void bgc_fp32_dual_quaternion_multiply_by_real_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier)
{ {
bgc_fp32_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier); bgc_fp32_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier);
bgc_fp32_quaternion_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multiplier); bgc_fp32_quaternion_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multiplier);
@ -247,7 +247,7 @@ inline int bgc_fp32_dual_quaternion_divide_by_dual_number(BGC_FP32_DualQuaternio
} }
bgc_fp32_dual_quaternion_multiply_by_conjugate_number(quotient, dividend, divisor); bgc_fp32_dual_quaternion_multiply_by_conjugate_number(quotient, dividend, divisor);
bgc_fp32_dual_quaternion_multiply_by_real(quotient, quotient, 1.0f / square_modulus); bgc_fp32_dual_quaternion_multiply_by_real_number(quotient, quotient, 1.0f / square_modulus);
return BGC_SUCCESS; return BGC_SUCCESS;
} }
@ -277,7 +277,7 @@ inline int bgc_fp32_dual_quaternion_divide_by_conjugate_number(BGC_FP32_DualQuat
} }
bgc_fp32_dual_quaternion_multiply_by_dual_number(quotient, dividend, divisor_to_conjugate); bgc_fp32_dual_quaternion_multiply_by_dual_number(quotient, dividend, divisor_to_conjugate);
bgc_fp32_dual_quaternion_multiply_by_real(quotient, quotient, 1.0f / square_modulus); bgc_fp32_dual_quaternion_multiply_by_real_number(quotient, quotient, 1.0f / square_modulus);
return BGC_SUCCESS; return BGC_SUCCESS;
} }

8
basic-geometry/quaternion.c
View file

@ -10,11 +10,11 @@ extern inline void bgc_fp64_quaternion_make_unit(BGC_FP64_Quaternion* quaternion
extern inline void bgc_fp32_quaternion_make(BGC_FP32_Quaternion* quaternion, const float s0, const float x1, const float x2, const float x3); extern inline void bgc_fp32_quaternion_make(BGC_FP32_Quaternion* quaternion, const float s0, const float x1, const float x2, const float x3);
extern inline void bgc_fp64_quaternion_make(BGC_FP64_Quaternion* quaternion, const double s0, const double x1, const double x2, const double x3); extern inline void bgc_fp64_quaternion_make(BGC_FP64_Quaternion* quaternion, const double s0, const double x1, const double x2, const double x3);
extern inline float bgc_fp32_quaternion_get_square_modulus(const BGC_FP32_Quaternion* quaternion); extern inline float bgc_fp32_quaternion_get_square_magnitude(const BGC_FP32_Quaternion* quaternion);
extern inline double bgc_fp64_quaternion_get_square_modulus(const BGC_FP64_Quaternion* quaternion); extern inline double bgc_fp64_quaternion_get_square_magnitude(const BGC_FP64_Quaternion* quaternion);
extern inline float bgc_fp32_quaternion_get_modulus(const BGC_FP32_Quaternion* quaternion); extern inline float bgc_fp32_quaternion_get_magnitude(const BGC_FP32_Quaternion* quaternion);
extern inline double bgc_fp64_quaternion_get_modulus(const BGC_FP64_Quaternion* quaternion); extern inline double bgc_fp64_quaternion_get_magnitude(const BGC_FP64_Quaternion* quaternion);
extern inline int bgc_fp32_quaternion_is_zero(const BGC_FP32_Quaternion* quaternion); extern inline int bgc_fp32_quaternion_is_zero(const BGC_FP32_Quaternion* quaternion);
extern inline int bgc_fp64_quaternion_is_zero(const BGC_FP64_Quaternion* quaternion); extern inline int bgc_fp64_quaternion_is_zero(const BGC_FP64_Quaternion* quaternion);

56
basic-geometry/quaternion.h
View file

@ -64,50 +64,50 @@ inline void bgc_fp64_quaternion_make(BGC_FP64_Quaternion* quaternion, const doub
// ============= Get Square Modulus ============= // // ============= Get Square Modulus ============= //
inline float bgc_fp32_quaternion_get_square_modulus(const BGC_FP32_Quaternion* quaternion) inline float bgc_fp32_quaternion_get_square_magnitude(const BGC_FP32_Quaternion* quaternion)
{ {
return (quaternion->s0 * quaternion->s0 + quaternion->x1 * quaternion->x1) + (quaternion->x2 * quaternion->x2 + quaternion->x3 * quaternion->x3); return (quaternion->s0 * quaternion->s0 + quaternion->x1 * quaternion->x1) + (quaternion->x2 * quaternion->x2 + quaternion->x3 * quaternion->x3);
} }
inline double bgc_fp64_quaternion_get_square_modulus(const BGC_FP64_Quaternion* quaternion) inline double bgc_fp64_quaternion_get_square_magnitude(const BGC_FP64_Quaternion* quaternion)
{ {
return (quaternion->s0 * quaternion->s0 + quaternion->x1 * quaternion->x1) + (quaternion->x2 * quaternion->x2 + quaternion->x3 * quaternion->x3); return (quaternion->s0 * quaternion->s0 + quaternion->x1 * quaternion->x1) + (quaternion->x2 * quaternion->x2 + quaternion->x3 * quaternion->x3);
} }
// ================ Get Modulus ================= // // ================ Get Modulus ================= //
inline float bgc_fp32_quaternion_get_modulus(const BGC_FP32_Quaternion* quaternion) inline float bgc_fp32_quaternion_get_magnitude(const BGC_FP32_Quaternion* quaternion)
{ {
return sqrtf(bgc_fp32_quaternion_get_square_modulus(quaternion)); return sqrtf(bgc_fp32_quaternion_get_square_magnitude(quaternion));
} }
inline double bgc_fp64_quaternion_get_modulus(const BGC_FP64_Quaternion* quaternion) inline double bgc_fp64_quaternion_get_magnitude(const BGC_FP64_Quaternion* quaternion)
{ {
return sqrt(bgc_fp64_quaternion_get_square_modulus(quaternion)); return sqrt(bgc_fp64_quaternion_get_square_magnitude(quaternion));
} }
// ================== Is Zero =================== // // ================== Is Zero =================== //
inline int bgc_fp32_quaternion_is_zero(const BGC_FP32_Quaternion* quaternion) inline int bgc_fp32_quaternion_is_zero(const BGC_FP32_Quaternion* quaternion)
{ {
return bgc_fp32_quaternion_get_square_modulus(quaternion) <= BGC_FP32_SQUARE_EPSILON; return bgc_fp32_quaternion_get_square_magnitude(quaternion) <= BGC_FP32_SQUARE_EPSILON;
} }
inline int bgc_fp64_quaternion_is_zero(const BGC_FP64_Quaternion* quaternion) inline int bgc_fp64_quaternion_is_zero(const BGC_FP64_Quaternion* quaternion)
{ {
return bgc_fp64_quaternion_get_square_modulus(quaternion) <= BGC_FP64_SQUARE_EPSILON; return bgc_fp64_quaternion_get_square_magnitude(quaternion) <= BGC_FP64_SQUARE_EPSILON;
} }
// ================== Is Unit =================== // // ================== Is Unit =================== //
inline int bgc_fp32_quaternion_is_unit(const BGC_FP32_Quaternion* quaternion) inline int bgc_fp32_quaternion_is_unit(const BGC_FP32_Quaternion* quaternion)
{ {
return bgc_fp32_is_square_unit(bgc_fp32_quaternion_get_square_modulus(quaternion)); return bgc_fp32_is_square_unit(bgc_fp32_quaternion_get_square_magnitude(quaternion));
} }
inline int bgc_fp64_quaternion_is_unit(const BGC_FP64_Quaternion* quaternion) inline int bgc_fp64_quaternion_is_unit(const BGC_FP64_Quaternion* quaternion)
{ {
return bgc_fp64_is_square_unit(bgc_fp64_quaternion_get_square_modulus(quaternion)); return bgc_fp64_is_square_unit(bgc_fp64_quaternion_get_square_magnitude(quaternion));
} }
// ==================== Copy ==================== // // ==================== Copy ==================== //
@ -358,7 +358,7 @@ inline int bgc_fp64_quaternion_divide_by_real(BGC_FP64_Quaternion* quotient, con
inline int bgc_fp32_quaternion_divide_by_quaternion(BGC_FP32_Quaternion* quotient, const BGC_FP32_Quaternion* divident, const BGC_FP32_Quaternion* divisor) inline int bgc_fp32_quaternion_divide_by_quaternion(BGC_FP32_Quaternion* quotient, const BGC_FP32_Quaternion* divident, const BGC_FP32_Quaternion* divisor)
{ {
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(divisor); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(divisor);
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -372,7 +372,7 @@ inline int bgc_fp32_quaternion_divide_by_quaternion(BGC_FP32_Quaternion* quotien
inline int bgc_fp64_quaternion_divide_by_quaternion(BGC_FP64_Quaternion* quotient, const BGC_FP64_Quaternion* divident, const BGC_FP64_Quaternion* divisor) inline int bgc_fp64_quaternion_divide_by_quaternion(BGC_FP64_Quaternion* quotient, const BGC_FP64_Quaternion* divident, const BGC_FP64_Quaternion* divisor)
{ {
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(divisor); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(divisor);
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -388,7 +388,7 @@ inline int bgc_fp64_quaternion_divide_by_quaternion(BGC_FP64_Quaternion* quotien
inline int bgc_fp32_quaternion_divide_by_conjugate(BGC_FP32_Quaternion* quotient, const BGC_FP32_Quaternion* divident, const BGC_FP32_Quaternion* divisor_to_conjugate) inline int bgc_fp32_quaternion_divide_by_conjugate(BGC_FP32_Quaternion* quotient, const BGC_FP32_Quaternion* divident, const BGC_FP32_Quaternion* divisor_to_conjugate)
{ {
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(divisor_to_conjugate); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(divisor_to_conjugate);
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -402,7 +402,7 @@ inline int bgc_fp32_quaternion_divide_by_conjugate(BGC_FP32_Quaternion* quotient
inline int bgc_fp64_quaternion_divide_by_conjugate(BGC_FP64_Quaternion* quotient, const BGC_FP64_Quaternion* divident, const BGC_FP64_Quaternion* divisor_to_conjugate) inline int bgc_fp64_quaternion_divide_by_conjugate(BGC_FP64_Quaternion* quotient, const BGC_FP64_Quaternion* divident, const BGC_FP64_Quaternion* divisor_to_conjugate)
{ {
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(divisor_to_conjugate); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(divisor_to_conjugate);
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -542,7 +542,7 @@ inline void bgc_fp64_quaternion_get_reverse(BGC_FP64_Quaternion* reverse, const
inline int bgc_fp32_quaternion_get_inverse(BGC_FP32_Quaternion* inverse, const BGC_FP32_Quaternion* quaternion) inline int bgc_fp32_quaternion_get_inverse(BGC_FP32_Quaternion* inverse, const BGC_FP32_Quaternion* quaternion)
{ {
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -560,7 +560,7 @@ inline int bgc_fp32_quaternion_get_inverse(BGC_FP32_Quaternion* inverse, const B
inline int bgc_fp64_quaternion_get_inverse(BGC_FP64_Quaternion* inverse, const BGC_FP64_Quaternion* quaternion) inline int bgc_fp64_quaternion_get_inverse(BGC_FP64_Quaternion* inverse, const BGC_FP64_Quaternion* quaternion)
{ {
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -590,7 +590,7 @@ inline int bgc_fp64_quaternion_invert(BGC_FP64_Quaternion* quaternion)
inline int bgc_fp32_quaternion_normalize(BGC_FP32_Quaternion* quaternion) inline int bgc_fp32_quaternion_normalize(BGC_FP32_Quaternion* quaternion)
{ {
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -612,7 +612,7 @@ inline int bgc_fp32_quaternion_normalize(BGC_FP32_Quaternion* quaternion)
inline int bgc_fp64_quaternion_normalize(BGC_FP64_Quaternion* quaternion) inline int bgc_fp64_quaternion_normalize(BGC_FP64_Quaternion* quaternion)
{ {
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -634,7 +634,7 @@ inline int bgc_fp64_quaternion_normalize(BGC_FP64_Quaternion* quaternion)
inline int bgc_fp32_quaternion_get_normalized(BGC_FP32_Quaternion* normalized, const BGC_FP32_Quaternion* quaternion) inline int bgc_fp32_quaternion_get_normalized(BGC_FP32_Quaternion* normalized, const BGC_FP32_Quaternion* quaternion)
{ {
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
bgc_fp32_quaternion_reset(normalized); bgc_fp32_quaternion_reset(normalized);
@ -652,7 +652,7 @@ inline int bgc_fp32_quaternion_get_normalized(BGC_FP32_Quaternion* normalized, c
inline int bgc_fp64_quaternion_get_normalized(BGC_FP64_Quaternion* normalized, const BGC_FP64_Quaternion* quaternion) inline int bgc_fp64_quaternion_get_normalized(BGC_FP64_Quaternion* normalized, const BGC_FP64_Quaternion* quaternion)
{ {
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
bgc_fp64_quaternion_reset(normalized); bgc_fp64_quaternion_reset(normalized);
@ -746,7 +746,7 @@ inline void _bgc_fp64_quaternion_turn_vector_back_roughly(BGC_FP64_Vector3* turn
inline int bgc_fp32_quaternion_turn_vector(BGC_FP32_Vector3* turned_vector, const BGC_FP32_Quaternion* quaternion, const BGC_FP32_Vector3* original_vector) inline int bgc_fp32_quaternion_turn_vector(BGC_FP32_Vector3* turned_vector, const BGC_FP32_Quaternion* quaternion, const BGC_FP32_Vector3* original_vector)
{ {
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
if (square_modulus < BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus < BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -772,7 +772,7 @@ inline int bgc_fp32_quaternion_turn_vector(BGC_FP32_Vector3* turned_vector, cons
inline int bgc_fp64_quaternion_turn_vector(BGC_FP64_Vector3* turned_vector, const BGC_FP64_Quaternion* quaternion, const BGC_FP64_Vector3* original_vector) inline int bgc_fp64_quaternion_turn_vector(BGC_FP64_Vector3* turned_vector, const BGC_FP64_Quaternion* quaternion, const BGC_FP64_Vector3* original_vector)
{ {
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
if (square_modulus < BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus < BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -800,7 +800,7 @@ inline int bgc_fp64_quaternion_turn_vector(BGC_FP64_Vector3* turned_vector, cons
inline int bgc_fp32_quaternion_turn_vector_back(BGC_FP32_Vector3* turned_vector, const BGC_FP32_Quaternion* quaternion, const BGC_FP32_Vector3* original_vector) inline int bgc_fp32_quaternion_turn_vector_back(BGC_FP32_Vector3* turned_vector, const BGC_FP32_Quaternion* quaternion, const BGC_FP32_Vector3* original_vector)
{ {
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
if (square_modulus < BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus < BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -826,7 +826,7 @@ inline int bgc_fp32_quaternion_turn_vector_back(BGC_FP32_Vector3* turned_vector,
inline int bgc_fp64_quaternion_turn_vector_back(BGC_FP64_Vector3* turned_vector, const BGC_FP64_Quaternion* quaternion, const BGC_FP64_Vector3* original_vector) inline int bgc_fp64_quaternion_turn_vector_back(BGC_FP64_Vector3* turned_vector, const BGC_FP64_Quaternion* quaternion, const BGC_FP64_Vector3* original_vector)
{ {
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
if (square_modulus < BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) { if (square_modulus < BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE; return BGC_FAILURE;
@ -1049,8 +1049,8 @@ inline int bgc_fp32_quaternion_are_close(const BGC_FP32_Quaternion* quaternion1,
const float dx2 = quaternion1->x2 - quaternion2->x2; const float dx2 = quaternion1->x2 - quaternion2->x2;
const float dx3 = quaternion1->x3 - quaternion2->x3; const float dx3 = quaternion1->x3 - quaternion2->x3;
const float square_modulus1 = bgc_fp32_quaternion_get_square_modulus(quaternion1); const float square_modulus1 = bgc_fp32_quaternion_get_square_magnitude(quaternion1);
const float square_modulus2 = bgc_fp32_quaternion_get_square_modulus(quaternion2); const float square_modulus2 = bgc_fp32_quaternion_get_square_magnitude(quaternion2);
const float square_distance = (ds0 * ds0 + dx1 * dx1) + (dx2 * dx2 + dx3 * dx3); const float square_distance = (ds0 * ds0 + dx1 * dx1) + (dx2 * dx2 + dx3 * dx3);
if (square_modulus1 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT) { if (square_modulus1 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT) {
@ -1067,8 +1067,8 @@ inline int bgc_fp64_quaternion_are_close(const BGC_FP64_Quaternion* quaternion1,
const double dx2 = quaternion1->x2 - quaternion2->x2; const double dx2 = quaternion1->x2 - quaternion2->x2;
const double dx3 = quaternion1->x3 - quaternion2->x3; const double dx3 = quaternion1->x3 - quaternion2->x3;
const double square_modulus1 = bgc_fp64_quaternion_get_square_modulus(quaternion1); const double square_modulus1 = bgc_fp64_quaternion_get_square_magnitude(quaternion1);
const double square_modulus2 = bgc_fp64_quaternion_get_square_modulus(quaternion2); const double square_modulus2 = bgc_fp64_quaternion_get_square_magnitude(quaternion2);
const double square_distance = (ds0 * ds0 + dx1 * dx1) + (dx2 * dx2 + dx3 * dx3); const double square_distance = (ds0 * ds0 + dx1 * dx1) + (dx2 * dx2 + dx3 * dx3);
if (square_modulus1 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT) { if (square_modulus1 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT) {

36
basic-geometry/slerp3.c
View file

@ -1,32 +1,32 @@
#include "./slerp3.h" #include "./slerp3.h"
extern inline void bgc_fp32_slerp_reset(BGC_FP32_Slerp3* slerp); extern inline void bgc_fp32_slerp3_reset(BGC_FP32_Slerp3* slerp);
extern inline void bgc_fp64_slerp_reset(BGC_FP64_Slerp3* slerp); extern inline void bgc_fp64_slerp3_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_fp32_slerp3_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_fp64_slerp3_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_fp32_slerp3_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_fp64_slerp3_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_fp32_slerp3_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_fp64_slerp3_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_fp32_slerp3_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_fp64_slerp3_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_fp32_slerp3_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_fp64_slerp3_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_fp32_slerp3_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); extern inline void bgc_fp64_slerp3_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) void bgc_fp32_slerp3_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; 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)) { if (isnan(square_vector)) {
bgc_fp32_slerp_reset(slerp); bgc_fp32_slerp3_reset(slerp);
return; return;
} }
@ -62,12 +62,12 @@ void bgc_fp32_slerp_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, co
slerp->_sine_weight.x3 = multiplier * (augment->_versor.x3 * start->_versor.s0 - augment->_versor.x2 * start->_versor.x1 + augment->_versor.x1 * start->_versor.x2); 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) void bgc_fp64_slerp3_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; 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)) { if (isnan(square_vector)) {
bgc_fp64_slerp_reset(slerp); bgc_fp64_slerp3_reset(slerp);
return; return;
} }

40
basic-geometry/slerp3.h
View file

@ -7,7 +7,7 @@
// =================== Reset ==================== // // =================== Reset ==================== //
inline void bgc_fp32_slerp_reset(BGC_FP32_Slerp3* slerp) inline void bgc_fp32_slerp3_reset(BGC_FP32_Slerp3* slerp)
{ {
slerp->_cosine_weight.s0 = 1.0f; slerp->_cosine_weight.s0 = 1.0f;
slerp->_cosine_weight.x1 = 0.0f; slerp->_cosine_weight.x1 = 0.0f;
@ -22,7 +22,7 @@ inline void bgc_fp32_slerp_reset(BGC_FP32_Slerp3* slerp)
slerp->radians = 0.0f; slerp->radians = 0.0f;
} }
inline void bgc_fp64_slerp_reset(BGC_FP64_Slerp3* slerp) inline void bgc_fp64_slerp3_reset(BGC_FP64_Slerp3* slerp)
{ {
slerp->_cosine_weight.s0 = 1.0; slerp->_cosine_weight.s0 = 1.0;
slerp->_cosine_weight.x1 = 0.0; slerp->_cosine_weight.x1 = 0.0;
@ -39,54 +39,54 @@ inline void bgc_fp64_slerp_reset(BGC_FP64_Slerp3* slerp)
// ==================== Make ==================== // // ==================== Make ==================== //
void bgc_fp32_slerp_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment); void bgc_fp32_slerp3_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); void bgc_fp64_slerp3_make(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment);
// ================= Make Full ================== // // ================= Make Full ================== //
inline void bgc_fp32_slerp_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end) inline void bgc_fp32_slerp3_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
{ {
BGC_FP32_Turn3 augment; BGC_FP32_Turn3 augment;
bgc_fp32_turn3_exclude(&augment, end, start); bgc_fp32_turn3_exclude(&augment, end, start);
bgc_fp32_slerp_make(slerp, start, &augment); bgc_fp32_slerp3_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) inline void bgc_fp64_slerp3_make_full(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
{ {
BGC_FP64_Turn3 augment; BGC_FP64_Turn3 augment;
bgc_fp64_turn3_exclude(&augment, end, start); bgc_fp64_turn3_exclude(&augment, end, start);
bgc_fp64_slerp_make(slerp, start, &augment); bgc_fp64_slerp3_make(slerp, start, &augment);
} }
// =============== Make Shortened =============== // // =============== Make Shortened =============== //
inline void bgc_fp32_slerp_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end) inline void bgc_fp32_slerp3_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
{ {
BGC_FP32_Turn3 augment; BGC_FP32_Turn3 augment;
bgc_fp32_turn3_exclude(&augment, end, start); bgc_fp32_turn3_exclude(&augment, end, start);
bgc_fp32_turn3_shorten(&augment); bgc_fp32_turn3_shorten(&augment);
bgc_fp32_slerp_make(slerp, start, &augment); bgc_fp32_slerp3_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) inline void bgc_fp64_slerp3_make_shortened(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
{ {
BGC_FP64_Turn3 augment; BGC_FP64_Turn3 augment;
bgc_fp64_turn3_exclude(&augment, end, start); bgc_fp64_turn3_exclude(&augment, end, start);
bgc_fp64_turn3_shorten(&augment); bgc_fp64_turn3_shorten(&augment);
bgc_fp64_slerp_make(slerp, start, &augment); bgc_fp64_slerp3_make(slerp, start, &augment);
} }
// =============== Get Phase Turn =============== // // =============== Get Phase Turn =============== //
inline void bgc_fp32_slerp_get_phase_turn(BGC_FP32_Turn3* turn, const BGC_FP32_Slerp3* slerp, const float phase) inline void bgc_fp32_slerp3_get_phase_turn(BGC_FP32_Turn3* turn, const BGC_FP32_Slerp3* slerp, const float phase)
{ {
const float angle = slerp->radians * phase; const float angle = slerp->radians * phase;
const float cosine = cosf(angle); const float cosine = cosf(angle);
@ -100,7 +100,7 @@ inline void bgc_fp32_slerp_get_phase_turn(BGC_FP32_Turn3* turn, const BGC_FP32_S
bgc_fp32_turn3_set_quaternion(turn, &q); 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) inline void bgc_fp64_slerp3_get_phase_turn(BGC_FP64_Turn3* turn, const BGC_FP64_Slerp3* slerp, const double phase)
{ {
const double angle = slerp->radians * phase; const double angle = slerp->radians * phase;
const double cosine = cos(angle); const double cosine = cos(angle);
@ -116,7 +116,7 @@ inline void bgc_fp64_slerp_get_phase_turn(BGC_FP64_Turn3* turn, const BGC_FP64_S
// ========= Get Phase Rotation Matrix ========== // // ========= 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) inline void bgc_fp32_slerp3_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 angle = slerp->radians * phase;
const float cosine = cosf(angle); const float cosine = cosf(angle);
@ -130,7 +130,7 @@ inline void bgc_fp32_slerp_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotatio
bgc_fp32_quaternion_get_rotation_matrix(rotation_matrix, &q); 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) inline void bgc_fp64_slerp3_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 angle = slerp->radians * phase;
const double cosine = cos(angle); const double cosine = cos(angle);
@ -146,7 +146,7 @@ inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotatio
// ========== Get Phase Reverse Matrix ========== // // ========== 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) inline void bgc_fp32_slerp3_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 angle = slerp->radians * phase;
const float cosine = cosf(angle); const float cosine = cosf(angle);
@ -160,7 +160,7 @@ inline void bgc_fp32_slerp_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_
bgc_fp32_quaternion_get_reverse_matrix(reverse_matrix, &q); 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) inline void bgc_fp64_slerp3_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 angle = slerp->radians * phase;
const double cosine = cos(angle); const double cosine = cos(angle);
@ -176,7 +176,7 @@ inline void bgc_fp64_slerp_get_phase_reverse_matrix(BGC_FP64_Matrix3x3* reverse_
// ========== Get Phase Both Matrices =========== // // ========== 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) inline void bgc_fp32_slerp3_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 angle = slerp->radians * phase;
const float cosine = cosf(angle); const float cosine = cosf(angle);
@ -190,7 +190,7 @@ inline void bgc_fp32_slerp_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_
bgc_fp32_quaternion_get_both_matrices(rotation_matrix, reverse_matrix, &q); 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) inline void bgc_fp64_slerp3_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 angle = slerp->radians * phase;
const double cosine = cos(angle); const double cosine = cos(angle);

36
basic-geometry/turn3.c
View file

@ -166,7 +166,7 @@ void bgc_fp32_turn3_set_rotation(BGC_FP32_Turn3* turn, const float x1, const flo
bgc_fp32_quaternion_make(&turn->_versor, cosf(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier); bgc_fp32_quaternion_make(&turn->_versor, cosf(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier);
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&turn->_versor); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&turn->_versor);
if (!bgc_fp32_is_square_unit(square_modulus)) { if (!bgc_fp32_is_square_unit(square_modulus)) {
_bgc_fp32_turn3_normalize(turn, square_modulus); _bgc_fp32_turn3_normalize(turn, square_modulus);
@ -195,7 +195,7 @@ void bgc_fp64_turn3_set_rotation(BGC_FP64_Turn3* turn, const double x1, const do
bgc_fp64_quaternion_make(&turn->_versor, cos(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier); bgc_fp64_quaternion_make(&turn->_versor, cos(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier);
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&turn->_versor); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&turn->_versor);
if (!bgc_fp64_is_square_unit(square_modulus)) { if (!bgc_fp64_is_square_unit(square_modulus)) {
_bgc_fp64_turn3_normalize(turn, square_modulus); _bgc_fp64_turn3_normalize(turn, square_modulus);
@ -206,7 +206,7 @@ void bgc_fp64_turn3_set_rotation(BGC_FP64_Turn3* turn, const double x1, const do
int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP32_Vector3* first, const BGC_FP32_Vector3* second) int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP32_Vector3* first, const BGC_FP32_Vector3* second)
{ {
const float first_square_modulus = bgc_fp32_vector3_get_square_modulus(first); const float first_square_modulus = bgc_fp32_vector3_get_squared_length(first);
bgc_fp32_turn3_reset(turn); bgc_fp32_turn3_reset(turn);
@ -214,7 +214,7 @@ int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP3
return BGC_ERROR_TURN3_FIRST_VECTOR_ZERO; return BGC_ERROR_TURN3_FIRST_VECTOR_ZERO;
} }
const float second_square_modulus = bgc_fp32_vector3_get_square_modulus(second); const float second_square_modulus = bgc_fp32_vector3_get_squared_length(second);
if (second_square_modulus <= BGC_FP32_SQUARE_EPSILON) { if (second_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
return BGC_ERROR_TURN3_SECOND_VECTOR_ZERO; return BGC_ERROR_TURN3_SECOND_VECTOR_ZERO;
@ -226,7 +226,7 @@ int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP3
const float square_product = first_square_modulus * second_square_modulus; const float square_product = first_square_modulus * second_square_modulus;
const float dot_product = bgc_fp32_vector3_get_dot_product(first, second); const float dot_product = bgc_fp32_vector3_get_dot_product(first, second);
const float axis_square_modulus = bgc_fp32_vector3_get_square_modulus(&axis); const float axis_square_modulus = bgc_fp32_vector3_get_squared_length(&axis);
if (axis_square_modulus <= BGC_FP32_SQUARE_EPSILON * square_product) { if (axis_square_modulus <= BGC_FP32_SQUARE_EPSILON * square_product) {
if (dot_product < 0.0f) { if (dot_product < 0.0f) {
@ -250,7 +250,7 @@ int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP3
int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP64_Vector3* first, const BGC_FP64_Vector3* second) int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP64_Vector3* first, const BGC_FP64_Vector3* second)
{ {
const double first_square_modulus = bgc_fp64_vector3_get_square_modulus(first); const double first_square_modulus = bgc_fp64_vector3_get_squared_length(first);
bgc_fp64_turn3_reset(turn); bgc_fp64_turn3_reset(turn);
@ -258,7 +258,7 @@ int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP6
return BGC_ERROR_TURN3_FIRST_VECTOR_ZERO; return BGC_ERROR_TURN3_FIRST_VECTOR_ZERO;
} }
const double second_square_modulus = bgc_fp64_vector3_get_square_modulus(second); const double second_square_modulus = bgc_fp64_vector3_get_squared_length(second);
if (second_square_modulus <= BGC_FP64_SQUARE_EPSILON) { if (second_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
return BGC_ERROR_TURN3_SECOND_VECTOR_ZERO; return BGC_ERROR_TURN3_SECOND_VECTOR_ZERO;
@ -270,7 +270,7 @@ int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP6
const double square_product = first_square_modulus * second_square_modulus; const double square_product = first_square_modulus * second_square_modulus;
const double dot_product = bgc_fp64_vector3_get_dot_product(first, second); const double dot_product = bgc_fp64_vector3_get_dot_product(first, second);
const double axis_square_modulus = bgc_fp64_vector3_get_square_modulus(&axis); const double axis_square_modulus = bgc_fp64_vector3_get_squared_length(&axis);
if (axis_square_modulus <= BGC_FP64_SQUARE_EPSILON * square_product) { if (axis_square_modulus <= BGC_FP64_SQUARE_EPSILON * square_product) {
bgc_fp64_turn3_reset(turn); bgc_fp64_turn3_reset(turn);
@ -297,13 +297,13 @@ int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP6
static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_main, BGC_FP32_Vector3* unit_branch, const BGC_FP32_Vector3* main, const BGC_FP32_Vector3* branch) static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_main, BGC_FP32_Vector3* unit_branch, const BGC_FP32_Vector3* main, const BGC_FP32_Vector3* branch)
{ {
const float main_square_modulus = bgc_fp32_vector3_get_square_modulus(main); const float main_square_modulus = bgc_fp32_vector3_get_squared_length(main);
if (main_square_modulus <= BGC_FP32_SQUARE_EPSILON) { if (main_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
return _BGC_ERROR_TURN3_EMPTY_MAIN; return _BGC_ERROR_TURN3_EMPTY_MAIN;
} }
const float branch_square_modulus = bgc_fp32_vector3_get_square_modulus(branch); const float branch_square_modulus = bgc_fp32_vector3_get_squared_length(branch);
if (branch_square_modulus <= BGC_FP32_SQUARE_EPSILON) { if (branch_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
return _BGC_ERROR_TURN3_EMPTY_BRANCH; return _BGC_ERROR_TURN3_EMPTY_BRANCH;
@ -313,7 +313,7 @@ static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_mai
bgc_fp32_vector3_add_scaled(unit_branch, branch, unit_main, -bgc_fp32_vector3_get_dot_product(branch, unit_main)); bgc_fp32_vector3_add_scaled(unit_branch, branch, unit_main, -bgc_fp32_vector3_get_dot_product(branch, unit_main));
const float orthogonal_square_modulus = bgc_fp32_vector3_get_square_modulus(unit_branch); const float orthogonal_square_modulus = bgc_fp32_vector3_get_squared_length(unit_branch);
if (orthogonal_square_modulus <= BGC_FP32_SQUARE_EPSILON) { if (orthogonal_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
return _BGC_ERROR_TURN3_PAIR_PARALLEL; return _BGC_ERROR_TURN3_PAIR_PARALLEL;
@ -326,13 +326,13 @@ static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_mai
static inline int _bgc_fp64_turn3_get_orthogonal_pair(BGC_FP64_Vector3* unit_main, BGC_FP64_Vector3* unit_branch, const BGC_FP64_Vector3* main, const BGC_FP64_Vector3* branch) static inline int _bgc_fp64_turn3_get_orthogonal_pair(BGC_FP64_Vector3* unit_main, BGC_FP64_Vector3* unit_branch, const BGC_FP64_Vector3* main, const BGC_FP64_Vector3* branch)
{ {
const double main_square_modulus = bgc_fp64_vector3_get_square_modulus(main); const double main_square_modulus = bgc_fp64_vector3_get_squared_length(main);
if (main_square_modulus <= BGC_FP64_SQUARE_EPSILON) { if (main_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
return _BGC_ERROR_TURN3_EMPTY_MAIN; return _BGC_ERROR_TURN3_EMPTY_MAIN;
} }
const double branch_square_modulus = bgc_fp64_vector3_get_square_modulus(branch); const double branch_square_modulus = bgc_fp64_vector3_get_squared_length(branch);
if (branch_square_modulus <= BGC_FP64_SQUARE_EPSILON) { if (branch_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
return _BGC_ERROR_TURN3_EMPTY_BRANCH; return _BGC_ERROR_TURN3_EMPTY_BRANCH;
@ -342,7 +342,7 @@ static inline int _bgc_fp64_turn3_get_orthogonal_pair(BGC_FP64_Vector3* unit_mai
bgc_fp64_vector3_add_scaled(unit_branch, branch, unit_main, -bgc_fp64_vector3_get_dot_product(branch, unit_main)); bgc_fp64_vector3_add_scaled(unit_branch, branch, unit_main, -bgc_fp64_vector3_get_dot_product(branch, unit_main));
const double orthogonal_square_modulus = bgc_fp64_vector3_get_square_modulus(unit_branch); const double orthogonal_square_modulus = bgc_fp64_vector3_get_squared_length(unit_branch);
if (orthogonal_square_modulus <= BGC_FP64_SQUARE_EPSILON) { if (orthogonal_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
return _BGC_ERROR_TURN3_PAIR_PARALLEL; return _BGC_ERROR_TURN3_PAIR_PARALLEL;
@ -363,7 +363,7 @@ static inline void _bgc_fp32_turn3_get_turning_quaternion(BGC_FP32_Quaternion* q
const float dot_product = bgc_fp32_vector3_get_dot_product(unit_start, unit_end); const float dot_product = bgc_fp32_vector3_get_dot_product(unit_start, unit_end);
const float axis_square_modulus = bgc_fp32_vector3_get_square_modulus(&axis); const float axis_square_modulus = bgc_fp32_vector3_get_squared_length(&axis);
// unit_start and unit_end are parallel // unit_start and unit_end are parallel
if (axis_square_modulus <= BGC_FP32_SQUARE_EPSILON) { if (axis_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
@ -404,7 +404,7 @@ static inline void _bgc_fp64_turn3_get_turning_quaternion(BGC_FP64_Quaternion* q
const double dot_product = bgc_fp64_vector3_get_dot_product(unit_start, unit_end); const double dot_product = bgc_fp64_vector3_get_dot_product(unit_start, unit_end);
const double axis_square_modulus = bgc_fp64_vector3_get_square_modulus(&axis); const double axis_square_modulus = bgc_fp64_vector3_get_squared_length(&axis);
// unit_start and unit_end are parallel // unit_start and unit_end are parallel
if (axis_square_modulus <= BGC_FP64_SQUARE_EPSILON) { if (axis_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
@ -477,7 +477,7 @@ int bgc_fp32_turn3_find_pair_difference(
bgc_fp32_quaternion_multiply_by_quaternion(&turn->_versor, &q2, &q1); bgc_fp32_quaternion_multiply_by_quaternion(&turn->_versor, &q2, &q1);
// Making a final versor (a normalized quaternion) // Making a final versor (a normalized quaternion)
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&turn->_versor); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&turn->_versor);
if (!bgc_fp32_is_square_unit(square_modulus)) { if (!bgc_fp32_is_square_unit(square_modulus)) {
_bgc_fp32_turn3_normalize(turn, square_modulus); _bgc_fp32_turn3_normalize(turn, square_modulus);
@ -524,7 +524,7 @@ int bgc_fp64_turn3_find_pair_difference(
bgc_fp64_quaternion_multiply_by_quaternion(&turn->_versor, &q2, &q1); bgc_fp64_quaternion_multiply_by_quaternion(&turn->_versor, &q2, &q1);
// Making a final versor (a normalized quaternion) // Making a final versor (a normalized quaternion)
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&turn->_versor); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&turn->_versor);
if (!bgc_fp64_is_square_unit(square_modulus)) { if (!bgc_fp64_is_square_unit(square_modulus)) {
_bgc_fp64_turn3_normalize(turn, square_modulus); _bgc_fp64_turn3_normalize(turn, square_modulus);

24
basic-geometry/turn3.h
View file

@ -91,7 +91,7 @@ inline void bgc_fp32_turn3_set_quaternion(BGC_FP32_Turn3* turn, const BGC_FP32_Q
{ {
bgc_fp32_quaternion_copy(&turn->_versor, quaternion); bgc_fp32_quaternion_copy(&turn->_versor, quaternion);
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
if (!bgc_fp32_is_square_unit(square_modulus)) { if (!bgc_fp32_is_square_unit(square_modulus)) {
_bgc_fp32_turn3_normalize(turn, square_modulus); _bgc_fp32_turn3_normalize(turn, square_modulus);
@ -102,7 +102,7 @@ inline void bgc_fp64_turn3_set_quaternion(BGC_FP64_Turn3* turn, const BGC_FP64_Q
{ {
bgc_fp64_quaternion_copy(&turn->_versor, quaternion); bgc_fp64_quaternion_copy(&turn->_versor, quaternion);
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
if (!bgc_fp64_is_square_unit(square_modulus)) { if (!bgc_fp64_is_square_unit(square_modulus)) {
_bgc_fp64_turn3_normalize(turn, square_modulus); _bgc_fp64_turn3_normalize(turn, square_modulus);
@ -187,7 +187,7 @@ inline void bgc_fp32_turn3_convert_to_fp64(BGC_FP64_Turn3* destination, const BG
{ {
bgc_fp32_quaternion_convert_to_fp64(&destination->_versor, &source->_versor); bgc_fp32_quaternion_convert_to_fp64(&destination->_versor, &source->_versor);
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&destination->_versor); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&destination->_versor);
if (!bgc_fp64_is_square_unit(square_modulus)) { if (!bgc_fp64_is_square_unit(square_modulus)) {
_bgc_fp64_turn3_normalize(destination, square_modulus); _bgc_fp64_turn3_normalize(destination, square_modulus);
@ -198,7 +198,7 @@ inline void bgc_fp64_turn3_convert_to_fp32(BGC_FP32_Turn3* destination, const BG
{ {
bgc_fp64_quaternion_convert_to_fp32(&destination->_versor, &source->_versor); bgc_fp64_quaternion_convert_to_fp32(&destination->_versor, &source->_versor);
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&destination->_versor); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&destination->_versor);
if (!bgc_fp32_is_square_unit(square_modulus)) { if (!bgc_fp32_is_square_unit(square_modulus)) {
_bgc_fp32_turn3_normalize(destination, square_modulus); _bgc_fp32_turn3_normalize(destination, square_modulus);
@ -297,7 +297,7 @@ inline void bgc_fp32_turn3_combine(BGC_FP32_Turn3* combination, const BGC_FP32_T
{ {
bgc_fp32_quaternion_multiply_by_quaternion(&combination->_versor, &second->_versor, &first->_versor); bgc_fp32_quaternion_multiply_by_quaternion(&combination->_versor, &second->_versor, &first->_versor);
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&combination->_versor); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&combination->_versor);
if (!bgc_fp32_is_square_unit(square_modulus)) { if (!bgc_fp32_is_square_unit(square_modulus)) {
_bgc_fp32_turn3_normalize(combination, square_modulus); _bgc_fp32_turn3_normalize(combination, square_modulus);
@ -308,7 +308,7 @@ inline void bgc_fp64_turn3_combine(BGC_FP64_Turn3* combination, const BGC_FP64_T
{ {
bgc_fp64_quaternion_multiply_by_quaternion(&combination->_versor, &second->_versor, &first->_versor); bgc_fp64_quaternion_multiply_by_quaternion(&combination->_versor, &second->_versor, &first->_versor);
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&combination->_versor); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&combination->_versor);
if (!bgc_fp64_is_square_unit(square_modulus)) { if (!bgc_fp64_is_square_unit(square_modulus)) {
_bgc_fp64_turn3_normalize(combination, square_modulus); _bgc_fp64_turn3_normalize(combination, square_modulus);
@ -325,7 +325,7 @@ inline void bgc_fp32_turn3_combine3(BGC_FP32_Turn3* combination, const BGC_FP32_
bgc_fp32_quaternion_multiply_by_quaternion(&combination->_versor, &third->_versor, &product); bgc_fp32_quaternion_multiply_by_quaternion(&combination->_versor, &third->_versor, &product);
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&combination->_versor); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&combination->_versor);
if (!bgc_fp32_is_square_unit(square_modulus)) { if (!bgc_fp32_is_square_unit(square_modulus)) {
_bgc_fp32_turn3_normalize(combination, square_modulus); _bgc_fp32_turn3_normalize(combination, square_modulus);
@ -340,7 +340,7 @@ inline void bgc_fp64_turn3_combine3(BGC_FP64_Turn3* combination, const BGC_FP64_
bgc_fp64_quaternion_multiply_by_quaternion(&combination->_versor, &third->_versor, &product); bgc_fp64_quaternion_multiply_by_quaternion(&combination->_versor, &third->_versor, &product);
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&combination->_versor); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&combination->_versor);
if (!bgc_fp64_is_square_unit(square_modulus)) { if (!bgc_fp64_is_square_unit(square_modulus)) {
_bgc_fp64_turn3_normalize(combination, square_modulus); _bgc_fp64_turn3_normalize(combination, square_modulus);
@ -353,7 +353,7 @@ inline void bgc_fp32_turn3_exclude(BGC_FP32_Turn3* difference, const BGC_FP32_Tu
{ {
bgc_fp32_quaternion_multiply_by_conjugate(&difference->_versor, &base->_versor, &excludant->_versor); bgc_fp32_quaternion_multiply_by_conjugate(&difference->_versor, &base->_versor, &excludant->_versor);
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&difference->_versor); const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&difference->_versor);
if (!bgc_fp32_is_square_unit(square_modulus)) { if (!bgc_fp32_is_square_unit(square_modulus)) {
_bgc_fp32_turn3_normalize(difference, square_modulus); _bgc_fp32_turn3_normalize(difference, square_modulus);
@ -364,7 +364,7 @@ inline void bgc_fp64_turn3_exclude(BGC_FP64_Turn3* difference, const BGC_FP64_Tu
{ {
bgc_fp64_quaternion_multiply_by_conjugate(&difference->_versor, &base->_versor, &excludant->_versor); bgc_fp64_quaternion_multiply_by_conjugate(&difference->_versor, &base->_versor, &excludant->_versor);
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&difference->_versor); const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&difference->_versor);
if (!bgc_fp64_is_square_unit(square_modulus)) { if (!bgc_fp64_is_square_unit(square_modulus)) {
_bgc_fp64_turn3_normalize(difference, square_modulus); _bgc_fp64_turn3_normalize(difference, square_modulus);
@ -541,14 +541,14 @@ inline int bgc_fp32_turn3_are_close(const BGC_FP32_Turn3* turn1, const BGC_FP32_
{ {
BGC_FP32_Quaternion difference; BGC_FP32_Quaternion difference;
bgc_fp32_quaternion_subtract(&difference, &turn1->_versor, &turn2->_versor); bgc_fp32_quaternion_subtract(&difference, &turn1->_versor, &turn2->_versor);
return bgc_fp32_quaternion_get_square_modulus(&difference) <= BGC_FP32_SQUARE_EPSILON; return bgc_fp32_quaternion_get_square_magnitude(&difference) <= BGC_FP32_SQUARE_EPSILON;
} }
inline int bgc_fp64_turn3_are_close(const BGC_FP64_Turn3* turn1, const BGC_FP64_Turn3* turn2) inline int bgc_fp64_turn3_are_close(const BGC_FP64_Turn3* turn1, const BGC_FP64_Turn3* turn2)
{ {
BGC_FP64_Quaternion difference; BGC_FP64_Quaternion difference;
bgc_fp64_quaternion_subtract(&difference, &turn1->_versor, &turn2->_versor); bgc_fp64_quaternion_subtract(&difference, &turn1->_versor, &turn2->_versor);
return bgc_fp64_quaternion_get_square_modulus(&difference) <= BGC_FP64_SQUARE_EPSILON; return bgc_fp64_quaternion_get_square_magnitude(&difference) <= BGC_FP64_SQUARE_EPSILON;
} }
#endif #endif

16
basic-geometry/vector2.c
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

 @ -6,11 +6,11 @@ extern inline void bgc_fp64_vector2_reset(BGC_FP64_Vector2* vector);
extern inline void bgc_fp32_vector2_make(BGC_FP32_Vector2* destination, const float x1, const float x2); extern inline void bgc_fp32_vector2_make(BGC_FP32_Vector2* destination, const float x1, const float x2);
extern inline void bgc_fp64_vector2_make(BGC_FP64_Vector2* destination, const double x1, const double x2); extern inline void bgc_fp64_vector2_make(BGC_FP64_Vector2* destination, const double x1, const double x2);
extern inline float bgc_fp32_vector2_get_square_modulus(const BGC_FP32_Vector2* vector); extern inline float bgc_fp32_vector2_get_squared_length(const BGC_FP32_Vector2* vector);
extern inline double bgc_fp64_vector2_get_square_modulus(const BGC_FP64_Vector2* vector); extern inline double bgc_fp64_vector2_get_squared_length(const BGC_FP64_Vector2* vector);
extern inline float bgc_fp32_vector2_get_modulus(const BGC_FP32_Vector2* vector); extern inline float bgc_fp32_vector2_get_length(const BGC_FP32_Vector2* vector);