coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-11-09 14:49:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Changed traits implementation for maths algorithms

Browse Source
This commit is contained in:
John Wellbelove 2021-04-10 18:51:10 +01:00
parent 0603794454
commit c426fc40b9
6 changed files with 187 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
include/etl/correlation.h
View File

@ -48,25 +48,7 @@ namespace etl
template <typename TInput, typename TCalc>
struct correlation_traits
{
TCalc inner_product;
TCalc sum_of_squares1;
TCalc sum_of_squares2;
TCalc sum1;
TCalc sum2;
uint32_t counter;
//*********************************
/// Clear the correlation.
//*********************************
void clear()
{
inner_product = TCalc(0);
sum_of_squares1 = TCalc(0);
sum_of_squares2 = TCalc(0);
sum1 = TCalc(0);
sum2 = TCalc(0);
counter = 0U;
}
typedef TCalc calc_t;
};
//***************************************************************************
@ -75,25 +57,7 @@ namespace etl
template <typename TCalc>
struct correlation_traits<float, TCalc>
{
float inner_product;
float sum_of_squares1;
float sum_of_squares2;
float sum1;
float sum2;
uint32_t counter;
//*********************************
/// Clear the correlation.
//*********************************
void clear()
{
inner_product = float(0);
sum_of_squares1 = float(0);
sum_of_squares2 = float(0);
sum1 = float(0);
sum2 = float(0);
counter = 0U;
}
typedef float calc_t;
};
//***************************************************************************
@ -102,25 +66,7 @@ namespace etl
template <typename TCalc>
struct correlation_traits<double, TCalc>
{
double inner_product;
double sum_of_squares1;
double sum_of_squares2;
double sum1;
double sum2;
uint32_t counter;
//*********************************
/// Clear the correlation.
//*********************************
void clear()
{
inner_product = double(0);
sum_of_squares1 = double(0);
sum_of_squares2 = double(0);
sum1 = double(0);
sum2 = double(0);
counter = 0U;
}
typedef double calc_t;
};
}
@ -145,17 +91,16 @@ namespace etl
static ETL_CONSTANT int Adjustment = (Correlation_Type == correlation_type::Population) ? 0 : 1;
typedef typename private_correlation::correlation_traits<TInput, TCalc>::calc_t calc_t;
public:
//*********************************
/// Constructor.
//*********************************
correlation()
: covariance_value(0.0)
, correlation_value(0.0)
, recalculate(true)
{
this->clear();
clear();
}
//*********************************
@ -163,11 +108,8 @@ namespace etl
//*********************************
template <typename TIterator>
correlation(TIterator first1, TIterator last1, TIterator first2)
: covariance_value(0.0)
, correlation_value(0.0)
, recalculate(true)
{
this->clear();
clear();
add(first1, last1, first2);
}
@ -252,6 +194,22 @@ namespace etl
return size_t(counter);
}
//*********************************
/// Clear the correlation.
//*********************************
void clear()
{
inner_product = calc_t(0);
sum_of_squares1 = calc_t(0);
sum_of_squares2 = calc_t(0);
sum1 = calc_t(0);
sum2 = calc_t(0);
counter = 0U;
covariance_value = 0.0;
correlation_value = 0.0;
recalculate = true;
}
private:
//*********************************
@ -300,9 +258,15 @@ namespace etl
}
}
double covariance_value;
double correlation_value;
bool recalculate;
calc_t inner_product;
calc_t sum_of_squares1;
calc_t sum_of_squares2;
calc_t sum1;
calc_t sum2;
uint32_t counter;
double covariance_value;
double correlation_value;
bool recalculate;
};
}

82
include/etl/covariance.h
View File

@ -48,21 +48,7 @@ namespace etl
template <typename TInput, typename TCalc>
struct covariance_traits
{
TCalc inner_product;
TCalc sum1;
TCalc sum2;
uint32_t counter;
//*********************************
/// Clear the covariance.
//*********************************
void clear()
{
inner_product = TCalc(0);
sum1 = TCalc(0);
sum2 = TCalc(0);
counter = 0U;
}
typedef TCalc calc_t;
};
//***************************************************************************
@ -71,21 +57,7 @@ namespace etl
template <typename TCalc>
struct covariance_traits<float, TCalc>
{
float inner_product;
float sum1;
float sum2;
uint32_t counter;
//*********************************
/// Clear the covariance.
//*********************************
void clear()
{
inner_product = float(0);
sum1 = float(0);
sum2 = float(0);
counter = 0U;
}
typedef float calc_t;
};
//***************************************************************************
@ -94,21 +66,7 @@ namespace etl
template <typename TCalc>
struct covariance_traits<double, TCalc>
{
double inner_product;
double sum1;
double sum2;
uint32_t counter;
//*********************************
/// Clear the covariance.
//*********************************
void clear()
{
inner_product = double(0);
sum1 = double(0);
sum2 = double(0);
counter = 0U;
}
typedef double calc_t;
};
}
@ -133,16 +91,16 @@ namespace etl
static ETL_CONSTANT int Adjustment = (Covariance_Type == covariance_type::Population) ? 0 : 1;
typedef typename private_covariance::covariance_traits<TInput, TCalc>::calc_t calc_t;
public:
//*********************************
/// Constructor.
//*********************************
covariance()
: covariance_value(0.0)
, recalculate(true)
{
this->clear();
clear();
}
//*********************************
@ -150,10 +108,8 @@ namespace etl
//*********************************
template <typename TIterator>
covariance(TIterator first1, TIterator last1, TIterator first2)
: covariance_value(0.0)
, recalculate(true)
{
this->clear();
clear();
add(first1, last1, first2);
}
@ -214,9 +170,6 @@ namespace etl
double n = double(counter);
double adjustment = 1.0 / (n * (n - Adjustment));
double mean1 = sum1 / n;
double mean2 = sum2 / n;
covariance_value = ((n * inner_product) - (sum1 * sum2)) * adjustment;
recalculate = false;
@ -242,10 +195,27 @@ namespace etl
return size_t(counter);
}
//*********************************
/// Clear the covariance.
//*********************************
void clear()
{
inner_product = calc_t(0);
sum1 = calc_t(0);
sum2 = calc_t(0);
counter = 0U;
covariance_value = 0.0;
recalculate = true;
}
private:
double covariance_value;
bool recalculate;
calc_t inner_product;
calc_t sum1;
calc_t sum2;
uint32_t counter;
double covariance_value;
bool recalculate;
};
}

65
include/etl/mean.h
View File

@ -48,17 +48,7 @@ namespace etl
template <typename TInput, typename TCalc>
struct mean_traits
{
TCalc sum;
uint32_t counter;
//*********************************
/// Clear the mean.
//*********************************
void clear()
{
sum = TCalc(0);
counter = 0U;
}
typedef TCalc calc_t;
};
//***************************************************************************
@ -67,17 +57,7 @@ namespace etl
template <typename TCalc>
struct mean_traits<float, TCalc>
{
float sum;
uint32_t counter;
//*********************************
/// Clear the mean.
//*********************************
void clear()
{
sum = float(0);
counter = 0U;
}
typedef float calc_t;
};
//***************************************************************************
@ -86,17 +66,7 @@ namespace etl
template <typename TCalc>
struct mean_traits<double, TCalc>
{
double sum;
uint32_t counter;
//*********************************
/// Clear the mean.
//*********************************
void clear()
{
sum = double(0);
counter = 0U;
}
typedef double calc_t;
};
}
@ -108,16 +78,18 @@ namespace etl
: public private_mean::mean_traits<TInput, TCalc>
, public etl::binary_function<TInput, TInput, void>
{
private:
typedef typename private_mean::mean_traits<TInput, TCalc>::calc_t calc_t;
public:
//*********************************
/// Constructor.
//*********************************
mean()
: mean_value(0.0)
, recalculate(true)
{
this->clear();
clear();
}
//*********************************
@ -125,10 +97,8 @@ namespace etl
//*********************************
template <typename TIterator>
mean(TIterator first, TIterator last)
: mean_value(0.0)
, recalculate(true)
{
this->clear();
clear();
add(first, last);
}
@ -210,10 +180,23 @@ namespace etl
return size_t(counter);
}
//*********************************
/// Clear the correlation.
//*********************************
void clear()
{
sum = calc_t(0);
counter = 0U;
mean_value = 0.0;
recalculate = true;
}
private:
double mean_value;
bool recalculate;
calc_t sum;
uint32_t counter;
double mean_value;
bool recalculate;
};
}

79
include/etl/rms.h
View File

@ -43,60 +43,30 @@ namespace etl
namespace private_rms
{
//***************************************************************************
/// Types for generic covariance.
/// Types for generic correlation.
//***************************************************************************
template <typename TInput, typename TCalc>
struct rms_traits
{
TCalc sum_of_squares;
uint32_t counter;
//*********************************
/// Clear the histogram.
//*********************************
void clear()
{
sum_of_squares = TCalc(0);
counter = 0U;
}
typedef TCalc calc_t;
};
//***************************************************************************
/// Types for float covariance.
/// Types for float correlation.
//***************************************************************************
template <typename TCalc>
struct rms_traits<float, TCalc>
{
float sum_of_squares;
uint32_t counter;
//*********************************
/// Clear the histogram.
//*********************************
void clear()
{
sum_of_squares = float(0);
counter = 0U;
}
typedef float calc_t;
};
//***************************************************************************
/// Types for double covariance.
/// Types for double correlation.
//***************************************************************************
template <typename TCalc>
struct rms_traits<double, TCalc>
{
double sum_of_squares;
uint32_t counter;
//*********************************
/// Clear the histogram.
//*********************************
void clear()
{
sum_of_squares = double(0);
counter = 0U;
}
typedef double calc_t;
};
}
@ -108,6 +78,10 @@ namespace etl
: public private_rms::rms_traits<TInput, TCalc>
, public etl::binary_function<TInput, TInput, void>
{
private:
typedef typename private_rms::rms_traits<TInput, TCalc>::calc_t calc_t;
public:
//*********************************
@ -116,7 +90,7 @@ namespace etl
rms()
: recalculate(true)
{
this->clear();
clear();
}
//*********************************
@ -126,7 +100,7 @@ namespace etl
rms(TIterator first, TIterator last)
: recalculate(true)
{
this->clear();
clear();
add(first, last);
}
@ -135,8 +109,8 @@ namespace etl
//*********************************
void add(TInput value)
{
this->sum_of_squares += TCalc(value * value);
++this->counter;
sum_of_squares += TCalc(value * value);
++counter;
recalculate = true;
}
@ -180,10 +154,10 @@ namespace etl
{
rms_value = 0.0;
if (this->counter != 0)
if (counter != 0)
{
double n = double(this->counter);
double mean_of_squares = this->sum_of_squares / n;
double n = double(counter);
double mean_of_squares = sum_of_squares / n;
if (mean_of_squares > 0)
{
@ -210,13 +184,26 @@ namespace etl
//*********************************
size_t count() const
{
return size_t(this->counter);
return size_t(counter);
}
//*********************************
/// Clear the histogram.
//*********************************
void clear()
{
sum_of_squares = calc_t(0);
counter = 0U;
rms_value = 0.0;
recalculate = true;
}
private:
double rms_value;
bool recalculate;
calc_t sum_of_squares;
uint32_t counter;
double rms_value;
bool recalculate;
};
}

98
include/etl/standard_deviation.h
View File

@ -43,66 +43,30 @@ namespace etl
namespace private_standard_deviation
{
//***************************************************************************
/// Types for generic covariance.
/// Types for generic standard_deviation.
//***************************************************************************
template <typename TInput, typename TCalc>
struct standard_deviation_traits
{
TCalc sum_of_squares;
TCalc sum;
uint32_t counter;
//*********************************
/// Clear the histogram.
//*********************************
void clear()
{
sum_of_squares = TCalc(0);
sum = TCalc(0);
counter = 0U;
}
typedef TCalc calc_t;
};
//***************************************************************************
/// Types for float covariance.
/// Types for float standard_deviation.
//***************************************************************************
template <typename TCalc>
struct standard_deviation_traits<float, TCalc>
{
float sum_of_squares;
float sum;
uint32_t counter;
//*********************************
/// Clear the histogram.
//*********************************
void clear()
{
sum_of_squares = float(0);
sum = float(0);
counter = 0U;
}
typedef float calc_t;
};
//***************************************************************************
/// Types for double covariance.
/// Types for double standard_deviation.
//***************************************************************************
template <typename TCalc>
struct standard_deviation_traits<double, TCalc>
{
double sum_of_squares;
double sum;
uint32_t counter;
//*********************************
/// Clear the histogram.
//*********************************
void clear()
{
sum_of_squares = double(0);
sum = double(0);
counter = 0U;
}
typedef double calc_t;
};
}
@ -127,17 +91,16 @@ namespace etl
static ETL_CONSTANT int Adjustment = (Standard_Deviation_Type == standard_deviation_type::Population) ? 0 : 1;
typedef typename private_standard_deviation::standard_deviation_traits<TInput, TCalc>::calc_t calc_t;
public:
//*********************************
/// Constructor.
//*********************************
standard_deviation()
: variance_value(0.0)
, standard_deviation_value(0.0)
, recalculate(true)
{
this->clear();
clear();
}
//*********************************
@ -145,11 +108,8 @@ namespace etl
//*********************************
template <typename TIterator>
standard_deviation(TIterator first, TIterator last)
: variance_value(0.0)
, standard_deviation_value(0.0)
, recalculate(true)
{
this->clear();
clear();
add(first, last);
}
@ -158,9 +118,9 @@ namespace etl
//*********************************
void add(TInput value)
{
this->sum_of_squares += TCalc(value * value);
this->sum += TCalc(value);
++this->counter;
sum_of_squares += TCalc(value * value);
sum += TCalc(value);
++counter;
recalculate = true;
}
@ -228,7 +188,20 @@ namespace etl
//*********************************
size_t count() const
{
return size_t(this->counter);
return size_t(counter);
}
//*********************************
/// Clear the histogram.
//*********************************
void clear()
{
sum_of_squares = calc_t(0);
sum = calc_t(0);
counter = 0U;
variance_value = 0.0;
standard_deviation_value = 0.0;
recalculate = true;
}
private:
@ -243,14 +216,14 @@ namespace etl
standard_deviation_value = 0.0;
variance_value = 0.0;
if (this->counter != 0)
if (counter != 0)
{
double n = double(this->counter);
double n = double(counter);
double adjustment = 1.0 / (n * (n - Adjustment));
double square_of_sum = (this->sum * this->sum);
double square_of_sum = (sum * sum);
variance_value = ((n * this->sum_of_squares) - square_of_sum) * adjustment;
variance_value = ((n * sum_of_squares) - square_of_sum) * adjustment;
if (variance_value > 0)
{
@ -262,9 +235,12 @@ namespace etl
}
}
double variance_value;
double standard_deviation_value;
bool recalculate;
calc_t sum_of_squares;
calc_t sum;
uint32_t counter;
double variance_value;
double standard_deviation_value;
bool recalculate;
};
}

93
include/etl/variance.h
View File

@ -43,66 +43,30 @@ namespace etl
namespace private_variance
{
//***************************************************************************
/// Types for generic variance.
/// Types for generic correlation.
//***************************************************************************
template <typename TInput, typename TCalc>
struct variance_traits
{
TCalc sum_of_squares;
TCalc sum;
uint32_t counter;
//*********************************
/// Clear the variance.
//*********************************
void clear()
{
sum_of_squares = TCalc(0);
sum = TCalc(0);
counter = 0U;
}
typedef TCalc calc_t;
};
//***************************************************************************
/// Types for float variance.
/// Types for float correlation.
//***************************************************************************
template <typename TCalc>
struct variance_traits<float, TCalc>
{
float sum_of_squares;
float sum;
uint32_t counter;
//*********************************
/// Clear the variance.
//*********************************
void clear()
{
sum_of_squares = float(0);
sum = float(0);
counter = 0U;
}
typedef float calc_t;
};
//***************************************************************************
/// Types for double variance.
/// Types for double correlation.
//***************************************************************************
template <typename TCalc>
struct variance_traits<double, TCalc>
{
double sum_of_squares;
double sum;
uint32_t counter;
//*********************************
/// Clear the variance.
//*********************************
void clear()
{
sum_of_squares = double(0);
sum = double(0);
counter = 0U;
}
typedef double calc_t;
};
}
@ -127,16 +91,16 @@ namespace etl
static ETL_CONSTANT int Adjustment = (Variance_Type == variance_type::Population) ? 0 : 1;
typedef typename private_variance::variance_traits<TInput, TCalc>::calc_t calc_t;
public:
//*********************************
/// Constructor.
//*********************************
variance()
: variance_value(0.0)
, recalculate(true)
{
this->clear();
clear();
}
//*********************************
@ -144,10 +108,8 @@ namespace etl
//*********************************
template <typename TIterator>
variance(TIterator first, TIterator last)
: variance_value(0.0)
, recalculate(true)
{
this->clear();
clear();
add(first, last);
}
@ -156,9 +118,9 @@ namespace etl
//*********************************
void add(TInput value)
{
this->sum_of_squares += TCalc(value * value);
this->sum += TCalc(value);
++this->counter;
sum_of_squares += TCalc(value * value);
sum += TCalc(value);
++counter;
recalculate = true;
}
@ -202,14 +164,14 @@ namespace etl
{
variance_value = 0.0;
if (this->counter != 0)
if (counter != 0)
{
double n = double(this->counter);
double n = double(counter);
double adjustment = 1.0 / (n * (n - Adjustment)) ;
double square_of_sum = this->sum * this->sum;
double square_of_sum = sum * sum;
variance_value = (n * this->sum_of_squares - square_of_sum) * adjustment;
variance_value = (n * sum_of_squares - square_of_sum) * adjustment;
}
recalculate = false;
@ -231,13 +193,28 @@ namespace etl
//*********************************
size_t count() const
{
return size_t(this->counter);
return size_t(counter);
}
//*********************************
/// Clear the variance.
//*********************************
void clear()
{
sum_of_squares = calc_t(0);
sum = calc_t(0);
counter = 0U;
variance_value = 0.0;
recalculate = true;
}
private:
double variance_value;
bool recalculate;
calc_t sum_of_squares;
calc_t sum;
uint32_t counter;
double variance_value;
bool recalculate;
};
}