Переход на версию 0.3: изменение подхода к именованию сущностей, добавление, изменение и удаление ряда функций
This commit is contained in:
parent
d33daf4e2d
commit
f7e41645fe
87 changed files with 4580 additions and 4051 deletions
|
|
@ -7,7 +7,7 @@
|
|||
|
||||
// =================== Reset ==================== //
|
||||
|
||||
inline void bgc_matrix2x3_reset_fp32(BgcMatrix2x3FP32* matrix)
|
||||
inline void bgc_fp32_matrix2x3_reset(BGC_FP32_Matrix2x3* matrix)
|
||||
{
|
||||
matrix->r1c1 = 0.0f;
|
||||
matrix->r1c2 = 0.0f;
|
||||
|
|
@ -19,7 +19,7 @@ inline void bgc_matrix2x3_reset_fp32(BgcMatrix2x3FP32* matrix)
|
|||
matrix->r3c2 = 0.0f;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_reset_fp64(BgcMatrix2x3FP64* matrix)
|
||||
inline void bgc_fp64_matrix2x3_reset(BGC_FP64_Matrix2x3* matrix)
|
||||
{
|
||||
matrix->r1c1 = 0.0;
|
||||
matrix->r1c2 = 0.0;
|
||||
|
|
@ -33,7 +33,7 @@ inline void bgc_matrix2x3_reset_fp64(BgcMatrix2x3FP64* matrix)
|
|||
|
||||
// ==================== Copy ==================== //
|
||||
|
||||
inline void bgc_matrix2x3_copy_fp32(const BgcMatrix2x3FP32* source, BgcMatrix2x3FP32* destination)
|
||||
inline void bgc_fp32_matrix2x3_copy(const BGC_FP32_Matrix2x3* source, BGC_FP32_Matrix2x3* destination)
|
||||
{
|
||||
destination->r1c1 = source->r1c1;
|
||||
destination->r1c2 = source->r1c2;
|
||||
|
|
@ -45,7 +45,7 @@ inline void bgc_matrix2x3_copy_fp32(const BgcMatrix2x3FP32* source, BgcMatrix2x3
|
|||
destination->r3c2 = source->r3c2;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_copy_fp64(const BgcMatrix2x3FP64* source, BgcMatrix2x3FP64* destination)
|
||||
inline void bgc_fp64_matrix2x3_copy(const BGC_FP64_Matrix2x3* source, BGC_FP64_Matrix2x3* destination)
|
||||
{
|
||||
destination->r1c1 = source->r1c1;
|
||||
destination->r1c2 = source->r1c2;
|
||||
|
|
@ -59,7 +59,7 @@ inline void bgc_matrix2x3_copy_fp64(const BgcMatrix2x3FP64* source, BgcMatrix2x3
|
|||
|
||||
// ==================== Swap ==================== //
|
||||
|
||||
inline void bgc_matrix2x3_swap_fp32(BgcMatrix2x3FP32* matrix1, BgcMatrix2x3FP32* matrix2)
|
||||
inline void bgc_fp32_matrix2x3_swap(BGC_FP32_Matrix2x3* matrix1, BGC_FP32_Matrix2x3* matrix2)
|
||||
{
|
||||
const float r1c1 = matrix2->r1c1;
|
||||
const float r1c2 = matrix2->r1c2;
|
||||
|
|
@ -89,7 +89,7 @@ inline void bgc_matrix2x3_swap_fp32(BgcMatrix2x3FP32* matrix1, BgcMatrix2x3FP32*
|
|||
matrix1->r3c2 = r3c2;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_swap_fp64(BgcMatrix2x3FP64* matrix1, BgcMatrix2x3FP64* matrix2)
|
||||
inline void bgc_fp64_matrix2x3_swap(BGC_FP64_Matrix2x3* matrix1, BGC_FP64_Matrix2x3* matrix2)
|
||||
{
|
||||
const double r1c1 = matrix2->r1c1;
|
||||
const double r1c2 = matrix2->r1c2;
|
||||
|
|
@ -121,7 +121,7 @@ inline void bgc_matrix2x3_swap_fp64(BgcMatrix2x3FP64* matrix1, BgcMatrix2x3FP64*
|
|||
|
||||
// ================== Convert =================== //
|
||||
|
||||
inline void bgc_matrix2x3_convert_fp64_to_fp32(const BgcMatrix2x3FP64* source, BgcMatrix2x3FP32* destination)
|
||||
inline void bgc_fp64_matrix2x3_convert_to_fp32(const BGC_FP64_Matrix2x3* source, BGC_FP32_Matrix2x3* destination)
|
||||
{
|
||||
destination->r1c1 = (float)source->r1c1;
|
||||
destination->r1c2 = (float)source->r1c2;
|
||||
|
|
@ -133,7 +133,7 @@ inline void bgc_matrix2x3_convert_fp64_to_fp32(const BgcMatrix2x3FP64* source, B
|
|||
destination->r3c2 = (float)source->r3c2;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_convert_fp32_to_fp64(const BgcMatrix2x3FP32* source, BgcMatrix2x3FP64* destination)
|
||||
inline void bgc_fp32_matrix2x3_convert_to_fp64(const BGC_FP32_Matrix2x3* source, BGC_FP64_Matrix2x3* destination)
|
||||
{
|
||||
destination->r1c1 = source->r1c1;
|
||||
destination->r1c2 = source->r1c2;
|
||||
|
|
@ -147,7 +147,7 @@ inline void bgc_matrix2x3_convert_fp32_to_fp64(const BgcMatrix2x3FP32* source, B
|
|||
|
||||
// ================= Transpose ================== //
|
||||
|
||||
inline void bgc_matrix2x3_transpose_fp32(const BgcMatrix3x2FP32* matrix, BgcMatrix2x3FP32* transposed)
|
||||
inline void bgc_fp32_matrix2x3_get_transposed(const BGC_FP32_Matrix3x2* matrix, BGC_FP32_Matrix2x3* transposed)
|
||||
{
|
||||
transposed->r1c1 = matrix->r1c1;
|
||||
transposed->r1c2 = matrix->r2c1;
|
||||
|
|
@ -159,7 +159,7 @@ inline void bgc_matrix2x3_transpose_fp32(const BgcMatrix3x2FP32* matrix, BgcMatr
|
|||
transposed->r3c2 = matrix->r2c3;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_transpose_fp64(const BgcMatrix3x2FP64* matrix, BgcMatrix2x3FP64* transposed)
|
||||
inline void bgc_fp64_matrix2x3_get_transposed(const BGC_FP64_Matrix3x2* matrix, BGC_FP64_Matrix2x3* transposed)
|
||||
{
|
||||
transposed->r1c1 = matrix->r1c1;
|
||||
transposed->r1c2 = matrix->r2c1;
|
||||
|
|
@ -171,83 +171,169 @@ inline void bgc_matrix2x3_transpose_fp64(const BgcMatrix3x2FP64* matrix, BgcMatr
|
|||
transposed->r3c2 = matrix->r2c3;
|
||||
}
|
||||
|
||||
// ================= Set Row 1 ================== //
|
||||
// ================== Get Row =================== //
|
||||
|
||||
inline void bgc_matrix2x3_set_row1_fp32(const float c1, const float c2, BgcMatrix2x3FP32* matrix)
|
||||
inline void bgc_fp32_matrix2x3_get_row(const int number, const BGC_FP32_Matrix2x3* matrix, BGC_FP32_Vector2* row)
|
||||
{
|
||||
matrix->r1c1 = c1;
|
||||
matrix->r1c2 = c2;
|
||||
if (number == 1) {
|
||||
row->x1 = matrix->r1c1;
|
||||
row->x2 = matrix->r1c2;
|
||||
return;
|
||||
}
|
||||
|
||||
if (number == 2) {
|
||||
row->x1 = matrix->r2c1;
|
||||
row->x2 = matrix->r2c2;
|
||||
return;
|
||||
}
|
||||
|
||||
if (number == 3) {
|
||||
row->x1 = matrix->r3c1;
|
||||
row->x2 = matrix->r3c2;
|
||||
return;
|
||||
}
|
||||
|
||||
row->x1 = 0.0f;
|
||||
row->x2 = 0.0f;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_set_row1_fp64(const double c1, const double c2, BgcMatrix2x3FP64* matrix)
|
||||
inline void bgc_fp64_matrix2x3_get_row(const int number, const BGC_FP64_Matrix2x3* matrix, BGC_FP64_Vector2* row)
|
||||
{
|
||||
matrix->r1c1 = c1;
|
||||
matrix->r1c2 = c2;
|
||||
if (number == 1) {
|
||||
row->x1 = matrix->r1c1;
|
||||
row->x2 = matrix->r1c2;
|
||||
return;
|
||||
}
|
||||
|
||||
if (number == 2) {
|
||||
row->x1 = matrix->r2c1;
|
||||
row->x2 = matrix->r2c2;
|
||||
return;
|
||||
}
|
||||
|
||||
if (number == 3) {
|
||||
row->x1 = matrix->r3c1;
|
||||
row->x2 = matrix->r3c2;
|
||||
return;
|
||||
}
|
||||
|
||||
row->x1 = 0.0f;
|
||||
row->x2 = 0.0f;
|
||||
}
|
||||
|
||||
// ================= Set Row 2 ================== //
|
||||
// ================== Set Row =================== //
|
||||
|
||||
inline void bgc_matrix2x3_set_row2_fp32(const float c1, const float c2, BgcMatrix2x3FP32* matrix)
|
||||
inline void bgc_fp32_matrix2x3_set_row(const int number, const BGC_FP32_Vector2* row, BGC_FP32_Matrix2x3* matrix)
|
||||
{
|
||||
matrix->r2c1 = c1;
|
||||
matrix->r2c2 = c2;
|
||||
if (number == 1) {
|
||||
matrix->r1c1 = row->x1;
|
||||
matrix->r1c2 = row->x2;
|
||||
return;
|
||||
}
|
||||
|
||||
if (number == 2) {
|
||||
matrix->r2c1 = row->x1;
|
||||
matrix->r2c2 = row->x2;
|
||||
return;
|
||||
}
|
||||
|
||||
if (number == 3) {
|
||||
matrix->r3c1 = row->x1;
|
||||
matrix->r3c2 = row->x2;
|
||||
}
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_set_row2_fp64(const double c1, const double c2, BgcMatrix2x3FP64* matrix)
|
||||
inline void bgc_fp64_matrix2x3_set_row(const int number, const BGC_FP64_Vector2* row, BGC_FP64_Matrix2x3* matrix)
|
||||
{
|
||||
matrix->r2c1 = c1;
|
||||
matrix->r2c2 = c2;
|
||||
if (number == 1) {
|
||||
matrix->r1c1 = row->x1;
|
||||
matrix->r1c2 = row->x2;
|
||||
return;
|
||||
}
|
||||
|
||||
if (number == 2) {
|
||||
matrix->r2c1 = row->x1;
|
||||
matrix->r2c2 = row->x2;
|
||||
return;
|
||||
}
|
||||
|
||||
if (number == 3) {
|
||||
matrix->r3c1 = row->x1;
|
||||
matrix->r3c2 = row->x2;
|
||||
}
|
||||
}
|
||||
|
||||
// ================= Set Row 3 ================== //
|
||||
// ================= Get Column ================= //
|
||||
|
||||
inline void bgc_matrix2x3_set_row3_fp32(const float c1, const float c2, BgcMatrix2x3FP32* matrix)
|
||||
inline void bgc_fp32_matrix2x3_get_column(const int number, const BGC_FP32_Matrix2x3* matrix, BGC_FP32_Vector3* column)
|
||||
{
|
||||
matrix->r3c1 = c1;
|
||||
matrix->r3c2 = c2;
|
||||
if (number == 1) {
|
||||
column->x1 = matrix->r1c1;
|
||||
column->x2 = matrix->r2c1;
|
||||
column->x3 = matrix->r3c1;
|
||||
return;
|
||||
}
|
||||
|
||||
if (number == 2) {
|
||||
column->x1 = matrix->r1c2;
|
||||
column->x2 = matrix->r2c2;
|
||||
column->x3 = matrix->r3c2;
|
||||
}
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_set_row3_fp64(const double c1, const double c2, BgcMatrix2x3FP64* matrix)
|
||||
inline void bgc_fp64_matrix2x3_get_column(const int number, const BGC_FP64_Matrix2x3* matrix, BGC_FP64_Vector3* column)
|
||||
{
|
||||
matrix->r3c1 = c1;
|
||||
matrix->r3c2 = c2;
|
||||
if (number == 1) {
|
||||
column->x1 = matrix->r1c1;
|
||||
column->x2 = matrix->r2c1;
|
||||
column->x3 = matrix->r3c1;
|
||||
return;
|
||||
}
|
||||
|
||||
if (number == 2) {
|
||||
column->x1 = matrix->r1c2;
|
||||
column->x2 = matrix->r2c2;
|
||||
column->x3 = matrix->r3c2;
|
||||
}
|
||||
}
|
||||
|
||||
// ================ Set Column 1 ================ //
|
||||
// ================= Set Column ================= //
|
||||
|
||||
inline void bgc_matrix2x3_set_column1_fp32(const float r1, const float r2, const float r3, BgcMatrix2x3FP32* matrix)
|
||||
inline void bgc_fp32_matrix2x3_set_column(const int number, const BGC_FP32_Vector3* column, BGC_FP32_Matrix2x3* matrix)
|
||||
{
|
||||
matrix->r1c1 = r1;
|
||||
matrix->r2c1 = r2;
|
||||
matrix->r3c1 = r3;
|
||||
if (number == 1) {
|
||||
matrix->r1c1 = column->x1;
|
||||
matrix->r2c1 = column->x2;
|
||||
matrix->r3c1 = column->x3;
|
||||
return;
|
||||
}
|
||||
|
||||
if (number == 2) {
|
||||
matrix->r1c2 = column->x1;
|
||||
matrix->r2c2 = column->x2;
|
||||
matrix->r3c2 = column->x3;
|
||||
}
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_set_column1_fp64(const double r1, const double r2, const double r3, BgcMatrix2x3FP64* matrix)
|
||||
inline void bgc_fp64_matrix2x3_set_column(const int number, const BGC_FP64_Vector3* column, BGC_FP64_Matrix2x3* matrix)
|
||||
{
|
||||
matrix->r1c1 = r1;
|
||||
matrix->r2c1 = r2;
|
||||
matrix->r3c1 = r3;
|
||||
}
|
||||
if (number == 1) {
|
||||
matrix->r1c1 = column->x1;
|
||||
matrix->r2c1 = column->x2;
|
||||
matrix->r3c1 = column->x3;
|
||||
return;
|
||||
}
|
||||
|
||||
// ================ Set Column 2 ================ //
|
||||
|
||||
inline void bgc_matrix2x3_set_column2_fp32(const float r1, const float r2, const float r3, BgcMatrix2x3FP32* matrix)
|
||||
{
|
||||
matrix->r1c2 = r1;
|
||||
matrix->r2c2 = r2;
|
||||
matrix->r3c2 = r3;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_set_column2_fp64(const double r1, const double r2, const double r3, BgcMatrix2x3FP64* matrix)
|
||||
{
|
||||
matrix->r1c2 = r1;
|
||||
matrix->r2c2 = r2;
|
||||
matrix->r3c2 = r3;
|
||||
if (number == 2) {
|
||||
matrix->r1c2 = column->x1;
|
||||
matrix->r2c2 = column->x2;
|
||||
matrix->r3c2 = column->x3;
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== Add ===================== //
|
||||
|
||||
inline void bgc_matrix2x3_add_fp32(const BgcMatrix2x3FP32* matrix1, const BgcMatrix2x3FP32* matrix2, BgcMatrix2x3FP32* sum)
|
||||
inline void bgc_fp32_matrix2x3_add(const BGC_FP32_Matrix2x3* matrix1, const BGC_FP32_Matrix2x3* matrix2, BGC_FP32_Matrix2x3* sum)
|
||||
{
|
||||
sum->r1c1 = matrix1->r1c1 + matrix2->r1c1;
|
||||
sum->r1c2 = matrix1->r1c2 + matrix2->r1c2;
|
||||
|
|
@ -259,7 +345,7 @@ inline void bgc_matrix2x3_add_fp32(const BgcMatrix2x3FP32* matrix1, const BgcMat
|
|||
sum->r3c2 = matrix1->r3c2 + matrix2->r3c2;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_add_fp64(const BgcMatrix2x3FP64* matrix1, const BgcMatrix2x3FP64* matrix2, BgcMatrix2x3FP64* sum)
|
||||
inline void bgc_fp64_matrix2x3_add(const BGC_FP64_Matrix2x3* matrix1, const BGC_FP64_Matrix2x3* matrix2, BGC_FP64_Matrix2x3* sum)
|
||||
{
|
||||
sum->r1c1 = matrix1->r1c1 + matrix2->r1c1;
|
||||
sum->r1c2 = matrix1->r1c2 + matrix2->r1c2;
|
||||
|
|
@ -273,7 +359,7 @@ inline void bgc_matrix2x3_add_fp64(const BgcMatrix2x3FP64* matrix1, const BgcMat
|
|||
|
||||
// ================= Add scaled ================= //
|
||||
|
||||
inline void bgc_matrix2x3_add_scaled_fp32(const BgcMatrix2x3FP32* basic_matrix, const BgcMatrix2x3FP32* scalable_matrix, const float scale, BgcMatrix2x3FP32* sum)
|
||||
inline void bgc_fp32_matrix2x3_add_scaled(const BGC_FP32_Matrix2x3* basic_matrix, const BGC_FP32_Matrix2x3* scalable_matrix, const float scale, BGC_FP32_Matrix2x3* sum)
|
||||
{
|
||||
sum->r1c1 = basic_matrix->r1c1 + scalable_matrix->r1c1 * scale;
|
||||
sum->r1c2 = basic_matrix->r1c2 + scalable_matrix->r1c2 * scale;
|
||||
|
|
@ -285,7 +371,7 @@ inline void bgc_matrix2x3_add_scaled_fp32(const BgcMatrix2x3FP32* basic_matrix,
|
|||
sum->r3c2 = basic_matrix->r3c2 + scalable_matrix->r3c2 * scale;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_add_scaled_fp64(const BgcMatrix2x3FP64* basic_matrix, const BgcMatrix2x3FP64* scalable_matrix, const double scale, BgcMatrix2x3FP64* sum)
|
||||
inline void bgc_fp64_matrix2x3_add_scaled(const BGC_FP64_Matrix2x3* basic_matrix, const BGC_FP64_Matrix2x3* scalable_matrix, const double scale, BGC_FP64_Matrix2x3* sum)
|
||||
{
|
||||
sum->r1c1 = basic_matrix->r1c1 + scalable_matrix->r1c1 * scale;
|
||||
sum->r1c2 = basic_matrix->r1c2 + scalable_matrix->r1c2 * scale;
|
||||
|
|
@ -299,7 +385,7 @@ inline void bgc_matrix2x3_add_scaled_fp64(const BgcMatrix2x3FP64* basic_matrix,
|
|||
|
||||
// ================== Subtract ================== //
|
||||
|
||||
inline void bgc_matrix2x3_subtract_fp32(const BgcMatrix2x3FP32* minuend, const BgcMatrix2x3FP32* subtrahend, BgcMatrix2x3FP32* difference)
|
||||
inline void bgc_fp32_matrix2x3_subtract(const BGC_FP32_Matrix2x3* minuend, const BGC_FP32_Matrix2x3* subtrahend, BGC_FP32_Matrix2x3* difference)
|
||||
{
|
||||
difference->r1c1 = minuend->r1c1 - subtrahend->r1c1;
|
||||
difference->r1c2 = minuend->r1c2 - subtrahend->r1c2;
|
||||
|
|
@ -311,7 +397,7 @@ inline void bgc_matrix2x3_subtract_fp32(const BgcMatrix2x3FP32* minuend, const B
|
|||
difference->r3c2 = minuend->r3c2 - subtrahend->r3c2;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_subtract_fp64(const BgcMatrix2x3FP64* minuend, const BgcMatrix2x3FP64* subtrahend, BgcMatrix2x3FP64* difference)
|
||||
inline void bgc_fp64_matrix2x3_subtract(const BGC_FP64_Matrix2x3* minuend, const BGC_FP64_Matrix2x3* subtrahend, BGC_FP64_Matrix2x3* difference)
|
||||
{
|
||||
difference->r1c1 = minuend->r1c1 - subtrahend->r1c1;
|
||||
difference->r1c2 = minuend->r1c2 - subtrahend->r1c2;
|
||||
|
|
@ -323,35 +409,9 @@ inline void bgc_matrix2x3_subtract_fp64(const BgcMatrix2x3FP64* minuend, const B
|
|||
difference->r3c2 = minuend->r3c2 - subtrahend->r3c2;
|
||||
}
|
||||
|
||||
// ============== Subtract scaled =============== //
|
||||
|
||||
inline void bgc_matrix2x3_subtract_scaled_fp32(const BgcMatrix2x3FP32* basic_matrix, const BgcMatrix2x3FP32* scalable_matrix, const float scale, BgcMatrix2x3FP32* difference)
|
||||
{
|
||||
difference->r1c1 = basic_matrix->r1c1 - scalable_matrix->r1c1 * scale;
|
||||
difference->r1c2 = basic_matrix->r1c2 - scalable_matrix->r1c2 * scale;
|
||||
|
||||
difference->r2c1 = basic_matrix->r2c1 - scalable_matrix->r2c1 * scale;
|
||||
difference->r2c2 = basic_matrix->r2c2 - scalable_matrix->r2c2 * scale;
|
||||
|
||||
difference->r3c1 = basic_matrix->r3c1 - scalable_matrix->r3c1 * scale;
|
||||
difference->r3c2 = basic_matrix->r3c2 - scalable_matrix->r3c2 * scale;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_subtract_scaled_fp64(const BgcMatrix2x3FP64* basic_matrix, const BgcMatrix2x3FP64* scalable_matrix, const double scale, BgcMatrix2x3FP64* difference)
|
||||
{
|
||||
difference->r1c1 = basic_matrix->r1c1 - scalable_matrix->r1c1 * scale;
|
||||
difference->r1c2 = basic_matrix->r1c2 - scalable_matrix->r1c2 * scale;
|
||||
|
||||
difference->r2c1 = basic_matrix->r2c1 - scalable_matrix->r2c1 * scale;
|
||||
difference->r2c2 = basic_matrix->r2c2 - scalable_matrix->r2c2 * scale;
|
||||
|
||||
difference->r3c1 = basic_matrix->r3c1 - scalable_matrix->r3c1 * scale;
|
||||
difference->r3c2 = basic_matrix->r3c2 - scalable_matrix->r3c2 * scale;
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_matrix2x3_multiply_fp32(const BgcMatrix2x3FP32* multiplicand, const float multiplier, BgcMatrix2x3FP32* product)
|
||||
inline void bgc_fp32_matrix2x3_multiply(const BGC_FP32_Matrix2x3* multiplicand, const float multiplier, BGC_FP32_Matrix2x3* product)
|
||||
{
|
||||
product->r1c1 = multiplicand->r1c1 * multiplier;
|
||||
product->r1c2 = multiplicand->r1c2 * multiplier;
|
||||
|
|
@ -363,7 +423,7 @@ inline void bgc_matrix2x3_multiply_fp32(const BgcMatrix2x3FP32* multiplicand, co
|
|||
product->r3c2 = multiplicand->r3c2 * multiplier;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_multiply_fp64(const BgcMatrix2x3FP64* multiplicand, const double multiplier, BgcMatrix2x3FP64* product)
|
||||
inline void bgc_fp64_matrix2x3_multiply(const BGC_FP64_Matrix2x3* multiplicand, const double multiplier, BGC_FP64_Matrix2x3* product)
|
||||
{
|
||||
product->r1c1 = multiplicand->r1c1 * multiplier;
|
||||
product->r1c2 = multiplicand->r1c2 * multiplier;
|
||||
|
|
@ -377,44 +437,74 @@ inline void bgc_matrix2x3_multiply_fp64(const BgcMatrix2x3FP64* multiplicand, co
|
|||
|
||||
// =================== Divide =================== //
|
||||
|
||||
inline void bgc_matrix2x3_divide_fp32(const BgcMatrix2x3FP32* dividend, const float divisor, BgcMatrix2x3FP32* quotient)
|
||||
inline void bgc_fp32_matrix2x3_divide(const BGC_FP32_Matrix2x3* dividend, const float divisor, BGC_FP32_Matrix2x3* quotient)
|
||||
{
|
||||
bgc_matrix2x3_multiply_fp32(dividend, 1.0f / divisor, quotient);
|
||||
bgc_fp32_matrix2x3_multiply(dividend, 1.0f / divisor, quotient);
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_divide_fp64(const BgcMatrix2x3FP64* dividend, const double divisor, BgcMatrix2x3FP64* quotient)
|
||||
inline void bgc_fp64_matrix2x3_divide(const BGC_FP64_Matrix2x3* dividend, const double divisor, BGC_FP64_Matrix2x3* quotient)
|
||||
{
|
||||
bgc_matrix2x3_multiply_fp64(dividend, 1.0 / divisor, quotient);
|
||||
bgc_fp64_matrix2x3_multiply(dividend, 1.0 / divisor, quotient);
|
||||
}
|
||||
|
||||
// ================ Interpolate ================= //
|
||||
|
||||
inline void bgc_fp32_matrix2x3_interpolate(const BGC_FP32_Matrix2x3* first, const BGC_FP32_Matrix2x3* second, const float phase, BGC_FP32_Matrix2x3* interpolation)
|
||||
{
|
||||
const float couter_phase = 1.0f - phase;
|
||||
|
||||
interpolation->r1c1 = first->r1c1 * couter_phase + second->r1c1 * phase;
|
||||
interpolation->r1c2 = first->r1c2 * couter_phase + second->r1c2 * phase;
|
||||
|
||||
interpolation->r2c1 = first->r2c1 * couter_phase + second->r2c1 * phase;
|
||||
interpolation->r2c2 = first->r2c2 * couter_phase + second->r2c2 * phase;
|
||||
|
||||
interpolation->r3c1 = first->r3c1 * couter_phase + second->r3c1 * phase;
|
||||
interpolation->r3c2 = first->r3c2 * couter_phase + second->r3c2 * phase;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_matrix2x3_interpolate(const BGC_FP64_Matrix2x3* first, const BGC_FP64_Matrix2x3* second, const double phase, BGC_FP64_Matrix2x3* interpolation)
|
||||
{
|
||||
const double couter_phase = 1.0 - phase;
|
||||
|
||||
interpolation->r1c1 = first->r1c1 * couter_phase + second->r1c1 * phase;
|
||||
interpolation->r1c2 = first->r1c2 * couter_phase + second->r1c2 * phase;
|
||||
|
||||
interpolation->r2c1 = first->r2c1 * couter_phase + second->r2c1 * phase;
|
||||
interpolation->r2c2 = first->r2c2 * couter_phase + second->r2c2 * phase;
|
||||
|
||||
interpolation->r3c1 = first->r3c1 * couter_phase + second->r3c1 * phase;
|
||||
interpolation->r3c2 = first->r3c2 * couter_phase + second->r3c2 * phase;
|
||||
}
|
||||
|
||||
// ============ Left Vector Product ============= //
|
||||
|
||||
inline void bgc_matrix2x3_get_left_product_fp32(const BgcVector3FP32* vector, const BgcMatrix2x3FP32* matrix, BgcVector2FP32* result)
|
||||
inline void bgc_fp32_multiply_vector3_by_matrix2x3(const BGC_FP32_Vector3* vector, const BGC_FP32_Matrix2x3* matrix, BGC_FP32_Vector2* product)
|
||||
{
|
||||
result->x1 = vector->x1 * matrix->r1c1 + vector->x2 * matrix->r2c1 + vector->x3 * matrix->r3c1;
|
||||
result->x2 = vector->x1 * matrix->r1c2 + vector->x2 * matrix->r2c2 + vector->x3 * matrix->r3c2;
|
||||
product->x1 = vector->x1 * matrix->r1c1 + vector->x2 * matrix->r2c1 + vector->x3 * matrix->r3c1;
|
||||
product->x2 = vector->x1 * matrix->r1c2 + vector->x2 * matrix->r2c2 + vector->x3 * matrix->r3c2;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_get_left_product_fp64(const BgcVector3FP64* vector, const BgcMatrix2x3FP64* matrix, BgcVector2FP64* result)
|
||||
inline void bgc_fp64_multiply_vector3_by_matrix2x3(const BGC_FP64_Vector3* vector, const BGC_FP64_Matrix2x3* matrix, BGC_FP64_Vector2* product)
|
||||
{
|
||||
result->x1 = vector->x1 * matrix->r1c1 + vector->x2 * matrix->r2c1 + vector->x3 * matrix->r3c1;
|
||||
result->x2 = vector->x1 * matrix->r1c2 + vector->x2 * matrix->r2c2 + vector->x3 * matrix->r3c2;
|
||||
product->x1 = vector->x1 * matrix->r1c1 + vector->x2 * matrix->r2c1 + vector->x3 * matrix->r3c1;
|
||||
product->x2 = vector->x1 * matrix->r1c2 + vector->x2 * matrix->r2c2 + vector->x3 * matrix->r3c2;
|
||||
}
|
||||
|
||||
// ============ Right Vector Product ============ //
|
||||
|
||||
inline void bgc_matrix2x3_get_right_product_fp32(const BgcMatrix2x3FP32* matrix, const BgcVector2FP32* vector, BgcVector3FP32* result)
|
||||
inline void bgc_fp32_multiply_matrix2x3_by_vector2(const BGC_FP32_Matrix2x3* matrix, const BGC_FP32_Vector2* vector, BGC_FP32_Vector3* product)
|
||||
{
|
||||
result->x1 = matrix->r1c1 * vector->x1 + matrix->r1c2 * vector->x2;
|
||||
result->x2 = matrix->r2c1 * vector->x1 + matrix->r2c2 * vector->x2;
|
||||
result->x3 = matrix->r3c1 * vector->x1 + matrix->r3c2 * vector->x2;
|
||||
product->x1 = matrix->r1c1 * vector->x1 + matrix->r1c2 * vector->x2;
|
||||
product->x2 = matrix->r2c1 * vector->x1 + matrix->r2c2 * vector->x2;
|
||||
product->x3 = matrix->r3c1 * vector->x1 + matrix->r3c2 * vector->x2;
|
||||
}
|
||||
|
||||
inline void bgc_matrix2x3_get_right_product_fp64(const BgcMatrix2x3FP64* matrix, const BgcVector2FP64* vector, BgcVector3FP64* result)
|
||||
inline void bgc_fp64_multiply_matrix2x3_by_vector2(const BGC_FP64_Matrix2x3* matrix, const BGC_FP64_Vector2* vector, BGC_FP64_Vector3* product)
|
||||
{
|
||||
result->x1 = matrix->r1c1 * vector->x1 + matrix->r1c2 * vector->x2;
|
||||
result->x2 = matrix->r2c1 * vector->x1 + matrix->r2c2 * vector->x2;
|
||||
result->x3 = matrix->r3c1 * vector->x1 + matrix->r3c2 * vector->x2;
|
||||
product->x1 = matrix->r1c1 * vector->x1 + matrix->r1c2 * vector->x2;
|
||||
product->x2 = matrix->r2c1 * vector->x1 + matrix->r2c2 * vector->x2;
|
||||
product->x3 = matrix->r3c1 * vector->x1 + matrix->r3c2 * vector->x2;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue