Mathematics, Digital Signal Processing, and Optimization (namespace Math)


Assessment: It dinamically computes: the minimum, the maximum, the mean and the variance
Assessment()
double getMaximum()
double getMean()
double getMinimum()
double getVariance()
void add(double value)
void reset()
~ Assessment()

AutomaticGainControl: It implements an Automatic Gain Control
AutomaticGainControl& operator =(const AutomaticGainControl& init)
AutomaticGainControl()
AutomaticGainControl(const AutomaticGainControl& init)
double GetAttackSpeed()
Low compression: 5 db/sec, Medium compression: 10 db/sec, High compression: 20 db/sec
double GetBackwardGainSpeed()
double GetForwardGainSpeed()
double GetMaxGaindB()
double GetReleaseSpeed()
Low compression: 2 db/sec, Medium compression: 10 db/sec, High compression: 20 db/sec
int ComputeOutput(int input)
int GetBitsResolution()
8, 16, 24
int GetBufferLen()
int GetSamplesPerSec()
22050, 44100, 48000, 96000, ...
void Delete()
It releases buffer memory
void Reset()
void SetAttackSpeed(double db_per_second)
Low compression: 5 db/sec, Medium compression: 10 db/sec, High compression: 20 db/sec
void SetBackwardGainSpeed(double db_per_second)
void SetBitsResolution(int bitsResolution)
8, 16, 24
void SetForwardGainSpeed(double db_per_second)
void SetMaxGaindB(double gain_dB)
void SetReleaseSpeed(double db_per_second)
Low compression: 2 db/sec, Medium compression: 10 db/sec, High compression: 20 db/sec
void SetSamplesPerSec(int samplesPerSec)
22050, 44100, 48000, 96000, ...
~ AutomaticGainControl()
double ForwardGainSpeed
double BackwardGainSpeed
double MaxGaindB
double ReleaseSpeed
double AttackSpeed
int BitsResolution
int SamplesPerSec

Bessel
static double I0(double x)
The first kind modified Bessel function of integer order 0, for any real x
static double I1(double x)
The first kind modified Bessel function of integer order 1, for any real x
static double In(int n, double x)
The first kind modified Bessel function of integer order n, for any real x
static double J0(double x)
The first kind Bessel function of integer order 0, for any real x
static double J1(double x)
The first kind Bessel function of integer order 1, for any real x
static double Jn(int n, double x)
The first kind Bessel function of integer order n, for any real x
~ Bessel(void)

BinaryConverter: It provides support to handle binary data
BinaryConverter(void)
bool GetBit(int bitIndex)
int Convert(int value)
static int Convert(const int value, const int bitCount, valarray<double >& output)
static int Convert(const int value, const int bitCount, valarray<int >& output)
~ BinaryConverter(void)

Chebyshev
static bool ComputeCoefficients_FirstKind(Math::IFunction& function, double a, double b, int N, valarray<double >& out_c)
Chebyshev Approximation coefficients in the interval [a b] A method for numerical integration on an automatic computer. C.W. Clenshaw and A. R. Curtis, Numerische Mathematik 1960
static bool ComputeCoefficients_SecondKind(Math::IFunction& function, double a, double b, int N, valarray<double >& out_c)
Chebyshev Approximation coefficients in the interval [a b] A method for numerical integration on an automatic computer. C.W. Clenshaw and A. R. Curtis, Numerische Mathematik 1960
static double ComputeApproximation_FirstKind(double a, double b, const double* in_c, const int size_of_c, double x)
a < x < b; f(x) = c_0/2 + SUM[c_n Tn(t)]; t = (2x - b - a)/(b - a); n goes from 1 to size_of_c-1
static double ComputeApproximation_FirstKind(double a, double b, const valarray<double >& in_c, int m, double x)
The only difference between ComputeApproximation_FirstKind and ComputeApproximation_SecondKind is that ComputeApproximation_SecondKind adds half of the last term in the approximation a < x < b; m is the degree of the approximation f(x) = c_0/2 + SUM[c_n Tn(t)]; t = (2x - b - a)/(b - a); n goes from 1 to m-1
static double ComputeApproximation_SecondKind(double a, double b, const valarray<double >& in_c, int m, double x)
The only difference between ComputeApproximation_FirstKindand ComputeApproximation_SecondKind is that ComputeApproximation_SecondKind adds half of the last term in the approximation a < x < b and m is the degree of the approximation
static double Tn(const unsigned int n, double x)
Polynomial of the first kind of integer order n
static double Un(const unsigned int n, double x)
Polynomial of the second kind of integer order n
~ Chebyshev(void)

Delay: It implements a signal delay
Delay(void)
bool SetDelay(int delay)
int ComputeOutput(int input)
void Reset()
~ Delay(void)

Dsp: It provides a set of functions for Digital Signal Processing
static bool Convolution(const valarray<complex<double>>& input_x, const valarray<complex<double>>& input_y, valarray<complex<double>>& result)
static bool Convolution(const valarray<double >& input_x, const valarray<double >& input_y, valarray<double >& result)
static bool DiscreteCosineTransform(const valarray<double >& input, valarray<double >& output)
It returns false, if not enough memory
static bool DiscreteCosineTransform_II(const valarray<double >& input, valarray<double >& output)
static bool FourierTransform(const MATRIXC& input, MATRIXC& output, bool inverse)
static bool FourierTransform(const valarray<complex<double>>& input, valarray<complex<double>>& output, bool inverse)
static bool FourierTransformRe(const MATRIX& input, MATRIXC& output)
static bool FourierTransformRe(const valarray<double >& input, valarray<complex<double>>& output)
static bool HighPass(const valarray<double >& input, valarray<double >& output, double cutFreqRad)
static bool InvDiscreteCosineTransform(const valarray<double >& input, valarray<double >& output)
static bool InvDiscreteCosineTransform_II(const valarray<double >& input, valarray<double >& output)
static bool InverseFourierTransformRe(const MATRIXC& input, MATRIX& output)
static bool InverseFourierTransformRe(const valarray<complex<double>>& input, valarray<double >& output)
static bool IsPowerOfTwo(int input)
static bool LowPass(const valarray<double >& input, valarray<double >& output, double cutFreqRad)
static bool ShortConvolution(const valarray<complex<double>>& input_x, const valarray<complex<double>>& input_y, valarray<complex<double>>& result)
static bool ShortConvolution(const valarray<double >& input_x, const valarray<double >& input_y, valarray<double >& result)
static bool SpectrumFold(const valarray<complex<double>>& input, valarray<complex<double>>& output)
input: x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7] output: x[4], x[5], x[6], x[7], x[0], x[1], x[2], x[3]
static bool SpectrumFold(const valarray<double >& input, valarray<double >& output)
input: x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7] output: x[4], x[5], x[6], x[7], x[0], x[1], x[2], x[3]
static bool SpectrumUnfold(const valarray<complex<double>>& input, valarray<complex<double>>& output)
static bool SpectrumUnfold(const valarray<double >& input, valarray<double >& output)
static bool SymmetricConvolution(const valarray<complex<double>>& symmetricInput, const valarray<complex<double>>& input_y, valarray<complex<double>>& result)
static bool SymmetricConvolution(const valarray<complex<double>>& symmetricInput, const valarray<double >& input_y, valarray<complex<double>>& result)
static bool SymmetricConvolution(const valarray<double >& symmetricInput, const valarray<double >& input_y, valarray<double >& result)
static const wchar_t* Fft(MATRIXC& in_out, bool inverse)
static const wchar_t* Fft(const MATRIX& input, MATRIXC& output, bool inverse)
static const wchar_t* Fft(const MATRIXC& input, MATRIXC& output, bool inverse)
static const wchar_t* Fft(const valarray<complex<double>>& input, valarray<complex<double>>& output, bool inverse)
static const wchar_t* Fft(const valarray<double >& input, valarray<complex<double>>& output, bool inverse)
static const wchar_t* Fft(valarray<complex<double>>& in_out, bool inverse)
output[0] is the lowest frequency (offset) pi/m, 2pi/m, 3pi/m, ...pi,.....,2pi-3pi/m, 2pi-2pi/m, 2pi-pi/m Let m = input.size() Then output[m/2] is output[PI] And output[m-1] is output[2PI - PI/m] For real domain series output is conjugate symmetric, i.e., 10, 8+3j, 2+4j, 5-6j, 0, 5+6j, 2-4j, 8-3j
static const wchar_t* Fft2D(const MATRIX& input, MATRIXC& output)
static const wchar_t* Fft2D(const MATRIXC& input, MATRIXC& output)
static const wchar_t* IFft2D(bool isInputSymmetric, const MATRIXC& input, MATRIXC& output)
static const wchar_t* Periodogram(const valarray<complex<double>>& input, valarray<double >& output)
static const wchar_t* RealFft(MATRIX& in_out, bool inverse)
Real and Imaginary parts are stored sequencially
static const wchar_t* RealFft(const MATRIX& input, MATRIX& output, bool inverse)
Real and Imaginary parts are stored sequencially
static const wchar_t* RealFft(const valarray<double >& input, valarray<complex<double>>& output)
FFT optimized for real domain series, output is conjugate symmetric, i.e., 10, 8+3j, 2+4j, 5-6j, 0, 5+6j, 2-4j, 8-3j
static const wchar_t* RealFft(const valarray<double >& input, valarray<double >& output, bool inverse)
Real and Imaginary parts are stored sequencially
static const wchar_t* RealFft(valarray<double >& in_out, bool inverse)
Real and Imaginary parts are stored sequencially
static const wchar_t* Spectrum(const MATRIX& input, MATRIX& output)
static const wchar_t* Spectrum(const MATRIXC& input, MATRIX& output)
static const wchar_t* Spectrum(const valarray<complex<double>>& input, valarray<double >& output)
static const wchar_t* Spectrum(const valarray<double >& input, valarray<double >& output)
static const wchar_t* TwoFft(const valarray<double >& input1, const valarray<double >& input2, valarray<complex<double>>& out_fft1, valarray<complex<double>>& out_fft2)
static const wchar_t* TwoIfft(const valarray<complex<double>>& input_fft1, const valarray<complex<double>>& input_fft2, valarray<double >& output1, valarray<double >& output2)
static double AngleRotate(double x)
static double AngleRotate2(double x)
static double Circ(double x)
static double ComputeBeta(double stopBandGaindB)
static double Delta(double x)
static double Impulse(int n, int delay)
n is the discrete time d[n-delay]
static double Kaiser(double beta, double x)
static double Pi(int n, int delay, int duration)
static double Rect(double x)
static double Rectangular(double x, double period)
static double Sawtooth(double x, double period)
static double Sgn(double x)
static double Sin(int n, double k, int delay)
n is the discrete time Sin(kn-delay)
static double Sinc(double x)
static double Sinc(int n, double k, int delay)
n is the discrete time Sin(kn-delay)
static double Step(double x)
static double Step(int n, int delay)
n is the discrete time u[n-delay]
static double Triangular(double x, double period)
static int ComputeM(double stopBandGaindB, double transitionWidthRad)
static int FindNextPowerOfTwo(int input)
static int FindPreviousPowerOfTwo(int input)
static void Autocorrelation(const valarray<complex<double>>& input, valarray<complex<double>>& output)
static void Autocorrelation(const valarray<double >& input, valarray<double >& output)
static void Autocorrelation2(const valarray<complex<double>>& input, valarray<complex<double>>& output)
static void Autocorrelation2(const valarray<double >& input, valarray<double >& output)
static void FreqRespHighPass(double beta, int length, double cutFreqRad, valarray<double >& out_H)
static void FreqRespHilbertTransform(double beta, int length, valarray<double >& out_H)
static void FreqRespHilbertTransform(double sampFreqHz, double rippleErrordB, double transitionWidthHz, valarray<double >& out_H)
static void FreqRespLowPass(double beta, int length, double cutFreqRad, valarray<double >& out_H)
static void GetModulus(const valarray<complex<double>>& input, valarray<double >& output)
static void ImpulRespHighPass(double beta, int length, double cutFreqRad, valarray<double >& out_h)
static void ImpulRespHighPass(double sampFreqHz, double cutFreqHz, double stopBandGaindB, double transitionWidthHz, valarray<double >& out_h)
static void ImpulRespHilbertTransform(double beta, int length, valarray<double >& out_h)
static void ImpulRespHilbertTransform(double sampFreqHz, double rippleErrordB, double transitionWidthHz, valarray<double >& out_h)
static void ImpulRespLowPass(double beta, int length, double cutFreqRad, valarray<double >& out_h)
cutFreqRad is in radians cutFreqRad = 2 * pi * fc / fs;
static void ImpulRespLowPass(double sampFreqHz, double cutFreqHz, double stopBandGaindB, double transitionWidthHz, valarray<double >& out_h)
static void KaiserWindow(double beta, int length, valarray<double >& out_window)
static void PhaseNormalization(MATRIX& in_out)
static void PhaseNormalization(MATRIXC& in_out)
static void PhaseNormalization(valarray<complex<double>>& in_out)
static void PhaseNormalization(valarray<double >& in_out)
static void SpectrumFold(valarray<complex<double>>& in_out)
input: x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7] output: x[4], x[5], x[6], x[7], x[0], x[1], x[2], x[3]
static void SpectrumFold(valarray<double >& in_out)
input: x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7] output: x[4], x[5], x[6], x[7], x[0], x[1], x[2], x[3]
static void SpectrumUnfold(valarray<complex<double>>& in_out)
static void SpectrumUnfold(valarray<double >& in_out)
static void WelchWindow(int length, valarray<double >& out_window)
~ Dsp()

EigenSystem: It provides a set of functions to find the eigen-values and eigen-vectors
static const wchar_t* Jacobi(MATRIX& input, valarray<double >& eigen_value, MATRIX& eigen_vector)

FIRFilter: An finite impulse response filter
FIRFilter(void)
bool Create(valarray<double >& impulseResponse)
double GenerateOutput(double input)
virtual ~ FIRFilter(void)
void ClearTaps()

FIRFilter16: An finite impulse response filter of 16 bits
FIRFilter16(void)
__int16 GenerateOutput(__int16 input)
__int16 GenerateOutputAntisymmetric(__int16 input)
__int16 GenerateOutputSymmetric(__int16 input)
bool Create(valarray<double >& impulseResponse)
virtual ~ FIRFilter16(void)
void ClearTaps()

FindMinimum: It finds the minimum of a function of one variable, i.e. y = f(x)
FindMinimum(void)
static double BrentWithDerivative(Math::IFunctionD& func, const double a, const double b, const double c, const double tol, double& out_minX)
It computes the value of x that minimizes y = f(x) given the values of a, b and c returned by the funcion Bracketing() The function returns the y = f(x) and min_out_x where min_out_x is value of x that produces the minimum value of y
static double FindMinimum::Brent(Math::IFunction& func, const double a, const double b, const double c, const double tol, double& out_minX)
It computes the value of x that minimizes y = f(x) given the values of a, b and c returned by the funcion Bracketing() The function returns the y = f(x) and out_minX where out_minX is value of x that produces the minimum value of y
static void Bracketing(Math::IFunction& func, Math::Point& a, Math::Point& b, Math::Point& c)
Given a function y = f(x), and two distinct initial values of x: a and b Bracketing searches the downhill direction to return: - three values of x: a, b, c that bracket a minimum of the function - three values of y: ya = f(a), yb = f(b), and yc = f(c).

FindMinimumMV: It finds the minimum of a multivariable function, i.e. y = f(x0, x2, ..., xn) It requires the computation of: f(x0, x2, ..., xn) and its derivative
DWORD ThreadFunc(Mt::BoolTs& cancel, Mt::DecimalTs& progress, Mt::BoolTs& resetTime)
FindMinimumMV()
bool Setup(Mt::DoubleTs& error, Math::IMultiVarFuncD& ifunc, const valarray<double >& startingPoint, int numIterations, double goal, int method)
method: WT_MATH_CONJGRAD, WT_MATH_VARMETRIC
double EvaluateFunc(const double x)
virtual ~ FindMinimumMV()
void EvaluateFuncAndDeriv(const double x, double& Fx, double& dFx)
void SetPostMessage(HWND hWnd, UINT wm_message, WPARAM wParam, LPARAM lParam)
It sets the information to call ::PostMessage when the ThreadFunc completes If hWnd is set to NULL, ::PostMessage will not be called wm_message can be: WM_APP+1, WM_APP+2, WM_APP+3, ...

GaborTransform
GaborTransform()
bool Create(int delta_n, int numFreq)
bool Create(int numFreq)
bool Transform(const valarray<double >& input, MATRIXC& output)
double GetDeltaF()
double GetDeltaT()
double GetSigma()
~ GaborTransform()

GeneticAlgorithm: It provides support to perform Genetic Algorithm Optimization
DWORD ThreadFunc(Mt::BoolTs& cancel, Mt::DecimalTs& progress, Mt::BoolTs& resetTime)
GeneticAlgorithm()
bool Setup(Mt::DoubleTs& error, int bitsPerIndividual, Math::IGenetic& igenetic)
void Delete()
void ListIndividuals(HWND hWnd)
void SetPostMessage(HWND hWnd, UINT wm_message, WPARAM wParam, LPARAM lParam)
It sets the information to call ::PostMessage when the ThreadFunc completes If hWnd is set to NULL, ::PostMessage will not be called wm_message can be: WM_APP+1, WM_APP+2, WM_APP+3, ...
~ GeneticAlgorithm()

GeneticIndividual: It represents one individual in a Genetic Algorithm Optimization
GeneticIndividual& operator =(const GeneticIndividual& init)
GeneticIndividual()
GeneticIndividual(const GeneticIndividual& init)
bool operator <(const GeneticIndividual& input)const
void Copy(const GeneticIndividual& init)
~ GeneticIndividual()

GeneticParam
GeneticParam()
~ GeneticParam()

IFunction: A function of one variable double EvaluateFunc(const double x)
virtual double EvaluateFunc(const double x)= 0

IFunctionC: A function of one complex variable complex EvaluateFunc(const double x)
virtual complex<double>EvaluateFunc(const double x)= 0

IFunctionD: A function of one variable and its derivative double EvaluateFunc(const double x) void EvaluateFuncAndDeriv(const double x, double& Fx, double& dFx)
virtual void EvaluateFuncAndDeriv(const double x, double& Fx, double& dFx)= 0
The function must compute F(x) and dFx/dx

IGenetic: The general interface to use Genetic Algorithm Optimization
virtual double GeneticGetError() = 0
It returns the individual error in the range from 0 to 1
virtual void GeneticInitialize(Sys::BoolArray& bits)= 0
Initialize one individual
virtual void GeneticSetFromBits(const Sys::BoolArray& bits)= 0
It converts the input bits to the specific variables of the problem

IMultiVarFunc: A function of several variables double EvaluateFunc(const valarray& x);
virtual double EvaluateFunc(const valarray<double >& x)= 0

IMultiVarFuncD: A function of several variables and its gradient double EvaluateFunc(const valarray& x); void EvaluateFuncAndGrad(const valarray& x, double& Fx, valarray& gradient);
virtual void EvaluateFuncAndGrad(const valarray<double >& x, double& Fx, valarray<double >& gradient)= 0
The function must compute F(x) and its gradient

ISimAnneal: The general interface to use Simulated Annealing Optimization
virtual double SimAnnealGetError() = 0
virtual void SimAnnealCopy(const Math::ISimAnneal& source)= 0
virtual void SimAnnealInitialize() = 0
virtual void SimAnnealPerturb(Math::ISimAnneal& original, double temperature, double initialTemperature)= 0

Interpolation: It provides a set of functions to interpolate a function of: one variable f(x) or two variables f(x, y)
static double Bilinear(const valarray<double >& vx, const valarray<double >& vy, const MATRIX& fxy, const double x, const double y)
The size of x must be equal to the number of rows of fxy The size of y must be equal to the number of columns of fxy x must contain a set of values for x. i.e., {0, 0.11, 0.2, 0.3, 0.4, 0.6} y must contain a set of values for y. i.e., {1, 2, 3, 4, 5} fxy must contain a set of values for f(x, y) The function returns the interpolation of f(x, y)
static double Lagrange(const MATRIX& x_fx, const double x)
The input matrix x_fx must have two columns: x and f(x) It returns the value of f(x) for the given value of x
static double Lagrange2D(const valarray<double >& vx, const valarray<double >& vy, const MATRIX& fxy, const double x, const double y)
The size of x must be equal to the number of rows of fxy The size of y must be equal to the number of columns of fxy x must contain a set of values for x. i.e., {0, 0.11, 0.2, 0.3, 0.4, 0.6} y must contain a set of values for y. i.e., {1, 2, 3, 4, 5} fxy must contain a set of values for f(x, y) The function returns the interpolation of f(x, y)
static double Linear(const MATRIX& x_fx, double& out_m, double& out_b)
It fits y = mx + b to the data given by the matrix x_fx, The x_fx matrix must have two columns: x and f(x) The function returns the value of chi-square to measure how well the line fits the data
static double Neville(const MATRIX& x_fx, const double x)
The input matrix x_fx must have two columns: x and f(x) It returns the value of f(x) for the given value of x
static double Neville(const MATRIX& x_fx, const double x, double& out_error)
The input matrix x_fx must have two columns: x and f(x) It returns the value of f(x) for the given value of x It also returns the error
static double Neville2D(const valarray<double >& vx, const valarray<double >& vy, const MATRIX& fxy, const double x, const double y)
The size of x must be equal to the number of rows of fxy The size of y must be equal to the number of columns of fxy x must contain a set of values for x. i.e., {0, 0.11, 0.2, 0.3, 0.4, 0.6} y must contain a set of values for y. i.e., {1, 2, 3, 4, 5} fxy must contain a set of values for f(x, y) The function returns the interpolation of f(x, y)
~ Interpolation()

KMeans: It implements the clustering algorithm K-means
KMeans()
void CreateClusters(size_t iterationCount, const MATRIX& input, size_t K, MATRIX& out_centroid, vector<int >& out_cluster)
The function groups the rows in 'input' to create K clusters. The resulting centroid of the K clusters are returned in out_centroid The resulting cluster index for each input (0, 1, 2, ..., K-1) is returned in out_cluster
~ KMeans()

Normalization: It normalizes a vector so that the mean is zero and the standard deviation is one
Normalization()
void poststd(valarray<double >& values)
void prestd(valarray<double >& values)
~ Normalization()

NumericDerivative: It provides a set of functions to compute the derivative of a function
static void FirstDerivative(double deltaX, const valarray<double >& in_y, valarray<double >& out_dy)
static void SecondDerivative(double deltaX, const valarray<double >& in_y, valarray<double >& out_dy)
static void ThirdDerivative(double deltaX, const valarray<double >& in_y, valarray<double >& out_dy)
virtual ~ NumericDerivative(void)

NumericIntegration: It provides a set of functions to perform numeric integration
static complex<double>Simpson(Math::IFunctionC& function, double a, double b, double& resultingError)
static complex<double>Simpson(Math::IFunctionC& function, double a, double b, int steps, double& resultingError)
static double AdaptiveSimpson(Math::IFunction& function, double a, double b, double errorTolerance, int maxRecursionDepth)
maxRecursionDepth = 100; errorTolerance = 1.0e-7
static double ClenshawCurtis(Math::IFunction& function, double a, double b)
static double ClenshawCurtis(Math::IFunction& function, double a, double b, int N)
static double Simpson(Math::IFunction& function, double a, double b, double& resultingError)
static double Simpson(Math::IFunction& function, double a, double b, int steps, double& resultingError)
steps will be approximated to next multiple of 4
static double Simpson3_8(Math::IFunction& function, double a, double b, int steps)
steps will be approximated to next multiple of 3
virtual ~ NumericIntegration(void)

Oper: A set of functions to perform Math, Vector and Matrix operations
Oper()
static bool AppendDown(MATRIX& in_out, const MATRIX& in_B)
static bool AppendDown(MATRIXC& in_out, const MATRIXC& in_B)
static bool AppendRight(MATRIX& in_out, const MATRIX& in_B)
static bool AppendRight(MATRIXC& in_out, const MATRIXC& in_B)
static bool AreTheyEqual(const MATRIX& a, const MATRIX& b)
static bool AreTheyEqual(const MATRIXC& a, const MATRIXC& b)
static bool ComputeRelativeError(const MATRIX& actualOutput, const MATRIX& target, valarray<double >& out_relError)
Returns a vector with the relative error values for each case (rows)
static bool CopyColToClipboard(HWND hWnd, const MATRIX& input, int col_index)
static bool CopyRowToClipboard(HWND hWnd, const MATRIX& input, int row_index)
static bool CopyToClipboard(HWND hWnd, const MATRIX& input)
static bool CreateMatrix(MATRIX& in_out, int rowCount, int colCount)
static bool CreateMatrix(MATRIXC& in_out, int rowCount, int colCount)
static bool CreateRandom(MATRIX& in_out, int rowCount, int colCount, double minValue, double maxValue)
static bool CreateRandom(valarray<double >& in_out, int length, double minValue, double maxValue)
static bool CreateRandomSet(valarray<double >& in_out, int length, int maxValue)
static bool DeleteCell(valarray<complex<double>>& in_out, int index)
static bool DeleteCell(valarray<double >& in_out, int index)
static bool DeleteCol(MATRIX& in_out, int colIndex)
static bool DeleteCol(MATRIXC& in_out, int colIndex)
static bool DeleteCols(MATRIX& input, const valarray<int>indexes)
static bool DeleteCols(MATRIXC& input, const valarray<int>indexes)
static bool DeleteCols(const MATRIX& input, MATRIX& output, const valarray<int>indexes)
static bool DeleteCols(const MATRIXC& input, MATRIXC& output, const valarray<int>indexes)
static bool DeleteRow(MATRIX& in_out, int rowIndex)
static bool DeleteRow(MATRIXC& in_out, int rowIndex)
static bool DeleteRows(MATRIX& input, const valarray<int>indexes)
static bool DeleteRows(MATRIXC& input, const valarray<int>indexes)
static bool DeleteRows(const MATRIX& input, MATRIX& output, const valarray<int>indexes)
static bool DeleteRows(const MATRIXC& input, MATRIXC& output, const valarray<int>indexes)
static bool GetCol(const MATRIX& input, MATRIX& output, int index)
static bool GetCol(const MATRIX& input, valarray<double >& output, int index)
static bool GetCol(const MATRIXC& input, MATRIXC& output, int index)
static bool GetCol(const MATRIXC& input, valarray<complex<double>>& output, int index)
static bool GetCols(const MATRIX& input, MATRIX& output, const valarray<int>indexes)
static bool GetCols(const MATRIXC& input, MATRIXC& output, const valarray<int>indexes)
static bool GetMinMax(const MATRIX& input, double& out_min, double& out_max)
static bool GetMinMax(const MATRIXC& input, double& out_min, double& out_max)
static bool GetRow(const MATRIX& input, MATRIX& output, int index)
static bool GetRow(const MATRIX& input, valarray<double >& output, int index)
static bool GetRow(const MATRIXC& input, MATRIXC& output, int index)
static bool GetRow(const MATRIXC& input, valarray<complex<double>>& output, int index)
static bool GetRows(const MATRIX& input, MATRIX& output, const valarray<int>indexes)
static bool GetRows(const MATRIXC& input, MATRIXC& output, const valarray<int>indexes)
static bool InsertCell(valarray<complex<double>>& in_out, int index)
static bool InsertCell(valarray<double >& in_out, int index)
static bool InsertCol(MATRIX& in_out, int colIndex)
static bool InsertCol(MATRIXC& in_out, int colIndex)
static bool InsertRow(MATRIX& in_out, int rowIndex)
static bool InsertRow(MATRIXC& in_out, int rowIndex)
static bool IsPrime(int x)
static bool Transpose(const MATRIX& input, MATRIX& output)
static bool Transpose(const MATRIXC& input, MATRIXC& output)
static bool WrapVector(const valarray<complex<double>>& input, int colCount, MATRIXC& output)
static bool WrapVector(const valarray<double >& input, int colCount, MATRIX& output)
static double ArcTangent(double y, double x)
It returns an angle from 0 to 2pi ArcTangent(1, 1) = 0.785398 radians (45 degrees) ArcTangent(1, -1) = 2.35619 radians (135 degrees) ArcTangent(-1, -1) = 3.9270 radians (225 degrees) ArcTangent(-1, 1) = 5.4978 radians (315 degrees)
static double ComputeDistance(const valarray<double >& x, const valarray<double >& y)
static double ComputeMse(const MATRIX& input_a, const MATRIX& input_b)
returns a negative value if error
static double DotProduct(const size_t len, const valarray<double >& a, const valarray<double >& b)
static double DotProduct(const valarray<double >& a, const valarray<double >& b)
static double Factorial(unsigned int x)
static double GetMaximum(const MATRIX& input)
static double GetMinimum(const MATRIX& input)
static double LineFitting(const valarray<double >& in_x, const valarray<double >& in_y, double& out_m, double& out_b)
Given a set of points (x, y) it returns the value of m and b so that y = mx+b The function returns the mean squared error
static double Round(double value, int decimalCount)
static double Round05(double value)
Round05(9.2) returns 9.0 Round05(9.45) return 9.5 Round05(9.62) returns 9.5 Round05(9.78) return 10.0
static double Sign(const double& a, const double& b)
static int GetClass(const valarray<complex<double>>& inputRow, double threshold)
static int GetClass(const valarray<double >& inputRow, double threshold)
static void AddValue(MATRIX& in_out, double value)
static void Denavit(double theta, double d, double a, double alfa, MATRIX& output)
cos(teta) -cos(alfa)*sin(teta) sin(alfa)*sin(teta) a*cos(teta) sin(teta) cos(alfa)*cos(teta) -sin(alfa)*cos(teta) a*sin(teta) 0 sin(alfa) cos(alfa) d 0 0 0 1
static void DivideBy(MATRIX& in_out, double value)
static void MultiplyBy(MATRIX& in_out, double value)
static void Normalize(valarray<double >& in_out)
It rescales the data to zero mean and unit variance
static void Normalize(valarray<double >& in_out, double minimum, double maximum)
It rescales the data to the range [0 1]
static void NormalizeCols(MATRIX& in_out)
It rescales the data to zero mean and unit variance
static void NormalizeCols(MATRIX& in_out, double minimum, double maximum)
It rescales the data to the range [0 1]
static void NormalizeRows(MATRIX& in_out)
It rescales the data to zero mean and unit variance
static void NormalizeRows(MATRIX& in_out, double minimum, double maximum)
It rescales the data to the range [0 1]
static void SetMatrix(MATRIX& in_out, double value)
static void SetTo(valarray<double >& in_out, double value)
static wchar_t* ConfusionMatrix(const MATRIX& output, const MATRIX& target, double threshold, MATRIX& out_confusionMatrix)
static wchar_t* ConfusionMatrix(const MATRIXC& output, const MATRIXC& target, double threshold, MATRIX& out_confusionMatrix)
static wchar_t* GetClass(const MATRIX input, valarray<double >& classes, double threshold)
static wchar_t* GetClass(const MATRIX input, valarray<int >& classes, double threshold)
static wchar_t* GetClass(const MATRIXC input, valarray<double >& classes, double threshold)
static wchar_t* Product(const MATRIX& input_a, const MATRIX& input_b, MATRIX& output)
static wchar_t* Product(const MATRIX& input_a, const valarray<double >& input_b, MATRIX& output)
static wchar_t* Product(const MATRIX& input_a, const valarray<double >& input_b, valarray<double >& output)
static wchar_t* Product(const MATRIXC& input_a, const MATRIXC& input_b, MATRIXC& output)
static wchar_t* Product(const MATRIXC& input_a, const valarray<complex<double>>& input_b, valarray<complex<double>>& output)
static wchar_t* Product(const valarray<complex<double>>& input_a, const MATRIXC& input_b, int rowb_index, MATRIXC& output)
static wchar_t* Product(const valarray<double >& input_a, const MATRIX& input_b, int rowb_index, MATRIX& output)

PidController: It implements a proportional integral derivative controller
PidController(void)
double Create(double kp, double ki, double kd, double targetValue, double minControlValue, double maxControlValue)
double GetControlValue(double measuredValue)
double GetControlValue(double measuredValue, double amortiguamiento)
~ PidController(void)

PowellFindMinMV: It finds the minimum of a multivariable function, i.e. y = f(x0, x2, ..., xn) This function is set when calling Setup(error, *this, startingPoint, 200) It requires only the computation of: f(x0, x2, ..., xn)
DWORD ThreadFunc(Mt::BoolTs& cancel, Mt::DecimalTs& progress, Mt::BoolTs& resetTime)
PowellFindMinMV()
bool Setup(Mt::DoubleTs& error, Math::IMultiVarFunc& ifunc, const valarray<double >& startingPoint, int numIterations)
virtual ~ PowellFindMinMV()
void Delete()
You may call to this function to release memory, but you dont have to
void SetPostMessage(HWND hWnd, UINT wm_message, WPARAM wParam, LPARAM lParam)
It sets the information to call ::PostMessage when the ThreadFunc completes If hWnd is set to NULL, ::PostMessage will not be called wm_message can be: WM_APP+1, WM_APP+2, WM_APP+3, ...

Remez: Filter Design: Low Pass, High Pass, Band Passs, Hilbert, Differentiator Given a set of bands, it computes the Finite Impulse Response of a filter: h[n].
static double ComputeDifferentiatorImpulseResponse(int length, valarray<double >& out_impulseResponse)
static double ComputeHilbertImpulseResponse(int length, valarray<double >& out_impulseResponse)
static double ComputeImpulseResponse(const vector<Math::Remez::Band >& in_band, int length, valarray<double >& out_impulseResponse)
~ Remez()

SimAnnealParam
SimAnnealParam()
~ SimAnnealParam()

SimulatedAnnealing: It provides support to perform Simulated Annealing Optimization
DWORD ThreadFunc(Mt::BoolTs& cancel, Mt::DecimalTs& progress, Mt::BoolTs& resetTime)
SimulatedAnnealing()
void GetSimulationParameters(Math::SimAnnealParam& out_param)
void SetPostMessage(HWND hWnd, UINT wm_message, WPARAM wParam, LPARAM lParam)
It sets the information to call ::PostMessage when the ThreadFunc completes If hWnd is set to NULL, ::PostMessage will not be called wm_message can be: WM_APP+1, WM_APP+2, WM_APP+3, ...
void SetSimulationParameters(const Math::SimAnnealParam& in_param)
void Setup(Mt::DoubleTs& error, ISimAnneal& solution, ISimAnneal& work1, ISimAnneal& work2)
~ SimulatedAnnealing()

SingValDecompos: It performs a singular value decomposition
static bool BackSubstitution(const MATRIX& u, const valarray<double >& s, const MATRIX& v, const valarray<double >& b, valarray<double >& x)
Solves A·x = b for a vector X where A is specified by U S V from a singular value descomposition U[m n], s[n], V[n n] b[m], x[n] 1. Call Decompose to produce S, U, V. Matrix U is return in variable a 2. Call BackSubstitution providing S, U, V as returned by Decompose Returns false if not enough memory
static wchar_t* Decompose(MATRIX& in_out_a, valarray<double >& out_s, MATRIX& out_v)
static wchar_t* Decompose(const MATRIX& in_a, MATRIX& out_u, valarray<double >& out_s, MATRIX& out_v)
~ SingValDecompos()

SplineInterpolation: It interpolates a value for f(x) given a value of x and a table with the values of: x and f(x)
SplineInterpolation()
bool Create(const valarray<double >& x, const valarray<double >& fx)
i.e. x: 0, 2, 5, 10, 20 y: f(0), f(2), f(5), f(10), f(20)
double Interpolate(const double x)
~ SplineInterpolation()

SplineInterpolation2D: It interpolates a value for f(x, y) given a value of x, y and a table with the values of: x, y and f(x, y)
SplineInterpolation2D()
bool Create(const valarray<double >& x, const valarray<double >& y, const MATRIX& fxy)
The size of x must be equal to the number of rows of fxy The size of y must be equal to the number of columns of fxy x must contain a set of values for x. i.e., {0, 0.11, 0.2, 0.3, 0.4, 0.6} y must contain a set of values for y. i.e., {1, 2, 3, 4, 5} fxy must contain a set of values for f(x, y)
double Interpolate(const double x, const double y)
The function returns the interpolation of f(x, y)
~ SplineInterpolation2D()

Statistics: It provides a set of functions in Statistics
static bool MovingAverage(const valarray<double >& input, const int windowLength, valarray<double >& output)
static bool MovingAverageAndVariance(const valarray<double >& input, const int windowLength, valarray<double >& out_average, valarray<double >& out_variance)
static bool MovingVariance(const valarray<double >& input, const int windowLength, valarray<double >& output)
static complex<double>GetDiagonalSum(MATRIXC& input)
static complex<double>GetMagnitudeMax(MATRIXC& input, int& row, int& col)
static complex<double>GetMagnitudeMax(valarray<complex<double>>& input, int& position)
static complex<double>GetMagnitudeMin(MATRIXC& input, int& row, int& col)
static complex<double>GetMagnitudeMin(valarray<complex<double>>& input, int& position)
static complex<double>GetSum(MATRIXC& input)
static complex<double>GetSum(valarray<complex<double>>& input)
static complex<double>MeanValue(MATRIXC& input)
static complex<double>MeanValue(valarray<complex<double>>& input)
static complex<double>Variance(const MATRIXC& input)
static complex<double>Variance(const valarray<complex<double>>& input)
static const wchar_t* CorrelationMatrix(const MATRIX& input, MATRIX& output)
static const wchar_t* CovarianceMatrix(const MATRIX& input, MATRIX& output)
static double AbsoluteRelativeError(const valarray<double >& exact, const valarray<double >& approx)
static double Bias(valarray<double >& approx, double exact)
static double Bias(valarray<double >& exact, valarray<double >& approx)
static double Correlation(const valarray<double >& input_x, const valarray<double >& input_y)
static double CorrelationCoeff(const valarray<double >& input_x, const valarray<double >& input_y)
static double Covariance(const valarray<double >& input_x, const valarray<double >& input_y, bool bNormalDistr)
static double GetDiagonalSum(MATRIX& input)
static double GetMaximum(const MATRIX& input, int& row, int& col)
static double GetMaximum(const MATRIXC& input, int& row, int& col)
static double GetMaximum(const valarray<complex<double>>& input, int& position)
static double GetMaximum(const valarray<double >& input, int& position)
static double GetMinimum(const MATRIX& input, int& row, int& col)
static double GetMinimum(const MATRIXC& input, int& row, int& col)
static double GetMinimum(const valarray<complex<double>>& input, int& position)
static double GetMinimum(const valarray<double >& input, int& position)
static double GetSum(MATRIX& input)
static double GetSum(valarray<double >& input)
static double GetSumOfSquares(MATRIX& input)
static double GetSumOfSquares(MATRIXC& input)
static double GetSumOfSquares(valarray<complex<double>>& input)
static double GetSumOfSquares(valarray<double >& input)
static double MeanAbsoluteError(const valarray<double >& exact, const valarray<double >& approx)
static double MeanSquaredError(const valarray<double >& exact, const valarray<double >& approx)
static double MeanValue(MATRIX& input)
static double MeanValue(valarray<double >& input)
static double RelativeRootMeanSquareError(const valarray<double >& exact, const valarray<double >& approx)
static double RootMeanSquaredError(const valarray<double >& exact, const valarray<double >& approx)
static double StandardDeviation(const valarray<double >& input)
static double TheilIndex(valarray<double >& input)
static double TheilUInequalityIndex(valarray<double >& input_x, valarray<double >& input_y)
static double Variance(const MATRIX& input)
static double Variance(const valarray<double >& input)
static unsigned int Combinations(unsigned int n, unsigned int k)
static void AbsoluteRelativeError(const valarray<double >& exact, const valarray<double >& approx, valarray<double >& outRelativeError)
static void ColumnMaximum(const MATRIX& input, valarray<double >& output)
static void ColumnMean(const MATRIX& input, valarray<double >& output)
static void ColumnMinimum(const MATRIX& input, valarray<double >& output)
static void ColumnVariance(const MATRIX& input, valarray<double >& output)
static void RowMaximum(const MATRIX& input, valarray<double >& output)
static void RowMean(const MATRIX& input, valarray<double >& output)
static void RowMinimum(const MATRIX& input, valarray<double >& output)
static void RowVariance(const MATRIX& input, valarray<double >& output)
virtual ~ Statistics(void)

SyntheticDiv: It provides a set of functions to perform a synthetic division
static complex<double>Run(const valarray<complex<double>>& inputCoeff, valarray<complex<double>>& outputCoeff, complex<double>x)
static complex<double>Run(const valarray<complex<double>>& inputCoeff, valarray<complex<double>>& outputCoeff, complex<double>x, complex<double >& out_dx)
static double Newton(const valarray<complex<double>>& inputCoeff, valarray<complex<double>>& outputCoeff, complex<double >& int_out_x)
static double Newton(const valarray<double >& inputCoeff, valarray<double >& outputCoeff, double& int_out_x)
static double Run(const valarray<double >& inputCoeff, valarray<double >& outputCoeff, double x)
static double Run(const valarray<double >& inputCoeff, valarray<double >& outputCoeff, double x, double& out_dx)
virtual ~ SyntheticDiv(void)

TimeDependentFT: Time-dependent Fourier Transform
TimeDependentFT()
bool Create(int windowWidth, int numFrequencies, double beta)
bool Transform(const valarray<double >& input, MATRIXC& output)
~ TimeDependentFT()

TimePredictor: It estimates how long it will take for a task to complete
TimePredictor(void)
int GetPredictionInSeconds(double targetValue)
void AddValue(double value)
void Reset(void)
~ TimePredictor(void)

Trender: It eliminates trends in the data using a line: y = mx + b
Trender()
void CalculateMB(bool bLeastSquares, valarray<double >& source)
void posttrending(valarray<double >& source, valarray<double >& destination)
void pretrending(bool leastSquares, valarray<double >& source, valarray<double >& destination)
~ Trender()
© Copyright 2000-2019 selo. All Rights Reserved. Sep 05 2019.