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-11 21:07:48 +07:00
parent e9558ff977
commit 642d39f2a9
11 changed files with 54 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

4
basic-geometry/complex.c
View file

@ -69,8 +69,8 @@ extern inline void bgc_fp64_complex_multiply_by_complex(BGC_FP64_Complex* produc
extern inline void bgc_fp32_complex_multiply_by_conjugate(BGC_FP32_Complex* product, const BGC_FP32_Complex* multiplicand, const BGC_FP32_Complex* multiplier_to_conjugate);
extern inline void bgc_fp64_complex_multiply_by_conjugate(BGC_FP64_Complex* product, const BGC_FP64_Complex* multiplicand, const BGC_FP64_Complex* multiplier_to_conjugate);
extern inline void bgc_fp32_complex_divide_by_real(BGC_FP32_Complex* quotient, const BGC_FP32_Complex* dividend, const float divisor);
extern inline void bgc_fp64_complex_divide_by_real(BGC_FP64_Complex* quotient, const BGC_FP64_Complex* dividend, const double divisor);
extern inline int bgc_fp32_complex_divide_by_real(BGC_FP32_Complex* quotient, const BGC_FP32_Complex* dividend, const float divisor);
extern inline int bgc_fp64_complex_divide_by_real(BGC_FP64_Complex* quotient, const BGC_FP64_Complex* dividend, const double divisor);
extern inline int bgc_fp32_complex_divide_by_complex(BGC_FP32_Complex* quotient, const BGC_FP32_Complex* divident, const BGC_FP32_Complex* divisor);
extern inline int bgc_fp64_complex_divide_by_complex(BGC_FP64_Complex* quotient, const BGC_FP64_Complex* divident, const BGC_FP64_Complex* divisor);

4
basic-geometry/complex.h
View file

@ -506,8 +506,8 @@ inline int bgc_fp64_complex_divide_by_conjugate(BGC_FP64_Complex* quotient, cons
return BGC_FAILURE;
}
bgc_fp32_complex_multiply_by_complex(quotient, divident, divisor_to_conjugate);
bgc_fp32_complex_multiply_by_real(quotient, quotient, 1.0 / square_modulus);
bgc_fp64_complex_multiply_by_complex(quotient, divident, divisor_to_conjugate);
bgc_fp64_complex_multiply_by_real(quotient, quotient, 1.0 / square_modulus);
return BGC_SUCCESS;
}

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

@ -27,11 +27,11 @@ extern inline void bgc_fp64_dual_vector3_add_scaled(BGC_FP64_DualVector3* sum, c
extern inline void bgc_fp32_dual_vector3_subtract(BGC_FP32_DualVector3* difference, const BGC_FP32_DualVector3* minuend, const BGC_FP32_DualVector3* subtrahend);
extern inline void bgc_fp64_dual_vector3_subtract(BGC_FP64_DualVector3* difference, const BGC_FP64_DualVector3* minuend, const BGC_FP64_DualVector3* subtrahend);
extern inline void bgc_fp32_dual_vector3_multiply_by_real(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const float multiplier);
extern inline void bgc_fp64_dual_vector3_multiply_by_real(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const double multiplier);
extern inline void bgc_fp32_dual_vector3_multiply(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const float multiplier);
extern inline void bgc_fp64_dual_vector3_multiply(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const double multiplier);
extern inline int bgc_fp32_dual_vector3_divide_by_real(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* dividend, const float divisor);
extern inline int bgc_fp64_dual_vector3_divide_by_real(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const double divisor);
extern inline int bgc_fp32_dual_vector3_divide(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* dividend, const float divisor);
extern inline int bgc_fp64_dual_vector3_divide(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const double divisor);
extern inline void bgc_fp32_dual_vector3_get_mean2(BGC_FP32_DualVector3* mean, const BGC_FP32_DualVector3* vector1, const BGC_FP32_DualVector3* vector2);
extern inline void bgc_fp64_dual_vector3_get_mean2(BGC_FP64_DualVector3* mean, const BGC_FP64_DualVector3* vector1, const BGC_FP64_DualVector3* vector2);

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

@ -145,21 +145,21 @@ inline void bgc_fp64_dual_vector3_subtract(BGC_FP64_DualVector3* difference, con
// ================== Multiply ================== //
inline void bgc_fp32_dual_vector3_multiply_by_real(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const float multiplier)
inline void bgc_fp32_dual_vector3_multiply(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const float multiplier)
{
bgc_fp32_vector3_multiply_by_real(&product->real, &multiplicand->real, multiplier);
bgc_fp32_vector3_multiply_by_real(&product->dual, &multiplicand->dual, multiplier);
bgc_fp32_vector3_multiply(&product->real, &multiplicand->real, multiplier);
bgc_fp32_vector3_multiply(&product->dual, &multiplicand->dual, multiplier);
}
inline void bgc_fp64_dual_vector3_multiply_by_real(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const double multiplier)
inline void bgc_fp64_dual_vector3_multiply(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const double multiplier)
{
bgc_fp64_vector3_multiply_by_real(&product->real, &multiplicand->real, multiplier);
bgc_fp64_vector3_multiply_by_real(&product->dual, &multiplicand->dual, multiplier);
bgc_fp64_vector3_multiply(&product->real, &multiplicand->real, multiplier);
bgc_fp64_vector3_multiply(&product->dual, &multiplicand->dual, multiplier);
}
// =================== Divide =================== //
inline int bgc_fp32_dual_vector3_divide_by_real(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* dividend, const float divisor)
inline int bgc_fp32_dual_vector3_divide(BGC_FP32_DualVector3* quotient, const BGC_FP32_DualVector3* dividend, const float divisor)
{
if (bgc_fp32_is_zero(divisor) || isnan(divisor)) {
return BGC_FAILURE;
@ -167,13 +167,13 @@ inline int bgc_fp32_dual_vector3_divide_by_real(BGC_FP32_DualVector3* quotient,
const float multiplier = 1.0f / divisor;
bgc_fp32_vector3_multiply_by_real(&quotient->real, &dividend->real, multiplier);
bgc_fp32_vector3_multiply_by_real(&quotient->dual, &dividend->dual, multiplier);
bgc_fp32_vector3_multiply(&quotient->real, &dividend->real, multiplier);
bgc_fp32_vector3_multiply(&quotient->dual, &dividend->dual, multiplier);
return BGC_SUCCESS;
}
inline int bgc_fp64_dual_vector3_divide_by_real(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const double divisor)
inline int bgc_fp64_dual_vector3_divide(BGC_FP64_DualVector3* quotient, const BGC_FP64_DualVector3* dividend, const double divisor)
{
if (bgc_fp64_is_zero(divisor) || isnan(divisor)) {
return BGC_FAILURE;
@ -181,8 +181,8 @@ inline int bgc_fp64_dual_vector3_divide_by_real(BGC_FP64_DualVector3* quotient,
const double multiplier = 1.0 / divisor;
bgc_fp64_vector3_multiply_by_real(&quotient->real, &dividend->real, multiplier);
bgc_fp64_vector3_multiply_by_real(&quotient->dual, &dividend->dual, multiplier);
bgc_fp64_vector3_multiply(&quotient->real, &dividend->real, multiplier);
bgc_fp64_vector3_multiply(&quotient->dual, &dividend->dual, multiplier);
return BGC_SUCCESS;
}

8
basic-geometry/quaternion.c
View file

@ -129,12 +129,12 @@ int bgc_fp32_quaternion_get_exponation(BGC_FP32_Quaternion* power, const BGC_FP3
// isnan(square_modulus) means checking for NaN value at square_modulus
if (isnan(square_modulus)) {
return BGC_FAILED;
return BGC_FAILURE;
}
if (square_vector <= BGC_FP32_SQUARE_EPSILON) {
if (base->s0 < 0.0f) {
return BGC_FAILED;
return BGC_FAILURE;
}
power->s0 = powf(base->s0, exponent);
@ -170,12 +170,12 @@ int bgc_fp64_quaternion_get_exponation(BGC_FP64_Quaternion* power, const BGC_FP6
// isnan(square_modulus) means checking for NaN value at square_modulus
if (isnan(square_modulus)) {
return BGC_FAILED;
return BGC_FAILURE;
}
if (square_vector <= BGC_FP64_SQUARE_EPSILON) {
if (base->s0 < 0.0) {
return BGC_FAILED;
return BGC_FAILURE;
}
power->s0 = pow(base->s0, exponent);

4
basic-geometry/quaternion.h
View file

@ -384,7 +384,7 @@ inline int bgc_fp32_quaternion_divide_by_conjugate(BGC_FP32_Quaternion* quotient
return BGC_FAILURE;
}
bgc_fp32_quaternion_multiply_by_quaternion(quotient, divisor_to_conjugate, divisor);
bgc_fp32_quaternion_multiply_by_quaternion(quotient, divisor_to_conjugate, divisor_to_conjugate);
bgc_fp32_quaternion_multiply_by_real(quotient, quotient, 1.0f / square_modulus);
return BGC_SUCCESS;
@ -398,7 +398,7 @@ inline int bgc_fp64_quaternion_divide_by_conjugate(BGC_FP64_Quaternion* quotient
return BGC_FAILURE;
}
bgc_fp64_quaternion_multiply_by_quaternion(quotient, divisor_to_conjugate, divisor);
bgc_fp64_quaternion_multiply_by_quaternion(quotient, divisor_to_conjugate, divisor_to_conjugate);
bgc_fp64_quaternion_multiply_by_real(quotient, quotient, 1.0 / square_modulus);
return BGC_SUCCESS;

8
basic-geometry/turn3.c
View file

@ -308,7 +308,7 @@ static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_mai
return _BGC_ERROR_TURN3_EMPTY_BRANCH;
}
bgc_fp32_vector3_multiply_by_real(unit_main, main, sqrtf(1.0f / main_square_modulus));
bgc_fp32_vector3_multiply(unit_main, main, sqrtf(1.0f / main_square_modulus));
bgc_fp32_vector3_add_scaled(unit_branch, branch, unit_main, -bgc_fp32_vector3_get_dot_product(branch, unit_main));
@ -318,7 +318,7 @@ static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_mai
return _BGC_ERROR_TURN3_PAIR_PARALLEL;
}
bgc_fp32_vector3_multiply_by_real(unit_branch, unit_branch, sqrtf(1.0f / orthogonal_square_modulus));
bgc_fp32_vector3_multiply(unit_branch, unit_branch, sqrtf(1.0f / orthogonal_square_modulus));
return BGC_SUCCESS;
}
@ -337,7 +337,7 @@ static inline int _bgc_fp64_turn3_get_orthogonal_pair(BGC_FP64_Vector3* unit_mai
return _BGC_ERROR_TURN3_EMPTY_BRANCH;
}
bgc_fp64_vector3_multiply_by_real(unit_main, main, sqrt(1.0 / main_square_modulus));
bgc_fp64_vector3_multiply(unit_main, main, sqrt(1.0 / main_square_modulus));
bgc_fp64_vector3_add_scaled(unit_branch, branch, unit_main, -bgc_fp64_vector3_get_dot_product(branch, unit_main));
@ -347,7 +347,7 @@ static inline int _bgc_fp64_turn3_get_orthogonal_pair(BGC_FP64_Vector3* unit_mai
return _BGC_ERROR_TURN3_PAIR_PARALLEL;
}
bgc_fp64_vector3_multiply_by_real(unit_branch, unit_branch, sqrt(1.0 / orthogonal_square_modulus));
bgc_fp64_vector3_multiply(unit_branch, unit_branch, sqrt(1.0 / orthogonal_square_modulus));
return BGC_SUCCESS;
}

8
basic-geometry/vector2.c
View file

@ -36,11 +36,11 @@ extern inline void bgc_fp64_vector2_add_scaled(BGC_FP64_Vector2* sum, const BGC_
extern inline void bgc_fp32_vector2_subtract(BGC_FP32_Vector2* difference, const BGC_FP32_Vector2* minuend, const BGC_FP32_Vector2* subtrahend);
extern inline void bgc_fp64_vector2_subtract(BGC_FP64_Vector2* difference, const BGC_FP64_Vector2* minuend, const BGC_FP64_Vector2* subtrahend);
extern inline void bgc_fp32_vector2_multiply_by_real(BGC_FP32_Vector2* product, const BGC_FP32_Vector2* multiplicand, const float multiplier);
extern inline void bgc_fp64_vector2_multiply_by_real(BGC_FP64_Vector2* product, const BGC_FP64_Vector2* multiplicand, const double multiplier);
extern inline void bgc_fp32_vector2_multiply(BGC_FP32_Vector2* product, const BGC_FP32_Vector2* multiplicand, const float multiplier);
extern inline void bgc_fp64_vector2_multiply(BGC_FP64_Vector2* product, const BGC_FP64_Vector2* multiplicand, const double multiplier);
extern inline int bgc_fp32_vector2_divide_by_real(BGC_FP32_Vector2* quotient, const BGC_FP32_Vector2* dividend, const float divisor);
extern inline int bgc_fp64_vector2_divide_by_real(BGC_FP64_Vector2* quotient, const BGC_FP64_Vector2* dividend, const double divisor);
extern inline int bgc_fp32_vector2_divide(BGC_FP32_Vector2* quotient, const BGC_FP32_Vector2* dividend, const float divisor);
extern inline int bgc_fp64_vector2_divide(BGC_FP64_Vector2* quotient, const BGC_FP64_Vector2* dividend, const double divisor);
extern inline void bgc_fp32_vector2_get_mean2(BGC_FP32_Vector2* mean, const BGC_FP32_Vector2* vector1, const BGC_FP32_Vector2* vector2);
extern inline void bgc_fp64_vector2_get_mean2(BGC_FP64_Vector2* mean, const BGC_FP64_Vector2* vector1, const BGC_FP64_Vector2* vector2);

16
basic-geometry/vector2.h
View file

@ -186,13 +186,13 @@ inline void bgc_fp64_vector2_subtract(BGC_FP64_Vector2* difference, const BGC_FP
// ================== Multiply ================== //
inline void bgc_fp32_vector2_multiply_by_real(BGC_FP32_Vector2* product, const BGC_FP32_Vector2* multiplicand, const float multiplier)
inline void bgc_fp32_vector2_multiply(BGC_FP32_Vector2* product, const BGC_FP32_Vector2* multiplicand, const float multiplier)
{
product->x1 = multiplicand->x1 * multiplier;
product->x2 = multiplicand->x2 * multiplier;
}
inline void bgc_fp64_vector2_multiply_by_real(BGC_FP64_Vector2* product, const BGC_FP64_Vector2* multiplicand, const double multiplier)
inline void bgc_fp64_vector2_multiply(BGC_FP64_Vector2* product, const BGC_FP64_Vector2* multiplicand, const double multiplier)
{
product->x1 = multiplicand->x1 * multiplier;
product->x2 = multiplicand->x2 * multiplier;
@ -200,24 +200,24 @@ inline void bgc_fp64_vector2_multiply_by_real(BGC_FP64_Vector2* product, const B
// =================== Divide =================== //
inline int bgc_fp32_vector2_divide_by_real(BGC_FP32_Vector2* quotient, const BGC_FP32_Vector2* dividend, const float divisor)
inline int bgc_fp32_vector2_divide(BGC_FP32_Vector2* quotient, const BGC_FP32_Vector2* dividend, const float divisor)
{
if (bgc_fp32_is_zero(divisor) || isnan(divisor)) {
return BGC_FAILURE;
}
bgc_fp32_vector2_multiply_by_real(quotient, dividend, 1.0f / divisor);
bgc_fp32_vector2_multiply(quotient, dividend, 1.0f / divisor);
return BGC_SUCCESS;
}
inline int bgc_fp64_vector2_divide_by_real(BGC_FP64_Vector2* quotient, const BGC_FP64_Vector2* dividend, const double divisor)
inline int bgc_fp64_vector2_divide(BGC_FP64_Vector2* quotient, const BGC_FP64_Vector2* dividend, const double divisor)
{
if (bgc_fp32_is_zero(divisor) || isnan(divisor)) {
return BGC_FAILURE;
}
bgc_fp64_vector2_multiply_by_real(quotient, dividend, 1.0 / divisor);
bgc_fp64_vector2_multiply(quotient, dividend, 1.0 / divisor);
return BGC_SUCCESS;
}
@ -350,7 +350,7 @@ inline int bgc_fp32_vector2_get_normalized(BGC_FP32_Vector2* normalized, const B
return BGC_SUCCESS;
}
bgc_fp32_vector2_multiply_by_real(normalized, vector, sqrtf(1.0f / square_modulus));
bgc_fp32_vector2_multiply(normalized, vector, sqrtf(1.0f / square_modulus));
return BGC_SUCCESS;
}
@ -368,7 +368,7 @@ inline int bgc_fp64_vector2_get_normalized(BGC_FP64_Vector2* normalized, const B
return BGC_SUCCESS;
}
bgc_fp64_vector2_multiply_by_real(normalized, vector, sqrt(1.0 / square_modulus));
bgc_fp64_vector2_multiply(normalized, vector, sqrt(1.0 / square_modulus));
return BGC_SUCCESS;
}

8
basic-geometry/vector3.c
View file

@ -36,11 +36,11 @@ extern inline void bgc_fp64_vector3_add_scaled(BGC_FP64_Vector3* sum, const BGC_
extern inline void bgc_fp32_vector3_subtract(BGC_FP32_Vector3* difference, const BGC_FP32_Vector3* minuend, const BGC_FP32_Vector3* subtrahend);
extern inline void bgc_fp64_vector3_subtract(BGC_FP64_Vector3* difference, const BGC_FP64_Vector3* minuend, const BGC_FP64_Vector3* subtrahend);
extern inline void bgc_fp32_vector3_multiply_by_real(BGC_FP32_Vector3* product, const BGC_FP32_Vector3* multiplicand, const float multiplier);
extern inline void bgc_fp64_vector3_multiply_by_real(BGC_FP64_Vector3* product, const BGC_FP64_Vector3* multiplicand, const double multiplier);
extern inline void bgc_fp32_vector3_multiply(BGC_FP32_Vector3* product, const BGC_FP32_Vector3* multiplicand, const float multiplier);
extern inline void bgc_fp64_vector3_multiply(BGC_FP64_Vector3* product, const BGC_FP64_Vector3* multiplicand, const double multiplier);
extern inline int bgc_fp32_vector3_divide_by_real(BGC_FP32_Vector3* quotient, const BGC_FP32_Vector3* dividend, const float divisor);
extern inline int bgc_fp64_vector3_divide_by_real(BGC_FP64_Vector3* quotient, const BGC_FP64_Vector3* dividend, const double divisor);
extern inline int bgc_fp32_vector3_divide(BGC_FP32_Vector3* quotient, const BGC_FP32_Vector3* dividend, const float divisor);
extern inline int bgc_fp64_vector3_divide(BGC_FP64_Vector3* quotient, const BGC_FP64_Vector3* dividend, const double divisor);
extern inline void bgc_fp32_vector3_get_mean2(BGC_FP32_Vector3* mean, const BGC_FP32_Vector3* vector1, const BGC_FP32_Vector3* vector2);
extern inline void bgc_fp64_vector3_get_mean2(BGC_FP64_Vector3* mean, const BGC_FP64_Vector3* vector1, const BGC_FP64_Vector3* vector2);

16
basic-geometry/vector3.h
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

 @ -208,14 +208,14 @@ inline void bgc_fp64_vector3_subtract(BGC_FP64_Vector3* difference, const BGC_FP
// ================== Multiply ================== //
inline void bgc_fp32_vector3_multiply_by_real(BGC_FP32_Vector3* product, const BGC_FP32_Vector3* multiplicand, const float multiplier)
inline void bgc_fp32_vector3_multiply(BGC_FP32_Vector3* product, const BGC_FP32_Vector3* multiplicand, const float multiplier)
{
product->x1 = multiplicand->x1 * multiplier;
product->x2 = multiplicand->x2 * multiplier;
product->x3 = multiplicand->x3 * multiplier;
}
inline void bgc_fp64_vector3_multiply_by_real(BGC_FP64_Vector3* product, const BGC_FP64_Vector3* multiplicand, const double multiplier)
inline void bgc_fp64_vector3_multiply(BGC_FP64_Vector3* product, const BGC_FP64_Vector3* multiplicand, const double multiplier)
{
product->x1 = multiplicand->x1 * multiplier;
product->x2 = multiplicand->x2 * multiplier;
@ -224,24 +224,24 @@ inline void bgc_fp64_vector3_multiply_by_real(BGC_FP64_Vector3* product, const B
// =================== Divide =================== //
inline int bgc_fp32_vector3_divide_by_real(BGC_FP32_Vector3* quotient, const BGC_FP32_Vector3* dividend, const float divisor)
inline int bgc_fp32_vector3_divide(BGC_FP32_Vector3* quotient, const BGC_FP32_Vector3* dividend, const float divisor)
{
if (bgc_fp32_is_zero(divisor) || isnan(divisor)) {
return BGC_FAILURE;
}
bgc_fp32_vector3_multiply_by_real(quotient, dividend, 1.0f / divisor);
bgc_fp32_vector3_multiply(quotient, dividend, 1.0f / divisor);
return BGC_SUCCESS;
}
inline int bgc_fp64_vector3_divide_by_real(BGC_FP64_Vector3* quotient, const BGC_FP64_Vector3* dividend, const double divisor)
inline int bgc_fp64_vector3_divide(BGC_FP64_Vector3* quotient, const BGC_FP64_Vector3* dividend, const double divisor)
{
if (bgc_fp64_is_zero(divisor) || isnan(divisor)) {
return BGC_FAILURE;
}
bgc_fp64_vector3_multiply_by_real(quotient, dividend, 1.0 / divisor);
bgc_fp64_vector3_multiply(quotient, dividend, 1.0 / divisor);
return BGC_SUCCESS;
}
@ -386,7 +386,7 @@ inline int bgc_fp32_vector3_get_normalized(BGC_FP32_Vector3* normalized, const B
return BGC_SUCCESS;
}
bgc_fp32_vector3_multiply_by_real(normalized, vector, sqrtf(1.0f / square_modulus));