gavindiaz/All-MQL5-code
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
All-MQL5-code/Scripts/UnitTests/Alglib/TestInterfaces.mqh
T
Pierre8rTeam 25e9006a0b First commit [09/03/2018]
2018-03-09 16:43:19 +01:00

11822 lines
392 KiB
Plaintext
Raw Permalink Blame History

//+------------------------------------------------------------------+
//| TestInterfaces.mqh |
//| Copyright 2003-2012 Sergey Bochkanov (ALGLIB project) |
//| Copyright 2012-2017, MetaQuotes Software Corp. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
//| Implementation of ALGLIB library in MetaQuotes Language 5 |
//| |
//| The features of the library include: |
//| - Linear algebra (direct algorithms, EVD, SVD) |
//| - Solving systems of linear and non-linear equations |
//| - Interpolation |
//| - Optimization |
//| - FFT (Fast Fourier Transform) |
//| - Numerical integration |
//| - Linear and nonlinear least-squares fitting |
//| - Ordinary differential equations |
//| - Computation of special functions |
//| - Descriptive statistics and hypothesis testing |
//| - Data analysis - classification, regression |
//| - Implementing linear algebra algorithms, interpolation, etc. |
//| in high-precision arithmetic (using MPFR) |
//| |
//| This file is free software; you can redistribute it and/or |
//| modify it under the terms of the GNU General Public License as |
//| published by the Free Software Foundation (www.fsf.org); either |
//| version 2 of the License, or (at your option) any later version. |
//| |
//| This program is distributed in the hope that it will be useful, |
//| but WITHOUT ANY WARRANTY; without even the implied warranty of |
//| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
//| GNU General Public License for more details. |
//+------------------------------------------------------------------+
#include <Math\Alglib\alglib.mqh>
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Func |
//+------------------------------------------------------------------+
class CNDimensional_Func1 : public CNDimensional_Func
{
public:
CNDimensional_Func1(void);
~CNDimensional_Func1(void);
virtual void Func(double &x[],double &func,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Func1::CNDimensional_Func1(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Func1::~CNDimensional_Func1(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(x0,x1)=100*(x0+3)^4 + (x1-3)^4 |
//+------------------------------------------------------------------+
void CNDimensional_Func1::Func(double &x[],double &func,CObject &obj)
{
func=100*MathPow(x[0]+3,4)+MathPow(x[1]-3,4);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Func |
//+------------------------------------------------------------------+
class CNDimensional_Func2 : public CNDimensional_Func
{
public:
//--- constructor, destructor
CNDimensional_Func2(void);
~CNDimensional_Func2(void);
//--- method
virtual void Func(double &x[],double &func,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Func2::CNDimensional_Func2(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Func2::~CNDimensional_Func2(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(x0,x1)=(x0^2+1)^2 + (x1-1)^2 |
//+------------------------------------------------------------------+
void CNDimensional_Func2::Func(double &x[],double &func,CObject &obj)
{
func=MathPow(x[0]*x[0]+1,2)+MathPow(x[1]-1,2);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Func |
//+------------------------------------------------------------------+
class CNDimensional_Bad_Func : public CNDimensional_Func
{
public:
//--- constructor, destructor
CNDimensional_Bad_Func(void);
~CNDimensional_Bad_Func(void);
//--- method
virtual void Func(double &x[],double &func,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Bad_Func::CNDimensional_Bad_Func(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Bad_Func::~CNDimensional_Bad_Func(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates 'bad' function, i.e. function with |
//| incorrectly calculated derivatives |
//+------------------------------------------------------------------+
void CNDimensional_Bad_Func::Func(double &x[],double &func,CObject &obj)
{
func=100*MathPow(x[0]+3,4)+MathPow(x[1]-3,4);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Grad |
//+------------------------------------------------------------------+
class CNDimensional_Grad1 : public CNDimensional_Grad
{
public:
//--- constructor, destructor
CNDimensional_Grad1(void);
~CNDimensional_Grad1(void);
//--- method
virtual void Grad(double &x[],double &func,double &grad[],CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Grad1::CNDimensional_Grad1(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Grad1::~CNDimensional_Grad1(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(x0,x1)=100*(x0+3)^4 + (x1-3)^4 and its|
//| derivatives df/d0 and df/dx1 |
//+------------------------------------------------------------------+
void CNDimensional_Grad1::Grad(double &x[],double &func,
double &grad[],CObject &obj)
{
func=100*MathPow(x[0]+3,4)+MathPow(x[1]-3,4);
grad[0]=400*MathPow(x[0]+3,3);
grad[1]=4*MathPow(x[1]-3,3);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Grad |
//+------------------------------------------------------------------+
class CNDimensional_Grad2 : public CNDimensional_Grad
{
public:
//--- constructor, destructor
CNDimensional_Grad2(void);
~CNDimensional_Grad2(void);
//--- method
virtual void Grad(double &x[],double &func,double &grad[],CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Grad2::CNDimensional_Grad2(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Grad2::~CNDimensional_Grad2(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(x0,x1)=(x0^2+1)^2 + (x1-1)^2 and its |
//| derivatives df/d0 and df/dx1 |
//+------------------------------------------------------------------+
void CNDimensional_Grad2::Grad(double &x[],double &func,
double &grad[],CObject &obj)
{
func=MathPow(x[0]*x[0]+1,2)+MathPow(x[1]-1,2);
grad[0]=4*(x[0]*x[0]+1)*x[0];
grad[1]=2*(x[1]-1);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Grad |
//+------------------------------------------------------------------+
class CNDimensional_Bad_Grad : public CNDimensional_Grad
{
public:
//--- constructor, destructor
CNDimensional_Bad_Grad(void);
~CNDimensional_Bad_Grad(void);
//--- method
virtual void Grad(double &x[],double &func,double &grad[],CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Bad_Grad::CNDimensional_Bad_Grad(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Bad_Grad::~CNDimensional_Bad_Grad(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates 'bad' function, i.e. function with |
//| incorrectly calculated derivatives |
//+------------------------------------------------------------------+
void CNDimensional_Bad_Grad::Grad(double &x[],double &func,double &grad[],CObject &obj)
{
func=100*MathPow(x[0]+3,4)+MathPow(x[1]-3,4);
grad[0]=40*MathPow(x[0]+3,3);
grad[1]=40*MathPow(x[1]-3,3);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Grad |
//+------------------------------------------------------------------+
class CNDimensional_S1_Grad : public CNDimensional_Grad
{
public:
CNDimensional_S1_Grad(void);
~CNDimensional_S1_Grad(void);
virtual void Grad(double &x[],double &func,double &grad[],CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_S1_Grad::CNDimensional_S1_Grad(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_S1_Grad::~CNDimensional_S1_Grad(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(x)=(1+x)^(-0.2)+(1-x)^(-0.3)+1000*x |
//| and its gradient. function is trimmed when we calculate it near |
//| the singular points or outside of the [-1,+1]. Note that we do |
//| NOT calculate gradient in this case. |
//+------------------------------------------------------------------+
void CNDimensional_S1_Grad::Grad(double &x[],double &func,double &grad[],CObject &obj)
{
if((x[0]<=-0.999999999999) || (x[0]>=+0.999999999999))
{
func=1.0E+300;
return;
}
func=MathPow(1+x[0],-0.2)+MathPow(1-x[0],-0.3)+1000*x[0];
grad[0]=-0.2*MathPow(1+x[0],-1.2)+0.3*MathPow(1-x[0],-1.3)+1000;
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Hess |
//+------------------------------------------------------------------+
class CNDimensional_Hess1 : public CNDimensional_Hess
{
public:
CNDimensional_Hess1(void);
~CNDimensional_Hess1(void);
virtual void Hess(double &x[],double &func,double &grad[],CMatrixDouble &hess,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Hess1::CNDimensional_Hess1(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Hess1::~CNDimensional_Hess1(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(x0,x1)=100*(x0+3)^4 + (x1-3)^4 |
//| its derivatives df/d0 and df/dx1 |
//| and its Hessian. |
//+------------------------------------------------------------------+
void CNDimensional_Hess1::Hess(double &x[],double &func,double &grad[],
CMatrixDouble &hess,CObject &obj)
{
func=100*MathPow(x[0]+3,4)+MathPow(x[1]-3,4);
grad[0]=400*MathPow(x[0]+3,3);
grad[1]=4*MathPow(x[1]-3,3);
hess[0].Set(0,1200*MathPow(x[0]+3,2));
hess[0].Set(1,0);
hess[1].Set(0,0);
hess[1].Set(1,12*MathPow(x[1]-3,2));
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Hess |
//+------------------------------------------------------------------+
class CNDimensional_Hess2 : public CNDimensional_Hess
{
public:
//--- constructor, destructor
CNDimensional_Hess2(void);
~CNDimensional_Hess2(void);
//--- method
virtual void Hess(double &x[],double &func,double &grad[],CMatrixDouble &hess,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Hess2::CNDimensional_Hess2(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Hess2::~CNDimensional_Hess2(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(x0,x1)=(x0^2+1)^2 + (x1-1)^2 |
//| its gradient and Hessian |
//+------------------------------------------------------------------+
void CNDimensional_Hess2::Hess(double &x[],double &func,double &grad[],
CMatrixDouble &hess,CObject &obj)
{
func=MathPow(x[0]*x[0]+1,2)+MathPow(x[1]-1,2);
grad[0]=4*(x[0]*x[0]+1)*x[0];
grad[1]=2*(x[1]-1);
hess[0].Set(0,12*x[0]*x[0]+4);
hess[0].Set(1,0);
hess[1].Set(0,0);
hess[1].Set(1,2);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Hess |
//+------------------------------------------------------------------+
class CNDimensional_Bad_Hess : public CNDimensional_Hess
{
public:
//--- constructor, destructor
CNDimensional_Bad_Hess(void);
~CNDimensional_Bad_Hess(void);
//--- method
virtual void Hess(double &x[],double &func,double &grad[],CMatrixDouble &hess,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Bad_Hess::CNDimensional_Bad_Hess(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Bad_Hess::~CNDimensional_Bad_Hess(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates 'bad' function, i.e. function with |
//| incorrectly calculated derivatives |
//+------------------------------------------------------------------+
void CNDimensional_Bad_Hess::Hess(double &x[],double &func,double &grad[],
CMatrixDouble &hess,CObject &obj)
{
func=100*MathPow(x[0]+3,4)+MathPow(x[1]-3,4);
grad[0]=40*MathPow(x[0]+3,3);
grad[1]=40*MathPow(x[1]-3,3);
hess[0].Set(0,120*MathPow(x[0]+3,2));
hess[0].Set(1,1);
hess[1].Set(0,1);
hess[1].Set(1,120*MathPow(x[1]-3,2));
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_FVec |
//+------------------------------------------------------------------+
class CNDimensional_FVec1 : public CNDimensional_FVec
{
public:
//--- constructor, destructor
CNDimensional_FVec1(void);
~CNDimensional_FVec1(void);
//--- method
virtual void FVec(double &x[],double &fi[],CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_FVec1::CNDimensional_FVec1(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_FVec1::~CNDimensional_FVec1(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates |
//| f0(x0,x1)=100*(x0+3)^4, |
//| f1(x0,x1)=(x1-3)^4 |
//+------------------------------------------------------------------+
void CNDimensional_FVec1::FVec(double &x[],double &fi[],CObject &obj)
{
fi[0]=10*MathPow(x[0]+3,2);
fi[1]=MathPow(x[1]-3,2);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_FVec |
//+------------------------------------------------------------------+
class CNDimensional_FVec2 : public CNDimensional_FVec
{
public:
//--- constructor, destructor
CNDimensional_FVec2(void);
~CNDimensional_FVec2(void);
//--- method
virtual void FVec(double &x[],double &fi[],CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_FVec2::CNDimensional_FVec2(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_FVec2::~CNDimensional_FVec2(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates |
//| f0(x0,x1)=100*(x0+3)^4, |
//| f1(x0,x1)=(x1-3)^4 |
//+------------------------------------------------------------------+
void CNDimensional_FVec2::FVec(double &x[],double &fi[],CObject &obj)
{
fi[0]=x[0]*x[0]+1;
fi[1]=x[1]-1;
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_FVec |
//+------------------------------------------------------------------+
class CNDimensional_Bad_FVec : public CNDimensional_FVec
{
public:
//--- constructor, destructor
CNDimensional_Bad_FVec(void);
~CNDimensional_Bad_FVec(void);
//--- method
virtual void FVec(double &x[],double &fi[],CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Bad_FVec::CNDimensional_Bad_FVec(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Bad_FVec::~CNDimensional_Bad_FVec(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates 'bad' function, i.e. function with |
//| incorrectly calculated derivatives |
//+------------------------------------------------------------------+
void CNDimensional_Bad_FVec::FVec(double &x[],double &fi[],CObject &obj)
{
fi[0]=10*MathPow(x[0]+3,2);
fi[1]=MathPow(x[1]-3,2);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Jac |
//+------------------------------------------------------------------+
class CNDimensional_Jac1 : public CNDimensional_Jac
{
public:
//--- constructor, destructor
CNDimensional_Jac1(void);
~CNDimensional_Jac1(void);
//--- method
virtual void Jac(double &x[],double &fi[],CMatrixDouble &jac,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Jac1::CNDimensional_Jac1(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Jac1::~CNDimensional_Jac1(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates |
//| f0(x0,x1)=100*(x0+3)^4, |
//| f1(x0,x1)=(x1-3)^4 |
//| and Jacobian matrix J=[dfi/dxj] |
//+------------------------------------------------------------------+
void CNDimensional_Jac1::Jac(double &x[],double &fi[],CMatrixDouble &jac,
CObject &obj)
{
fi[0]=10*MathPow(x[0]+3,2);
fi[1]=MathPow(x[1]-3,2);
jac[0].Set(0,20*(x[0]+3));
jac[0].Set(1,0);
jac[1].Set(0,0);
jac[1].Set(1,2*(x[1]-3));
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Jac |
//+------------------------------------------------------------------+
class CNDimensional_Jac2 : public CNDimensional_Jac
{
public:
//--- constructor, destructor
CNDimensional_Jac2(void);
~CNDimensional_Jac2(void);
//--- method
virtual void Jac(double &x[],double &fi[],CMatrixDouble &jac,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Jac2::CNDimensional_Jac2(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Jac2::~CNDimensional_Jac2(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates |
//| f0(x0,x1)=x0^2+1 |
//| f1(x0,x1)=x1-1 |
//| and Jacobian matrix J=[dfi/dxj] |
//+------------------------------------------------------------------+
void CNDimensional_Jac2::Jac(double &x[],double &fi[],CMatrixDouble &jac,
CObject &obj)
{
fi[0]=x[0]*x[0]+1;
fi[1]=x[1]-1;
jac[0].Set(0,2*x[0]);
jac[0].Set(1,0);
jac[1].Set(0,0);
jac[1].Set(1,1);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_Jac |
//+------------------------------------------------------------------+
class CNDimensional_Bad_Jac : public CNDimensional_Jac
{
public:
//--- constructor, destructor
CNDimensional_Bad_Jac(void);
~CNDimensional_Bad_Jac(void);
//--- method
virtual void Jac(double &x[],double &fi[],CMatrixDouble &jac,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Bad_Jac::CNDimensional_Bad_Jac(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Bad_Jac::~CNDimensional_Bad_Jac(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates 'bad' function, |
//| i.e. function with incorrectly calculated derivatives |
//+------------------------------------------------------------------+
void CNDimensional_Bad_Jac::Jac(double &x[],double &fi[],CMatrixDouble &jac,
CObject &obj)
{
fi[0]=10*MathPow(x[0]+3,2);
fi[1]=MathPow(x[1]-3,2);
jac[0].Set(0,20*(x[0]+3));
jac[0].Set(1,0);
jac[1].Set(0,1);
jac[1].Set(1,20*(x[1]-3));
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_PFunc |
//+------------------------------------------------------------------+
class CNDimensional_CX_1_Func : public CNDimensional_PFunc
{
public:
//--- constructor, destructor
CNDimensional_CX_1_Func(void);
~CNDimensional_CX_1_Func(void);
//--- method
virtual void PFunc(double &c[],double &x[],double &func,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_CX_1_Func::CNDimensional_CX_1_Func(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_CX_1_Func::~CNDimensional_CX_1_Func(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(c,x)=exp(-c0*sqr(x0)) where x is a |
//| position on X-axis and c is adjustable parameter |
//+------------------------------------------------------------------+
void CNDimensional_CX_1_Func::PFunc(double &c[],double &x[],double &func,
CObject &obj)
{
func=MathExp(-c[0]*x[0]*x[0]);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_PFunc |
//+------------------------------------------------------------------+
class CNDimensional_Debt_Func : public CNDimensional_PFunc
{
public:
//--- constructor, destructor
CNDimensional_Debt_Func(void);
~CNDimensional_Debt_Func(void);
//--- method
virtual void PFunc(double &c[],double &x[],double &func,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_Debt_Func::CNDimensional_Debt_Func(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_Debt_Func::~CNDimensional_Debt_Func(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates |
//| f(c,x)=c[0]*(1+c[1]*(pow(x[0]-1999,c[2])-1)) |
//+------------------------------------------------------------------+
void CNDimensional_Debt_Func::PFunc(double &c[],double &x[],double &func,
CObject &obj)
{
func=c[0]*(1+c[1]*(MathPow(x[0]-1999,c[2])-1));
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_PGrad |
//+------------------------------------------------------------------+
class CNDimensional_CX_1_Grad : public CNDimensional_PGrad
{
public:
//--- constructor, destructor
CNDimensional_CX_1_Grad(void);
~CNDimensional_CX_1_Grad(void);
//--- method
virtual void PGrad(double &c[],double &x[],double &func,double &grad[],CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_CX_1_Grad::CNDimensional_CX_1_Grad(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_CX_1_Grad::~CNDimensional_CX_1_Grad(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(c,x)=exp(-c0*sqr(x0)) and gradient |
//| G={df/dc[i]} where x is a position on X-axis and c is adjustable |
//| parameter. |
//| IMPORTANT: gradient is calculated with respect to C, not to X |
//+------------------------------------------------------------------+
void CNDimensional_CX_1_Grad::PGrad(double &c[],double &x[],double &func,
double &grad[],CObject &obj)
{
func=MathExp(-c[0]*MathPow(x[0],2));
grad[0]=-MathPow(x[0],2)*func;
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_PHess |
//+------------------------------------------------------------------+
class CNDimensional_CX_1_Hess : public CNDimensional_PHess
{
public:
//--- constructor, destructor
CNDimensional_CX_1_Hess(void);
~CNDimensional_CX_1_Hess(void);
//--- method
virtual void PHess(double &c[],double &x[],double &func,double &grad[],CMatrixDouble &hess,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_CX_1_Hess::CNDimensional_CX_1_Hess(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_CX_1_Hess::~CNDimensional_CX_1_Hess(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(c,x)=exp(-c0*sqr(x0)), gradient |
//| G={df/dc[i]} and Hessian H={d2f/(dc[i]*dc[j])} where x is a |
//| position on X-axis and c is adjustable parameter. |
//| IMPORTANT: gradient/Hessian are calculated with respect to C, |
//| not to X |
//+------------------------------------------------------------------+
void CNDimensional_CX_1_Hess::PHess(double &c[],double &x[],double &func,
double &grad[],CMatrixDouble &hess,
CObject &obj)
{
func=MathExp(-c[0]*MathPow(x[0],2));
grad[0]=-MathPow(x[0],2)*func;
hess[0].Set(0,MathPow(x[0],4)*func);
}
//+------------------------------------------------------------------+
//| Derived class from CNDimensional_ODE_RP |
//+------------------------------------------------------------------+
class CNDimensional_ODE_Function_1_Dif : public CNDimensional_ODE_RP
{
public:
//--- constructor, destructor
CNDimensional_ODE_Function_1_Dif(void);
~CNDimensional_ODE_Function_1_Dif(void);
//--- method
virtual void ODE_RP(double &y[],double x,double &dy[],CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CNDimensional_ODE_Function_1_Dif::CNDimensional_ODE_Function_1_Dif(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CNDimensional_ODE_Function_1_Dif::~CNDimensional_ODE_Function_1_Dif(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(y[],x)=-y[0] |
//+------------------------------------------------------------------+
CNDimensional_ODE_Function_1_Dif::ODE_RP(double &y[],double x,double &dy[],
CObject &obj)
{
dy[0]=-y[0];
}
//+------------------------------------------------------------------+
//| Derived class from CIntegrator1_Func |
//+------------------------------------------------------------------+
class CInt_Function_1_Func : public CIntegrator1_Func
{
public:
//--- constructor, destructor
CInt_Function_1_Func(void);
~CInt_Function_1_Func(void);
//--- method
virtual void Int_Func(double x,double xminusa,double bminusx,double &y,CObject &obj);
};
//+------------------------------------------------------------------+
//| Constructor without parameters |
//+------------------------------------------------------------------+
CInt_Function_1_Func::CInt_Function_1_Func(void)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
CInt_Function_1_Func::~CInt_Function_1_Func(void)
{
}
//+------------------------------------------------------------------+
//| This callback calculates f(x)=exp(x) |
//+------------------------------------------------------------------+
void CInt_Function_1_Func::Int_Func(double x,double xminusa,double bminusx,
double &y,CObject &obj)
{
y=MathExp(x);
}
//+------------------------------------------------------------------+
//| A comparison of the two numbers |
//+------------------------------------------------------------------+
bool Doc_Test_Int(int val,int test_val)
{
//--- return result
return(val==test_val);
}
//+------------------------------------------------------------------+
//| A comparison of two numbers with an accuracy |
//+------------------------------------------------------------------+
bool Doc_Test_Real(double val,double test_val,double _threshold)
{
//--- calculation
double s=_threshold>=0 ? 1.0 : MathAbs(test_val);
double threshold=MathAbs(_threshold);
//--- return result
return(MathAbs(val-test_val)/s<=threshold);
}
//+------------------------------------------------------------------+
//| A comparison of two numbers with an accuracy |
//+------------------------------------------------------------------+
bool Doc_Test_Complex(complex &val,complex &test_val,double _threshold)
{
//--- calculation
double s=_threshold>=0 ? 1.0 : CMath::AbsComplex(test_val);
double threshold=MathAbs(_threshold);
//--- return result
return(CMath::AbsComplex(val-test_val)/s<=threshold);
}
//+------------------------------------------------------------------+
//| A comparison of two vectors |
//+------------------------------------------------------------------+
bool Doc_Test_Int_Vector(int &val[],int &test_val[])
{
//--- create a variable
int i;
//--- check
if(CAp::Len(val)!=CAp::Len(test_val))
return(false);
//--- comparison
for(i=0;i<CAp::Len(val);i++)
if(val[i]!=test_val[i])
return(false);
//--- return result
return(true);
}
//+------------------------------------------------------------------+
//| Comparison of the two matrices |
//+------------------------------------------------------------------+
bool Doc_Test_Int_Matrix(CMatrixInt &val,CMatrixInt &test_val)
{
//--- create variables
int i,j;
//--- check
if(CAp::Rows(val)!=CAp::Rows(test_val))
return(false);
//--- check
if(CAp::Cols(val)!=CAp::Cols(test_val))
return(false);
//--- comparison
for(i=0;i<CAp::Rows(val);i++)
for(j=0;j<CAp::Cols(val);j++)
if(val[i][j]!=test_val[i][j])
return(false);
//--- return result
return(true);
}
//+------------------------------------------------------------------+
//| A comparison of two vectors with an accuracy |
//+------------------------------------------------------------------+
bool Doc_Test_Real_Vector(double &val[],double &test_val[],double _threshold)
{
//--- create a variable
int i;
//--- check
if(CAp::Len(val)!=CAp::Len(test_val))
return(false);
//--- comparison
for(i=0;i<CAp::Len(val);i++)
{
double s=_threshold>=0 ? 1.0 : MathAbs(test_val[i]);
double threshold=MathAbs(_threshold);
//--- check
if(MathAbs(val[i]-test_val[i])/s>threshold)
return(false);
}
//--- return result
return(true);
}
//+------------------------------------------------------------------+
//| A comparison of two vectors with an accuracy |
//+------------------------------------------------------------------+
bool Doc_Test_Real_Matrix(CMatrixDouble &val,CMatrixDouble &test_val,double _threshold)
{
//--- create variables
int i,j;
//--- check
if(CAp::Rows(val)!=CAp::Rows(test_val))
return(false);
//--- check
if(CAp::Cols(val)!=CAp::Cols(test_val))
return(false);
//--- comparison
for(i=0;i<CAp::Rows(val);i++)
for(j=0;j<CAp::Cols(val);j++)
{
double s=_threshold>=0 ? 1.0 : MathAbs(test_val[i][j]);
double threshold=MathAbs(_threshold);
//--- check
if(MathAbs(val[i][j]-test_val[i][j])/s>threshold)
return(false);
}
//--- return result
return(true);
}
//+------------------------------------------------------------------+
//| A comparison of two vectors with an accuracy |
//+------------------------------------------------------------------+
bool Doc_Test_Complex_Vector(complex &val[],complex &test_val[],double _threshold)
{
//--- create a variable
int i;
//--- check
if(CAp::Len(val)!=CAp::Len(test_val))
return(false);
//--- comparison
for(i=0;i<CAp::Len(val);i++)
{
double s=_threshold>=0 ? 1.0 : CMath::AbsComplex(test_val[i]);
double threshold=MathAbs(_threshold);
//--- check
if(CMath::AbsComplex(val[i]-test_val[i])/s>threshold)
return(false);
}
//--- return result
return(true);
}
//+------------------------------------------------------------------+
//| A comparison of two matrices with an accuracy |
//+------------------------------------------------------------------+
bool Doc_Test_Complex_Matrix(CMatrixComplex &val,CMatrixComplex &test_val,double _threshold)
{
//--- create variables
int i,j;
//--- check
if(CAp::Rows(val)!=CAp::Rows(test_val))
return(false);
//--- check
if(CAp::Cols(val)!=CAp::Cols(test_val))
return(false);
//--- comparison
for(i=0;i<CAp::Rows(val);i++)
for(j=0;j<CAp::Cols(val);j++)
{
double s=_threshold>=0 ? 1.0 : CMath::AbsComplex(test_val[i][j]);
double threshold=MathAbs(_threshold);
//--- check
if(CMath::AbsComplex(val[i][j]-test_val[i][j])/s>threshold)
return(false);
}
//--- return result
return(true);
}
//+------------------------------------------------------------------+
//| Add to the vector random element |
//+------------------------------------------------------------------+
void Spoil_Vector_By_Adding_Element(int &x[])
{
//--- size calculation
int n=ArraySize(x);
//--- increasing the length of the vector
ArrayResize(x,n+1);
//--- set value
x[n]=MathRand();
}
//+------------------------------------------------------------------+
//| Add to the vector random element |
//+------------------------------------------------------------------+
void Spoil_Vector_By_Adding_Element(double &x[])
{
//--- size calculation
int n=ArraySize(x);
//--- increasing the length of the vector
ArrayResize(x,n+1);
//--- set value
x[n]=CMath::RandomReal();
}
//+------------------------------------------------------------------+
//| Add to the vector random element |
//+------------------------------------------------------------------+
void Spoil_Vector_By_Adding_Element(complex &x[])
{
//--- size calculation
int n=ArraySize(x);
//--- increasing the length of the vector
ArrayResize(x,n+1);
//--- set value
x[n].re=CMath::RandomReal();
x[n].im=CMath::RandomReal();
}
//+------------------------------------------------------------------+
//| Removing the number of vector |
//+------------------------------------------------------------------+
void Spoil_Vector_By_Deleting_Element(int &x[])
{
//--- size calculation
int n=ArraySize(x);
//--- reduction length of the vector
ArrayResize(x,n-1);
}
//+------------------------------------------------------------------+
//| Removing the number of vector |
//+------------------------------------------------------------------+
void Spoil_Vector_By_Deleting_Element(double &x[])
{
//--- size calculation
int n=ArraySize(x);
//--- reduction length of the vector
ArrayResize(x,n-1);
}
//+------------------------------------------------------------------+
//| Removing the number of vector |
//+------------------------------------------------------------------+
void Spoil_Vector_By_Deleting_Element(complex &x[])
{
//--- size calculation
int n=ArraySize(x);
//--- reduction length of the vector
ArrayResize(x,n-1);
}
//+------------------------------------------------------------------+
//| Add a row in the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Adding_Row(CMatrixInt &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- increase the dimension
x.Resize(n+1,m);
//--- set values
for(int i=0;i<m;i++)
x[n].Set(i,MathRand());
}
//+------------------------------------------------------------------+
//| Add a row in the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Adding_Row(CMatrixDouble &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- increase the dimension
x.Resize(n+1,m);
//--- set values
for(int i=0;i<m;i++)
x[n].Set(i,CMath::RandomReal());
}
//+------------------------------------------------------------------+
//| Add a row in the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Adding_Row(CMatrixComplex &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- increase the dimension
x.Resize(n+1,m);
//--- set values
for(int i=0;i<m;i++)
{
x[n].SetRe(i,CMath::RandomReal());
x[n].SetIm(i,CMath::RandomReal());
}
}
//+------------------------------------------------------------------+
//| Deleting a row from the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Deleting_Row(CMatrixInt &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- reduction of dimension
x.Resize(n-1,m);
}
//+------------------------------------------------------------------+
//| Deleting a row from the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Deleting_Row(CMatrixDouble &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- reduction of dimension
x.Resize(n-1,m);
}
//+------------------------------------------------------------------+
//| Deleting a row from the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Deleting_Row(CMatrixComplex &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- reduction of dimension
x.Resize(n-1,m);
}
//+------------------------------------------------------------------+
//| Add a col in the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Adding_Col(CMatrixInt &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- increase the dimension
x.Resize(n,m+1);
//--- set values
for(int i=0;i<m;i++)
x[i].Set(m,MathRand());
}
//+------------------------------------------------------------------+
//| Add a col in the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Adding_Col(CMatrixDouble &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- increase the dimension
x.Resize(n,m+1);
//--- set values
for(int i=0;i<m;i++)
x[i].Set(m,CMath::RandomReal());
}
//+------------------------------------------------------------------+
//| Add a col in the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Adding_Col(CMatrixComplex &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- increase the dimension
x.Resize(n,m+1);
//--- set values
for(int i=0;i<m;i++)
{
x[i].SetRe(m,CMath::RandomReal());
x[i].SetIm(m,CMath::RandomReal());
}
}
//+------------------------------------------------------------------+
//| Deleting a col from the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Deleting_Col(CMatrixInt &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- reduction of dimension
x.Resize(n,m-1);
}
//+------------------------------------------------------------------+
//| Deleting a col from the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Deleting_Col(CMatrixDouble &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- reduction of dimension
x.Resize(n,m-1);
}
//+------------------------------------------------------------------+
//| Deleting a col from the matrix |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Deleting_Col(CMatrixComplex &x)
{
//--- cols and rows calculation
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- reduction of dimension
x.Resize(n,m-1);
}
//+------------------------------------------------------------------+
//| Set number to a random position |
//+------------------------------------------------------------------+
void Spoil_Vector_By_Value(int &x[],int &val)
{
//--- size calculation
int n=ArraySize(x);
//--- ????????? ????? ? ????????? ?????? ???????
if(n!=0)
x[CMath::RandomInteger(n)]=val;
}
//+------------------------------------------------------------------+
//| Set number to a random position |
//+------------------------------------------------------------------+
void Spoil_Vector_By_Value(double &x[],double val)
{
//--- size calculation
int n=ArraySize(x);
//--- set value
if(n!=0)
x[CMath::RandomInteger(n)]=val;
}
//+------------------------------------------------------------------+
//| Set number to a random position |
//+------------------------------------------------------------------+
void Spoil_Vector_By_Value(complex &x[],complex &val)
{
//--- size calculation
int n=ArraySize(x);
//--- set value
if(n!=0)
x[CMath::RandomInteger(n)]=val;
}
//+------------------------------------------------------------------+
//| Set number to a random position |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Value(CMatrixInt &x,int val)
{
//--- get cols and rows
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- set value
if(n!=0 && m!=0)
x[CMath::RandomInteger(n)].Set(CMath::RandomInteger(m),val);
}
//+------------------------------------------------------------------+
//| Set number to a random position |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Value(CMatrixDouble &x,double val)
{
//--- get cols and rows
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- set value
if(n!=0 && m!=0)
x[CMath::RandomInteger(n)].Set(CMath::RandomInteger(m),val);
}
//+------------------------------------------------------------------+
//| Set number to a random position |
//+------------------------------------------------------------------+
void Spoil_Matrix_By_Value(CMatrixComplex &x,complex &val)
{
//--- get cols and rows
int n=CAp::Rows(x);
int m=CAp::Cols(x);
//--- set value
if(n!=0 && m!=0)
x[CMath::RandomInteger(n)].Set(CMath::RandomInteger(m),val);
}
//+------------------------------------------------------------------+
//| Function test and exception handling |
//+------------------------------------------------------------------+
bool Func_spoil_scenario(int _spoil_scenario,bool &_TestResult)
{
if(CAp::exception_happened==true)
{
//--- check
if(_spoil_scenario==-1)
_TestResult=false;
//--- reset exception
CAp::exception_happened=false;
//--- return result
return(false);
}
//--- return result
return(true);
}
//+------------------------------------------------------------------+
//| Nearest neighbor search, KNN queries |
//+------------------------------------------------------------------+
void TEST_NNeighbor_D_1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble a;
int nx;
int ny;
int normtype;
CKDTreeShell kdt;
double x[];
CMatrixDouble r;
int k;
CMatrixDouble tempmatrix;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<3;_spoil_scenario++)
{
//--- allocation
a.Resize(4,2);
//--- initialization
a[0].Set(0,0);
a[0].Set(1,0);
a[1].Set(0,0);
a[1].Set(1,1);
a[2].Set(0,1);
a[2].Set(1,0);
a[3].Set(0,1);
a[3].Set(1,1);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(a,CInfOrNaN::NegativeInfinity());
//--- change values
nx=2;
ny=0;
normtype=2;
//--- function call
CAlglib::KDTreeBuild(a,nx,ny,normtype,kdt);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x,2);
//--- initialization
x[0]=-1;
x[1]=0;
//--- function call
k=CAlglib::KDTreeQueryKNN(kdt,x,1);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(k,1);
//--- function call
CAlglib::KDTreeQueryResultsX(kdt,r);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(1,2);
//--- initialization
tempmatrix[0].Set(0,0);
tempmatrix[0].Set(1,0);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(r,tempmatrix,0.05);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","nneighbor_d_1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Subsequent queries; buffered functions must use previously |
//| allocated storage (if large enough), so buffer may contain some |
//| info from previous call |
//+------------------------------------------------------------------+
void TEST_NNeighbor_T_2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble a;
int nx;
int ny;
int normtype;
CKDTreeShell kdt;
double x[];
CMatrixDouble rx;
int k;
CMatrixDouble tempmatrix;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<3;_spoil_scenario++)
{
//--- allocation
a.Resize(4,2);
//--- initialization
a[0].Set(0,0);
a[0].Set(1,0);
a[1].Set(0,0);
a[1].Set(1,1);
a[2].Set(0,1);
a[2].Set(1,0);
a[3].Set(0,1);
a[3].Set(1,1);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(a,CInfOrNaN::NegativeInfinity());
//--- change values
nx=2;
ny=0;
normtype=2;
//--- allocation
rx.Resize(0,0);
//--- function call
CAlglib::KDTreeBuild(a,nx,ny,normtype,kdt);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x,2);
//--- initialization
x[0]=2;
x[1]=0;
//--- function call
k=CAlglib::KDTreeQueryKNN(kdt,x,2,true);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(k,2);
//--- function call
CAlglib::KDTreeQueryResultsX(kdt,rx);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(2,2);
//--- initialization
tempmatrix[0].Set(0,1);
tempmatrix[0].Set(1,0);
tempmatrix[1].Set(0,1);
tempmatrix[1].Set(1,1);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(rx,tempmatrix,0.05);
//--- allocation
ArrayResize(x,2);
//--- initialization
x[0]=-2;
x[1]=0;
//--- function call
k=CAlglib::KDTreeQueryKNN(kdt,x,1,true);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(k,1);
//--- function call
CAlglib::KDTreeQueryResultsX(kdt,rx);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(2,2);
//--- initialization
tempmatrix[0].Set(0,0);
tempmatrix[0].Set(1,0);
tempmatrix[1].Set(0,1);
tempmatrix[1].Set(1,1);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(rx,tempmatrix,0.05);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","nneighbor_t_2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Serialization of KD-trees |
//+------------------------------------------------------------------+
void TEST_NNeighbor_D_2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble a;
int nx;
int ny;
int normtype;
CKDTreeShell kdt0;
CKDTreeShell kdt1;
string s;
double x[];
CMatrixDouble r0;
CMatrixDouble r1;
CMatrixDouble tempmatrix;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<3;_spoil_scenario++)
{
//--- allocation
a.Resize(4,2);
//--- initialization
a[0].Set(0,0);
a[0].Set(1,0);
a[1].Set(0,0);
a[1].Set(1,1);
a[2].Set(0,1);
a[2].Set(1,0);
a[3].Set(0,1);
a[3].Set(1,1);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(a,CInfOrNaN::NegativeInfinity());
//--- change values
nx=2;
ny=0;
normtype=2;
//--- allocation
r0.Resize(0,0);
r1.Resize(0,0);
//--- Build tree and serialize it
CAlglib::KDTreeBuild(a,nx,ny,normtype,kdt0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::KDTreeSerialize(kdt0,s);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::KDTreeUnserialize(s,kdt1);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- Compare results from KNN queries
ArrayResize(x,2);
//--- initialization
x[0]=-1;
x[1]=0;
//--- function call
CAlglib::KDTreeQueryKNN(kdt0,x,1);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::KDTreeQueryResultsX(kdt0,r0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::KDTreeQueryKNN(kdt1,x,1);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::KDTreeQueryResultsX(kdt1,r1);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(1,2);
//--- initialization
tempmatrix[0].Set(0,0);
tempmatrix[0].Set(1,0);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(r0,tempmatrix,0.05);
//--- allocation
tempmatrix.Resize(1,2);
//--- initialization
tempmatrix[0].Set(0,0);
tempmatrix[0].Set(1,0);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(r1,tempmatrix,0.05);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","nneighbor_d_2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Basic functionality (moments,adev,median,percentile) |
//+------------------------------------------------------------------+
void TEST_BaseStat_D_Base(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double mean;
double variance;
double skewness;
double kurtosis;
double adev;
double p;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<6;_spoil_scenario++)
{
//--- allocation
ArrayResize(x,10);
//--- initialization
for(int i=0;i<10;i++)
x[i]=i*i;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- Here we demonstrate calculation of sample moments
//--- (mean,variance,skewness,kurtosis)
CAlglib::SampleMoments(x,mean,variance,skewness,kurtosis);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(mean,28.5,0.01);
_TestResult=_TestResult && Doc_Test_Real(variance,801.1667,0.01);
_TestResult=_TestResult && Doc_Test_Real(skewness,0.5751,0.01);
_TestResult=_TestResult && Doc_Test_Real(kurtosis,-1.2666,0.01);
//--- Average deviation
CAlglib::SampleAdev(x,adev);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(adev,23.2,0.01);
//--- Median and percentile
CAlglib::SampleMedian(x,v);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,20.5,0.01);
p=0.5;
//--- check
if(_spoil_scenario==3)
p=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
p=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
p=CInfOrNaN::NegativeInfinity();
//--- function call
CAlglib::SamplePercentile(x,p,v);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,20.5,0.01);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","basestat_d_base");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Correlation (covariance) between two random variables |
//+------------------------------------------------------------------+
void TEST_BaseStat_D_C2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<10;_spoil_scenario++)
{
//--- We have two samples - x and y,and want to measure dependency between them
ArrayResize(x,10);
//--- initialization
for(int i=0;i<10;i++)
x[i]=i*i;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Adding_Element(x);
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,10);
//--- initialization
for(int i=0;i<10;i++)
y[i]=i;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
//--- Three dependency measures are calculated:
//--- * covariation
//--- * Pearson correlation
//--- * Spearman rank correlation
v=CAlglib::Cov2(x,y);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,82.5,0.001);
//--- function call
v=CAlglib::PearsonCorr2(x,y);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,0.9627,0.001);
//--- function call
v=CAlglib::SpearmanCorr2(x,y);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,1.000,0.001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","basestat_d_c2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Correlation (covariance) between components of random vector |
//+------------------------------------------------------------------+
void TEST_BaseStat_D_CM(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble x;
CMatrixDouble c;
CMatrixDouble tempmatrix;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<3;_spoil_scenario++)
{
//--- X is a sample matrix:
//--- * I-th row corresponds to I-th observation
//--- * J-th column corresponds to J-th variable
x.Resize(5,3);
//--- initialization
x[0].Set(0,1);
x[0].Set(1,0);
x[0].Set(2,1);
x[1].Set(0,1);
x[1].Set(1,1);
x[1].Set(2,0);
x[2].Set(0,-1);
x[2].Set(1,1);
x[2].Set(2,0);
x[3].Set(0,-2);
x[3].Set(1,-1);
x[3].Set(2,1);
x[4].Set(0,-1);
x[4].Set(1,0);
x[4].Set(2,9);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- Three dependency measures are calculated:
//--- * covariation
//--- * Pearson correlation
//--- * Spearman rank correlation
//--- Result is stored into C,with C[i,j] equal to correlation
//--- (covariance) between I-th and J-th variables of X.
CAlglib::CovM(x,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(3,3);
//--- initialization
tempmatrix[0].Set(0,1.8);
tempmatrix[0].Set(1,0.6);
tempmatrix[0].Set(2,-1.4);
tempmatrix[1].Set(0,0.6);
tempmatrix[1].Set(1,0.7);
tempmatrix[1].Set(2,-0.8);
tempmatrix[2].Set(0,-1.4);
tempmatrix[2].Set(1,-0.8);
tempmatrix[2].Set(2,14.7);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(c,tempmatrix,0.01);
//--- function call
CAlglib::PearsonCorrM(x,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(3,3);
//--- initialization
tempmatrix[0].Set(0,1);
tempmatrix[0].Set(1,0.535);
tempmatrix[0].Set(2,-0.272);
tempmatrix[1].Set(0,0.535);
tempmatrix[1].Set(1,1);
tempmatrix[1].Set(2,-0.249);
tempmatrix[2].Set(0,-0.272);
tempmatrix[2].Set(1,-0.249);
tempmatrix[2].Set(2,1);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(c,tempmatrix,0.01);
//--- function call
CAlglib::SpearmanCorrM(x,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(3,3);
//--- initialization
tempmatrix[0].Set(0,1);
tempmatrix[0].Set(1,0.556);
tempmatrix[0].Set(2,-0.306);
tempmatrix[1].Set(0,0.556);
tempmatrix[1].Set(1,1);
tempmatrix[1].Set(2,-0.75);
tempmatrix[2].Set(0,-0.306);
tempmatrix[2].Set(1,-0.75);
tempmatrix[2].Set(2,1);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(c,tempmatrix,0.01);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","basestat_d_cm");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Correlation (covariance) between two random vectors |
//+------------------------------------------------------------------+
void TEST_BaseStat_D_CM2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble x;
CMatrixDouble y;
CMatrixDouble tempmatrix;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<6;_spoil_scenario++)
{
//--- X and Y are sample matrices:
//--- * I-th row corresponds to I-th observation
//--- * J-th column corresponds to J-th variable
x.Resize(5,3);
//--- initialization
x[0].Set(0,1);
x[0].Set(1,0);
x[0].Set(2,1);
x[1].Set(0,1);
x[1].Set(1,1);
x[1].Set(2,0);
x[2].Set(0,-1);
x[2].Set(1,1);
x[2].Set(2,0);
x[3].Set(0,-2);
x[3].Set(1,-1);
x[3].Set(2,1);
x[4].Set(0,-1);
x[4].Set(1,0);
x[4].Set(2,9);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- allocation
y.Resize(5,2);
//--- initialization
y[0].Set(0,2);
y[0].Set(1,3);
y[1].Set(0,2);
y[1].Set(1,1);
y[2].Set(0,-1);
y[2].Set(1,6);
y[3].Set(0,-9);
y[3].Set(1,9);
y[4].Set(0,7);
y[4].Set(1,1);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Value(y,CInfOrNaN::NegativeInfinity());
CMatrixDouble c;
//--- Three dependency measures are calculated:
//--- * covariation
//--- * Pearson correlation
//--- * Spearman rank correlation
//--- Result is stored into C,with C[i,j] equal to correlation
//--- (covariance) between I-th variable of X and J-th variable of Y.
CAlglib::CovM2(x,y,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(3,2);
//--- initialization
tempmatrix[0].Set(0,4.1);
tempmatrix[0].Set(1,-3.25);
tempmatrix[1].Set(0,2.45);
tempmatrix[1].Set(1,-1.5);
tempmatrix[2].Set(0,13.45);
tempmatrix[2].Set(1,-5.75);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(c,tempmatrix,0.01);
//--- function call
CAlglib::PearsonCorrM2(x,y,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(3,2);
//--- initialization
tempmatrix[0].Set(0,0.519);
tempmatrix[0].Set(1,-0.699);
tempmatrix[1].Set(0,0.497);
tempmatrix[1].Set(1,-0.518);
tempmatrix[2].Set(0,0.596);
tempmatrix[2].Set(1,-0.433);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(c,tempmatrix,0.01);
//--- function call
CAlglib::SpearmanCorrM2(x,y,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(3,2);
//--- initialization
tempmatrix[0].Set(0,0.541);
tempmatrix[0].Set(1,-0.649);
tempmatrix[1].Set(0,0.216);
tempmatrix[1].Set(1,-0.433);
tempmatrix[2].Set(0,0.433);
tempmatrix[2].Set(1,-0.135);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(c,tempmatrix,0.01);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","basestat_d_cm2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Tests ability to detect errors in inputs |
//+------------------------------------------------------------------+
void TEST_BaseStat_T_Base(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double mean;
double variance;
double skewness;
double kurtosis;
double adev;
double p;
double v;
double x1[];
double x2[];
double x3[];
double x4[];
double x5[];
double x6[];
double x7[];
double x8[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<34;_spoil_scenario++)
{
//--- first,we test short form of functions
ArrayResize(x1,10);
//--- initialization
for(int i=0;i<10;i++)
x1[i]=i*i;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x1,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x1,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x1,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::SampleMoments(x1,mean,variance,skewness,kurtosis);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x2,10);
//--- initialization
for(int i=0;i<10;i++)
x2[i]=i*i;
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Value(x2,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Value(x2,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(x2,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::SampleAdev(x2,adev);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x3,10);
//--- initialization
for(int i=0;i<10;i++)
x3[i]=i*i;
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(x3,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(x3,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Value(x3,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::SampleMedian(x3,v);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x4,10);
//--- initialization
for(int i=0;i<10;i++)
x4[i]=i*i;
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Value(x4,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(x4,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Value(x4,CInfOrNaN::NegativeInfinity());
//--- change value
p=0.5;
//--- check
if(_spoil_scenario==12)
p=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==13)
p=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==14)
p=CInfOrNaN::NegativeInfinity();
//--- function call
CAlglib::SamplePercentile(x4,p,v);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- and then we test full form
ArrayResize(x5,10);
//--- initialization
for(int i=0;i<10;i++)
x5[i]=i*i;
//--- check
if(_spoil_scenario==15)
Spoil_Vector_By_Value(x5,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==16)
Spoil_Vector_By_Value(x5,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==17)
Spoil_Vector_By_Value(x5,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==18)
Spoil_Vector_By_Deleting_Element(x5);
//--- function call
CAlglib::SampleMoments(x5,10,mean,variance,skewness,kurtosis);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x6,10);
//--- initialization
for(int i=0;i<10;i++)
x6[i]=i*i;
//--- check
if(_spoil_scenario==19)
Spoil_Vector_By_Value(x6,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==20)
Spoil_Vector_By_Value(x6,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==21)
Spoil_Vector_By_Value(x6,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==22)
Spoil_Vector_By_Deleting_Element(x6);
//--- function call
CAlglib::SampleAdev(x6,10,adev);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x7,10);
//--- initialization
for(int i=0;i<10;i++)
x7[i]=i*i;
//--- check
if(_spoil_scenario==23)
Spoil_Vector_By_Value(x7,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==24)
Spoil_Vector_By_Value(x7,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==25)
Spoil_Vector_By_Value(x7,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==26)
Spoil_Vector_By_Deleting_Element(x7);
//--- function call
CAlglib::SampleMedian(x7,10,v);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x8,10);
//--- initialization
for(int i=0;i<10;i++)
x8[i]=i*i;
//--- check
if(_spoil_scenario==27)
Spoil_Vector_By_Value(x8,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==28)
Spoil_Vector_By_Value(x8,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==29)
Spoil_Vector_By_Value(x8,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==30)
Spoil_Vector_By_Deleting_Element(x8);
//--- change value
p=0.5;
//--- check
if(_spoil_scenario==31)
p=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==32)
p=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==33)
p=CInfOrNaN::NegativeInfinity();
//--- function call
CAlglib::SamplePercentile(x8,10,p,v);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","basestat_t_base");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Tests ability to detect errors in inputs |
//+------------------------------------------------------------------+
void TEST_BaseStat_T_CovCorr(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double v;
CMatrixDouble c;
double x1[];
double x2[];
double x3[];
double y1[];
double y2[];
double y3[];
double x1a[];
double x2a[];
double x3a[];
double y1a[];
double y2a[];
double y3a[];
CMatrixDouble x4;
CMatrixDouble x5;
CMatrixDouble x6;
CMatrixDouble x7;
CMatrixDouble x8;
CMatrixDouble x9;
CMatrixDouble x10;
CMatrixDouble x11;
CMatrixDouble x12;
CMatrixDouble x13;
CMatrixDouble x14;
CMatrixDouble x15;
CMatrixDouble y10;
CMatrixDouble y11;
CMatrixDouble y12;
CMatrixDouble y13;
CMatrixDouble y14;
CMatrixDouble y15;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<126;_spoil_scenario++)
{
//--- 2-sample short-form cov/corr are tested
ArrayResize(x1,10);
//--- initialization
for(int i=0;i<10;i++)
x1[i]=i*i;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x1,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x1,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x1,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Adding_Element(x1);
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(x1);
//--- allocation
ArrayResize(y1,10);
//--- initialization
for(int i=0;i<10;i++)
y1[i]=i;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y1,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y1,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y1,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y1);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y1);
//--- function call
v=CAlglib::Cov2(x1,y1);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x2,10);
//--- initialization
for(int i=0;i<10;i++)
x2[i]=i*i;
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(x2,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Value(x2,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Value(x2,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==13)
Spoil_Vector_By_Adding_Element(x2);
//--- check
if(_spoil_scenario==14)
Spoil_Vector_By_Deleting_Element(x2);
//--- allocation
ArrayResize(y2,10);
//--- initialization
for(int i=0;i<10;i++)
y2[i]=i;
//--- check
if(_spoil_scenario==15)
Spoil_Vector_By_Value(y2,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==16)
Spoil_Vector_By_Value(y2,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==17)
Spoil_Vector_By_Value(y2,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==18)
Spoil_Vector_By_Adding_Element(y2);
//--- check
if(_spoil_scenario==19)
Spoil_Vector_By_Deleting_Element(y2);
//--- function call
v=CAlglib::PearsonCorr2(x2,y2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x3,10);
//--- initialization
for(int i=0;i<10;i++)
x3[i]=i*i;
//--- check
if(_spoil_scenario==20)
Spoil_Vector_By_Value(x3,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==21)
Spoil_Vector_By_Value(x3,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==22)
Spoil_Vector_By_Value(x3,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==23)
Spoil_Vector_By_Adding_Element(x3);
//--- check
if(_spoil_scenario==24)
Spoil_Vector_By_Deleting_Element(x3);
//--- allocation
ArrayResize(y3,10);
//--- initialization
for(int i=0;i<10;i++)
y3[i]=i;
//--- check
if(_spoil_scenario==25)
Spoil_Vector_By_Value(y3,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==26)
Spoil_Vector_By_Value(y3,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==27)
Spoil_Vector_By_Value(y3,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==28)
Spoil_Vector_By_Adding_Element(y3);
//--- check
if(_spoil_scenario==29)
Spoil_Vector_By_Deleting_Element(y3);
//--- function call
v=CAlglib::SpearmanCorr2(x3,y3);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- 2-sample full-form cov/corr are tested
ArrayResize(x1a,10);
//--- initialization
for(int i=0;i<10;i++)
x1a[i]=i*i;
//--- check
if(_spoil_scenario==30)
Spoil_Vector_By_Value(x1a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==31)
Spoil_Vector_By_Value(x1a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==32)
Spoil_Vector_By_Value(x1a,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==33)
Spoil_Vector_By_Deleting_Element(x1a);
//--- allocation
ArrayResize(y1a,10);
//--- initialization
for(int i=0;i<10;i++)
y1a[i]=i;
//--- check
if(_spoil_scenario==34)
Spoil_Vector_By_Value(y1a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==35)
Spoil_Vector_By_Value(y1a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==36)
Spoil_Vector_By_Value(y1a,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==37)
Spoil_Vector_By_Deleting_Element(y1a);
//--- function call
v=CAlglib::Cov2(x1a,y1a,10);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x2a,10);
//--- initialization
for(int i=0;i<10;i++)
x2a[i]=i*i;
//--- check
if(_spoil_scenario==38)
Spoil_Vector_By_Value(x2a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==39)
Spoil_Vector_By_Value(x2a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==40)
Spoil_Vector_By_Value(x2a,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==41)
Spoil_Vector_By_Deleting_Element(x2a);
//--- allocation
ArrayResize(y2a,10);
//--- initialization
for(int i=0;i<10;i++)
y2a[i]=i;
//--- check
if(_spoil_scenario==42)
Spoil_Vector_By_Value(y2a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==43)
Spoil_Vector_By_Value(y2a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==44)
Spoil_Vector_By_Value(y2a,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==45)
Spoil_Vector_By_Deleting_Element(y2a);
//--- function call
v=CAlglib::PearsonCorr2(x2a,y2a,10);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(x3a,10);
//--- initialization
for(int i=0;i<10;i++)
x3a[i]=i*i;
//--- check
if(_spoil_scenario==46)
Spoil_Vector_By_Value(x3a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==47)
Spoil_Vector_By_Value(x3a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==48)
Spoil_Vector_By_Value(x3a,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==49)
Spoil_Vector_By_Deleting_Element(x3a);
//--- allocation
ArrayResize(y3a,10);
//--- initialization
for(int i=0;i<10;i++)
y3a[i]=i;
//--- check
if(_spoil_scenario==50)
Spoil_Vector_By_Value(y3a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==51)
Spoil_Vector_By_Value(y3a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==52)
Spoil_Vector_By_Value(y3a,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==53)
Spoil_Vector_By_Deleting_Element(y3a);
//--- function call
v=CAlglib::SpearmanCorr2(x3a,y3a,10);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- vector short-form cov/corr are tested.
x4.Resize(5,3);
//--- initialization
x4[0].Set(0,1);
x4[0].Set(1,0);
x4[0].Set(2,1);
x4[1].Set(0,1);
x4[1].Set(1,1);
x4[1].Set(2,0);
x4[2].Set(0,-1);
x4[2].Set(1,1);
x4[2].Set(2,0);
x4[3].Set(0,-2);
x4[3].Set(1,-1);
x4[3].Set(2,1);
x4[4].Set(0,-1);
x4[4].Set(1,0);
x4[4].Set(2,9);
//--- check
if(_spoil_scenario==54)
Spoil_Matrix_By_Value(x4,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==55)
Spoil_Matrix_By_Value(x4,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==56)
Spoil_Matrix_By_Value(x4,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::CovM(x4,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
x5.Resize(5,3);
//--- initialization
x5[0].Set(0,1);
x5[0].Set(1,0);
x5[0].Set(2,1);
x5[1].Set(0,1);
x5[1].Set(1,1);
x5[1].Set(2,0);
x5[2].Set(0,-1);
x5[2].Set(1,1);
x5[2].Set(2,0);
x5[3].Set(0,-2);
x5[3].Set(1,-1);
x5[3].Set(2,1);
x5[4].Set(0,-1);
x5[4].Set(1,0);
x5[4].Set(2,9);
//--- check
if(_spoil_scenario==57)
Spoil_Matrix_By_Value(x5,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==58)
Spoil_Matrix_By_Value(x5,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==59)
Spoil_Matrix_By_Value(x5,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::PearsonCorrM(x5,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
x6.Resize(5,3);
//--- initialization
x6[0].Set(0,1);
x6[0].Set(1,0);
x6[0].Set(2,1);
x6[1].Set(0,1);
x6[1].Set(1,1);
x6[1].Set(2,0);
x6[2].Set(0,-1);
x6[2].Set(1,1);
x6[2].Set(2,0);
x6[3].Set(0,-2);
x6[3].Set(1,-1);
x6[3].Set(2,1);
x6[4].Set(0,-1);
x6[4].Set(1,0);
x6[4].Set(2,9);
//--- check
if(_spoil_scenario==60)
Spoil_Matrix_By_Value(x6,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==61)
Spoil_Matrix_By_Value(x6,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==62)
Spoil_Matrix_By_Value(x6,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::SpearmanCorrM(x6,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- vector full-form cov/corr are tested.
x7.Resize(5,3);
//--- initialization
x7[0].Set(0,1);
x7[0].Set(1,0);
x7[0].Set(2,1);
x7[1].Set(0,1);
x7[1].Set(1,1);
x7[1].Set(2,0);
x7[2].Set(0,-1);
x7[2].Set(1,1);
x7[2].Set(2,0);
x7[3].Set(0,-2);
x7[3].Set(1,-1);
x7[3].Set(2,1);
x7[4].Set(0,-1);
x7[4].Set(1,0);
x7[4].Set(2,9);
//--- check
if(_spoil_scenario==63)
Spoil_Matrix_By_Value(x7,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==64)
Spoil_Matrix_By_Value(x7,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==65)
Spoil_Matrix_By_Value(x7,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==66)
Spoil_Matrix_By_Deleting_Row(x7);
//--- check
if(_spoil_scenario==67)
Spoil_Matrix_By_Deleting_Col(x7);
//--- function call
CAlglib::CovM(x7,5,3,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
x8.Resize(5,3);
//--- initialization
x8[0].Set(0,1);
x8[0].Set(1,0);
x8[0].Set(2,1);
x8[1].Set(0,1);
x8[1].Set(1,1);
x8[1].Set(2,0);
x8[2].Set(0,-1);
x8[2].Set(1,1);
x8[2].Set(2,0);
x8[3].Set(0,-2);
x8[3].Set(1,-1);
x8[3].Set(2,1);
x8[4].Set(0,-1);
x8[4].Set(1,0);
x8[4].Set(2,9);
//--- check
if(_spoil_scenario==68)
Spoil_Matrix_By_Value(x8,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==69)
Spoil_Matrix_By_Value(x8,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==70)
Spoil_Matrix_By_Value(x8,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==71)
Spoil_Matrix_By_Deleting_Row(x8);
//--- check
if(_spoil_scenario==72)
Spoil_Matrix_By_Deleting_Col(x8);
//--- function call
CAlglib::PearsonCorrM(x8,5,3,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
x9.Resize(5,3);
//--- initialization
x9[0].Set(0,1);
x9[0].Set(1,0);
x9[0].Set(2,1);
x9[1].Set(0,1);
x9[1].Set(1,1);
x9[1].Set(2,0);
x9[2].Set(0,-1);
x9[2].Set(1,1);
x9[2].Set(2,0);
x9[3].Set(0,-2);
x9[3].Set(1,-1);
x9[3].Set(2,1);
x9[4].Set(0,-1);
x9[4].Set(1,0);
x9[4].Set(2,9);
//--- check
if(_spoil_scenario==73)
Spoil_Matrix_By_Value(x9,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==74)
Spoil_Matrix_By_Value(x9,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==75)
Spoil_Matrix_By_Value(x9,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==76)
Spoil_Matrix_By_Deleting_Row(x9);
//--- check
if(_spoil_scenario==77)
Spoil_Matrix_By_Deleting_Col(x9);
//--- function call
CAlglib::SpearmanCorrM(x9,5,3,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- cross-vector short-form cov/corr are tested.
x10.Resize(5,3);
//--- initialization
x10[0].Set(0,1);
x10[0].Set(1,0);
x10[0].Set(2,1);
x10[1].Set(0,1);
x10[1].Set(1,1);
x10[1].Set(2,0);
x10[2].Set(0,-1);
x10[2].Set(1,1);
x10[2].Set(2,0);
x10[3].Set(0,-2);
x10[3].Set(1,-1);
x10[3].Set(2,1);
x10[4].Set(0,-1);
x10[4].Set(1,0);
x10[4].Set(2,9);
//--- check
if(_spoil_scenario==78)
Spoil_Matrix_By_Value(x10,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==79)
Spoil_Matrix_By_Value(x10,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==80)
Spoil_Matrix_By_Value(x10,CInfOrNaN::NegativeInfinity());
//--- allocation
y10.Resize(5,2);
//--- initialization
y10[0].Set(0,2);
y10[0].Set(1,3);
y10[1].Set(0,2);
y10[1].Set(1,1);
y10[2].Set(0,-1);
y10[2].Set(1,6);
y10[3].Set(0,-9);
y10[3].Set(1,9);
y10[4].Set(0,7);
y10[4].Set(1,1);
//--- check
if(_spoil_scenario==81)
Spoil_Matrix_By_Value(y10,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==82)
Spoil_Matrix_By_Value(y10,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==83)
Spoil_Matrix_By_Value(y10,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::CovM2(x10,y10,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
x11.Resize(5,3);
//--- initialization
x11[0].Set(0,1);
x11[0].Set(1,0);
x11[0].Set(2,1);
x11[1].Set(0,1);
x11[1].Set(1,1);
x11[1].Set(2,0);
x11[2].Set(0,-1);
x11[2].Set(1,1);
x11[2].Set(2,0);
x11[3].Set(0,-2);
x11[3].Set(1,-1);
x11[3].Set(2,1);
x11[4].Set(0,-1);
x11[4].Set(1,0);
x11[4].Set(2,9);
//--- check
if(_spoil_scenario==84)
Spoil_Matrix_By_Value(x11,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==85)
Spoil_Matrix_By_Value(x11,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==86)
Spoil_Matrix_By_Value(x11,CInfOrNaN::NegativeInfinity());
//--- allocation
y11.Resize(5,2);
//--- initialization
y11[0].Set(0,2);
y11[0].Set(1,3);
y11[1].Set(0,2);
y11[1].Set(1,1);
y11[2].Set(0,-1);
y11[2].Set(1,6);
y11[3].Set(0,-9);
y11[3].Set(1,9);
y11[4].Set(0,7);
y11[4].Set(1,1);
//--- check
if(_spoil_scenario==87)
Spoil_Matrix_By_Value(y11,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==88)
Spoil_Matrix_By_Value(y11,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==89)
Spoil_Matrix_By_Value(y11,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::PearsonCorrM2(x11,y11,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
x12.Resize(5,3);
//--- initialization
x12[0].Set(0,1);
x12[0].Set(1,0);
x12[0].Set(2,1);
x12[1].Set(0,1);
x12[1].Set(1,1);
x12[1].Set(2,0);
x12[2].Set(0,-1);
x12[2].Set(1,1);
x12[2].Set(2,0);
x12[3].Set(0,-2);
x12[3].Set(1,-1);
x12[3].Set(2,1);
x12[4].Set(0,-1);
x12[4].Set(1,0);
x12[4].Set(2,9);
//--- check
if(_spoil_scenario==90)
Spoil_Matrix_By_Value(x12,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==91)
Spoil_Matrix_By_Value(x12,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==92)
Spoil_Matrix_By_Value(x12,CInfOrNaN::NegativeInfinity());
//--- allocation
y12.Resize(5,2);
//--- initialization
y12[0].Set(0,2);
y12[0].Set(1,3);
y12[1].Set(0,2);
y12[1].Set(1,1);
y12[2].Set(0,-1);
y12[2].Set(1,6);
y12[3].Set(0,-9);
y12[3].Set(1,9);
y12[4].Set(0,7);
y12[4].Set(1,1);
//--- check
if(_spoil_scenario==93)
Spoil_Matrix_By_Value(y12,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==94)
Spoil_Matrix_By_Value(y12,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==95)
Spoil_Matrix_By_Value(y12,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::SpearmanCorrM2(x12,y12,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- cross-vector full-form cov/corr are tested.
x13.Resize(5,3);
//--- initialization
x13[0].Set(0,1);
x13[0].Set(1,0);
x13[0].Set(2,1);
x13[1].Set(0,1);
x13[1].Set(1,1);
x13[1].Set(2,0);
x13[2].Set(0,-1);
x13[2].Set(1,1);
x13[2].Set(2,0);
x13[3].Set(0,-2);
x13[3].Set(1,-1);
x13[3].Set(2,1);
x13[4].Set(0,-1);
x13[4].Set(1,0);
x13[4].Set(2,9);
//--- check
if(_spoil_scenario==96)
Spoil_Matrix_By_Value(x13,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==97)
Spoil_Matrix_By_Value(x13,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==98)
Spoil_Matrix_By_Value(x13,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==99)
Spoil_Matrix_By_Deleting_Row(x13);
//--- check
if(_spoil_scenario==100)
Spoil_Matrix_By_Deleting_Col(x13);
//--- allocation
y13.Resize(5,2);
//--- initialization
y13[0].Set(0,2);
y13[0].Set(1,3);
y13[1].Set(0,2);
y13[1].Set(1,1);
y13[2].Set(0,-1);
y13[2].Set(1,6);
y13[3].Set(0,-9);
y13[3].Set(1,9);
y13[4].Set(0,7);
y13[4].Set(1,1);
//--- check
if(_spoil_scenario==101)
Spoil_Matrix_By_Value(y13,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==102)
Spoil_Matrix_By_Value(y13,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==103)
Spoil_Matrix_By_Value(y13,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==104)
Spoil_Matrix_By_Deleting_Row(y13);
//--- check
if(_spoil_scenario==105)
Spoil_Matrix_By_Deleting_Col(y13);
//--- function call
CAlglib::CovM2(x13,y13,5,3,2,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
x14.Resize(5,3);
//--- initialization
x14[0].Set(0,1);
x14[0].Set(1,0);
x14[0].Set(2,1);
x14[1].Set(0,1);
x14[1].Set(1,1);
x14[1].Set(2,0);
x14[2].Set(0,-1);
x14[2].Set(1,1);
x14[2].Set(2,0);
x14[3].Set(0,-2);
x14[3].Set(1,-1);
x14[3].Set(2,1);
x14[4].Set(0,-1);
x14[4].Set(1,0);
x14[4].Set(2,9);
//--- check
if(_spoil_scenario==106)
Spoil_Matrix_By_Value(x14,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==107)
Spoil_Matrix_By_Value(x14,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==108)
Spoil_Matrix_By_Value(x14,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==109)
Spoil_Matrix_By_Deleting_Row(x14);
//--- check
if(_spoil_scenario==110)
Spoil_Matrix_By_Deleting_Col(x14);
//--- allocation
y14.Resize(5,2);
//--- initialization
y14[0].Set(0,2);
y14[0].Set(1,3);
y14[1].Set(0,2);
y14[1].Set(1,1);
y14[2].Set(0,-1);
y14[2].Set(1,6);
y14[3].Set(0,-9);
y14[3].Set(1,9);
y14[4].Set(0,7);
y14[4].Set(1,1);
//--- check
if(_spoil_scenario==111)
Spoil_Matrix_By_Value(y14,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==112)
Spoil_Matrix_By_Value(y14,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==113)
Spoil_Matrix_By_Value(y14,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==114)
Spoil_Matrix_By_Deleting_Row(y14);
//--- check
if(_spoil_scenario==115)
Spoil_Matrix_By_Deleting_Col(y14);
//--- function call
CAlglib::PearsonCorrM2(x14,y14,5,3,2,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
x15.Resize(5,3);
//--- initialization
x15[0].Set(0,1);
x15[0].Set(1,0);
x15[0].Set(2,1);
x15[1].Set(0,1);
x15[1].Set(1,1);
x15[1].Set(2,0);
x15[2].Set(0,-1);
x15[2].Set(1,1);
x15[2].Set(2,0);
x15[3].Set(0,-2);
x15[3].Set(1,-1);
x15[3].Set(2,1);
x15[4].Set(0,-1);
x15[4].Set(1,0);
x15[4].Set(2,9);
//--- check
if(_spoil_scenario==116)
Spoil_Matrix_By_Value(x15,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==117)
Spoil_Matrix_By_Value(x15,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==118)
Spoil_Matrix_By_Value(x15,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==119)
Spoil_Matrix_By_Deleting_Row(x15);
//--- check
if(_spoil_scenario==120)
Spoil_Matrix_By_Deleting_Col(x15);
//--- allocation
y15.Resize(5,2);
//--- initialization
y15[0].Set(0,2);
y15[0].Set(1,3);
y15[1].Set(0,2);
y15[1].Set(1,1);
y15[2].Set(0,-1);
y15[2].Set(1,6);
y15[3].Set(0,-9);
y15[3].Set(1,9);
y15[4].Set(0,7);
y15[4].Set(1,1);
//--- check
if(_spoil_scenario==121)
Spoil_Matrix_By_Value(y15,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==122)
Spoil_Matrix_By_Value(y15,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==123)
Spoil_Matrix_By_Value(y15,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==124)
Spoil_Matrix_By_Deleting_Row(y15);
//--- check
if(_spoil_scenario==125)
Spoil_Matrix_By_Deleting_Col(y15);
//--- function call
CAlglib::SpearmanCorrM2(x15,y15,5,3,2,c);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","basestat_t_covcorr");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Real matrix inverse |
//+------------------------------------------------------------------+
void TEST_MatInv_D_R1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble a;
CMatrixDouble tempmatrix;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<7;_spoil_scenario++)
{
//--- allocation
a.Resize(2,2);
//--- initialization
a[0].Set(0,1);
a[0].Set(1,-1);
a[1].Set(0,1);
a[1].Set(1,1);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(a,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Adding_Row(a);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Adding_Col(a);
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Deleting_Row(a);
//--- check
if(_spoil_scenario==6)
Spoil_Matrix_By_Deleting_Col(a);
//--- create variables
int info;
CMatInvReportShell rep;
//--- function call
CAlglib::RMatrixInverse(a,info,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(2,2);
//--- initialization
tempmatrix[0].Set(0,0.5);
tempmatrix[0].Set(1,0.5);
tempmatrix[1].Set(0,-0.5);
tempmatrix[1].Set(1,0.5);
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,1);
_TestResult=_TestResult && Doc_Test_Real_Matrix(a,tempmatrix,0.00005);
_TestResult=_TestResult && Doc_Test_Real(rep.GetR1(),0.5,0.00005);
_TestResult=_TestResult && Doc_Test_Real(rep.GetRInf(),0.5,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matinv_d_r1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Complex matrix inverse |
//+------------------------------------------------------------------+
void TEST_MatInv_D_C1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixComplex a;
CMatrixComplex tempmatrix;
complex tempcomplex1;
complex tempcomplex2;
complex cnan;
complex cpositiveinfinity;
complex cnegativeinfinity;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<7;_spoil_scenario++)
{
//--- initialization
cnan.re=CInfOrNaN::NaN();
cnan.im=CInfOrNaN::NaN();
cpositiveinfinity.re=CInfOrNaN::PositiveInfinity();
cpositiveinfinity.im=CInfOrNaN::PositiveInfinity();
cnegativeinfinity.re=CInfOrNaN::NegativeInfinity();
cnegativeinfinity.im=CInfOrNaN::NegativeInfinity();
//--- initialization
tempcomplex1.re=0;
tempcomplex1.im=1;
tempcomplex2.re=0;
tempcomplex2.im=-0.5;
//--- allocation
a.Resize(2,2);
//--- initialization
a[0].Set(0,tempcomplex1);
a[0].Set(1,-1);
a[1].Set(0,tempcomplex1);
a[1].Set(1,1);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(a,cnan);
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(a,cpositiveinfinity);
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(a,cnegativeinfinity);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Adding_Row(a);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Adding_Col(a);
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Deleting_Row(a);
//--- check
if(_spoil_scenario==6)
Spoil_Matrix_By_Deleting_Col(a);
//--- create variables
int info;
CMatInvReportShell rep;
//--- function call
CAlglib::CMatrixInverse(a,info,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(2,2);
//--- initialization
tempmatrix[0].Set(0,tempcomplex2);
tempmatrix[0].Set(1,tempcomplex2);
tempmatrix[1].Set(0,-0.5);
tempmatrix[1].Set(1,0.5);
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,1);
_TestResult=_TestResult && Doc_Test_Complex_Matrix(a,tempmatrix,0.00005);
_TestResult=_TestResult && Doc_Test_Real(rep.GetR1(),0.5,0.00005);
_TestResult=_TestResult && Doc_Test_Real(rep.GetRInf(),0.5,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matinv_d_c1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| SPD matrix inverse |
//+------------------------------------------------------------------+
void TEST_MatInv_D_SPD1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble a;
CMatrixDouble tempmatrix;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<7;_spoil_scenario++)
{
//--- allocation
a.Resize(2,2);
//--- initialization
a[0].Set(0,2);
a[0].Set(1,1);
a[1].Set(0,1);
a[1].Set(1,2);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(a,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Adding_Row(a);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Adding_Col(a);
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Deleting_Row(a);
//--- check
if(_spoil_scenario==6)
Spoil_Matrix_By_Deleting_Col(a);
//--- create variables
int info;
CMatInvReportShell rep;
//--- function call
CAlglib::SPDMatrixInverse(a,info,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(2,2);
//--- initialization
tempmatrix[0].Set(0,0.666666);
tempmatrix[0].Set(1,-0.333333);
tempmatrix[1].Set(0,-0.333333);
tempmatrix[1].Set(1,0.666666);
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,1);
_TestResult=_TestResult && Doc_Test_Real_Matrix(a,tempmatrix,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matinv_d_spd1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| HPD matrix inverse |
//+------------------------------------------------------------------+
void TEST_MatInv_D_HPD1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixComplex a;
CMatrixComplex tempmatrix;
complex cnan;
complex cpositiveinfinity;
complex cnegativeinfinity;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<7;_spoil_scenario++)
{
//--- allocation
a.Resize(2,2);
//--- initialization
a[0].Set(0,2);
a[0].Set(1,1);
a[1].Set(0,1);
a[1].Set(1,2);
//--- initialization
cnan.re=CInfOrNaN::NaN();
cnan.im=CInfOrNaN::NaN();
cpositiveinfinity.re=CInfOrNaN::PositiveInfinity();
cpositiveinfinity.im=CInfOrNaN::PositiveInfinity();
cnegativeinfinity.re=CInfOrNaN::NegativeInfinity();
cnegativeinfinity.im=CInfOrNaN::NegativeInfinity();
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(a,cnan);
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(a,cpositiveinfinity);
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(a,cnegativeinfinity);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Adding_Row(a);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Adding_Col(a);
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Deleting_Row(a);
//--- check
if(_spoil_scenario==6)
Spoil_Matrix_By_Deleting_Col(a);
//--- create variables
int info;
CMatInvReportShell rep;
//--- function call
CAlglib::HPDMatrixInverse(a,info,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
tempmatrix.Resize(2,2);
//--- initialization
tempmatrix[0].Set(0,0.666666);
tempmatrix[0].Set(1,-0.333333);
tempmatrix[1].Set(0,-0.333333);
tempmatrix[1].Set(1,0.666666);
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,1);
_TestResult=_TestResult && Doc_Test_Complex_Matrix(a,tempmatrix,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matinv_d_hpd1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Real matrix inverse: singular matrix |
//+------------------------------------------------------------------+
void TEST_MatInv_T_R1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble a;
//--- allocation
a.Resize(2,2);
//--- initialization
a[0].Set(0,1);
a[0].Set(1,-1);
a[1].Set(0,-2);
a[1].Set(1,2);
//--- create variables
int info;
CMatInvReportShell rep;
//--- function call
CAlglib::RMatrixInverse(a,info,rep);
//--- handling exceptions
Func_spoil_scenario(_spoil_scenario,_TestResult);
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,-3);
_TestResult=_TestResult && Doc_Test_Real(rep.GetR1(),0.0,0.00005);
_TestResult=_TestResult && Doc_Test_Real(rep.GetRInf(),0.0,0.00005);
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matinv_t_r1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Complex matrix inverse: singular matrix |
//+------------------------------------------------------------------+
void TEST_MatInv_T_C1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
CMatrixComplex a;
complex tempcomplex1;
complex tempcomplex2;
_TestResult=true;
//--- create variables
tempcomplex1.re=0;
tempcomplex1.im=1;
tempcomplex2.re=0;
tempcomplex2.im=-1;
//--- allocation
a.Resize(2,2);
//--- initialization
a[0].Set(0,tempcomplex1);
a[0].Set(1,tempcomplex2);
a[1].Set(0,-2);
a[1].Set(1,2);
//--- create variables
int info;
CMatInvReportShell rep;
//--- function call
CAlglib::CMatrixInverse(a,info,rep);
//--- handling exceptions
Func_spoil_scenario(_spoil_scenario,_TestResult);
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,-3);
_TestResult=_TestResult && Doc_Test_Real(rep.GetR1(),0.0,0.00005);
_TestResult=_TestResult && Doc_Test_Real(rep.GetRInf(),0.0,0.00005);
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matinv_t_c1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Attempt to use SPD function on nonsymmetrix matrix |
//+------------------------------------------------------------------+
void TEST_MatInv_E_SPD1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble a;
//--- allocation
a.Resize(2,2);
//--- initialization
a[0].Set(0,1);
a[0].Set(1,0);
a[1].Set(0,1);
a[1].Set(1,1);
//--- create variables
int info;
CMatInvReportShell rep;
//--- function call
CAlglib::SPDMatrixInverse(a,info,rep);
//--- handling exceptions
if(Func_spoil_scenario(_spoil_scenario,_TestResult))
_TestResult=false;
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matinv_e_spd1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Attempt to use SPD function on nonsymmetrix matrix |
//+------------------------------------------------------------------+
void TEST_MatInv_E_HPD1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixComplex a;
//--- allocation
a.Resize(2,2);
//--- initialization
a[0].Set(0,1);
a[0].Set(1,0);
a[1].Set(0,1);
a[1].Set(1,1);
//--- create variables
int info;
CMatInvReportShell rep;
//--- function call
CAlglib::HPDMatrixInverse(a,info,rep);
//--- handling exceptions
if(Func_spoil_scenario(_spoil_scenario,_TestResult))
_TestResult=false;
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matinv_e_hpd1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization by CG |
//+------------------------------------------------------------------+
void TEST_MinCG_D_1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_Grad1 fgrad;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x,y)=100*(x+3)^4+(y-3)^4
//--- with nonlinear conjugate gradient method.
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- create a variable
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
//--- create a variable
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
//--- create a variable
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
int maxits=0;
//--- create variables
CMinCGStateShell state;
CMinCGReportShell rep;
//--- function call
CAlglib::MinCGCreate(x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGOptimize(state,fgrad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","mincg_d_1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization with additional settings and restarts |
//+------------------------------------------------------------------+
void TEST_MinCG_D_2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_Grad1 fgrad;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<18;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x,y)=100*(x+3)^4+(y-3)^4
//--- with nonlinear conjugate gradient method.
//--- Several advanced techniques are demonstrated:
//--- * upper limit on step size
//--- * restart from new point
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
double stpmax=0.1;
//--- check
if(_spoil_scenario==12)
stpmax=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==13)
stpmax=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==14)
stpmax=CInfOrNaN::NegativeInfinity();
int maxits=0;
//--- create variables
CMinCGStateShell state;
CMinCGReportShell rep;
//--- first run
CAlglib::MinCGCreate(x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGSetStpMax(state,stpmax);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGOptimize(state,fgrad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
//--- second run - algorithm is restarted with mincgrestartfrom()
ArrayResize(x,2);
//--- initialization
x[0]=10;
x[1]=10;
//--- check
if(_spoil_scenario==15)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==16)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==17)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::MinCGRestartFrom(state,x);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGOptimize(state,fgrad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","mincg_d_2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization by CG with numerical differentiation |
//+------------------------------------------------------------------+
void TEST_MinCG_NumDiff(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_Func1 ffunc;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<15;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x,y)=100*(x+3)^4+(y-3)^4
//--- using numerical differentiation to calculate gradient.
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
double diffstep=1.0e-6;
//--- check
if(_spoil_scenario==12)
diffstep=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==13)
diffstep=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==14)
diffstep=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
CMinCGStateShell state;
CMinCGReportShell rep;
//--- function call
CAlglib::MinCGCreateF(x,diffstep,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGOptimize(state,ffunc,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","mincg_numdiff");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization by CG, function with singularities |
//+------------------------------------------------------------------+
void TEST_MinCG_FTRIM(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_S1_Grad fs1grad;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x)=(1+x)^(-0.2) + (1-x)^(-0.3) + 1000*x.
//--- This function has singularities at the boundary of the [-1,+1],but technique called
//--- "function trimming" allows us to solve this optimization problem.
//--- See http://www.CAlglib::net/optimization/tipsandtricks.php#ftrimming for more information
//--- on this subject.
ArrayResize(x,1);
//--- initialization
x[0]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=1.0e-6;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
CMinCGStateShell state;
CMinCGReportShell rep;
//--- function call
CAlglib::MinCGCreate(x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGOptimize(state,fs1grad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinCGResults(state,x,rep);
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=-0.99917305;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.000005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","mincg_ftrim");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization with bound constraints |
//+------------------------------------------------------------------+
void TEST_MinBLEIC_D_1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
double bndl[];
double bndu[];
CObject obj;
CNDimensional_Grad1 fgrad;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<22;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x,y)=100*(x+3)^4+(y-3)^4
//--- subject to bound constraints -1<=x<=+1,-1<=y<=+1,using BLEIC optimizer.
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- allocation
ArrayResize(bndl,2);
//--- initialization
bndl[0]=-1;
bndl[1]=-1;
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Value(bndl,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(bndl);
//--- allocation
ArrayResize(bndu,2);
//--- initialization
bndu[0]=1;
bndu[1]=1;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(bndu,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Deleting_Element(bndu);
CMinBLEICStateShell state;
CMinBLEICReportShell rep;
//--- These variables define stopping conditions for the underlying CG algorithm.
//--- They should be stringent enough in order to guarantee overall stability
//--- of the outer iterations.
//--- We use very simple condition - |g|<=epsg
double epsg=0.000001;
//--- check
if(_spoil_scenario==7)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==8)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==9)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==10)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==11)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==12)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==13)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==14)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==15)
epsx=CInfOrNaN::NegativeInfinity();
//--- These variables define stopping conditions for the outer iterations:
//--- * epso controls convergence of outer iterations;algorithm will stop
//--- when difference between solutions of subsequent unconstrained problems
//--- will be less than 0.0001
//--- * epsi controls amount of infeasibility allowed in the final solution
double epso=0.00001;
//--- check
if(_spoil_scenario==16)
epso=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==17)
epso=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==18)
epso=CInfOrNaN::NegativeInfinity();
double epsi=0.00001;
//--- check
if(_spoil_scenario==19)
epsi=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==20)
epsi=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==21)
epsi=CInfOrNaN::NegativeInfinity();
//--- Now we are ready to actually optimize something:
//--- * first we create optimizer
//--- * we add boundary constraints
//--- * we tune stopping conditions
//--- * and,finally,optimize and obtain results...
CAlglib::MinBLEICCreate(x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICSetBC(state,bndl,bndu);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICSetInnerCond(state,epsg,epsf,epsx);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICSetOuterCond(state,epso,epsi);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICOptimize(state,fgrad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- ...and evaluate these results
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-1;
temparray[1]=1;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minbleic_d_1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization with linear inequality constraints |
//+------------------------------------------------------------------+
void TEST_MinBLEIC_D_2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
int ct[];
CMatrixDouble c;
CObject obj;
CNDimensional_Grad1 fgrad;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<24;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x,y)=100*(x+3)^4+(y-3)^4
//--- subject to inequality constraints:
//--- * x>=2 (posed as general linear constraint),
//--- * x+y>=6
//--- using BLEIC optimizer.
ArrayResize(x,2);
//--- initialization
x[0]=5;
x[1]=5;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- allocation
c.Resize(2,3);
//--- initialization
c[0].Set(0,1);
c[0].Set(1,0);
c[0].Set(2,2);
c[1].Set(0,1);
c[1].Set(1,1);
c[1].Set(2,6);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Value(c,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Value(c,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Value(c,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==6)
Spoil_Matrix_By_Deleting_Row(c);
//--- check
if(_spoil_scenario==7)
Spoil_Matrix_By_Deleting_Col(c);
//--- allocation
ArrayResize(ct,2);
//--- initialization
ct[0]=1;
ct[1]=1;
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Deleting_Element(ct);
//--- create variables
CMinBLEICStateShell state;
CMinBLEICReportShell rep;
//--- These variables define stopping conditions for the underlying CG algorithm.
//--- They should be stringent enough in order to guarantee overall stability
//--- of the outer iterations.
//--- We use very simple condition - |g|<=epsg
double epsg=0.000001;
//--- check
if(_spoil_scenario==9)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==12)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==13)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==14)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==15)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==16)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==17)
epsx=CInfOrNaN::NegativeInfinity();
//--- These variables define stopping conditions for the outer iterations:
//--- * epso controls convergence of outer iterations;algorithm will stop
//--- when difference between solutions of subsequent unconstrained problems
//--- will be less than 0.0001
//--- * epsi controls amount of infeasibility allowed in the final solution
double epso=0.00001;
//--- check
if(_spoil_scenario==18)
epso=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==19)
epso=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==20)
epso=CInfOrNaN::NegativeInfinity();
double epsi=0.00001;
//--- check
if(_spoil_scenario==21)
epsi=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==22)
epsi=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==23)
epsi=CInfOrNaN::NegativeInfinity();
//--- Now we are ready to actually optimize something:
//--- * first we create optimizer
//--- * we add linear constraints
//--- * we tune stopping conditions
//--- * and,finally,optimize and obtain results...
CAlglib::MinBLEICCreate(x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICSetLC(state,c,ct);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICSetInnerCond(state,epsg,epsf,epsx);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICSetOuterCond(state,epso,epsi);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICOptimize(state,fgrad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- ...and evaluate these results
ArrayResize(temparray,2);
//--- initialization
temparray[0]=2;
temparray[1]=4;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minbleic_d_2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization with bound constraints and numerical |
//| differentiation |
//+------------------------------------------------------------------+
void TEST_MinBLEIC_NumDiff(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
double bndl[];
double bndu[];
CObject obj;
CNDimensional_Func1 ffunc;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<25;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x,y)=100*(x+3)^4+(y-3)^4
//--- subject to bound constraints -1<=x<=+1,-1<=y<=+1,using BLEIC optimizer.
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- allocation
ArrayResize(bndl,2);
//--- initialization
bndl[0]=-1;
bndl[1]=-1;
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Value(bndl,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(bndl);
//--- allocation
ArrayResize(bndu,2);
//--- initialization
bndu[0]=1;
bndu[1]=1;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(bndu,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Deleting_Element(bndu);
CMinBLEICStateShell state;
CMinBLEICReportShell rep;
//--- These variables define stopping conditions for the underlying CG algorithm.
//--- They should be stringent enough in order to guarantee overall stability
//--- of the outer iterations.
//--- We use very simple condition - |g|<=epsg
double epsg=0.000001;
//--- check
if(_spoil_scenario==7)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==8)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==9)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==10)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==11)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==12)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==13)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==14)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==15)
epsx=CInfOrNaN::NegativeInfinity();
//--- These variables define stopping conditions for the outer iterations:
//--- * epso controls convergence of outer iterations;algorithm will stop
//--- when difference between solutions of subsequent unconstrained problems
//--- will be less than 0.0001
//--- * epsi controls amount of infeasibility allowed in the final solution
double epso=0.00001;
//--- check
if(_spoil_scenario==16)
epso=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==17)
epso=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==18)
epso=CInfOrNaN::NegativeInfinity();
double epsi=0.00001;
//--- check
if(_spoil_scenario==19)
epsi=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==20)
epsi=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==21)
epsi=CInfOrNaN::NegativeInfinity();
//--- This variable contains differentiation step
double diffstep=1.0e-6;
//--- check
if(_spoil_scenario==22)
diffstep=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==23)
diffstep=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==24)
diffstep=CInfOrNaN::NegativeInfinity();
//--- Now we are ready to actually optimize something:
//--- * first we create optimizer
//--- * we add boundary constraints
//--- * we tune stopping conditions
//--- * and,finally,optimize and obtain results...
CAlglib::MinBLEICCreateF(x,diffstep,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICSetBC(state,bndl,bndu);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICSetInnerCond(state,epsg,epsf,epsx);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICSetOuterCond(state,epso,epsi);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICOptimize(state,ffunc,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- ...and evaluate these results
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-1;
temparray[1]=1;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minbleic_numdiff");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization by BLEIC, function with singularities |
//+------------------------------------------------------------------+
void TEST_MinBLEIC_FTRIM(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_S1_Grad fs1grad;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<18;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x)=(1+x)^(-0.2) + (1-x)^(-0.3) + 1000*x.
//--- This function is undefined outside of (-1,+1) and has singularities at x=-1 and x=+1.
//--- Special technique called "function trimming" allows us to solve this optimization problem
//--- - withusing boundary constraints!
//--- See http://www.CAlglib::net/optimization/tipsandtricks.php#ftrimming for more information
//--- on this subject.
ArrayResize(x,1);
//--- initialization
x[0]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=1.0e-6;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
double epso=1.0e-6;
//--- check
if(_spoil_scenario==12)
epso=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==13)
epso=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==14)
epso=CInfOrNaN::NegativeInfinity();
double epsi=1.0e-6;
//--- check
if(_spoil_scenario==15)
epsi=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==16)
epsi=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==17)
epsi=CInfOrNaN::NegativeInfinity();
//--- create variables
CMinBLEICStateShell state;
CMinBLEICReportShell rep;
//--- function call
CAlglib::MinBLEICCreate(x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICSetInnerCond(state,epsg,epsf,epsx);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICSetOuterCond(state,epso,epsi);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICOptimize(state,fs1grad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinBLEICResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=-0.99917305;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.000005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minbleic_ftrim");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Simple unconstrained MCPD model (no entry/exit states) |
//+------------------------------------------------------------------+
void TEST_MCPD_Simple1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble track0;
CMatrixDouble track1;
CMatrixDouble tempmatrix;
CMatrixDouble p;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<6;_spoil_scenario++)
{
//--- The very simple MCPD example
//--- We have a loan portfolio. Our loans can be in one of two states:
//--- * normal loans ("good" ones)
//--- * past due loans ("bad" ones)
//--- We assume that:
//--- * loans can transition from any state to any other state. In
//--- particular,past due loan can become "good" one at any moment
//--- with same (fixed) probability. Not realistic,but it is toy example :)
//--- * portfolio size does not change over time
//
//--- Thus,we have following model
//--- state_new=P*state_old
//--- where
//--- ( p00 p01 )
//--- P = ( )
//--- ( p10 p11 )
//--- We want to model transitions between these two states using MCPD
//--- approach (Markov Chains for Proportional/Population Data),i.e.
//--- to restore hidden transition matrix P using actual portfolio data.
//--- We have:
//--- * poportional data,i.e. proportion of loans in the normal and past
//--- due states (not portfolio size measured in some currency,although
//--- it is possible to work with population data too)
//--- * two tracks,i.e. two sequences which describe portfolio
//--- evolution from two different starting states: [1,0] (all loans
//--- are "good") and [0.8,0.2] (only 80% of portfolio is in the "good"
//--- state)
CMCPDStateShell s;
CMCPDReportShell rep;
//--- allocation
track0.Resize(5,2);
//--- initialization
track0[0].Set(0,1);
track0[0].Set(1,0);
track0[1].Set(0,0.95);
track0[1].Set(1,0.05);
track0[2].Set(0,0.9275);
track0[2].Set(1,0.0725);
track0[3].Set(0,0.91738);
track0[3].Set(1,0.08263);
track0[4].Set(0,0.91282);
track0[4].Set(1,0.08718);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(track0,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(track0,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(track0,CInfOrNaN::NegativeInfinity());
//--- allocation
track1.Resize(4,2);
//--- initialization
track1[0].Set(0,0.8);
track1[0].Set(1,0.2);
track1[1].Set(0,0.86);
track1[1].Set(1,0.14);
track1[2].Set(0,0.887);
track1[2].Set(1,0.113);
track1[3].Set(0,0.89915);
track1[3].Set(1,0.10085);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Value(track1,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Value(track1,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Value(track1,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::MCPDCreate(2,s);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDAddTrack(s,track0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDAddTrack(s,track1);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDSolve(s);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDResults(s,p,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- Hidden matrix P is equal to
//--- ( 0.95 0.50 )
//--- ( )
//--- ( 0.05 0.50 )
//--- which means that "good" loans can become "bad" with 5% probability,
//--- while "bad" loans will return to good state with 50% probability.
tempmatrix.Resize(2,2);
//--- initialization
tempmatrix[0].Set(0,0.95);
tempmatrix[0].Set(1,0.5);
tempmatrix[1].Set(0,0.05);
tempmatrix[1].Set(1,0.5);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(p,tempmatrix,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","mcpd_simple1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Simple MCPD model (no entry/exit states) with equality |
//| constraints |
//+------------------------------------------------------------------+
void TEST_MCPD_Simple2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble track0;
CMatrixDouble track1;
CMatrixDouble tempmatrix;
CMatrixDouble p;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<6;_spoil_scenario++)
{
//--- Simple MCPD example
//--- We have a loan portfolio. Our loans can be in one of three states:
//--- * normal loans
//--- * past due loans
//--- * charged off loans
//--- We assume that:
//--- * normal loan can stay normal or become past due (but not charged off)
//--- * past due loan can stay past due,become normal or charged off
//--- * charged off loan will stay charged off for the rest of eternity
//--- * portfolio size does not change over time
//--- Not realistic,but it is toy example :)
//--- Thus,we have following model
//--- state_new=P*state_old
//--- where
//--- ( p00 p01 )
//--- P = ( p10 p11 )
//--- ( p21 1 )
//--- i.e. four elements of P are known a priori.
//--- Although it is possible (given enough data) to In order to enforce
//--- this property we set equality constraints on these elements.
//--- We want to model transitions between these two states using MCPD
//--- approach (Markov Chains for Proportional/Population Data),i.e.
//--- to restore hidden transition matrix P using actual portfolio data.
//--- We have:
//--- * poportional data,i.e. proportion of loans in the current and past
//--- due states (not portfolio size measured in some currency,although
//--- it is possible to work with population data too)
//--- * two tracks,i.e. two sequences which describe portfolio
//--- evolution from two different starting states: [1,0,0] (all loans
//--- are "good") and [0.8,0.2,0.0] (only 80% of portfolio is in the "good"
//--- state)
CMCPDStateShell s;
CMCPDReportShell rep;
//--- allocation
track0.Resize(5,3);
//--- initialization
track0[0].Set(0,1);
track0[0].Set(1,0);
track0[0].Set(2,0);
track0[1].Set(0,0.95);
track0[1].Set(1,0.05);
track0[1].Set(2,0);
track0[2].Set(0,0.9275);
track0[2].Set(1,0.06);
track0[2].Set(2,0.0125);
track0[3].Set(0,0.911125);
track0[3].Set(1,0.061375);
track0[3].Set(2,0.0275);
track0[4].Set(0,0.896256);
track0[4].Set(1,0.0609);
track0[4].Set(2,0.042844);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(track0,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(track0,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(track0,CInfOrNaN::NegativeInfinity());
//--- allocation
track1.Resize(5,3);
//--- initialization
track1[0].Set(0,0.8);
track1[0].Set(1,0.2);
track1[0].Set(2,0);
track1[1].Set(0,0.86);
track1[1].Set(1,0.09);
track1[1].Set(2,0.05);
track1[2].Set(0,0.862);
track1[2].Set(1,0.0655);
track1[2].Set(2,0.0725);
track1[3].Set(0,0.85165);
track1[3].Set(1,0.059475);
track1[3].Set(2,0.088875);
track1[4].Set(0,0.838805);
track1[4].Set(1,0.057451);
track1[4].Set(2,0.103744);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Value(track1,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Value(track1,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Value(track1,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::MCPDCreate(3,s);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDAddTrack(s,track0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDAddTrack(s,track1);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDAddEC(s,0,2,0.0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDAddEC(s,1,2,0.0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDAddEC(s,2,2,1.0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDAddEC(s,2,0,0.0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDSolve(s);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MCPDResults(s,p,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- Hidden matrix P is equal to
//--- ( 0.95 0.50 )
//--- ( 0.05 0.25 )
//--- ( 0.25 1.00 )
//--- which means that "good" loans can become past due with 5% probability,
//--- while past due loans will become charged off with 25% probability or
//--- return back to normal state with 50% probability.
tempmatrix.Resize(3,3);
//--- initialization
tempmatrix[0].Set(0,0.95);
tempmatrix[0].Set(1,0.5);
tempmatrix[0].Set(2,0);
tempmatrix[1].Set(0,0.05);
tempmatrix[1].Set(1,0.25);
tempmatrix[1].Set(2,0);
tempmatrix[2].Set(0,0);
tempmatrix[2].Set(1,0.25);
tempmatrix[2].Set(2,1);
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Matrix(p,tempmatrix,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","mcpd_simple2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization by L-BFGS |
//+------------------------------------------------------------------+
void TEST_MinLBFGS_D_1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_Grad1 fgrad;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x,y)=100*(x+3)^4+(y-3)^4
//--- using LBFGS method.
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
CMinLBFGSStateShell state;
CMinLBFGSReportShell rep;
//--- function call
CAlglib::MinLBFGSCreate(1,x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSOptimize(state,fgrad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minlbfgs_d_1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization with additional settings and restarts |
//+------------------------------------------------------------------+
void TEST_MinLBFGS_D_2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_Grad1 fgrad;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<18;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x,y)=100*(x+3)^4+(y-3)^4
//--- using LBFGS method.
//--- Several advanced techniques are demonstrated:
//--- * upper limit on step size
//--- * restart from new point
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
double stpmax=0.1;
//--- check
if(_spoil_scenario==12)
stpmax=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==13)
stpmax=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==14)
stpmax=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
CMinLBFGSStateShell state;
CMinLBFGSReportShell rep;
//--- first run
CAlglib::MinLBFGSCreate(1,x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSSetStpMax(state,stpmax);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSOptimize(state,fgrad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
//--- second run - algorithm is restarted
ArrayResize(x,2);
//--- initialization
x[0]=10;
x[1]=10;
//--- check
if(_spoil_scenario==15)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==16)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==17)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::MinLBFGSRestartFrom(state,x);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSOptimize(state,fgrad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minlbfgs_d_2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization by L-BFGS with numerical differentiation |
//+------------------------------------------------------------------+
void TEST_MinLBFGS_NumDiff(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_Func1 ffunc;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<15;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x,y)=100*(x+3)^4+(y-3)^4
//--- using numerical differentiation to calculate gradient.
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
double diffstep=1.0e-6;
//--- check
if(_spoil_scenario==12)
diffstep=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==13)
diffstep=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==14)
diffstep=CInfOrNaN::NegativeInfinity();
int maxits=0;
CMinLBFGSStateShell state;
CMinLBFGSReportShell rep;
//--- function call
CAlglib::MinLBFGSCreateF(1,x,diffstep,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSOptimize(state,ffunc,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minlbfgs_numdiff");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear optimization by LBFGS, function with singularities |
//+------------------------------------------------------------------+
void TEST_MinLBFGS_FTRIM(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_S1_Grad fs1grad;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- This example demonstrates minimization of f(x)=(1+x)^(-0.2) + (1-x)^(-0.3) + 1000*x.
//--- This function has singularities at the boundary of the [-1,+1],but technique called
//--- "function trimming" allows us to solve this optimization problem.
//--- See http://www.CAlglib::net/optimization/tipsandtricks.php#ftrimming for more information
//--- on this subject.
ArrayResize(x,1);
//--- initialization
x[0]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=1.0e-6;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
CMinLBFGSStateShell state;
CMinLBFGSReportShell rep;
//--- function call
CAlglib::MinLBFGSCreate(1,x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSOptimize(state,fs1grad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLBFGSResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=-0.99917305;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.000005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minlbfgs_ftrim");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Solving y'=-y with ODE solver |
//+------------------------------------------------------------------+
void TEST_ODESolver_D1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double x[];
int m;
double xtbl[];
double temparray[];
CMatrixDouble ytbl;
CMatrixDouble tempmatrix;
CObject obj;
CNDimensional_ODE_Function_1_Dif fode;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<13;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,1);
//--- initialization
y[0]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(y);
//--- allocation
ArrayResize(x,4);
//--- initialization
x[0]=0;
x[1]=1;
x[2]=2;
x[3]=3;
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double eps=0.00001;
//--- check
if(_spoil_scenario==7)
eps=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==8)
eps=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==9)
eps=CInfOrNaN::NegativeInfinity();
double h=0;
//--- check
if(_spoil_scenario==10)
h=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==11)
h=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==12)
h=CInfOrNaN::NegativeInfinity();
//--- create variables
CODESolverStateShell s;
CODESolverReportShell rep;
//--- function call
CAlglib::ODESolverRKCK(y,x,eps,h,s);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::ODESolverSolve(s,fode,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::ODESolverResults(s,m,xtbl,ytbl,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,4);
//--- initialization
temparray[0]=0;
temparray[1]=1;
temparray[2]=2;
temparray[3]=3;
//--- allocation
tempmatrix.Resize(4,1);
//--- initialization
tempmatrix[0].Set(0,1);
tempmatrix[1].Set(0,0.367);
tempmatrix[2].Set(0,0.135);
tempmatrix[3].Set(0,0.05);
//--- check result
_TestResult=_TestResult && Doc_Test_Int(m,4);
_TestResult=_TestResult && Doc_Test_Real_Vector(xtbl,temparray,0.005);
_TestResult=_TestResult && Doc_Test_Real_Matrix(ytbl,tempmatrix,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","odesolver_d1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Complex FFT: simple example |
//+------------------------------------------------------------------+
void TEST_FFT_Complex_D1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
complex z[];
complex temparray[];
complex tempcomplex1;
complex tempcomplex2;
complex cnan;
complex cpositiveinfinity;
complex cnegativeinfinity;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<3;_spoil_scenario++)
{
//--- first we demonstrate forward FFT:
//--- [1i,1i,1i,1i] is converted to [4i,0,0,0]
tempcomplex1.re=0;
tempcomplex1.im=1;
tempcomplex2.re=0;
tempcomplex2.im=4;
//--- allocation
ArrayResize(z,4);
//--- initialization
z[0]=tempcomplex1;
z[1]=tempcomplex1;
z[2]=tempcomplex1;
z[3]=tempcomplex1;
//--- initialization
cnan.re=CInfOrNaN::NaN();
cnan.im=CInfOrNaN::NaN();
cpositiveinfinity.re=CInfOrNaN::PositiveInfinity();
cpositiveinfinity.im=CInfOrNaN::PositiveInfinity();
cnegativeinfinity.re=CInfOrNaN::NegativeInfinity();
cnegativeinfinity.im=CInfOrNaN::NegativeInfinity();
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(z,cnan);
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(z,cpositiveinfinity);
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(z,cnegativeinfinity);
//--- function call
CAlglib::FFTC1D(z);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,4);
//--- initialization
temparray[0]=tempcomplex2;
temparray[1]=0;
temparray[2]=0;
temparray[3]=0;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex_Vector(z,temparray,0.0001);
//--- now we convert [4i,0,0,0] back to [1i,1i,1i,1i]
//--- with backward FFT
CAlglib::FFTC1DInv(z);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,4);
//--- initialization
temparray[0]=tempcomplex1;
temparray[1]=tempcomplex1;
temparray[2]=tempcomplex1;
temparray[3]=tempcomplex1;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex_Vector(z,temparray,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","fft_complex_d1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Complex FFT: advanced example |
//+------------------------------------------------------------------+
void TEST_FFT_Complex_D2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
complex z[];
complex temparray[];
complex tempcomplex1;
complex tempcomplex2;
complex tempcomplex3;
complex cnan;
complex cpositiveinfinity;
complex cnegativeinfinity;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<3;_spoil_scenario++)
{
//--- first we demonstrate forward FFT:
//--- [0,1,0,1i] is converted to [1+1i,-1-1i,-1-1i,1+1i]
tempcomplex1.re=0;
tempcomplex1.im=1;
//--- allocation
ArrayResize(z,4);
//--- initialization
z[0]=0;
z[1]=1;
z[2]=0;
z[3]=tempcomplex1;
//--- initialization
cnan.re=CInfOrNaN::NaN();
cnan.im=CInfOrNaN::NaN();
cpositiveinfinity.re=CInfOrNaN::PositiveInfinity();
cpositiveinfinity.im=CInfOrNaN::PositiveInfinity();
cnegativeinfinity.re=CInfOrNaN::NegativeInfinity();
cnegativeinfinity.im=CInfOrNaN::NegativeInfinity();
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(z,cnan);
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(z,cpositiveinfinity);
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(z,cnegativeinfinity);
//--- function call
CAlglib::FFTC1D(z);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- initialization
tempcomplex2.re=1;
tempcomplex2.im=1;
tempcomplex3.re=-1;
tempcomplex3.im=-1;
//--- allocation
ArrayResize(temparray,4);
//--- initialization
temparray[0]=tempcomplex2;
temparray[1]=tempcomplex3;
temparray[2]=tempcomplex3;
temparray[3]=tempcomplex2;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex_Vector(z,temparray,0.0001);
//--- now we convert result back with backward FFT
CAlglib::FFTC1DInv(z);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,4);
//--- initialization
temparray[0]=0;
temparray[1]=1;
temparray[2]=0;
temparray[3]=tempcomplex1;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex_Vector(z,temparray,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","fft_complex_d2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Real FFT: simple example |
//+------------------------------------------------------------------+
void TEST_FFT_Real_D1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
complex tempcarray[];
double temparray[];
complex f[];
double x2[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<3;_spoil_scenario++)
{
//--- first we demonstrate forward FFT:
//--- [1,1,1,1] is converted to [4,0,0,0]
ArrayResize(x,4);
//--- initialization
x[0]=1;
x[1]=1;
x[2]=1;
x[3]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::FFTR1D(x,f);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(tempcarray,4);
//--- initialization
tempcarray[0]=4;
tempcarray[1]=0;
tempcarray[2]=0;
tempcarray[3]=0;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex_Vector(f,tempcarray,0.0001);
//--- now we convert [4,0,0,0] back to [1,1,1,1]
//--- with backward FFT
CAlglib::FFTR1DInv(f,x2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,4);
//--- initialization
temparray[0]=1;
temparray[1]=1;
temparray[2]=1;
temparray[3]=1;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(x2,temparray,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","fft_real_d1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Real FFT: advanced example |
//+------------------------------------------------------------------+
void TEST_FFT_Real_D2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
complex tempcarray[];
complex f[];
double x2[];
complex tempcomplex1;
complex tempcomplex2;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<3;_spoil_scenario++)
{
//--- first we demonstrate forward FFT:
//--- [1,2,3,4] is converted to [10,-2+2i,-2,-2-2i]
//--- note that output array is self-adjoint:
//--- * f[0]=conj(f[0])
//--- * f[1]=conj(f[3])
//--- * f[2]=conj(f[2])
ArrayResize(x,4);
//--- initialization
x[0]=1;
x[1]=2;
x[2]=3;
x[3]=4;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::FFTR1D(x,f);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- initialization
tempcomplex1.re=-2;
tempcomplex1.im=2;
tempcomplex2.re=-2;
tempcomplex2.im=-2;
//--- allocation
ArrayResize(tempcarray,4);
//--- initialization
tempcarray[0]=10;
tempcarray[1]=tempcomplex1;
tempcarray[2]=-2;
tempcarray[3]=tempcomplex2;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex_Vector(f,tempcarray,0.0001);
//--- now we convert [10,-2+2i,-2,-2-2i] back to [1,2,3,4]
CAlglib::FFTR1DInv(f,x2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,4);
//--- initialization
temparray[0]=1;
temparray[1]=2;
temparray[2]=3;
temparray[3]=4;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(x2,temparray,0.0001);
//--- remember that F is self-adjoint? It means that we can pass just half
//--- (slightly larger than half) of F to inverse real FFT and still get our result.
//--- I.e. instead [10,-2+2i,-2,-2-2i] we pass just [10,-2+2i,-2] and everything works!
//--- NOTE: in this case we should explicitly pass array length (which is 4) to ALGLIB;
//--- if not,it will automatically use array length to determine FFT size and
//--- will erroneously make half-length FFT.
ArrayResize(f,3);
//--- initialization
f[0]=10;
f[1]=tempcomplex1;
f[2]=-2;
//--- function call
CAlglib::FFTR1DInv(f,4,x2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,4);
//--- initialization
temparray[0]=1;
temparray[1]=2;
temparray[2]=3;
temparray[3]=4;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(x2,temparray,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","fft_real_d2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| error detection in backward FFT |
//+------------------------------------------------------------------+
void TEST_FFT_Complex_E1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
complex tempcomplex1;
complex tempcomplex2;
complex z[];
complex temparray[];
complex cnan;
complex cpositiveinfinity;
complex cnegativeinfinity;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<3;_spoil_scenario++)
{
//--- allocation
ArrayResize(z,4);
//--- initialization
z[0]=0;
z[1]=2;
z[2]=0;
z[3]=-2;
//--- initialization
cnan.re=CInfOrNaN::NaN();
cnan.im=CInfOrNaN::NaN();
cpositiveinfinity.re=CInfOrNaN::PositiveInfinity();
cpositiveinfinity.im=CInfOrNaN::PositiveInfinity();
cnegativeinfinity.re=CInfOrNaN::NegativeInfinity();
cnegativeinfinity.im=CInfOrNaN::NegativeInfinity();
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(z,cnan);
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(z,cpositiveinfinity);
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(z,cnegativeinfinity);
//--- function call
CAlglib::FFTC1DInv(z);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- initialization
tempcomplex1.re=0;
tempcomplex1.im=1;
tempcomplex2.re=0;
tempcomplex2.im=-1;
//--- allocation
ArrayResize(temparray,4);
//--- initialization
temparray[0]=0;
temparray[1]=tempcomplex1;
temparray[2]=0;
temparray[3]=tempcomplex2;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex_Vector(z,temparray,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","fft_complex_e1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Integrating f=exp(x) by adaptive integrator |
//+------------------------------------------------------------------+
void TEST_AutoGK_D1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CObject obj;
CInt_Function_1_Func fint;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<6;_spoil_scenario++)
{
//--- This example demonstrates integration of f=exp(x) on [0,1]:
//--- * first,autogkstate is initialized
//--- * then we call integration function
//--- * and finally we obtain results with autogkresults() call
double a=0;
//--- check
if(_spoil_scenario==0)
a=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==1)
a=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==2)
a=CInfOrNaN::NegativeInfinity();
double b=1;
//--- check
if(_spoil_scenario==3)
b=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
b=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
b=CInfOrNaN::NegativeInfinity();
//--- create variables
CAutoGKStateShell s;
double v;
CAutoGKReportShell rep;
//--- function call
CAlglib::AutoGKSmooth(a,b,s);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::AutoGKIntegrate(s,fint,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::AutoGKResults(s,v,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,1.7182,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","autogk_d1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Interpolation and differentiation using barycentric |
//| representation |
//+------------------------------------------------------------------+
void TEST_PolInt_D_CalcDiff(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- Here we demonstrate polynomial interpolation and differentiation
//--- of y=x^2-x sampled at [0,1,2]. Barycentric representation of polynomial is used.
ArrayResize(x,3);
//--- initialization
x[0]=0;
x[1]=1;
x[2]=2;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Adding_Element(x);
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=0;
y[1]=0;
y[2]=2;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
double t=-1;
//--- check
if(_spoil_scenario==10)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
t=CInfOrNaN::NegativeInfinity();
//--- create variables
double v;
double dv;
double d2v;
CBarycentricInterpolantShell p;
//--- barycentric model is created
CAlglib::PolynomialBuild(x,y,p);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- barycentric interpolation is demonstrated
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
//--- barycentric differentation is demonstrated
CAlglib::BarycentricDiff1(p,t,v,dv);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && Doc_Test_Real(dv,-3.0,0.00005);
//--- second derivatives with barycentric representation
CAlglib::BarycentricDiff1(p,t,v,dv);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && Doc_Test_Real(dv,-3.0,0.00005);
//--- function call
CAlglib::BarycentricDiff2(p,t,v,dv,d2v);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && Doc_Test_Real(dv,-3.0,0.00005);
_TestResult=_TestResult && Doc_Test_Real(d2v,2.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_d_calcdiff");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Conversion between power basis and barycentric representation |
//+------------------------------------------------------------------+
void TEST_PolInt_D_Conv(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double a[];
double temparray[];
double a2[];
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<5;_spoil_scenario++)
{
//--- Here we demonstrate conversion of y=x^2-x
//--- between power basis and barycentric representation.
ArrayResize(a,3);
//--- initialization
a[0]=0;
a[1]=-1;
a[2]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(a,CInfOrNaN::NegativeInfinity());
double t=2;
//--- check
if(_spoil_scenario==3)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::NegativeInfinity();
//--- create a variable
CBarycentricInterpolantShell p;
//--- a=[0,-1,+1] is decomposition of y=x^2-x in the power basis:
//--- y=0 - 1*x + 1*x^2
//--- We convert it to the barycentric form.
CAlglib::PolynomialPow2Bar(a,p);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- now we have barycentric interpolation;we can use it for interpolation
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.005);
//--- we can also convert back from barycentric representation to power basis
CAlglib::PolynomialBar2Pow(p,a2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,3);
//--- initialization
temparray[0]=0;
temparray[1]=-1;
temparray[2]=1;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(a2,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_d_conv");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation on special grids (equidistant, |
//| Chebyshev I/II) |
//+------------------------------------------------------------------+
void TEST_PolInt_D_Spec(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y_eqdist[];
double y_cheb1[];
double y_cheb2[];
double a_eqdist[];
double a_cheb1[];
double a_cheb2[];
double temparray[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<11;_spoil_scenario++)
{
//--- Temporaries:
//--- * values of y=x^2-x sampled at three special grids:
//--- * equdistant grid spanning [0,2], x[i]=2*i/(N-1),i=0..N-1
//--- * Chebyshev-I grid spanning [-1,+1],x[i]=1 + Cos(PI*(2*i+1)/(2*n)),i=0..N-1
//--- * Chebyshev-II grid spanning [-1,+1],x[i]=1 + Cos(PI*i/(n-1)),i=0..N-1
//--- * barycentric interpolants for these three grids
//--- * vectors to store coefficients of quadratic representation
ArrayResize(y_eqdist,3);
//--- initialization
y_eqdist[0]=0;
y_eqdist[1]=0;
y_eqdist[2]=2;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y_eqdist,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y_eqdist,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y_eqdist,CInfOrNaN::NegativeInfinity());
//--- allocation
ArrayResize(y_cheb1,3);
//--- initialization
y_cheb1[0]=-0.116025;
y_cheb1[1]=0;
y_cheb1[2]=1.616025;
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Value(y_cheb1,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Value(y_cheb1,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y_cheb1,CInfOrNaN::NegativeInfinity());
//--- allocation
ArrayResize(y_cheb2,3);
//--- initialization
y_cheb2[0]=0;
y_cheb2[1]=0;
y_cheb2[2]=2;
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y_cheb2,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y_cheb2,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Value(y_cheb2,CInfOrNaN::NegativeInfinity());
//--- create variables
CBarycentricInterpolantShell p_eqdist;
CBarycentricInterpolantShell p_cheb1;
CBarycentricInterpolantShell p_cheb2;
//--- First,we demonstrate construction of barycentric interpolants on
//--- special grids. We unpack power representation to ensure that
//--- interpolant was built correctly.
//--- In all three cases we should get same quadratic function.
CAlglib::PolynomialBuildEqDist(0.0,2.0,y_eqdist,p_eqdist);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::PolynomialBar2Pow(p_eqdist,a_eqdist);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,3);
//--- initialization
temparray[0]=0;
temparray[1]=-1;
temparray[2]=1;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(a_eqdist,temparray,0.00005);
//--- function call
CAlglib::PolynomialBuildCheb1(-1,+1,y_cheb1,p_cheb1);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::PolynomialBar2Pow(p_cheb1,a_cheb1);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,3);
//--- initialization
temparray[0]=0;
temparray[1]=-1;
temparray[2]=1;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(a_cheb1,temparray,0.00005);
//--- function call
CAlglib::PolynomialBuildCheb2(-1,+1,y_cheb2,p_cheb2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::PolynomialBar2Pow(p_cheb2,a_cheb2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,3);
//--- initialization
temparray[0]=0;
temparray[1]=-1;
temparray[2]=1;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(a_cheb2,temparray,0.00005);
//--- Now we demonstrate polynomial interpolation withconstruction
//--- of the barycentricinterpolant structure.
//--- We calculate interpolant value at x=-2.
//--- In all three cases we should get same f=6
double t=-2;
//--- check
if(_spoil_scenario==9)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==10)
t=CInfOrNaN::NegativeInfinity();
double v;
//--- function call
v=CAlglib::PolynomialCalcEqDist(0.0,2.0,y_eqdist,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,6.0,0.00005);
//--- function call
v=CAlglib::PolynomialCalcCheb1(-1,+1,y_cheb1,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,6.0,0.00005);
//--- function call
v=CAlglib::PolynomialCalcCheb2(-1,+1,y_cheb2,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,6.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_d_spec");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation,full list of parameters. |
//+------------------------------------------------------------------+
void TEST_PolInt_T_1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<10;_spoil_scenario++)
{
//--- allocation
ArrayResize(x,3);
//--- initialization
x[0]=0;
x[1]=1;
x[2]=2;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=0;
y[1]=0;
y[2]=2;
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Deleting_Element(y);
double t=-1;
//--- check
if(_spoil_scenario==8)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==9)
t=CInfOrNaN::NegativeInfinity();
//--- create variables
CBarycentricInterpolantShell p;
double v;
//--- function call
CAlglib::PolynomialBuild(x,y,3,p);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation,full list of parameters. |
//+------------------------------------------------------------------+
void TEST_PolInt_T_2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double t;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<6;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=0;
y[1]=0;
y[2]=2;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(y);
t=-1;
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
t=CInfOrNaN::NegativeInfinity();
CBarycentricInterpolantShell p;
//--- function call
CAlglib::PolynomialBuildEqDist(0.0,2.0,y,3,p);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation,full list of parameters. |
//+------------------------------------------------------------------+
void TEST_PolInt_T_3(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double t;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<6;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=-0.116025;
y[1]=0;
y[2]=1.616025;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(y);
t=-1;
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
t=CInfOrNaN::NegativeInfinity();
CBarycentricInterpolantShell p;
//--- function call
CAlglib::PolynomialBuildCheb1(-1.0,+1.0,y,3,p);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- create a variable
double v;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_3");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation,full list of parameters. |
//+------------------------------------------------------------------+
void TEST_PolInt_T_4(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double t;
double a;
double b;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=0;
y[1]=0;
y[2]=2;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(y);
t=-2;
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
t=CInfOrNaN::NegativeInfinity();
a=-1;
//--- check
if(_spoil_scenario==6)
a=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
a=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
a=CInfOrNaN::NegativeInfinity();
b=1;
//--- check
if(_spoil_scenario==9)
b=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
b=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
b=CInfOrNaN::NegativeInfinity();
//--- create a variable
CBarycentricInterpolantShell p;
//--- function call
CAlglib::PolynomialBuildCheb2(a,b,y,3,p);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,6.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_4");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation,full list of parameters. |
//+------------------------------------------------------------------+
void TEST_PolInt_T_5(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double t;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<6;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=0;
y[1]=0;
y[2]=2;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(y);
t=-1;
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
t=CInfOrNaN::NegativeInfinity();
//--- function call
v=CAlglib::PolynomialCalcEqDist(0.0,2.0,y,3,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_5");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation,full list of parameters. |
//+------------------------------------------------------------------+
void TEST_PolInt_T_6(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double t;
double a;
double b;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=-0.116025;
y[1]=0;
y[2]=1.616025;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(y);
t=-1;
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
t=CInfOrNaN::NegativeInfinity();
a=-1;
//--- check
if(_spoil_scenario==6)
a=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
a=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
a=CInfOrNaN::NegativeInfinity();
b=1;
//--- check
if(_spoil_scenario==9)
b=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
b=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
b=CInfOrNaN::NegativeInfinity();
//--- function call
v=CAlglib::PolynomialCalcCheb1(a,b,y,3,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_6");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation,full list of parameters. |
//+------------------------------------------------------------------+
void TEST_PolInt_T_7(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double t;
double a;
double b;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=0;
y[1]=0;
y[2]=2;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(y);
t=-2;
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
t=CInfOrNaN::NegativeInfinity();
a=-1;
//--- check
if(_spoil_scenario==6)
a=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
a=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
a=CInfOrNaN::NegativeInfinity();
b=1;
//--- check
if(_spoil_scenario==9)
b=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
b=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
b=CInfOrNaN::NegativeInfinity();
//--- function call
v=CAlglib::PolynomialCalcCheb2(a,b,y,3,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,6.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_7");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation: y=x^2-x,equidistant grid, barycentric |
//| form |
//+------------------------------------------------------------------+
void TEST_PolInt_T_8(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double t;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<5;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=0;
y[1]=0;
y[2]=2;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
t=-1;
//--- check
if(_spoil_scenario==3)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::NegativeInfinity();
CBarycentricInterpolantShell p;
//--- function call
CAlglib::PolynomialBuildEqDist(0.0,2.0,y,p);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_8");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation: y=x^2-x, Chebyshev grid (first kind), |
//| barycentric form |
//+------------------------------------------------------------------+
void TEST_PolInt_T_9(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double t;
double a;
double b;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<11;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=-0.116025;
y[1]=0;
y[2]=1.616025;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
t=-1;
//--- check
if(_spoil_scenario==3)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::NegativeInfinity();
a=-1;
//--- check
if(_spoil_scenario==5)
a=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==6)
a=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==7)
a=CInfOrNaN::NegativeInfinity();
b=1;
//--- check
if(_spoil_scenario==8)
b=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==9)
b=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==10)
b=CInfOrNaN::NegativeInfinity();
//--- create a variable
CBarycentricInterpolantShell p;
//--- function call
CAlglib::PolynomialBuildCheb1(a,b,y,p);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_9");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation: y=x^2-x, Chebyshev grid (second kind), |
//| barycentric form |
//+------------------------------------------------------------------+
void TEST_PolInt_T_10(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double t;
double a;
double b;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<11;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=0;
y[1]=0;
y[2]=2;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
t=-2;
//--- check
if(_spoil_scenario==3)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::NegativeInfinity();
a=-1;
//--- check
if(_spoil_scenario==5)
a=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==6)
a=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==7)
a=CInfOrNaN::NegativeInfinity();
b=1;
//--- check
if(_spoil_scenario==8)
b=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==9)
b=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==10)
b=CInfOrNaN::NegativeInfinity();
//--- create a variable
CBarycentricInterpolantShell p;
//--- function call
CAlglib::PolynomialBuildCheb2(a,b,y,p);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,6.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_10");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation: y=x^2-x,equidistant grid |
//+------------------------------------------------------------------+
void TEST_PolInt_T_11(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double t;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<5;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=0;
y[1]=0;
y[2]=2;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
t=-1;
//--- check
if(_spoil_scenario==3)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::NegativeInfinity();
//--- function call
v=CAlglib::PolynomialCalcEqDist(0.0,2.0,y,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_11");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation: y=x^2-x,Chebyshev grid (first kind) |
//+------------------------------------------------------------------+
void TEST_PolInt_T_12(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
double t;
double a;
double b;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<11;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=-0.116025;
y[1]=0;
y[2]=1.616025;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
t=-1;
//--- check
if(_spoil_scenario==3)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::NegativeInfinity();
a=-1;
//--- check
if(_spoil_scenario==5)
a=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==6)
a=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==7)
a=CInfOrNaN::NegativeInfinity();
b=+1;
//--- check
if(_spoil_scenario==8)
b=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==9)
b=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==10)
b=CInfOrNaN::NegativeInfinity();
//--- function call
v=CAlglib::PolynomialCalcCheb1(a,b,y,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_12");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial interpolation: y=x^2-x,Chebyshev grid (second kind) |
//+------------------------------------------------------------------+
void TEST_PolInt_T_13(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double y[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<11;_spoil_scenario++)
{
//--- allocation
ArrayResize(y,3);
//--- initialization
y[0]=0;
y[1]=0;
y[2]=2;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
double t=-2;
//--- check
if(_spoil_scenario==3)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==4)
t=CInfOrNaN::NegativeInfinity();
double a=-1;
//--- check
if(_spoil_scenario==5)
a=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==6)
a=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==7)
a=CInfOrNaN::NegativeInfinity();
double b=+1;
//--- check
if(_spoil_scenario==8)
b=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==9)
b=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==10)
b=CInfOrNaN::NegativeInfinity();
double v;
//--- function call
v=CAlglib::PolynomialCalcCheb2(a,b,y,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,6.0,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","polint_t_13");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Piecewise linear spline interpolation |
//+------------------------------------------------------------------+
void TEST_Spline1D_D_Linear(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
double t;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- We use piecewise linear spline to interpolate f(x)=x^2 sampled
//--- at 5 equidistant nodes on [-1,+1].
ArrayResize(x,5);
//--- initialization
x[0]=-1;
x[1]=-0.5;
x[2]=0;
x[3]=0.5;
x[4]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Adding_Element(x);
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,5);
//--- initialization
y[0]=1;
y[1]=0.25;
y[2]=0;
y[3]=0.25;
y[4]=1;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
t=0.25;
//--- check
if(_spoil_scenario==10)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
t=CInfOrNaN::NegativeInfinity();
//--- create a variable
CSpline1DInterpolantShell s;
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- build spline
CAlglib::Spline1DBuildLinear(x,y,s);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- calculate S(0.25) - it is quite different from 0.25^2=0.0625
v=CAlglib::Spline1DCalc(s,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,0.125,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","spline1d_d_linear");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Cubic spline interpolation |
//+------------------------------------------------------------------+
void TEST_Spline1D_D_Cubic(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<10;_spoil_scenario++)
{
//--- We use cubic spline to interpolate f(x)=x^2 sampled
//--- at 5 equidistant nodes on [-1,+1].
//--- First,we use default boundary conditions ("parabolically terminated
//--- spline") because cubic spline built with such boundary conditions
//--- will exactly reproduce any quadratic f(x).
//--- Then we try to use natural boundary conditions
//--- d2S(-1)/dx^2=0.0
//--- d2S(+1)/dx^2=0.0
//--- and see that such spline interpolated f(x) with small error.
ArrayResize(x,5);
//--- initialization
x[0]=-1;
x[1]=-0.5;
x[2]=0;
x[3]=0.5;
x[4]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,5);
//--- initialization
y[0]=1;
y[1]=0.25;
y[2]=0;
y[3]=0.25;
y[4]=1;
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Deleting_Element(y);
double t=0.25;
//--- check
if(_spoil_scenario==8)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==9)
t=CInfOrNaN::NegativeInfinity();
//--- create variables
double v;
CSpline1DInterpolantShell s;
int natural_bound_type=2;
//--- Test exact boundary conditions: build S(x),calculare S(0.25)
//--- (almost same as original function)
CAlglib::Spline1DBuildCubic(x,y,s);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::Spline1DCalc(s,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,0.0625,0.00001);
//--- Test natural boundary conditions: build S(x),calculare S(0.25)
//--- (small interpolation error)
CAlglib::Spline1DBuildCubic(x,y,5,natural_bound_type,0.0,natural_bound_type,0.0,s);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::Spline1DCalc(s,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,0.0580,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","spline1d_d_cubic");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Differentiation on the grid using cubic splines |
//+------------------------------------------------------------------+
void TEST_Spline1D_D_GridDiff(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
double d1[];
double d2[];
double temparray1[];
double temparray2[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<10;_spoil_scenario++)
{
//--- We use cubic spline to do grid differentiation,i.e. having
//--- values of f(x)=x^2 sampled at 5 equidistant nodes on [-1,+1]
//--- we calculate derivatives of cubic spline at nodes WITHOUT
//--- CONSTRUCTION OF SPLINE OBJECT.
//--- There are efficient functions spline1dgriddiffcubic() and
//--- spline1dgriddiff2cubic() for such calculations.
//--- We use default boundary conditions ("parabolically terminated
//--- spline") because cubic spline built with such boundary conditions
//--- will exactly reproduce any quadratic f(x).
//--- Actually,we could use natural conditions,but we feel that
//--- spline which exactly reproduces f() will show us more
//--- understandable results.
ArrayResize(x,5);
//--- initialization
x[0]=-1;
x[1]=-0.5;
x[2]=0;
x[3]=0.5;
x[4]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Adding_Element(x);
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,5);
//--- initialization
y[0]=1;
y[1]=0.25;
y[2]=0;
y[3]=0.25;
y[4]=1;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
//--- We calculate first derivatives: they must be equal to 2*x
CAlglib::Spline1DGridDiffCubic(x,y,d1);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray1,5);
//--- initialization
temparray1[0]=-2;
temparray1[1]=-1;
temparray1[2]=0;
temparray1[3]=1;
temparray1[4]=2;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(d1,temparray1,0.0001);
//--- Now test griddiff2,which returns first AND second derivatives.
//--- First derivative is 2*x,second is equal to 2.0
CAlglib::Spline1DGridDiff2Cubic(x,y,d1,d2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray2,5);
//--- initialization
temparray2[0]=2;
temparray2[1]=2;
temparray2[2]=2;
temparray2[3]=2;
temparray2[4]=2;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(d1,temparray1,0.0001);
_TestResult=_TestResult && Doc_Test_Real_Vector(d2,temparray2,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","spline1d_d_griddiff");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Resampling using cubic splines |
//+------------------------------------------------------------------+
void TEST_Spline1D_D_ConvDiff(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x_old[];
double y_old[];
double x_new[];
double y_new[];
double d1_new[];
double d2_new[];
double temparray1[];
double temparray2[];
double temparray3[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<11;_spoil_scenario++)
{
//--- We use cubic spline to do resampling,i.e. having
//--- values of f(x)=x^2 sampled at 5 equidistant nodes on [-1,+1]
//--- we calculate values/derivatives of cubic spline on
//--- another grid (equidistant with 9 nodes on [-1,+1])
//--- WITHOUT CONSTRUCTION OF SPLINE OBJECT.
//--- There are efficient functions spline1dconvcubic(),
//--- spline1dconvdiffcubic() and spline1dconvdiff2cubic()
//--- for such calculations.
//--- We use default boundary conditions ("parabolically terminated
//--- spline") because cubic spline built with such boundary conditions
//--- will exactly reproduce any quadratic f(x).
//--- Actually,we could use natural conditions,but we feel that
//--- spline which exactly reproduces f() will show us more
//--- understandable results.
ArrayResize(x_old,5);
//--- initialization
x_old[0]=-1;
x_old[1]=-0.5;
x_old[2]=0;
x_old[3]=0.5;
x_old[4]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x_old,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x_old,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x_old,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(x_old);
//--- allocation
ArrayResize(y_old,5);
//--- initialization
y_old[0]=1;
y_old[1]=0.25;
y_old[2]=0;
y_old[3]=0.25;
y_old[4]=1;
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Value(y_old,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y_old,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y_old,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Deleting_Element(y_old);
//--- allocation
ArrayResize(x_new,9);
//--- initialization
x_new[0]=-1;
x_new[1]=-0.75;
x_new[2]=-0.5;
x_new[3]=-0.25;
x_new[4]=0;
x_new[5]=0.25;
x_new[6]=0.5;
x_new[7]=0.75;
x_new[8]=1;
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Value(x_new,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Value(x_new,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(x_new,CInfOrNaN::NegativeInfinity());
//--- First,conversion withdifferentiation.
CAlglib::Spline1DConvCubic(x_old,y_old,x_new,y_new);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray1,9);
//--- initialization
temparray1[0]=1;
temparray1[1]=0.5625;
temparray1[2]=0.25;
temparray1[3]=0.0625;
temparray1[4]=0;
temparray1[5]=0.0625;
temparray1[6]=0.25;
temparray1[7]=0.5625;
temparray1[8]=1;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(y_new,temparray1,0.0001);
//--- Then,conversion with differentiation (first derivatives only)
CAlglib::Spline1DConvDiffCubic(x_old,y_old,x_new,y_new,d1_new);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray2,9);
//--- initialization
temparray2[0]=-2;
temparray2[1]=-1.5;
temparray2[2]=-1;
temparray2[3]=-0.5;
temparray2[4]=0;
temparray2[5]=0.5;
temparray2[6]=1.0;
temparray2[7]=1.5;
temparray2[8]=2;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(y_new,temparray1,0.0001);
_TestResult=_TestResult && Doc_Test_Real_Vector(d1_new,temparray2,0.0001);
//--- Finally,conversion with first and second derivatives
CAlglib::Spline1DConvDiff2Cubic(x_old,y_old,x_new,y_new,d1_new,d2_new);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray3,9);
//--- initialization
temparray3[0]=2;
temparray3[1]=2;
temparray3[2]=2;
temparray3[3]=2;
temparray3[4]=2;
temparray3[5]=2;
temparray3[6]=2;
temparray3[7]=2;
temparray3[8]=2;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(y_new,temparray1,0.0001);
_TestResult=_TestResult && Doc_Test_Real_Vector(d1_new,temparray2,0.0001);
_TestResult=_TestResult && Doc_Test_Real_Vector(d2_new,temparray3,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","spline1d_d_convdiff");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Unconstrained dense quadratic programming |
//+------------------------------------------------------------------+
void TEST_MinQP_D_U1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble a;
double b[];
double x0[];
double x[];
double temparray[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<13;_spoil_scenario++)
{
//--- This example demonstrates minimization of F(x0,x1)=x0^2 + x1^2 -6*x0 - 4*x1
//--- Exact solution is [x0,x1]=[3,2]
//--- We provide algorithm with starting point,although in this case
//--- (dense matrix,no constraints) it can work withsuch information.
//--- IMPORTANT: this solver minimizes following function:
//--- f(x)=0.5*x'*A*x + b'*x.
//--- Note that quadratic term has 0.5 before it. So if you want to minimize
//--- quadratic function,you should rewrite it in such way that quadratic term
//--- is multiplied by 0.5 too.
//--- For example,our function is f(x)=x0^2+x1^2+...,but we rewrite it as
//--- f(x)=0.5*(2*x0^2+2*x1^2) + ....
//--- and pass diag(2,2) as quadratic term - NOT diag(1,1)!
a.Resize(2,2);
//--- initialization
a[0].Set(0,2);
a[0].Set(1,0);
a[1].Set(0,0);
a[1].Set(1,2);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(a,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(a);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(a);
//--- allocation
ArrayResize(b,2);
//--- initialization
b[0]=-6;
b[1]=-4;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(b,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(b,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(b,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Deleting_Element(b);
//--- allocation
ArrayResize(x0,2);
//--- initialization
x0[0]=0;
x0[1]=1;
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Value(x0,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(x0,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Value(x0,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Deleting_Element(x0);
//--- create variables
CMinQPStateShell state;
CMinQPReportShell rep;
//--- function call
CAlglib::MinQPCreate(2,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinQPSetQuadraticTerm(state,a);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinQPSetLinearTerm(state,b);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinQPSetStartingPoint(state,x0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinQPOptimize(state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinQPResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=3;
temparray[1]=2;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minqp_d_u1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Constrained dense quadratic programming |
//+------------------------------------------------------------------+
void TEST_MinQP_D_BC1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble a;
double b[];
double x0[];
double bndl[];
double bndu[];
double temparray[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<17;_spoil_scenario++)
{
//--- This example demonstrates minimization of F(x0,x1)=x0^2 + x1^2 -6*x0 - 4*x1
//--- subject to bound constraints 0<=x0<=2.5,0<=x1<=2.5
//--- Exact solution is [x0,x1]=[2.5,2]
//--- We provide algorithm with starting point. With such small problem good starting
//--- point is not really necessary,but with high-dimensional problem it can save us
//--- a lot of time.
//--- IMPORTANT: this solver minimizes following function:
//--- f(x)=0.5*x'*A*x + b'*x.
//--- Note that quadratic term has 0.5 before it. So if you want to minimize
//--- quadratic function,you should rewrite it in such way that quadratic term
//--- is multiplied by 0.5 too.
//--- For example,our function is f(x)=x0^2+x1^2+...,but we rewrite it as
//--- f(x)=0.5*(2*x0^2+2*x1^2) + ....
//--- and pass diag(2,2) as quadratic term - NOT diag(1,1)!
a.Resize(2,2);
//--- initialization
a[0].Set(0,2);
a[0].Set(1,0);
a[1].Set(0,0);
a[1].Set(1,2);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(a,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(a,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(a,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(a);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(a);
//--- allocation
ArrayResize(b,2);
//--- initialization
b[0]=-6;
b[1]=-4;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(b,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(b,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(b,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Deleting_Element(b);
//--- allocation
ArrayResize(x0,2);
//--- initialization
x0[0]=0;
x0[1]=1;
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Value(x0,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(x0,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Value(x0,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Deleting_Element(x0);
//--- allocation
ArrayResize(bndl,2);
//--- initialization
bndl[0]=0;
bndl[1]=0;
//--- check
if(_spoil_scenario==13)
Spoil_Vector_By_Value(bndl,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==14)
Spoil_Vector_By_Deleting_Element(bndl);
//--- allocation
ArrayResize(bndu,2);
//--- initialization
bndu[0]=2.5;
bndu[1]=2.5;
//--- check
if(_spoil_scenario==15)
Spoil_Vector_By_Value(bndu,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==16)
Spoil_Vector_By_Deleting_Element(bndu);
double x[];
CMinQPStateShell state;
CMinQPReportShell rep;
//--- function call
CAlglib::MinQPCreate(2,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinQPSetQuadraticTerm(state,a);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinQPSetLinearTerm(state,b);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinQPSetStartingPoint(state,x0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinQPSetBC(state,bndl,bndu);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinQPOptimize(state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinQPResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=2.5;
temparray[1]=2;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minqp_d_bc1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear least squares optimization using function vector only |
//+------------------------------------------------------------------+
void TEST_MinLM_D_V(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_FVec1 ffvec;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- This example demonstrates minimization of F(x0,x1)=f0^2+f1^2,where
//--- f0(x0,x1)=10*(x0+3)^2
//--- f1(x0,x1)=(x1-3)^2
//--- using "V" mode of the Levenberg-Marquardt optimizer.
//--- Optimization algorithm uses:
//--- * function vector f[]={f1,f2}
//--- No other information (Jacobian,gradient,etc.) is needed.
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
int maxits=0;
//--- objects of classes
CMinLMStateShell state;
CMinLMReportShell rep;
//--- function call
CAlglib::MinLMCreateV(2,x,0.0001,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMOptimize(state,ffvec,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minlm_d_v");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear least squares optimization using function vector and |
//| Jacobian |
//+------------------------------------------------------------------+
void TEST_MinLM_D_VJ(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
//--- TEST minlm_d_vj
//--- Nonlinear least squares optimization using function vector and Jacobian
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_FVec1 ffvec;
CNDimensional_Jac1 fjac;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- This example demonstrates minimization of F(x0,x1)=f0^2+f1^2,where
//--- f0(x0,x1)=10*(x0+3)^2
//--- f1(x0,x1)=(x1-3)^2
//--- using "VJ" mode of the Levenberg-Marquardt optimizer.
//--- Optimization algorithm uses:
//--- * function vector f[]={f1,f2}
//--- * Jacobian matrix J={dfi/dxj}.
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
CMinLMStateShell state;
CMinLMReportShell rep;
//--- function call
CAlglib::MinLMCreateVJ(2,x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMOptimize(state,ffvec,fjac,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minlm_d_vj");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear Hessian-based optimization for general functions |
//+------------------------------------------------------------------+
void TEST_MinLM_D_FGH(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_Func1 ffunc;
CNDimensional_Grad1 fgrad;
CNDimensional_Hess1 fhess;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- This example demonstrates minimization of F(x0,x1)=100*(x0+3)^4+(x1-3)^4
//--- using "FGH" mode of the Levenberg-Marquardt optimizer.
//--- F is treated like a monolitic function withinternal structure,
//--- i.e. we do NOT represent it as a sum of squares.
//--- Optimization algorithm uses:
//--- * function value F(x0,x1)
//--- * gradient G={dF/dxi}
//--- * Hessian H={d2F/(dxi*dxj)}
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
CMinLMStateShell state;
CMinLMReportShell rep;
//--- function call
CAlglib::MinLMCreateFGH(x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMOptimize(state,ffunc,fgrad,fhess,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minlm_d_fgh");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Bound constrained nonlinear least squares optimization |
//+------------------------------------------------------------------+
void TEST_MinLM_D_VB(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double bndl[];
double bndu[];
double temparray[];
CObject obj;
CNDimensional_FVec1 ffvec;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<16;_spoil_scenario++)
{
//--- This example demonstrates minimization of F(x0,x1)=f0^2+f1^2,where
//--- f0(x0,x1)=10*(x0+3)^2
//--- f1(x0,x1)=(x1-3)^2
//--- with boundary constraints
//--- -1 <= x0 <= +1
//--- -1 <= x1 <= +1
//--- using "V" mode of the Levenberg-Marquardt optimizer.
//--- Optimization algorithm uses:
//--- * function vector f[]={f1,f2}
//--- No other information (Jacobian,gradient,etc.) is needed.
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- allocation
ArrayResize(bndl,2);
//--- initialization
bndl[0]=-1;
bndl[1]=-1;
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Value(bndl,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(bndl);
//--- allocation
ArrayResize(bndu,2);
//--- initialization
bndu[0]=1;
bndu[1]=1;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(bndu,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Deleting_Element(bndu);
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==7)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==8)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==9)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==10)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==11)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==12)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==13)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==14)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==15)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
CMinLMStateShell state;
CMinLMReportShell rep;
//--- function call
CAlglib::MinLMCreateV(2,x,0.0001,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMSetBC(state,bndl,bndu);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMOptimize(state,ffvec,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-1;
temparray[1]=1;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minlm_d_vb");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Efficient restarts of LM optimizer |
//+------------------------------------------------------------------+
void TEST_MinLM_D_Restarts(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_FVec1 ffvec1;
CNDimensional_FVec2 ffvec2;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<15;_spoil_scenario++)
{
//--- This example demonstrates minimization of F(x0,x1)=f0^2+f1^2,where
//--- f0(x0,x1)=10*(x0+3)^2
//--- f1(x0,x1)=(x1-3)^2
//--- using several starting points and efficient restarts.
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==0)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==1)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==2)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==3)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==6)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
CMinLMStateShell state;
CMinLMReportShell rep;
//--- create optimizer using minlmcreatev()
ArrayResize(x,2);
//--- initialization
x[0]=10;
x[1]=10;
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::MinLMCreateV(2,x,0.0001,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMOptimize(state,ffvec1,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
//--- restart optimizer using minlmrestartfrom()
//--- we can use different starting point,different function,
//--- different stopping conditions,but problem size
//--- must remain unchanged.
ArrayResize(x,2);
//--- initialization
x[0]=4;
x[1]=4;
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==13)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==14)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- function call
CAlglib::MinLMRestartFrom(state,x);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMOptimize(state,ffvec2,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=0;
temparray[1]=1;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minlm_d_restarts");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear least squares optimization, FJ scheme (obsolete, but |
//| supported) |
//+------------------------------------------------------------------+
void TEST_MinLM_T_1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_Func1 ffunc;
CNDimensional_Jac1 fjac;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- allocation
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
int maxits=0;
CMinLMStateShell state;
CMinLMReportShell rep;
//--- function call
CAlglib::MinLMCreateFJ(2,x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMOptimize(state,ffunc,fjac,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minlm_t_1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear least squares optimization, FGJ scheme (obsolete, but |
//| supported) |
//+------------------------------------------------------------------+
void TEST_MinLM_T_2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double temparray[];
CObject obj;
CNDimensional_Func1 ffunc;
CNDimensional_Grad1 fgrad;
CNDimensional_Jac1 fjac;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<12;_spoil_scenario++)
{
//--- allocation
ArrayResize(x,2);
//--- initialization
x[0]=0;
x[1]=0;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
double epsg=0.0000000001;
//--- check
if(_spoil_scenario==3)
epsg=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==4)
epsg=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==5)
epsg=CInfOrNaN::NegativeInfinity();
double epsf=0;
//--- check
if(_spoil_scenario==6)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==7)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==8)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0;
//--- check
if(_spoil_scenario==9)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==10)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
CMinLMStateShell state;
CMinLMReportShell rep;
//--- function call
CAlglib::MinLMCreateFGJ(2,x,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMSetCond(state,epsg,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMOptimize(state,ffunc,fgrad,fjac,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::MinLMResults(state,x,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=-3;
temparray[1]=3;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(rep.GetTerminationType(),4);
_TestResult=_TestResult && Doc_Test_Real_Vector(x,temparray,0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","minlm_t_2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear fitting using function value only |
//+------------------------------------------------------------------+
void TEST_LSFit_D_NLF(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble x;
double y[];
double c[];
double temparray[];
double w[];
CObject obj;
CNDimensional_CX_1_Func fcx1func;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<27;_spoil_scenario++)
{
//--- In this example we demonstrate exponential fitting
//--- by f(x)=exp(-c*x^2)
//--- using function value only.
//--- Gradient is estimated using combination of numerical differences
//--- and secant updates. diffstep variable stores differentiation step
//--- (we have to tell algorithm what step to use).
x.Resize(11,1);
//--- initialization
x[0].Set(0,-1);
x[1].Set(0,-0.8);
x[2].Set(0,-0.6);
x[3].Set(0,-0.4);
x[4].Set(0,-0.2);
x[5].Set(0,0);
x[6].Set(0,0.2);
x[7].Set(0,0.4);
x[8].Set(0,0.6);
x[9].Set(0,0.8);
x[10].Set(0,1);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(x);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(x);
//--- allocation
ArrayResize(y,11);
//--- initialization
y[0]=0.22313;
y[1]=0.382893;
y[2]=0.582748;
y[3]=0.786628;
y[4]=0.941765;
y[5]=1;
y[6]=0.941765;
y[7]=0.786628;
y[8]=0.582748;
y[9]=0.382893;
y[10]=0.22313;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
//--- allocation
ArrayResize(c,1);
//--- initialization
c[0]=0.3;
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(c,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Value(c,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Value(c,CInfOrNaN::NegativeInfinity());
double epsf=0;
//--- check
if(_spoil_scenario==13)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==14)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==15)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0.000001;
//--- check
if(_spoil_scenario==16)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==17)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==18)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
int info;
CLSFitStateShell state;
CLSFitReportShell rep;
double diffstep=0.0001;
//--- check
if(_spoil_scenario==19)
diffstep=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==20)
diffstep=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==21)
diffstep=CInfOrNaN::NegativeInfinity();
//--- Fitting withweights
CAlglib::LSFitCreateF(x,y,c,diffstep,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitSetCond(state,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitFit(state,fcx1func,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitResults(state,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=1.5;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,2);
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,0.05);
//--- Fitting with weights
//--- (you can change weights and see how it changes result)
ArrayResize(w,11);
//--- initialization
w[0]=1;
w[1]=1;
w[2]=1;
w[3]=1;
w[4]=1;
w[5]=1;
w[6]=1;
w[7]=1;
w[8]=1;
w[9]=1;
w[10]=1;
//--- check
if(_spoil_scenario==22)
Spoil_Vector_By_Value(w,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==23)
Spoil_Vector_By_Value(w,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==24)
Spoil_Vector_By_Value(w,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==25)
Spoil_Vector_By_Adding_Element(w);
//--- check
if(_spoil_scenario==26)
Spoil_Vector_By_Deleting_Element(w);
//--- function call
CAlglib::LSFitCreateWF(x,y,w,c,diffstep,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitSetCond(state,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitFit(state,fcx1func,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitResults(state,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=1.5;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,2);
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,0.05);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_d_nlf");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear fitting using gradient |
//+------------------------------------------------------------------+
void TEST_LSFit_D_NLFG(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble x;
double y[];
double c[];
double temparray[];
double w[];
CObject obj;
CNDimensional_CX_1_Func fcx1func;
CNDimensional_CX_1_Grad fcx1grad;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<24;_spoil_scenario++)
{
//--- In this example we demonstrate exponential fitting
//--- by f(x)=exp(-c*x^2)
//--- using function value and gradient (with respect to c).
x.Resize(11,1);
//--- initialization
x[0].Set(0,-1);
x[1].Set(0,-0.8);
x[2].Set(0,-0.6);
x[3].Set(0,-0.4);
x[4].Set(0,-0.2);
x[5].Set(0,0);
x[6].Set(0,0.2);
x[7].Set(0,0.4);
x[8].Set(0,0.6);
x[9].Set(0,0.8);
x[10].Set(0,1);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(x);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(x);
//--- allocation
ArrayResize(y,11);
//--- initialization
y[0]=0.22313;
y[1]=0.382893;
y[2]=0.582748;
y[3]=0.786628;
y[4]=0.941765;
y[5]=1;
y[6]=0.941765;
y[7]=0.786628;
y[8]=0.582748;
y[9]=0.382893;
y[10]=0.22313;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
//--- allocation
ArrayResize(c,1);
//--- initialization
c[0]=0.3;
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(c,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Value(c,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Value(c,CInfOrNaN::NegativeInfinity());
double epsf=0;
//--- check
if(_spoil_scenario==13)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==14)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==15)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0.000001;
//--- check
if(_spoil_scenario==16)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==17)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==18)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
int info;
CLSFitStateShell state;
CLSFitReportShell rep;
//--- Fitting withweights
CAlglib::LSFitCreateFG(x,y,c,true,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitSetCond(state,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitFit(state,fcx1func,fcx1grad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitResults(state,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=1.5;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,2);
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,0.05);
//--- Fitting with weights
//--- (you can change weights and see how it changes result)
ArrayResize(w,11);
//--- initialization
w[0]=1;
w[1]=1;
w[2]=1;
w[3]=1;
w[4]=1;
w[5]=1;
w[6]=1;
w[7]=1;
w[8]=1;
w[9]=1;
w[10]=1;
//--- check
if(_spoil_scenario==19)
Spoil_Vector_By_Value(w,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==20)
Spoil_Vector_By_Value(w,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==21)
Spoil_Vector_By_Value(w,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==22)
Spoil_Vector_By_Adding_Element(w);
//--- check
if(_spoil_scenario==23)
Spoil_Vector_By_Deleting_Element(w);
//--- function call
CAlglib::LSFitCreateWFG(x,y,w,c,true,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitSetCond(state,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitFit(state,fcx1func,fcx1grad,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitResults(state,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=1.5;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,2);
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,0.05);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_d_nlfg");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear fitting using gradient and Hessian |
//+------------------------------------------------------------------+
void TEST_LSFit_D_NLFGH(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble x;
double y[];
double c[];
double temparray[];
double w[];
CObject obj;
CNDimensional_CX_1_Func fcx1func;
CNDimensional_CX_1_Grad fcx1grad;
CNDimensional_CX_1_Hess fcx1hess;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<24;_spoil_scenario++)
{
//--- In this example we demonstrate exponential fitting
//--- by f(x)=exp(-c*x^2)
//--- using function value,gradient and Hessian (with respect to c)
x.Resize(11,1);
//--- initialization
x[0].Set(0,-1);
x[1].Set(0,-0.8);
x[2].Set(0,-0.6);
x[3].Set(0,-0.4);
x[4].Set(0,-0.2);
x[5].Set(0,0);
x[6].Set(0,0.2);
x[7].Set(0,0.4);
x[8].Set(0,0.6);
x[9].Set(0,0.8);
x[10].Set(0,1);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(x);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(x);
//--- allocation
ArrayResize(y,11);
//--- initialization
y[0]=0.22313;
y[1]=0.382893;
y[2]=0.582748;
y[3]=0.786628;
y[4]=0.941765;
y[5]=1;
y[6]=0.941765;
y[7]=0.786628;
y[8]=0.582748;
y[9]=0.382893;
y[10]=0.22313;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
//--- allocation
ArrayResize(c,1);
//--- initialization
c[0]=0.3;
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(c,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Value(c,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Value(c,CInfOrNaN::NegativeInfinity());
double epsf=0;
//--- check
if(_spoil_scenario==13)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==14)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==15)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0.000001;
//--- check
if(_spoil_scenario==16)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==17)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==18)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
int info;
CLSFitStateShell state;
CLSFitReportShell rep;
//--- Fitting withweights
CAlglib::LSFitCreateFGH(x,y,c,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitSetCond(state,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitFit(state,fcx1func,fcx1grad,fcx1hess,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitResults(state,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=1.5;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,2);
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,0.05);
//--- Fitting with weights
//--- (you can change weights and see how it changes result)
ArrayResize(w,11);
//--- initialization
w[0]=1;
w[1]=1;
w[2]=1;
w[3]=1;
w[4]=1;
w[5]=1;
w[6]=1;
w[7]=1;
w[8]=1;
w[9]=1;
w[10]=1;
//--- check
if(_spoil_scenario==19)
Spoil_Vector_By_Value(w,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==20)
Spoil_Vector_By_Value(w,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==21)
Spoil_Vector_By_Value(w,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==22)
Spoil_Vector_By_Adding_Element(w);
//--- check
if(_spoil_scenario==23)
Spoil_Vector_By_Deleting_Element(w);
//--- function call
CAlglib::LSFitCreateWFGH(x,y,w,c,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitSetCond(state,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitFit(state,fcx1func,fcx1grad,fcx1hess,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitResults(state,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=1.5;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,2);
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,0.05);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_d_nlfgh");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Bound contstrained nonlinear fitting using function value only |
//+------------------------------------------------------------------+
void TEST_LSFit_D_NLFB(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble x;
double y[];
double c[];
double temparray[];
double w[];
double bndl[];
double bndu[];
CObject obj;
CNDimensional_CX_1_Func fcx1func;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<26;_spoil_scenario++)
{
//--- In this example we demonstrate exponential fitting by
//--- f(x)=exp(-c*x^2)
//--- subject to bound constraints
//--- 0.0 <= c <= 1.0
//--- using function value only.
//--- Gradient is estimated using combination of numerical differences
//--- and secant updates. diffstep variable stores differentiation step
//--- (we have to tell algorithm what step to use).
//--- Unconstrained solution is c=1.5,but because of constraints we should
//--- get c=1.0 (at the boundary).
x.Resize(11,1);
//--- initialization
x[0].Set(0,-1);
x[1].Set(0,-0.8);
x[2].Set(0,-0.6);
x[3].Set(0,-0.4);
x[4].Set(0,-0.2);
x[5].Set(0,0);
x[6].Set(0,0.2);
x[7].Set(0,0.4);
x[8].Set(0,0.6);
x[9].Set(0,0.8);
x[10].Set(0,1);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(x);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(x);
//--- allocation
ArrayResize(y,11);
//--- initialization
y[0]=0.22313;
y[1]=0.382893;
y[2]=0.582748;
y[3]=0.786628;
y[4]=0.941765;
y[5]=1;
y[6]=0.941765;
y[7]=0.786628;
y[8]=0.582748;
y[9]=0.382893;
y[10]=0.22313;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
//--- allocation
ArrayResize(c,1);
//--- initialization
c[0]=0.3;
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(c,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Value(c,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Value(c,CInfOrNaN::NegativeInfinity());
//--- allocation
ArrayResize(bndl,1);
//--- initialization
bndl[0]=0;
//--- check
if(_spoil_scenario==13)
Spoil_Vector_By_Value(bndl,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==14)
Spoil_Vector_By_Deleting_Element(bndl);
//--- allocation
ArrayResize(bndu,1);
//--- initialization
bndu[0]=1;
//--- check
if(_spoil_scenario==15)
Spoil_Vector_By_Value(bndu,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==16)
Spoil_Vector_By_Deleting_Element(bndu);
double epsf=0;
//--- check
if(_spoil_scenario==17)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==18)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==19)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=0.000001;
//--- check
if(_spoil_scenario==20)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==21)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==22)
epsx=CInfOrNaN::NegativeInfinity();
//--- create variables
int maxits=0;
int info;
CLSFitStateShell state;
CLSFitReportShell rep;
double diffstep=0.0001;
//--- check
if(_spoil_scenario==23)
diffstep=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==24)
diffstep=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==25)
diffstep=CInfOrNaN::NegativeInfinity();
//--- function call
CAlglib::LSFitCreateF(x,y,c,diffstep,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitSetBC(state,bndl,bndu);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitSetCond(state,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitFit(state,fcx1func,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitResults(state,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=1;
//--- check result
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,0.05);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_d_nlfb");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Nonlinear fitting with custom scaling and bound constraints |
//+------------------------------------------------------------------+
void TEST_LSFit_D_NLScale(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble x;
double y[];
double c[];
double bndl[];
double bndu[];
double s[];
double temparray[];
CObject obj;
CNDimensional_Debt_Func fdebtfunc;
CNDimensional_Rep frep;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<30;_spoil_scenario++)
{
//--- In this example we demonstrate fitting by
//--- f(x)=c[0]*(1+c[1]*((x-1999)^c[2]-1))
//--- subject to bound constraints
//--- -INF < c[0] < +INF
//--- -10 <= c[1] <= +10
//--- 0.1 <= c[2] <= 2.0
//--- Data we want to fit are time series of Japan national debt
//--- collected from 2000 to 2008 measured in USD (dollars,not
//--- millions of dollars).
//--- Our variables are:
//--- c[0] - debt value at initial moment (2000),
//--- c[1] - direction coefficient (growth or decrease),
//--- c[2] - curvature coefficient.
//--- You may see that our variables are badly scaled - first one
//--- is order of 10^12,and next two are somewhere ab1 in
//--- magnitude. Such problem is difficult to solve withsome
//--- kind of scaling.
//--- That is exactly where lsfitsetscale() function can be used.
//--- We set scale of our variables to [1.0E12,1,1],which allows
//--- us to easily solve this problem.
//--- You can try commenting lsfitsetscale() call - and you will
//--- see that algorithm will fail to converge.
x.Resize(9,1);
//--- initialization
x[0].Set(0,2000);
x[1].Set(0,2001);
x[2].Set(0,2002);
x[3].Set(0,2003);
x[4].Set(0,2004);
x[5].Set(0,2005);
x[6].Set(0,2006);
x[7].Set(0,2007);
x[8].Set(0,2008);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(x);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(x);
//--- allocation
ArrayResize(y,9);
//--- initialization
y[0]=4323239600000.0;
y[1]=4560913100000.0;
y[2]=5564091500000.0;
y[3]=6743189300000.0;
y[4]=7284064600000.0;
y[5]=7050129600000.0;
y[6]=7092221500000.0;
y[7]=8483907600000.0;
y[8]=8625804400000.0;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
//--- allocation
ArrayResize(c,3);
//--- initialization
c[0]=1.0e+13;
c[1]=1;
c[2]=1;
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(c,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Value(c,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Value(c,CInfOrNaN::NegativeInfinity());
double epsf=0;
//--- check
if(_spoil_scenario==13)
epsf=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==14)
epsf=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==15)
epsf=CInfOrNaN::NegativeInfinity();
double epsx=1.0e-5;
//--- check
if(_spoil_scenario==16)
epsx=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==17)
epsx=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==18)
epsx=CInfOrNaN::NegativeInfinity();
//--- allocation
ArrayResize(bndl,3);
//--- initialization
bndl[0]=-CInfOrNaN::PositiveInfinity();
bndl[1]=-10;
bndl[2]=0.1;
//--- check
if(_spoil_scenario==19)
Spoil_Vector_By_Value(bndl,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==20)
Spoil_Vector_By_Deleting_Element(bndl);
//--- allocation
ArrayResize(bndu,3);
//--- initialization
bndu[0]=CInfOrNaN::PositiveInfinity();
bndu[1]=10;
bndu[2]=2;
//--- check
if(_spoil_scenario==21)
Spoil_Vector_By_Value(bndu,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==22)
Spoil_Vector_By_Deleting_Element(bndu);
//--- allocation
ArrayResize(s,3);
//--- initialization
s[0]=1.0e+12;
s[1]=1;
s[2]=1;
//--- check
if(_spoil_scenario==23)
Spoil_Vector_By_Value(s,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==24)
Spoil_Vector_By_Value(s,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==25)
Spoil_Vector_By_Value(s,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==26)
Spoil_Vector_By_Deleting_Element(s);
//--- create variables
int maxits=0;
int info;
CLSFitStateShell state;
CLSFitReportShell rep;
double diffstep=1.0e-5;
//--- check
if(_spoil_scenario==27)
diffstep=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==28)
diffstep=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==29)
diffstep=CInfOrNaN::NegativeInfinity();
//--- function call
CAlglib::LSFitCreateF(x,y,c,diffstep,state);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitSetCond(state,epsf,epsx,maxits);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitSetBC(state,bndl,bndu);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitSetScale(state,s);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitFit(state,fdebtfunc,frep,0,obj);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
CAlglib::LSFitResults(state,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,3);
//--- initialization
temparray[0]=4.142560e+12;
temparray[1]=0.43424;
temparray[2]=0.565376;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,2);
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,-0.005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_d_nlscale");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Unconstrained (general) linear least squares fitting with and |
//| withweights |
//+------------------------------------------------------------------+
void TEST_LSFit_D_Lin(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble fmatrix;
int info;
double c[];
double y[];
double temparray[];
double w[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<13;_spoil_scenario++)
{
//--- In this example we demonstrate linear fitting by f(x|a)=a*exp(0.5*x).
//--- We have:
//--- * y - vector of experimental data
//--- * fmatrix - matrix of basis functions calculated at sample points
//--- Actually,we have only one basis function F0=exp(0.5*x).
fmatrix.Resize(11,1);
//--- initialization
fmatrix[0].Set(0,0.606531);
fmatrix[1].Set(0,0.67032);
fmatrix[2].Set(0,0.740818);
fmatrix[3].Set(0,0.818731);
fmatrix[4].Set(0,0.904837);
fmatrix[5].Set(0,1);
fmatrix[6].Set(0,1.105171);
fmatrix[7].Set(0,1.221403);
fmatrix[8].Set(0,1.349859);
fmatrix[9].Set(0,1.491825);
fmatrix[10].Set(0,1.648721);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(fmatrix,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(fmatrix,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(fmatrix,CInfOrNaN::NegativeInfinity());
//--- allocation
ArrayResize(y,11);
//--- initialization
y[0]=1.133719;
y[1]=1.306522;
y[2]=1.504604;
y[3]=1.554663;
y[4]=1.884638;
y[5]=2.072436;
y[6]=2.257285;
y[7]=2.534068;
y[8]=2.622017;
y[9]=2.897713;
y[10]=3.219371;
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Deleting_Element(y);
//--- create a variable
CLSFitReportShell rep;
//--- Linear fitting withweights
CAlglib::LSFitLinear(y,fmatrix,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=1.9865;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,1);
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,0.00005);
//--- Linear fitting with individual weights.
//--- Slightly different result is returned.
ArrayResize(w,11);
//--- initialization
w[0]=1.414213;
w[1]=1;
w[2]=1;
w[3]=1;
w[4]=1;
w[5]=1;
w[6]=1;
w[7]=1;
w[8]=1;
w[9]=1;
w[10]=1;
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Value(w,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Value(w,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(w,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Adding_Element(w);
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Deleting_Element(w);
//--- function call
CAlglib::LSFitLinearW(y,w,fmatrix,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,1);
//--- initialization
temparray[0]=1.983354;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,1);
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,0.00005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_d_lin");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Constrained (general) linear least squares fitting with and |
//| withweights |
//+------------------------------------------------------------------+
void TEST_LSFit_D_Linc(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
CMatrixDouble fmatrix;
CMatrixDouble cmatrix;
double y[];
double c[];
double temparray[];
double w[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<20;_spoil_scenario++)
{
//--- In this example we demonstrate linear fitting by f(x|a,b)=a*x+b
//--- with simple constraint f(0)=0.
//--- We have:
//--- * y - vector of experimental data
//--- * fmatrix - matrix of basis functions sampled at [0,1] with step 0.2:
//--- [ 1.0 0.0 ]
//--- [ 1.0 0.2 ]
//--- [ 1.0 0.4 ]
//--- [ 1.0 0.6 ]
//--- [ 1.0 0.8 ]
//--- [ 1.0 1.0 ]
//--- first column contains value of first basis function (constant term)
//--- second column contains second basis function (linear term)
//--- * cmatrix - matrix of linear constraints:
//--- [ 1.0 0.0 0.0 ]
//--- first two columns contain coefficients before basis functions,
//--- last column contains desired value of their sum.
//--- So [1,0,0] means "1*constant_term + 0*linear_term=0"
ArrayResize(y,6);
//--- initialization
y[0]=0.072436;
y[1]=0.246944;
y[2]=0.491263;
y[3]=0.5223;
y[4]=0.714064;
y[5]=0.921929;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(y);
//--- allocation
fmatrix.Resize(6,2);
//--- initialization
fmatrix[0].Set(0,1);
fmatrix[0].Set(1,0);
fmatrix[1].Set(0,1);
fmatrix[1].Set(1,0.2);
fmatrix[2].Set(0,1);
fmatrix[2].Set(1,0.4);
fmatrix[3].Set(0,1);
fmatrix[3].Set(1,0.6);
fmatrix[4].Set(0,1);
fmatrix[4].Set(1,0.8);
fmatrix[5].Set(0,1);
fmatrix[5].Set(1,1);
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Value(fmatrix,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Matrix_By_Value(fmatrix,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Matrix_By_Value(fmatrix,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Matrix_By_Adding_Row(fmatrix);
//--- check
if(_spoil_scenario==9)
Spoil_Matrix_By_Adding_Col(fmatrix);
//--- check
if(_spoil_scenario==10)
Spoil_Matrix_By_Deleting_Row(fmatrix);
//--- check
if(_spoil_scenario==11)
Spoil_Matrix_By_Deleting_Col(fmatrix);
//--- allocation
cmatrix.Resize(1,3);
//--- initialization
cmatrix[0].Set(0,1);
cmatrix[0].Set(1,0);
cmatrix[0].Set(2,0);
//--- check
if(_spoil_scenario==12)
Spoil_Matrix_By_Value(cmatrix,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==13)
Spoil_Matrix_By_Value(cmatrix,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==14)
Spoil_Matrix_By_Value(cmatrix,CInfOrNaN::NegativeInfinity());
//--- create variables
int info;
CLSFitReportShell rep;
//--- Constrained fitting withweights
CAlglib::LSFitLinearC(y,fmatrix,cmatrix,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=0;
temparray[1]=0.932933;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,1);
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,0.0005);
//--- Constrained fitting with individual weights
ArrayResize(w,6);
//--- initialization
w[0]=1;
w[1]=1.414213;
w[2]=1;
w[3]=1;
w[4]=1;
w[5]=1;
//--- check
if(_spoil_scenario==15)
Spoil_Vector_By_Value(w,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==16)
Spoil_Vector_By_Value(w,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==17)
Spoil_Vector_By_Value(w,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==18)
Spoil_Vector_By_Adding_Element(w);
//--- check
if(_spoil_scenario==19)
Spoil_Vector_By_Deleting_Element(w);
//--- function call
CAlglib::LSFitLinearWC(y,w,fmatrix,cmatrix,info,c,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- allocation
ArrayResize(temparray,2);
//--- initialization
temparray[0]=0;
temparray[1]=0.938322;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,1);
_TestResult=_TestResult && Doc_Test_Real_Vector(c,temparray,0.0005);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_d_linc");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Unconstrained polynomial fitting |
//+------------------------------------------------------------------+
void TEST_LSFit_D_Pol(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
double w[];
double xc[];
double yc[];
int dc[];
int m;
double t;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<20;_spoil_scenario++)
{
//--- This example demonstrates polynomial fitting.
//--- Fitting is done by two (M=2) functions from polynomial basis:
//--- f0=1
//--- f1=x
//--- Basically,it just a linear fit;more complex polynomials may be used
//--- (e.g. parabolas with M=3,cubic with M=4),but even such simple fit allows
//--- us to demonstrate polynomialfit() function in action.
//--- We have:
//--- * x set of abscissas
//--- * y experimental data
//--- Additionally we demonstrate weighted fitting,where second point has
//--- more weight than other ones.
ArrayResize(x,11);
//--- initialization
x[0]=0;
x[1]=0.1;
x[2]=0.2;
x[3]=0.3;
x[4]=0.4;
x[5]=0.5;
x[6]=0.6;
x[7]=0.7;
x[8]=0.8;
x[9]=0.9;
x[10]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Adding_Element(x);
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,11);
//--- initialization
y[0]=0;
y[1]=0.05;
y[2]=0.26;
y[3]=0.32;
y[4]=0.33;
y[5]=0.43;
y[6]=0.6;
y[7]=0.6;
y[8]=0.77;
y[9]=0.98;
y[10]=1.02;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
m=2;
t=2;
//--- check
if(_spoil_scenario==10)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==11)
t=CInfOrNaN::NegativeInfinity();
//--- create variables
int info;
CBarycentricInterpolantShell p;
CPolynomialFitReportShell rep;
//--- Fitting withindividual weights
//--- NOTE: result is returned as barycentricinterpolant structure.
//--- if you want to get representation in the power basis,
//--- you can use barycentricbar2pow() function to convert
//--- from barycentric to power representation (see docs for
//--- POLINT subpackage for more info).
CAlglib::PolynomialFit(x,y,m,info,p,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.011,0.002);
//--- Fitting with individual weights
//--- NOTE: slightly different result is returned
ArrayResize(w,11);
//--- initialization
w[0]=1;
w[1]=1.414213562;
w[2]=1;
w[3]=1;
w[4]=1;
w[5]=1;
w[6]=1;
w[7]=1;
w[8]=1;
w[9]=1;
w[10]=1;
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Value(w,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==13)
Spoil_Vector_By_Value(w,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==14)
Spoil_Vector_By_Value(w,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==15)
Spoil_Vector_By_Adding_Element(w);
//--- check
if(_spoil_scenario==16)
Spoil_Vector_By_Deleting_Element(w);
//--- allocation
ArrayResize(xc,0);
//--- check
if(_spoil_scenario==17)
Spoil_Vector_By_Adding_Element(xc);
//--- allocation
ArrayResize(yc,0);
//--- check
if(_spoil_scenario==18)
Spoil_Vector_By_Adding_Element(yc);
//--- allocation
ArrayResize(dc,0);
//--- check
if(_spoil_scenario==19)
Spoil_Vector_By_Adding_Element(dc);
//--- function call
CAlglib::PolynomialFitWC(x,y,w,xc,yc,dc,m,info,p,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.023,0.002);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_d_pol");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Constrained polynomial fitting |
//+------------------------------------------------------------------+
void TEST_LSFit_D_Polc(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
double w[];
double xc[];
double yc[];
int dc[];
int m;
int info;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<29;_spoil_scenario++)
{
//--- This example demonstrates polynomial fitting.
//--- Fitting is done by two (M=2) functions from polynomial basis:
//--- f0=1
//--- f1=x
//--- with simple constraint on function value
//--- f(0)=0
//--- Basically,it just a linear fit;more complex polynomials may be used
//--- (e.g. parabolas with M=3,cubic with M=4),but even such simple fit allows
//--- us to demonstrate polynomialfit() function in action.
//--- We have:
//--- * x set of abscissas
//--- * y experimental data
//--- * xc points where constraints are placed
//--- * yc constraints on derivatives
//--- * dc derivative indices
//--- (0 means function itself,1 means first derivative)
ArrayResize(x,2);
//--- initialization
x[0]=1;
x[1]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Adding_Element(x);
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,2);
//--- initialization
y[0]=0.9;
y[1]=1.1;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
//--- allocation
ArrayResize(w,2);
//--- initialization
w[0]=1;
w[1]=1;
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(w,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Value(w,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Value(w,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==13)
Spoil_Vector_By_Adding_Element(w);
//--- check
if(_spoil_scenario==14)
Spoil_Vector_By_Deleting_Element(w);
//--- allocation
ArrayResize(xc,1);
//--- initialization
xc[0]=0;
//--- check
if(_spoil_scenario==15)
Spoil_Vector_By_Value(xc,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==16)
Spoil_Vector_By_Value(xc,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==17)
Spoil_Vector_By_Value(xc,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==18)
Spoil_Vector_By_Adding_Element(xc);
//--- check
if(_spoil_scenario==19)
Spoil_Vector_By_Deleting_Element(xc);
//--- allocation
ArrayResize(yc,1);
//--- initialization
yc[0]=0;
//--- check
if(_spoil_scenario==20)
Spoil_Vector_By_Value(yc,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==21)
Spoil_Vector_By_Value(yc,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==22)
Spoil_Vector_By_Value(yc,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==23)
Spoil_Vector_By_Adding_Element(yc);
//--- check
if(_spoil_scenario==24)
Spoil_Vector_By_Deleting_Element(yc);
//--- allocation
ArrayResize(dc,1);
//--- initialization
dc[0]=0;
//--- check
if(_spoil_scenario==25)
Spoil_Vector_By_Adding_Element(dc);
//--- check
if(_spoil_scenario==26)
Spoil_Vector_By_Deleting_Element(dc);
double t=2;
//--- check
if(_spoil_scenario==27)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==28)
t=CInfOrNaN::NegativeInfinity();
m=2;
//--- create variables
CBarycentricInterpolantShell p;
CPolynomialFitReportShell rep;
//--- function call
CAlglib::PolynomialFitWC(x,y,w,xc,yc,dc,m,info,p,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.000,0.001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_d_polc");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Unconstrained fitting by penalized regression spline |
//+------------------------------------------------------------------+
void TEST_LSFit_D_Spline(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
int info;
double v;
double rho;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<19;_spoil_scenario++)
{
//--- In this example we demonstrate penalized spline fitting of noisy data
//--- We have:
//--- * x - abscissas
//--- * y - vector of experimental data,straight line with small noise
ArrayResize(x,10);
//--- initialization
x[0]=0;
x[1]=0.1;
x[2]=0.2;
x[3]=0.3;
x[4]=0.4;
x[5]=0.5;
x[6]=0.6;
x[7]=0.7;
x[8]=0.8;
x[9]=0.9;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Adding_Element(x);
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,10);
//--- initialization
y[0]=0.1;
y[1]=0;
y[2]=0.3;
y[3]=0.4;
y[4]=0.3;
y[5]=0.4;
y[6]=0.62;
y[7]=0.68;
y[8]=0.75;
y[9]=0.95;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Adding_Element(y);
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Deleting_Element(y);
//--- create variables
CSpline1DInterpolantShell s;
CSpline1DFitReportShell rep;
//--- Fit with VERY small amount of smoothing (rho=-5.0)
//--- and large number of basis functions (M=50).
//--- With such small regularization penalized spline almost fully reproduces function values
rho=-5.0;
//--- check
if(_spoil_scenario==10)
rho=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==11)
rho=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==12)
rho=CInfOrNaN::NegativeInfinity();
//--- function call
CAlglib::Spline1DFitPenalized(x,y,50,rho,info,s,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,1);
//--- function call
v=CAlglib::Spline1DCalc(s,0.0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,0.10,0.01);
//--- Fit with VERY large amount of smoothing (rho=10.0)
//--- and large number of basis functions (M=50).
//--- With such regularization our spline should become close to the straight line fit.
//--- We will compare its value in x=1.0 with results obtained from such fit.
rho=+10.0;
//--- check
if(_spoil_scenario==13)
rho=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==14)
rho=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==15)
rho=CInfOrNaN::NegativeInfinity();
//--- function call
CAlglib::Spline1DFitPenalized(x,y,50,rho,info,s,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,1);
//--- function call
v=CAlglib::Spline1DCalc(s,1.0);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,0.969,0.001);
//--- In real life applications you may need some moderate degree of fitting,
//--- so we try to fit once more with rho=3.0.
rho=+3.0;
//--- check
if(_spoil_scenario==16)
rho=CInfOrNaN::NaN();
//--- check
if(_spoil_scenario==17)
rho=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==18)
rho=CInfOrNaN::NegativeInfinity();
//--- function call
CAlglib::Spline1DFitPenalized(x,y,50,rho,info,s,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Int(info,1);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_d_spline");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial fitting, full list of parameters. |
//+------------------------------------------------------------------+
void TEST_LSFit_T_PolFit_1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
int info;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<10;_spoil_scenario++)
{
//--- allocation
ArrayResize(x,11);
//--- initialization
x[0]=0;
x[1]=0.1;
x[2]=0.2;
x[3]=0.3;
x[4]=0.4;
x[5]=0.5;
x[6]=0.6;
x[7]=0.7;
x[8]=0.8;
x[9]=0.9;
x[10]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,11);
//--- initialization
y[0]=0;
y[1]=0.05;
y[2]=0.26;
y[3]=0.32;
y[4]=0.33;
y[5]=0.43;
y[6]=0.6;
y[7]=0.6;
y[8]=0.77;
y[9]=0.98;
y[10]=1.02;
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Deleting_Element(y);
int m=2;
double t=2;
//--- check
if(_spoil_scenario==8)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==9)
t=CInfOrNaN::NegativeInfinity();
//--- create variables
CBarycentricInterpolantShell p;
CPolynomialFitReportShell rep;
//--- function call
CAlglib::PolynomialFit(x,y,11,m,info,p,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.011,0.002);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_t_polfit_1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial fitting, full list of parameters. |
//+------------------------------------------------------------------+
void TEST_LSFit_T_PolFit_2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
double w[];
double xc[];
double yc[];
int dc[];
int m;
double t;
int info;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<14;_spoil_scenario++)
{
//--- allocation
ArrayResize(x,11);
//--- initialization
x[0]=0;
x[1]=0.1;
x[2]=0.2;
x[3]=0.3;
x[4]=0.4;
x[5]=0.5;
x[6]=0.6;
x[7]=0.7;
x[8]=0.8;
x[9]=0.9;
x[10]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,11);
//--- initialization
y[0]=0;
y[1]=0.05;
y[2]=0.26;
y[3]=0.32;
y[4]=0.33;
y[5]=0.43;
y[6]=0.6;
y[7]=0.6;
y[8]=0.77;
y[9]=0.98;
y[10]=1.02;
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Deleting_Element(y);
//--- allocation
ArrayResize(w,11);
//--- initialization
w[0]=1;
w[1]=1.414213562;
w[2]=1;
w[3]=1;
w[4]=1;
w[5]=1;
w[6]=1;
w[7]=1;
w[8]=1;
w[9]=1;
w[10]=1;
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Value(w,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Value(w,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(w,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Deleting_Element(w);
//--- allocation
ArrayResize(xc,0);
ArrayResize(yc,0);
ArrayResize(dc,0);
//--- initialization
m=2;
t=2;
//--- check
if(_spoil_scenario==12)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==13)
t=CInfOrNaN::NegativeInfinity();
//--- create variables
CBarycentricInterpolantShell p;
CPolynomialFitReportShell rep;
//--- function call
CAlglib::PolynomialFitWC(x,y,w,11,xc,yc,dc,0,m,info,p,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.023,0.002);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_t_polfit_2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Polynomial fitting,full list of parameters. |
//+------------------------------------------------------------------+
void TEST_LSFit_T_PolFit_3(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double x[];
double y[];
double w[];
double xc[];
double yc[];
int dc[];
int m;
double t;
int info;
double v;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<23;_spoil_scenario++)
{
//--- allocation
ArrayResize(x,2);
//--- initialization
x[0]=1;
x[1]=1;
//--- check
if(_spoil_scenario==0)
Spoil_Vector_By_Value(x,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Vector_By_Value(x,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Vector_By_Value(x,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Vector_By_Deleting_Element(x);
//--- allocation
ArrayResize(y,2);
//--- initialization
y[0]=0.9;
y[1]=1.1;
//--- check
if(_spoil_scenario==4)
Spoil_Vector_By_Value(y,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Value(y,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==6)
Spoil_Vector_By_Value(y,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Deleting_Element(y);
//--- allocation
ArrayResize(w,2);
//--- initialization
w[0]=1;
w[1]=1;
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Value(w,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==9)
Spoil_Vector_By_Value(w,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==10)
Spoil_Vector_By_Value(w,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==11)
Spoil_Vector_By_Deleting_Element(w);
//--- allocation
ArrayResize(xc,1);
//--- initialization
xc[0]=0;
//--- check
if(_spoil_scenario==12)
Spoil_Vector_By_Value(xc,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==13)
Spoil_Vector_By_Value(xc,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==14)
Spoil_Vector_By_Value(xc,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==15)
Spoil_Vector_By_Deleting_Element(xc);
//--- allocation
ArrayResize(yc,1);
//--- initialization
yc[0]=0;
//--- check
if(_spoil_scenario==16)
Spoil_Vector_By_Value(yc,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==17)
Spoil_Vector_By_Value(yc,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==18)
Spoil_Vector_By_Value(yc,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==19)
Spoil_Vector_By_Deleting_Element(yc);
//--- allocation
ArrayResize(dc,1);
//--- initialization
dc[0]=0;
//--- check
if(_spoil_scenario==20)
Spoil_Vector_By_Deleting_Element(dc);
m=2;
t=2;
//--- check
if(_spoil_scenario==21)
t=CInfOrNaN::PositiveInfinity();
//--- check
if(_spoil_scenario==22)
t=CInfOrNaN::NegativeInfinity();
//--- create variables
CBarycentricInterpolantShell p;
CPolynomialFitReportShell rep;
//--- function call
CAlglib::PolynomialFitWC(x,y,w,2,xc,yc,dc,1,m,info,p,rep);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- function call
v=CAlglib::BarycentricCalc(p,t);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(v,2.000,0.001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","lsfit_t_polfit_3");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Determinant calculation, real matrix, short form |
//+------------------------------------------------------------------+
void TEST_MatDet_D_1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double a;
CMatrixDouble b;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<7;_spoil_scenario++)
{
//--- allocation
b.Resize(2,2);
//--- initialization
b[0].Set(0,1);
b[0].Set(1,2);
b[1].Set(0,2);
b[1].Set(1,1);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(b,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(b,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(b,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Adding_Row(b);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Adding_Col(b);
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Deleting_Row(b);
//--- check
if(_spoil_scenario==6)
Spoil_Matrix_By_Deleting_Col(b);
//--- function call
a=CAlglib::RMatrixDet(b);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(a,-3,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matdet_d_1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Determinant calculation, real matrix, full form |
//+------------------------------------------------------------------+
void TEST_MatDet_D_2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double a;
CMatrixDouble b;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<5;_spoil_scenario++)
{
//--- allocation
b.Resize(2,2);
//--- initialization
b[0].Set(0,5);
b[0].Set(1,4);
b[1].Set(0,4);
b[1].Set(1,5);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(b,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(b,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(b,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(b);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(b);
//--- function call
a=CAlglib::RMatrixDet(b,2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(a,9,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matdet_d_2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Determinant calculation, complex matrix, short form |
//+------------------------------------------------------------------+
void TEST_MatDet_D_3(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
complex a;
complex tempcomplex1;
complex tempcomplex2;
complex tempcomplex3;
CMatrixComplex b;
complex cnan;
complex cpositiveinfinity;
complex cnegativeinfinity;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<7;_spoil_scenario++)
{
//--- initialization
tempcomplex1.re=1;
tempcomplex1.im=1;
tempcomplex2.re=1;
tempcomplex2.im=-1;
//--- allocation
b.Resize(2,2);
//--- initialization
b[0].Set(0,tempcomplex1);
b[0].Set(1,2);
b[1].Set(0,2);
b[1].Set(1,tempcomplex2);
//--- initialization
cnan.re=CInfOrNaN::NaN();
cnan.im=CInfOrNaN::NaN();
cpositiveinfinity.re=CInfOrNaN::PositiveInfinity();
cpositiveinfinity.im=CInfOrNaN::PositiveInfinity();
cnegativeinfinity.re=CInfOrNaN::NegativeInfinity();
cnegativeinfinity.im=CInfOrNaN::NegativeInfinity();
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(b,cnan);
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(b,cpositiveinfinity);
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(b,cnegativeinfinity);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Adding_Row(b);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Adding_Col(b);
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Deleting_Row(b);
//--- check
if(_spoil_scenario==6)
Spoil_Matrix_By_Deleting_Col(b);
//--- function call
a=CAlglib::CMatrixDet(b);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- initialization
tempcomplex3.re=-2;
tempcomplex3.im=0;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex(a,tempcomplex3,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matdet_d_3");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Determinant calculation, complex matrix, full form |
//+------------------------------------------------------------------+
void TEST_MatDet_D_4(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
complex a;
complex tempcomplex1;
complex tempcomplex2;
complex tempcomplex3;
CMatrixComplex b;
complex cnan;
complex cpositiveinfinity;
complex cnegativeinfinity;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<5;_spoil_scenario++)
{
//--- initialization
tempcomplex1.re=0;
tempcomplex1.im=5;
tempcomplex2.re=0;
tempcomplex2.im=4;
//--- allocation
b.Resize(2,2);
//--- initialization
b[0].Set(0,tempcomplex1);
b[0].Set(1,4);
b[1].Set(0,tempcomplex2);
b[1].Set(1,5);
//--- initialization
cnan.re=CInfOrNaN::NaN();
cnan.im=CInfOrNaN::NaN();
cpositiveinfinity.re=CInfOrNaN::PositiveInfinity();
cpositiveinfinity.im=CInfOrNaN::PositiveInfinity();
cnegativeinfinity.re=CInfOrNaN::NegativeInfinity();
cnegativeinfinity.im=CInfOrNaN::NegativeInfinity();
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(b,cnan);
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(b,cpositiveinfinity);
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(b,cnegativeinfinity);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(b);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(b);
//--- function call
a=CAlglib::CMatrixDet(b,2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- initialization
tempcomplex3.re=0;
tempcomplex3.im=9;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex(a,tempcomplex3,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matdet_d_4");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Determinant calculation, complex matrix with zero imaginary part,|
//| short form |
//+------------------------------------------------------------------+
void TEST_MatDet_D_5(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
complex a;
complex tempcomplex;
CMatrixComplex b;
complex cnan;
complex cpositiveinfinity;
complex cnegativeinfinity;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<7;_spoil_scenario++)
{
//--- allocation
b.Resize(2,2);
//--- initialization
b[0].Set(0,9);
b[0].Set(1,1);
b[1].Set(0,2);
b[1].Set(1,1);
//--- initialization
cnan.re=CInfOrNaN::NaN();
cnan.im=CInfOrNaN::NaN();
cpositiveinfinity.re=CInfOrNaN::PositiveInfinity();
cpositiveinfinity.im=CInfOrNaN::PositiveInfinity();
cnegativeinfinity.re=CInfOrNaN::NegativeInfinity();
cnegativeinfinity.im=CInfOrNaN::NegativeInfinity();
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(b,cnan);
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(b,cpositiveinfinity);
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(b,cnegativeinfinity);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Adding_Row(b);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Adding_Col(b);
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Deleting_Row(b);
//--- check
if(_spoil_scenario==6)
Spoil_Matrix_By_Deleting_Col(b);
//--- function call
a=CAlglib::CMatrixDet(b);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- initialization
tempcomplex.re=7;
tempcomplex.im=0;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex(a,tempcomplex,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matdet_d_5");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Determinant calculation, real matrix, full form |
//+------------------------------------------------------------------+
void TEST_MatDet_T_0(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double a;
CMatrixDouble b;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<5;_spoil_scenario++)
{
//--- allocation
b.Resize(2,2);
//--- initialization
b[0].Set(0,3);
b[0].Set(1,4);
b[1].Set(0,-4);
b[1].Set(1,3);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(b,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(b,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(b,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(b);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(b);
//--- function call
a=CAlglib::RMatrixDet(b,2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(a,25,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matdet_t_0");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Determinant calculation, real matrix, LU, short form |
//+------------------------------------------------------------------+
void TEST_MatDet_T_1(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double a;
CMatrixDouble b;
int p[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<9;_spoil_scenario++)
{
//--- allocation
b.Resize(2,2);
//--- initialization
b[0].Set(0,1);
b[0].Set(1,2);
b[1].Set(0,2);
b[1].Set(1,5);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(b,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(b,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(b,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Adding_Row(b);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Adding_Col(b);
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Deleting_Row(b);
//--- check
if(_spoil_scenario==6)
Spoil_Matrix_By_Deleting_Col(b);
//--- allocation
ArrayResize(p,2);
//--- initialization
p[0]=1;
p[1]=1;
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Adding_Element(p);
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Deleting_Element(p);
//--- function call
a=CAlglib::RMatrixLUDet(b,p);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(a,-5,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matdet_t_1");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Determinant calculation, real matrix, LU, full form |
//+------------------------------------------------------------------+
void TEST_MatDet_T_2(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
double a;
int p[];
CMatrixDouble b;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<6;_spoil_scenario++)
{
//--- allocation
b.Resize(2,2);
//--- initialization
b[0].Set(0,5);
b[0].Set(1,4);
b[1].Set(0,4);
b[1].Set(1,5);
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(b,CInfOrNaN::NaN());
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(b,CInfOrNaN::PositiveInfinity());
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(b,CInfOrNaN::NegativeInfinity());
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(b);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(b);
//--- allocation
ArrayResize(p,2);
//--- initialization
p[0]=0;
p[1]=1;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Deleting_Element(p);
//--- function call
a=CAlglib::RMatrixLUDet(b,p,2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- check result
_TestResult=_TestResult && Doc_Test_Real(a,25,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matdet_t_2");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Determinant calculation, complex matrix, full form |
//+------------------------------------------------------------------+
void TEST_MatDet_T_3(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
complex a;
CMatrixComplex b;
complex tempcomplex1;
complex tempcomplex2;
complex cnan;
complex cpositiveinfinity;
complex cnegativeinfinity;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<5;_spoil_scenario++)
{
//--- initialization
tempcomplex1.re=0;
tempcomplex1.im=5;
//--- allocation
b.Resize(2,2);
//--- initialization
b[0].Set(0,tempcomplex1);
b[0].Set(1,4);
b[1].Set(0,-4);
b[1].Set(1,tempcomplex1);
//--- initialization
cnan.re=CInfOrNaN::NaN();
cnan.im=CInfOrNaN::NaN();
cpositiveinfinity.re=CInfOrNaN::PositiveInfinity();
cpositiveinfinity.im=CInfOrNaN::PositiveInfinity();
cnegativeinfinity.re=CInfOrNaN::NegativeInfinity();
cnegativeinfinity.im=CInfOrNaN::NegativeInfinity();
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(b,cnan);
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(b,cpositiveinfinity);
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(b,cnegativeinfinity);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(b);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(b);
//--- function call
a=CAlglib::CMatrixDet(b,2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- initialization
tempcomplex2.re=-9;
tempcomplex2.im=0;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex(a,tempcomplex2,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matdet_t_3");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Determinant calculation, complex matrix, LU, short form |
//+------------------------------------------------------------------+
void TEST_MatDet_T_4(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
complex a;
int p[];
complex tempcomplex1;
complex tempcomplex2;
CMatrixComplex b;
complex cnan;
complex cpositiveinfinity;
complex cnegativeinfinity;
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<9;_spoil_scenario++)
{
//--- initialization
tempcomplex1.re=0;
tempcomplex1.im=5;
//--- allocation
b.Resize(2,2);
//--- initialization
b[0].Set(0,1);
b[0].Set(1,2);
b[1].Set(0,2);
b[1].Set(1,tempcomplex1);
//--- initialization
cnan.re=CInfOrNaN::NaN();
cnan.im=CInfOrNaN::NaN();
cpositiveinfinity.re=CInfOrNaN::PositiveInfinity();
cpositiveinfinity.im=CInfOrNaN::PositiveInfinity();
cnegativeinfinity.re=CInfOrNaN::NegativeInfinity();
cnegativeinfinity.im=CInfOrNaN::NegativeInfinity();
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(b,cnan);
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(b,cpositiveinfinity);
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(b,cnegativeinfinity);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Adding_Row(b);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Adding_Col(b);
//--- check
if(_spoil_scenario==5)
Spoil_Matrix_By_Deleting_Row(b);
//--- check
if(_spoil_scenario==6)
Spoil_Matrix_By_Deleting_Col(b);
//--- allocation
ArrayResize(p,2);
//--- initialization
p[0]=1;
p[1]=1;
//--- check
if(_spoil_scenario==7)
Spoil_Vector_By_Adding_Element(p);
//--- check
if(_spoil_scenario==8)
Spoil_Vector_By_Deleting_Element(p);
//--- function call
a=CAlglib::CMatrixLUDet(b,p);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- initialization
tempcomplex2.re=0;
tempcomplex2.im=-5;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex(a,tempcomplex2,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matdet_t_4");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
//| Determinant calculation, complex matrix, LU, full form |
//+------------------------------------------------------------------+
void TEST_MatDet_T_5(int &_spoil_scenario,bool &_TestResult,bool &_TotalResult)
{
_TestResult=true;
//--- create variables
complex a;
complex tempcomplex1;
complex tempcomplex2;
CMatrixComplex b;
complex cnan;
complex cpositiveinfinity;
complex cnegativeinfinity;
int p[];
//--- testing
for(_spoil_scenario=-1;_spoil_scenario<6;_spoil_scenario++)
{
//--- initialization
tempcomplex1.re=0;
tempcomplex1.im=4;
//--- allocation
b.Resize(2,2);
//--- initialization
b[0].Set(0,5);
b[0].Set(1,tempcomplex1);
b[1].Set(0,4);
b[1].Set(1,5);
//--- initialization
cnan.re=CInfOrNaN::NaN();
cnan.im=CInfOrNaN::NaN();
cpositiveinfinity.re=CInfOrNaN::PositiveInfinity();
cpositiveinfinity.im=CInfOrNaN::PositiveInfinity();
cnegativeinfinity.re=CInfOrNaN::NegativeInfinity();
cnegativeinfinity.im=CInfOrNaN::NegativeInfinity();
//--- check
if(_spoil_scenario==0)
Spoil_Matrix_By_Value(b,cnan);
//--- check
if(_spoil_scenario==1)
Spoil_Matrix_By_Value(b,cpositiveinfinity);
//--- check
if(_spoil_scenario==2)
Spoil_Matrix_By_Value(b,cnegativeinfinity);
//--- check
if(_spoil_scenario==3)
Spoil_Matrix_By_Deleting_Row(b);
//--- check
if(_spoil_scenario==4)
Spoil_Matrix_By_Deleting_Col(b);
//--- allocation
ArrayResize(p,2);
//--- initialization
p[0]=0;
p[1]=1;
//--- check
if(_spoil_scenario==5)
Spoil_Vector_By_Deleting_Element(p);
//--- function call
a=CAlglib::CMatrixLUDet(b,p,2);
//--- handling exceptions
if(!Func_spoil_scenario(_spoil_scenario,_TestResult))
continue;
//--- initialization
tempcomplex2.re=25;
tempcomplex2.im=0;
//--- check result
_TestResult=_TestResult && Doc_Test_Complex(a,tempcomplex2,0.0001);
_TestResult=_TestResult && (_spoil_scenario==-1);
}
//--- check
if(!_TestResult)
Print("{0,-32} FAILED","matdet_t_5");
//--- change total result
_TotalResult=_TotalResult && _TestResult;
}
//+------------------------------------------------------------------+
Reference in New Issue View Git Blame Copy Permalink