Skip to content

Kill unused math functions and formatting cleanup #182

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Sep 4, 2025
+0 −306
Merged

Kill unused math functions and formatting cleanup #182

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
152 changes: 0 additions & 152 deletions src/rawtoaces_core/mathOps.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,17 +20,6 @@ namespace core
{

// Non-class functions
inline double invertD( double val )
{
assert( fabs( val - 0.0 ) >= DBL_EPSILON );

return 1.0 / val;
};

template <typename T> T clip( T val, T target )
{
return std::min( val, target );
};

template <typename T> int isSquare( const vector<vector<T>> &vm )
{
Expand Down Expand Up @@ -126,16 +115,6 @@ template <typename T> vector<T> invertV( const vector<T> &vMtx )
return result;
};

template <typename T> vector<vector<T>> diagVM( const vector<T> &vct )
{
assert( vct.size() != 0 );
vector<vector<T>> vctdiag( vct.size(), vector<T>( vct.size(), T( 0.0 ) ) );

FORI( vct.size() ) vctdiag[i][i] = vct[i];

return vctdiag;
};

template <typename T> vector<T> diagV( const vector<T> &vct )
{
assert( vct.size() != 0 );
Expand Down Expand Up @@ -205,55 +184,6 @@ template <typename T> void scaleVector( vector<T> &vct, const T scale )
return;
};

template <typename T> void scale_vector_max( vector<T> &vector )
{
Eigen::Matrix<T, Eigen::Dynamic, 1> column_vector;
column_vector.resize( vector.size(), 1 );

FORI( vector.size() )
{
column_vector( i, 0 ) = vector[i];
}
column_vector *= ( 1.0 / column_vector.maxCoeff() );

FORI( vector.size() )
{
vector[i] = column_vector( i, 0 );
}

return;
};

template <typename T> void scale_vector_min( vector<T> &vector )
{
Eigen::Matrix<T, Eigen::Dynamic, 1> column_vector;
column_vector.resize( vector.size(), 1 );

FORI( vector.size() )
{
column_vector( i, 0 ) = vector[i];
}
column_vector *= ( 1.0 / column_vector.minCoeff() );

FORI( vector.size() )
{
vector[i] = column_vector( i, 0 );
}

return;
};

template <typename T> void scaleVectorD( vector<T> &vct )
{
Eigen::Matrix<T, Eigen::Dynamic, 1> v;
v.resize( vct.size(), 1 );

FORI( v.rows() ) v( i, 0 ) = vct[i];
FORI( v.rows() ) vct[i] = v.maxCoeff() / vct[i];

return;
};

template <typename T>
vector<T> mulVectorElement( const vector<T> &vct1, const vector<T> &vct2 )
{
Expand All @@ -275,21 +205,6 @@ vector<T> mulVectorElement( const vector<T> &vct1, const vector<T> &vct2 )
return vct3;
};

template <typename T>
vector<T> divVectorElement( const vector<T> &vct1, const vector<T> &vct2 )
{
assert( vct1.size() == vct2.size() );

vector<T> vct2D( vct2.size(), T( 1.0 ) );
FORI( vct2.size() )
{
assert( vct2[i] != T( 0.0 ) );
vct2D[i] = T( 1.0 ) / vct2[i];
}

return mulVectorElement( vct1, vct2D );
};

template <typename T>
vector<T> mulVector( vector<T> vct1, vector<T> vct2, int k = 3 )
{
Expand Down Expand Up @@ -368,73 +283,6 @@ vector<T> mulVector( const vector<T> &vct1, const vector<vector<T>> &vct2 )
return mulVector( vct2, vct1 );
};

template <typename T>
T *mulVectorArray(
T *data,
const uint32_t total,
const uint8_t dim,
const vector<vector<double>> &vct )
{
assert( vct.size() == dim && isSquare( vct ) );

/**
// new implementation based on Eigen::Eigen::Matrix (Slow...)

Eigen::Matrix <T, Eigen::Dynamic, Eigen::Dynamic> MI, mvct;
MI.resize(total/dim, dim);
mvct.resize(dim, dim);
FORIJ(MI.rows(), MI.cols()) MI(i,j) = data[i*dim+j];
FORIJ(dim, dim) mvct(i,j) = static_cast<T>(vct[i][j]);

Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic,RowMajor> MR(MI * (mvct.transpose()));
FORI(total) data[i] = MR(i);
*/

if ( dim == 3 || dim == 4 )
{
for ( uint32_t i = 0; i < total; i += dim )
{
T temp[4];

for ( uint8_t j = 0; j < dim; j++ )
{
temp[j] = 0;

for ( uint8_t k = 0; k < dim; k++ )
temp[j] += vct[j][k] * data[i + k];
}

for ( uint8_t j = 0; j < dim; j++ )
data[i + j] = temp[j];
}
}

return data;
};

template <typename T>
vector<vector<T>>
solveVM( const vector<vector<T>> &vct1, const vector<vector<T>> &vct2 )
{

Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> m1, m2, m3;
m1.resize( vct1.size(), vct1[0].size() );
m2.resize( vct2.size(), vct2[0].size() );

FORIJ( vct1.size(), vct1[0].size() )
m1( i, j ) = vct1[i][j];
FORIJ( vct2.size(), vct2[0].size() )
m2( i, j ) = vct2[i][j];

// colPivHouseholderQr()
m3 = m1.jacobiSvd( Eigen::ComputeThinU | Eigen::ComputeThinV ).solve( m2 );

vector<vector<T>> vct3( m3.rows(), vector<T>( m3.cols() ) );
FORIJ( m3.rows(), m3.cols() ) vct3[i][j] = m3( i, j );

return vct3;
};

/// Calculate the Sum of Squared Errors (SSE) between two vectors.
/// The SSE measures how well the calculated values (tcp) match the reference values (src).
/// Formula: Σ((tcp[i] / src[i] - 1)²)
Expand Down
154 changes: 0 additions & 154 deletions tests/testMath.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,30 +13,6 @@

using namespace rta::core;

void test_InvertD()
{
double a = 1.0;
OIIO_CHECK_EQUAL_THRESH( invertD( a ), 1.0, 1e-9 );

double b = 1000.0;
OIIO_CHECK_EQUAL_THRESH( invertD( b ), 0.001, 1e-9 );

double c = 1000000.0;
OIIO_CHECK_EQUAL_THRESH( invertD( c ), 0.000001, 1e-9 );
};

void test_Clip()
{
double a = 254.9;
OIIO_CHECK_EQUAL_THRESH( clip( a, 255.0 ), a, 1e-5 );

double b = 255.1;
OIIO_CHECK_EQUAL_THRESH( clip( b, 255.0 ), 255.0, 1e-5 );

double c = 63355.0;
OIIO_CHECK_EQUAL_THRESH( clip( c, 63355.0 ), c, 1e-5 );
};

void test_IsSquare()
{
vector<vector<double>> a;
Expand Down Expand Up @@ -126,24 +102,6 @@ void test_InvertV()
FORI( 9 ) OIIO_CHECK_EQUAL_THRESH( V_Inverse[i], MV_Inverse[i], 1e-5 );
};

void test_DiagVM()
{
double M[3][3] = { { 1.0, 0.0, 0.0 },
{ 0.0, 2.0, 0.0 },
{ 0.0, 0.0, 3.0 } };

double vd[3] = { 1.0, 2.0, 3.0 };
vector<double> MV( vd, vd + 3 );
vector<vector<double>> MVD = diagVM( MV );

FORI( 3 )
{
OIIO_CHECK_EQUAL_THRESH( MVD[i][0], M[i][0], 1e-5 );
OIIO_CHECK_EQUAL_THRESH( MVD[i][1], M[i][1], 1e-5 );
OIIO_CHECK_EQUAL_THRESH( MVD[i][2], M[i][2], 1e-5 );
}
};

void test_DiagV()
{
double v[3] = { 1.0, 2.0, 3.0 };
Expand Down Expand Up @@ -200,41 +158,6 @@ void test_SumVector()
OIIO_CHECK_EQUAL_THRESH( sum, 55.0000, 1e-5 );
};

void test_ScaleVectorMax()
{
double M[10] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
double M_Scaled[10] = { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 };
vector<double> MV( M, M + 10 );

scale_vector_max( MV );
FORI( MV.size() )
OIIO_CHECK_EQUAL_THRESH( M_Scaled[i], MV[i], 1e-5 );
};

void test_ScaleVectorMin()
{
double M[10] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
vector<double> MV( M, M + 10 );

scale_vector_min( MV );
FORI( MV.size() )
OIIO_CHECK_EQUAL_THRESH( M[i], MV[i], 1e-5 );
};

void test_scaleVectorD()
{
double M[10] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
double M_Scaled[10] = { 10.0000000000, 5.0000000000, 3.3333333333,
2.5000000000, 2.0000000000, 1.6666666667,
1.4285714286, 1.2500000000, 1.1111111111,
1.0000000000 };
vector<double> MV( M, M + 10 );

scaleVectorD( MV );
FORI( MV.size() )
OIIO_CHECK_EQUAL_THRESH( MV[i], M_Scaled[i], 1e-5 );
};

void test_MulVectorElement()
{
double M1[10] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
Expand All @@ -249,19 +172,6 @@ void test_MulVectorElement()
OIIO_CHECK_EQUAL_THRESH( MV3[i], 10.0000000000, 1e-5 );
};

void test_DivVectorElement()
{
double M1[10] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
double M2[10] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };

vector<double> MV1( M1, M1 + 10 );
vector<double> MV2( M2, M2 + 10 );

vector<double> MV3 = divVectorElement( MV1, MV2 );
FORI( MV3.size() )
OIIO_CHECK_EQUAL_THRESH( MV3[i], 1.0000000000, 1e-5 );
};

void test_MulVector1()
{
double M1[3][3] = { { 1.0, 0.0, 0.0 },
Expand Down Expand Up @@ -312,61 +222,6 @@ void test_MulVector2()
OIIO_CHECK_EQUAL_THRESH( MV3[i], M2[i], 1e-5 );
};

void test_MulVectorArray()
{
double data[9] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
double M[3][3] = { { 1.0000000000, 0.1000000000, 0.0100000000 },
{ 0.1000000000, 2.0000000000, 0.0100000000 },
{ 0.1000000000, 0.0100000000, 3.0000000000 }

};

double data_test[9] = { 1.2300000000, 4.13000000000, 9.12000000000,
4.5600000000, 10.4600000000, 18.4500000000,
7.8900000000, 16.7900000000, 27.7800000000 };

vector<vector<double>> MV( 3, vector<double>( 3 ) );
FORIJ( 3, 3 )
MV[i][j] = M[i][j];

mulVectorArray( data, 9, 3, MV );
FORI( 9 )
OIIO_CHECK_EQUAL_THRESH( data[i], data_test[i], 1e-5 );
};

void test_SolveVM()
{
double M1[3][3] = { { 1.0000000000, 0.0000000000, 0.0000000000 },
{ 0.0000000000, 2.0000000000, 0.0000000000 },
{ 0.0000000000, 0.0000000000, 3.0000000000 }

};
double M2[3][3] = { { 1.0000000000, 0.0000000000, 0.0000000000 },
{ 0.0000000000, 1.0000000000, 0.0000000000 },
{ 0.0000000000, 0.0000000000, 1.0000000000 }

};

double M3_test[3][3] = { { 1.0000000000, 0.0000000000, 0.0000000000 },
{ 0.0000000000, 0.5000000000, 0.0000000000 },
{ 0.0000000000, 0.0000000000, 0.3333333333 }

};

vector<vector<double>> MV1( 3, vector<double>( 3 ) );
vector<vector<double>> MV2( 3, vector<double>( 3 ) );

FORIJ( 3, 3 )
{
MV1[i][j] = M1[i][j];
MV2[i][j] = M2[i][j];
}

vector<vector<double>> MV3 = solveVM( MV1, MV2 );
FORIJ( 3, 3 )
OIIO_CHECK_EQUAL_THRESH( MV3[i][j], M3_test[i][j], 1e-5 );
};

void test_FindIndexInterp1()
{
int M[100];
Expand Down Expand Up @@ -909,27 +764,18 @@ void test_GetCalcXYZt()

int main( int, char ** )
{
test_InvertD();
test_Clip();
test_IsSquare();
test_AddVectors();
test_SubVectors();
test_Cross2();
test_InvertVM();
test_InvertV();
test_DiagVM();
test_DiagV();
test_TransposeVec();
test_SumVector();
test_ScaleVectorMax();
test_ScaleVectorMin();
test_scaleVectorD();
test_MulVectorElement();
test_DivVectorElement();
test_MulVector1();
test_MulVector2();
test_MulVectorArray();
test_SolveVM();
test_FindIndexInterp1();
test_Interp1DLinear();
testIDT_XytoXYZ();
Expand Down
Loading