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

Добавление проверки при делении, стандартизация возвращаемого значения (BGC_SUCCESS, BGC_FAILURE)

Browse source
This commit is contained in:
Andrey Pokidov 2026-02-11 20:55:54 +07:00
parent a4b9f8b2b9
commit e9558ff977
27 changed files with 589 additions and 370 deletions
Download patch file Download diff file Expand all files Collapse all files

76
basic-geometry/vector3.h
View file

@ -208,14 +208,14 @@ inline void bgc_fp64_vector3_subtract(BGC_FP64_Vector3* difference, const BGC_FP
// ================== Multiply ================== //
inline void bgc_fp32_vector3_multiply(BGC_FP32_Vector3* product, const BGC_FP32_Vector3* multiplicand, const float multiplier)
inline void bgc_fp32_vector3_multiply_by_real(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(BGC_FP64_Vector3* product, const BGC_FP64_Vector3* multiplicand, const double multiplier)
inline void bgc_fp64_vector3_multiply_by_real(BGC_FP64_Vector3* product, const BGC_FP64_Vector3* multiplicand, const double multiplier)
{
product->x1 = multiplicand->x1 * multiplier;
product->x2 = multiplicand->x2 * multiplier;
@ -224,14 +224,26 @@ inline void bgc_fp64_vector3_multiply(BGC_FP64_Vector3* product, const BGC_FP64_
// =================== Divide =================== //
inline void bgc_fp32_vector3_divide(BGC_FP32_Vector3* quotient, const BGC_FP32_Vector3* dividend, const float divisor)
inline int bgc_fp32_vector3_divide_by_real(BGC_FP32_Vector3* quotient, const BGC_FP32_Vector3* dividend, const float divisor)
{
bgc_fp32_vector3_multiply(quotient, dividend, 1.0f / divisor);
if (bgc_fp32_is_zero(divisor) || isnan(divisor)) {
return BGC_FAILURE;
}
bgc_fp32_vector3_multiply_by_real(quotient, dividend, 1.0f / divisor);
return BGC_SUCCESS;
}
inline void bgc_fp64_vector3_divide(BGC_FP64_Vector3* quotient, const BGC_FP64_Vector3* dividend, const double divisor)
inline int bgc_fp64_vector3_divide_by_real(BGC_FP64_Vector3* quotient, const BGC_FP64_Vector3* dividend, const double divisor)
{
bgc_fp64_vector3_multiply(quotient, dividend, 1.0 / divisor);
if (bgc_fp64_is_zero(divisor) || isnan(divisor)) {
return BGC_FAILURE;
}
bgc_fp64_vector3_multiply_by_real(quotient, dividend, 1.0 / divisor);
return BGC_SUCCESS;
}
// ================== Average2 ================== //
@ -322,12 +334,12 @@ inline int bgc_fp32_vector3_normalize(BGC_FP32_Vector3* vector)
{
const float square_modulus = bgc_fp32_vector3_get_square_modulus(vector);
if (bgc_fp32_is_square_unit(square_modulus)) {
return 1;
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE;
}
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
return 0;
if (bgc_fp32_is_square_unit(square_modulus)) {
return BGC_SUCCESS;
}
const float multiplier = sqrtf(1.0f / square_modulus);
@ -336,19 +348,19 @@ inline int bgc_fp32_vector3_normalize(BGC_FP32_Vector3* vector)
vector->x2 *= multiplier;
vector->x3 *= multiplier;
return 1;
return BGC_SUCCESS;
}
inline int bgc_fp64_vector3_normalize(BGC_FP64_Vector3* vector)
{
const double square_modulus = bgc_fp64_vector3_get_square_modulus(vector);
if (bgc_fp64_is_square_unit(square_modulus)) {
return 1;
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
return BGC_FAILURE;
}
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
return 0;
if (bgc_fp64_is_square_unit(square_modulus)) {
return BGC_SUCCESS;
}
const double multiplier = sqrt(1.0 / square_modulus);
@ -357,43 +369,43 @@ inline int bgc_fp64_vector3_normalize(BGC_FP64_Vector3* vector)
vector->x2 *= multiplier;
vector->x3 *= multiplier;
return 1;
return BGC_SUCCESS;
}
inline int bgc_fp32_vector3_get_normalized(BGC_FP32_Vector3* normalized, const BGC_FP32_Vector3* vector)
{
const float square_modulus = bgc_fp32_vector3_get_square_modulus(vector);
if (bgc_fp32_is_square_unit(square_modulus)) {
bgc_fp32_vector3_copy(normalized, vector);
return 1;
}
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
bgc_fp32_vector3_reset(normalized);
return 0;
return BGC_FAILURE;
}
bgc_fp32_vector3_multiply(normalized, vector, sqrtf(1.0f / square_modulus));
return 1;
if (bgc_fp32_is_square_unit(square_modulus)) {
bgc_fp32_vector3_copy(normalized, vector);
return BGC_SUCCESS;
}
bgc_fp32_vector3_multiply_by_real(normalized, vector, sqrtf(1.0f / square_modulus));
return BGC_SUCCESS;
}
inline int bgc_fp64_vector3_get_normalized(BGC_FP64_Vector3* normalized, const BGC_FP64_Vector3* vector)
{
const double square_modulus = bgc_fp64_vector3_get_square_modulus(vector);
if (bgc_fp64_is_square_unit(square_modulus)) {
bgc_fp64_vector3_copy(normalized, vector);
return 1;
}
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
bgc_fp64_vector3_reset(normalized);
return 0;
return BGC_FAILURE;
}
bgc_fp64_vector3_multiply(normalized, vector, sqrt(1.0 / square_modulus));
return 1;
if (bgc_fp64_is_square_unit(square_modulus)) {
bgc_fp64_vector3_copy(normalized, vector);
return BGC_SUCCESS;
}
bgc_fp64_vector3_multiply_by_real(normalized, vector, sqrt(1.0 / square_modulus));
return BGC_SUCCESS;
}
// =============== Scalar Product =============== //