//+------------------------------------------------------------------+
//|                                                       alglib.mqh |
//|            Copyright 2003-2022 Sergey Bochkanov (ALGLIB project) |
//|                             Copyright 2012-2023, MetaQuotes Ltd. |
//|                                             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 <Object.mqh>
#include "alglibmisc.mqh"
#include "dataanalysis.mqh"
#include "diffequations.mqh"
#include "delegatefunctions.mqh"
#include "fasttransforms.mqh"
#include "integration.mqh"
#include "interpolation.mqh"

//+------------------------------------------------------------------+
//| The main class, which includes functions for users               |
//+------------------------------------------------------------------+
class CAlglib
  {
public:
   //--- function of package alglibmisc
   //--- high quality random number generator
   static void       HQRndRandomize(CHighQualityRandStateShell &state);
   static void       HQRndSeed(const int s1,const int s2,CHighQualityRandStateShell &state);
   static double     HQRndUniformR(CHighQualityRandStateShell &state);
   static int        HQRndUniformI(CHighQualityRandStateShell &state,const int n);
   static double     HQRndNormal(CHighQualityRandStateShell &state);
   static void       HQRndNormalV(CHighQualityRandStateShell &state,int n,CRowDouble &x);
   static void       HQRndNormalV(CHighQualityRandStateShell &state,int n,vector<double> &x);
   static void       HQRndNormalM(CHighQualityRandStateShell &state,int m,int n,CMatrixDouble &x);
   static void       HQRndNormalM(CHighQualityRandStateShell &state,int m,int n,matrix<double> &x);
   static void       HQRndUnit2(CHighQualityRandStateShell &state,double &x,double &y);
   static void       HQRndNormal2(CHighQualityRandStateShell &state,double &x1,double &x2);
   static double     HQRndExponential(CHighQualityRandStateShell &state,const double lambdav);
   static double     HQRndDiscrete(CHighQualityRandStateShell &state,int n,CRowDouble &x);
   static double     HQRndDiscrete(CHighQualityRandStateShell &state,int n,vector<double> &x);
   static double     HQRndContinuous(CHighQualityRandStateShell &state,int n,CRowDouble &x);
   static double     HQRndContinuous(CHighQualityRandStateShell &state,int n,vector<double> &x);
   //---  build KD-trees
   static void       KDTreeSerialize(CKDTreeShell &obj,string &s_out);
   static void       KDTreeUnserialize(string s_in,CKDTreeShell &obj);
   static void       KDTreeBuild(CMatrixDouble &xy,const int n,const int nx,const int ny,const int normtype,CKDTreeShell &kdt);
   static void       KDTreeBuild(CMatrixDouble &xy,const int nx,const int ny,const int normtype,CKDTreeShell &kdt);
   static void       KDTreeBuildTagged(CMatrixDouble &xy,int &tags[],const int n,const int nx,const int ny,const int normtype,CKDTreeShell &kdt);
   static void       KDTreeBuildTagged(CMatrixDouble &xy,CRowInt &tags,const int n,const int nx,const int ny,const int normtype,CKDTreeShell &kdt);
   static void       KDTreeBuildTagged(CMatrixDouble &xy,int &tags[],const int nx,const int ny,const int normtype,CKDTreeShell &kdt);
   static void       KDTreeBuildTagged(CMatrixDouble &xy,CRowInt &tags,const int nx,const int ny,const int normtype,CKDTreeShell &kdt);
   static void       KDTreeCreateRequestBuffer(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf);
   static int        KDTreeQueryKNN(CKDTreeShell &kdt,double &x[],const int k,const bool selfmatch=true);
   static int        KDTreeQueryKNN(CKDTreeShell &kdt,CRowDouble &x,const int k,const bool selfmatch=true);
   static int        KDTreeQueryKNN(CKDTreeShell &kdt,vector<double> &x,const int k,const bool selfmatch=true);
   static int        KDTreeTsQueryKNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,double &x[],const int k,const bool selfmatch=true);
   static int        KDTreeTsQueryKNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,CRowDouble &x,const int k,const bool selfmatch=true);
   static int        KDTreeTsQueryKNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,vector<double> &x,const int k,const bool selfmatch=true);
   static int        KDTreeQueryRNN(CKDTreeShell &kdt,double &x[],const double r,const bool selfmatch=true);
   static int        KDTreeQueryRNN(CKDTreeShell &kdt,CRowDouble &x,const double r,const bool selfmatch=true);
   static int        KDTreeQueryRNN(CKDTreeShell &kdt,vector<double> &x,const double r,const bool selfmatch=true);
   static int        KDTreeQueryRNNU(CKDTreeShell &kdt,double &x[],const double r,const bool selfmatch=true);
   static int        KDTreeQueryRNNU(CKDTreeShell &kdt,CRowDouble &x,const double r,const bool selfmatch=true);
   static int        KDTreeQueryRNNU(CKDTreeShell &kdt,vector<double> &x,const double r,const bool selfmatch=true);
   static int        KDTreeTsQueryRNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,double &x[],const double r,const bool selfmatch=true);
   static int        KDTreeTsQueryRNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,CRowDouble &x,const double r,const bool selfmatch=true);
   static int        KDTreeTsQueryRNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,vector<double> &x,const double r,const bool selfmatch=true);
   static int        KDTreeTsQueryRNNU(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,double &x[],const double r,const bool selfmatch=true);
   static int        KDTreeTsQueryRNNU(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,CRowDouble &x,const double r,const bool selfmatch=true);
   static int        KDTreeTsQueryRNNU(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,vector<double> &x,const double r,const bool selfmatch=true);
   static int        KDTreeQueryAKNN(CKDTreeShell &kdt,double &x[],const int k,const bool selfmatch=true,const double eps=0);
   static int        KDTreeQueryAKNN(CKDTreeShell &kdt,vector<double> &x,const int k,const bool selfmatch=true,const double eps=0);
   static int        KDTreeQueryAKNN(CKDTreeShell &kdt,CRowDouble &x,const int k,const bool selfmatch=true,const double eps=0);
   static int        KDTreeQueryBox(CKDTreeShell &kdt,double &boxmin[],double &boxmax[]);
   static int        KDTreeQueryBox(CKDTreeShell &kdt,vector<double> &boxmin,vector<double> &boxmax);
   static int        KDTreeQueryBox(CKDTreeShell &kdt,CRowDouble &boxmin,CRowDouble &boxmax);
   static int        KDTreeTsQueryBox(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,double &boxmin[],double &boxmax[]);
   static int        KDTreeTsQueryBox(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,vector<double> &boxmin,vector<double> &boxmax);
   static int        KDTreeTsQueryBox(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,CRowDouble &boxmin,CRowDouble &boxmax);
   static void       KDTreeQueryResultsX(CKDTreeShell &kdt,CMatrixDouble &x);
   static void       KDTreeQueryResultsXY(CKDTreeShell &kdt,CMatrixDouble &xy);
   static void       KDTreeQueryResultsTags(CKDTreeShell &kdt,int &tags[]);
   static void       KDTreeQueryResultsTags(CKDTreeShell &kdt,CRowInt &tags);
   static void       KDTreeQueryResultsDistances(CKDTreeShell &kdt,double &r[]);
   static void       KDTreeQueryResultsDistances(CKDTreeShell &kdt,vector<double> &r);
   static void       KDTreeQueryResultsDistances(CKDTreeShell &kdt,CRowDouble &r);
   static void       KDTreeQueryResultsXI(CKDTreeShell &kdt,CMatrixDouble &x);
   static void       KDTreeQueryResultsXYI(CKDTreeShell &kdt,CMatrixDouble &xy);
   static void       KDTreeQueryResultsTagsI(CKDTreeShell &kdt,int &tags[]);
   static void       KDTreeQueryResultsTagsI(CKDTreeShell &kdt,CRowInt &tags);
   static void       KDTreeQueryResultsDistancesI(CKDTreeShell &kdt,double &r[]);
   static void       KDTreeQueryResultsDistancesI(CKDTreeShell &kdt,vector<double> &r);
   static void       KDTreeQueryResultsDistancesI(CKDTreeShell &kdt,CRowDouble &r);
   //--- functions of package dataanalysis
   //--- data analysis
   static void       DSOptimalSplit2(double &a[],int &c[],const int n,int &info,double &threshold,double &pal,double &pbl,double &par,double &pbr,double &cve);
   static void       DSOptimalSplit2(CRowDouble &a,CRowInt &c,const int n,int &info,double &threshold,double &pal,double &pbl,double &par,double &pbr,double &cve);
   static void       DSOptimalSplit2Fast(double &a[],int &c[],int &tiesbuf[],int &cntbuf[],double &bufr[],int &bufi[],const int n,const int nc,const double alpha,int &info,double &threshold,double &rms,double &cvrms);
   static void       DSOptimalSplit2Fast(CRowDouble &a,CRowInt &c,CRowInt &tiesbuf,CRowInt &cntbuf,CRowDouble &bufr,CRowInt &bufi,const int n,const int nc,const double alpha,int &info,double &threshold,double &rms,double &cvrms);
   //--- decision forest
   static void       DFSerialize(CDecisionForestShell &obj,string &s_out);
   static void       DFUnserialize(const string s_in,CDecisionForestShell &obj);
   static void       DFCreateBuffer(CDecisionForestShell &model,CDecisionForestBuffer &buf);
   static void       DFBuilderCreate(CDecisionForestBuilder &s);
   static void       DFBuilderSetDataset(CDecisionForestBuilder &s,CMatrixDouble &xy,int npoints,int nvars,int nclasses);
   static void       DFBuilderSetRndVars(CDecisionForestBuilder &s,int rndvars);
   static void       DFBuilderSetRndVarsRatio(CDecisionForestBuilder &s,double f);
   static void       DFBuilderSetRndVarsAuto(CDecisionForestBuilder &s);
   static void       DFBuilderSetSubsampleRatio(CDecisionForestBuilder &s,double f);
   static void       DFBuilderSetSeed(CDecisionForestBuilder &s,int seedval);
   static void       DFBuilderSetRDFAlgo(CDecisionForestBuilder &s,int algotype);
   static void       DFBuilderSetRDFSplitStrength(CDecisionForestBuilder &s,int splitstrength);
   static void       DFBuilderSetImportanceTrnGini(CDecisionForestBuilder &s);
   static void       DFBuilderSetImportanceOOBGini(CDecisionForestBuilder &s);
   static void       DFBuilderSetImportancePermutation(CDecisionForestBuilder &s);
   static void       DFBuilderSetImportanceNone(CDecisionForestBuilder &s);
   static double     DFBuilderGetProgress(CDecisionForestBuilder &s);
   static double     DFBuilderPeekProgress(CDecisionForestBuilder &s);
   static void       DFBuilderBuildRandomForest(CDecisionForestBuilder &s,int ntrees,CDecisionForestShell &df,CDFReportShell &rep);
   static double     DFBinaryCompression(CDecisionForestShell &df);
   static void       DFProcess(CDecisionForestShell &df,double &x[],double &y[]);
   static void       DFProcessI(CDecisionForestShell &df,double &x[],double &y[]);
   static double     DFProcess0(CDecisionForestShell &model,double &x[]);
   static double     DFProcess0(CDecisionForestShell &model,CRowDouble &x);
   static int        DFClassify(CDecisionForestShell &model,double &x[]);
   static int        DFClassify(CDecisionForestShell &model,CRowDouble &x);
   static double     DFRelClsError(CDecisionForestShell &df,CMatrixDouble &xy,const int npoints);
   static double     DFAvgCE(CDecisionForestShell &df,CMatrixDouble &xy,const int npoints);
   static double     DFRMSError(CDecisionForestShell &df,CMatrixDouble &xy,const int npoints);
   static double     DFAvgError(CDecisionForestShell &df,CMatrixDouble &xy,const int npoints);
   static double     DFAvgRelError(CDecisionForestShell &df,CMatrixDouble &xy,const int npoints);
   static void       DFBuildRandomDecisionForest(CMatrixDouble &xy,const int npoints,const int nvars,const int nclasses,const int ntrees,const double r,int &info,CDecisionForestShell &df,CDFReportShell &rep);
   static void       DFBuildRandomDecisionForestX1(CMatrixDouble &xy,const int npoints,const int nvars,const int nclasses,const int ntrees,int nrndvars,const double r,int &info,CDecisionForestShell &df,CDFReportShell &rep);
   //--- middle and clusterization
   static void       ClusterizerCreate(CClusterizerState &s);
   static void       ClusterizerSetPoints(CClusterizerState &s,CMatrixDouble &xy,int npoints,int nfeatures,int disttype);
   static void       ClusterizerSetPoints(CClusterizerState &s,CMatrixDouble &xy,int disttype);
   static void       ClusterizerSetDistances(CClusterizerState &s,CMatrixDouble &d,int npoints,bool IsUpper);
   static void       ClusterizerSetDistances(CClusterizerState &s,CMatrixDouble &d,bool IsUpper);
   static void       ClusterizerSetAHCAlgo(CClusterizerState &s,int algo);
   static void       ClusterizerSetKMeansLimits(CClusterizerState &s,int restarts,int maxits);
   static void       ClusterizerSetKMeansInit(CClusterizerState &s,int initalgo);
   static void       ClusterizerSetSeed(CClusterizerState &s,int seed);
   static void       ClusterizerRunAHC(CClusterizerState &s,CAHCReport &rep);
   static void       ClusterizerRunKMeans(CClusterizerState &s,int k,CKmeansReport &rep);
   static void       ClusterizerGetDistances(CMatrixDouble &xy,int npoints,int nfeatures,int disttype,CMatrixDouble &d);
   static void       ClusterizerGetKClusters(CAHCReport &rep,int k,CRowInt &cidx,CRowInt &cz);
   static void       ClusterizerSeparatedByDist(CAHCReport &rep,double r,int &k,CRowInt &cidx,CRowInt &cz);
   static void       ClusterizerSeparatedByCorr(CAHCReport &rep,double r,int &k,CRowInt &cidx,CRowInt &cz);
   static void       KMeansGenerate(CMatrixDouble &xy,const int npoints,const int nvars,const int k,const int restarts,int &info,CMatrixDouble &c,int &xyc[]);
   //--- Fisher LDA functions
   static void       FisherLDA(CMatrixDouble &xy,const int npoints,const int nvars,const int nclasses,int &info,double &w[]);
   static void       FisherLDA(CMatrixDouble &xy,const int npoints,const int nvars,const int nclasses,int &info,CRowDouble &w);
   static void       FisherLDAN(CMatrixDouble &xy,const int npoints,const int nvars,const int nclasses,int &info,CMatrixDouble &w);
   //--- linear regression
   static void       LRBuild(CMatrixDouble &xy,const int npoints,const int nvars,int &info,CLinearModelShell &lm,CLRReportShell &ar);
   static void       LRBuildS(CMatrixDouble &xy,double &s[],const int npoints,const int nvars,int &info,CLinearModelShell &lm,CLRReportShell &ar);
   static void       LRBuildS(CMatrixDouble &xy,CRowDouble &s,const int npoints,const int nvars,int &info,CLinearModelShell &lm,CLRReportShell &ar);
   static void       LRBuildZS(CMatrixDouble &xy,double &s[],const int npoints,const int nvars,int &info,CLinearModelShell &lm,CLRReportShell &ar);
   static void       LRBuildZS(CMatrixDouble &xy,CRowDouble &s,const int npoints,const int nvars,int &info,CLinearModelShell &lm,CLRReportShell &ar);
   static void       LRBuildZ(CMatrixDouble &xy,const int npoints,const int nvars,int &info,CLinearModelShell &lm,CLRReportShell &ar);
   static void       LRUnpack(CLinearModelShell &lm,double &v[],int &nvars);
   static void       LRUnpack(CLinearModelShell &lm,CRowDouble &v,int &nvars);
   static void       LRPack(double &v[],const int nvars,CLinearModelShell &lm);
   static void       LRPack(CRowDouble &v,const int nvars,CLinearModelShell &lm);
   static double     LRProcess(CLinearModelShell &lm,double &x[]);
   static double     LRProcess(CLinearModelShell &lm,CRowDouble &x);
   static double     LRRMSError(CLinearModelShell &lm,CMatrixDouble &xy,const int npoints);
   static double     LRAvgError(CLinearModelShell &lm,CMatrixDouble &xy,const int npoints);
   static double     LRAvgRelError(CLinearModelShell &lm,CMatrixDouble &xy,const int npoints);
   //--- multilayer perceptron
   static void       MLPSerialize(CMultilayerPerceptronShell &obj,string &s_out);
   static void       MLPUnserialize(const string s_in,CMultilayerPerceptronShell &obj);
   static void       MLPCreate0(const int nin,const int nout,CMultilayerPerceptronShell &network);
   static void       MLPCreate1(const int nin,int nhid,const int nout,CMultilayerPerceptronShell &network);
   static void       MLPCreate2(const int nin,const int nhid1,const int nhid2,const int nout,CMultilayerPerceptronShell &network);
   static void       MLPCreateB0(const int nin,const int nout,const double b,const double d,CMultilayerPerceptronShell &network);
   static void       MLPCreateB1(const int nin,int nhid,const int nout,const double b,const double d,CMultilayerPerceptronShell &network);
   static void       MLPCreateB2(const int nin,const int nhid1,const int nhid2,const int nout,const double b,const double d,CMultilayerPerceptronShell &network);
   static void       MLPCreateR0(const int nin,const int nout,double a,const double b,CMultilayerPerceptronShell &network);
   static void       MLPCreateR1(const int nin,int nhid,const int nout,const double a,const double b,CMultilayerPerceptronShell &network);
   static void       MLPCreateR2(const int nin,const int nhid1,const int nhid2,const int nout,const double a,const double b,CMultilayerPerceptronShell &network);
   static void       MLPCreateC0(const int nin,const int nout,CMultilayerPerceptronShell &network);
   static void       MLPCreateC1(const int nin,int nhid,const int nout,CMultilayerPerceptronShell &network);
   static void       MLPCreateC2(const int nin,const int nhid1,const int nhid2,const int nout,CMultilayerPerceptronShell &network);
   static void       MLPRandomize(CMultilayerPerceptronShell &network);
   static void       MLPRandomizeFull(CMultilayerPerceptronShell &network);
   static void       MLPInitPreprocessor(CMultilayerPerceptronShell &network,CMatrixDouble &xy,int ssize);
   static void       MLPProperties(CMultilayerPerceptronShell &network,int &nin,int &nout,int &wcount);
   static int        MLPGetInputsCount(CMultilayerPerceptronShell &network);
   static int        MLPGetOutputsCount(CMultilayerPerceptronShell &network);
   static int        MLPGetWeightsCount(CMultilayerPerceptronShell &network);
   static bool       MLPIsSoftMax(CMultilayerPerceptronShell &network);
   static int        MLPGetLayersCount(CMultilayerPerceptronShell &network);
   static int        MLPGetLayerSize(CMultilayerPerceptronShell &network,const int k);
   static void       MLPGetInputScaling(CMultilayerPerceptronShell &network,const int i,double &mean,double &sigma);
   static void       MLPGetOutputScaling(CMultilayerPerceptronShell &network,const int i,double &mean,double &sigma);
   static void       MLPGetNeuronInfo(CMultilayerPerceptronShell &network,const int k,const int i,int &fkind,double &threshold);
   static double     MLPGetWeight(CMultilayerPerceptronShell &network,const int k0,const int i0,const int k1,const int i1);
   static void       MLPSetInputScaling(CMultilayerPerceptronShell &network,const int i,const double mean,const double sigma);
   static void       MLPSetOutputScaling(CMultilayerPerceptronShell &network,const int i,const double mean,const double sigma);
   static void       MLPSetNeuronInfo(CMultilayerPerceptronShell &network,const int k,const int i,int fkind,double threshold);
   static void       MLPSetWeight(CMultilayerPerceptronShell &network,const int k0,const int i0,const int k1,const int i1,const double w);
   static void       MLPActivationFunction(const double net,const int k,double &f,double &df,double &d2f);
   static void       MLPProcess(CMultilayerPerceptronShell &network,double &x[],double &y[]);
   static void       MLPProcessI(CMultilayerPerceptronShell &network,double &x[],double &y[]);
   static double     MLPError(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int ssize);
   static double     MLPErrorSparse(CMultilayerPerceptronShell &network,CSparseMatrix &xy,int npoints);
   static double     MLPErrorN(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int ssize);
   static int        MLPClsError(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int ssize);
   static double     MLPRelClsError(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int npoints);
   static double     MLPRelClsErrorSparse(CMultilayerPerceptronShell &network,CSparseMatrix &xy,int npoints);
   static double     MLPAvgCE(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int npoints);
   static double     MLPAvgCESparse(CMultilayerPerceptronShell &network,CSparseMatrix &xy,int npoints);
   static double     MLPRMSError(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int npoints);
   static double     MLPRMSErrorSparse(CMultilayerPerceptronShell &network,CSparseMatrix &xy,int npoints);
   static double     MLPAvgError(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int npoints);
   static double     MLPAvgErrorSparse(CMultilayerPerceptronShell &network,CSparseMatrix &xy,int npoints);
   static double     MLPAvgRelError(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int npoints);
   static double     MLPAvgRelErrorSparse(CMultilayerPerceptronShell &network,CSparseMatrix &xy,int npoints);
   static void       MLPGrad(CMultilayerPerceptronShell &network,double &x[],double &desiredy[],double &e,double &grad[]);
   static void       MLPGradN(CMultilayerPerceptronShell &network,double &x[],double &desiredy[],double &e,double &grad[]);
   static void       MLPGradBatch(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int ssize,double &e,double &grad[]);
   static void       MLPGradBatch(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int ssize,double &e,CRowDouble &grad);
   static void       MLPGradBatchSparse(CMultilayerPerceptronShell &network,CSparseMatrix &xy,int ssize,double &e,CRowDouble &grad);
   static void       MLPGradBatchSubset(CMultilayerPerceptronShell &network,CMatrixDouble &xy,int setsize,CRowInt &idx,int subsetsize,double &e,CRowDouble &grad);
   static void       MLPGradBatchSparseSubset(CMultilayerPerceptronShell &network,CSparseMatrix &xy,int setsize,CRowInt &idx,int subsetsize,double &e,CRowDouble &grad);
   static void       MLPGradNBatch(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int ssize,double &e,double &grad[]);
   static void       MLPGradNBatch(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int ssize,double &e,CRowDouble &grad);
   static void       MLPHessianNBatch(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int ssize,double &e,double &grad[],CMatrixDouble &h);
   static void       MLPHessianNBatch(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int ssize,double &e,CRowDouble &grad,CMatrixDouble &h);
   static void       MLPHessianBatch(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int ssize,double &e,double &grad[],CMatrixDouble &h);
   static void       MLPHessianBatch(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int ssize,double &e,CRowDouble &grad,CMatrixDouble &h);
   static void       MLPAllErrorsSubset(CMultilayerPerceptronShell &network,CMatrixDouble &xy,int setsize,CRowInt &subset,int subsetsize,CModelErrors &rep);
   static void       MLPAllErrorsSparseSubset(CMultilayerPerceptronShell &network,CSparseMatrix &xy,int setsize,CRowInt &subset,int subsetsize,CModelErrors &rep);
   static double     MLPErrorSubset(CMultilayerPerceptronShell &network,CMatrixDouble &xy,int setsize,CRowInt &subset,int subsetsize);
   static double     MLPErrorSparseSubset(CMultilayerPerceptronShell &network,CSparseMatrix &xy,int setsize,CRowInt &subset,int subsetsize);
   //--- logit model functions
   static void       MNLTrainH(CMatrixDouble &xy,const int npoints,const int nvars,const int nclasses,int &info,CLogitModelShell &lm,CMNLReportShell &rep);
   static void       MNLProcess(CLogitModelShell &lm,double &x[],double &y[]);
   static void       MNLProcess(CLogitModelShell &lm,CRowDouble &x,CRowDouble &y);
   static void       MNLProcessI(CLogitModelShell &lm,double &x[],double &y[]);
   static void       MNLProcessI(CLogitModelShell &lm,CRowDouble &x,CRowDouble &y);
   static void       MNLUnpack(CLogitModelShell &lm,CMatrixDouble &a,int &nvars,int &nclasses);
   static void       MNLPack(CMatrixDouble &a,const int nvars,const int nclasses,CLogitModelShell &lm);
   static double     MNLAvgCE(CLogitModelShell &lm,CMatrixDouble &xy,const int npoints);
   static double     MNLRelClsError(CLogitModelShell &lm,CMatrixDouble &xy,const int npoints);
   static double     MNLRMSError(CLogitModelShell &lm,CMatrixDouble &xy,const int npoints);
   static double     MNLAvgError(CLogitModelShell &lm,CMatrixDouble &xy,const int npoints);
   static double     MNLAvgRelError(CLogitModelShell &lm,CMatrixDouble &xy,const int ssize);
   static int        MNLClsError(CLogitModelShell &lm,CMatrixDouble &xy,const int npoints);
   //--- Markov chains
   static void       MCPDCreate(const int n,CMCPDStateShell &s);
   static void       MCPDCreateEntry(const int n,const int entrystate,CMCPDStateShell &s);
   static void       MCPDCreateExit(const int n,const int exitstate,CMCPDStateShell &s);
   static void       MCPDCreateEntryExit(const int n,const int entrystate,const int exitstate,CMCPDStateShell &s);
   static void       MCPDAddTrack(CMCPDStateShell &s,CMatrixDouble &xy,const int k);
   static void       MCPDAddTrack(CMCPDStateShell &s,CMatrixDouble &xy);
   static void       MCPDSetEC(CMCPDStateShell &s,CMatrixDouble &ec);
   static void       MCPDAddEC(CMCPDStateShell &s,const int i,const int j,const double c);
   static void       MCPDSetBC(CMCPDStateShell &s,CMatrixDouble &bndl,CMatrixDouble &bndu);
   static void       MCPDAddBC(CMCPDStateShell &s,const int i,const int j,const double bndl,const double bndu);
   static void       MCPDSetLC(CMCPDStateShell &s,CMatrixDouble &c,int &ct[],const int k);
   static void       MCPDSetLC(CMCPDStateShell &s,CMatrixDouble &c,CRowInt &ct,const int k);
   static void       MCPDSetLC(CMCPDStateShell &s,CMatrixDouble &c,int &ct[]);
   static void       MCPDSetLC(CMCPDStateShell &s,CMatrixDouble &c,CRowInt &ct);
   static void       MCPDSetTikhonovRegularizer(CMCPDStateShell &s,const double v);
   static void       MCPDSetPrior(CMCPDStateShell &s,CMatrixDouble &pp);
   static void       MCPDSetPredictionWeights(CMCPDStateShell &s,double &pw[]);
   static void       MCPDSetPredictionWeights(CMCPDStateShell &s,CRowDouble &pw);
   static void       MCPDSolve(CMCPDStateShell &s);
   static void       MCPDResults(CMCPDStateShell &s,CMatrixDouble &p,CMCPDReportShell &rep);
   //--- training neural networks
   static void       MLPTrainLM(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int npoints,const double decay,const int restarts,int &info,CMLPReportShell &rep);
   static void       MLPTrainLBFGS(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int npoints,const double decay,const int restarts,const double wstep,int maxits,int &info,CMLPReportShell &rep);
   static void       MLPTrainES(CMultilayerPerceptronShell &network,CMatrixDouble &trnxy,const int trnsize,CMatrixDouble &valxy,const int valsize,const double decay,const int restarts,int &info,CMLPReportShell &rep);
   static void       MLPKFoldCVLBFGS(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int npoints,const double decay,const int restarts,const double wstep,const int maxits,const int foldscount,int &info,CMLPReportShell &rep,CMLPCVReportShell &cvrep);
   static void       MLPKFoldCVLM(CMultilayerPerceptronShell &network,CMatrixDouble &xy,const int npoints,const double decay,const int restarts,const int foldscount,int &info,CMLPReportShell &rep,CMLPCVReportShell &cvrep);
   static void       MLPCreateTrainer(int nin,int nout,CMLPTrainer &s);
   static void       MLPCreateTrainerCls(int nin,int nclasses,CMLPTrainer &s);
   static void       MLPSetDataset(CMLPTrainer &s,CMatrixDouble &xy,int npoints);
   static void       MLPSetSparseDataset(CMLPTrainer &s,CSparseMatrix &xy,int npoints);
   static void       MLPSetDecay(CMLPTrainer &s,double decay);
   static void       MLPSetCond(CMLPTrainer &s,double wstep,int maxits);
   static void       MLPSetAlgoBatch(CMLPTrainer &s);
   static void       MLPTrainNetwork(CMLPTrainer &s,CMultilayerPerceptronShell &network,int nrestarts,CMLPReportShell &rep);
   static void       MLPStartTraining(CMLPTrainer &s,CMultilayerPerceptronShell &network,bool randomstart);
   static bool       MLPContinueTraining(CMLPTrainer &s,CMultilayerPerceptronShell &network);
   //--- neural networks ensemble functions
   static void       MLPECreate0(const int nin,const int nout,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreate1(const int nin,int nhid,const int nout,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreate2(const int nin,const int nhid1,const int nhid2,const int nout,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreateB0(const int nin,const int nout,const double b,const double d,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreateB1(const int nin,int nhid,const int nout,const double b,const double d,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreateB2(const int nin,const int nhid1,const int nhid2,const int nout,const double b,const double d,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreateR0(const int nin,const int nout,const double a,const double b,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreateR1(const int nin,int nhid,const int nout,const double a,const double b,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreateR2(const int nin,const int nhid1,const int nhid2,const int nout,const double a,const double b,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreateC0(const int nin,const int nout,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreateC1(const int nin,int nhid,const int nout,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreateC2(const int nin,const int nhid1,const int nhid2,const int nout,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPECreateFromNetwork(CMultilayerPerceptronShell &network,const int ensemblesize,CMLPEnsembleShell &ensemble);
   static void       MLPERandomize(CMLPEnsembleShell &ensemble);
   static void       MLPEProperties(CMLPEnsembleShell &ensemble,int &nin,int &nout);
   static bool       MLPEIsSoftMax(CMLPEnsembleShell &ensemble);
   static void       MLPEProcess(CMLPEnsembleShell &ensemble,double &x[],double &y[]);
   static void       MLPEProcessI(CMLPEnsembleShell &ensemble,double &x[],double &y[]);
   static double     MLPERelClsError(CMLPEnsembleShell &ensemble,CMatrixDouble &xy,const int npoints);
   static double     MLPEAvgCE(CMLPEnsembleShell &ensemble,CMatrixDouble &xy,const int npoints);
   static double     MLPERMSError(CMLPEnsembleShell &ensemble,CMatrixDouble &xy,const int npoints);
   static double     MLPEAvgError(CMLPEnsembleShell &ensemble,CMatrixDouble &xy,const int npoints);
   static double     MLPEAvgRelError(CMLPEnsembleShell &ensemble,CMatrixDouble &xy,const int npoints);
   static void       MLPEBaggingLM(CMLPEnsembleShell &ensemble,CMatrixDouble &xy,const int npoints,const double decay,const int restarts,int &info,CMLPReportShell &rep,CMLPCVReportShell &ooberrors);
   static void       MLPEBaggingLBFGS(CMLPEnsembleShell &ensemble,CMatrixDouble &xy,const int npoints,const double decay,const int restarts,const double wstep,const int maxits,int &info,CMLPReportShell &rep,CMLPCVReportShell &ooberrors);
   static void       MLPETrainES(CMLPEnsembleShell &ensemble,CMatrixDouble &xy,const int npoints,const double decay,const int restarts,int &info,CMLPReportShell &rep);
   static void       MLPTrainEnsembleES(CMLPTrainer &s,CMLPEnsembleShell &ensemble,int nrestarts,CMLPReportShell &rep);
   //--- principal components analysis
   static void       PCABuildBasis(CMatrixDouble &x,const int npoints,const int nvars,int &info,double &s2[],CMatrixDouble &v);
   static void       PCABuildBasis(CMatrixDouble &x,const int npoints,const int nvars,int &info,CRowDouble &s2,CMatrixDouble &v);
   static void       PCATruncatedSubspace(CMatrixDouble &x,int npoints,int nvars,int nneeded,double eps,int maxits,CRowDouble &s2,CMatrixDouble &v);
   static void       PCATruncatedSubspaceSparse(CSparseMatrix &x,int npoints,int nvars,int nneeded,double eps,int maxits,CRowDouble &s2,CMatrixDouble &v);
   //--- functions of package diffequations
   static void       ODESolverRKCK(double &y[],const int n,double &x[],const int m,const double eps,const double h,CODESolverStateShell &state);
   static void       ODESolverRKCK(double &y[],double &x[],const double eps,const double h,CODESolverStateShell &state);
   static bool       ODESolverIteration(CODESolverStateShell &state);
   static void       ODESolverSolve(CODESolverStateShell &state,CNDimensional_ODE_RP &diff,CObject &obj);
   static void       ODESolverResults(CODESolverStateShell &state,int &m,double &xtbl[],CMatrixDouble &ytbl,CODESolverReportShell &rep);
   //--- filters
   static void       FilterSMA(CRowDouble &x,int n,int k);
   static void       FilterSMA(CRowDouble &x,int k);
   static void       FilterEMA(CRowDouble &x,int n,double alpha);
   static void       FilterEMA(CRowDouble &x,double alpha);
   static void       FilterLRMA(CRowDouble &x,int n,int k);
   static void       FilterLRMA(CRowDouble &x,int k);
   //--- SSA models
   static void       SSACreate(CSSAModel &s);
   static void       SSASetWindow(CSSAModel &s,int windowwidth);
   static void       SSASetSeed(CSSAModel &s,int seed);
   static void       SSASetPowerUpLength(CSSAModel &s,int pwlen);
   static void       SSASetMemoryLimit(CSSAModel &s,int memlimit);
   static void       SSAAddSequence(CSSAModel &s,CRowDouble &x,int n);
   static void       SSAAddSequence(CSSAModel &s,CRowDouble &x);
   static void       SSAAppendPointAndUpdate(CSSAModel &s,double x,double updateits);
   static void       SSAAppendSequenceAndUpdate(CSSAModel &s,CRowDouble &x,int nticks,double updateits);
   static void       SSAAppendSequenceAndUpdate(CSSAModel &s,CRowDouble &x,double updateits);
   static void       SSASetAlgoPrecomputed(CSSAModel &s,CMatrixDouble &a,int windowwidth,int nbasis);
   static void       SSASetAlgoPrecomputed(CSSAModel &s,CMatrixDouble &a);
   static void       SSASetAlgoTopKDirect(CSSAModel &s,int topk);
   static void       SSASetAlgoTopKRealtime(CSSAModel &s,int topk);
   static void       SSAClearData(CSSAModel &s);
   static void       SSAGetBasis(CSSAModel &s,CMatrixDouble &a,CRowDouble &sv,int &windowwidth,int &nbasis);
   static void       SSAGetLRR(CSSAModel &s,CRowDouble &a,int &windowwidth);
   static void       SSAAnalyzeLastWindow(CSSAModel &s,CRowDouble &trend,CRowDouble &noise,int &nticks);
   static void       SSAAnalyzeLast(CSSAModel &s,int nticks,CRowDouble &trend,CRowDouble &noise);
   static void       SSAAnalyzeSequence(CSSAModel &s,CRowDouble &data,int nticks,CRowDouble &trend,CRowDouble &noise);
   static void       SSAAnalyzeSequence(CSSAModel &s,CRowDouble &data,CRowDouble &trend,CRowDouble &noise);
   static void       SSAForecastLast(CSSAModel &s,int nticks,CRowDouble &trend);
   static void       SSAForecastSequence(CSSAModel &s,CRowDouble &data,int datalen,int forecastlen,bool applysmoothing,CRowDouble &trend);
   static void       SSAForecastSequence(CSSAModel &s,CRowDouble &data,int forecastlen,CRowDouble &trend);
   static void       SSAForecastAvgLast(CSSAModel &s,int m,int nticks,CRowDouble &trend);
   static void       SSAForecastAvgSequence(CSSAModel &s,CRowDouble &data,int datalen,int m,int forecastlen,bool applysmoothing,CRowDouble &trend);
   static void       SSAForecastAvgSequence(CSSAModel &s,CRowDouble &data,int m,int forecastlen,CRowDouble &trend);
   //--- KNN models
   static void       KNNSerialize(CKNNModel &obj,string &s_out);
   static void       KNNUnserialize(const string s_in,CKNNModel &obj);
   static void       KNNCreateBuffer(CKNNModel &model,CKNNBuffer &buf);
   static void       KNNBuilderCreate(CKNNBuilder &s);
   static void       KNNBuilderSetDatasetReg(CKNNBuilder &s,CMatrixDouble &xy,int npoints,int nvars,int nout);
   static void       KNNBuilderSetDatasetCLS(CKNNBuilder &s,CMatrixDouble &xy,int npoints,int nvars,int nclasses);
   static void       KNNBuilderSetNorm(CKNNBuilder &s,int nrmtype);
   static void       KNNBuilderBuildKNNModel(CKNNBuilder &s,int k,double eps,CKNNModel &model,CKNNReport &rep);
   static void       KNNRewriteKEps(CKNNModel &model,int k,double eps);
   static void       KNNProcess(CKNNModel &model,CRowDouble &x,CRowDouble &y);
   static double     KNNProcess0(CKNNModel &model,CRowDouble &x);
   static int        KNNClassify(CKNNModel &model,CRowDouble &x);
   static void       KNNProcessI(CKNNModel &model,CRowDouble &x,CRowDouble &y);
   static void       KNNTsProcess(CKNNModel &model,CKNNBuffer &buf,CRowDouble &x,CRowDouble &y);
   static double     KNNRelClsError(CKNNModel &model,CMatrixDouble &xy,int npoints);
   static double     KNNAvgCE(CKNNModel &model,CMatrixDouble &xy,int npoints);
   static double     KNNRMSError(CKNNModel &model,CMatrixDouble &xy,int npoints);
   static double     KNNAvgError(CKNNModel &model,CMatrixDouble &xy,int npoints);
   static double     KNNAvgRelError(CKNNModel &model,CMatrixDouble &xy,int npoints);
   static void       KNNAllErrors(CKNNModel &model,CMatrixDouble &xy,int npoints,CKNNReport &rep);
   //--- functions of package fasttransforms
   //--- fast Fourier transform
   static void       FFTC1D(complex &a[],const int n);
   static void       FFTC1D(complex &a[]);
   static void       FFTC1DInv(complex &a[],const int n);
   static void       FFTC1DInv(complex &a[]);
   static void       FFTR1D(double &a[],const int n,complex &f[]);
   static void       FFTR1D(double &a[],complex &f[]);
   static void       FFTR1DInv(complex &f[],const int n,double &a[]);
   static void       FFTR1DInv(complex &f[],double &a[]);
   static void       FFTC1D(CRowComplex &a,const int n);
   static void       FFTC1D(CRowComplex &a);
   static void       FFTC1DInv(CRowComplex &a,const int n);
   static void       FFTC1DInv(CRowComplex &a);
   static void       FFTR1D(CRowDouble &a,const int n,CRowComplex &f);
   static void       FFTR1D(CRowDouble &a,CRowComplex &f);
   static void       FFTR1DInv(CRowComplex &f,const int n,CRowDouble &a);
   static void       FFTR1DInv(CRowComplex &f,CRowDouble &a);
   //--- convolution
   static void       ConvC1D(complex &a[],const int m,complex &b[],const int n,complex &r[]);
   static void       ConvC1DInv(complex &a[],const int m,complex &b[],const int n,complex &r[]);
   static void       ConvC1DCircular(complex &s[],const int m,complex &r[],const int n,complex &c[]);
   static void       ConvC1DCircularInv(complex &a[],const int m,complex &b[],const int n,complex &r[]);
   static void       ConvR1D(double &a[],const int m,double &b[],const int n,double &r[]);
   static void       ConvR1DInv(double &a[],const int m,double &b[],const int n,double &r[]);
   static void       ConvR1DCircular(double &s[],const int m,double &r[],const int n,double &c[]);
   static void       ConvR1DCircularInv(double &a[],const int m,double &b[],const int n,double &r[]);
   static void       CorrC1D(complex &signal[],const int n,complex &pattern[],const int m,complex &r[]);
   static void       CorrC1DCircular(complex &signal[],const int m,complex &pattern[],const int n,complex &c[]);
   static void       CorrR1D(double &signal[],const int n,double &pattern[],const int m,double &r[]);
   static void       CorrR1DCircular(double &signal[],const int m,double &pattern[],const int n,double &c[]);
   //--- fast Hartley transform
   static void       FHTR1D(double &a[],const int n);
   static void       FHTR1DInv(double &a[],const int n);
   //--- functions of package integration
   //--- Gauss quadrature formula
   static void       GQGenerateRec(double &alpha[],double &beta[],const double mu0,const int n,int &info,double &x[],double &w[]);
   static void       GQGenerateGaussLobattoRec(double &alpha[],double &beta[],const double mu0,const double a,const double b,const int n,int &info,double &x[],double &w[]);
   static void       GQGenerateGaussRadauRec(double &alpha[],double &beta[],const double mu0,const double a,const int n,int &info,double &x[],double &w[]);
   static void       GQGenerateGaussLegendre(const int n,int &info,double &x[],double &w[]);
   static void       GQGenerateGaussJacobi(const int n,const double alpha,const double beta,int &info,double &x[],double &w[]);
   static void       GQGenerateGaussLaguerre(const int n,const double alpha,int &info,double &x[],double &w[]);
   static void       GQGenerateGaussHermite(const int n,int &info,double &x[],double &w[]);
   //--- Gauss-Kronrod quadrature formula
   static void       GKQGenerateRec(double &alpha[],double &beta[],const double mu0,const int n,int &info,double &x[],double &wkronrod[],double &wgauss[]);
   static void       GKQGenerateGaussLegendre(const int n,int &info,double &x[],double &wkronrod[],double &wgauss[]);
   static void       GKQGenerateGaussJacobi(const int n,const double alpha,const double beta,int &info,double &x[],double &wkronrod[],double &wgauss[]);
   static void       GKQLegendreCalc(const int n,int &info,double &x[],double &wkronrod[],double &wgauss[]);
   static void       GKQLegendreTbl(const int n,double &x[],double &wkronrod[],double &wgauss[],double &eps);
   //--- auto Gauss-Kronrod
   static void       AutoGKSmooth(const double a,const double b,CAutoGKStateShell &state);
   static void       AutoGKSmoothW(const double a,const double b,double xwidth,CAutoGKStateShell &state);
   static void       AutoGKSingular(const double a,const double b,const double alpha,const double beta,CAutoGKStateShell &state);
   static bool       AutoGKIteration(CAutoGKStateShell &state);
   static void       AutoGKIntegrate(CAutoGKStateShell &state,CIntegrator1_Func &func,CObject &obj);
   static void       AutoGKResults(CAutoGKStateShell &state,double &v,CAutoGKReportShell &rep);
   //--- functions of package interpolation
   //--- inverse distance weighting interpolation
   static void       IDWSerialize(CIDWModelShell &obj,string &s_out);
   static void       IDWUnserialize(string s_in,CIDWModelShell &obj);
   static void       IDWCreateCalcBuffer(CIDWModelShell &s,CIDWCalcBuffer &buf);
   static void       IDWBuilderCreate(int nx,int ny,CIDWBuilder &state);
   static void       IDWBuilderSetNLayers(CIDWBuilder &state,int nlayers);
   static void       IDWBuilderSetPoints(CIDWBuilder &state,CMatrixDouble &xy,int n);
   static void       IDWBuilderSetPoints(CIDWBuilder &state,CMatrixDouble &xy);
   static void       IDWBuilderSetAlgoMSTAB(CIDWBuilder &state,double srad);
   static void       IDWBuilderSetAlgoTextBookShepard(CIDWBuilder &state,double p);
   static void       IDWBuilderSetAlgoTextBookModShepard(CIDWBuilder &state,double r);
   static void       IDWBuilderSetUserTerm(CIDWBuilder &state,double v);
   static void       IDWBuilderSetConstTerm(CIDWBuilder &state);
   static void       IDWBuilderSetZeroTerm(CIDWBuilder &state);
   static double     IDWCalc1(CIDWModelShell &s,double x0);
   static double     IDWCalc2(CIDWModelShell &s,double x0,double x1);
   static double     IDWCalc3(CIDWModelShell &s,double x0,double x1,double x2);
   static void       IDWCalc(CIDWModelShell &s,CRowDouble &x,CRowDouble &y);
   static void       IDWCalcBuf(CIDWModelShell &s,CRowDouble &x,CRowDouble &y);
   static void       IDWTsCalcBuf(CIDWModelShell &s,CIDWCalcBuffer &buf,CRowDouble &x,CRowDouble &y);
   static void       IDWFit(CIDWBuilder &state,CIDWModelShell &model,CIDWReport &rep);
   //--- rational interpolation
   static double     BarycentricCalc(CBarycentricInterpolantShell &b,const double t);
   static void       BarycentricDiff1(CBarycentricInterpolantShell &b,const double t,double &f,double &df);
   static void       BarycentricDiff2(CBarycentricInterpolantShell &b,const double t,double &f,double &df,double &d2f);
   static void       BarycentricLinTransX(CBarycentricInterpolantShell &b,const double ca,const double cb);
   static void       BarycentricLinTransY(CBarycentricInterpolantShell &b,const double ca,const double cb);
   static void       BarycentricUnpack(CBarycentricInterpolantShell &b,int &n,double &x[],double &y[],double &w[]);
   static void       BarycentricBuildXYW(double &x[],double &y[],double &w[],const int n,CBarycentricInterpolantShell &b);
   static void       BarycentricBuildFloaterHormann(double &x[],double &y[],const int n,const int d,CBarycentricInterpolantShell &b);
   //--- polynomial interpolant
   static void       PolynomialBar2Cheb(CBarycentricInterpolantShell &p,const double a,const double b,double &t[]);
   static void       PolynomialCheb2Bar(double &t[],const int n,const double a,const double b,CBarycentricInterpolantShell &p);
   static void       PolynomialCheb2Bar(double &t[],const double a,const double b,CBarycentricInterpolantShell &p);
   static void       PolynomialBar2Pow(CBarycentricInterpolantShell &p,const double c,const double s,double &a[]);
   static void       PolynomialBar2Pow(CBarycentricInterpolantShell &p,double &a[]);
   static void       PolynomialPow2Bar(double &a[],const int n,const double c,const double s,CBarycentricInterpolantShell &p);
   static void       PolynomialPow2Bar(double &a[],CBarycentricInterpolantShell &p);
   static void       PolynomialBuild(double &x[],double &y[],const int n,CBarycentricInterpolantShell &p);
   static void       PolynomialBuild(double &x[],double &y[],CBarycentricInterpolantShell &p);
   static void       PolynomialBuildEqDist(const double a,const double b,double &y[],const int n,CBarycentricInterpolantShell &p);
   static void       PolynomialBuildEqDist(const double a,const double b,double &y[],CBarycentricInterpolantShell &p);
   static void       PolynomialBuildCheb1(const double a,const double b,double &y[],const int n,CBarycentricInterpolantShell &p);
   static void       PolynomialBuildCheb1(const double a,const double b,double &y[],CBarycentricInterpolantShell &p);
   static void       PolynomialBuildCheb2(const double a,const double b,double &y[],const int n,CBarycentricInterpolantShell &p);
   static void       PolynomialBuildCheb2(const double a,const double b,double &y[],CBarycentricInterpolantShell &p);
   static double     PolynomialCalcEqDist(const double a,const double b,double &f[],const int n,const double t);
   static double     PolynomialCalcEqDist(const double a,const double b,double &f[],const double t);
   static double     PolynomialCalcCheb1(const double a,const double b,double &f[],const int n,const double t);
   static double     PolynomialCalcCheb1(const double a,const double b,double &f[],const double t);
   static double     PolynomialCalcCheb2(const double a,const double b,double &f[],const int n,const double t);
   static double     PolynomialCalcCheb2(const double a,const double b,double &f[],const double t);
   //--- 1-dimensional spline interpolation
   static void       Spline1DBuildLinear(double &x[],double &y[],const int n,CSpline1DInterpolantShell &c);
   static void       Spline1DBuildLinear(double &x[],double &y[],CSpline1DInterpolantShell &c);
   static void       Spline1DBuildCubic(double &x[],double &y[],const int n,const int boundltype,const double boundl,const int boundrtype,const double boundr,CSpline1DInterpolantShell &c);
   static void       Spline1DBuildCubic(double &x[],double &y[],CSpline1DInterpolantShell &c);
   static void       Spline1DGridDiffCubic(double &x[],double &y[],const int n,const int boundltype,const double boundl,const int boundrtype,const double boundr,double &d[]);
   static void       Spline1DGridDiffCubic(double &x[],double &y[],double &d[]);
   static void       Spline1DGridDiff2Cubic(double &x[],double &y[],const int n,const int boundltype,const double boundl,const int boundrtype,const double boundr,double &d1[],double &d2[]);
   static void       Spline1DGridDiff2Cubic(double &x[],double &y[],double &d1[],double &d2[]);
   static void       Spline1DConvCubic(double &x[],double &y[],const int n,const int boundltype,const double boundl,const int boundrtype,const double boundr,double &x2[],int n2,double &y2[]);
   static void       Spline1DConvCubic(double &x[],double &y[],double &x2[],double &y2[]);
   static void       Spline1DConvDiffCubic(double &x[],double &y[],const int n,const int boundltype,const double boundl,const int boundrtype,const double boundr,double &x2[],int n2,double &y2[],double &d2[]);
   static void       Spline1DConvDiffCubic(double &x[],double &y[],double &x2[],double &y2[],double &d2[]);
   static void       Spline1DConvDiff2Cubic(double &x[],double &y[],const int n,const int boundltype,const double boundl,const int boundrtype,const double boundr,double &x2[],const int n2,double &y2[],double &d2[],double &dd2[]);
   static void       Spline1DConvDiff2Cubic(double &x[],double &y[],double &x2[],double &y2[],double &d2[],double &dd2[]);
   static void       Spline1DBuildCatmullRom(double &x[],double &y[],const int n,const int boundtype,const double tension,CSpline1DInterpolantShell &c);
   static void       Spline1DBuildCatmullRom(double &x[],double &y[],CSpline1DInterpolantShell &c);
   static void       Spline1DBuildHermite(double &x[],double &y[],double &d[],const int n,CSpline1DInterpolantShell &c);
   static void       Spline1DBuildHermite(double &x[],double &y[],double &d[],CSpline1DInterpolantShell &c);
   static void       Spline1DBuildAkima(double &x[],double &y[],const int n,CSpline1DInterpolantShell &c);
   static void       Spline1DBuildAkima(double &x[],double &y[],CSpline1DInterpolantShell &c);
   static double     Spline1DCalc(CSpline1DInterpolantShell &c,const double x);
   static void       Spline1DDiff(CSpline1DInterpolantShell &c,const double x,double &s,double &ds,double &d2s);
   static void       Spline1DUnpack(CSpline1DInterpolantShell &c,int &n,CMatrixDouble &tbl);
   static void       Spline1DLinTransX(CSpline1DInterpolantShell &c,const double a,const double b);
   static void       Spline1DLinTransY(CSpline1DInterpolantShell &c,const double a,const double b);
   static double     Spline1DIntegrate(CSpline1DInterpolantShell &c,const double x);
   static void       Spline1DFit(double &x[],double &y[],int n,int m,double lambdans,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFit(double &x[],double &y[],int m,double lambdans,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DBuildMonotone(double &x[],double &y[],int n,CSpline1DInterpolantShell &c);
   static void       Spline1DBuildMonotone(double &x[],double &y[],CSpline1DInterpolantShell &c);
   static void       Spline1DBuildMonotone(CRowDouble &x,CRowDouble &y,CSpline1DInterpolantShell &c);
   //--- least squares fitting
   static void       PolynomialFit(double &x[],double &y[],const int n,const int m,int &info,CBarycentricInterpolantShell &p,CPolynomialFitReportShell &rep);
   static void       PolynomialFit(double &x[],double &y[],const int m,int &info,CBarycentricInterpolantShell &p,CPolynomialFitReportShell &rep);
   static void       PolynomialFitWC(double &x[],double &y[],double &w[],const int n,double &xc[],double &yc[],int &dc[],const int k,const int m,int &info,CBarycentricInterpolantShell &p,CPolynomialFitReportShell &rep);
   static void       PolynomialFitWC(double &x[],double &y[],double &w[],double &xc[],double &yc[],int &dc[],const int m,int &info,CBarycentricInterpolantShell &p,CPolynomialFitReportShell &rep);
   static void       BarycentricFitFloaterHormannWC(double &x[],double &y[],double &w[],const int n,double &xc[],double &yc[],int &dc[],const int k,const int m,int &info,CBarycentricInterpolantShell &b,CBarycentricFitReportShell &rep);
   static void       BarycentricFitFloaterHormann(double &x[],double &y[],const int n,const int m,int &info,CBarycentricInterpolantShell &b,CBarycentricFitReportShell &rep);
   static void       Spline1DFitPenalized(double &x[],double &y[],const int n,const int m,const double rho,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFitPenalized(double &x[],double &y[],const int m,const double rho,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFitPenalizedW(double &x[],double &y[],double &w[],const int n,const int m,const double rho,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFitPenalizedW(double &x[],double &y[],double &w[],const int m,const double rho,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFitCubicWC(double &x[],double &y[],double &w[],const int n,double &xc[],double &yc[],int &dc[],const int k,const int m,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFitCubicWC(double &x[],double &y[],double &w[],double &xc[],double &yc[],int &dc[],const int m,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFitHermiteWC(double &x[],double &y[],double &w[],const int n,double &xc[],double &yc[],int &dc[],const int k,const int m,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFitHermiteWC(double &x[],double &y[],double &w[],double &xc[],double &yc[],int &dc[],const int m,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFitCubic(double &x[],double &y[],const int n,const int m,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFitCubic(double &x[],double &y[],const int m,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFitHermite(double &x[],double &y[],const int n,const int m,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       Spline1DFitHermite(double &x[],double &y[],const int m,int &info,CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep);
   static void       LSFitLinearW(double &y[],double &w[],CMatrixDouble &fmatrix,const int n,const int m,int &info,double &c[],CLSFitReportShell &rep);
   static void       LSFitLinearW(double &y[],double &w[],CMatrixDouble &fmatrix,int &info,double &c[],CLSFitReportShell &rep);
   static void       LSFitLinearWC(double &y[],double &w[],CMatrixDouble &fmatrix,CMatrixDouble &cmatrix,const int n,const int m,const int k,int &info,double &c[],CLSFitReportShell &rep);
   static void       LSFitLinearWC(double &y[],double &w[],CMatrixDouble &fmatrix,CMatrixDouble &cmatrix,int &info,double &c[],CLSFitReportShell &rep);
   static void       LSFitLinear(double &y[],CMatrixDouble &fmatrix,const int n,const int m,int &info,double &c[],CLSFitReportShell &rep);
   static void       LSFitLinear(double &y[],CMatrixDouble &fmatrix,int &info,double &c[],CLSFitReportShell &rep);
   static void       LSFitLinearC(double &y[],CMatrixDouble &fmatrix,CMatrixDouble &cmatrix,const int n,const int m,const int k,int &info,double &c[],CLSFitReportShell &rep);
   static void       LSFitLinearC(double &y[],CMatrixDouble &fmatrix,CMatrixDouble &cmatrix,int &info,double &c[],CLSFitReportShell &rep);
   static void       LSFitCreateWF(CMatrixDouble &x,double &y[],double &w[],double &c[],const int n,const int m,const int k,const double diffstep,CLSFitStateShell &state);
   static void       LSFitCreateWF(CMatrixDouble &x,double &y[],double &w[],double &c[],const double diffstep,CLSFitStateShell &state);
   static void       LSFitCreateF(CMatrixDouble &x,double &y[],double &c[],const int n,const int m,const int k,const double diffstep,CLSFitStateShell &state);
   static void       LSFitCreateF(CMatrixDouble &x,double &y[],double &c[],const double diffstep,CLSFitStateShell &state);
   static void       LSFitCreateWFG(CMatrixDouble &x,double &y[],double &w[],double &c[],const int n,const int m,const int k,const bool cheapfg,CLSFitStateShell &state);
   static void       LSFitCreateWFG(CMatrixDouble &x,double &y[],double &w[],double &c[],const bool cheapfg,CLSFitStateShell &state);
   static void       LSFitCreateFG(CMatrixDouble &x,double &y[],double &c[],const int n,const int m,const int k,const bool cheapfg,CLSFitStateShell &state);
   static void       LSFitCreateFG(CMatrixDouble &x,double &y[],double &c[],const bool cheapfg,CLSFitStateShell &state);
   static void       LSFitCreateWFGH(CMatrixDouble &x,double &y[],double &w[],double &c[],const int n,const int m,const int k,CLSFitStateShell &state);
   static void       LSFitCreateWFGH(CMatrixDouble &x,double &y[],double &w[],double &c[],CLSFitStateShell &state);
   static void       LSFitCreateFGH(CMatrixDouble &x,double &y[],double &c[],const int n,const int m,const int k,CLSFitStateShell &state);
   static void       LSFitCreateFGH(CMatrixDouble &x,double &y[],double &c[],CLSFitStateShell &state);
   static void       LSFitSetCond(CLSFitStateShell &state,const double epsx,const int maxits);
   static void       LSFitSetStpMax(CLSFitStateShell &state,const double stpmax);
   static void       LSFitSetXRep(CLSFitStateShell &state,const bool needxrep);
   static void       LSFitSetScale(CLSFitStateShell &state,double &s[]);
   static void       LSFitSetBC(CLSFitStateShell &state,double &bndl[],double &bndu[]);
   static bool       LSFitIteration(CLSFitStateShell &state);
   static void       LSFitFit(CLSFitStateShell &state,CNDimensional_PFunc &func,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       LSFitFit(CLSFitStateShell &state,CNDimensional_PFunc &func,CNDimensional_PGrad &grad,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       LSFitFit(CLSFitStateShell &state,CNDimensional_PFunc &func,CNDimensional_PGrad &grad,CNDimensional_PHess &hess,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       LSFitResults(CLSFitStateShell &state,int &info,double &c[],CLSFitReportShell &rep);
   static double     LogisticCalc4(double x,double a,double b,double c,double d);
   static double     LogisticCalc5(double x,double a,double b,double c,double d,double g);
   static void       LogisticFit4(CRowDouble &x,CRowDouble &y,int n,double &a,double &b,double &c,double &d,CLSFitReportShell &rep);
   static void       LogisticFit4ec(CRowDouble &x,CRowDouble &y,int n,double cnstrleft,double cnstrright,double &a,double &b,double &c,double &d,CLSFitReportShell &rep);
   static void       LogisticFit5(CRowDouble &x,CRowDouble &y,int n,double &a,double &b,double &c,double &d,double &g,CLSFitReportShell &rep);
   static void       LogisticFit5ec(CRowDouble &x,CRowDouble &y,int n,double cnstrleft,double cnstrright,double &a,double &b,double &c,double &d,double &g,CLSFitReportShell &rep);
   static void       LogisticFit45x(CRowDouble &x,CRowDouble &y,int n,double cnstrleft,double cnstrright,bool is4pl,double lambdav,double epsx,int rscnt,double &a,double &b,double &c,double &d,double &g,CLSFitReportShell &rep);
   //--- least squares (LS) circle
   static void       FitSphereLS(CMatrixDouble &xy,int npoints,int nx,CRowDouble &cx,double &r);
   static void       FitSphereMC(CMatrixDouble &xy,int npoints,int nx,CRowDouble &cx,double &rhi);
   static void       FitSphereMI(CMatrixDouble &xy,int npoints,int nx,CRowDouble &cx,double &rlo);
   static void       FitSphereMZ(CMatrixDouble &xy,int npoints,int nx,CRowDouble &cx,double &rlo,double &rhi);
   static void       FitSphereX(CMatrixDouble &xy,int npoints,int nx,int problemtype,double epsx,int aulits,double penalty,CRowDouble &cx,double &rlo,double &rhi);
   //--- parametric spline
   static void       PSpline2Build(CMatrixDouble &xy,const int n,const int st,const int pt,CPSpline2InterpolantShell &p);
   static void       PSpline3Build(CMatrixDouble &xy,const int n,const int st,const int pt,CPSpline3InterpolantShell &p);
   static void       PSpline2BuildPeriodic(CMatrixDouble &xy,const int n,const int st,const int pt,CPSpline2InterpolantShell &p);
   static void       PSpline3BuildPeriodic(CMatrixDouble &xy,const int n,const int st,const int pt,CPSpline3InterpolantShell &p);
   static void       PSpline2ParameterValues(CPSpline2InterpolantShell &p,int &n,double &t[]);
   static void       PSpline3ParameterValues(CPSpline3InterpolantShell &p,int &n,double &t[]);
   static void       PSpline2Calc(CPSpline2InterpolantShell &p,const double t,double &x,double &y);
   static void       PSpline3Calc(CPSpline3InterpolantShell &p,const double t,double &x,double &y,double &z);
   static void       PSpline2Tangent(CPSpline2InterpolantShell &p,const double t,double &x,double &y);
   static void       PSpline3Tangent(CPSpline3InterpolantShell &p,const double t,double &x,double &y,double &z);
   static void       PSpline2Diff(CPSpline2InterpolantShell &p,const double t,double &x,double &dx,double &y,double &dy);
   static void       PSpline3Diff(CPSpline3InterpolantShell &p,const double t,double &x,double &dx,double &y,double &dy,double &z,double &dz);
   static void       PSpline2Diff2(CPSpline2InterpolantShell &p,const double t,double &x,double &dx,double &d2x,double &y,double &dy,double &d2y);
   static void       PSpline3Diff2(CPSpline3InterpolantShell &p,const double t,double &x,double &dx,double &d2x,double &y,double &dy,double &d2y,double &z,double &dz,double &d2z);
   static double     PSpline2ArcLength(CPSpline2InterpolantShell &p,const double a,const double b);
   static double     PSpline3ArcLength(CPSpline3InterpolantShell &p,const double a,const double b);
   static void       ParametricRDPFixed(CMatrixDouble &x,int n,int d,int stopm,double stopeps,CMatrixDouble &x2,int &idx2[],int &nsections);
   //--- 2-dimensional spline interpolation
   static void       Spline2DSerialize(CSpline2DInterpolantShell &obj,string &s_out);
   static void       Spline2DUnserialize(string s_in,CSpline2DInterpolantShell &obj);
   static double     Spline2DCalc(CSpline2DInterpolantShell &c,const double x,const double y);
   static void       Spline2DDiff(CSpline2DInterpolantShell &c,const double x,const double y,double &f,double &fx,double &fy,double &fxy);
   static void       Spline2DCalcVBuf(CSpline2DInterpolantShell &c,double x,double y,CRowDouble &f);
   static double     Spline2DCalcVi(CSpline2DInterpolantShell &c,double x,double y,int i);
   static void       Spline2DCalcV(CSpline2DInterpolantShell &c,double x,double y,CRowDouble &f);
   static void       Spline2DDiffVi(CSpline2DInterpolantShell &c,double x,double y,int i,double &f,double &fx,double &fy,double &fxy);
   static void       Spline2DLinTransXY(CSpline2DInterpolantShell &c,const double ax,const double bx,const double ay,const double by);
   static void       Spline2DLinTransF(CSpline2DInterpolantShell &c,const double a,const double b);
   static void       Spline2DCopy(CSpline2DInterpolantShell &c,CSpline2DInterpolantShell &cc);
   static void       Spline2DResampleBicubic(CMatrixDouble &a,const int oldheight,const int oldwidth,CMatrixDouble &b,const int newheight,const int newwidth);
   static void       Spline2DResampleBilinear(CMatrixDouble &a,const int oldheight,const int oldwidth,CMatrixDouble &b,const int newheight,const int newwidth);
   static void       Spline2DBuildBilinearV(CRowDouble &x,int n,CRowDouble &y,int m,CRowDouble &f,int d,CSpline2DInterpolantShell &c);
   static void       Spline2DBuildBicubicV(CRowDouble &x,int n,CRowDouble &y,int m,CRowDouble &f,int d,CSpline2DInterpolantShell &c);
   static void       Spline2DUnpackV(CSpline2DInterpolantShell &c,int &m,int &n,int &d,CMatrixDouble &tbl);
   static void       Spline2DBuildBilinear(double &x[],double &y[],CMatrixDouble &f,const int m,const int n,CSpline2DInterpolantShell &c);
   static void       Spline2DBuildBicubic(double &x[],double &y[],CMatrixDouble &f,const int m,const int n,CSpline2DInterpolantShell &c);
   static void       Spline2DUnpack(CSpline2DInterpolantShell &c,int &m,int &n,CMatrixDouble &tbl);
   static void       Spline2DBuilderCreate(int d,CSpline2DBuilder &state);
   static void       Spline2DBuilderSetUserTerm(CSpline2DBuilder &state,double v);
   static void       Spline2DBuilderSetLinTerm(CSpline2DBuilder &state);
   static void       Spline2DBuilderSetConstTerm(CSpline2DBuilder &state);
   static void       Spline2DBuilderSetZeroTerm(CSpline2DBuilder &state);
   static void       Spline2DBuilderSetPoints(CSpline2DBuilder &state,CMatrixDouble &xy,int n);
   static void       Spline2DBuilderSetAreaAuto(CSpline2DBuilder &state);
   static void       Spline2DBuilderSetArea(CSpline2DBuilder &state,double xa,double xb,double ya,double yb);
   static void       Spline2DBuilderSetGrid(CSpline2DBuilder &state,int kx,int ky);
   static void       Spline2DBuilderSetAlgoFastDDM(CSpline2DBuilder &state,int nlayers,double lambdav);
   static void       Spline2DBuilderSetAlgoBlockLLS(CSpline2DBuilder &state,double lambdans);
   static void       Spline2DBuilderSetAlgoNaiveLLS(CSpline2DBuilder &state,double lambdans);
   static void       Spline2DFit(CSpline2DBuilder &state,CSpline2DInterpolantShell &s,CSpline2DFitReport &rep);
   //--- 3-dimensional spline interpolation
   static double     Spline3DCalc(CSpline3DInterpolant &c,double x,double y,double z);
   static void       Spline3DLinTransXYZ(CSpline3DInterpolant &c,double ax,double bx,double ay,double by,double az,double bz);
   static void       Spline3DLinTransF(CSpline3DInterpolant &c,double a,double b);
   static void       Spline3DResampleTrilinear(CRowDouble &a,int oldzcount,int oldycount,int oldxcount,int newzcount,int newycount,int newxcount,CRowDouble &b);
   static void       Spline3DBuildTrilinearV(CRowDouble &x,int n,CRowDouble &y,int m,CRowDouble &z,int l,CRowDouble &f,int d,CSpline3DInterpolant &c);
   static void       Spline3DCalcVBuf(CSpline3DInterpolant &c,double x,double y,double z,CRowDouble &f);
   static void       Spline3DCalcV(CSpline3DInterpolant &c,double x,double y,double z,CRowDouble &f);
   static void       Spline3DUnpackV(CSpline3DInterpolant &c,int &n,int &m,int &l,int &d,int &stype,CMatrixDouble &tbl);
   //--- RBF model
   static void       RBFSerialize(CRBFModel &obj,string &s_out);
   static void       RBFUnserialize(string s_in,CRBFModel &obj);
   static void       RBFCreate(int nx,int ny,CRBFModel &s);
   static void       RBFCreateCalcBuffer(CRBFModel &s,CRBFCalcBuffer &buf);
   static void       RBFSetPoints(CRBFModel &s,CMatrixDouble &xy,int n);
   static void       RBFSetPoints(CRBFModel &s,CMatrixDouble &xy);
   static void       RBFSetPointsAndScales(CRBFModel &r,CMatrixDouble &xy,int n,CRowDouble &s);
   static void       RBFSetPointsAndScales(CRBFModel &r,CMatrixDouble &xy,CRowDouble &s);
   static void       RBFSetAlgoQNN(CRBFModel &s,double q=1.0,double z=5.0);
   static void       RBFSetAlgoMultilayer(CRBFModel &s,double rbase,int nlayers,double lambdav=0.01);
   static void       RBFSetAlgoHierarchical(CRBFModel &s,double rbase,int nlayers,double lambdans);
   static void       RBFSetAlgoThinPlateSpline(CRBFModel &s,double lambdav=0.0);
   static void       RBFSetAlgoMultiQuadricManual(CRBFModel &s,double alpha,double lambdav=0.0);
   static void       RBFSetAlgoMultiQuadricAuto(CRBFModel &s,double lambdav=0.0);
   static void       RBFSetAlgoBiharmonic(CRBFModel &s,double lambdav=0.0);
   static void       RBFSetLinTerm(CRBFModel &s);
   static void       RBFSetConstTerm(CRBFModel &s);
   static void       RBFSetZeroTerm(CRBFModel &s);
   static void       RBFSetV2BF(CRBFModel &s,int bf);
   static void       RBFSetV2Its(CRBFModel &s,int maxits);
   static void       RBFSetV2SupportR(CRBFModel &s,double r);
   static void       RBFBuildModel(CRBFModel &s,CRBFReport &rep);
   static double     RBFCalc1(CRBFModel &s,double x0);
   static double     RBFCalc2(CRBFModel &s,double x0,double x1);
   static double     RBFCalc3(CRBFModel &s,double x0,double x1,double x2);
   static void       RBFDiff1(CRBFModel &s,double x0,double &y,double &dy0);
   static void       RBFDiff2(CRBFModel &s,double x0,double x1,double &y,double &dy0,double &dy1);
   static void       RBFDiff3(CRBFModel &s,double x0,double x1,double x2,double &y,double &dy0,double &dy1,double &dy2);
   static void       RBFCalc(CRBFModel &s,CRowDouble &x,CRowDouble &y);
   static void       RBFDiff(CRBFModel &s,CRowDouble &x,CRowDouble &y,CRowDouble &dy);
   static void       RBFHess(CRBFModel &s,CRowDouble &x,CRowDouble &y,CRowDouble &dy,CRowDouble &d2y);
   static void       RBFCalcBuf(CRBFModel &s,CRowDouble &x,CRowDouble &y);
   static void       RBFDiffBuf(CRBFModel &s,CRowDouble &x,CRowDouble &y,CRowDouble &dy);
   static void       RBFHessBuf(CRBFModel &s,CRowDouble &x,CRowDouble &y,CRowDouble &dy,CRowDouble &d2y);
   static void       RBFTSCalcBuf(CRBFModel &s,CRBFCalcBuffer &buf,CRowDouble &x,CRowDouble &y);
   static void       RBFTSDiffBuf(CRBFModel &s,CRBFCalcBuffer &buf,CRowDouble &x,CRowDouble &y,CRowDouble &dy);
   static void       RBFTSHessBuf(CRBFModel &s,CRBFCalcBuffer &buf,CRowDouble &x,CRowDouble &y,CRowDouble &dy,CRowDouble &d2y);
   static void       RBFGridCalc2(CRBFModel &s,CRowDouble &x0,int n0,CRowDouble &x1,int n1,CMatrixDouble &y);
   static void       RBFGridCalc2V(CRBFModel &s,CRowDouble &x0,int n0,CRowDouble &x1,int n1,CRowDouble &y);
   static void       RBFGridCalc2VSubset(CRBFModel &s,CRowDouble &x0,int n0,CRowDouble &x1,int n1,bool &flagy[],CRowDouble &y);
   static void       RBFGridCalc3V(CRBFModel &s,CRowDouble &x0,int n0,CRowDouble &x1,int n1,CRowDouble &x2,int n2,CRowDouble &y);
   static void       RBFGridCalc3VSubset(CRBFModel &s,CRowDouble &x0,int n0,CRowDouble &x1,int n1,CRowDouble &x2,int n2,bool &flagy[],CRowDouble &y);
   static void       RBFUnpack(CRBFModel &s,int &nx,int &ny,CMatrixDouble &xwr,int &nc,CMatrixDouble &v,int &modelversion);
   static int        RBFGetModelVersion(CRBFModel &s);
   static double     RBFPeekProgress(CRBFModel &s);
   static void       RBFRequestTermination(CRBFModel &s);
   //--- functions of package linalg
   //--- working with matrix forms
   static void       CMatrixTranspose(const int m,const int n,CMatrixComplex &a,const int ia,const int ja,CMatrixComplex &b,const int ib,const int jb);
   static void       RMatrixTranspose(const int m,const int n,CMatrixDouble &a,const int ia,const int ja,CMatrixDouble &b,const int ib,const int jb);
   static void       RMatrixEnforceSymmetricity(CMatrixDouble &a,int n,bool IsUpper);
   static void       CMatrixCopy(const int m,const int n,CMatrixComplex &a,const int ia,const int ja,CMatrixComplex &b,const int ib,const int jb);
   static void       RVectorCopy(int n,CRowDouble &a,int ia,CRowDouble &b,int ib);
   static void       RMatrixCopy(const int m,const int n,CMatrixDouble &a,const int ia,const int ja,CMatrixDouble &b,const int ib,const int jb);
   static void       RMatrixGenCopy(int m,int n,double alpha,CMatrixDouble &a,int ia,int ja,double beta,CMatrixDouble &b,int ib,int jb);
   static void       RMatrixGer(int m,int n,CMatrixDouble &a,int ia,int ja,double alpha,CRowDouble &u,int iu,CRowDouble &v,int iv);
   static void       CMatrixRank1(const int m,const int n,CMatrixComplex &a,const int ia,const int ja,complex &u[],const int iu,complex &v[],const int iv);
   static void       RMatrixRank1(const int m,const int n,CMatrixDouble &a,const int ia,const int ja,double &u[],const int iu,double &v[],const int iv);
   static void       RMatrixGemVect(int m,int n,double alpha,CMatrixDouble &a,int ia,int ja,int opa,CRowDouble &x,int ix,double beta,CRowDouble &y,int iy);
   static void       CMatrixMVect(const int m,const int n,CMatrixComplex &a,const int ia,const int ja,const int opa,complex &x[],const int ix,complex &y[],const int iy);
   static void       RMatrixMVect(const int m,const int n,CMatrixDouble &a,const int ia,const int ja,const int opa,double &x[],const int ix,double &y[],const int iy);
   static void       RMatrixSymVect(int n,double alpha,CMatrixDouble &a,int ia,int ja,bool IsUpper,CRowDouble &x,int ix,double beta,CRowDouble &y,int iy);
   static double     RMatrixSyvMVect(int n,CMatrixDouble &a,int ia,int ja,bool IsUpper,CRowDouble &x,int ix,CRowDouble &tmp);
   static void       RMatrixTrsVect(int n,CMatrixDouble &a,int ia,int ja,bool IsUpper,bool IsUnit,int OpType,CRowDouble &x,int ix);
   static void       CMatrixRightTrsM(const int m,const int n,CMatrixComplex &a,const int i1,const int j1,const bool IsUpper,const bool IsUnit,const int OpType,CMatrixComplex &x,const int i2,const int j2);
   static void       CMatrixLeftTrsM(const int m,const int n,CMatrixComplex &a,const int i1,const int j1,const bool IsUpper,const bool IsUnit,const int OpType,CMatrixComplex &x,const int i2,const int j2);
   static void       RMatrixRightTrsM(const int m,const int n,CMatrixDouble &a,const int i1,const int j1,const bool IsUpper,const bool IsUnit,const int OpType,CMatrixDouble &x,const int i2,const int j2);
   static void       RMatrixLeftTrsM(const int m,const int n,CMatrixDouble &a,const int i1,const int j1,const bool IsUpper,const bool IsUnit,const int OpType,CMatrixDouble &x,const int i2,const int j2);
   static void       CMatrixSyrk(const int n,const int k,const double alpha,CMatrixComplex &a,const int ia,const int ja,const int optypea,const double beta,CMatrixComplex &c,const int ic,const int jc,const bool IsUpper);
   static void       RMatrixSyrk(const int n,const int k,const double alpha,CMatrixDouble &a,const int ia,const int ja,const int optypea,const double beta,CMatrixDouble &c,const int ic,const int jc,const bool IsUpper);
   static void       CMatrixGemm(const int m,const int n,const int k,complex alpha,CMatrixComplex &a,const int ia,const int ja,const int optypea,CMatrixComplex &b,const int ib,const int jb,const int optypeb,complex beta,CMatrixComplex &c,const int ic,const int jc);
   static void       RMatrixGemm(const int m,const int n,const int k,const double alpha,CMatrixDouble &a,const int ia,const int ja,const int optypea,CMatrixDouble &b,const int ib,const int jb,const int optypeb,const double beta,CMatrixDouble &c,const int ic,const int jc);
   //--- orthogonal factorizations
   static void       RMatrixQR(CMatrixDouble &a,const int m,const int n,double &tau[]);
   static void       RMatrixLQ(CMatrixDouble &a,const int m,const int n,double &tau[]);
   static void       CMatrixQR(CMatrixComplex &a,const int m,const int n,complex &tau[]);
   static void       CMatrixLQ(CMatrixComplex &a,const int m,const int n,complex &tau[]);
   static void       RMatrixQRUnpackQ(CMatrixDouble &a,const int m,const int n,double &tau[],const int qcolumns,CMatrixDouble &q);
   static void       RMatrixQRUnpackR(CMatrixDouble &a,const int m,const int n,CMatrixDouble &r);
   static void       RMatrixLQUnpackQ(CMatrixDouble &a,const int m,const int n,double &tau[],const int qrows,CMatrixDouble &q);
   static void       RMatrixLQUnpackL(CMatrixDouble &a,const int m,const int n,CMatrixDouble &l);
   static void       CMatrixQRUnpackQ(CMatrixComplex &a,const int m,const int n,complex &tau[],const int qcolumns,CMatrixComplex &q);
   static void       CMatrixQRUnpackR(CMatrixComplex &a,const int m,const int n,CMatrixComplex &r);
   static void       CMatrixLQUnpackQ(CMatrixComplex &a,const int m,const int n,complex &tau[],const int qrows,CMatrixComplex &q);
   static void       CMatrixLQUnpackL(CMatrixComplex &a,const int m,const int n,CMatrixComplex &l);
   static void       RMatrixBD(CMatrixDouble &a,const int m,const int n,double &tauq[],double &taup[]);
   static void       RMatrixBDUnpackQ(CMatrixDouble &qp,const int m,const int n,double &tauq[],const int qcolumns,CMatrixDouble &q);
   static void       RMatrixBDMultiplyByQ(CMatrixDouble &qp,const int m,const int n,double &tauq[],CMatrixDouble &z,const int zrows,const int zcolumns,const bool fromtheright,const bool dotranspose);
   static void       RMatrixBDUnpackPT(CMatrixDouble &qp,const int m,const int n,double &taup[],const int ptrows,CMatrixDouble &pt);
   static void       RMatrixBDMultiplyByP(CMatrixDouble &qp,const int m,const int n,double &taup[],CMatrixDouble &z,const int zrows,const int zcolumns,const bool fromtheright,const bool dotranspose);
   static void       RMatrixBDUnpackDiagonals(CMatrixDouble &b,const int m,const int n,bool &IsUpper,double &d[],double &e[]);
   static void       RMatrixHessenberg(CMatrixDouble &a,const int n,double &tau[]);
   static void       RMatrixHessenbergUnpackQ(CMatrixDouble &a,const int n,double &tau[],CMatrixDouble &q);
   static void       RMatrixHessenbergUnpackH(CMatrixDouble &a,const int n,CMatrixDouble &h);
   static void       SMatrixTD(CMatrixDouble &a,const int n,const bool IsUpper,double &tau[],double &d[],double &e[]);
   static void       SMatrixTDUnpackQ(CMatrixDouble &a,const int n,const bool IsUpper,double &tau[],CMatrixDouble &q);
   static void       HMatrixTD(CMatrixComplex &a,const int n,const bool IsUpper,complex &tau[],double &d[],double &e[]);
   static void       HMatrixTDUnpackQ(CMatrixComplex &a,const int n,const bool IsUpper,complex &tau[],CMatrixComplex &q);
   //--- eigenvalues and eigenvectors
   static void       EigSubSpaceCreate(int n,int k,CEigSubSpaceState &state);
   static void       EigSubSpaceCreateBuf(int n,int k,CEigSubSpaceState &state);
   static void       EigSubSpaceSetCond(CEigSubSpaceState &state,double eps,int maxits);
   static void       EigSubSpaceSetWarmStart(CEigSubSpaceState &state,bool usewarmstart);
   static void       EigSubSpaceOOCStart(CEigSubSpaceState &state,int mtype);
   static bool       EigSubSpaceOOCContinue(CEigSubSpaceState &state);
   static void       EigSubSpaceOOCGetRequestInfo(CEigSubSpaceState &state,int &requesttype,int &requestsize);
   static void       EigSubSpaceOOCGetRequestData(CEigSubSpaceState &state,CMatrixDouble &x);
   static void       EigSubSpaceOOCSendResult(CEigSubSpaceState &state,CMatrixDouble &ax);
   static void       EigSubSpaceOOCStop(CEigSubSpaceState &state,CRowDouble &w,CMatrixDouble &z,CEigSubSpaceReport &rep);
   static void       EigSubSpaceSolveDenses(CEigSubSpaceState &state,CMatrixDouble &a,bool IsUpper,CRowDouble &w,CMatrixDouble &z,CEigSubSpaceReport &rep);
   static void       EigSubSpaceSolveSparses(CEigSubSpaceState &state,CSparseMatrix &a,bool IsUpper,CRowDouble &w,CMatrixDouble &z,CEigSubSpaceReport &rep);
   static bool       SMatrixEVD(CMatrixDouble &a,const int n,int zneeded,const bool IsUpper,double &d[],CMatrixDouble &z);
   static bool       SMatrixEVDR(CMatrixDouble &a,const int n,int zneeded,const bool IsUpper,double b1,double b2,int &m,double &w[],CMatrixDouble &z);
   static bool       SMatrixEVDI(CMatrixDouble &a,const int n,int zneeded,const bool IsUpper,const int i1,const int i2,double &w[],CMatrixDouble &z);
   static bool       HMatrixEVD(CMatrixComplex &a,const int n,const int zneeded,const bool IsUpper,double &d[],CMatrixComplex &z);
   static bool       HMatrixEVDR(CMatrixComplex &a,const int n,const int zneeded,const bool IsUpper,double b1,double b2,int &m,double &w[],CMatrixComplex &z);
   static bool       HMatrixEVDI(CMatrixComplex &a,const int n,const int zneeded,const bool IsUpper,const int i1,const int i2,double &w[],CMatrixComplex &z);
   static bool       SMatrixTdEVD(double &d[],double &e[],const int n,const int zneeded,CMatrixDouble &z);
   static bool       SMatrixTdEVDR(double &d[],double &e[],const int n,const int zneeded,const double a,const double b,int &m,CMatrixDouble &z);
   static bool       SMatrixTdEVDI(double &d[],double &e[],const int n,const int zneeded,const int i1,const int i2,CMatrixDouble &z);
   static bool       RMatrixEVD(CMatrixDouble &a,const int n,const int vneeded,double &wr[],double &wi[],CMatrixDouble &vl,CMatrixDouble &vr);
   //--- random matrix generation
   static void       RMatrixRndOrthogonal(const int n,CMatrixDouble &a);
   static void       RMatrixRndCond(const int n,const double c,CMatrixDouble &a);
   static void       CMatrixRndOrthogonal(const int n,CMatrixComplex &a);
   static void       CMatrixRndCond(const int n,const double c,CMatrixComplex &a);
   static void       SMatrixRndCond(const int n,const double c,CMatrixDouble &a);
   static void       SPDMatrixRndCond(const int n,const double c,CMatrixDouble &a);
   static void       HMatrixRndCond(const int n,const double c,CMatrixComplex &a);
   static void       HPDMatrixRndCond(const int n,const double c,CMatrixComplex &a);
   static void       RMatrixRndOrthogonalFromTheRight(CMatrixDouble &a,const int m,const int n);
   static void       RMatrixRndOrthogonalFromTheLeft(CMatrixDouble &a,const int m,const int n);
   static void       CMatrixRndOrthogonalFromTheRight(CMatrixComplex &a,const int m,const int n);
   static void       CMatrixRndOrthogonalFromTheLeft(CMatrixComplex &a,const int m,const int n);
   static void       SMatrixRndMultiply(CMatrixDouble &a,const int n);
   static void       HMatrixRndMultiply(CMatrixComplex &a,const int n);
   //--- sparse matrix
   static void       SparseSerialize(CSparseMatrix &obj,string &s_out);
   static void       SparseUunserialize(string s_in,CSparseMatrix &obj);
   static void       SparseCreate(int m,int n,int k,CSparseMatrix &s);
   static void       SparseCreate(int m,int n,CSparseMatrix &s);
   static void       SparseCreateBuf(int m,int n,int k,CSparseMatrix &s);
   static void       SparseCreateBuf(int m,int n,CSparseMatrix &s);
   static void       SparseCreateCRS(int m,int n,CRowInt &ner,CSparseMatrix &s);
   static void       SparseCreateCRS(int m,int n,int &ner[],CSparseMatrix &s);
   static void       SparseCreateCRSBuf(int m,int n,CRowInt &ner,CSparseMatrix &s);
   static void       SparseCreateCRSBuf(int m,int n,int &ner[],CSparseMatrix &s);
   static void       SparseCreateSKS(int m,int n,CRowInt &d,CRowInt &u,CSparseMatrix &s);
   static void       SparseCreateSKS(int m,int n,int &d[],int &u[],CSparseMatrix &s);
   static void       SparseCreateSKSBuf(int m,int n,CRowInt &d,CRowInt &u,CSparseMatrix &s);
   static void       SparseCreateSKSBuf(int m,int n,int &d[],int &u[],CSparseMatrix &s);
   static void       SparseCreateSKSBand(int m,int n,int bw,CSparseMatrix &s);
   static void       SparseCreateSKSBandBuf(int m,int n,int bw,CSparseMatrix &s);
   static void       SparseCopy(CSparseMatrix &s0,CSparseMatrix &s1);
   static void       SparseCopyBuf(CSparseMatrix &s0,CSparseMatrix &s1);
   static void       SparseSwap(CSparseMatrix &s0,CSparseMatrix &s1);
   static void       SparseAdd(CSparseMatrix &s,int i,int j,double v);
   static void       SparseSet(CSparseMatrix &s,int i,int j,double v);
   static double     SparseGet(CSparseMatrix &s,int i,int j);
   static bool       SparseExists(CSparseMatrix &s,int i,int j);
   static double     SparseGetDiagonal(CSparseMatrix &s,int i);
   static void       SparseMV(CSparseMatrix &s,CRowDouble &x,CRowDouble &y);
   static void       SparseMTV(CSparseMatrix &s,CRowDouble &x,CRowDouble &y);
   static void       SparseGemV(CSparseMatrix &s,double alpha,int ops,CRowDouble &x,int ix,double beta,CRowDouble &y,int iy);
   static void       SparseMV2(CSparseMatrix &s,CRowDouble &x,CRowDouble &y0,CRowDouble &y1);
   static void       SparseSMV(CSparseMatrix &s,bool IsUpper,CRowDouble &x,CRowDouble &y);
   static double     SparseVSMV(CSparseMatrix &s,bool IsUpper,CRowDouble &x);
   static void       SparseMM(CSparseMatrix &s,CMatrixDouble &a,int k,CMatrixDouble &b);
   static void       SparseMTM(CSparseMatrix &s,CMatrixDouble &a,int k,CMatrixDouble &b);
   static void       SparseMM2(CSparseMatrix &s,CMatrixDouble &a,int k,CMatrixDouble &b0,CMatrixDouble &b1);
   static void       SparseSMM(CSparseMatrix &s,bool IsUpper,CMatrixDouble &a,int k,CMatrixDouble &b);
   static void       SparseTRMV(CSparseMatrix &s,bool IsUpper,bool IsUnit,int OpType,CRowDouble &x,CRowDouble &y);
   static void       SparseTRSV(CSparseMatrix &s,bool IsUpper,bool IsUnit,int OpType,CRowDouble &x);
   static void       SparseSymmPermTbl(CSparseMatrix &a,bool IsUpper,CRowInt &p,CSparseMatrix &b);
   static void       SparseSymmPermTblBuf(CSparseMatrix &a,bool IsUpper,CRowInt &p,CSparseMatrix &b);
   static void       SparseResizeMatrix(CSparseMatrix &s);
   static bool       SparseEnumerate(CSparseMatrix &s,int &t0,int &t1,int &i,int &j,double &v);
   static bool       SparseRewriteExisting(CSparseMatrix &s,int i,int j,double v);
   static void       SparseGetRow(CSparseMatrix &s,int i,CRowDouble &irow);
   static void       SparseGetCompressedRow(CSparseMatrix &s,int i,CRowInt &colidx,CRowDouble &vals,int &nzcnt);
   static void       SparseTransposeSKS(CSparseMatrix &s);
   static void       SparseTransposeCRS(CSparseMatrix &s);
   static void       SparseCopyTransposeCRS(CSparseMatrix &s0,CSparseMatrix &s1);
   static void       SparseCopyTransposeCRSBuf(CSparseMatrix &s0,CSparseMatrix &s1);
   static void       SparseConvertTo(CSparseMatrix &s0,int fmt);
   static void       SparseCopyToBuf(CSparseMatrix &s0,int fmt,CSparseMatrix &s1);
   static void       SparseConvertToHash(CSparseMatrix &s);
   static void       SparseCopyToHash(CSparseMatrix &s0,CSparseMatrix &s1);
   static void       SparseCopyToHashBuf(CSparseMatrix &s0,CSparseMatrix &s1);
   static void       SparseConvertToCRS(CSparseMatrix &s);
   static void       SparseCopyToCRS(CSparseMatrix &s0,CSparseMatrix &s1);
   static void       SparseCopyToCRSBuf(CSparseMatrix &s0,CSparseMatrix &s1);
   static void       SparseConvertToSKS(CSparseMatrix &s);
   static void       SparseCopyToSKS(CSparseMatrix &s0,CSparseMatrix &s1);
   static void       SparseCopyToSKSBuf(CSparseMatrix &s0,CSparseMatrix &s1);
   static int        SparseGetMatrixType(CSparseMatrix &s);
   static bool       SparseIsHash(CSparseMatrix &s);
   static bool       SparseIsCRS(CSparseMatrix &s);
   static bool       SparseIsSKS(CSparseMatrix &s);
   static void       SparseFree(CSparseMatrix &s);
   static int        SparseGetNRows(CSparseMatrix &s);
   static int        SparseGetNCols(CSparseMatrix &s);
   static int        SparseGetUpperCount(CSparseMatrix &s);
   static int        SparseGetLowerCount(CSparseMatrix &s);
   //--- triangular factorizations
   static void       RMatrixLU(CMatrixDouble &a,const int m,const int n,int &pivots[]);
   static void       CMatrixLU(CMatrixComplex &a,const int m,const int n,int &pivots[]);
   static bool       HPDMatrixCholesky(CMatrixComplex &a,const int n,const bool IsUpper);
   static bool       SPDMatrixCholesky(CMatrixDouble &a,const int n,const bool IsUpper);
   static void       SPDMatrixCholeskyUpdateAdd1(CMatrixDouble &a,int n,bool IsUpper,CRowDouble &u);
   static void       SPDMatrixCholeskyUpdateFix(CMatrixDouble &a,int n,bool IsUpper,bool &fix[]);
   static void       SPDMatrixCholeskyUpdateAdd1Buf(CMatrixDouble &a,int n,bool IsUpper,CRowDouble &u,CRowDouble &bufr);
   static void       SPDMatrixCholeskyUpdateFixBuf(CMatrixDouble &a,int n,bool IsUpper,bool &fix[],CRowDouble &bufr);
   static bool       SparseLU(CSparseMatrix &a,int pivottype,CRowInt &p,CRowInt &q);
   static bool       SparseCholeskySkyLine(CSparseMatrix &a,int n,bool IsUpper);
   static bool       SparseCholesky(CSparseMatrix &a,bool IsUpper);
   static bool       SparseCholeskyP(CSparseMatrix &a,bool IsUpper,CRowInt &p);
   static bool       sparsecholeskyanalyze(CSparseMatrix &a,bool IsUpper,int facttype,int permtype,CSparseDecompositionAnalysis &analysis);
   static bool       SparseCholeskyFactorize(CSparseDecompositionAnalysis &analysis,bool needupper,CSparseMatrix &a,CRowDouble &d,CRowInt &p);
   static void       SparseCholeskyReload(CSparseDecompositionAnalysis &analysis,CSparseMatrix &a,bool IsUpper);
   //--- estimate of the condition numbers
   static double     RMatrixRCond1(CMatrixDouble &a,const int n);
   static double     RMatrixRCondInf(CMatrixDouble &a,const int n);
   static double     SPDMatrixRCond(CMatrixDouble &a,const int n,const bool IsUpper);
   static double     RMatrixTrRCond1(CMatrixDouble &a,const int n,const bool IsUpper,const bool IsUnit);
   static double     RMatrixTrRCondInf(CMatrixDouble &a,const int n,const bool IsUpper,const bool IsUnit);
   static double     HPDMatrixRCond(CMatrixComplex &a,const int n,const bool IsUpper);
   static double     CMatrixRCond1(CMatrixComplex &a,const int n);
   static double     CMatrixRCondInf(CMatrixComplex &a,const int n);
   static double     RMatrixLURCond1(CMatrixDouble &lua,const int n);
   static double     RMatrixLURCondInf(CMatrixDouble &lua,const int n);
   static double     SPDMatrixCholeskyRCond(CMatrixDouble &a,const int n,const bool IsUpper);
   static double     HPDMatrixCholeskyRCond(CMatrixComplex &a,const int n,const bool IsUpper);
   static double     CMatrixLURCond1(CMatrixComplex &lua,const int n);
   static double     CMatrixLURCondInf(CMatrixComplex &lua,const int n);
   static double     CMatrixTrRCond1(CMatrixComplex &a,const int n,const bool IsUpper,const bool IsUnit);
   static double     CMatrixTrRCondInf(CMatrixComplex &a,const int n,const bool IsUpper,const bool IsUnit);
   //--- norm estimator
   static void       NormEstimatorCreate(int m,int n,int nstart,int nits,CNormEstimatorState &state);
   static void       NormEstimatorSetSeed(CNormEstimatorState &state,int seedval);
   static void       NormEstimatorEstimateSparse(CNormEstimatorState &state,CSparseMatrix &a);
   static void       NormEstimatorResults(CNormEstimatorState &state,double &nrm);
   //--- matrix inversion
   static void       RMatrixLUInverse(CMatrixDouble &a,int &pivots[],const int n,int &info,CMatInvReportShell &rep);
   static void       RMatrixLUInverse(CMatrixDouble &a,int &pivots[],int &info,CMatInvReportShell &rep);
   static void       RMatrixInverse(CMatrixDouble &a,const int n,int &info,CMatInvReportShell &rep);
   static void       RMatrixInverse(CMatrixDouble &a,int &info,CMatInvReportShell &rep);
   static void       CMatrixLUInverse(CMatrixComplex &a,int &pivots[],const int n,int &info,CMatInvReportShell &rep);
   static void       CMatrixLUInverse(CMatrixComplex &a,int &pivots[],int &info,CMatInvReportShell &rep);
   static void       CMatrixInverse(CMatrixComplex &a,const int n,int &info,CMatInvReportShell &rep);
   static void       CMatrixInverse(CMatrixComplex &a,int &info,CMatInvReportShell &rep);
   static void       SPDMatrixCholeskyInverse(CMatrixDouble &a,const int n,const bool IsUpper,int &info,CMatInvReportShell &rep);
   static void       SPDMatrixCholeskyInverse(CMatrixDouble &a,int &info,CMatInvReportShell &rep);
   static void       SPDMatrixInverse(CMatrixDouble &a,const int n,const bool IsUpper,int &info,CMatInvReportShell &rep);
   static void       SPDMatrixInverse(CMatrixDouble &a,int &info,CMatInvReportShell &rep);
   static void       HPDMatrixCholeskyInverse(CMatrixComplex &a,const int n,const bool IsUpper,int &info,CMatInvReportShell &rep);
   static void       HPDMatrixCholeskyInverse(CMatrixComplex &a,int &info,CMatInvReportShell &rep);
   static void       HPDMatrixInverse(CMatrixComplex &a,const int n,const bool IsUpper,int &info,CMatInvReportShell &rep);
   static void       HPDMatrixInverse(CMatrixComplex &a,int &info,CMatInvReportShell &rep);
   static void       RMatrixTrInverse(CMatrixDouble &a,const int n,const bool IsUpper,const bool IsUnit,int &info,CMatInvReportShell &rep);
   static void       RMatrixTrInverse(CMatrixDouble &a,const bool IsUpper,int &info,CMatInvReportShell &rep);
   static void       CMatrixTrInverse(CMatrixComplex &a,const int n,const bool IsUpper,const bool IsUnit,int &info,CMatInvReportShell &rep);
   static void       CMatrixTrInverse(CMatrixComplex &a,const bool IsUpper,int &info,CMatInvReportShell &rep);
   //--- singular value decomposition of a bidiagonal matrix
   static bool       RMatrixBdSVD(double &d[],double &e[],const int n,const bool IsUpper,bool isfractionalaccuracyrequired,CMatrixDouble &u,const int nru,CMatrixDouble &c,const int ncc,CMatrixDouble &vt,const int ncvt);
   //--- singular value decomposition
   static bool       RMatrixSVD(CMatrixDouble &a,const int m,const int n,const int uneeded,const int vtneeded,const int additionalmemory,double &w[],CMatrixDouble &u,CMatrixDouble &vt);
   //--- calculation determinant of the matrix
   static double     RMatrixLUDet(CMatrixDouble &a,int &pivots[],const int n);
   static double     RMatrixLUDet(CMatrixDouble &a,int &pivots[]);
   static double     RMatrixDet(CMatrixDouble &a,const int n);
   static double     RMatrixDet(CMatrixDouble &a);
   static complex    CMatrixLUDet(CMatrixComplex &a,int &pivots[],const int n);
   static complex    CMatrixLUDet(CMatrixComplex &a,int &pivots[]);
   static complex    CMatrixDet(CMatrixComplex &a,const int n);
   static complex    CMatrixDet(CMatrixComplex &a);
   static double     SPDMatrixCholeskyDet(CMatrixDouble &a,const int n);
   static double     SPDMatrixCholeskyDet(CMatrixDouble &a);
   static double     SPDMatrixDet(CMatrixDouble &a,const int n,const bool IsUpper);
   static double     SPDMatrixDet(CMatrixDouble &a);
   //--- generalized symmetric positive definite eigenproblem
   static bool       SMatrixGEVD(CMatrixDouble &a,const int n,const bool isuppera,CMatrixDouble &b,const bool isupperb,const int zneeded,const int problemtype,double &d[],CMatrixDouble &z);
   static bool       SMatrixGEVDReduce(CMatrixDouble &a,const int n,const bool isuppera,CMatrixDouble &b,const bool isupperb,const int problemtype,CMatrixDouble &r,bool &isupperr);
   //--- update of the inverse matrix by the Sherman-Morrison formula
   static void       RMatrixInvUpdateSimple(CMatrixDouble &inva,const int n,const int updrow,const int updcolumn,const double updval);
   static void       RMatrixInvUpdateRow(CMatrixDouble &inva,const int n,const int updrow,double &v[]);
   static void       RMatrixInvUpdateColumn(CMatrixDouble &inva,const int n,const int updcolumn,double &u[]);
   static void       RMatrixInvUpdateUV(CMatrixDouble &inva,const int n,double &u[],double &v[]);
   //--- Schur decomposition
   static bool       RMatrixSchur(CMatrixDouble &a,const int n,CMatrixDouble &s);
   //--- functions of package optimization
   //--- conjugate gradient method
   static void       MinCGCreate(const int n,double &x[],CMinCGStateShell &state);
   static void       MinCGCreate(double &x[],CMinCGStateShell &state);
   static void       MinCGCreateF(const int n,double &x[],double diffstep,CMinCGStateShell &state);
   static void       MinCGCreateF(double &x[],double diffstep,CMinCGStateShell &state);
   static void       MinCGSetCond(CMinCGStateShell &state,double epsg,double epsf,double epsx,int maxits);
   static void       MinCGSetScale(CMinCGStateShell &state,double &s[]);
   static void       MinCGSetXRep(CMinCGStateShell &state,bool needxrep);
   static void       MinCGSetCGType(CMinCGStateShell &state,int cgtype);
   static void       MinCGSetStpMax(CMinCGStateShell &state,double stpmax);
   static void       MinCGSuggestStep(CMinCGStateShell &state,double stp);
   static void       MinCGSetPrecDefault(CMinCGStateShell &state);
   static void       MinCGSetPrecDiag(CMinCGStateShell &state,double &d[]);
   static void       MinCGSetPrecScale(CMinCGStateShell &state);
   static bool       MinCGIteration(CMinCGStateShell &state);
   static void       MinCGOptimize(CMinCGStateShell &state,CNDimensional_Func &func,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinCGOptimize(CMinCGStateShell &state,CNDimensional_Grad &grad,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinCGResults(CMinCGStateShell &state,double &x[],CMinCGReportShell &rep);
   static void       MinCGResultsBuf(CMinCGStateShell &state,double &x[],CMinCGReportShell &rep);
   static void       MinCGRestartFrom(CMinCGStateShell &state,double &x[]);
   static void       MinLBFGSRequestTermination(CMinLBFGSStateShell &state);
   //--- bound constrained optimization with additional linear equality and inequality constraints
   static void       MinBLEICCreate(const int n,double &x[],CMinBLEICStateShell &state);
   static void       MinBLEICCreate(double &x[],CMinBLEICStateShell &state);
   static void       MinBLEICCreateF(const int n,double &x[],double diffstep,CMinBLEICStateShell &state);
   static void       MinBLEICCreateF(double &x[],double diffstep,CMinBLEICStateShell &state);
   static void       MinBLEICSetBC(CMinBLEICStateShell &state,double &bndl[],double &bndu[]);
   static void       MinBLEICSetLC(CMinBLEICStateShell &state,CMatrixDouble &c,int &ct[],const int k);
   static void       MinBLEICSetLC(CMinBLEICStateShell &state,CMatrixDouble &c,int &ct[]);
   static void       MinBLEICSetInnerCond(CMinBLEICStateShell &state,const double epsg,const double epsf,const double epsx);
   static void       MinBLEICSetOuterCond(CMinBLEICStateShell &state,const double epsx,const double epsi);
   static void       MinBLEICSetScale(CMinBLEICStateShell &state,double &s[]);
   static void       MinBLEICSetPrecDefault(CMinBLEICStateShell &state);
   static void       MinBLEICSetPrecDiag(CMinBLEICStateShell &state,double &d[]);
   static void       MinBLEICSetPrecScale(CMinBLEICStateShell &state);
   static void       MinBLEICSetMaxIts(CMinBLEICStateShell &state,const int maxits);
   static void       MinBLEICSetXRep(CMinBLEICStateShell &state,bool needxrep);
   static void       MinBLEICSetStpMax(CMinBLEICStateShell &state,double stpmax);
   static bool       MinBLEICIteration(CMinBLEICStateShell &state);
   static void       MinBLEICOptimize(CMinBLEICStateShell &state,CNDimensional_Func &func,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinBLEICOptimize(CMinBLEICStateShell &state,CNDimensional_Grad &grad,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinBLEICOptGuardGradient(CMinBLEICStateShell &state,double teststep);
   static void       MinBLEICOptGuardSmoothness(CMinBLEICStateShell &state,int level=1);
   static void       MinBLEICOptGuardResults(CMinBLEICStateShell &state,COptGuardReport &rep);
   static void       MinBLEICOptGuardNonC1Test0Results(CMinBLEICStateShell &state,COptGuardNonC1Test0Report &strrep,COptGuardNonC1Test0Report &lngrep);
   static void       MinBLEICOptGuardNonC1Test1Results(CMinBLEICStateShell &state,COptGuardNonC1Test1Report &strrep,COptGuardNonC1Test1Report &lngrep);
   static void       MinBLEICResults(CMinBLEICStateShell &state,double &x[],CMinBLEICReportShell &rep);
   static void       MinBLEICResultsBuf(CMinBLEICStateShell &state,double &x[],CMinBLEICReportShell &rep);
   static void       MinBLEICRestartFrom(CMinBLEICStateShell &state,double &x[]);
   static void       MinBLEICRequestTermination(CMinBLEICStateShell &state);
   //--- limited memory BFGS method for large scale optimization
   static void       MinLBFGSCreate(const int n,const int m,double &x[],CMinLBFGSStateShell &state);
   static void       MinLBFGSCreate(const int m,double &x[],CMinLBFGSStateShell &state);
   static void       MinLBFGSCreateF(const int n,const int m,double &x[],const double diffstep,CMinLBFGSStateShell &state);
   static void       MinLBFGSCreateF(const int m,double &x[],const double diffstep,CMinLBFGSStateShell &state);
   static void       MinLBFGSSetCond(CMinLBFGSStateShell &state,const double epsg,const double epsf,const double epsx,const int maxits);
   static void       MinLBFGSSetXRep(CMinLBFGSStateShell &state,const bool needxrep);
   static void       MinLBFGSSetStpMax(CMinLBFGSStateShell &state,const double stpmax);
   static void       MinLBFGSSetScale(CMinLBFGSStateShell &state,double &s[]);
   static void       MinLBFGSSetPrecDefault(CMinLBFGSStateShell &state);
   static void       MinLBFGSSetPrecCholesky(CMinLBFGSStateShell &state,CMatrixDouble &p,const bool IsUpper);
   static void       MinLBFGSSetPrecDiag(CMinLBFGSStateShell &state,double &d[]);
   static void       MinLBFGSSetPrecScale(CMinLBFGSStateShell &state);
   static bool       MinLBFGSIteration(CMinLBFGSStateShell &state);
   static void       MinLBFGSOptimize(CMinLBFGSStateShell &state,CNDimensional_Func &func,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinLBFGSOptimize(CMinLBFGSStateShell &state,CNDimensional_Grad &grad,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinLBFGSResults(CMinLBFGSStateShell &state,double &x[],CMinLBFGSReportShell &rep);
   static void       MinLBFGSresultsbuf(CMinLBFGSStateShell &state,double &x[],CMinLBFGSReportShell &rep);
   static void       MinLBFGSRestartFrom(CMinLBFGSStateShell &state,double &x[]);
   //--- constrained quadratic programming
   static void       MinQPCreate(const int n,CMinQPStateShell &state);
   static void       MinQPSetLinearTerm(CMinQPStateShell &state,double &b[]);
   static void       MinQPSetQuadraticTerm(CMinQPStateShell &state,CMatrixDouble &a,const bool IsUpper);
   static void       MinQPSetQuadraticTerm(CMinQPStateShell &state,CMatrixDouble &a);
   static void       MinQPSetQuadraticTermSparse(CMinQPStateShell &state,CSparseMatrix &a,bool IsUpper);
   static void       MinQPSetStartingPoint(CMinQPStateShell &state,double &x[]);
   static void       MinQPSetOrigin(CMinQPStateShell &state,double &xorigin[]);
   static void       MinQPSetScale(CMinQPStateShell &state,CRowDouble &s);
   static void       MinQPSetScaleAutoDiag(CMinQPStateShell &state);
   static void       MinQPSetAlgoBLEIC(CMinQPStateShell &state,double epsg,double epsf,double epsx,int maxits);
   static void       MinQPSetAlgoDenseAUL(CMinQPStateShell &state,double epsx,double rho,int itscnt);
   static void       MinQPSetAlgoDenseIPM(CMinQPStateShell &state,double eps);
   static void       MinQPSetAlgoSparseIPM(CMinQPStateShell &state,double eps);
   static void       MinQPSetAlgoQuickQP(CMinQPStateShell &state,double epsg,double epsf,double epsx,int maxouterits,bool usenewton);
   static void       MinQPSetBCAll(CMinQPStateShell &state,double bndl,double bndu);
   static void       MinQPSetAlgoCholesky(CMinQPStateShell &state);
   static void       MinQPSetBC(CMinQPStateShell &state,double &bndl[],double &bndu[]);
   static void       MinQPSetBCI(CMinQPStateShell &state,int i,double bndl,double bndu);
   static void       MinQPSetLC(CMinQPStateShell &state,CMatrixDouble &c,CRowInt &ct,int k);
   static void       MinQPSetLC(CMinQPStateShell &state,CMatrixDouble &c,CRowInt &ct);
   static void       MinQPSetLCSparse(CMinQPStateShell &state,CSparseMatrix &c,CRowInt &ct,int k);
   static void       MinQPSetLCMixed(CMinQPStateShell &state,CSparseMatrix &sparsec,CRowInt &sparsect,int sparsek,CMatrixDouble &densec,CRowInt &densect,int densek);
   static void       MinQPSetLCMixedLegacy(CMinQPStateShell &state,CMatrixDouble &densec,CRowInt &densect,int densek,CSparseMatrix &sparsec,CRowInt &sparsect,int sparsek);
   static void       MinQPSetLC2Dense(CMinQPStateShell &state,CMatrixDouble &a,CRowDouble &al,CRowDouble &au,int k);
   static void       MinQPSetLC2Dense(CMinQPStateShell &state,CMatrixDouble &a,CRowDouble &al,CRowDouble &au);
   static void       MinQPSetLC2(CMinQPStateShell &state,CSparseMatrix &a,CRowDouble &al,CRowDouble &au,int k);
   static void       MinQPSetLC2Mixed(CMinQPStateShell &state,CSparseMatrix &sparsea,int ksparse,CMatrixDouble &densea,int kdense,CRowDouble &al,CRowDouble &au);
   static void       MinQPAddLC2Dense(CMinQPStateShell &state,CRowDouble &a,double al,double au);
   static void       MinQPAddLC2(CMinQPStateShell &state,CRowInt &idxa,CRowDouble &vala,int nnz,double al,double au);
   static void       MinQPAddLC2SparseFromDense(CMinQPStateShell &state,CRowDouble &da,double al,double au);
   static void       MinQPOptimize(CMinQPStateShell &state);
   static void       MinQPResults(CMinQPStateShell &state,double &x[],CMinQPReportShell &rep);
   static void       MinQPResultsBuf(CMinQPStateShell &state,double &x[],CMinQPReportShell &rep);
   //--- Levenberg-Marquardt method
   static void       MinLMCreateVJ(const int n,const int m,double &x[],CMinLMStateShell &state);
   static void       MinLMCreateVJ(const int m,double &x[],CMinLMStateShell &state);
   static void       MinLMCreateV(const int n,const int m,double &x[],double diffstep,CMinLMStateShell &state);
   static void       MinLMCreateV(const int m,double &x[],const double diffstep,CMinLMStateShell &state);
   static void       MinLMCreateFGH(const int n,double &x[],CMinLMStateShell &state);
   static void       MinLMCreateFGH(double &x[],CMinLMStateShell &state);
   static void       MinLMSetCond(CMinLMStateShell &state,const double epsx,const int maxits);
   static void       MinLMSetXRep(CMinLMStateShell &state,const bool needxrep);
   static void       MinLMSetStpMax(CMinLMStateShell &state,const double stpmax);
   static void       MinLMSetScale(CMinLMStateShell &state,double &s[]);
   static void       MinLMSetBC(CMinLMStateShell &state,double &bndl[],double &bndu[]);
   static void       MinLMSetAccType(CMinLMStateShell &state,const int acctype);
   static bool       MinLMIteration(CMinLMStateShell &state);
   static void       MinLMOptimize(CMinLMStateShell &state,CNDimensional_FVec &fvec,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinLMOptimize(CMinLMStateShell &state,CNDimensional_FVec &fvec,CNDimensional_Jac &jac,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinLMOptimize(CMinLMStateShell &state,CNDimensional_Func &func,CNDimensional_Grad &grad,CNDimensional_Hess &hess,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinLMOptimize(CMinLMStateShell &state,CNDimensional_Func &func,CNDimensional_Jac &jac,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinLMOptimize(CMinLMStateShell &state,CNDimensional_Func &func,CNDimensional_Grad &grad,CNDimensional_Jac &jac,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinLMResults(CMinLMStateShell &state,double &x[],CMinLMReportShell &rep);
   static void       MinLMResultsBuf(CMinLMStateShell &state,double &x[],CMinLMReportShell &rep);
   static void       MinLMRestartFrom(CMinLMStateShell &state,double &x[]);
   static void       MinLMCreateVGJ(const int n,const int m,double &x[],CMinLMStateShell &state);
   static void       MinLMCreateVGJ(const int m,double &x[],CMinLMStateShell &state);
   static void       MinLMCreateFGJ(const int n,const int m,double &x[],CMinLMStateShell &state);
   static void       MinLMCreateFGJ(const int m,double &x[],CMinLMStateShell &state);
   static void       MinLMCreateFJ(const int n,const int m,double &x[],CMinLMStateShell &state);
   static void       MinLMCreateFJ(const int m,double &x[],CMinLMStateShell &state);
   //--- linear programming
   static void       MinLPCreate(int n,CMinLPState &state);
   static void       MinLPSetAlgoDSS(CMinLPState &state,double eps);
   static void       MinLPSetAlgoIPM(CMinLPState &state,double eps=0);
   static void       MinLPSetCost(CMinLPState &state,CRowDouble &c);
   static void       MinLPSetScale(CMinLPState &state,CRowDouble &s);
   static void       MinLPSetBC(CMinLPState &state,CRowDouble &bndl,CRowDouble &bndu);
   static void       MinLPSetBCAll(CMinLPState &state,double bndl,double bndu);
   static void       MinLPSetBCi(CMinLPState &state,int i,double bndl,double bndu);
   static void       MinLPSetLC(CMinLPState &state,CMatrixDouble &a,CRowInt &ct,int k);
   static void       MinLPSetLC(CMinLPState &state,CMatrixDouble &a,CRowInt &ct);
   static void       MinLPSetLC2Dense(CMinLPState &state,CMatrixDouble &a,CRowDouble &al,CRowDouble &au,int k);
   static void       MinLPSetLC2Dense(CMinLPState &state,CMatrixDouble &a,CRowDouble &al,CRowDouble &au);
   static void       MinLPSetLC2(CMinLPState &state,CSparseMatrix &a,CRowDouble &al,CRowDouble &au,int k);
   static void       MinLPAddLC2Dense(CMinLPState &state,CRowDouble &a,double al,double au);
   static void       MinLPAddLC2(CMinLPState &state,CRowInt &idxa,CRowDouble &vala,int nnz,double al,double au);
   static void       MinLPOptimize(CMinLPState &state);
   static void       MinLPResults(CMinLPState &state,CRowDouble &x,CMinLPReport &rep);
   static void       MinLPResultsBuf(CMinLPState &state,CRowDouble &x,CMinLPReport &rep);
   //--- non-linear  constrained optimization
   static void       MinNLCCreate(int n,CRowDouble &x,CMinNLCState &state);
   static void       MinNLCCreate(CRowDouble &x,CMinNLCState &state);
   static void       MinNLCCreateF(int n,CRowDouble &x,double diffstep,CMinNLCState &state);
   static void       MinNLCCreateF(CRowDouble &x,double diffstep,CMinNLCState &state);
   static void       MinNLCSetBC(CMinNLCState &state,CRowDouble &bndl,CRowDouble &bndu);
   static void       MinNLCSetLC(CMinNLCState &state,CMatrixDouble &c,CRowInt &ct,int k);
   static void       MinNLCSetLC(CMinNLCState &state,CMatrixDouble &c,CRowInt &ct);
   static void       MinNLCSetNLC(CMinNLCState &state,int nlec,int nlic);
   static void       MinNLCSetCond(CMinNLCState &state,double epsx,int maxits);
   static void       MinNLCSetScale(CMinNLCState &state,CRowDouble &s);
   static void       MinNLCSetPrecInexact(CMinNLCState &state);
   static void       MinNLCSetPrecExactLowRank(CMinNLCState &state,int updatefreq);
   static void       MinNLCSetPrecExactRobust(CMinNLCState &state,int updatefreq);
   static void       MinNLCSetPrecNone(CMinNLCState &state);
   static void       MinNLCSetSTPMax(CMinNLCState &state,double stpmax);
   static void       MinNLCSetAlgoAUL(CMinNLCState &state,double rho,int itscnt);
   static void       MinNLCSetAlgoSLP(CMinNLCState &state);
   static void       MinNLCSetAlgoSQP(CMinNLCState &state);
   static void       MinNLCSetXRep(CMinNLCState &state,bool needxrep);
   static bool       MinNLCIteration(CMinNLCState &state);
   static void       MinNLCOptimize(CMinNLCState &state,CNDimensional_FVec &fvec,CNDimensional_Rep &rep,CObject &obj);
   static void       MinNLCOptimize(CMinNLCState &state,CNDimensional_Jac &jac,CNDimensional_Rep &rep,CObject &obj);
   static void       MinNLCOptGuardGradient(CMinNLCState &state,double teststep);
   static void       MinNLCOptGuardSmoothness(CMinNLCState &state,int level=1);
   static void       MinNLCOptGuardResults(CMinNLCState &state,COptGuardReport &rep);
   static void       MinNLCOptGuardNonC1Test0Results(CMinNLCState &state,COptGuardNonC1Test0Report &strrep,COptGuardNonC1Test0Report &lngrep);
   static void       MinNLCOptGuardNonC1Test1Results(CMinNLCState &state,COptGuardNonC1Test1Report &strrep,COptGuardNonC1Test1Report &lngrep);
   static void       MinNLCResults(CMinNLCState &state,CRowDouble &x,CMinNLCReport &rep);
   static void       MinNLCResultsBuf(CMinNLCState &state,CRowDouble &x,CMinNLCReport &rep);
   static void       MinNLCRequestTermination(CMinNLCState &state);
   static void       MinNLCRestartFrom(CMinNLCState &state,CRowDouble &x);
   //--- non-smooth non-convex optimization
   static void       MinNSCreate(int n,CRowDouble &x,CMinNSState &state);
   static void       MinNSCreate(CRowDouble &x,CMinNSState &state);
   static void       MinNSCreateF(int n,CRowDouble &x,double diffstep,CMinNSState &state);
   static void       MinNSCreateF(CRowDouble &x,double diffstep,CMinNSState &state);
   static void       MinNSSetBC(CMinNSState &state,CRowDouble &bndl,CRowDouble &bndu);
   static void       MinNSSetLC(CMinNSState &state,CMatrixDouble &c,CRowInt &ct,int k);
   static void       MinNSSetLC(CMinNSState &state,CMatrixDouble &c,CRowInt &ct);
   static void       MinNSSetNLC(CMinNSState &state,int nlec,int nlic);
   static void       MinNSSetCond(CMinNSState &state,double epsx,int maxits);
   static void       MinNSSetScale(CMinNSState &state,CRowDouble &s);
   static void       MinNSSetAlgoAGS(CMinNSState &state,double radius,double penalty);
   static void       MinNSSetXRep(CMinNSState &state,bool needxrep);
   static void       MinNSRequestTermination(CMinNSState &state);
   static bool       MinNSIteration(CMinNSState &state);
   static void       MinNSOptimize(CMinNSState &state,CNDimensional_FVec &fvec,CNDimensional_Rep &rep,CObject &obj);
   static void       MinNSOptimize(CMinNSState &state,CNDimensional_Jac &jac,CNDimensional_Rep &rep,CObject &obj);
   static void       MinNSResults(CMinNSState &state,CRowDouble &x,CMinNSReport &rep);
   static void       MinNSResultsBuf(CMinNSState &state,CRowDouble &x,CMinNSReport &rep);
   static void       MinNSRestartFrom(CMinNSState &state,CRowDouble &x);
   //---box constrained optimization
   static void       MinBCCreate(int n,CRowDouble &x,CMinBCState &state);
   static void       MinBCCreate(CRowDouble &x,CMinBCState &state);
   static void       MinBCCreateF(int n,CRowDouble &x,double diffstep,CMinBCState &state);
   static void       MinBCCreateF(CRowDouble &x,double diffstep,CMinBCState &state);
   static void       MinBCSetBC(CMinBCState &state,CRowDouble &bndl,CRowDouble &bndu);
   static void       MinBCSetCond(CMinBCState &state,double epsg,double epsf,double epsx,int maxits);
   static void       MinBCSetScale(CMinBCState &state,CRowDouble &s);
   static void       MinBCSetPrecDefault(CMinBCState &state);
   static void       MinBCSetPrecDiag(CMinBCState &state,CRowDouble &d);
   static void       MinBCSetPrecScale(CMinBCState &state);
   static void       MinBCSetXRep(CMinBCState &state,bool needxrep);
   static void       MinBCSetStpMax(CMinBCState &state,double stpmax);
   static bool       MinBCIteration(CMinBCState &state);
   static void       MinBCOptimize(CMinBCState &state,CNDimensional_Func &func,CNDimensional_Rep &rep,CObject &obj);
   static void       MinBCOptimize(CMinBCState &state,CNDimensional_Grad &grad,CNDimensional_Rep &rep,CObject &obj);
   static void       MinBCOptGuardGradient(CMinBCState &state,double teststep);
   static void       MinBCOptGuardSmoothness(CMinBCState &state,int level=1);
   static void       MinBCOptGuardResults(CMinBCState &state,COptGuardReport &rep);
   static void       MinBCOptGuardNonC1Test0Results(CMinBCState &state,COptGuardNonC1Test0Report &strrep,COptGuardNonC1Test0Report &lngrep);
   static void       MinBCOptGuardNonC1Test1Results(CMinBCState &state,COptGuardNonC1Test1Report &strrep,COptGuardNonC1Test1Report &lngrep);
   static void       MinBCResults(CMinBCState &state,CRowDouble &x,CMinBCReport &rep);
   static void       MinBCResultsBuf(CMinBCState &state,CRowDouble &x,CMinBCReport &rep);
   static void       MinBCRestartFrom(CMinBCState &state,CRowDouble &x);
   static void       MinBCRequestTermination(CMinBCState &state);
   //--- optimization
   static void       MinLBFGSSetDefaultPreconditioner(CMinLBFGSStateShell &state);
   static void       MinLBFGSSetCholeskyPreconditioner(CMinLBFGSStateShell &state,CMatrixDouble &p,bool IsUpper);
   static void       MinBLEICSetBarrierWidth(CMinBLEICStateShell &state,const double mu);
   static void       MinBLEICSetBarrierDecay(CMinBLEICStateShell &state,const double mudecay);
   static void       MinASACreate(const int n,double &x[],double &bndl[],double &bndu[],CMinASAStateShell &state);
   static void       MinASACreate(double &x[],double &bndl[],double &bndu[],CMinASAStateShell &state);
   static void       MinASASetCond(CMinASAStateShell &state,const double epsg,const double epsf,const double epsx,const int maxits);
   static void       MinASASetXRep(CMinASAStateShell &state,const bool needxrep);
   static void       MinASASetAlgorithm(CMinASAStateShell &state,const int algotype);
   static void       MinASASetStpMax(CMinASAStateShell &state,const double stpmax);
   static bool       MinASAIteration(CMinASAStateShell &state);
   static void       MinASAOptimize(CMinASAStateShell &state,CNDimensional_Grad &grad,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       MinASAResults(CMinASAStateShell &state,double &x[],CMinASAReportShell &rep);
   static void       MinASAResultsBuf(CMinASAStateShell &state,double &x[],CMinASAReportShell &rep);
   static void       MinASARestartFrom(CMinASAStateShell &state,double &x[],double &bndl[],double &bndu[]);
   //--- functions of package solvers
   //--- polynomial root finding
   static void       PolynomialSolve(CRowDouble &a,int n,CRowComplex &x,CPolynomialSolverReport &rep);
   //--- dense solver
   static void       RMatrixSolve(CMatrixDouble &a,const int n,double &b[],int &info,CDenseSolverReportShell &rep,double &x[]);
   static void       RMatrixSolveM(CMatrixDouble &a,const int n,CMatrixDouble &b,const int m,const bool rfs,int &info,CDenseSolverReportShell &rep,CMatrixDouble &x);
   static void       RMatrixLUSolve(CMatrixDouble &lua,int &p[],const int n,double &b[],int &info,CDenseSolverReportShell &rep,double &x[]);
   static void       RMatrixLUSolveM(CMatrixDouble &lua,int &p[],const int n,CMatrixDouble &b,const int m,int &info,CDenseSolverReportShell &rep,CMatrixDouble &x);
   static void       RMatrixMixedSolve(CMatrixDouble &a,CMatrixDouble &lua,int &p[],const int n,double &b[],int &info,CDenseSolverReportShell &rep,double &x[]);
   static void       RMatrixMixedSolveM(CMatrixDouble &a,CMatrixDouble &lua,int &p[],const int n,CMatrixDouble &b,const int m,int &info,CDenseSolverReportShell &rep,CMatrixDouble &x);
   static void       CMatrixSolveM(CMatrixComplex &a,const int n,CMatrixComplex &b,const int m,const bool rfs,int &info,CDenseSolverReportShell &rep,CMatrixComplex &x);
   static void       CMatrixSolve(CMatrixComplex &a,const int n,complex &b[],int &info,CDenseSolverReportShell &rep,complex &x[]);
   static void       CMatrixLUSolveM(CMatrixComplex &lua,int &p[],const int n,CMatrixComplex &b,const int m,int &info,CDenseSolverReportShell &rep,CMatrixComplex &x);
   static void       CMatrixLUSolve(CMatrixComplex &lua,int &p[],const int n,complex &b[],int &info,CDenseSolverReportShell &rep,complex &x[]);
   static void       CMatrixMixedSolveM(CMatrixComplex &a,CMatrixComplex &lua,int &p[],const int n,CMatrixComplex &b,const int m,int &info,CDenseSolverReportShell &rep,CMatrixComplex &x);
   static void       CMatrixMixedSolve(CMatrixComplex &a,CMatrixComplex &lua,int &p[],const int n,complex &b[],int &info,CDenseSolverReportShell &rep,complex &x[]);
   static void       SPDMatrixSolveM(CMatrixDouble &a,const int n,const bool IsUpper,CMatrixDouble &b,const int m,int &info,CDenseSolverReportShell &rep,CMatrixDouble &x);
   static void       SPDMatrixSolve(CMatrixDouble &a,const int n,const bool IsUpper,double &b[],int &info,CDenseSolverReportShell &rep,double &x[]);
   static void       SPDMatrixCholeskySolveM(CMatrixDouble &cha,const int n,const bool IsUpper,CMatrixDouble &b,const int m,int &info,CDenseSolverReportShell &rep,CMatrixDouble &x);
   static void       SPDMatrixCholeskySolve(CMatrixDouble &cha,const int n,const bool IsUpper,double &b[],int &info,CDenseSolverReportShell &rep,double &x[]);
   static void       HPDMatrixSolveM(CMatrixComplex &a,const int n,const bool IsUpper,CMatrixComplex &b,const int m,int &info,CDenseSolverReportShell &rep,CMatrixComplex &x);
   static void       HPDMatrixSolve(CMatrixComplex &a,const int n,const bool IsUpper,complex &b[],int &info,CDenseSolverReportShell &rep,complex &x[]);
   static void       HPDMatrixCholeskySolveM(CMatrixComplex &cha,const int n,const bool IsUpper,CMatrixComplex &b,const int m,int &info,CDenseSolverReportShell &rep,CMatrixComplex &x);
   static void       HPDMatrixCholeskySolve(CMatrixComplex &cha,const int n,const bool IsUpper,complex &b[],int &info,CDenseSolverReportShell &rep,complex &x[]);
   static void       RMatrixSolveLS(CMatrixDouble &a,const int nrows,const int ncols,double &b[],const double threshold,int &info,CDenseSolverLSReportShell &rep,double &x[]);
   //--- sparse linear solver
   static void       SparseSPDSolveSKS(CSparseMatrix &a,bool IsUpper,CRowDouble &b,CRowDouble &x,CSparseSolverReport &rep);
   static void       SparseSPDSolve(CSparseMatrix &a,bool IsUpper,CRowDouble &b,CRowDouble &x,CSparseSolverReport &rep);
   static void       SparseSPDCholeskySolve(CSparseMatrix &a,bool IsUpper,CRowDouble &b,CRowDouble &x,CSparseSolverReport &rep);
   static void       SparseSolve(CSparseMatrix &a,CRowDouble &b,CRowDouble &x,CSparseSolverReport &rep);
   static void       SparseLUSolve(CSparseMatrix &a,CRowInt &p,CRowInt &q,CRowDouble &b,CRowDouble &x,CSparseSolverReport &rep);
   //--- sparse symmetric linear solver
   static void       SparseSolveSymmetricGMRES(CSparseMatrix &a,bool IsUpper,CRowDouble &b,int k,double epsf,int maxits,CRowDouble &x,CSparseSolverReport &rep);
   static void       SparseSolveGMRES(CSparseMatrix &a,CRowDouble &b,int k,double epsf,int maxits,CRowDouble &x,CSparseSolverReport &rep);
   static void       SparseSolverCreate(int n,CSparseSolverState &state);
   static void       SparseSolverSetAlgoGMRES(CSparseSolverState &state,int k);
   static void       SparseSolverSetStartingPoint(CSparseSolverState &state,CRowDouble &x);
   static void       SparseSolverSetCond(CSparseSolverState &state,double epsf,int maxits);
   static void       SparseSolverSolveSymmetric(CSparseSolverState &state,CSparseMatrix &a,bool IsUpper,CRowDouble &b);
   static void       SparseSolverSolve(CSparseSolverState &state,CSparseMatrix &a,CRowDouble &b);
   static void       SparseSolverResults(CSparseSolverState &state,CRowDouble &x,CSparseSolverReport &rep);
   static void       SparseSolverSetXRep(CSparseSolverState &state,bool needxrep);
   static void       SparseSolverOOCStart(CSparseSolverState &state,CRowDouble &b);
   static bool       SparseSolverOOCContinue(CSparseSolverState &state);
   static void       SparseSolverOOCGetRequestInfo(CSparseSolverState &state,int &requesttype);
   static void       SparseSolverOOCGetRequestData(CSparseSolverState &state,CRowDouble &x);
   static void       SparseSolverOOCGetRequestData1(CSparseSolverState &state,double &v);
   static void       SparseSolverOOCSendResult(CSparseSolverState &state,CRowDouble &ax);
   static void       SparseSolverOOCStop(CSparseSolverState &state,CRowDouble &x,CSparseSolverReport &rep);
   static void       SparseSolverRequestTermination(CSparseSolverState &state);
   //--- linear CG Solver
   static void       LinCGCreate(int n,CLinCGState &state);
   static void       LinCGSetStartingPoint(CLinCGState &state,CRowDouble &x);
   static void       LinCGSetPrecUnit(CLinCGState &state);
   static void       LinCGSetPrecDiag(CLinCGState &state);
   static void       LinCGSetCond(CLinCGState &state,double epsf,int maxits);
   static void       LinCGSolveSparse(CLinCGState &state,CSparseMatrix &a,bool IsUpper,CRowDouble &b);
   static void       LinCGResult(CLinCGState &state,CRowDouble &x,CLinCGReport &rep);
   static void       LinCGSetRestartFreq(CLinCGState &state,int srf);
   static void       LinCGSetRUpdateFreq(CLinCGState &state,int freq);
   static void       LinCGSetXRep(CLinCGState &state,bool needxrep);
   //--- linear LSQR Solver
   static void       LinLSQRCreate(int m,int n,CLinLSQRState &state);
   static void       LinLSQRCreateBuf(int m,int n,CLinLSQRState &state);
   static void       LinLSQRSetPrecUnit(CLinLSQRState &state);
   static void       LinLSQRSetPrecDiag(CLinLSQRState &state);
   static void       LinLSQRSetLambdaI(CLinLSQRState &state,double lambdai);
   static void       LinLSQRSolveSparse(CLinLSQRState &state,CSparseMatrix &a,CRowDouble &b);
   static void       LinLSQRSetCond(CLinLSQRState &state,double epsa,double epsb,int maxits);
   static void       LinLSQRResults(CLinLSQRState &state,CRowDouble &x,CLinLSQRReport &rep);
   static void       LinLSQRSetXRep(CLinLSQRState &state,bool needxrep);
   static int        LinLSQRPeekIterationsCount(CLinLSQRState &s);
   static void       LinLSQRRequestTermination(CLinLSQRState &state);
   //--- solving systems of nonlinear equations
   static void       NlEqCreateLM(const int n,const int m,double &x[],CNlEqStateShell &state);
   static void       NlEqCreateLM(const int m,double &x[],CNlEqStateShell &state);
   static void       NlEqSetCond(CNlEqStateShell &state,const double epsf,const int maxits);
   static void       NlEqSetXRep(CNlEqStateShell &state,const bool needxrep);
   static void       NlEqSetStpMax(CNlEqStateShell &state,const double stpmax);
   static bool       NlEqIteration(CNlEqStateShell &state);
   static void       NlEqSolve(CNlEqStateShell &state,CNDimensional_Func &func,CNDimensional_Jac &jac,CNDimensional_Rep &rep,bool rep_status,CObject &obj);
   static void       NlEqResults(CNlEqStateShell &state,double &x[],CNlEqReportShell &rep);
   static void       NlEqResultsBuf(CNlEqStateShell &state,double &x[],CNlEqReportShell &rep);
   static void       NlEqRestartFrom(CNlEqStateShell &state,double &x[]);
   //--- functions of package specialfunctions
   //--- gamma function
   static double     GammaFunction(const double x);
   static double     LnGamma(const double x,double &sgngam);
   //--- normal distribution
   static double     ErrorFunction(const double x);
   static double     ErrorFunctionC(const double x);
   static double     NormalDistribution(const double x);
   static double     NormalPDF(const double x);
   static double     NormalCDF(const double x);
   static double     InvErF(const double e);
   static double     InvNormalDistribution(double y0);
   static double     InvNormalCDF(const double y0);
   static double     BivariateNormalPDF(const double x,const double y,const double rho);
   static double     BivariateNormalCDF(double x,double y,const double rho);
   
   //--- incomplete gamma function
   static double     IncompleteGamma(const double a,const double x);
   static double     IncompleteGammaC(const double a,const double x);
   static double     InvIncompleteGammaC(const double a,const double y0);
   //--- airy function
   static void       Airy(const double x,double &ai,double &aip,double &bi,double &bip);
   //--- Bessel function
   static double     BesselJ0(const double x);
   static double     BesselJ1(const double x);
   static double     BesselJN(const int n,const double x);
   static double     BesselY0(const double x);
   static double     BesselY1(const double x);
   static double     BesselYN(const int n,const double x);
   static double     BesselI0(const double x);
   static double     BesselI1(const double x);
   static double     BesselK0(const double x);
   static double     BesselK1(const double x);
   static double     BesselKN(const int nn,const double x);
   //--- beta function
   static double     Beta(const double a,const double b);
   static double     IncompleteBeta(const double a,const double b,const double x);
   static double     InvIncompleteBeta(const double a,const double b,double y);
   //--- binomial distribution
   static double     BinomialDistribution(const int k,const int n,const double p);
   static double     BinomialComplDistribution(const int k,const int n,const double p);
   static double     InvBinomialDistribution(const int k,const int n,const double y);
   //--- Chebyshev polynom
   static double     ChebyshevCalculate(int r,const int n,const double x);
   static double     ChebyshevSum(double &c[],const int r,const int n,const double x);
   static void       ChebyshevCoefficients(const int n,double &c[]);
   static void       FromChebyshev(double &a[],const int n,double &b[]);
   //--- chi-square distribution
   static double     ChiSquareDistribution(const double v,const double x);
   static double     ChiSquareComplDistribution(const double v,const double x);
   static double     InvChiSquareDistribution(const double v,const double y);
   //--- Dawson's Integral
   static double     DawsonIntegral(const double x);
   //--- elliptic integral
   static double     EllipticIntegralK(const double m);
   static double     EllipticIntegralKhighPrecision(const double m1);
   static double     IncompleteEllipticIntegralK(const double phi,const double m);
   static double     EllipticIntegralE(const double m);
   static double     IncompleteEllipticIntegralE(const double phi,const double m);
   //--- exponential integral
   static double     ExponentialIntegralEi(const double x);
   static double     ExponentialIntegralEn(const double x,const int n);
   //--- F distribution functions
   static double     FDistribution(const int a,const int b,const double x);
   static double     FComplDistribution(const int a,const int b,const double x);
   static double     InvFDistribution(const int a,const int b,const double y);
   //--- Fresnel integral
   static void       FresnelIntegral(const double x,double &c,double &s);
   //--- Hermite polynomial
   static double     HermiteCalculate(const int n,const double x);
   static double     HermiteSum(double &c[],const int n,const double x);
   static void       HermiteCoefficients(const int n,double &c[]);
   //--- Jacobian elliptic functions
   static void       JacobianEllipticFunctions(const double u,const double m,double &sn,double &cn,double &dn,double &ph);
   //--- Laguerre polynomial
   static double     LaguerreCalculate(const int n,const double x);
   static double     LaguerreSum(double &c[],const int n,const double x);
   static void       LaguerreCoefficients(const int n,double &c[]);
   //--- Legendre polynomial
   static double     LegendreCalculate(const int n,const double x);
   static double     LegendreSum(double &c[],const int n,const double x);
   static void       LegendreCoefficients(const int n,double &c[]);
   //--- Poisson distribution
   static double     PoissonDistribution(const int k,const double m);
   static double     PoissonComplDistribution(const int k,const double m);
   static double     InvPoissonDistribution(const int k,const double y);
   //--- psi function
   static double     Psi(const double x);
   //--- Student's t distribution
   static double     StudenttDistribution(const int k,const double t);
   static double     InvStudenttDistribution(const int k,const double p);
   //--- trigonometric integrals
   static void       SineCosineIntegrals(const double x,double &si,double &ci);
   static void       HyperbolicSineCosineIntegrals(const double x,double &shi,double &chi);
   //--- functions of package statistics
   //--- basic statistics methods
   static void       SampleMoments(const double &x[],const int n,double &mean,double &variance,double &skewness,double &kurtosis);
   static void       SampleMoments(const double &x[],double &mean,double &variance,double &skewness,double &kurtosis);
   static double     SampleMean(CRowDouble &x,int n);
   static double     SampleMean(CRowDouble &x);
   static double     SampleVariance(CRowDouble &x,int n);
   static double     SampleVariance(CRowDouble &x);
   static double     SampleSkewness(CRowDouble &x,int n);
   static double     SampleSkewness(CRowDouble &x);
   static double     SampleKurtosis(CRowDouble &x,int n);
   static double     SampleKurtosis(CRowDouble &x);
   static void       SampleAdev(const double &x[],const int n,double &adev);
   static void       SampleAdev(const double &x[],double &adev);
   static void       SampleMedian(const double &x[],const int n,double &median);
   static void       SampleMedian(const double &x[],double &median);
   static void       SamplePercentile(const double &x[],const int n,const double p,double &v);
   static void       SamplePercentile(const double &x[],const double p,double &v);
   static double     Cov2(const double &x[],const double &y[],const int n);
   static double     Cov2(const double &x[],const double &y[]);
   static double     PearsonCorr2(const double &x[],const double &y[],const int n);
   static double     PearsonCorr2(const double &x[],const double &y[]);
   static double     SpearmanCorr2(const double &x[],const double &y[],const int n);
   static double     SpearmanCorr2(const double &x[],const double &y[]);
   static void       CovM(const CMatrixDouble &x,const int n,const int m,CMatrixDouble &c);
   static void       CovM(const CMatrixDouble &x,CMatrixDouble &c);
   static void       PearsonCorrM(const CMatrixDouble &x,const int n,const int m,CMatrixDouble &c);
   static void       PearsonCorrM(CMatrixDouble &x,CMatrixDouble &c);
   static void       SpearmanCorrM(const CMatrixDouble &x,const int n,const int m,CMatrixDouble &c);
   static void       SpearmanCorrM(const CMatrixDouble &x,CMatrixDouble &c);
   static void       CovM2(const CMatrixDouble &x,const CMatrixDouble &y,const int n,const int m1,const int m2,CMatrixDouble &c);
   static void       CovM2(const CMatrixDouble &x,const CMatrixDouble &y,CMatrixDouble &c);
   static void       PearsonCorrM2(const CMatrixDouble &x,const CMatrixDouble &y,const int n,const int m1,const int m2,CMatrixDouble &c);
   static void       PearsonCorrM2(const CMatrixDouble &x,const CMatrixDouble &y,CMatrixDouble &c);
   static void       SpearmanCorrM2(const CMatrixDouble &x,const CMatrixDouble &y,const int n,const int m1,const int m2,CMatrixDouble &c);
   static void       SpearmanCorrM2(const CMatrixDouble &x,const CMatrixDouble &y,CMatrixDouble &c);
   static void       RankData(CMatrixDouble &xy,int npoints,int nfeatures);
   static void       RankData(CMatrixDouble &xy);
   static void       RankDataCentered(CMatrixDouble &xy,int npoints,int nfeatures);
   static void       RankDataCentered(CMatrixDouble &xy);
   //--- correlation tests
   static void       PearsonCorrelationSignificance(const double r,const int n,double &bothTails,double &leftTail,double &rightTail);
   static void       SpearmanRankCorrelationSignificance(const double r,const int n,double &bothTails,double &leftTail,double &rightTail);
   //--- Jarque-Bera test
   static void       JarqueBeraTest(const double &x[],const int n,double &p);
   //--- Mann-Whitney U-test
   static void       MannWhitneyUTest(const double &x[],const int n,const double &y[],const int m,double &bothTails,double &leftTail,double &rightTail);
   //--- sign test
   static void       OneSampleSignTest(const double &x[],const int n,const double median,double &bothTails,double &leftTail,double &rightTail);
   //--- Student Tests
   static void       StudentTest1(const double &x[],const int n,const double mean,double &bothTails,double &leftTail,double &rightTail);
   static void       StudentTest2(const double &x[],const int n,const double &y[],const int m,double &bothTails,double &leftTail,double &rightTail);
   static void       UnequalVarianceTest(const double &x[],const int n,const double &y[],const int m,double &bothTails,double &leftTail,double &rightTail);
   //--- variance tests
   static void       FTest(const double &x[],const int n,const double &y[],const int m,double &bothTails,double &leftTail,double &rightTail);
   static void       OneSampleVarianceTest(double &x[],int n,double variance,double &bothTails,double &leftTail,double &rightTail);
   //--- Wilcoxon signed-rank test
   static void       WilcoxonSignedRankTest(const double &x[],const int n,const double e,double &bothTails,double &leftTail,double &rightTail);
  };
//+------------------------------------------------------------------+
//| HQRNDState initialization with random values which come from     |
//| standard RNG.                                                    |
//+------------------------------------------------------------------+
void CAlglib::HQRndRandomize(CHighQualityRandStateShell &state)
  {
   CHighQualityRand::HQRndRandomize(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| HQRNDState initialization with seed values                       |
//+------------------------------------------------------------------+
void CAlglib::HQRndSeed(const int s1,const int s2,CHighQualityRandStateShell &state)
  {
   CHighQualityRand::HQRndSeed(s1,s2,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function generates random real number in (0,1),             |
//| not including interval boundaries                                |
//| State structure must be initialized with HQRNDRandomize() or     |
//| HQRNDSeed().                                                     |
//+------------------------------------------------------------------+
double CAlglib::HQRndUniformR(CHighQualityRandStateShell &state)
  {
   return(CHighQualityRand::HQRndUniformR(state.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This function generates random integer number in [0, N)          |
//| 1. N must be less than HQRNDMax-1.                               |
//| 2. State structure must be initialized with HQRNDRandomize() or  |
//| HQRNDSeed()                                                      |
//+------------------------------------------------------------------+
int CAlglib::HQRndUniformI(CHighQualityRandStateShell &state,const int n)
  {
   return(CHighQualityRand::HQRndUniformI(state.GetInnerObj(),n));
  }
//+------------------------------------------------------------------+
//| Random number generator: normal numbers                          |
//| This function generates one random number from normal            |
//| distribution.                                                    |
//| Its performance is equal to that of HQRNDNormal2()               |
//| State structure must be initialized with HQRNDRandomize() or     |
//| HQRNDSeed().                                                     |
//+------------------------------------------------------------------+
double CAlglib::HQRndNormal(CHighQualityRandStateShell &state)
  {
   return(CHighQualityRand::HQRndNormal(state.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| Random number generator: vector with random entries (normal      |
//| distribution)                                                    |
//| This function generates N random numbers from normal             |
//| distribution.                                                    |
//| State structure must be initialized with HQRNDRandomize() or     |
//| HQRNDSeed().                                                     |
//+------------------------------------------------------------------+
void CAlglib::HQRndNormalV(CHighQualityRandStateShell &state,
                           int n,CRowDouble &x)
  {
   CHighQualityRand::HQRndNormalV(state.GetInnerObj(),n,x);
  }
//+------------------------------------------------------------------+
//| Random number generator: vector with random entries (normal      |
//| distribution)                                                    |
//| This function generates N random numbers from normal             |
//| distribution.                                                    |
//| State structure must be initialized with HQRNDRandomize() or     |
//| HQRNDSeed().                                                     |
//+------------------------------------------------------------------+
void CAlglib::HQRndNormalV(CHighQualityRandStateShell &state,
                           int n,vector<double> &x)
  {
   CRowDouble X=x;
   HQRndNormalV(state,n,X);
   x=X.ToVector();
  }
//+------------------------------------------------------------------+
//| Random number generator: matrix with random entries (normal      |
//| distribution)                                                    |
//| This function generates MxN random matrix.                       |
//| State structure must be initialized with HQRNDRandomize() or     |
//| HQRNDSeed().                                                     |
//+------------------------------------------------------------------+
void CAlglib::HQRndNormalM(CHighQualityRandStateShell &state,
                           int m,int n,CMatrixDouble &x)
  {
   CHighQualityRand::HQRndNormalM(state.GetInnerObj(),m,n,x);
  }
//+------------------------------------------------------------------+
//| Random number generator: matrix with random entries (normal      |
//| distribution)                                                    |
//| This function generates MxN random matrix.                       |
//| State structure must be initialized with HQRNDRandomize() or     |
//| HQRNDSeed().                                                     |
//+------------------------------------------------------------------+
void CAlglib::HQRndNormalM(CHighQualityRandStateShell &state,
                           int m,int n,matrix<double> &x)
  {
   CMatrixDouble X=x;
   HQRndNormalM(state,m,n,X);
   x=X.ToMatrix();
  }
//+------------------------------------------------------------------+
//| Random number generator: random X and Y such that X^2+Y^2=1      |
//| State structure must be initialized with HQRNDRandomize() or     |
//| HQRNDSeed().                                                     |
//+------------------------------------------------------------------+
void CAlglib::HQRndUnit2(CHighQualityRandStateShell &state,
                         double &x,double &y)
  {
//--- initialization
   x=0;
   y=0;
//--- function call
   CHighQualityRand::HQRndUnit2(state.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//| Random number generator: normal numbers                          |
//| This function generates two independent random numbers from      |
//| normal distribution. Its performance is equal to that of         |
//| HQRNDNormal()                                                    |
//| State structure must be initialized with HQRNDRandomize() or     |
//| HQRNDSeed().                                                     |
//+------------------------------------------------------------------+
void CAlglib::HQRndNormal2(CHighQualityRandStateShell &state,
                           double &x1,double &x2)
  {
//--- initialization
   x1=0;
   x2=0;
//--- function call
   CHighQualityRand::HQRndNormal2(state.GetInnerObj(),x1,x2);
  }
//+------------------------------------------------------------------+
//| Random number generator: exponential distribution                |
//| State structure must be initialized with HQRNDRandomize() or     |
//| HQRNDSeed().                                                     |
//+------------------------------------------------------------------+
double CAlglib::HQRndExponential(CHighQualityRandStateShell &state,
                                 const double lambdav)
  {
   return(CHighQualityRand::HQRndExponential(state.GetInnerObj(),lambdav));
  }
//+------------------------------------------------------------------+
//| This function generates  random number from discrete distribution|
//| given by finite sample X.                                        |
//| INPUT PARAMETERS                                                 |
//|   State   -   high quality random number generator, must be      |
//|               initialized with HQRNDRandomize() or HQRNDSeed().  |
//|   X   -   finite sample                                          |
//|   N   -   number of elements to use, N>=1                        |
//| RESULT                                                           |
//|   this function returns one of the X[i] for random i=0..N-1      |
//+------------------------------------------------------------------+
double CAlglib::HQRndDiscrete(CHighQualityRandStateShell &state,
                              int n,CRowDouble &x)
  {
   return(CHighQualityRand::HQRndDiscrete(state.GetInnerObj(),n,x));
  }
//+------------------------------------------------------------------+
//| This function generates  random number from discrete distribution|
//| given by finite sample X.                                        |
//| INPUT PARAMETERS                                                 |
//|   State   -   high quality random number generator, must be      |
//|               initialized with HQRNDRandomize() or HQRNDSeed().  |
//|   X   -   finite sample                                          |
//|   N   -   number of elements to use, N>=1                        |
//| RESULT                                                           |
//|   this function returns one of the X[i] for random i=0..N-1      |
//+------------------------------------------------------------------+
double CAlglib::HQRndDiscrete(CHighQualityRandStateShell &state,
                              int n,vector<double> &x)
  {
   return(CHighQualityRand::HQRndDiscrete(state.GetInnerObj(),n,x));
  }
//+------------------------------------------------------------------+
//| This function generates random number from continuous            |
//| distribution  given by finite sample X.                          |
//| INPUT PARAMETERS                                                 |
//|   State   -   high quality random number generator, must be      |
//|               initialized with HQRNDRandomize() or HQRNDSeed().  |
//|   X       -   finite sample, array[N] (can be larger, in this    |
//|               case only leading N elements are used). THIS ARRAY |
//|               MUST BE SORTED BY ASCENDING.                       |
//|   N       -   number of elements to use, N>=1                    |
//| RESULT                                                           |
//|   this function returns random number from continuous            |
//|   distribution which tries to approximate X as mush as possible. |
//|   min(X)<=Result<=max(X).                                        |
//+------------------------------------------------------------------+
double CAlglib::HQRndContinuous(CHighQualityRandStateShell &state,
                                int n,CRowDouble &x)
  {
   return(CHighQualityRand::HQRndContinuous(state.GetInnerObj(),n,x));
  }
//+------------------------------------------------------------------+
//| This function generates random number from continuous            |
//| distribution  given by finite sample X.                          |
//| INPUT PARAMETERS                                                 |
//|   State   -   high quality random number generator, must be      |
//|               initialized with HQRNDRandomize() or HQRNDSeed().  |
//|   X       -   finite sample, array[N] (can be larger, in this    |
//|               case only leading N elements are used). THIS ARRAY |
//|               MUST BE SORTED BY ASCENDING.                       |
//|   N       -   number of elements to use, N>=1                    |
//| RESULT                                                           |
//|   this function returns random number from continuous            |
//|   distribution which tries to approximate X as mush as possible. |
//|   min(X)<=Result<=max(X).                                        |
//+------------------------------------------------------------------+
double CAlglib::HQRndContinuous(CHighQualityRandStateShell &state,
                                int n,vector<double> &x)
  {
   return(CHighQualityRand::HQRndContinuous(state.GetInnerObj(),n,x));
  }
//+------------------------------------------------------------------+
//| This function serializes data structure to string.               |
//| Important properties of s_out:                                   |
//| * it contains alphanumeric characters, dots, underscores, minus  |
//|   signs                                                          |
//| * these symbols are grouped into words, which are separated by   |
//|   spaces and Windows-style (CR+LF) newlines                      |
//| * although serializer uses spaces and CR+LF as separators, you   |
//|   can replace any separator character by arbitrary combination   |
//|   of spaces, tabs, Windows or Unix newlines. It allows flexible  |
//|   reformatting of the string in case you want to include it into |
//|   text or XML file. But you should not insert separators into the|
//|   middle of the "words" nor you should change case of letters.   |
//| * s_out can be freely moved between 32-bit and 64-bit systems,   |
//|   little and big endian machines, and so on. You can reference   |
//|   structure on 32-bit machine and unserialize it on 64-bit one   |
//|   (or vice versa), or reference it on SPARC and unserialize on   |
//|   x86. You can also reference it in C# version of ALGLIB and     |
//|   unserialize in C++ one, and vice versa.                        |
//+------------------------------------------------------------------+
void CAlglib::KDTreeSerialize(CKDTreeShell &obj,string &s_out)
  {
//--- create a variable
   CSerializer s;
//--- serialization start
   s.Alloc_Start();
//--- function call
   CNearestNeighbor::KDTreeAlloc(s,obj.GetInnerObj());
   s.SStart_Str();
//--- function call
   CNearestNeighbor::KDTreeSerialize(s,obj.GetInnerObj());
   s.Stop();
//--- get result
   s_out=s.Get_String();
  }
//+------------------------------------------------------------------+
//| This function unserializes data structure from string.           |
//+------------------------------------------------------------------+
void CAlglib::KDTreeUnserialize(string s_in,CKDTreeShell &obj)
  {
//--- object of class
   CSerializer s;
   s.UStart_Str(s_in);
//--- function call
   CNearestNeighbor::KDTreeUnserialize(s,obj.GetInnerObj());
   s.Stop();
  }
//+------------------------------------------------------------------+
//| KD-tree creation                                                 |
//| This subroutine creates KD-tree from set of X-values and optional|
//| Y-values                                                         |
//| INPUT PARAMETERS                                                 |
//|     XY      -   dataset,array[0..N-1, 0..NX+NY-1].               |
//|                 one row corresponds to one point.                |
//|                 first NX columns contain X-values, next NY (NY   |
//|                 may be zero)                                     |
//|                 columns may contain associated Y-values          |
//|     N       -   number of points, N>=1                           |
//|     NX      -   space dimension, NX>=1.                          |
//|     NY      -   number of optional Y-values, NY>=0.              |
//|     NormType-   norm type:                                       |
//|                 * 0 denotes infinity-norm                        |
//|                 * 1 denotes 1-norm                               |
//|                 * 2 denotes 2-norm (Euclidean norm)              |
//| OUTPUT PARAMETERS                                                |
//|     KDT     -   KD-tree                                          |
//| NOTES                                                            |
//| 1. KD-tree  creation  have O(N*logN) complexity and              |
//|    O(N*(2*NX+NY)) memory requirements.                           |
//| 2. Although KD-trees may be used with any combination of N and   |
//|    NX, they are more efficient than brute-force search only when |
//|    N >> 4^NX. So they are most useful in low-dimensional tasks   |
//|    (NX=2, NX=3). NX=1  is another inefficient case, because      |
//|    simple  binary  search  (without  additional structures) is   |
//|    much more efficient in such tasks than KD-trees.              |
//+------------------------------------------------------------------+
void CAlglib::KDTreeBuild(CMatrixDouble &xy,const int n,const int nx,
                          const int ny,const int normtype,CKDTreeShell &kdt)
  {
   CNearestNeighbor::KDTreeBuild(xy,n,nx,ny,normtype,kdt.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| KD-tree creation                                                 |
//| This subroutine creates KD-tree from set of X-values and optional|
//| Y-values                                                         |
//| INPUT PARAMETERS                                                 |
//|     XY      -   dataset,array[0..N-1, 0..NX+NY-1].               |
//|                 one row corresponds to one point.                |
//|                 first NX columns contain X-values, next NY (NY   |
//|                 may be zero)                                     |
//|                 columns may contain associated Y-values          |
//|     N       -   number of points, N>=1                           |
//|     NX      -   space dimension, NX>=1.                          |
//|     NY      -   number of optional Y-values, NY>=0.              |
//|     NormType-   norm type:                                       |
//|                 * 0 denotes infinity-norm                        |
//|                 * 1 denotes 1-norm                               |
//|                 * 2 denotes 2-norm (Euclidean norm)              |
//| OUTPUT PARAMETERS                                                |
//|     KDT     -   KD-tree                                          |
//| NOTES                                                            |
//| 1. KD-tree  creation  have O(N*logN) complexity and              |
//|    O(N*(2*NX+NY)) memory requirements.                           |
//| 2. Although KD-trees may be used with any combination of N and   |
//|    NX, they are more efficient than brute-force search only when |
//|    N >> 4^NX. So they are most useful in low-dimensional tasks   |
//|    (NX=2, NX=3). NX=1  is another inefficient case, because      |
//|    simple  binary  search  (without  additional structures) is   |
//|    much more efficient in such tasks than KD-trees.              |
//+------------------------------------------------------------------+
void CAlglib::KDTreeBuild(CMatrixDouble &xy,const int nx,const int ny,
                          const int normtype,CKDTreeShell &kdt)
  {
//--- create a variable
   int n=(int)CAp::Rows(xy);
//--- function call
   CNearestNeighbor::KDTreeBuild(xy,n,nx,ny,normtype,kdt.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| KD-tree creation                                                 |
//| This subroutine creates KD-tree from set of X-values, integer    |
//| tags and optional Y-values                                       |
//| INPUT PARAMETERS                                                 |
//|     XY      -   dataset,array[0..N-1, 0..NX+NY-1].               |
//|                 one row corresponds to one point.                |
//|                 first NX columns contain X-values, next NY (NY   |
//|                 may be zero)                                     |
//|                 columns may contain associated Y-values          |
//|     Tags    -   tags, array[0..N-1], contains integer tags       |
//|                 associated with points.                          |
//|     N       -   number of points, N>=1                           |
//|     NX      -   space dimension, NX>=1.                          |
//|     NY      -   number of optional Y-values, NY>=0.              |
//|     NormType-   norm type:                                       |
//|                 * 0 denotes infinity-norm                        |
//|                 * 1 denotes 1-norm                               |
//|                 * 2 denotes 2-norm (Euclidean norm)              |
//| OUTPUT PARAMETERS                                                |
//|     KDT     -   KD-tree                                          |
//| NOTES                                                            |
//| 1. KD-tree  creation  have O(N*logN) complexity and              |
//|    O(N*(2*NX+NY)) memory requirements.                           |
//| 2. Although KD-trees may be used with any combination of N and   |
//|    NX, they are more efficient than brute-force search only when |
//|    N >> 4^NX. So they are most useful in low-dimensional tasks   |
//|    (NX=2, NX=3). NX=1 is another inefficient case, because simple|
//|    binary search (without additional structures) is much more    |
//|    efficient in such tasks than KD-trees.                        |
//+------------------------------------------------------------------+
void CAlglib::KDTreeBuildTagged(CMatrixDouble &xy,int &tags[],
                                const int n,const int nx,
                                const int ny,const int normtype,
                                CKDTreeShell &kdt)
  {
   CNearestNeighbor::KDTreeBuildTagged(xy,tags,n,nx,ny,normtype,kdt.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::KDTreeBuildTagged(CMatrixDouble &xy,CRowInt &tags,
                                const int n,const int nx,
                                const int ny,const int normtype,
                                CKDTreeShell &kdt)
  {
   CNearestNeighbor::KDTreeBuildTagged(xy,tags,n,nx,ny,normtype,kdt.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| KD-tree creation                                                 |
//| This subroutine creates KD-tree from set of X-values, integer    |
//| tags and optional Y-values                                       |
//| INPUT PARAMETERS                                                 |
//|     XY      -   dataset,array[0..N-1, 0..NX+NY-1].               |
//|                 one row corresponds to one point.                |
//|                 first NX columns contain X-values, next NY (NY   |
//|                 may be zero)                                     |
//|                 columns may contain associated Y-values          |
//|     Tags    -   tags, array[0..N-1], contains integer tags       |
//|                 associated with points.                          |
//|     N       -   number of points, N>=1                           |
//|     NX      -   space dimension, NX>=1.                          |
//|     NY      -   number of optional Y-values, NY>=0.              |
//|     NormType-   norm type:                                       |
//|                 * 0 denotes infinity-norm                        |
//|                 * 1 denotes 1-norm                               |
//|                 * 2 denotes 2-norm (Euclidean norm)              |
//| OUTPUT PARAMETERS                                                |
//|     KDT     -   KD-tree                                          |
//| NOTES                                                            |
//| 1. KD-tree  creation  have O(N*logN) complexity and              |
//|    O(N*(2*NX+NY)) memory requirements.                           |
//| 2. Although KD-trees may be used with any combination of N and   |
//|    NX, they are more efficient than brute-force search only when |
//|    N >> 4^NX. So they are most useful in low-dimensional tasks   |
//|    (NX=2, NX=3). NX=1 is another inefficient case, because simple|
//|    binary search (without additional structures) is much more    |
//|    efficient in such tasks than KD-trees.                        |
//+------------------------------------------------------------------+
void CAlglib::KDTreeBuildTagged(CMatrixDouble &xy,int &tags[],
                                const int nx,const int ny,
                                const int normtype,CKDTreeShell &kdt)
  {
//--- check
   if((CAp::Rows(xy)!=CAp::Len(tags)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=(int)CAp::Rows(xy);
//--- function call
   CNearestNeighbor::KDTreeBuildTagged(xy,tags,n,nx,ny,normtype,kdt.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::KDTreeBuildTagged(CMatrixDouble &xy,CRowInt &tags,
                                const int nx,const int ny,
                                const int normtype,CKDTreeShell &kdt)
  {
//--- check
   if((CAp::Rows(xy)!=CAp::Len(tags)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=(int)CAp::Rows(xy);
//--- function call
   CNearestNeighbor::KDTreeBuildTagged(xy,tags,n,nx,ny,normtype,kdt.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| K-NN query: K nearest neighbors                                  |
//| INPUT PARAMETERS                                                 |
//|     KDT         -   KD-tree                                      |
//|     X           -   point, array[0..NX-1].                       |
//|     K           -   number of neighbors to return, K>=1          |
//|     SelfMatch   -   whether self-matches are allowed:            |
//|                     * if True, nearest neighbor may be the point |
//|                       itself (if it exists in original dataset)  |
//|                     * if False, then only points with non-zero   |
//|                       distance are returned                      |
//|                     * if not given, considered True              |
//| RESULT                                                           |
//|     number of actual neighbors found (either K or N, if K>N).    |
//| This  subroutine performs query and stores its result in the     |
//| internal structures of the KD-tree. You can use following        |
//| subroutines to obtain these results:                             |
//| * KDTreeQueryResultsX() to get X-values                          |
//| * KDTreeQueryResultsXY() to get X- and Y-values                  |
//| * KDTreeQueryResultsTags() to get tag values                     |
//| * KDTreeQueryResultsDistances() to get distances                 |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryKNN(CKDTreeShell &kdt,double &x[],
                            const int k,const bool selfmatch=true)
  {
   return(CNearestNeighbor::KDTreeQueryKNN(kdt.GetInnerObj(),x,k,selfmatch));
  }
//+------------------------------------------------------------------+
//| K-NN query: K nearest neighbors                                  |
//| INPUT PARAMETERS                                                 |
//|     KDT         -   KD-tree                                      |
//|     X           -   point, array[0..NX-1].                       |
//|     K           -   number of neighbors to return, K>=1          |
//|     SelfMatch   -   whether self-matches are allowed:            |
//|                     * if True, nearest neighbor may be the point |
//|                       itself (if it exists in original dataset)  |
//|                     * if False, then only points with non-zero   |
//|                       distance are returned                      |
//|                     * if not given, considered True              |
//| RESULT                                                           |
//|     number of actual neighbors found (either K or N, if K>N).    |
//| This  subroutine performs query and stores its result in the     |
//| internal structures of the KD-tree. You can use following        |
//| subroutines to obtain these results:                             |
//| * KDTreeQueryResultsX() to get X-values                          |
//| * KDTreeQueryResultsXY() to get X- and Y-values                  |
//| * KDTreeQueryResultsTags() to get tag values                     |
//| * KDTreeQueryResultsDistances() to get distances                 |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryKNN(CKDTreeShell &kdt,vector<double> &x,
                            const int k,const bool selfmatch)
  {
   CRowDouble X=x;
   return(CNearestNeighbor::KDTreeQueryKNN(kdt.GetInnerObj(),X,k,selfmatch));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryKNN(CKDTreeShell &kdt,CRowDouble &x,
                            const int k,const bool selfmatch=true)
  {
   return(CNearestNeighbor::KDTreeQueryKNN(kdt.GetInnerObj(),x,k,selfmatch));
  }
//+------------------------------------------------------------------+
//| K-NN query: K nearest neighbors, using external thread-local     |
//| buffer.                                                          |
//| You can call this function from multiple threads for same kd-tree|
//| instance, assuming that different instances of buffer object are |
//| passed to different threads.                                     |
//| INPUT PARAMETERS                                                 |
//|   KDT   -  kd-tree                                               |
//|   Buf   -  request buffer object created for this particular     |
//|            instance of kd-tree structure with                    |
//|            KDTreeCreateRequestBuffer() function.                 |
//|   X     -  point, array[0..NX-1].                                |
//|   K     -  number of neighbors to return, K>=1                   |
//|   SelfMatch   -  whether self-matches are allowed:               |
//|                  * if True, nearest neighbor may be the point    |
//|                    itself (if it exists in original dataset)     |
//|                  * if False, then only points with non-zero      |
//|                    distance are returned                         |
//|                  * if not given, considered True                 |
//| RESULT                                                           |
//|   number of actual neighbors found (either K or N, if K>N).      |
//| This subroutine performs query and stores its result in the      |
//| internal structures of the buffer object. You can use following  |
//| subroutines to obtain these results (pay attention to "buf" in   |
//| their names):                                                    |
//|   * KDTreeTsQueryResultsX() to get X-values                      |
//|   * KDTreeTsQueryResultsXY() to get X- and Y-values              |
//|   * KDTreeTsQueryResultsTags() to get tag values                 |
//|   * KDTreeTsQueryResultsDistances() to get distances             |
//| IMPORTANT: kd-tree buffer should be used only with KD-tree object|
//| which was used to initialize buffer. Any attempt to use biffer   |
//| with different object is dangerous - you may get integrity check |
//| failure (exception) because sizes of internal arrays do not fit  |
//| to dimensions of KD-tree structure.                              |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryKNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,
                              double &x[],const int k,const bool selfmatch)
  {
   CRowDouble X=x;
   return(CNearestNeighbor::KDTreeTsQueryKNN(kdt.GetInnerObj(),buf.GetInnerObj(),X,k,selfmatch));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryKNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,
                              vector<double> &x,const int k,const bool selfmatch)
  {
   CRowDouble X=x;
   return(CNearestNeighbor::KDTreeTsQueryKNN(kdt.GetInnerObj(),buf.GetInnerObj(),X,k,selfmatch));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryKNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,
                              CRowDouble &x,const int k,const bool selfmatch)
  {
   return(CNearestNeighbor::KDTreeTsQueryKNN(kdt.GetInnerObj(),buf.GetInnerObj(),x,k,selfmatch));
  }
//+------------------------------------------------------------------+
//| R-NN query: all points within R-sphere centered at X             |
//| INPUT PARAMETERS                                                 |
//|     KDT         -   KD-tree                                      |
//|     X           -   point, array[0..NX-1].                       |
//|     R           -   radius of sphere (in corresponding norm), R>0|
//|     SelfMatch   -   whether self-matches are allowed:            |
//|                     * if True, nearest neighbor may be the point |
//|                       itself (if it exists in original dataset)  |
//|                     * if False, then only points with non-zero   |
//|                       distance are returned                      |
//|                     * if not given, considered True              |
//| RESULT                                                           |
//|     number of neighbors found, >=0                               |
//| This subroutine performs query and stores its result in the      |
//| internal structures of the KD-tree. You can use following        |
//| subroutines to obtain actual results:                            |
//| * KDTreeQueryResultsX() to get X-values                          |
//| * KDTreeQueryResultsXY() to get X- and Y-values                  |
//| * KDTreeQueryResultsTags() to get tag values                     |
//| * KDTreeQueryResultsDistances() to get distances                 |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryRNN(CKDTreeShell &kdt,double &x[],
                            const double r,const bool selfmatch)
  {
   return(CNearestNeighbor::KDTreeQueryRNN(kdt.GetInnerObj(),x,r,selfmatch));
  }
//+------------------------------------------------------------------+
//| R-NN query: all points within R-sphere centered at X             |
//| INPUT PARAMETERS                                                 |
//|     KDT         -   KD-tree                                      |
//|     X           -   point, array[0..NX-1].                       |
//|     R           -   radius of sphere (in corresponding norm), R>0|
//|     SelfMatch   -   whether self-matches are allowed:            |
//|                     * if True, nearest neighbor may be the point |
//|                       itself (if it exists in original dataset)  |
//|                     * if False, then only points with non-zero   |
//|                       distance are returned                      |
//|                     * if not given, considered True              |
//| RESULT                                                           |
//|     number of neighbors found, >=0                               |
//| This subroutine performs query and stores its result in the      |
//| internal structures of the KD-tree. You can use following        |
//| subroutines to obtain actual results:                            |
//| * KDTreeQueryResultsX() to get X-values                          |
//| * KDTreeQueryResultsXY() to get X- and Y-values                  |
//| * KDTreeQueryResultsTags() to get tag values                     |
//| * KDTreeQueryResultsDistances() to get distances                 |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryRNN(CKDTreeShell &kdt,vector<double> &x,
                            const double r,const bool selfmatch)
  {
   CRowDouble X=x;
   return(CNearestNeighbor::KDTreeQueryRNN(kdt.GetInnerObj(),X,r,selfmatch));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryRNN(CKDTreeShell &kdt,CRowDouble &x,
                            const double r,const bool selfmatch)
  {
   return(CNearestNeighbor::KDTreeQueryRNN(kdt.GetInnerObj(),x,r,selfmatch));
  }
//+------------------------------------------------------------------+
//| R-NN query: all points within R-sphere centered at X, no ordering|
//| by distance as undicated by "U" suffix (faster that ordered      |
//| query, for large queries - significantly faster).                |
//| IMPORTANT: this function can not be used in multithreaded code   |
//|            because it uses internal temporary buffer of kd-tree  |
//|            object, which can not be shared between multiple      |
//|            threads. If you want to perform parallel requests, use|
//|            function which uses external request buffer:          |
//|            KDTreeTsQueryRNN() ("Ts" stands for "thread-safe").   |
//| INPUT PARAMETERS                                                 |
//|   KDT   -  KD-tree                                               |
//|   X     -  point, array[0..NX-1].                                |
//|   R     -  radius of sphere (in corresponding norm), R>0         |
//|   SelfMatch   -  whether self-matches are allowed:               |
//|                  * if True, nearest neighbor may be the point    |
//|                    itself (if it exists in original dataset)     |
//|                  * if False, then only points with non-zero      |
//|                    distance are returned                         |
//|                  * if not given, considered True                 |
//| RESULT                                                           |
//|   number of neighbors found, >=0                                 |
//| This subroutine performs query and stores its result in the      |
//| internal structures of the KD-tree. You can use following        |
//| subroutines to obtain actual results:                            |
//|   * KDTreeQueryResultsX() to get X-values                        |
//|   * KDTreeQueryResultsXY() to get X- and Y-values                |
//|   * KDTreeQueryResultsTags() to get tag values                   |
//|   * KDTreeQueryResultsDistances() to get distances               |
//| As indicated by "U" suffix, this function returns unordered      |
//| results.                                                         |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryRNNU(CKDTreeShell &kdt,double &x[],const double r,bool selfmatch)
  {
   return(CNearestNeighbor::KDTreeQueryRNNU(kdt.GetInnerObj(),x,r,selfmatch));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryRNNU(CKDTreeShell &kdt,vector<double> &x,const double r,bool selfmatch)
  {
   CRowDouble X=x;
   return(CNearestNeighbor::KDTreeQueryRNNU(kdt.GetInnerObj(),X,r,selfmatch));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryRNNU(CKDTreeShell &kdt,CRowDouble &x,const double r,bool selfmatch)
  {
   return(CNearestNeighbor::KDTreeQueryRNNU(kdt.GetInnerObj(),x,r,selfmatch));
  }
//+------------------------------------------------------------------+
//| R-NN query: all points within  R-sphere  centered  at  X, using  |
//| external thread-local buffer, sorted by distance between point   |
//| and X (by ascending)                                             |
//| You can call this function from multiple threads for same kd-tree|
//| instance, assuming that different instances of buffer object are |
//| passed to different threads.                                     |
//| NOTE: it is also possible to perform undordered queries performed|
//| by means of KDTreeQueryRNNU() and KDTreeTsQueryRNNU() functions. |
//| Such queries are faster because we do not have to use heap       |
//| structure for sorting.                                           |
//| INPUT PARAMETERS                                                 |
//|   KDT   -  KD-tree                                               |
//|   Buf   -  request buffer object created for this particular     |
//|            instance of kd-tree structure with                    |
//|            KDTreeCreateRequestBuffer() function.                 |
//|   X     -  point, array[0..NX-1].                                |
//|   R     -  radius of sphere (in corresponding norm), R>0         |
//|   SelfMatch   -  whether self-matches are allowed:               |
//|            * if True, nearest neighbor may be the point itself   |
//|              (if it exists in original dataset)                  |
//|            * if False, then only points with non-zero distance   |
//|              are returned                                        |
//|            * if not given, considered True                       |
//| RESULT                                                           |
//|   number of neighbors found, >=0                                 |
//| This subroutine performs query and stores its result in the      |
//| internal structures of the buffer object. You can use following  |
//| subroutines to obtain these results (pay attention to "buf" in   |
//| their names):                                                    |
//|   * KDTreeTsQueryResultsX() to get X-values                      |
//|   * KDTreeTsQueryResultsXY() to get X- and Y-values              |
//|   * KDTreeTsQueryResultsTags() to get tag values                 |
//|   * KDTreeTsQueryResultsDistances() to get distances             |
//| IMPORTANT: kd-tree buffer should be used only with KD-tree object|
//|            which was used to initialize buffer. Any attempt to   |
//|            use biffer with different object is dangerous - you   |
//|            may get integrity check failure (exception) because   |
//|            sizes of internal arrays do not fit to dimensions of  |
//|            KD-tree structure.                                    |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryRNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,
                              double &x[],const double r,bool selfmatch)
  {
   CRowDouble X=x;
   return(CNearestNeighbor::KDTreeTsQueryRNN(kdt.GetInnerObj(),buf.GetInnerObj(),X,r,selfmatch));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryRNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,
                              vector<double> &x,const double r,bool selfmatch)
  {
   CRowDouble X=x;
   return(CNearestNeighbor::KDTreeTsQueryRNN(kdt.GetInnerObj(),buf.GetInnerObj(),X,r,selfmatch));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryRNN(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,
                              CRowDouble &x,const double r,bool selfmatch)
  {
   return(CNearestNeighbor::KDTreeTsQueryRNN(kdt.GetInnerObj(),buf.GetInnerObj(),x,r,selfmatch));
  }
//+------------------------------------------------------------------+
//| R-NN query: all points within R-sphere centered at X, using      |
//| external thread-local buffer, no ordering by distance as         |
//| undicated by "U" suffix (faster that ordered query, for large    |
//| queries - significantly faster).                                 |
//| You can call this function from multiple threads for same kd-tree|
//| instance, assuming that different instances of buffer object are |
//| passed to different threads.                                     |
//| INPUT PARAMETERS                                                 |
//|   KDT   -  KD-tree                                               |
//|   Buf   -  request buffer object created for this particular     |
//|            instance of kd-tree structure with                    |
//|            KDTreeCreateRequestBuffer() function.                 |
//|   X     -  point, array[0..NX-1].                                |
//|   R     -  radius of sphere (in corresponding norm), R>0         |
//|   SelfMatch   -  whether self-matches are allowed:               |
//|               * if True, nearest neighbor may be the point itself|
//|                 (if it exists in original dataset)               |
//|               * if False, then only points with non-zero distance|
//|                 are returned                                     |
//|               * if not given, considered True                    |
//| RESULT                                                           |
//|   number of neighbors found, >=0                                 |
//| This subroutine performs query and stores its result in the      |
//| internal structures of the buffer object. You can use following  |
//| subroutines to obtain these results (pay attention to "buf" in   |
//| their names):                                                    |
//|   * KDTreeTsQueryResultsX() to get X-values                      |
//|   * KDTreeTsQueryResultsXY() to get X- and Y-values              |
//|   * KDTreeTsQueryResultsTags() to get tag values                 |
//|   * KDTreeTsQueryResultsDistances() to get distances             |
//| As indicated by "U" suffix, this function returns unordered      |
//| results.                                                         |
//| IMPORTANT: kd-tree buffer should be used only with KD-tree object|
//|            which was used to initialize buffer. Any attempt to   |
//|            use biffer with different object is dangerous - you   |
//|            may get integrity check failure (exception) because   |
//|            sizes of internal arrays do not fit to dimensions of  |
//|            KD-tree structure.                                    |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryRNNU(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,
                               double &x[],const double r,const bool selfmatch)
  {
   CRowDouble X=x;
   return(CNearestNeighbor::KDTreeTsQueryRNNU(kdt.GetInnerObj(),buf.GetInnerObj(),X,r,selfmatch));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryRNNU(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,
                               vector<double> &x,const double r,const bool selfmatch)
  {
   CRowDouble X=x;
   return(CNearestNeighbor::KDTreeTsQueryRNNU(kdt.GetInnerObj(),buf.GetInnerObj(),X,r,selfmatch));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryRNNU(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,
                               CRowDouble &x,const double r,const bool selfmatch)
  {
   return(CNearestNeighbor::KDTreeTsQueryRNNU(kdt.GetInnerObj(),buf.GetInnerObj(),x,r,selfmatch));
  }
//+------------------------------------------------------------------+
//| K-NN query: approximate K nearest neighbors                      |
//| INPUT PARAMETERS                                                 |
//|     KDT         -   KD-tree                                      |
//|     X           -   point, array[0..NX-1].                       |
//|     K           -   number of neighbors to return, K>=1          |
//|     SelfMatch   -   whether self-matches are allowed:            |
//|                     * if True, nearest neighbor may be the point |
//|                       itself (if it exists in original dataset)  |
//|                     * if False, then only points with non-zero   |
//|                       distance are returned                      |
//|                     * if not given, considered True              |
//|     Eps         -   approximation factor, Eps>=0. eps-approximate|
//|                     nearest neighbor is a neighbor whose distance|
//|                     from X is at most (1+eps) times distance of  |
//|                     true nearest neighbor.                       |
//| RESULT                                                           |
//|     number of actual neighbors found (either K or N, if K>N).    |
//| NOTES                                                            |
//|     significant performance gain may be achieved only when Eps is|
//|     on the order of magnitude of 1 or larger.                    |
//| This subroutine performs query and stores its result in the      |
//| internal structures of the KD-tree. You can use following        |
//| these subroutines to  obtain results:                            |
//| * KDTreeQueryResultsX() to get X-values                          |
//| * KDTreeQueryResultsXY() to get X- and Y-values                  |
//| * KDTreeQueryResultsTags() to get tag values                     |
//| * KDTreeQueryResultsDistances() to get distances                 |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryAKNN(CKDTreeShell &kdt,double &x[],
                             const int k,const bool selfmatch,
                             const double eps)
  {
   return(CNearestNeighbor::KDTreeQueryAKNN(kdt.GetInnerObj(),x,k,selfmatch,eps));
  }
//+------------------------------------------------------------------+
//| K-NN query: approximate K nearest neighbors                      |
//| INPUT PARAMETERS                                                 |
//|     KDT         -   KD-tree                                      |
//|     X           -   point, array[0..NX-1].                       |
//|     K           -   number of neighbors to return, K>=1          |
//|     SelfMatch   -   whether self-matches are allowed:            |
//|                     * if True, nearest neighbor may be the point |
//|                       itself (if it exists in original dataset)  |
//|                     * if False, then only points with non-zero   |
//|                       distance are returned                      |
//|                     * if not given, considered True              |
//|     Eps         -   approximation factor, Eps>=0. eps-approximate|
//|                     nearest neighbor is a neighbor whose distance|
//|                     from X is at most (1+eps) times distance of  |
//|                     true nearest neighbor.                       |
//| RESULT                                                           |
//|     number of actual neighbors found (either K or N, if K>N).    |
//| NOTES                                                            |
//|     significant performance gain may be achieved only when Eps is|
//|     on the order of magnitude of 1 or larger.                    |
//| This subroutine performs query and stores its result in the      |
//| internal structures of the KD-tree. You can use following        |
//| these subroutines to  obtain results:                            |
//| * KDTreeQueryResultsX() to get X-values                          |
//| * KDTreeQueryResultsXY() to get X- and Y-values                  |
//| * KDTreeQueryResultsTags() to get tag values                     |
//| * KDTreeQueryResultsDistances() to get distances                 |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryAKNN(CKDTreeShell &kdt,vector<double> &x,
                             const int k,const bool selfmatch,
                             const double eps=0)
  {
   CRowDouble X=x;
   return(CNearestNeighbor::KDTreeQueryAKNN(kdt.GetInnerObj(),X,k,selfmatch,eps));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryAKNN(CKDTreeShell &kdt,CRowDouble &x,
                             const int k,const bool selfmatch,
                             const double eps)
  {
   return(CNearestNeighbor::KDTreeQueryAKNN(kdt.GetInnerObj(),x,k,selfmatch,eps));
  }
//+------------------------------------------------------------------+
//| Box query: all points within user-specified box.                 |
//| IMPORTANT: this function can not be used in multithreaded code   |
//|            because it uses internal temporary buffer of kd-tree  |
//|            object, which can not be shared between multiple      |
//|            threads. If you want to perform parallel requests,    |
//|            use function which uses external request buffer:      |
//|            KDTreeTsQueryBox() ("Ts" stands for "thread-safe").   |
//| INPUT PARAMETERS                                                 |
//|   KDT      -  KD-tree                                            |
//|   BoxMin   -  lower bounds, array[0..NX-1].                      |
//|   BoxMax   -  upper bounds, array[0..NX-1].                      |
//| RESULT                                                           |
//|   number of actual neighbors found (in [0,N]).                   |
//| This subroutine performs query and stores its result in the      |
//| internal structures of the KD-tree. You can use following        |
//| subroutines to obtain these results:                             |
//|   * KDTreeQueryResultsX() to get X-values                        |
//|   * KDTreeQueryResultsXY() to get X- and Y-values                |
//|   * KDTreeQueryResultsTags() to get tag values                   |
//|   * KDTreeQueryResultsDistances() returns zeros for this request |
//| NOTE: this particular query returns unordered results, because   |
//|       there is no meaningful way of ordering points. Furthermore,|
//|       no 'distance' is associated with points - it is either     |
//|       INSIDE or OUTSIDE (so request for distances will return    |
//|       zeros).                                                    |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryBox(CKDTreeShell &kdt,double &boxmin[],double &boxmax[])
  {
   return(CNearestNeighbor::KDTreeQueryBox(kdt.GetInnerObj(),boxmin,boxmax));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryBox(CKDTreeShell &kdt,vector<double> &boxmin,vector<double> &boxmax)
  {
   CRowDouble Min=boxmin;
   CRowDouble Max=boxmax;
   return(CNearestNeighbor::KDTreeQueryBox(kdt.GetInnerObj(),Min,Max));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeQueryBox(CKDTreeShell &kdt,CRowDouble &boxmin,CRowDouble &boxmax)
  {
   return(CNearestNeighbor::KDTreeQueryBox(kdt.GetInnerObj(),boxmin,boxmax));
  }
//+------------------------------------------------------------------+
//| Box query: all points within user-specified box, using           |
//| thread-local buffer.                                             |
//| You can call this function from multiple threads for same kd-tree|
//| instance, assuming that different instances of buffer object are |
//| passed to different threads.                                     |
//| INPUT PARAMETERS                                                 |
//|   KDT      -  KD-tree                                            |
//|   Buf      -  request buffer object created for this particular  |
//|               instance of kd-tree structure with                 |
//|               KDTreeCreateRequestBuffer() function.              |
//|   BoxMin   -  lower bounds, array[0..NX-1].                      |
//|   BoxMax   -  upper bounds, array[0..NX-1].                      |
//| RESULT                                                           |
//|   number of actual neighbors found (in [0,N]).                   |
//| This subroutine performs query and stores its result in the      |
//| internal structures of the buffer object. You can use following  |
//| subroutines to obtain these results (pay attention to "ts" in    |
//| their names):                                                    |
//|   * KDTreeTsQueryResultsX() to get X-values                      |
//|   * KDTreeTsQueryResultsXY() to get X- and Y-values              |
//|   * KDTreeTsQueryResultsTags() to get tag values                 |
//|   * KDTreeTsQueryResultsDistances() returns zeros for this query |
//| NOTE: this particular query returns unordered results, because   |
//|       there is no meaningful way of ordering points. Furthermore,|
//|       no 'distance' is associated with points - it is either     |
//|       INSIDE  or OUTSIDE (so request for distances will return   |
//|       zeros).                                                    |
//| IMPORTANT: kd-tree buffer should be used only with KD-tree object|
//|            which was used to initialize buffer. Any attempt to   |
//|            use biffer with different object is dangerous - you   |
//|            may  get  integrity  check failure (exception) because|
//|            sizes of internal arrays do not fit to dimensions of  |
//|            KD-tree structure.                                    |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryBox(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,double &boxmin[],double &boxmax[])
  {
   return(CNearestNeighbor::KDTreeTsQueryBox(kdt.GetInnerObj(),buf.GetInnerObj(),boxmin,boxmax));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryBox(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,CRowDouble &boxmin,CRowDouble &boxmax)
  {
   return(CNearestNeighbor::KDTreeTsQueryBox(kdt.GetInnerObj(),buf.GetInnerObj(),boxmin,boxmax));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::KDTreeTsQueryBox(CKDTreeShell &kdt,CKDTreeRequestBufferShell &buf,vector<double> &boxmin,vector<double> &boxmax)
  {
   CRowDouble Min=boxmin;
   CRowDouble Max=boxmax;
   return(CNearestNeighbor::KDTreeTsQueryBox(kdt.GetInnerObj(),buf.GetInnerObj(),Min,Max));
  }
//+------------------------------------------------------------------+
//| X-values from last query                                         |
//| INPUT PARAMETERS                                                 |
//|     KDT     -   KD-tree                                          |
//|     X       -   possibly pre-allocated buffer. If X is too small |
//|                 to store result, it is resized. If size(X) is    |
//|                 enough to store result, it is left unchanged.    |
//| OUTPUT PARAMETERS                                                |
//|     X       -   rows are filled with X-values                    |
//| NOTES                                                            |
//| 1. points are ordered by distance from the query point (first =  |
//|    closest)                                                      |
//| 2. if  XY is larger than required to store result, only leading  |
//|    part will be overwritten; trailing part will be left          |
//|    unchanged. So if on input XY = [[A,B],[C,D]], and result is   |
//|    [1,2], then on exit we will get XY = [[1,2],[C,D]]. This is   |
//|    done purposely to increase performance; if you want function  |
//|    to resize array according to result size, use function with   |
//| same name and suffix 'I'.                                        |
//| SEE ALSO                                                         |
//| * KDTreeQueryResultsXY()            X- and Y-values              |
//| * KDTreeQueryResultsTags()          tag values                   |
//| * KDTreeQueryResultsDistances()     distances                    |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsX(CKDTreeShell &kdt,CMatrixDouble &x)
  {
   CNearestNeighbor::KDTreeQueryResultsX(kdt.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| X- and Y-values from last query                                  |
//| INPUT PARAMETERS                                                 |
//|     KDT     -   KD-tree                                          |
//|     XY      -   possibly pre-allocated buffer. If XY is too small|
//|                 to store result, it is resized. If size(XY) is   |
//|                 enough to store result, it is left unchanged.    |
//| OUTPUT PARAMETERS                                                |
//|     XY      -   rows are filled with points: first NX columns    |
//|                 with X-values, next NY columns - with Y-values.  |
//| NOTES                                                            |
//| 1. points are ordered by distance from the query point (first =  |
//|    closest)                                                      |
//| 2. if  XY is larger than required to store result, only leading  |
//|    part will be overwritten; trailing part will be left          |
//|    unchanged. So if on input XY = [[A,B],[C,D]], and result is   |
//|    [1,2], then on exit we will get XY = [[1,2],[C,D]]. This is   |
//|    done purposely to increase performance; if you want function  |
//|    to resize array according to result size, use function with   |
//|    same name and suffix 'I'.                                     |
//| SEE ALSO                                                         |
//| * KDTreeQueryResultsX()             X-values                     |
//| * KDTreeQueryResultsTags()          tag values                   |
//| * KDTreeQueryResultsDistances()     distances                    |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsXY(CKDTreeShell &kdt,CMatrixDouble &xy)
  {
   CNearestNeighbor::KDTreeQueryResultsXY(kdt.GetInnerObj(),xy);
  }
//+------------------------------------------------------------------+
//| Tags from last query                                             |
//| INPUT PARAMETERS                                                 |
//|     KDT     -   KD-tree                                          |
//|     Tags    -   possibly pre-allocated buffer. If X is too small |
//|                 to store result, it is resized. If size(X) is    |
//|                 enough to store result, it is left unchanged.    |
//| OUTPUT PARAMETERS                                                |
//|     Tags    -   filled with tags associated with points,         |
//|                 or, when no tags were supplied, with zeros       |
//| NOTES                                                            |
//| 1. points are ordered by distance from the query point (first    |
//|    = closest)                                                    |
//| 2. if  XY is larger than required to store result, only leading  |
//|    part will be overwritten; trailing part will be left          |
//|    unchanged. So if on input XY = [[A,B],[C,D]], and result is   |
//|    [1,2],then on exit we will get XY = [[1,2], [C,D]]. This is   |
//|    done purposely to increase performance; if you want function  |
//|    to resize array according to result size, use function with   |
//|    same name and suffix 'I'.                                     |
//| SEE ALSO                                                         |
//| * KDTreeQueryResultsX()             X-values                     |
//| * KDTreeQueryResultsXY()            X- and Y-values              |
//| * KDTreeQueryResultsDistances()     distances                    |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsTags(CKDTreeShell &kdt,int &tags[])
  {
   CNearestNeighbor::KDTreeQueryResultsTags(kdt.GetInnerObj(),tags);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsTags(CKDTreeShell &kdt,CRowInt &tags)
  {
   CNearestNeighbor::KDTreeQueryResultsTags(kdt.GetInnerObj(),tags);
  }
//+------------------------------------------------------------------+
//| Distances from last query                                        |
//| INPUT PARAMETERS                                                 |
//|     KDT     -   KD-tree                                          |
//|     R       -   possibly pre-allocated buffer. If X is too small |
//|                 to store result, it is resized. If size(X) is    |
//|                 enough to store result, it is left unchanged.    |
//| OUTPUT PARAMETERS                                                |
//|     R       -   filled with distances (in corresponding norm)    |
//| NOTES                                                            |
//| 1. points are ordered by distance from the query point (first    |
//|    = closest)                                                    |
//| 2. if  XY is larger than required to store result, only leading  |
//|    part will be overwritten; trailing part will be left          |
//|    unchanged. So if on input XY = [[A,B], [C,D]],and result is   |
//|    [1,2], then on exit we will get XY = [[1,2], C,D]]. This is   |
//|    done purposely to increase performance; if you want function  |
//|    to resize array according to result size, use function with   |
//|    same name and suffix 'I'.                                     |
//| SEE ALSO                                                         |
//| * KDTreeQueryResultsX()             X-values                     |
//| * KDTreeQueryResultsXY()            X- and Y-values              |
//| * KDTreeQueryResultsTags()          tag values                   |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsDistances(CKDTreeShell &kdt,double &r[])
  {
   CNearestNeighbor::KDTreeQueryResultsDistances(kdt.GetInnerObj(),r);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsDistances(CKDTreeShell &kdt,CRowDouble &r)
  {
   CNearestNeighbor::KDTreeQueryResultsDistances(kdt.GetInnerObj(),r);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsDistances(CKDTreeShell &kdt,vector<double> &r)
  {
//--- create variables
   CRowDouble R;
//--- function call
   CNearestNeighbor::KDTreeQueryResultsDistances(kdt.GetInnerObj(),R);
//---copy result
   r=R.ToVector();
  }
//+------------------------------------------------------------------+
//| X-values from last query; 'interactive' variant for languages    |
//| like Python which support constructs like "X =                   |
//| KDTreeQueryResultsXI(KDT)" and interactive mode of interpreter.  |
//| This function allocates new array on each call, so it is         |
//| significantly slower than its 'non-interactive' counterpart, but |
//| it is more convenient when you call it from command line.        |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsXI(CKDTreeShell &kdt,CMatrixDouble &x)
  {
   CNearestNeighbor::KDTreeQueryResultsXI(kdt.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| XY-values from last query; 'interactive' variant for languages   |
//| like Python which support constructs like "XY =                  |
//| KDTreeQueryResultsXYI(KDT)" and interactive mode of interpreter. |
//| This function allocates new array on each call, so it is         |
//| significantly slower than its 'non-interactive' counterpart, but |
//| it is more convenient when you call it from command line.        |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsXYI(CKDTreeShell &kdt,CMatrixDouble &xy)
  {
   CNearestNeighbor::KDTreeQueryResultsXYI(kdt.GetInnerObj(),xy);
  }
//+------------------------------------------------------------------+
//| Tags from last query; 'interactive' variant for languages like   |
//| Python which  support  constructs  like "Tags =                  |
//| KDTreeQueryResultsTagsI(KDT)" and interactive mode of            |
//| interpreter.                                                     |
//| This function allocates new array on each call, so it is         |
//| significantly slower than its 'non-interactive' counterpart, but |
//| it is more convenient when you call it from command line.        |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsTagsI(CKDTreeShell &kdt,int &tags[])
  {
   CNearestNeighbor::KDTreeQueryResultsTagsI(kdt.GetInnerObj(),tags);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsTagsI(CKDTreeShell &kdt,CRowInt &tags)
  {
   CNearestNeighbor::KDTreeQueryResultsTagsI(kdt.GetInnerObj(),tags);
  }
//+------------------------------------------------------------------+
//| Distances from last query; 'interactive' variant for languages   |
//| like Python which support constructs like "R =                   |
//| KDTreeQueryResultsDistancesI(KDT)" and interactive mode of       |
//| interpreter.                                                     |
//| This function allocates new array on each call, so it is         |
//| significantly slower than its 'non-interactive' counterpart, but |
//| it is more convenient when you call it from command line.        |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsDistancesI(CKDTreeShell &kdt,double &r[])
  {
   CNearestNeighbor::KDTreeQueryResultsDistancesI(kdt.GetInnerObj(),r);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsDistancesI(CKDTreeShell &kdt,vector<double> &r)
  {
   CRowDouble R;
   CNearestNeighbor::KDTreeQueryResultsDistancesI(kdt.GetInnerObj(),R);
   r=R.ToVector();
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::KDTreeQueryResultsDistancesI(CKDTreeShell &kdt,CRowDouble &r)
  {
   CNearestNeighbor::KDTreeQueryResultsDistancesI(kdt.GetInnerObj(),r);
  }
//+------------------------------------------------------------------+
//| Optimal binary classification                                    |
//| Algorithms finds optimal (=with minimal cross-entropy) binary    |
//| partition.                                                       |
//| Internal subroutine.                                             |
//| INPUT PARAMETERS:                                                |
//|     A       -   array[0..N-1], variable                          |
//|     C       -   array[0..N-1], class numbers (0 or 1).           |
//|     N       -   array size                                       |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   completetion code:                               |
//|                 * -3, all values of A[] are same (partition is   |
//|                   impossible)                                    |
//|                 * -2, one of C[] is incorrect (<0, >1)           |
//|                 * -1, incorrect pararemets were passed (N<=0).   |
//|                 *  1, OK                                         |
//|     Threshold-  partiton boundary. Left part contains values     |
//|                 which are strictly less than Threshold. Right    |
//|                 part contains values which are greater than or   |
//|                 equal to Threshold.                              |
//|     PAL, PBL-   probabilities P(0|v<Threshold) and               |
//|                 P(1|v<Threshold)                                 |
//|     PAR, PBR-   probabilities P(0|v>=Threshold) and              |
//|                 P(1|v>=Threshold)                                |
//|     CVE     -   cross-validation estimate of cross-entropy       |
//+------------------------------------------------------------------+
void CAlglib::DSOptimalSplit2(double &a[],int &c[],const int n,
                              int &info,double &threshold,
                              double &pal,double &pbl,double &par,
                              double &pbr,double &cve)
  {
//--- initialization
   info=0;
   threshold=0;
   pal=0;
   pbl=0;
   par=0;
   pbr=0;
   cve=0;
//--- function call
   CBdSS::DSOptimalSplit2(a,c,n,info,threshold,pal,pbl,par,pbr,cve);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::DSOptimalSplit2(CRowDouble &a,CRowInt &c,const int n,
                              int &info,double &threshold,
                              double &pal,double &pbl,double &par,
                              double &pbr,double &cve)
  {
//--- initialization
   info=0;
   threshold=0;
   pal=0;
   pbl=0;
   par=0;
   pbr=0;
   cve=0;
//--- function call
   CBdSS::DSOptimalSplit2(a,c,n,info,threshold,pal,pbl,par,pbr,cve);
  }
//+------------------------------------------------------------------+
//| Optimal partition, internal subroutine. Fast version.            |
//| Accepts:                                                         |
//|     A       array[0..N-1]       array of attributes array[0..N-1]|
//|     C       array[0..N-1]       array of class labels            |
//|     TiesBuf array[0..N]         temporaries (ties)               |
//|     CntBuf  array[0..2*NC-1]    temporaries (counts)             |
//|     Alpha                       centering factor (0<=alpha<=1,   |
//|                                 recommended value - 0.05)        |
//|     BufR    array[0..N-1]       temporaries                      |
//|     BufI    array[0..N-1]       temporaries                      |
//| Output:                                                          |
//|     Info    error code (">0"=OK, "<0"=bad)                       |
//|     RMS     training set RMS error                               |
//|     CVRMS   leave-one-out RMS error                              |
//| Note:                                                            |
//|     content of all arrays is changed by subroutine;              |
//|     it doesn't allocate temporaries.                             |
//+------------------------------------------------------------------+
void CAlglib::DSOptimalSplit2Fast(double &a[],int &c[],int &tiesbuf[],
                                  int &cntbuf[],double &bufr[],
                                  int &bufi[],const int n,
                                  const int nc,const double alpha,
                                  int &info,double &threshold,
                                  double &rms,double &cvrms)
  {
//--- initialization
   info=0;
   threshold=0;
   rms=0;
   cvrms=0;
//--- function call
   CBdSS::DSOptimalSplit2Fast(a,c,tiesbuf,cntbuf,bufr,bufi,n,nc,alpha,info,threshold,rms,cvrms);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::DSOptimalSplit2Fast(CRowDouble &a,CRowInt &c,CRowInt &tiesbuf,
                                  CRowInt &cntbuf,CRowDouble &bufr,
                                  CRowInt &bufi,const int n,
                                  const int nc,const double alpha,
                                  int &info,double &threshold,
                                  double &rms,double &cvrms)
  {
//--- initialization
   info=0;
   threshold=0;
   rms=0;
   cvrms=0;
//--- function call
   CBdSS::DSOptimalSplit2Fast(a,c,tiesbuf,cntbuf,bufr,bufi,n,nc,alpha,info,threshold,rms,cvrms);
  }
//+------------------------------------------------------------------+
//| This function serializes data structure to string.               |
//| Important properties of s_out:                                   |
//| * it contains alphanumeric characters, dots, underscores, minus  |
//|   signs                                                          |
//| * these symbols are grouped into words, which are separated by   |
//|   spaces and Windows-style (CR+LF) newlines                      |
//| * although  serializer  uses  spaces and CR+LF as separators, you|
//|   can replace any separator character by arbitrary combination of|
//|   spaces, tabs, Windows or Unix newlines. It allows flexible     |
//|   reformatting of the string in case you want to include it into |
//|   text or XML file. But you should not insert separators into the|
//|   middle of the "words" nor you should change case of letters.   |
//| * s_out can be freely moved between 32-bit and 64-bit systems,   |
//|   little and big endian machines, and so on. You can reference   |
//|   structure on 32-bit machine and unserialize it on 64-bit one   |
//|   (or vice versa), or reference it on SPARC and unserialize on   |
//|   x86. You can also reference it in C# version of ALGLIB and     |
//|   unserialize in C++ one, and vice versa.                        |
//+------------------------------------------------------------------+
void CAlglib::DFSerialize(CDecisionForestShell &obj,string &s_out)
  {
   CSerializer s;
//--- serialization start
   s.Alloc_Start();
//--- function call
   CDForest::DFAlloc(s,obj.GetInnerObj());
//--- serialization
   s.SStart_Str();
//--- function call
   CDForest::DFSerialize(s,obj.GetInnerObj());
//--- stop
   s.Stop();
//--- change value
   s_out=s.Get_String();
  }
//+------------------------------------------------------------------+
//| This function unserializes data structure from string.           |
//+------------------------------------------------------------------+
void CAlglib::DFUnserialize(const string s_in,CDecisionForestShell &obj)
  {
   CSerializer s;
//--- unserialization
   s.UStart_Str(s_in);
//--- function call
   CDForest::DFUnserialize(s,obj.GetInnerObj());
//--- stop
   s.Stop();
  }
//+------------------------------------------------------------------+
//| This function creates buffer structure which can be used to      |
//| perform parallel inference requests.                             |
//| DF subpackage provides two sets of computing functions - ones    |
//| which use internal buffer of DF model (these functions are       |
//| single-threaded because they use same buffer, which can not      |
//| shared between threads), and ones which use external buffer.     |
//| This function is used to initialize external buffer.             |
//| INPUT PARAMETERS:                                                |
//|   Model    -  DF model which is associated with newly created    |
//|               buffer                                             |
//| OUTPUT PARAMETERS:                                               |
//|   Buf      -  external buffer.                                   |
//| IMPORTANT: buffer object should be used only with model which was|
//|            used to initialize buffer. Any attempt to use buffer  |
//|            with different object is dangerous - you may get      |
//|            integrity check failure (exception) because sizes of  |
//|            internal arrays do not fit to dimensions of the model |
//|            structure.                                            |
//+------------------------------------------------------------------+
void CAlglib::DFCreateBuffer(CDecisionForestShell &model,
                             CDecisionForestBuffer &buf)
  {
   CDForest::DFCreateBuffer(model.GetInnerObj(),buf);
  }
//+------------------------------------------------------------------+
//| This subroutine creates CDecisionForestBuilder object which is   |
//| used to train decision forests.                                  |
//| By default, new builder stores empty dataset and some reasonable |
//| default settings. At the very least, you should specify dataset  |
//| prior to building decision forest. You can also tweak settings of|
//| the forest construction algorithm (recommended, although default |
//| setting should work well).                                       |
//| Following actions are mandatory:                                 |
//|   * calling DFBuilderSetDataset() to specify dataset             |
//|   * calling DFBuilderBuildRandomForest() to build decision forest|
//|     using current dataset and default settings                   |
//| Additionally, you may call:                                      |
//|   * DFBuilderSetRndVars() or DFBuilderSetRndVarsRatio() to       |
//|     specify number of variables randomly chosen for each split   |
//|   * DFBuilderSetSubsampleRatio() to specify fraction of the      |
//|     dataset randomly subsampled to build each tree               |
//|   * DFBuilderSetSeed() to control random seed chosen for tree    |
//|     construction                                                 |
//| INPUT PARAMETERS:                                                |
//|   none                                                           |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  decision forest builder                            |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderCreate(CDecisionForestBuilder &s)
  {
   CDForest::DFBuilderCreate(s);
  }
//+------------------------------------------------------------------+
//| This subroutine adds dense dataset to the internal storage of the|
//| builder object. Specifying your dataset in the dense format means|
//| that the dense version of the forest construction algorithm will |
//| be invoked.                                                      |
//| INPUT PARAMETERS:                                                |
//|   S        -  decision forest builder object                     |
//|   XY       -  array[NPoints,NVars+1] (minimum size; actual size  |
//|               can be larger, only leading part is used anyway),  |
//|               dataset:                                           |
//|               * first NVars elements of each row store values of |
//|                 the independent variables                        |
//|               * last column store class number(in 0...NClasses-1)|
//|                 or real value of the dependent variable          |
//|   NPoints  -  number of rows in the dataset, NPoints>=1          |
//|   NVars    -  number of independent variables, NVars>=1          |
//|   NClasses -  indicates type of the problem being solved:        |
//|               * NClasses>=2 means that classification problem is |
//|                 solved (last column of the dataset stores class  |
//|                 number)                                          |
//|               * NClasses=1  means  that  regression  problem  is |
//|                 solved  (last  column  of  the  dataset  stores  |
//|                 variable value)                                  |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  decision forest builder                            |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetDataset(CDecisionForestBuilder &s,CMatrixDouble &xy,
                                  int npoints,int nvars,int nclasses)
  {
   CDForest::DFBuilderSetDataset(s,xy,npoints,nvars,nclasses);
  }
//+------------------------------------------------------------------+
//| This function sets number of variables (in [1,NVars] range) used |
//| by decision forest construction algorithm.                       |
//| The default option is to use roughly sqrt(NVars) variables.      |
//| INPUT PARAMETERS:                                                |
//|   S        -  decision forest builder object                     |
//|   RndVars  -  number of randomly selected variables; values      |
//|               outside of [1,NVars] range are silently clipped.   |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  decision forest builder                            |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetRndVars(CDecisionForestBuilder &s,int rndvars)
  {
   CDForest::DFBuilderSetRndVars(s,rndvars);
  }
//+------------------------------------------------------------------+
//| This function sets number of variables used by decision forest   |
//| construction algorithm as a fraction of total variable count     |
//| (0,1) range.                                                     |
//| The default option is to use roughly sqrt(NVars) variables.      |
//| INPUT PARAMETERS:                                                |
//|   S        -  decision forest builder object                     |
//|   F        -  round(NVars*F) variables are selected              |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  decision forest builder                            |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetRndVarsRatio(CDecisionForestBuilder &s,double f)
  {
   CDForest::DFBuilderSetRndVarsRatio(s,f);
  }
//+------------------------------------------------------------------+
//| This function tells decision forest builder to automatically     |
//| choose number of variables used by decision forest construction  |
//| algorithm. Roughly sqrt(NVars) variables will be used.           |
//| INPUT PARAMETERS:                                                |
//|   S        -  decision forest builder object                     |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  decision forest builder                            |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetRndVarsAuto(CDecisionForestBuilder &s)
  {
   CDForest::DFBuilderSetRndVarsAuto(s);
  }
//+------------------------------------------------------------------+
//| This function sets size of dataset subsample generated the       |
//| decision forest construction algorithm. Size is specified as a   |
//| fraction of  total  dataset size.                                |
//| The default option is to use 50% of the dataset for training,    |
//| 50% for the OOB estimates. You can decrease fraction F down to   |
//| 10%, 1% or  even  below in order to reduce overfitting.          |
//| INPUT PARAMETERS:                                                |
//|   S        -  decision forest builder object                     |
//|   F        -  fraction of the dataset to use, in (0,1] range.    |
//|               Values outside of this range will  be  silently    |
//|               clipped. At least one element is always selected   |
//|               for the training set.                              |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  decision forest builder                            |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetSubsampleRatio(CDecisionForestBuilder &s,double f)
  {
   CDForest::DFBuilderSetSubsampleRatio(s,f);
  }
//+------------------------------------------------------------------+
//| This  function  sets  seed  used  by  internal  RNG  for  random |
//| subsampling and random selection of variable subsets.            |
//| By  default  random  seed  is  used, i.e. every time you build   |
//| decision forest, we seed generator with new value obtained from  |
//| system-wide  RNG.  Thus, decision  forest  builder  returns      |
//| non-deterministic results. You  can  change  such  behavior  by  |
//| specyfing fixed positive seed value.                             |
//| INPUT PARAMETERS:                                                |
//|   S        -  decision forest builder object                     |
//|   SeedVal  -  seed value:                                        |
//|               * positive values are used for seeding RNG with    |
//|                 fixed seed, i.e. subsequent runs on same data    |
//|                 will return same decision forests                |
//|               * non-positive seed means that random seed is used |
//|                 for every run of builder, i.e. subsequent  runs  |
//|                 on same datasets will return slightly different  |
//|                 decision forests                                 |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  decision forest builder, see                       |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetSeed(CDecisionForestBuilder &s,int seedval)
  {
   CDForest::DFBuilderSetSeed(s,seedval);
  }
//+------------------------------------------------------------------+
//| This function sets random decision forest construction algorithm.|
//| As for now, only one decision forest construction algorithm is   |
//| supported-a dense "baseline" RDF algorithm.                    |
//| INPUT PARAMETERS:                                                |
//|   S        -  decision forest builder object                     |
//|   AlgoType -  algorithm type:                                    |
//|               * 0 = baseline dense RDF                           |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  decision forest builder, see                       |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetRDFAlgo(CDecisionForestBuilder &s,int algotype)
  {
   CDForest::DFBuilderSetRDFAlgo(s,algotype);
  }
//+------------------------------------------------------------------+
//| This function sets split selection algorithm used by decision    |
//| forest classifier. You may choose several algorithms, with       |
//| different speed and quality of the results.                      |
//| INPUT PARAMETERS:                                                |
//|   S              -  decision forest builder object               |
//|   SplitStrength  -  split type:                                  |
//|            * 0 = split at the random position, fastest one       |
//|            * 1 = split at the middle of the range                |
//|            * 2 = strong split at the best point of the range     |
//|                  (default)                                       |
//| OUTPUT PARAMETERS:                                               |
//|   S              -  decision forest builder, see                 |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetRDFSplitStrength(CDecisionForestBuilder &s,
                                           int splitstrength)
  {
   CDForest::DFBuilderSetRDFSplitStrength(s,splitstrength);
  }
//+------------------------------------------------------------------+
//| This function tells decision forest construction algorithm to use|
//| Gini impurity based variable importance estimation (also known as|
//| MDI).                                                            |
//| This version of importance estimation algorithm analyzes mean    |
//| decrease in impurity (MDI) on training sample during splits. The |
//| result is divided by impurity at the root node in order to       |
//| produce estimate in [0,1] range.                                 |
//| Such estimates are fast to calculate and beautifully normalized  |
//| (sum to one) but have following downsides:                       |
//|   * They ALWAYS sum to 1.0, even if output is completely         |
//|     unpredictable. I.e. MDI allows to order variables by         |
//|     importance, but does not  tell us about "absolute"           |
//|     importances of variables                                     |
//|   * there exist some bias towards continuous and high-cardinality|
//|     categorical variables                                        |
//| NOTE: informally speaking, MDA (permutation importance) rating   |
//|       answers the question  "what  part  of  the  model          |
//|       predictive power is ruined by permuting k-th variable?"    |
//|       while MDI tells us "what part of the model predictive power|
//|       was achieved due to usage of k-th variable".               |
//| Thus, MDA rates each variable independently at "0 to 1" scale    |
//| while MDI (and OOB-MDI too) tends to divide "unit amount of      |
//| importance" between several important variables.                 |
//| If all variables are equally important, they will have same      |
//| MDI/OOB-MDI rating, equal (for OOB-MDI: roughly equal)  to       |
//| 1/NVars. However, roughly  same  picture  will  be  produced for |
//| the "all variables provide information no one is critical"       |
//| situation and for the "all variables are critical, drop any one, |
//| everything is ruined" situation.                                 |
//| Contrary to that, MDA will rate critical variable as ~1.0        |
//| important, and important but non-critical variable will have less|
//| than unit rating.                                                |
//| NOTE: quite an often MDA and MDI return same results. It         |
//|       generally happens on problems with low test set error      |
//|       (a few percents at most) and large enough training set     |
//|       to avoid overfitting.                                      |
//| The difference between MDA, MDI and OOB-MDI becomes important    |
//| only on "hard" tasks with high test set error and/or small       |
//| training set.                                                    |
//| INPUT PARAMETERS:                                                |
//|   S        -  decision forest builder object                     |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  decision forest builder object. Next call to the   |
//|               forest construction function will produce:         |
//|         * importance estimates in rep.varimportances field       |
//|         * variable ranks in rep.topvars field                    |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetImportanceTrnGini(CDecisionForestBuilder &s)
  {
   CDForest::DFBuilderSetImportanceTrnGini(s);
  }
//+------------------------------------------------------------------+
//| This function tells decision forest construction algorithm to use|
//| out-of-bag version of Gini variable importance estimation (also  |
//| known as OOB-MDI).                                               |
//| This version of importance estimation algorithm analyzes mean    |
//| decrease in impurity (MDI) on out-of-bag sample during splits.   |
//| The result is divided by impurity at the root node in order to   |
//| produce estimate in [0,1] range.                                 |
//| Such estimates are fast to calculate and resistant to overfitting|
//| issues (thanks to the out-of-bag estimates used). However, OOB   |
//| Gini rating has following downsides:                             |
//|         * there exist some bias towards continuous and           |
//|           high-cardinality categorical variables                 |
//|         * Gini rating allows us to order variables by importance,|
//|           but it is hard to define importance of the variable by |
//|           itself.                                                |
//| NOTE: informally speaking, MDA (permutation importance) rating   |
//|       answers the question "what part of the model predictive    |
//|       power is ruined by permuting k-th variable?" while MDI     |
//|       tells us "what part of the model predictive power was      |
//|       achieved due to usage of k-th variable".                   |
//| Thus, MDA rates each variable independently at "0 to 1" scale    |
//| while MDI (and OOB-MDI too) tends to divide "unit amount of      |
//| importance" between several important variables.                 |
//| If all variables are equally important, they will have same      |
//| MDI/OOB-MDI rating, equal (for OOB-MDI: roughly equal) to        |
//| 1/NVars. However, roughly same picture will be produced for the  |
//| "all variables provide information no one is critical" situation |
//| and for the "all variables are critical, drop any one, everything|
//| is ruined" situation.                                            |
//| Contrary to that, MDA will rate critical variable as ~1.0        |
//| important, and important but non-critical variable will have less|
//| than unit rating.                                                |
//| NOTE: quite an often MDA and MDI return same results. It         |
//|       generally happens on problems with low test set error      |
//|       (a few percents at most) and large enough training set to  |
//|       avoid overfitting.                                         |
//| The difference between MDA, MDI and OOB-MDI becomes important    |
//| only on "hard" tasks with high test set error and/or small       |
//| training set.                                                    |
//| INPUT PARAMETERS:                                                |
//|   S           -  decision forest builder object                  |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  decision forest builder object. Next call to the|
//|                  forest construction function will produce:      |
//|            * importance estimates in rep.varimportances field    |
//|            * variable ranks in rep.topvars field                 |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetImportanceOOBGini(CDecisionForestBuilder &s)
  {
   CDForest::DFBuilderSetImportanceOOBGini(s);
  }
//+------------------------------------------------------------------+
//| This function tells decision forest construction algorithm to use|
//| permutation variable importance estimator (also known as MDA).   |
//| This version of importance estimation algorithm analyzes mean    |
//| increase in out-of-bag sum of squared residuals after random     |
//| permutation of J-th variable. The result is divided by error     |
//| computed with all variables being perturbed in order to produce  |
//| R-squared-like estimate in [0,1] range.                          |
//| Such estimate is slower to calculate than Gini-based rating      |
//| because it needs multiple inference runs for each of variables   |
//| being studied.                                                   |
//| MDA rating has following benefits over Gini-based ones:          |
//|      * no bias towards specific variable types                   |
//|     *ability to directly evaluate "absolute" importance of some|
//|        variable at "0 to 1" scale (contrary to Gini-based rating,|
//|        which returns comparative importances).                   |
//| NOTE: informally speaking, MDA (permutation importance) rating   |
//|       answers the question "what part of the model predictive    |
//|       power is ruined by permuting k-th variable?" while MDI     |
//|       tells us "what part of the model predictive power was      |
//|       achieved due to usage of k-th variable".                   |
//| Thus, MDA rates each variable independently at "0 to 1" scale    |
//| while MDI (and OOB-MDI too) tends to divide "unit amount  of     |
//| importance" between several important variables.                 |
//| If all variables are equally important, they will have same      |
//| MDI/OOB-MDI rating, equal (for OOB-MDI: roughly equal)  to       |
//| 1/NVars. However, roughly same picture will be produced forthe   |
//| "all variables provide information no one is critical" situation |
//| and for the "all variables are critical, drop any one, everything|
//| is ruined" situation.                                            |
//| Contrary to that, MDA will rate critical variable as ~1.0        |
//| important, and important but non-critical variable will have less|
//| than unit rating.                                                |
//| NOTE: quite an often MDA and MDI return same results. It         |
//|       generally happens on problems with low test set error      |
//|       (a few percents at most) and large enough training set     |
//|       to avoid overfitting.                                      |
//| The difference between MDA, MDI and OOB-MDI becomes important    |
//| only on "hard" tasks with high test set error and/or small       |
//| training set.                                                    |
//| INPUT PARAMETERS:                                                |
//|   S           -  decision forest builder object                  |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  decision forest builder object. Next call to    |
//|                  the forest construction function will produce:  |
//|            * importance estimates in rep.varimportances field    |
//|            * variable ranks in rep.topvars field                 |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetImportancePermutation(CDecisionForestBuilder &s)
  {
   CDForest::DFBuilderSetImportancePermutation(s);
  }
//+------------------------------------------------------------------+
//| This function tells decision forest construction algorithm to    |
//| skip variable importance estimation.                             |
//| INPUT PARAMETERS:                                                |
//|   S        -  decision forest builder object                     |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  decision forest builder object. Next call to the   |
//|               forest construction function will result in forest |
//|               being built without variable importance estimation.|
//+------------------------------------------------------------------+
void CAlglib::DFBuilderSetImportanceNone(CDecisionForestBuilder &s)
  {
   CDForest::DFBuilderSetImportanceNone(s);
  }
//+------------------------------------------------------------------+
//| This function is an alias for dfbuilderpeekprogress(), left in   |
//| ALGLIB for backward compatibility reasons.                       |
//+------------------------------------------------------------------+
double CAlglib::DFBuilderGetProgress(CDecisionForestBuilder &s)
  {
   return(CDForest::DFBuilderGetProgress(s));
  }
//+------------------------------------------------------------------+
//| This function is used to peek into decision forest construction  |
//| process from some other thread and get current progress indicator|
//| It returns value in [0,1].                                       |
//| INPUT PARAMETERS:                                                |
//|   S        -  decision forest builder object used to build forest|
//|               in some other thread                               |
//| RESULT:                                                          |
//|   progress value, in [0,1]                                       |
//+------------------------------------------------------------------+
double CAlglib::DFBuilderPeekProgress(CDecisionForestBuilder &s)
  {
   return(CDForest::DFBuilderPeekProgress(s));
  }
//+------------------------------------------------------------------+
//| This subroutine builds decision forest according to current      |
//| settings using dataset internally stored in the builder object.  |
//| Dense algorithm is used.                                         |
//| NOTE: this function uses dense algorithm for forest construction |
//|       independently from the dataset format (dense or sparse).   |
//| NOTE: forest built with this function is stored in-memory using  |
//|       64-bit data structures for offsets/indexes/split values. It|
//|       is possible to convert forest into more memory-efficient   |
//|       compressed binary representation. Depending on the problem |
//|       properties, 3.7x-5.7x compression factors are possible.    |
//| The downsides of compression are (a) slight reduction in  the    |
//| model accuracy and (b) ~1.5x reduction in the inference speed    |
//| (due to increased complexity of the storage format).             |
//| See comments on DFBinaryCompression() for more info.             |
//| Default settings are used by the algorithm; you can tweak them   |
//| with the help of the following functions:                        |
//|   * DFBuilderSetRFactor()    - to control a fraction of the      |
//|                                dataset used for subsampling      |
//|   * DFBuilderSetRandomVars() - to control number of variables    |
//|                                randomly chosen for decision rule |
//|                                creation                          |
//| INPUT PARAMETERS:                                                |
//|   S        -  decision forest builder object                     |
//|   NTrees   -  NTrees>=1, number of trees to train                |
//| OUTPUT PARAMETERS:                                               |
//|   D        -  decision forest. You can compress this forest to   |
//|               more compact 16-bit representation with            |
//|               DFBinaryCompression()                              |
//|   Rep      -  report, see below for information on its fields.   |
//| == report information produced by forest construction function = |
//| Decision forest training report includes following information:  |
//|      * training set errors                                       |
//|      * out-of-bag estimates of errors                            |
//|      * variable importance ratings                               |
//| Following fields are used to store information:                  |
//|   * training set errors are stored in rep.RelCLSError, rep.AvgCE,|
//|     rep.RMSError, rep.AvgError and rep.AvgRelError               |
//|   * out-of-bag estimates of errors are stored in                 |
//|     rep.oobrelclserror, rep.oobavgce, rep.oobrmserror,           |
//|     rep.oobavgerror and rep.oobavgrelerror                       |
//| Variable importance reports, if requested by                     |
//| DFBuilderSetImportanceGini(), DFBuilderSetImportanceTrnGini() or |
//| DFBuilderSetImportancePermutation() call, are stored in:         |
//|   * rep.varimportances field stores importance ratings           |
//|   * rep.topvars stores variable indexes ordered from the most    |
//|     important to less important ones                             |
//| You can find more information about report fields in:            |
//|   * comments on CDFReport structure                              |
//|   * comments on DFBuilderSetImportanceGini function              |
//|   * comments on DFBuilderSetImportanceTrnGini function           |
//|   * comments on DFBuilderDetImportancePermutation function       |
//+------------------------------------------------------------------+
void CAlglib::DFBuilderBuildRandomForest(CDecisionForestBuilder &s,int ntrees,
                                         CDecisionForestShell &df,
                                         CDFReportShell &rep)
  {
   CDForest::DFBuilderBuildRandomForest(s,ntrees,df.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function performs binary compression of the decision forest.|
//| Original decision forest produced by the forest builder is stored|
//| using 64-bit representation for all numbers - offsets, variable  |
//| indexes, split points.                                           |
//| It is possible to significantly reduce model size by means of:   |
//|   * using compressed dynamic encoding for integers (offsets and  |
//|     variable indexes), which uses just 1 byte to store small ints|
//|     (less than 128), just 2 bytes for larger values (less than   |
//|     128^2) and so on                                             |
//|   * storing floating point numbers using 8-bit exponent and      |
//|     16-bit mantissa                                              |
//| As result, model needs significantly less memory (compression    |
//| factor depends on  variable and class counts). In particular:    |
//|   * NVars<128 and NClasses<128 result in 4.4x-5.7x model size    |
//|     reduction                                                    |
//|   * NVars<16384 and NClasses<128 result in 3.7x-4.5x model size  |
//|     reduction                                                    |
//| Such storage format performs lossless compression of all integers|
//| but compression of floating point values (split values) is lossy,|
//| with roughly 0.01% relative error introduced during rounding.    |
//| Thus, we recommend you to re-evaluate model accuracy after       |
//| compression.                                                     |
//| Another downside of compression is ~1.5x reduction in the        |
//| inference speed due to necessity of dynamic decompression of the |
//| compressed model.                                                |
//| INPUT PARAMETERS:                                                |
//|   DF       -  decision forest built by forest builder            |
//| OUTPUT PARAMETERS:                                               |
//|   DF       -  replaced by compressed forest                      |
//| RESULT:                                                          |
//| compression factor (in-RAM size of the compressed model vs than  |
//| of the uncompressed one), positive number larger than 1.0        |
//+------------------------------------------------------------------+
double CAlglib::DFBinaryCompression(CDecisionForestShell &df)
  {
   return(CDForest::DFBinaryCompression(df.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| Procesing                                                        |
//| INPUT PARAMETERS:                                                |
//|     DF      -   decision forest model                            |
//|     X       -   input vector,  array[0..NVars-1].                |
//| OUTPUT PARAMETERS:                                               |
//|     Y       -   result. Regression estimate when solving         |
//|                 regression task, vector of posterior             |
//|                 probabilities for classification task.           |
//| See also DFProcessI.                                             |
//+------------------------------------------------------------------+
void CAlglib::DFProcess(CDecisionForestShell &df,double &x[],
                        double &y[])
  {
   CDForest::DFProcess(df.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//| 'interactive' variant of DFProcess for languages like Python     |
//| which support constructs like "Y = DFProcessI(DF,X)" and         |
//| interactive mode of interpreter                                  |
//| This function allocates new array on each call, so it is         |
//| significantly slower than its 'non-interactive' counterpart, but |
//| it is more convenient when you call it from command line.        |
//+------------------------------------------------------------------+
void CAlglib::DFProcessI(CDecisionForestShell &df,
                         double &x[],double &y[])
  {
   CDForest::DFProcessI(df.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//|  This function returns first component of the inferred vector    |
//| (i.e. one with index #0).                                        |
//| It is a convenience wrapper for dfprocess() intended for either: |
//|      * 1-dimensional regression problems                         |
//|      * 2-class classification problems                           |
//| In the former case this function returns inference result as     |
//| scalar, which is definitely more convenient that wrapping it as  |
//| vector. In the latter case it returns probability of object      |
//| belonging to class #0.                                           |
//| If you call it for anything different from two cases above, it   |
//| will work as defined, i.e. return y[0], although it is of less   |
//| use in such cases.                                               |
//| INPUT PARAMETERS:                                                |
//|   Model    -  DF model                                           |
//|   X        -  input vector,  array[0..NVars-1].                  |
//| RESULT:                                                          |
//|   Y[0]                                                           |
//+------------------------------------------------------------------+
double CAlglib::DFProcess0(CDecisionForestShell &model,double &X[])
  {
   CRowDouble x=X;
   return(CDForest::DFProcess0(model.GetInnerObj(),x));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CAlglib::DFProcess0(CDecisionForestShell &model,CRowDouble &x)
  {
   return(CDForest::DFProcess0(model.GetInnerObj(),x));
  }
//+------------------------------------------------------------------+
//| This function returns most probable class number for an input X. |
//| It is same as calling DFProcess(model,x,y), then determining     |
//| i=ArgMax(y[i]) and returning i.                                  |
//| A class number in [0,NOut) range in returned for classification  |
//| problems, -1 is returned when this function is called for        |
//| regression problems.                                             |
//| INPUT PARAMETERS:                                                |
//|   Model    -  decision forest model                              |
//|   X        -  input vector,  array[0..NVars-1].                  |
//| RESULT:                                                          |
//|   class number, -1 for regression tasks                          |
//+------------------------------------------------------------------+
int CAlglib::DFClassify(CDecisionForestShell &model,double &X[])
  {
   CRowDouble x=X;
   return(CDForest::DFClassify(model.GetInnerObj(),x));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CAlglib::DFClassify(CDecisionForestShell &model,CRowDouble &x)
  {
   return(CDForest::DFClassify(model.GetInnerObj(),x));
  }
//+------------------------------------------------------------------+
//| Relative classification error on the test set                    |
//| INPUT PARAMETERS:                                                |
//|     DF      -   decision forest model                            |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     percent of incorrectly classified cases.                     |
//|     Zero if model solves regression task.                        |
//+------------------------------------------------------------------+
double CAlglib::DFRelClsError(CDecisionForestShell &df,CMatrixDouble &xy,
                              const int npoints)
  {
   return(CDForest::DFRelClsError(df.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average cross-entropy (in bits per element) on the test set      |
//| INPUT PARAMETERS:                                                |
//|     DF      -   decision forest model                            |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     CrossEntropy/(NPoints*LN(2)).                                |
//|     Zero if model solves regression task.                        |
//+------------------------------------------------------------------+
double CAlglib::DFAvgCE(CDecisionForestShell &df,CMatrixDouble &xy,
                        const int npoints)
  {
   return(CDForest::DFAvgCE(df.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| RMS error on the test set                                        |
//| INPUT PARAMETERS:                                                |
//|     DF      -   decision forest model                            |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     root mean square error.                                      |
//|     Its meaning for regression task is obvious. As for           |
//|     classification task,RMS error means error when estimating    |
//|     posterior probabilities.                                     |
//+------------------------------------------------------------------+
double CAlglib::DFRMSError(CDecisionForestShell &df,CMatrixDouble &xy,
                           const int npoints)
  {
   return(CDForest::DFRMSError(df.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average error on the test set                                    |
//| INPUT PARAMETERS:                                                |
//|     DF      -   decision forest model                            |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     Its meaning for regression task is obvious. As for           |
//|     classification task, it means average error when estimating  |
//|     posterior probabilities.                                     |
//+------------------------------------------------------------------+
double CAlglib::DFAvgError(CDecisionForestShell &df,CMatrixDouble &xy,
                           const int npoints)
  {
   return(CDForest::DFAvgError(df.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average relative error on the test set                           |
//| INPUT PARAMETERS:                                                |
//|     DF      -   decision forest model                            |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     Its meaning for regression task is obvious. As for           |
//|     classification task, it means average relative error when    |
//|     estimating posterior probability of belonging to the correct |
//|     class.                                                       |
//+------------------------------------------------------------------+
double CAlglib::DFAvgRelError(CDecisionForestShell &df,CMatrixDouble &xy,
                              const int npoints)
  {
   return(CDForest::DFAvgRelError(df.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| This subroutine builds random decision forest.                   |
//| ---- DEPRECATED VERSION! USE DECISION FOREST BUILDER OBJECT ---- |
//+------------------------------------------------------------------+
void CAlglib::DFBuildRandomDecisionForest(CMatrixDouble &xy,const int npoints,
                                          const int nvars,const int nclasses,
                                          const int ntrees,const double r,
                                          int &info,CDecisionForestShell &df,
                                          CDFReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CDForest::DFBuildRandomDecisionForest(xy,npoints,nvars,nclasses,ntrees,r,info,df.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine builds random decision forest.                   |
//| ---- DEPRECATED VERSION! USE DECISION FOREST BUILDER OBJECT ---- |
//+------------------------------------------------------------------+
void CAlglib::DFBuildRandomDecisionForestX1(CMatrixDouble &xy,
                                            const int npoints,
                                            const int nvars,
                                            const int nclasses,
                                            const int ntrees,
                                            int nrndvars,
                                            const double r,
                                            int &info,
                                            CDecisionForestShell &df,
                                            CDFReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CDForest::DFBuildRandomDecisionForestX1(xy,npoints,nvars,nclasses,ntrees,nrndvars,r,info,df.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function initializes clusterizer object. Newly initialized  |
//| object is empty, i.e. it does not contain dataset. You should    |
//| use it as follows:                                               |
//|   1. creation                                                    |
//|   2. dataset is added with ClusterizerSetPoints()                |
//|   3. additional parameters are set                               |
//|   3. clusterization is performed with one of the clustering      |
//|      functions                                                   |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerCreate(CClusterizerState &s)
  {
   CClustering::ClusterizerCreate(s);
  }
//+------------------------------------------------------------------+
//| This function adds dataset to the clusterizer structure.         |
//| This function overrides all previous calls of                    |
//| ClusterizerSetPoints() or ClusterizerSetDistances().             |
//| INPUT PARAMETERS:                                                |
//|   S        -  clusterizer state, initialized by                  |
//|               ClusterizerCreate()                                |
//|   XY       -  array[NPoints,NFeatures], dataset                  |
//|   NPoints  -  number of points, >=0                              |
//|   NFeatures-  number of features, >=1                            |
//|   DistType -  distance function:                                 |
//|               *  0    Chebyshev distance  (L-inf norm)           |
//|               *  1    city block distance (L1 norm)              |
//|               *  2    Euclidean distance  (L2 norm), non-squared |
//|               * 10    Pearson correlation:                       |
//|                       dist(a,b) = 1-corr(a,b)                    |
//|               * 11    Absolute Pearson correlation:              |
//|                       dist(a,b) = 1-|corr(a,b)|                  |
//|               * 12    Uncentered Pearson correlation (cosine of  |
//|                       the angle): dist(a,b) = a'*b/(|a|*|b|)     |
//|               * 13    Absolute uncentered Pearson correlation    |
//|                       dist(a,b) = |a'*b|/(|a|*|b|)               |
//|               * 20    Spearman rank correlation:                 |
//|                       dist(a,b) = 1-rankcorr(a,b)                |
//|               * 21    Absolute Spearman rank correlation         |
//|                       dist(a,b) = 1-|rankcorr(a,b)|              |
//| NOTE 1: different distance functions have different performance  |
//|         penalty:                                                 |
//|         * Euclidean or Pearson correlation distances are         |
//|           the fastest ones                                       |
//|         * Spearman correlation distance function is a bit slower |
//|         * city block and Chebyshev distances are order           |
//|           of magnitude slower                                    |
//|         The reason behing difference in performance is that      |
//|         correlation-based distance functions are computed using  |
//|         optimized linear algebra kernels, while Chebyshev and    |
//|         city block distance functions are computed using simple  |
//|         nested loops with two branches at each iteration.        |
//| NOTE 2: different clustering algorithms have different           |
//|         limitations:                                             |
//|         * agglomerative hierarchical clustering algorithms may   |
//|           be used with any kind of distance metric               |
//|         * k-means++ clustering algorithm may be used only with   |
//|           Euclidean distance function                            |
//|         Thus, list of specific clustering algorithms you may use |
//|         depends on distance function you specify when you set    |
//|         your dataset.                                            |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerSetPoints(CClusterizerState &s,CMatrixDouble &xy,
                                   int npoints,int nfeatures,int disttype)
  {
   CClustering::ClusterizerSetPoints(s,xy,npoints,nfeatures,disttype);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerSetPoints(CClusterizerState &s,CMatrixDouble &xy,int disttype)
  {
//--- create variables
   int npoints=CAp::Rows(xy);
   int nfeatures=CAp::Cols(xy);
//--- function call
   CClustering::ClusterizerSetPoints(s,xy,npoints,nfeatures,disttype);
  }
//+------------------------------------------------------------------+
//| This function adds dataset given by distance matrix to the       |
//| clusterizer structure. It is important that dataset is not given |
//| explicitly - only distance matrix is given.                      |
//| This function overrides all previous calls  of                   |
//| ClusterizerSetPoints() or ClusterizerSetDistances().             |
//| INPUT PARAMETERS:                                                |
//|   S        -  clusterizer state, initialized by                  |
//|               ClusterizerCreate()                                |
//|   D        -  array[NPoints,NPoints], distance matrix given by   |
//|               its upper or lower triangle (main diagonal is      |
//|               ignored because its entries are expected to        |
//|               be zero).                                          |
//|   NPoints  -  number of points                                   |
//|   IsUpper  -  whether upper or lower triangle of D is given.     |
//| NOTE 1: different clustering algorithms have different           |
//|         limitations:                                             |
//|         * agglomerative hierarchical clustering algorithms may   |
//|           be used with any kind of distance metric, including    |
//|           one which is given by distance matrix                  |
//|         * k-means++ clustering algorithm may be used only with   |
//|           Euclidean distance function and explicitly given       |
//|           points - it can not be used with dataset given by      |
//|           distance matrix. Thus, if you call this function, you  |
//|           will be unable to use k-means clustering algorithm     |
//|           to process your problem.                               |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerSetDistances(CClusterizerState &s,CMatrixDouble &d,int npoints,bool IsUpper)
  {
   CClustering::ClusterizerSetDistances(s,d,npoints,IsUpper);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerSetDistances(CClusterizerState &s,CMatrixDouble &d,bool IsUpper)
  {
//--- check
   if(!CAp::Assert(CAp::Rows(d)==CAp::Cols(d),"Error while calling 'ClusterizerSetDistances': looks like one of arguments has wrong size"))
      return;
//--- initialization
   int npoints=CAp::Rows(d);
//--- function call
   CClustering::ClusterizerSetDistances(s,d,npoints,IsUpper);
  }
//+------------------------------------------------------------------+
//| This function sets agglomerative hierarchical clustering         |
//| algorithm                                                        |
//| INPUT PARAMETERS:                                                |
//|   S     -  clusterizer state, initialized by ClusterizerCreate() |
//|   Algo  -  algorithm type:                                       |
//|            * 0     complete linkage(default algorithm)           |
//|            * 1     single linkage                                |
//|            * 2     unweighted average linkage                    |
//|            * 3     weighted average linkage                      |
//|            * 4     Ward's method                                 |
//| NOTE: Ward's method works correctly only with Euclidean distance,|
//|       that's why algorithm will return negative termination      |
//|       code(failure) for any other distance type.                 |
//| It is possible, however, to use this method with user - supplied |
//| distance matrix. It is your responsibility to pass one which was |
//| calculated with Euclidean distance function.                     |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerSetAHCAlgo(CClusterizerState &s,int algo)
  {
   CClustering::ClusterizerSetAHCAlgo(s,algo);
  }
//+------------------------------------------------------------------+
//| This  function  sets k-means properties:                         |
//|      number  of  restarts and maximum                            |
//|      number of iterations per one run.                           |
//| INPUT PARAMETERS:                                                |
//|   S        -  clusterizer state, initialized by                  |
//|               ClusterizerCreate()                                |
//|   Restarts -  restarts count, >= 1.                              |
//|               k-means++ algorithm performs several restarts      |
//|               and chooses best set of centers(one with minimum   |
//|               squared distance).                                 |
//|   MaxIts   -  maximum number of k-means iterations performed     |
//|               during one run. >= 0, zero value means that        |
//|               algorithm performs unlimited number of iterations. |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerSetKMeansLimits(CClusterizerState &s,int restarts,int maxits)
  {
   CClustering::ClusterizerSetKMeansLimits(s,restarts,maxits);
  }
//+------------------------------------------------------------------+
//| This function sets k-means initialization algorithm. Several     |
//| different algorithms can be chosen, including k-means++.         |
//| INPUT PARAMETERS:                                                |
//|   S        -  clusterizer state, initialized by                  |
//|               ClusterizerCreate()                                |
//|   InitAlgo -  initialization algorithm:                          |
//|      * 0  automatic selection(different  versions  of  ALGLIB    |
//|           may select different algorithms)                       |
//|      * 1  random initialization                                  |
//|      * 2  k-means++ initialization(best  quality  of  initial    |
//|           centers, but long  non-parallelizable initialization   |
//|           phase with bad cache locality)                         |
//|     *3  "fast-greedy" algorithm with efficient, easy to        |
//|           parallelize initialization. Quality of initial centers |
//|           is somewhat worse than that of k-means++. This         |
//|           algorithm is a default one in the current version of   |
//|           ALGLIB.                                                |
//|     *-1 "debug" algorithm which always selects first K rows    |
//|           of dataset; this algorithm is used for debug purposes  |
//|           only. Do not use it in the industrial code!            |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerSetKMeansInit(CClusterizerState &s,int initalgo)
  {
   CClustering::ClusterizerSetKMeansInit(s,initalgo);
  }
//+------------------------------------------------------------------+
//| This function sets seed which is used to initialize internal RNG.|
//| By default, deterministic seed is used - same for each run of    |
//| clusterizer. If you specify non-deterministic seed value, then   |
//| some algorithms which depend on random initialization(in current |
//| version : k-means) may return slightly different results after   |
//| each run.                                                        |
//| INPUT PARAMETERS:                                                |
//|   S        -  clusterizer state, initialized by                  |
//|               ClusterizerCreate()                                |
//|   Seed     -  seed:                                              |
//|               * positive values = use deterministic seed for each|
//|                 run of algorithms which depend on random         |
//|                 initialization                                   |
//|               * zero or negative values = use non-deterministic  |
//|                 seed                                             |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerSetSeed(CClusterizerState &s,int seed)
  {
   CClustering::ClusterizerSetSeed(s,seed);
  }
//+------------------------------------------------------------------+
//| This function performs agglomerative hierarchical clustering     |
//| NOTE: Agglomerative hierarchical clustering algorithm has two    |
//|       phases: distance matrix calculation and clustering itself. |
//| INPUT PARAMETERS:                                                |
//|   S        -  clusterizer state, initialized by                  |
//|               ClusterizerCreate()                                |
//| OUTPUT PARAMETERS:                                               |
//|   Rep      -  clustering results; see description of AHCReport   |
//|               structure for more information.                    |
//| NOTE 1: hierarchical clustering algorithms require large amounts |
//|         of memory. In particular, this implementation needs      |
//|         sizeof(double) *NPoints^2 bytes, which are used to store |
//|         distance matrix. In case we work with user - supplied    |
//|         matrix, this amount is multiplied by 2 (we have to store |
//|         original matrix and to work with its copy).              |
//|         For example, problem with 10000 points would require 800M|
//|         of RAM, even when working in a 1-dimensional space.      |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerRunAHC(CClusterizerState &s,CAHCReport &rep)
  {
   CClustering::ClusterizerRunAHC(s,rep);
  }
//+------------------------------------------------------------------+
//| This function performs clustering by k-means++ algorithm.        |
//| You may change algorithm properties by calling:                  |
//|      * ClusterizerSetKMeansLimits() to change number of restarts |
//|        or iterations                                             |
//|      * ClusterizerSetKMeansInit() to change initialization       |
//|        algorithm                                                 |
//| By default, one restart and unlimited number of iterations are   |
//| used. Initialization algorithm is chosen automatically.          |
//| NOTE: k-means clustering algorithm has two phases: selection of  |
//|       initial centers and clustering itself.                     |
//| INPUT PARAMETERS:                                                |
//|   S        -  clusterizer state, initialized by                  |
//|               ClusterizerCreate()                                |
//|   K        -  number of clusters, K >= 0.                        |
//|               K can be zero only when algorithm is called for    |
//|               empty dataset, in this case completion code is set |
//|               to success(+1).                                    |
//|               If K = 0 and dataset size is non-zero, we can not  |
//|               meaningfully assign points to some center(there are|
//|               no centers because K = 0) and return -3 as         |
//|               completion code (failure).                         |
//| OUTPUT PARAMETERS:                                               |
//|   Rep      -  clustering results; see description of KMeansReport|
//|               structure for more information.                    |
//| NOTE 1: k-means clustering can be performed only for datasets    |
//|         with Euclidean distance function. Algorithm will return  |
//|         negative completion code in Rep.TerminationType in case  |
//|         dataset was added to clusterizer with DistType other     |
//|         than Euclidean (or dataset was specified by distance     |
//|         matrix instead of explicitly given points).              |
//| NOTE 2: by default, k-means uses non-deterministic seed to       |
//|         initialize RNG which is used to select initial centers.  |
//|         As result, each run of algorithm may return different    |
//|         values. If you  need  deterministic behavior, use        |
//|         ClusterizerSetSeed() function.                           |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerRunKMeans(CClusterizerState &s,int k,CKmeansReport &rep)
  {
   CClustering::ClusterizerRunKMeans(s,k,rep);
  }
//+------------------------------------------------------------------+
//| This function returns distance matrix for dataset                |
//| INPUT PARAMETERS:                                                |
//|   XY       -  array[NPoints, NFeatures], dataset                 |
//|   NPoints  -  number of points, >= 0                             |
//|   NFeatures-  number of features, >= 1                           |
//|   DistType -  distance function:                                 |
//|               *  0    Chebyshev distance(L - inf norm)           |
//|               *  1    city block distance(L1 norm)               |
//|               *  2    Euclidean distance(L2 norm, non - squared) |
//|               * 10    Pearson correlation:                       |
//|                       dist(a, b) = 1 - corr(a, b)                |
//|               * 11    Absolute Pearson correlation:              |
//|                       dist(a, b) = 1 - |corr(a, b)|              |
//|               * 12    Uncentered Pearson correlation(cosine of   |
//|                       the angle): dist(a, b) = a'*b/(|a|*|b|)    |
//|               * 13    Absolute uncentered Pearson correlation    |
//|                       dist(a, b) = |a'*b|/(|a|*|b|)              |
//|               * 20    Spearman rank correlation:                 |
//|                       dist(a, b) = 1 - rankcorr(a, b)            |
//|               * 21    Absolute Spearman rank correlation         |
//|                       dist(a, b) = 1 - |rankcorr(a, b)|          |
//| OUTPUT PARAMETERS:                                               |
//|   D        -  array[NPoints, NPoints], distance matrix (full     |
//|               matrix is returned, with lower and upper triangles)|
//| NOTE: different distance functions have different performance    |
//|       penalty:                                                   |
//|      * Euclidean or Pearson correlation distances are the fastest|
//|        ones                                                      |
//|      * Spearman correlation distance function is a bit slower    |
//|      * city block and Chebyshev distances are order of magnitude |
//|        slower                                                    |
//| The reason behing difference in performance is that correlation -|
//| based distance functions are computed using optimized linear     |
//| algebra kernels, while Chebyshev and city block distance         |
//| functions are computed using simple nested loops with two        |
//| branches at each iteration.                                      |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerGetDistances(CMatrixDouble &xy,int npoints,
                                      int nfeatures,int disttype,
                                      CMatrixDouble &d)
  {
   d.Resize(0,0);
   CClustering::ClusterizerGetDistances(xy,npoints,nfeatures,disttype,d);
  }
//+------------------------------------------------------------------+
//| This function takes as input clusterization report Rep, desired  |
//| clusters count K, and builds top K clusters from hierarchical    |
//| clusterization tree.                                             |
//| It returns assignment of points to clusters(array of cluster     |
//| indexes).                                                        |
//| INPUT PARAMETERS:                                                |
//|   Rep     -  report from ClusterizerRunAHC() performed on XY     |
//|   K       -   desired number of clusters, 1 <= K <= NPoints.     |
//|               K can be zero only when NPoints = 0.               |
//| OUTPUT PARAMETERS:                                               |
//|   CIdx    -   array[NPoints], I-th element contains cluster      |
//|               index(from 0 to K-1) for I-th point of the dataset.|
//|   CZ      -   array[K]. This array allows  to  convert  cluster  |
//|               indexes returned by this function to indexes used  |
//|               by Rep.Z. J-th cluster returned by this function   |
//|               corresponds to CZ[J]-th cluster stored in          |
//|               Rep.Z/PZ/PM. It is guaranteed that CZ[I] < CZ[I+1].|
//| NOTE: K clusters built by this subroutine are assumed to have no |
//|       hierarchy. Although they were obtained by manipulation with|
//|       top K nodes of dendrogram(i.e. hierarchical decomposition  |
//|       of dataset), this function does not return information     |
//|       about hierarchy. Each of the clusters stand on its own.    |
//| NOTE: Cluster indexes returned by this function does not         |
//|       correspond to indexes returned in Rep.Z/PZ/PM. Either you  |
//|       work with hierarchical representation of the dataset       |
//|       (dendrogram), or you work with "flat" representation       |
//|       returned by this function. Each of representations has its |
//|       own clusters indexing system(former uses [0,2*NPoints-2]), |
//|       while latter uses [0..K-1]), although it is possible to    |
//|       perform conversion from one system to another by means of  |
//|       CZ array, returned by this function, which allows you to   |
//|       convert indexes stored in CIdx to the numeration system    |
//|       used by Rep.Z.                                             |
//| NOTE: this subroutine is optimized for moderate values of K.     |
//|       Say, for K=5 it will perform many times faster than for    |
//|       K=100. Its worst - case performance is O(N*K), although in |
//|       average case it perform better (up to O(N*log(K))).        |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerGetKClusters(CAHCReport &rep,int k,CRowInt &cidx,CRowInt &cz)
  {
   cidx.Resize(0);
   cz.Resize(0);
   CClustering::ClusterizerGetKClusters(rep,k,cidx,cz);
  }
//+------------------------------------------------------------------+
//| This function accepts AHC report Rep, desired minimum            |
//| intercluster distance and returns top clusters from hierarchical |
//| clusterization tree which are separated by distance R or HIGHER. |
//| It returns assignment of points to clusters (array of cluster    |
//| indexes).                                                        |
//| There is one more function with similar name -                   |
//| ClusterizerSeparatedByCorr, which returns clusters with          |
//| intercluster correlation equal to R or LOWER (note: higher for   |
//| distance, lower for correlation).                                |
//| INPUT PARAMETERS:                                                |
//|   Rep      -  report from ClusterizerRunAHC() performed on XY    |
//|   R        -   desired minimum intercluster distance, R >= 0     |
//| OUTPUT PARAMETERS:                                               |
//|   K        -  number of clusters, 1 <= K <= NPoints              |
//|   CIdx     -  array[NPoints], I-th element contains cluster      |
//|               index (from 0 to K-1) for I-th point of the dataset|
//|   CZ       -  array[K]. This array allows to convert cluster     |
//|               indexes returned by this function to indexes used  |
//|               by Rep.Z. J-th cluster returned by this function   |
//|               corresponds to CZ[J]-th cluster stored in          |
//|               Rep.Z/PZ/PM. It is guaranteed that CZ[I] < CZ[I+1].|
//| NOTE: K clusters built by this subroutine are assumed to have no |
//|       hierarchy. Although they were obtained by manipulation with|
//|       top K nodes of dendrogram (i.e. hierarchical decomposition |
//|       of dataset), this function does not return information     |
//|       about hierarchy. Each of the clusters stand on its own.    |
//| NOTE: Cluster indexes returned by this function does not         |
//|       correspond to indexes returned in Rep.Z/PZ/PM. Either you  |
//|       work with hierarchical representation of the dataset       |
//|       (dendrogram), or you work with "flat" representation       |
//|       returned by this function. Each of representations has its |
//|       own clusters indexing system (former uses [0,2*NPoints-2]),|
//|       while latter uses [0..K-1]), although it is possible to    |
//|       perform conversion from one system to another by means of  |
//|       CZ array, returned by this function, which allows you to   |
//|       convert indexes stored in CIdx to the numeration system    |
//|       used by Rep.Z.                                             |
//| NOTE: this subroutine is optimized for moderate values of K. Say,|
//|       for K=5 it will perform many times faster than for K=100.  |
//|       Its worst - case performance is O(N*K), although in average|
//|       case it perform better (up to O(N*log(K))).                |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerSeparatedByDist(CAHCReport &rep,double r,int &k,
                                         CRowInt &cidx,CRowInt &cz)
  {
   k=0;
   cidx.Resize(0);
   cz.Resize(0);
   CClustering::ClusterizerSeparatedByDist(rep,r,k,cidx,cz);
  }
//+------------------------------------------------------------------+
//| This function accepts AHC report Rep, desired maximum            |
//| intercluster correlation and returns top clusters from           |
//| hierarchical clusterization tree which are separated by          |
//| correlation R or LOWER.                                          |
//| It returns assignment of points to clusters(array of cluster     |
//| indexes).                                                        |
//| There is one more function with similar name -                   |
//| ClusterizerSeparatedByDist, which returns clusters with          |
//| intercluster distance equal to R or HIGHER (note: higher for     |
//| distance, lower for correlation).                                |
//| INPUT PARAMETERS:                                                |
//|   Rep      -  report from ClusterizerRunAHC() performed on XY    |
//|   R        -  desired maximum intercluster correlation, -1<=R<=+1|
//| OUTPUT PARAMETERS:                                               |
//|   K        -  number of clusters, 1 <= K <= NPoints              |
//|   CIdx     -  array[NPoints], I-th element contains cluster index|
//|               (from 0 to K-1) for I-th point of the dataset.     |
//|   CZ       -  array[K]. This array allows to convert cluster     |
//|               indexes returned by this function to indexes used  |
//|               by Rep.Z. J-th cluster returned by this function   |
//|               corresponds to CZ[J]-th cluster stored in          |
//|               Rep.Z/PZ/PM. It is guaranteed that CZ[I] < CZ[I+1].|
//| NOTE: K clusters built by this subroutine are assumed to have no |
//|       hierarchy. Although they were obtained by manipulation with|
//|       top K nodes of dendrogram (i.e. hierarchical decomposition |
//|       of dataset), this function does not return information     |
//|       about hierarchy. Each of the clusters stand on its own.    |
//| NOTE: Cluster indexes returned by this function does not         |
//|       correspond to indexes returned in Rep.Z/PZ/PM. Either you  |
//|       work with hierarchical representation of the dataset       |
//|       (dendrogram), or you work with "flat" representation       |
//|       returned by this function. Each of representations has its |
//|       own clusters indexing system (former uses [0,2*NPoints-2]),|
//|       while latter uses [0..K-1]), although it is possible to    |
//|       perform conversion from one system to another by means of  |
//|       CZ array, returned by this function, which allows you to   |
//|       convert indexes stored in CIdx to the numeration system    |
//|       used by Rep.Z.                                             |
//| NOTE: this subroutine is optimized for moderate values of K. Say,|
//|       for K=5 it will perform many times faster than for K=100.  |
//|       Its worst - case performance is O(N*K), although in average|
//|       case it perform better (up to O(N*log(K))).                |
//+------------------------------------------------------------------+
void CAlglib::ClusterizerSeparatedByCorr(CAHCReport &rep,double r,
                                         int &k,CRowInt &cidx,CRowInt &cz)
  {
   k=0;
   cidx.Resize(0);
   cz.Resize(0);
   CClustering::ClusterizerSeparatedByCorr(rep,r,k,cidx,cz);
  }
//+------------------------------------------------------------------+
//| k-means++ clusterization                                         |
//| Backward compatibility function, we recommend to use CLUSTERING  |
//| subpackage as better replacement.                                |
//| INPUT PARAMETERS:                                                |
//|     XY          -   dataset, array [0..NPoints-1,0..NVars-1].    |
//|     NPoints     -   dataset size, NPoints>=K                     |
//|     NVars       -   number of variables, NVars>=1                |
//|     K           -   desired number of clusters, K>=1             |
//|     Restarts    -   number of restarts, Restarts>=1              |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   return code:                                 |
//|                     * -3, if task is degenerate (number of       |
//|                           distinct points is less than K)        |
//|                     * -1, if incorrect                           |
//|                           NPoints/NFeatures/K/Restarts was passed|
//|                     *  1, if subroutine finished successfully    |
//|     C           -   array[0..NVars-1,0..K-1].matrix whose columns|
//|                     store cluster's centers                      |
//|     XYC         -   array[NPoints], which contains cluster       |
//|                     indexes                                      |
//+------------------------------------------------------------------+
void CAlglib::KMeansGenerate(CMatrixDouble &xy,const int npoints,
                             const int nvars,const int k,
                             const int restarts,int &info,
                             CMatrixDouble &c,int &xyc[])
  {
//--- initialization
   info=0;
//--- function call
   CKMeans::KMeansGenerate(xy,npoints,nvars,k,restarts,info,c,xyc);
  }
//+------------------------------------------------------------------+
//| Multiclass Fisher LDA                                            |
//| Subroutine finds coefficients of linear combination which        |
//| optimally separates training set on classes.                     |
//| INPUT PARAMETERS:                                                |
//|     XY          -   training set, array[0..NPoints-1,0..NVars].  |
//|                     First NVars columns store values of          |
//|                     independent variables, next column stores    |
//|                     number of class (from 0 to NClasses-1) which |
//|                     dataset element belongs to. Fractional values|
//|                     are rounded to nearest integer.              |
//|     NPoints     -   training set size, NPoints>=0                |
//|     NVars       -   number of independent variables, NVars>=1    |
//|     NClasses    -   number of classes, NClasses>=2               |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   return code:                                 |
//|                     * -4, if internal EVD subroutine hasn't      |
//|                           converged                              |
//|                     * -2, if there is a point with class number  |
//|                           outside of [0..NClasses-1].            |
//|                     * -1, if incorrect parameters was passed     |
//|                           (NPoints<0, NVars<1, NClasses<2)       |
//|                     *  1, if task has been solved                |
//|                     *  2, if there was a multicollinearity in    |
//|                           training set, but task has been solved.|
//|     W           -   linear combination coefficients,             |
//|                     array[0..NVars-1]                            |
//+------------------------------------------------------------------+
void CAlglib::FisherLDA(CMatrixDouble &xy,const int npoints,
                        const int nvars,const int nclasses,
                        int &info,double &w[])
  {
//--- initialization
   info=0;
//--- function call
   CLDA::FisherLDA(xy,npoints,nvars,nclasses,info,w);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FisherLDA(CMatrixDouble &xy,const int npoints,
                        const int nvars,const int nclasses,
                        int &info,CRowDouble &w)
  {
//--- initialization
   info=0;
//--- function call
   CLDA::FisherLDA(xy,npoints,nvars,nclasses,info,w);
  }
//+------------------------------------------------------------------+
//| N-dimensional multiclass Fisher LDA                              |
//| Subroutine finds coefficients of linear combinations which       |
//| optimally separates                                              |
//| training set on classes. It returns N-dimensional basis whose    |
//| vector are sorted                                                |
//| by quality of training set separation (in descending order).     |
//| INPUT PARAMETERS:                                                |
//|     XY          -   training set, array[0..NPoints-1,0..NVars].  |
//|                     First NVars columns store values of          |
//|                     independent variables, next column stores    |
//|                     number of class (from 0 to NClasses-1) which |
//|                     dataset element belongs to. Fractional values|
//|                     are rounded to nearest integer.              |
//|     NPoints     -   training set size, NPoints>=0                |
//|     NVars       -   number of independent variables, NVars>=1    |
//|     NClasses    -   number of classes, NClasses>=2               |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   return code:                                 |
//|                     * -4, if internal EVD subroutine hasn't      |
//|                           converged                              |
//|                     * -2, if there is a point with class number  |
//|                           outside of [0..NClasses-1].            |
//|                     * -1, if incorrect parameters was passed     |
//|                           (NPoints<0, NVars<1, NClasses<2)       |
//|                     *  1, if task has been solved                |
//|                     *  2, if there was a multicollinearity in    |
//|                           training set, but task has been solved.|
//|     W           -   basis, array[0..NVars-1,0..NVars-1]          |
//|                     columns of matrix stores basis vectors,      |
//|                     sorted by quality of training set separation |
//|                     (in descending order)                        |
//+------------------------------------------------------------------+
void CAlglib::FisherLDAN(CMatrixDouble &xy,const int npoints,
                         const int nvars,const int nclasses,
                         int &info,CMatrixDouble &w)
  {
//--- initialization
   info=0;
//--- function call
   CLDA::FisherLDAN(xy,npoints,nvars,nclasses,info,w);
  }
//+------------------------------------------------------------------+
//| Linear regression                                                |
//| Subroutine builds model:                                         |
//|     Y = A(0)*X[0] + ... + A(N-1)*X[N-1] + A(N)                   |
//| and model found in ALGLIB format, covariation matrix, training   |
//| set errors (rms, average, average relative) and leave-one-out    |
//| cross-validation estimate of the generalization error. CV        |
//| estimate calculated using fast algorithm with O(NPoints*NVars)   |
//| complexity.                                                      |
//| When  covariation  matrix  is  calculated  standard deviations of|
//| function values are assumed to be equal to RMS error on the      |
//| training set.                                                    |
//| INPUT PARAMETERS:                                                |
//|     XY          -   training set, array [0..NPoints-1,0..NVars]: |
//|                     * NVars columns - independent variables      |
//|                     * last column - dependent variable           |
//|     NPoints     -   training set size, NPoints>NVars+1           |
//|     NVars       -   number of independent variables              |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   return code:                                 |
//|                     * -255, in case of unknown internal error    |
//|                     * -4, if internal SVD subroutine haven't     |
//|                           converged                              |
//|                     * -1, if incorrect parameters was passed     |
//|                           (NPoints<NVars+2, NVars<1).            |
//|                     *  1, if subroutine successfully finished    |
//|     LM          -   linear model in the ALGLIB format. Use       |
//|                     subroutines of this unit to work with the    |
//|                     model.                                       |
//|     AR          -   additional results                           |
//+------------------------------------------------------------------+
void CAlglib::LRBuild(CMatrixDouble &xy,const int npoints,const int nvars,
                      int &info,CLinearModelShell &lm,CLRReportShell &ar)
  {
//--- initialization
   info=0;
//--- function call
   CLinReg::LRBuild(xy,npoints,nvars,info,lm.GetInnerObj(),ar.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Linear regression                                                |
//| Variant of LRBuild which uses vector of standatd deviations      |
//| (errors in function values).                                     |
//| INPUT PARAMETERS:                                                |
//|     XY          -   training set, array [0..NPoints-1,0..NVars]: |
//|                     * NVars columns - independent variables      |
//|                     * last column - dependent variable           |
//|     S           -   standard deviations (errors in function      |
//|                     values) array[0..NPoints-1], S[i]>0.         |
//|     NPoints     -   training set size, NPoints>NVars+1           |
//|     NVars       -   number of independent variables              |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   return code:                                 |
//|                     * -255, in case of unknown internal error    |
//|                     * -4, if internal SVD subroutine haven't     |
//|                     converged                                    |
//|                     * -1, if incorrect parameters was passed     |
//|                     (NPoints<NVars+2, NVars<1).                  |
//|                     * -2, if S[I]<=0                             |
//|                     *  1, if subroutine successfully finished    |
//|     LM          -   linear model in the ALGLIB format. Use       |
//|                     subroutines of this unit to work with the    |
//|                     model.                                       |
//|     AR          -   additional results                           |
//+------------------------------------------------------------------+
void CAlglib::LRBuildS(CMatrixDouble &xy,double &s[],const int npoints,
                       const int nvars,int &info,CLinearModelShell &lm,
                       CLRReportShell &ar)
  {
//--- initialization
   info=0;
//--- function call
   CLinReg::LRBuildS(xy,s,npoints,nvars,info,lm.GetInnerObj(),ar.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::LRBuildS(CMatrixDouble &xy,CRowDouble &s,const int npoints,
                       const int nvars,int &info,CLinearModelShell &lm,
                       CLRReportShell &ar)
  {
//--- initialization
   info=0;
//--- function call
   CLinReg::LRBuildS(xy,s,npoints,nvars,info,lm.GetInnerObj(),ar.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like LRBuildS, but builds model                                  |
//|     Y=A(0)*X[0] + ... + A(N-1)*X[N-1]                            |
//| i.m_e. with zero constant term.                                  |
//+------------------------------------------------------------------+
void CAlglib::LRBuildZS(CMatrixDouble &xy,double &s[],const int npoints,
                        const int nvars,int &info,CLinearModelShell &lm,
                        CLRReportShell &ar)
  {
//--- initialization
   info=0;
//--- function call
   CLinReg::LRBuildZS(xy,s,npoints,nvars,info,lm.GetInnerObj(),ar.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::LRBuildZS(CMatrixDouble &xy,CRowDouble &s,const int npoints,
                        const int nvars,int &info,CLinearModelShell &lm,
                        CLRReportShell &ar)
  {
//--- initialization
   info=0;
//--- function call
   CLinReg::LRBuildZS(xy,s,npoints,nvars,info,lm.GetInnerObj(),ar.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like LRBuild but builds model                                    |
//|     Y=A(0)*X[0] + ... + A(N-1)*X[N-1]                            |
//| i.m_e. with zero constant term.                                  |
//+------------------------------------------------------------------+
void CAlglib::LRBuildZ(CMatrixDouble &xy,const int npoints,
                       const int nvars,int &info,CLinearModelShell &lm,
                       CLRReportShell &ar)
  {
//--- initialization
   info=0;
//--- function call
   CLinReg::LRBuildZ(xy,npoints,nvars,info,lm.GetInnerObj(),ar.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Unpacks coefficients of linear model.                            |
//| INPUT PARAMETERS:                                                |
//|     LM          -   linear model in ALGLIB format                |
//| OUTPUT PARAMETERS:                                               |
//|     V           -   coefficients,array[0..NVars]                 |
//|                     constant term (intercept) is stored in the   |
//|                     V[NVars].                                    |
//|     NVars       -   number of independent variables (one less    |
//|                     than number of coefficients)                 |
//+------------------------------------------------------------------+
void CAlglib::LRUnpack(CLinearModelShell &lm,double &v[],int &nvars)
  {
//--- initialization
   nvars=0;
//--- function call
   CLinReg::LRUnpack(lm.GetInnerObj(),v,nvars);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::LRUnpack(CLinearModelShell &lm,CRowDouble &v,int &nvars)
  {
//--- initialization
   nvars=0;
//--- function call
   CLinReg::LRUnpack(lm.GetInnerObj(),v,nvars);
  }
//+------------------------------------------------------------------+
//| "Packs" coefficients and creates linear model in ALGLIB format   |
//| (LRUnpack reversed).                                             |
//| INPUT PARAMETERS:                                                |
//|     V           -   coefficients, array[0..NVars]                |
//|     NVars       -   number of independent variables              |
//| OUTPUT PAREMETERS:                                               |
//|     LM          -   linear model.                                |
//+------------------------------------------------------------------+
void CAlglib::LRPack(double &v[],const int nvars,CLinearModelShell &lm)
  {
   CLinReg::LRPack(v,nvars,lm.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::LRPack(CRowDouble &v,const int nvars,CLinearModelShell &lm)
  {
   CLinReg::LRPack(v,nvars,lm.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Procesing                                                        |
//| INPUT PARAMETERS:                                                |
//|     LM      -   linear model                                     |
//|     X       -   input vector, array[0..NVars-1].                 |
//| Result:                                                          |
//|     value of linear model regression estimate                    |
//+------------------------------------------------------------------+
double CAlglib::LRProcess(CLinearModelShell &lm,double &x[])
  {
   return(CLinReg::LRProcess(lm.GetInnerObj(),x));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CAlglib::LRProcess(CLinearModelShell &lm,CRowDouble &x)
  {
   return(CLinReg::LRProcess(lm.GetInnerObj(),x));
  }
//+------------------------------------------------------------------+
//| RMS error on the test set                                        |
//| INPUT PARAMETERS:                                                |
//|     LM      -   linear model                                     |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     root mean square error.                                      |
//+------------------------------------------------------------------+
double CAlglib::LRRMSError(CLinearModelShell &lm,CMatrixDouble &xy,
                           const int npoints)
  {
   return(CLinReg::LRRMSError(lm.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average error on the test set                                    |
//| INPUT PARAMETERS:                                                |
//|     LM      -   linear model                                     |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     average error.                                               |
//+------------------------------------------------------------------+
double CAlglib::LRAvgError(CLinearModelShell &lm,CMatrixDouble &xy,
                           const int npoints)
  {
   return(CLinReg::LRAvgError(lm.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| RMS error on the test set                                        |
//| INPUT PARAMETERS:                                                |
//|     LM      -   linear model                                     |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     average relative error.                                      |
//+------------------------------------------------------------------+
double CAlglib::LRAvgRelError(CLinearModelShell &lm,CMatrixDouble &xy,
                              const int npoints)
  {
   return(CLinReg::LRAvgRelError(lm.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| This function serializes data structure to string.               |
//| Important properties of s_out:                                   |
//| * it contains alphanumeric characters, dots, underscores, minus  |
//|   signs                                                          |
//| * these symbols are grouped into words, which are separated by   |
//|   spaces and Windows-style (CR+LF) newlines                      |
//| * although  serializer  uses  spaces and CR+LF as separators, you|
//|   can replace any separator character by arbitrary combination of|
//|   spaces, tabs, Windows or Unix newlines. It allows flexible     |
//|   reformatting of the string in case you want to include it into |
//|   text or XML file. But you should not insert separators into the|
//|   middle of the "words" nor you should change case of letters.   |
//| * s_out can be freely moved between 32-bit and 64-bit systems,   |
//|   little and big endian machines, and so on. You can reference   |
//|   structure on 32-bit machine and unserialize it on 64-bit one   |
//|   (or vice versa), or reference it on SPARC and unserialize on   |
//|   x86. You can also reference it in C# version of ALGLIB and     |
//|   unserialize in C++ one, and vice versa.                        |
//+------------------------------------------------------------------+
void CAlglib::MLPSerialize(CMultilayerPerceptronShell &obj,string &s_out)
  {
//--- create a variable
   CSerializer s;
//--- serialization start
   s.Alloc_Start();
//--- function call
   CMLPBase::MLPAlloc(s,obj.GetInnerObj());
//--- serialization
   s.SStart_Str();
//--- function call
   CMLPBase::MLPSerialize(s,obj.GetInnerObj());
//--- stop
   s.Stop();
//--- change value
   s_out=s.Get_String();
  }
//+------------------------------------------------------------------+
//| This function unserializes data structure from string.           |
//+------------------------------------------------------------------+
void CAlglib::MLPUnserialize(const string s_in,CMultilayerPerceptronShell &obj)
  {
//--- create a variable
   CSerializer s;
//--- unserialization
   s.UStart_Str(s_in);
//--- function call
   CMLPBase::MLPUnserialize(s,obj.GetInnerObj());
//--- stop
   s.Stop();
  }
//+------------------------------------------------------------------+
//| Creates  neural  network  with  NIn  inputs,  NOut outputs,      |
//| without hidden layers, with linear output layer. Network weights |
//| are filled with small random values.                             |
//+------------------------------------------------------------------+
void CAlglib::MLPCreate0(const int nin,const int nout,
                         CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreate0(nin,nout,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Same as MLPCreate0, but with one hidden layer (NHid neurons) with|
//| non-linear activation function. Output layer is linear.          |
//+------------------------------------------------------------------+
void CAlglib::MLPCreate1(const int nin,int nhid,const int nout,
                         CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreate1(nin,nhid,nout,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Same as MLPCreate0,but with two hidden layers (NHid1 and NHid2   |
//| neurons) with non-linear activation function. Output layer is    |
//| linear.                                                          |
//|  $ALL                                                            |
//+------------------------------------------------------------------+
void CAlglib::MLPCreate2(const int nin,const int nhid1,const int nhid2,
                         const int nout,CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreate2(nin,nhid1,nhid2,nout,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Creates neural network with NIn inputs, NOut outputs, without    |
//| hidden layers with non-linear output layer. Network weights are  |
//| filled with small random values.                                 |
//| Activation function of the output layer takes values:            |
//|     (B, +INF), if D>=0                                           |
//| or                                                               |
//|     (-INF, B), if D<0.                                           |
//+------------------------------------------------------------------+
void CAlglib::MLPCreateB0(const int nin,const int nout,const double b,
                          const double d,CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreateB0(nin,nout,b,d,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Same as MLPCreateB0 but with non-linear hidden layer.            |
//+------------------------------------------------------------------+
void CAlglib::MLPCreateB1(const int nin,int nhid,const int nout,
                          const double b,const double d,
                          CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreateB1(nin,nhid,nout,b,d,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Same as MLPCreateB0 but with two non-linear hidden layers.       |
//+------------------------------------------------------------------+
void CAlglib::MLPCreateB2(const int nin,const int nhid1,const int nhid2,
                          const int nout,const double b,const double d,
                          CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreateB2(nin,nhid1,nhid2,nout,b,d,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Creates  neural  network  with  NIn  inputs,  NOut outputs,      |
//| without hidden layers with non-linear output layer. Network      |
//| weights are filled with small random values. Activation function |
//| of the output layer takes values [A,B].                          |
//+------------------------------------------------------------------+
void CAlglib::MLPCreateR0(const int nin,const int nout,double a,
                          const double b,CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreateR0(nin,nout,a,b,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Same as MLPCreateR0,but with non-linear hidden layer.            |
//+------------------------------------------------------------------+
void CAlglib::MLPCreateR1(const int nin,int nhid,const int nout,
                          const double a,const double b,
                          CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreateR1(nin,nhid,nout,a,b,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Same as MLPCreateR0,but with two non-linear hidden layers.       |
//+------------------------------------------------------------------+
void CAlglib::MLPCreateR2(const int nin,const int nhid1,const int nhid2,
                          const int nout,const double a,const double b,
                          CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreateR2(nin,nhid1,nhid2,nout,a,b,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Creates classifier network with NIn inputs and NOut possible     |
//| classes.                                                         |
//| Network contains no hidden layers and linear output layer with   |
//| SOFTMAX-normalization (so outputs sums up to 1.0 and converge to |
//| posterior probabilities).                                        |
//+------------------------------------------------------------------+
void CAlglib::MLPCreateC0(const int nin,const int nout,
                          CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreateC0(nin,nout,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Same as MLPCreateC0,but with one non-linear hidden layer.        |
//+------------------------------------------------------------------+
void CAlglib::MLPCreateC1(const int nin,int nhid,const int nout,
                          CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreateC1(nin,nhid,nout,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Same as MLPCreateC0, but with two non-linear hidden layers.      |
//+------------------------------------------------------------------+
void CAlglib::MLPCreateC2(const int nin,const int nhid1,const int nhid2,
                          const int nout,CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPCreateC2(nin,nhid1,nhid2,nout,network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Randomization of neural network weights                          |
//+------------------------------------------------------------------+
void CAlglib::MLPRandomize(CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPRandomize(network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Randomization of neural network weights and standartisator       |
//+------------------------------------------------------------------+
void CAlglib::MLPRandomizeFull(CMultilayerPerceptronShell &network)
  {
   CMLPBase::MLPRandomizeFull(network.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Internal subroutine.                                             |
//+------------------------------------------------------------------+
void CAlglib::MLPInitPreprocessor(CMultilayerPerceptronShell &network,
                                  CMatrixDouble &xy,int ssize)
  {
   CMLPBase::MLPInitPreprocessor(network.GetInnerObj(),xy,ssize);
  }
//+------------------------------------------------------------------+
//| Returns information about initialized network: number of inputs, |
//| outputs, weights.                                                |
//+------------------------------------------------------------------+
void CAlglib::MLPProperties(CMultilayerPerceptronShell &network,
                            int &nin,int &nout,int &wcount)
  {
//--- initialization
   nin=0;
   nout=0;
   wcount=0;
//--- function call
   CMLPBase::MLPProperties(network.GetInnerObj(),nin,nout,wcount);
  }
//+------------------------------------------------------------------+
//| Returns number of inputs.                                        |
//+------------------------------------------------------------------+
int CAlglib::MLPGetInputsCount(CMultilayerPerceptronShell &network)
  {
   return(CMLPBase::MLPGetInputsCount(network.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| Returns number of outputs.                                       |
//+------------------------------------------------------------------+
int CAlglib::MLPGetOutputsCount(CMultilayerPerceptronShell &network)
  {
   return(CMLPBase::MLPGetOutputsCount(network.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| Returns number of weights.                                       |
//+------------------------------------------------------------------+
int CAlglib::MLPGetWeightsCount(CMultilayerPerceptronShell &network)
  {
   return(CMLPBase::MLPGetWeightsCount(network.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| Tells whether network is SOFTMAX-normalized (i.m_e. classifier)  |
//| or not.                                                          |
//+------------------------------------------------------------------+
bool CAlglib::MLPIsSoftMax(CMultilayerPerceptronShell &network)
  {
   return(CMLPBase::MLPIsSoftMax(network.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This function returns total number of layers (including input,   |
//| hidden and output layers).                                       |
//+------------------------------------------------------------------+
int CAlglib::MLPGetLayersCount(CMultilayerPerceptronShell &network)
  {
   return(CMLPBase::MLPGetLayersCount(network.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This function returns size of K-th layer.                        |
//| K=0 corresponds to input layer, K=CNT-1 corresponds to output    |
//| layer.                                                           |
//| Size of the output layer is always equal to the number of        |
//| outputs, although when we have softmax-normalized network, last  |
//| neuron doesn't have any connections - it is just zero.           |
//+------------------------------------------------------------------+
int CAlglib::MLPGetLayerSize(CMultilayerPerceptronShell &network,
                             const int k)
  {
   return(CMLPBase::MLPGetLayerSize(network.GetInnerObj(),k));
  }
//+------------------------------------------------------------------+
//| This function returns offset/scaling coefficients for I-th input |
//| of the network.                                                  |
//| INPUT PARAMETERS:                                                |
//|     Network     -   network                                      |
//|     I           -   input index                                  |
//| OUTPUT PARAMETERS:                                               |
//|     Mean        -   mean term                                    |
//|     Sigma       -   sigma term,guaranteed to be nonzero.         |
//| I-th input is passed through linear transformation               |
//|     IN[i]=(IN[i]-Mean)/Sigma                                     |
//| before feeding to the network                                    |
//+------------------------------------------------------------------+
void CAlglib::MLPGetInputScaling(CMultilayerPerceptronShell &network,
                                 const int i,double &mean,double &sigma)
  {
//--- initialization
   mean=0;
   sigma=0;
//--- function call
   CMLPBase::MLPGetInputScaling(network.GetInnerObj(),i,mean,sigma);
  }
//+------------------------------------------------------------------+
//| This function returns offset/scaling coefficients for I-th output|
//| of the network.                                                  |
//| INPUT PARAMETERS:                                                |
//|     Network     -   network                                      |
//|     I           -   input index                                  |
//| OUTPUT PARAMETERS:                                               |
//|     Mean        -   mean term                                    |
//|     Sigma       -   sigma term, guaranteed to be nonzero.        |
//| I-th output is passed through linear transformation              |
//|     OUT[i] = OUT[i]*Sigma+Mean                                   |
//| before returning it to user. In case we have SOFTMAX-normalized  |
//| network, we return (Mean,Sigma)=(0.0,1.0).                       |
//+------------------------------------------------------------------+
void CAlglib::MLPGetOutputScaling(CMultilayerPerceptronShell &network,
                                  const int i,double &mean,double &sigma)
  {
//--- initialization
   mean=0;
   sigma=0;
//--- function call
   CMLPBase::MLPGetOutputScaling(network.GetInnerObj(),i,mean,sigma);
  }
//+------------------------------------------------------------------+
//| This function returns information about Ith neuron of Kth layer  |
//| INPUT PARAMETERS:                                                |
//|     Network     -   network                                      |
//|     K           -   layer index                                  |
//|     I           -   neuron index (within layer)                  |
//| OUTPUT PARAMETERS:                                               |
//|     FKind       -   activation function type (used by            |
//|                     MLPActivationFunction()) this value is zero  |
//|                     for input or linear neurons                  |
//|     Threshold   -   also called offset, bias                     |
//|                     zero for input neurons                       |
//| NOTE: this function throws exception if layer or neuron with     |
//| given index do not exists.                                       |
//+------------------------------------------------------------------+
void CAlglib::MLPGetNeuronInfo(CMultilayerPerceptronShell &network,
                               const int k,const int i,int &fkind,
                               double &threshold)
  {
//--- initialization
   fkind=0;
   threshold=0;
//--- function call
   CMLPBase::MLPGetNeuronInfo(network.GetInnerObj(),k,i,fkind,threshold);
  }
//+------------------------------------------------------------------+
//| This function returns information about connection from I0-th    |
//| neuron of K0-th layer to I1-th neuron of K1-th layer.            |
//| INPUT PARAMETERS:                                                |
//|     Network     -   network                                      |
//|     K0          -   layer index                                  |
//|     I0          -   neuron index (within layer)                  |
//|     K1          -   layer index                                  |
//|     I1          -   neuron index (within layer)                  |
//| RESULT:                                                          |
//|     connection weight (zero for non-existent connections)        |
//| This function:                                                   |
//| 1. throws exception if layer or neuron with given index do not   |
//|    exists.                                                       |
//| 2. returns zero if neurons exist, but there is no connection     |
//|    between them                                                  |
//+------------------------------------------------------------------+
double CAlglib::MLPGetWeight(CMultilayerPerceptronShell &network,
                             const int k0,const int i0,const int k1,
                             const int i1)
  {
   return(CMLPBase::MLPGetWeight(network.GetInnerObj(),k0,i0,k1,i1));
  }
//+------------------------------------------------------------------+
//| This function sets offset/scaling coefficients for I-th input of |
//| the network.                                                     |
//| INPUT PARAMETERS:                                                |
//|     Network     -   network                                      |
//|     I           -   input index                                  |
//|     Mean        -   mean term                                    |
//|     Sigma       -   sigma term (if zero,will be replaced by 1.0) |
//| NTE: I-th input is passed through linear transformation          |
//|     IN[i]=(IN[i]-Mean)/Sigma                                     |
//| before feeding to the network. This function sets Mean and Sigma.|
//+------------------------------------------------------------------+
void CAlglib::MLPSetInputScaling(CMultilayerPerceptronShell &network,
                                 const int i,const double mean,
                                 const double sigma)
  {
   CMLPBase::MLPSetInputScaling(network.GetInnerObj(),i,mean,sigma);
  }
//+------------------------------------------------------------------+
//| This function sets offset/scaling coefficients for I-th output of|
//| the network.                                                     |
//| INPUT PARAMETERS:                                                |
//|     Network     -   network                                      |
//|     I           -   input index                                  |
//|     Mean        -   mean term                                    |
//|     Sigma       -   sigma term (if zero, will be replaced by 1.0)|
//| OUTPUT PARAMETERS:                                               |
//| NOTE: I-th output is passed through linear transformation        |
//|     OUT[i] = OUT[i]*Sigma+Mean                                   |
//| before returning it to user. This function sets Sigma/Mean. In   |
//| case we have SOFTMAX-normalized network, you can not set (Sigma, |
//| Mean) to anything other than(0.0,1.0) - this function will throw |
//| exception.                                                       |
//+------------------------------------------------------------------+
void CAlglib::MLPSetOutputScaling(CMultilayerPerceptronShell &network,
                                  const int i,const double mean,
                                  const double sigma)
  {
   CMLPBase::MLPSetOutputScaling(network.GetInnerObj(),i,mean,sigma);
  }
//+------------------------------------------------------------------+
//| This function modifies information about Ith neuron of Kth layer |
//| INPUT PARAMETERS:                                                |
//|     Network     -   network                                      |
//|     K           -   layer index                                  |
//|     I           -   neuron index (within layer)                  |
//|     FKind       -   activation function type (used by            |
//|                     MLPActivationFunction()) this value must be  |
//|                     zero for input neurons (you can not set      |
//|                     activation function for input neurons)       |
//|     Threshold   -   also called offset, bias                     |
//|                     this value must be zero for input neurons    |
//|                     (you can not set threshold for input neurons)|
//| NOTES:                                                           |
//| 1. this function throws exception if layer or neuron with given  |
//|    index do not exists.                                          |
//| 2. this function also throws exception when you try to set       |
//|    non-linear activation function for input neurons (any kind    |
//|    of network) or for output neurons of classifier network.      |
//| 3. this function throws exception when you try to set non-zero   |
//|    threshold for input neurons (any kind of network).            |
//+------------------------------------------------------------------+
void CAlglib::MLPSetNeuronInfo(CMultilayerPerceptronShell &network,
                               const int k,const int i,int fkind,
                               double threshold)
  {
   CMLPBase::MLPSetNeuronInfo(network.GetInnerObj(),k,i,fkind,threshold);
  }
//+------------------------------------------------------------------+
//| This function modifies information about connection from I0-th   |
//| neuron of K0-th layer to I1-th neuron of K1-th layer.            |
//| INPUT PARAMETERS:                                                |
//|     Network     -   network                                      |
//|     K0          -   layer index                                  |
//|     I0          -   neuron index (within layer)                  |
//|     K1          -   layer index                                  |
//|     I1          -   neuron index (within layer)                  |
//|     W           -   connection weight (must be zero for          |
//|                     non-existent connections)                    |
//| This function:                                                   |
//| 1. throws exception if layer or neuron with given index do not   |
//|    exists.                                                       |
//| 2. throws exception if you try to set non-zero weight for        |
//|    non-existent connection                                       |
//+------------------------------------------------------------------+
void CAlglib::MLPSetWeight(CMultilayerPerceptronShell &network,
                           const int k0,const int i0,const int k1,
                           const int i1,const double w)
  {
   CMLPBase::MLPSetWeight(network.GetInnerObj(),k0,i0,k1,i1,w);
  }
//+------------------------------------------------------------------+
//| Neural network activation function                               |
//| INPUT PARAMETERS:                                                |
//|     NET         -   neuron input                                 |
//|     K           -   function index (zero for linear function)    |
//| OUTPUT PARAMETERS:                                               |
//|     F           -   function                                     |
//|     DF          -   its derivative                               |
//|     D2F         -   its second derivative                        |
//+------------------------------------------------------------------+
void CAlglib::MLPActivationFunction(const double net,const int k,
                                    double &f,double &df,double &d2f)
  {
//--- initialization
   f=0;
   df=0;
   d2f=0;
//--- function call
   CMLPBase::MLPActivationFunction(net,k,f,df,d2f);
  }
//+------------------------------------------------------------------+
//| Procesing                                                        |
//| INPUT PARAMETERS:                                                |
//|     Network -   neural network                                   |
//|     X       -   input vector,  array[0..NIn-1].                  |
//| OUTPUT PARAMETERS:                                               |
//|     Y       -   result. Regression estimate when solving         |
//|                 regression task, vector of posterior             |
//|                 probabilities for classification task.           |
//| See also MLPProcessI                                             |
//+------------------------------------------------------------------+
void CAlglib::MLPProcess(CMultilayerPerceptronShell &network,
                         double &x[],double &y[])
  {
   CMLPBase::MLPProcess(network.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//| 'interactive' variant of MLPProcess for languages like Python    |
//| which support constructs like "Y = MLPProcess(NN,X)" and         |
//| interactive mode of the interpreter                              |
//| This function allocates new array on each call, so it is         |
//| significantly slower than its 'non-interactive' counterpart,     |
//| but it is more convenient when you call it from command line.    |
//+------------------------------------------------------------------+
void CAlglib::MLPProcessI(CMultilayerPerceptronShell &network,
                          double &x[],double &y[])
  {
   CMLPBase::MLPProcessI(network.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//| Error function for neural network,internal subroutine.           |
//+------------------------------------------------------------------+
double CAlglib::MLPError(CMultilayerPerceptronShell &network,
                         CMatrixDouble &xy,const int ssize)
  {
   return(CMLPBase::MLPError(network.GetInnerObj(),xy,ssize));
  }
//+------------------------------------------------------------------+
//| Error of the neural network on dataset given by sparse matrix.   |
//| INPUT PARAMETERS:                                                |
//|   Network     -  neural network                                  |
//|   XY          -  training set, see below for information on the  |
//|                  training set format. This function checks       |
//|                  correctness of the dataset (no NANs/INFs, class |
//|                  numbers are correct) and throws exception when  |
//|                  incorrect dataset is passed. Sparse matrix must |
//|                  use CRS format for storage.                     |
//|   NPoints     -  points count, >=0                               |
//| RESULT:                                                          |
//|   sum-of-squares error, SUM(sqr(y[i]-desired_y[i])/2)            |
//| DATASET FORMAT:                                                  |
//| This function uses two different dataset formats - one for       |
//| regression networks, another one for classification networks.    |
//| For regression networks with NIn inputs and NOut outputs         |
//| following dataset format is used:                                |
//|   * dataset is given by NPoints*(NIn+NOut) matrix                |
//|   * each row corresponds to one example                          |
//|   * first NIn columns are inputs, next NOut columns are outputs  |
//| For classification networks with NIn inputs and NClasses clases  |
//| following dataset format is used:                                |
//|   * dataset is given by NPoints*(NIn+1) matrix                   |
//|   * each row corresponds to one example                          |
//|   * first NIn columns are inputs, last column stores class number|
//|     (from 0 to NClasses-1).                                      |
//+------------------------------------------------------------------+
double CAlglib::MLPErrorSparse(CMultilayerPerceptronShell &network,
                               CSparseMatrix &xy,int npoints)
  {
   return(CMLPBase::MLPErrorSparse(network.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Natural error function for neural network,internal subroutine.   |
//+------------------------------------------------------------------+
double CAlglib::MLPErrorN(CMultilayerPerceptronShell &network,
                          CMatrixDouble &xy,const int ssize)
  {
   return(CMLPBase::MLPErrorN(network.GetInnerObj(),xy,ssize));
  }
//+------------------------------------------------------------------+
//| Classification error                                             |
//+------------------------------------------------------------------+
int CAlglib::MLPClsError(CMultilayerPerceptronShell &network,
                         CMatrixDouble &xy,const int ssize)
  {
   return(CMLPBase::MLPClsError(network.GetInnerObj(),xy,ssize));
  }
//+------------------------------------------------------------------+
//| Relative classification error on the test set                    |
//| INPUT PARAMETERS:                                                |
//|     Network -   network                                          |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     percent of incorrectly classified cases. Works both for      |
//|     classifier networks and general purpose networks used as     |
//|     classifiers.                                                 |
//+------------------------------------------------------------------+
double CAlglib::MLPRelClsError(CMultilayerPerceptronShell &network,
                               CMatrixDouble &xy,const int npoints)
  {
   return(CMLPBase::MLPRelClsError(network.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Relative classification error on the test set given by sparse    |
//| matrix.                                                          |
//| INPUT PARAMETERS:                                                |
//|   Network     -  neural network;                                 |
//|   XY          -  training set, see below for information on the  |
//|                  training set format. Sparse matrix must use CRS |
//|                  format for storage.                             |
//|   NPoints     -  points count, >=0.                              |
//| RESULT:                                                          |
//|   Percent of incorrectly classified cases. Works both for        |
//|   classifier networks and general purpose networks used as       |
//|   classifiers.                                                   |
//| DATASET FORMAT:                                                  |
//|   This function uses two different dataset formats - one for     |
//|   regression networks, another one for classification networks.  |
//|   For regression networks with NIn inputs and NOut outputs       |
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+NOut) matrix             |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, next NOut columns are       |
//|        outputs                                                   |
//|   For classification networks with NIn inputs and NClasses clases|
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+1) matrix                |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, last column stores class    |
//|        number (from 0 to NClasses-1).                            |
//+------------------------------------------------------------------+
double CAlglib::MLPRelClsErrorSparse(CMultilayerPerceptronShell &network,
                                     CSparseMatrix &xy,int npoints)
  {
   return(CMLPBase::MLPRelClsErrorSparse(network.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average cross-entropy (in bits per element) on the test set      |
//| INPUT PARAMETERS:                                                |
//|     Network -   neural network                                   |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     CrossEntropy/(NPoints*LN(2)).                                |
//|     Zero if network solves regression task.                      |
//+------------------------------------------------------------------+
double CAlglib::MLPAvgCE(CMultilayerPerceptronShell &network,
                         CMatrixDouble &xy,const int npoints)
  {
   return(CMLPBase::MLPAvgCE(network.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average cross-entropy (in bits per element) on the test set given|
//| by sparse matrix.                                                |
//| INPUT PARAMETERS:                                                |
//|   Network     -  neural network;                                 |
//|   XY          -  training set, see below for information on the  |
//|                  training set format. This function checks       |
//|                  correctness of the dataset (no NANs/INFs, class |
//|                  numbers are correct) and throws exception when  |
//|                  incorrect dataset is passed. Sparse matrix must |
//|                  use CRS format for storage.                     |
//|   NPoints     -  points count, >=0.                              |
//| RESULT:                                                          |
//|   CrossEntropy/(NPoints*LN(2)).                                  |
//|   Zero if network solves regression task.                        |
//| DATASET FORMAT:                                                  |
//|   This function uses two different dataset formats - one for     |
//|   regression networks, another one for classification networks.  |
//|   For regression networks with NIn inputs and NOut outputs       |
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+NOut) matrix             |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, next NOut columns are       |
//|        outputs                                                   |
//|   For classification networks with NIn inputs and NClasses clases|
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+1) matrix                |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, last column stores class    |
//|        number (from 0 to NClasses-1).                            |
//+------------------------------------------------------------------+
double CAlglib::MLPAvgCESparse(CMultilayerPerceptronShell &network,
                               CSparseMatrix &xy,int npoints)
  {
   return(CMLPBase::MLPAvgCESparse(network.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| RMS error on the test set                                        |
//| INPUT PARAMETERS:                                                |
//|     Network -   neural network                                   |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     root mean square error.                                      |
//|     Its meaning for regression task is obvious. As for           |
//|     classification task,RMS error means error when estimating    |
//|     posterior probabilities.                                     |
//+------------------------------------------------------------------+
double CAlglib::MLPRMSError(CMultilayerPerceptronShell &network,
                            CMatrixDouble &xy,const int npoints)
  {
   return(CMLPBase::MLPRMSError(network.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| RMS error on the test set given by sparse matrix.                |
//| INPUT PARAMETERS:                                                |
//|   Network     -  neural network;                                 |
//|   XY          -  training set, see below for information on the  |
//|                  training set format. This function checks       |
//|                  correctness of the dataset (no NANs/INFs, class |
//|                  numbers are correct) and throws exception when  |
//|                  incorrect dataset is passed. Sparse matrix must |
//|                  use CRS format for storage.                     |
//|   NPoints     -  points count, >=0.                              |
//| RESULT:                                                          |
//|   Root mean square error. Its meaning for regression task is     |
//|   obvious. As for classification task, RMS error means error when|
//|   estimating posterior probabilities.                            |
//| DATASET FORMAT:                                                  |
//|   This function uses two different dataset formats - one for     |
//|   regression networks, another one for classification networks.  |
//|   For regression networks with NIn inputs and NOut outputs       |
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn + NOut) matrix           |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, next NOut columns are       |
//|        outputs                                                   |
//|   For classification networks with NIn inputs and NClasses       |
//|   clases following dataset format is used:                       |
//|      * dataset is given by NPoints*(NIn + 1) matrix              |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, last column stores class    |
//|        number(from 0 to NClasses - 1).                           |
//+------------------------------------------------------------------+
double CAlglib::MLPRMSErrorSparse(CMultilayerPerceptronShell &network,
                                  CSparseMatrix &xy,int npoints)
  {
   return(CMLPBase::MLPRMSErrorSparse(network.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average error on the test set                                    |
//| INPUT PARAMETERS:                                                |
//|     Network -   neural network                                   |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     Its meaning for regression task is obvious. As for           |
//|     classification task,it means average error when estimating   |
//|     posterior probabilities.                                     |
//+------------------------------------------------------------------+
double CAlglib::MLPAvgError(CMultilayerPerceptronShell &network,
                            CMatrixDouble &xy,const int npoints)
  {
   return(CMLPBase::MLPAvgError(network.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average absolute error on the test set given by sparse matrix.   |
//| INPUT PARAMETERS:                                                |
//|   Network     -  neural network;                                 |
//|   XY          -  training set, see below for information on the  |
//|                  training set format. This function checks       |
//|                  correctness of the dataset (no NANs/INFs, class |
//|                  numbers are correct) and throws exception when  |
//|                  incorrect dataset is passed. Sparse matrix must |
//|                  use CRS format for storage.                     |
//|   NPoints     -  points count, >=0.                              |
//| RESULT:                                                          |
//|   Its meaning for regression task is obvious. As for             |
//|   classification task, it means average error when estimating    |
//|   posterior probabilities.                                       |
//| DATASET FORMAT:                                                  |
//|   This function uses two different dataset formats - one for     |
//|   regression networks, another one for classification networks.  |
//|   For regression networks with NIn inputs and NOut outputs       |
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+NOut) matrix             |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, next NOut columns are       |
//|        outputs                                                   |
//|   For classification networks with NIn inputs and NClasses clases|
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+1) matrix                |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, last column stores class    |
//|        number (from 0 to NClasses-1).                            |
//+------------------------------------------------------------------+
double CAlglib::MLPAvgErrorSparse(CMultilayerPerceptronShell &network,
                                  CSparseMatrix &xy,int npoints)
  {
   return(CMLPBase::MLPAvgErrorSparse(network.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average relative error on the test set                           |
//| INPUT PARAMETERS:                                                |
//|     Network -   neural network                                   |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     Its meaning for regression task is obvious. As for           |
//|     classification task, it means average relative error when    |
//|     estimating posterior probability of belonging to the correct |
//|     class.                                                       |
//+------------------------------------------------------------------+
double CAlglib::MLPAvgRelError(CMultilayerPerceptronShell &network,
                               CMatrixDouble &xy,const int npoints)
  {
   return(CMLPBase::MLPAvgRelError(network.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average relative error on the test set given by sparse matrix.   |
//| INPUT PARAMETERS:                                                |
//|   Network     -  neural network;                                 |
//|   XY          -  training set, see below for information on the  |
//|                  training set format. This function checks       |
//|                  correctness of the dataset (no NANs/INFs, class |
//|                  numbers are correct) and throws exception when  |
//|                  incorrect dataset is passed. Sparse matrix must |
//|                  use CRS format for storage.                     |
//|   NPoints     -  points count, >=0.                              |
//| RESULT:                                                          |
//|   Its meaning for regression task is obvious. As for             |
//|   classification task, it means average relative error when      |
//|   estimating posterior probability of belonging to the correct   |
//|   class.                                                         |
//| DATASET FORMAT:                                                  |
//|   This function uses two different dataset formats - one for     |
//|   regression networks, another one for classification networks.  |
//|   For regression networks with NIn inputs and NOut outputs       |
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+NOut) matrix             |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, next NOut columns are       |
//|        outputs                                                   |
//|   For classification networks with NIn inputs and NClasses clases|
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+1) matrix                |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, last column stores class    |
//|        number (from 0 to NClasses-1).                            |
//+------------------------------------------------------------------+
double CAlglib::MLPAvgRelErrorSparse(CMultilayerPerceptronShell &network,
                                     CSparseMatrix &xy,int npoints)
  {
   return(CMLPBase::MLPAvgRelErrorSparse(network.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Gradient calculation                                             |
//| INPUT PARAMETERS:                                                |
//|     Network -   network initialized with one of the network      |
//|                 creation funcs                                   |
//|     X       -   input vector, length of array must be at least   |
//|                 NIn                                              |
//|     DesiredY-   desired outputs, length of array must be at least|
//|                 NOut                                             |
//|     Grad    -   possibly preallocated array. If size of array is |
//|                 smaller than WCount, it will be reallocated. It  |
//|                 is recommended to reuse previously allocated     |
//|                 array to reduce allocation overhead.             |
//| OUTPUT PARAMETERS:                                               |
//|     E       -   error function, SUM(sqr(y[i]-desiredy[i])/2,i)   |
//|     Grad    -   gradient of E with respect to weights of network,|
//|                 array[WCount]                                    |
//+------------------------------------------------------------------+
void CAlglib::MLPGrad(CMultilayerPerceptronShell &network,double &x[],
                      double &desiredy[],double &e,double &grad[])
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPGrad(network.GetInnerObj(),x,desiredy,e,grad);
  }
//+------------------------------------------------------------------+
//| Gradient calculation (natural error function is used)            |
//| INPUT PARAMETERS:                                                |
//|     Network -   network initialized with one of the network      |
//|                 creation funcs                                   |
//|     X       -   input vector, length of array must be at least   |
//|                 NIn                                              |
//|     DesiredY-   desired outputs, length of array must be at least|
//|                 NOut                                             |
//|     Grad    -   possibly preallocated array. If size of array is |
//|                 smaller than WCount, it will be reallocated. It  |
//|                 is recommended to reuse previously allocated     |
//|                 array to reduce allocation overhead.             |
//| OUTPUT PARAMETERS:                                               |
//|     E       -   error function, sum-of-squares for regression    |
//|                 networks, cross-entropy for classification       |
//|                 networks.                                        |
//|     Grad    -   gradient of E with respect to weights of network,|
//|                 array[WCount]                                    |
//+------------------------------------------------------------------+
void CAlglib::MLPGradN(CMultilayerPerceptronShell &network,double &x[],
                       double &desiredy[],double &e,double &grad[])
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPGradN(network.GetInnerObj(),x,desiredy,e,grad);
  }
//+------------------------------------------------------------------+
//| Batch gradient calculation for a set of inputs/outputs           |
//| INPUT PARAMETERS:                                                |
//|     Network -   network initialized with one of the network      |
//|                 creation funcs                                   |
//|     XY      -   set of inputs/outputs; one sample = one row;     |
//|                 first NIn columns contain inputs,                |
//|                 next NOut columns - desired outputs.             |
//|     SSize   -   number of elements in XY                         |
//|     Grad    -   possibly preallocated array. If size of array is |
//|                 smaller than WCount, it will be reallocated. It  |
//|                 is recommended to reuse previously allocated     |
//|                 array to reduce allocation overhead.             |
//| OUTPUT PARAMETERS:                                               |
//|     E       -   error function, SUM(sqr(y[i]-desiredy[i])/2,i)   |
//|     Grad    -   gradient of E with respect to weights of network,|
//|                 array[WCount]                                    |
//+------------------------------------------------------------------+
void CAlglib::MLPGradBatch(CMultilayerPerceptronShell &network,
                           CMatrixDouble &xy,const int ssize,
                           double &e,double &grad[])
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPGradBatch(network.GetInnerObj(),xy,ssize,e,grad);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MLPGradBatch(CMultilayerPerceptronShell &network,
                           CMatrixDouble &xy,const int ssize,
                           double &e,CRowDouble &grad)
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPGradBatch(network.GetInnerObj(),xy,ssize,e,grad);
  }
//+------------------------------------------------------------------+
//| Batch gradient calculation for a set of inputs/outputs given by  |
//| sparse matrices                                                  |
//| INPUT PARAMETERS:                                                |
//|   Network  -  network initialized with one of the network        |
//|               creation funcs                                     |
//|   XY       -  original dataset in sparse format; one sample = one|
//|               row:                                               |
//|               * MATRIX MUST BE STORED IN CRS FORMAT              |
//|               * first NIn columns contain inputs.                |
//|               * for regression problem, next NOut columns store  |
//|                 desired outputs.                                 |
//|               * for classification problem, next column (just    |
//|                 one!) stores class number.                       |
//|   SSize    -  number of elements in XY                           |
//|   Grad     -  possibly preallocated array. If size of array is   |
//|               smaller than WCount, it will be reallocated. It is |
//|               recommended to reuse previously allocated array to |
//|               reduce allocation overhead.                        |
//| OUTPUT PARAMETERS:                                               |
//|   E        -  error function, SUM(sqr(y[i]-desiredy[i])/2,i)     |
//|   Grad     -  gradient of E with respect to weights of network,  |
//|               array[WCount]                                      |
//+------------------------------------------------------------------+
void CAlglib::MLPGradBatchSparse(CMultilayerPerceptronShell &network,
                                 CSparseMatrix &xy,int ssize,double &e,
                                 CRowDouble &grad)
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPGradBatchSparse(network.GetInnerObj(),xy,ssize,e,grad);
  }
//+------------------------------------------------------------------+
//| Batch gradient calculation for a subset of dataset               |
//| INPUT PARAMETERS:                                                |
//|   Network  -  network initialized with one of the network        |
//|               creation funcs                                     |
//|   XY       -  original dataset in dense format; one sample = one |
//|               row:                                               |
//|               * first NIn columns contain inputs,                |
//|               * for regression problem, next NOut columns store  |
//|                 desired outputs.                                 |
//|               * for classification problem, next column (just    |
//|                 one!) stores class number.                       |
//|   SetSize  -  real size of XY, SetSize>=0;                       |
//|   Idx      -  subset of SubsetSize elements, array[SubsetSize]:  |
//|               * Idx[I] stores row index in the original dataset  |
//|                 which is given by XY. Gradient is calculated with|
//|                 respect to rows whose indexes are stored in Idx[]|
//|               * Idx[]  must store correct indexes; this function |
//|                 throws an exception in case incorrect index (less|
//|                 than 0 or larger than rows(XY)) is given         |
//|               * Idx[] may store indexes in any order and even    |
//|                 with repetitions.                                |
//|   SubsetSize- number of elements in Idx[] array:                 |
//|               * positive value means that subset given by Idx[]  |
//|                 is processed                                     |
//|               * zero value results in zero gradient              |
//|               * negative value means that full dataset is        |
//|                 processed                                        |
//|   Grad     -  possibly preallocated array. If size of array is   |
//|               smaller than WCount, it will be reallocated. It is |
//|               recommended to reuse previously allocated array to |
//|               reduce allocation overhead.                        |
//| OUTPUT PARAMETERS:                                               |
//|   E        -  error function, SUM(sqr(y[i]-desiredy[i])/2,i)     |
//|   Grad     -  gradient of E with respect to weights of network,  |
//|               array[WCount]                                      |
//+------------------------------------------------------------------+
void CAlglib::MLPGradBatchSubset(CMultilayerPerceptronShell &network,
                                 CMatrixDouble &xy,int setsize,
                                 CRowInt &idx,int subsetsize,
                                 double &e,CRowDouble &grad)
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPGradBatchSubset(network.GetInnerObj(),xy,setsize,idx,subsetsize,e,grad);
  }
//+------------------------------------------------------------------+
//| Batch gradient calculation for a set of inputs/outputs for a     |
//| subset of dataset given by set of indexes.                       |
//| INPUT PARAMETERS:                                                |
//|   Network  -  network initialized with one of the network        |
//|               creation funcs                                     |
//|   XY       -  original dataset in sparse format; one sample = one|
//|               row:                                               |
//|               * MATRIX MUST BE STORED IN CRS FORMAT              |
//|               * first NIn columns contain inputs,                |
//|               * for regression problem, next NOut columns store  |
//|                 desired outputs.                                 |
//|               * for classification problem, next column (just    |
//|                 one!) stores class number.                       |
//|   SetSize  -  real size of XY, SetSize>=0;                       |
//|   Idx      -  subset of SubsetSize elements, array[SubsetSize]:  |
//|               * Idx[I] stores row index in the original dataset  |
//|                 which is given by XY. Gradient is calculated with|
//|                 respect to rows whose indexes are stored in Idx[]|
//|               * Idx[] must store correct indexes; this function  |
//|                 throws an exception in case incorrect index (less|
//|                 than 0 or larger than rows(XY)) is given         |
//|               * Idx[] may store indexes in any order and even    |
//|                 with repetitions.                                |
//|   SubsetSize- number of elements in Idx[] array:                 |
//|               * positive value means that subset given by Idx[]  |
//|                 is processed                                     |
//|               * zero value results in zero gradient              |
//|               * negative value means that full dataset is        |
//|                 processed                                        |
//|   Grad     -  possibly preallocated array. If size of array is   |
//|               smaller than WCount, it will be reallocated. It is |
//|               recommended to reuse previously allocated array to |
//|               reduce allocation overhead.                        |
//| OUTPUT PARAMETERS:                                               |
//|   E        -  error function, SUM(sqr(y[i]-desiredy[i])/2,i)     |
//|   Grad     -  gradient of E with respect to weights of network,  |
//|               array[WCount]                                      |
//| NOTE: when SubsetSize<0 is used full dataset by call             |
//|       MLPGradBatchSparse function.                               |
//+------------------------------------------------------------------+
void CAlglib::MLPGradBatchSparseSubset(CMultilayerPerceptronShell &network,
                                       CSparseMatrix &xy,int setsize,
                                       CRowInt &idx,int subsetsize,
                                       double &e,CRowDouble &grad)
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPGradBatchSparseSubset(network.GetInnerObj(),xy,setsize,idx,subsetsize,e,grad);
  }
//+------------------------------------------------------------------+
//| Batch gradient calculation for a set of inputs/outputs           |
//| (natural error function is used)                                 |
//| INPUT PARAMETERS:                                                |
//|     Network -   network initialized with one of the network      |
//|                 creation funcs                                   |
//|     XY      -   set of inputs/outputs; one sample=one row;       |
//|                 first NIn columns contain inputs,                |
//|                 next NOut columns - desired outputs.             |
//|     SSize   -   number of elements in XY                         |
//|     Grad    -   possibly preallocated array. If size of array is |
//|                 smaller than WCount, it will be reallocated. It  |
//|                 is recommended to reuse previously allocated     |
//|                 array to reduce allocation overhead.             |
//| OUTPUT PARAMETERS:                                               |
//|     E       -   error function, sum-of-squares for regression    |
//|                 networks, cross-entropy for classification       |
//|                 networks.                                        |
//|     Grad    -   gradient of E with respect to weights of network,|
//|                 array[WCount]                                    |
//+------------------------------------------------------------------+
void CAlglib::MLPGradNBatch(CMultilayerPerceptronShell &network,
                            CMatrixDouble &xy,const int ssize,
                            double &e,double &grad[])
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPGradNBatch(network.GetInnerObj(),xy,ssize,e,grad);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MLPGradNBatch(CMultilayerPerceptronShell &network,
                            CMatrixDouble &xy,const int ssize,
                            double &e,CRowDouble &grad)
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPGradNBatch(network.GetInnerObj(),xy,ssize,e,grad);
  }
//+------------------------------------------------------------------+
//| Batch Hessian calculation (natural error function) using         |
//| R-algorithm. Internal subroutine.                                |
//|      Hessian calculation based on R-algorithm described in       |
//|      "Fast Exact Multiplication by the Hessian",                 |
//|      B. A. Pearlmutter,                                          |
//|      Neural Computation, 1994.                                   |
//+------------------------------------------------------------------+
void CAlglib::MLPHessianNBatch(CMultilayerPerceptronShell &network,
                               CMatrixDouble &xy,const int ssize,
                               double &e,double &grad[],
                               CMatrixDouble &h)
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPHessianNBatch(network.GetInnerObj(),xy,ssize,e,grad,h);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MLPHessianNBatch(CMultilayerPerceptronShell &network,
                               CMatrixDouble &xy,const int ssize,
                               double &e,CRowDouble &grad,
                               CMatrixDouble &h)
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPHessianNBatch(network.GetInnerObj(),xy,ssize,e,grad,h);
  }
//+------------------------------------------------------------------+
//| Batch Hessian calculation using R-algorithm.                     |
//| Internal subroutine.                                             |
//|      Hessian calculation based on R-algorithm described in       |
//|      "Fast Exact Multiplication by the Hessian",                 |
//|      B. A. Pearlmutter,                                          |
//|      Neural Computation, 1994.                                   |
//+------------------------------------------------------------------+
void CAlglib::MLPHessianBatch(CMultilayerPerceptronShell &network,
                              CMatrixDouble &xy,const int ssize,
                              double &e,double &grad[],CMatrixDouble &h)
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPHessianBatch(network.GetInnerObj(),xy,ssize,e,grad,h);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MLPHessianBatch(CMultilayerPerceptronShell &network,
                              CMatrixDouble &xy,const int ssize,
                              double &e,CRowDouble &grad,CMatrixDouble &h)
  {
//--- initialization
   e=0;
//--- function call
   CMLPBase::MLPHessianBatch(network.GetInnerObj(),xy,ssize,e,grad,h);
  }
//+------------------------------------------------------------------+
//| Calculation of all types of errors on subset of dataset.         |
//| INPUT PARAMETERS:                                                |
//|   Network  -  network initialized with one of the network        |
//|               creation funcs                                     |
//|   XY       -  original dataset; one sample = one row;            |
//|               first NIn columns contain inputs, next NOut        |
//|               columns - desired outputs.                         |
//|   SetSize  -  real size of XY, SetSize>=0;                       |
//|   Subset   -  subset of SubsetSize elements, array[SubsetSize];  |
//|   SubsetSize- number of elements in Subset[] array:              |
//|               * if SubsetSize>0, rows of XY with indices         |
//|                 Subset[0]......Subset[SubsetSize-1] are processed|
//|               * if SubsetSize=0, zeros are returned              |
//|               * if SubsetSize<0, entire dataset is  processed;   |
//|                 Subset[] array is ignored in this case.          |
//| OUTPUT PARAMETERS:                                               |
//|   Rep      -  it contains all type of errors.                    |
//+------------------------------------------------------------------+
void CAlglib::MLPAllErrorsSubset(CMultilayerPerceptronShell &network,
                                 CMatrixDouble &xy,int setsize,
                                 CRowInt &subset,int subsetsize,
                                 CModelErrors &rep)
  {
   CMLPBase::MLPAllErrorsSubset(network.GetInnerObj(),xy,setsize,subset,subsetsize,rep);
  }
//+------------------------------------------------------------------+
//| Calculation of all types of errors on subset of dataset.         |
//| INPUT PARAMETERS:                                                |
//|   Network  -  network initialized with one of the network        |
//|               creation funcs                                     |
//|   XY       -  original dataset given by sparse matrix;           |
//|               one sample = one row; first NIn columns contain    |
//|               inputs, next NOut columns - desired outputs.       |
//|   SetSize  -  real size of XY, SetSize>=0;                       |
//|   Subset   -  subset of SubsetSize elements, array[SubsetSize];  |
//|   SubsetSize- number of elements in Subset[] array:              |
//|               * if SubsetSize>0, rows of XY with indices         |
//|                 Subset[0]......Subset[SubsetSize-1] are processed|
//|               * if SubsetSize=0, zeros are returned              |
//|               * if SubsetSize<0, entire dataset is processed;    |
//|                 Subset[] array is ignored in this case.          |
//| OUTPUT PARAMETERS:                                               |
//|   Rep      -  it contains all type of errors.                    |
//+------------------------------------------------------------------+
void CAlglib::MLPAllErrorsSparseSubset(CMultilayerPerceptronShell &network,
                                       CSparseMatrix &xy,int setsize,
                                       CRowInt &subset,int subsetsize,
                                       CModelErrors &rep)
  {
   CMLPBase::MLPAllErrorsSparseSubset(network.GetInnerObj(),xy,setsize,subset,subsetsize,rep);
  }
//+------------------------------------------------------------------+
//| Error of the neural network on subset of dataset.                |
//| INPUT PARAMETERS:                                                |
//|   Network  -  neural network;                                    |
//|   XY       -  training set, see below for information on the     |
//|               training set format;                               |
//|   SetSize  -  real size of XY, SetSize>=0;                       |
//|   Subset   -  subset of SubsetSize elements, array[SubsetSize];  |
//|   SubsetSize- number of elements in Subset[] array:              |
//|               * if SubsetSize>0, rows of XY with indices         |
//|                 Subset[0]......Subset[SubsetSize-1] are processed|
//|               * if SubsetSize=0, zeros are returned              |
//|               * if SubsetSize<0, entire dataset is  processed;   |
//|                 Subset[] array is ignored in this case.          |
//| RESULT:                                                          |
//|   sum-of-squares error, SUM(sqr(y[i]-desired_y[i])/2)            |
//| DATASET FORMAT:                                                  |
//|   This function uses two different dataset formats - one for     |
//|   regression networks, another one for classification networks.  |
//|   For regression networks with NIn inputs and NOut outputs       |
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+NOut) matrix             |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, next NOut columns are       |
//|        outputs                                                   |
//|   For classification networks with NIn inputs and NClasses clases|
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+1) matrix                |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, last column stores class    |
//|        number (from 0 to NClasses-1).                            |
//+------------------------------------------------------------------+
double CAlglib::MLPErrorSubset(CMultilayerPerceptronShell &network,
                               CMatrixDouble &xy,int setsize,
                               CRowInt &subset,int subsetsize)
  {
   return(CMLPBase::MLPErrorSubset(network.GetInnerObj(),xy,setsize,subset,subsetsize));
  }
//+------------------------------------------------------------------+
//| Error of the neural network on subset of sparse dataset.         |
//| INPUT PARAMETERS:                                                |
//|   Network  -  neural network;                                    |
//|   XY       -  training set, see below for information on the     |
//|               training set format. This function checks          |
//|               correctness of the dataset (no NANs/INFs, class    |
//|               numbers are correct) and throws exception when     |
//|               incorrect dataset is passed. Sparse matrix must use|
//|               CRS format for storage.                            |
//|   SetSize  -  real size of XY, SetSize>=0;  it is used when      |
//|               SubsetSize<0;                                      |
//|   Subset   -  subset of SubsetSize elements, array[SubsetSize];  |
//|   SubsetSize- number of elements in Subset[] array:              |
//|               * if SubsetSize>0, rows of XY with indices         |
//|                 Subset[0]......Subset[SubsetSize-1] are processed|
//|               * if SubsetSize=0, zeros are returned              |
//|               * if SubsetSize<0, entire dataset is processed;    |
//|                 Subset[] array is ignored in this case.          |
//| RESULT:                                                          |
//|   sum-of-squares error, SUM(sqr(y[i]-desired_y[i])/2)            |
//| DATASET FORMAT:                                                  |
//|   This function uses two different dataset formats - one for     |
//|   regression networks, another one for classification networks.  |
//|   For regression networks with NIn inputs and NOut outputs       |
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+NOut) matrix             |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, next NOut columns are       |
//|        outputs                                                   |
//|   For classification networks with NIn inputs and NClasses clases|
//|   following dataset format is used:                              |
//|      * dataset is given by NPoints*(NIn+1) matrix                |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, last column stores class    |
//|        number (from 0 to NClasses-1).                            |
//+------------------------------------------------------------------+
double CAlglib::MLPErrorSparseSubset(CMultilayerPerceptronShell &network,
                                     CSparseMatrix &xy,int setsize,
                                     CRowInt &subset,int subsetsize)
  {
   return(CMLPBase::MLPErrorSparseSubset(network.GetInnerObj(),xy,setsize,subset,subsetsize));
  }
//+------------------------------------------------------------------+
//| This subroutine trains logit model.                              |
//| INPUT PARAMETERS:                                                |
//|     XY          -   training set, array[0..NPoints-1,0..NVars]   |
//|                     First NVars columns store values of          |
//|                     independent variables, next column stores    |
//|                     number of class (from 0 to NClasses-1) which |
//|                     dataset element belongs to. Fractional values|
//|                     are rounded to nearest integer.              |
//|     NPoints     -   training set size, NPoints>=1                |
//|     NVars       -   number of independent variables, NVars>=1    |
//|     NClasses    -   number of classes, NClasses>=2               |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   return code:                                 |
//|                     * -2, if there is a point with class number  |
//|                           outside of [0..NClasses-1].            |
//|                     * -1, if incorrect parameters was passed     |
//|                           (NPoints<NVars+2, NVars<1, NClasses<2).|
//|                     *  1, if task has been solved                |
//|     LM          -   model built                                  |
//|     Rep         -   training report                              |
//+------------------------------------------------------------------+
void CAlglib::MNLTrainH(CMatrixDouble &xy,const int npoints,
                        const int nvars,const int nclasses,
                        int &info,CLogitModelShell &lm,
                        CMNLReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLogit::MNLTrainH(xy,npoints,nvars,nclasses,info,lm.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Procesing                                                        |
//| INPUT PARAMETERS:                                                |
//|     LM      -   logit model, passed by non-constant reference    |
//|                 (some fields of structure are used as temporaries|
//|                 when calculating model output).                  |
//|     X       -   input vector,  array[0..NVars-1].                |
//|     Y       -   (possibly) preallocated buffer; if size of Y is  |
//|                 less than NClasses, it will be reallocated.If it |
//|                 is large enough, it is NOT reallocated, so we    |
//|                 can save some time on reallocation.              |
//| OUTPUT PARAMETERS:                                               |
//|     Y       -   result, array[0..NClasses-1]                     |
//|                 Vector of posterior probabilities for            |
//|                 classification task.                             |
//+------------------------------------------------------------------+
void CAlglib::MNLProcess(CLogitModelShell &lm,double &x[],double &y[])
  {
   CLogit::MNLProcess(lm.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MNLProcess(CLogitModelShell &lm,CRowDouble &x,CRowDouble &y)
  {
   CLogit::MNLProcess(lm.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//| 'interactive' variant of MNLProcess for languages like Python    |
//| which support constructs like "Y=MNLProcess(LM,X)" and           |
//| interactive mode of the interpreter                              |
//| This function allocates new array on each call, so it is         |
//| significantly slower than its 'non-interactive' counterpart,     |
//| but it is  more  convenient when you call it from command line.  |
//+------------------------------------------------------------------+
void CAlglib::MNLProcessI(CLogitModelShell &lm,double &x[],double &y[])
  {
   CLogit::MNLProcessI(lm.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MNLProcessI(CLogitModelShell &lm,CRowDouble &x,CRowDouble &y)
  {
   CLogit::MNLProcessI(lm.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//| Unpacks coefficients of logit model. Logit model have form:      |
//|     P(class=i) = S(i) / (S(0) + S(1) + ... +S(M-1))              |
//|     S(i) = Exp(A[i,0]*X[0] + ... + A[i,N-1]*X[N-1] + A[i,N]),    |
//|            when i<M-1                                            |
//|     S(M-1) = 1                                                   |
//| INPUT PARAMETERS:                                                |
//|     LM          -   logit model in ALGLIB format                 |
//| OUTPUT PARAMETERS:                                               |
//|     V           -   coefficients, array[0..NClasses-2,0..NVars]  |
//|     NVars       -   number of independent variables              |
//|     NClasses    -   number of classes                            |
//+------------------------------------------------------------------+
void CAlglib::MNLUnpack(CLogitModelShell &lm,CMatrixDouble &a,
                        int &nvars,int &nclasses)
  {
//--- initialization
   nvars=0;
   nclasses=0;
//--- function call
   CLogit::MNLUnpack(lm.GetInnerObj(),a,nvars,nclasses);
  }
//+------------------------------------------------------------------+
//| "Packs" coefficients and creates logit model in ALGLIB format    |
//| (MNLUnpack reversed).                                            |
//| INPUT PARAMETERS:                                                |
//|     A           -   model (see MNLUnpack)                        |
//|     NVars       -   number of independent variables              |
//|     NClasses    -   number of classes                            |
//| OUTPUT PARAMETERS:                                               |
//|     LM          -   logit model.                                 |
//+------------------------------------------------------------------+
void CAlglib::MNLPack(CMatrixDouble &a,const int nvars,
                      const int nclasses,CLogitModelShell &lm)
  {
   CLogit::MNLPack(a,nvars,nclasses,lm.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Average cross-entropy (in bits per element) on the test set      |
//| INPUT PARAMETERS:                                                |
//|     LM      -   logit model                                      |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     CrossEntropy/(NPoints*ln(2)).                                |
//+------------------------------------------------------------------+
double CAlglib::MNLAvgCE(CLogitModelShell &lm,CMatrixDouble &xy,
                         const int npoints)
  {
   return(CLogit::MNLAvgCE(lm.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Relative classification error on the test set                    |
//| INPUT PARAMETERS:                                                |
//|     LM      -   logit model                                      |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     percent of incorrectly classified cases.                     |
//+------------------------------------------------------------------+
double CAlglib::MNLRelClsError(CLogitModelShell &lm,CMatrixDouble &xy,
                               const int npoints)
  {
   return(CLogit::MNLRelClsError(lm.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| RMS error on the test set                                        |
//| INPUT PARAMETERS:                                                |
//|     LM      -   logit model                                      |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     root mean square error (error when estimating posterior      |
//|     probabilities).                                              |
//+------------------------------------------------------------------+
double CAlglib::MNLRMSError(CLogitModelShell &lm,CMatrixDouble &xy,
                            const int npoints)
  {
   return(CLogit::MNLRMSError(lm.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average error on the test set                                    |
//| INPUT PARAMETERS:                                                |
//|     LM      -   logit model                                      |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     average error (error when estimating posterior               |
//|     probabilities).                                              |
//+------------------------------------------------------------------+
double CAlglib::MNLAvgError(CLogitModelShell &lm,CMatrixDouble &xy,
                            const int npoints)
  {
   return(CLogit::MNLAvgError(lm.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average relative error on the test set                           |
//| INPUT PARAMETERS:                                                |
//|     LM      -   logit model                                      |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     average relative error (error when estimating posterior      |
//|     probabilities).                                              |
//+------------------------------------------------------------------+
double CAlglib::MNLAvgRelError(CLogitModelShell &lm,CMatrixDouble &xy,
                               const int ssize)
  {
   return(CLogit::MNLAvgRelError(lm.GetInnerObj(),xy,ssize));
  }
//+------------------------------------------------------------------+
//| Classification error on test set = MNLRelClsError*NPoints        |
//+------------------------------------------------------------------+
int CAlglib::MNLClsError(CLogitModelShell &lm,CMatrixDouble &xy,
                         const int npoints)
  {
   return(CLogit::MNLClsError(lm.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| DESCRIPTION:                                                     |
//| This function creates MCPD (Markov Chains for Population Data)   |
//| solver.                                                          |
//| This solver can be used to find transition matrix P for          |
//| N-dimensional prediction problem where transition from X[i] to   |
//|     X[i+1] is modelled as X[i+1] = P*X[i]                        |
//| where X[i] and X[i+1] are N-dimensional population vectors       |
//| (components of each X are non-negative), and P is a N*N          |
//| transition matrix (elements of   are non-negative, each column   |
//| sums to 1.0).                                                    |
//| Such models arise when when:                                     |
//| * there is some population of individuals                        |
//| * individuals can have different states                          |
//| * individuals can transit from one state to another              |
//| * population size is constant, i.e. there is no new individuals  |
//|   and no one leaves population                                   |
//| * you want to model transitions of individuals from one state    |
//|   into another                                                   |
//| USAGE:                                                           |
//| Here we give very brief outline of the MCPD. We strongly         |
//| recommend you to read examples in the ALGLIB Reference Manual    |
//| and to read ALGLIB User Guide on data analysis which is          |
//| available at http://www.alglib.net/dataanalysis/                 |
//| 1. User initializes algorithm state with MCPDCreate() call       |
//| 2. User adds one or more tracks -  sequences of states which     |
//|    describe evolution of a system being modelled from different  |
//|    starting conditions                                           |
//| 3. User may add optional boundary, equality and/or linear        |
//|    constraints on the coefficients of P by calling one of the    |
//|    following functions:                                          |
//|    * MCPDSetEC() to set equality constraints                     |
//|    * MCPDSetBC() to set bound constraints                        |
//|    * MCPDSetLC() to set linear constraints                       |
//| 4. Optionally, user may set custom weights for prediction errors |
//|    (by default, algorithm assigns non-equal, automatically chosen|
//|    weights for errors in the prediction of different components  |
//|    of X). It can be done with a call of                          |
//|    MCPDSetPredictionWeights() function.                          |
//| 5. User calls MCPDSolve() function which takes algorithm state   |
//|    and pointer (delegate, etc.) to callback function which       |
//|    calculates F/G.                                               |
//| 6. User calls MCPDResults() to get solution                      |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>=1                          |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure stores algorithm state                 |
//+------------------------------------------------------------------+
void CAlglib::MCPDCreate(const int n,CMCPDStateShell &s)
  {
   CMarkovCPD::MCPDCreate(n,s.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| DESCRIPTION:                                                     |
//| This function is a specialized version of MCPDCreate() function, |
//| and we recommend  you  to read comments for this function for    |
//| general information about MCPD solver.                           |
//| This function creates MCPD (Markov Chains for Population Data)   |
//| solver for "Entry-state" model, i.e. model where transition from |
//| X[i] to X[i+1] is modelled as                                    |
//|     X[i+1] = P*X[i]                                              |
//| where                                                            |
//|     X[i] and X[i+1] are N-dimensional state vectors              |
//|     P is a N*N transition matrix                                 |
//| and  one  selected component of X[] is called "entry" state and  |
//| is treated in a special way:                                     |
//|     system state always transits from "entry" state to some      |
//|     another state                                                |
//|     system state can not transit from any state into "entry"     |
//|     state                                                        |
//| Such conditions basically mean that row of P which corresponds to|
//| "entry" state is zero.                                           |
//| Such models arise when:                                          |
//| * there is some population of individuals                        |
//| * individuals can have different states                          |
//| * individuals can transit from one state to another              |
//| * population size is NOT constant -  at every moment of time     |
//|   there is some (unpredictable) amount of "new" individuals,     |
//|   which can transit into one of the states at the next turn, but |
//|   still no one leaves population                                 |
//| * you want to model transitions of individuals from one state    |
//|   into another                                                   |
//|*but you do NOT want to predict amount of "new" individuals     |
//|   because it does not depends on individuals already present     |
//|   (hence system can not transit INTO entry state - it can only   |
//|   transit FROM it).                                              |
//| This model is discussed in more details in the ALGLIB User Guide |
//| (see http://www.alglib.net/dataanalysis/ for more data).         |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>=2                          |
//|     EntryState- index of entry state, in 0..N-1                  |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure stores algorithm state                 |
//+------------------------------------------------------------------+
void CAlglib::MCPDCreateEntry(const int n,const int entrystate,
                              CMCPDStateShell &s)
  {
   CMarkovCPD::MCPDCreateEntry(n,entrystate,s.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| DESCRIPTION:                                                     |
//| This function is a specialized version of MCPDCreate() function, |
//| and we recommend  you  to read comments for this function for    |
//| general information about MCPD solver.                           |
//| This function creates MCPD (Markov Chains for Population Data)   |
//| solver for "Exit-state" model, i.e. model where transition from  |
//| X[i] to X[i+1] is modelled as                                    |
//|     X[i+1] = P*X[i]                                              |
//| where                                                            |
//|     X[i] and X[i+1] are N-dimensional state vectors              |
//|     P is a N*N transition matrix                                 |
//| and  one  selected component of X[] is called "exit" state and   |
//| is treated in a special way:                                     |
//|     system state can transit from any state into "exit" state    |
//|     system state can not transit from "exit" state into any other|
//|     state transition operator discards "exit" state (makes it    |
//|     zero at each turn)                                           |
//| Such conditions basically mean that column of P which            |
//| corresponds to "exit" state is zero. Multiplication by such P    |
//| may decrease sum of vector components.                           |
//| Such models arise when:                                          |
//| * there is some population of individuals                        |
//| * individuals can have different states                          |
//| * individuals can transit from one state to another              |
//| * population size is NOT constant - individuals can move into    |
//|   "exit" state and leave population at the next turn, but there  |
//|   are no new individuals                                         |
//| * amount of individuals which leave population can be predicted  |
//| * you want to model transitions of individuals from one state    |
//|   into another (including transitions into the "exit" state)     |
//| This model is discussed in more details in the ALGLIB User Guide |
//| (see http://www.alglib.net/dataanalysis/ for more data).         |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>=2                          |
//|     ExitState-  index of exit state, in 0..N-1                   |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure stores algorithm state                 |
//+------------------------------------------------------------------+
void CAlglib::MCPDCreateExit(const int n,const int exitstate,
                             CMCPDStateShell &s)
  {
   CMarkovCPD::MCPDCreateExit(n,exitstate,s.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| DESCRIPTION:                                                     |
//| This function is a specialized version of MCPDCreate() function, |
//| and we recommend you to read comments for this function for      |
//| general information about MCPD solver.                           |
//| This function creates MCPD (Markov Chains for Population Data)   |
//| solver for "Entry-Exit-states" model, i.e. model where transition|
//| from X[i] to X[i+1] is modelled as                               |
//|     X[i+1] = P*X[i]                                              |
//| where                                                            |
//|     X[i] and X[i+1] are N-dimensional state vectors              |
//|     P is a N*N transition matrix                                 |
//| one selected component of X[] is called "entry" state and is a   |
//| treated in special way:                                          |
//|     system state always transits from "entry" state to some      |
//|     another state                                                |
//|     system state can not transit from any state into "entry"     |
//|     state                                                        |
//| and another one component of X[] is called "exit" state and is   |
//| treated in a special way too:                                    |
//|     system state can transit from any state into "exit" state    |
//|     system state can not transit from "exit" state into any other|
//|     state transition operator discards "exit" state (makes it    |
//|     zero at each turn)                                           |
//| Such conditions basically mean that:                             |
//|     row of P which corresponds to "entry" state is zero          |
//|     column of P which corresponds to "exit" state is zero        |
//| Multiplication by such P may decrease sum of vector components.  |
//| Such models arise when:                                          |
//| * there is some population of individuals                        |
//| * individuals can have different states                          |
//| * individuals can transit from one state to another              |
//| * population size is NOT constant                                |
//| * at every moment of time there is some (unpredictable) amount   |
//|   of "new" individuals, which can transit into one of the states |
//|   at the next turn                                               |
//|*some individuals can move (predictably) into "exit" state      |
//|   and leave population at the next turn                          |
//| * you want to model transitions of individuals from one state    |
//|   into another, including transitions from the "entry" state and |
//|   into the "exit" state.                                         |
//|*but you do NOT want to predict amount of "new" individuals     |
//|   because it does not depends on individuals already present     |
//|   (hence system can not transit INTO entry state - it can only   |
//|   transit FROM it).                                              |
//| This model is discussed  in  more  details  in  the ALGLIB User  |
//| Guide (see http://www.alglib.net/dataanalysis/ for more data).   |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>=2                          |
//|     EntryState- index of entry state, in 0..N-1                  |
//|     ExitState-  index of exit state, in 0..N-1                   |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure stores algorithm state                 |
//+------------------------------------------------------------------+
void CAlglib::MCPDCreateEntryExit(const int n,const int entrystate,
                                  const int exitstate,CMCPDStateShell &s)
  {
   CMarkovCPD::MCPDCreateEntryExit(n,entrystate,exitstate,s.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function is used to add a track - sequence of system states |
//| at the different moments of its evolution.                       |
//| You may add one or several tracks to the MCPD solver. In case you|
//| have several tracks, they won't overwrite each other. For        |
//| example, if you pass two tracks, A1-A2-A3 (system at t=A+1, t=A+2|
//| and t=A+3) and B1-B2-B3, then solver will try to model           |
//| transitions from t=A+1 to t=A+2, t=A+2 to t=A+3, t=B+1 to t=B+2, |
//| t=B+2 to t=B+3. But it WONT mix these two tracks - i.e. it wont  |
//| try to model transition from t=A+3 to t=B+1.                     |
//| INPUT PARAMETERS:                                                |
//|     S       -   solver                                           |
//|     XY      -   track, array[K, N]:                               |
//|                 * I-th row is a state at t=I                     |
//|                 * elements of XY must be non-negative (exception |
//|                   will be thrown on negative elements)           |
//|     K       -   number of points in a track                      |
//|                 * if given, only leading K rows of XY are used   |
//|                 * if not given, automatically determined from    |
//|                   size of XY                                     |
//| NOTES:                                                           |
//| 1. Track may contain either proportional or population data:     |
//|    * with proportional data all rows of XY must sum to 1.0, i.e. |
//|      we have proportions instead of absolute population values   |
//|    * with population data rows of XY contain population counts   |
//|      and generally do not sum to 1.0 (although they still must be|
//|      non-negative)                                               |
//+------------------------------------------------------------------+
void CAlglib::MCPDAddTrack(CMCPDStateShell &s,CMatrixDouble &xy,
                           const int k)
  {
   CMarkovCPD::MCPDAddTrack(s.GetInnerObj(),xy,k);
  }
//+------------------------------------------------------------------+
//| This function is used to add a track - sequence of system states |
//| at the different moments of its evolution.                       |
//| You may add one or several tracks to the MCPD solver. In case you|
//| have several tracks, they won't overwrite each other. For        |
//| example, if you pass two tracks, A1-A2-A3 (system at t=A+1, t=A+2|
//| and t=A+3) and B1-B2-B3, then solver will try to model           |
//| transitions from t=A+1 to t=A+2, t=A+2 to t=A+3, t=B+1 to t=B+2, |
//| t=B+2 to t=B+3. But it WONT mix these two tracks - i.e. it wont  |
//| try to model transition from t=A+3 to t=B+1.                     |
//| INPUT PARAMETERS:                                                |
//|     S       -   solver                                           |
//|     XY      -   track, array[K,N]:                               |
//|                 * I-th row is a state at t=I                     |
//|                 * elements of XY must be non-negative (exception |
//|                   will be thrown on negative elements)           |
//|     K       -   number of points in a track                      |
//|                 * if given, only leading K rows of XY are used   |
//|                 * if not given, automatically determined from    |
//|                   size of XY                                     |
//| NOTES:                                                           |
//| 1. Track may contain either proportional or population data:     |
//|    * with proportional data all rows of XY must sum to 1.0, i.e. |
//|      we have proportions instead of absolute population values   |
//|    * with population data rows of XY contain population counts   |
//|      and generally do not sum to 1.0 (although they still must be|
//|      non-negative)                                               |
//+------------------------------------------------------------------+
void CAlglib::MCPDAddTrack(CMCPDStateShell &s,CMatrixDouble &xy)
  {
//--- initialization
   int k=(int)CAp::Rows(xy);
//--- function call
   CMarkovCPD::MCPDAddTrack(s.GetInnerObj(),xy,k);
  }
//+------------------------------------------------------------------+
//| This function is used to add equality constraints on the elements|
//| of the transition matrix P.                                      |
//| MCPD solver has four types of constraints which can be placed    |
//| on P:                                                            |
//| * user-specified equality constraints (optional)                 |
//| * user-specified bound constraints (optional)                    |
//| * user-specified general linear constraints (optional)           |
//| * basic constraints (always present):                            |
//|   * non-negativity: P[i,j]>=0                                    |
//|   * consistency: every column of P sums to 1.0                   |
//| Final constraints which are passed to the underlying optimizer   |
//| are calculated as intersection of all present constraints. For   |
//| example, you may specify boundary constraint on P[0,0] and       |
//| equality one:                                                    |
//|     0.1<=P[0,0]<=0.9                                             |
//|     P[0,0]=0.5                                                   |
//| Such combination of constraints will be silently reduced to their|
//| intersection, which is P[0,0]=0.5.                               |
//| This function can be used to place equality constraints on       |
//| arbitrary subset of elements of P. Set of constraints is         |
//| specified by EC, which may contain either NAN's or finite numbers|
//| from [0,1]. NAN denotes absence of constraint, finite number     |
//| denotes equality constraint on specific element of P.            |
//| You can also use MCPDAddEC() function which allows to ADD        |
//| equality constraint for one element of P without changing        |
//| constraints for other elements.                                  |
//| These functions (MCPDSetEC and MCPDAddEC) interact as follows:   |
//| * there is internal matrix of equality constraints which is      |
//|   stored in the MCPD solver                                      |
//| * MCPDSetEC() replaces this matrix by another one (SET)          |
//| * MCPDAddEC() modifies one element of this matrix and leaves     |
//|   other ones unchanged (ADD)                                     |
//| * thus MCPDAddEC() call preserves all modifications done by      |
//|   previous calls, while MCPDSetEC() completely discards all      |
//|   changes done to the equality constraints.                      |
//| INPUT PARAMETERS:                                                |
//|     S       -   solver                                           |
//|     EC      -   equality constraints, array[N,N]. Elements of EC |
//|                 can be either NAN's or finite numbers from [0,1].|
//|                 NAN denotes absence of constraints, while finite |
//|                 value denotes equality constraint on the         |
//|                 corresponding element of P.                      |
//| NOTES:                                                           |
//| 1. infinite values of EC will lead to exception being thrown.    |
//| Values less than 0.0 or greater than 1.0 will lead to error code |
//| being returned after call to MCPDSolve().                        |
//+------------------------------------------------------------------+
void CAlglib::MCPDSetEC(CMCPDStateShell &s,CMatrixDouble &ec)
  {
   CMarkovCPD::MCPDSetEC(s.GetInnerObj(),ec);
  }
//+------------------------------------------------------------------+
//| This function is used to add equality constraints on the elements|
//| of the transition matrix P.                                      |
//| MCPD solver has four types of constraints which can be placed    |
//| on P:                                                            |
//| * user-specified equality constraints (optional)                 |
//| * user-specified bound constraints (optional)                    |
//| * user-specified general linear constraints (optional)           |
//| * basic constraints (always present):                            |
//|   * non-negativity: P[i,j]>=0                                    |
//|   * consistency: every column of P sums to 1.0                   |
//| Final constraints which are passed to the underlying optimizer   |
//| are calculated as intersection of all present constraints. For   |
//| example, you may specify boundary constraint on P[0,0] and       |
//| equality one:                                                    |
//|     0.1<=P[0,0]<=0.9                                             |
//|     P[0,0]=0.5                                                   |
//| Such combination of constraints will be silently reduced to their|
//| intersection, which is P[0,0]=0.5.                               |
//| This function can be used to ADD equality constraint for one     |
//| element of P without changing constraints for other elements.    |
//| You can also use MCPDSetEC() function which allows you to specify|
//| arbitrary set of equality constraints in one call.               |
//| These functions (MCPDSetEC and MCPDAddEC) interact as follows:   |
//| * there is internal matrix of equality constraints which is      |
//|   stored in the MCPD solver                                      |
//| * MCPDSetEC() replaces this matrix by another one (SET)          |
//| * MCPDAddEC() modifies one element of this matrix and leaves     |
//|   other ones unchanged (ADD)                                     |
//| * thus MCPDAddEC() call preserves all modifications done by      |
//|   previous calls, while MCPDSetEC() completely discards all      |
//|   changes done to the equality constraints.                      |
//| INPUT PARAMETERS:                                                |
//|     S       -   solver                                           |
//|     I       -   row index of element being constrained           |
//|     J       -   column index of element being constrained        |
//|     C       -   value (constraint for P[I,J]). Can be either NAN |
//|                 (no constraint) or finite value from [0,1].      |
//| NOTES:                                                           |
//| 1. infinite values of C will lead to exception being thrown.     |
//| Values less than 0.0 or greater than 1.0 will lead to error code |
//| being returned after call to MCPDSolve().                        |
//+------------------------------------------------------------------+
void CAlglib::MCPDAddEC(CMCPDStateShell &s,const int i,const int j,
                        const double c)
  {
   CMarkovCPD::MCPDAddEC(s.GetInnerObj(),i,j,c);
  }
//+------------------------------------------------------------------+
//| This function is used to add bound constraints on the elements   |
//| of the transition matrix P.                                      |
//| MCPD solver has four types of constraints which can be placed    |
//| on P:                                                            |
//| * user-specified equality constraints (optional)                 |
//| * user-specified bound constraints (optional)                    |
//| * user-specified general linear constraints (optional)           |
//| * basic constraints (always present):                            |
//|   * non-negativity: P[i,j]>=0                                    |
//|   * consistency: every column of P sums to 1.0                   |
//| Final constraints which are passed to the underlying optimizer   |
//| are calculated as intersection of all present constraints. For   |
//| example, you may specify boundary constraint on P[0,0] and       |
//| equality one:                                                    |
//|     0.1<=P[0,0]<=0.9                                             |
//|     P[0,0]=0.5                                                   |
//| Such combination of constraints will be silently reduced to their|
//| intersection, which is P[0,0]=0.5.                               |
//| This function can be used to place bound constraints on arbitrary|
//| subset of elements of P. Set of constraints is specified by      |
//| BndL/BndU matrices, which may contain arbitrary combination of   |
//| finite numbers or infinities (like -INF<x<=0.5 or 0.1<=x<+INF).  |
//| You can also use MCPDAddBC() function which allows to ADD bound  |
//| constraint for one element of P without changing constraints for |
//| other elements.                                                  |
//| These functions (MCPDSetBC and MCPDAddBC) interact as follows:   |
//| * there is internal matrix of bound constraints which is stored  |
//|   in the MCPD solver                                             |
//| * MCPDSetBC() replaces this matrix by another one (SET)          |
//| * MCPDAddBC() modifies one element of this matrix and leaves     |
//|   other ones unchanged (ADD)                                     |
//| * thus MCPDAddBC() call preserves all modifications done by      |
//|   previous calls, while MCPDSetBC() completely discards all      |
//|   changes done to the equality constraints.                      |
//| INPUT PARAMETERS:                                                |
//|     S       -   solver                                           |
//|     BndL    -   lower bounds constraints, array[N,N]. Elements of|
//|                 BndL can be finite numbers or -INF.              |
//|     BndU    -   upper bounds constraints, array[N,N]. Elements of|
//|                 BndU can be finite numbers or +INF.              |
//+------------------------------------------------------------------+
void CAlglib::MCPDSetBC(CMCPDStateShell &s,CMatrixDouble &bndl,
                        CMatrixDouble &bndu)
  {
   CMarkovCPD::MCPDSetBC(s.GetInnerObj(),bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function is used to add bound constraints on the elements   |
//| of the transition matrix P.                                      |
//| MCPD solver has four types of constraints which can be placed    |
//| on P:                                                            |
//| * user-specified equality constraints (optional)                 |
//| * user-specified bound constraints (optional)                    |
//| * user-specified general linear constraints (optional)           |
//| * basic constraints (always present):                            |
//|   * non-negativity: P[i,j]>=0                                    |
//|   * consistency: every column of P sums to 1.0                   |
//| Final constraints which are passed to the underlying optimizer   |
//| are calculated as intersection of all present constraints. For   |
//| example, you may specify boundary constraint on P[0,0] and       |
//| equality one:                                                    |
//|     0.1<=P[0,0]<=0.9                                             |
//|     P[0,0]=0.5                                                   |
//| Such combination of constraints will be silently reduced to their|
//| intersection, which is P[0,0]=0.5.                               |
//| This function can be used to ADD bound constraint for one element|
//| of P without changing constraints for other elements.            |
//| You can also use MCPDSetBC() function which allows to place bound|
//| constraints on arbitrary subset of elements of P. Set of         |
//| constraints is specified  by  BndL/BndU matrices, which may      |
//| contain arbitrary combination of finite numbers or infinities    |
//| (like -INF<x<=0.5 or 0.1<=x<+INF).                               |
//| These functions (MCPDSetBC and MCPDAddBC) interact as follows:   |
//| * there is internal matrix of bound constraints which is stored  |
//|   in the MCPD solver                                             |
//| * MCPDSetBC() replaces this matrix by another one (SET)          |
//| * MCPDAddBC() modifies one element of this matrix and leaves     |
//|   other ones unchanged (ADD)                                     |
//| * thus MCPDAddBC() call preserves all modifications done by      |
//|   previous calls, while MCPDSetBC() completely discards all      |
//|   changes done to the equality constraints.                      |
//| INPUT PARAMETERS:                                                |
//|     S       -   solver                                           |
//|     I       -   row index of element being constrained           |
//|     J       -   column index of element being constrained        |
//|     BndL    -   lower bound                                      |
//|     BndU    -   upper bound                                      |
//+------------------------------------------------------------------+
void CAlglib::MCPDAddBC(CMCPDStateShell &s,const int i,const int j,
                        const double bndl,const double bndu)
  {
   CMarkovCPD::MCPDAddBC(s.GetInnerObj(),i,j,bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function is used to set linear equality/inequality          |
//| constraints on the elements of the transition matrix P.          |
//| This function can be used to set one or several general linear   |
//| constraints on the elements of P. Two types of constraints are   |
//| supported:                                                       |
//| * equality constraints                                           |
//| * inequality constraints (both less-or-equal and                 |
//|   greater-or-equal)                                              |
//| Coefficients of constraints are specified by matrix C (one of the|
//| parameters). One row of C corresponds to one constraint.         |
//| Because transition matrix P has N*N elements, we need N*N columns|
//| to store all coefficients  (they  are  stored row by row), and   |
//| one more column to store right part - hence C has N*N+1 columns. |
//| Constraint kind is stored in the CT array.                       |
//| Thus, I-th linear constraint is                                  |
//|     P[0,0]*C[I,0] + P[0,1]*C[I,1] + .. + P[0,N-1]*C[I,N-1] +     |
//|         + P[1,0]*C[I,N] + P[1,1]*C[I,N+1] + ... +                |
//|         + P[N-1,N-1]*C[I,N*N-1]  ?=?  C[I,N*N]                   |
//| where ?=? can be either "=" (CT[i]=0), "<=" (CT[i]<0) or ">="    |
//| (CT[i]>0).                                                       |
//| Your constraint may involve only some subset of P (less than N*N |
//| elements).                                                       |
//| For example it can be something like                             |
//|     P[0,0] + P[0,1] = 0.5                                        |
//| In this case you still should pass matrix  with N*N+1 columns,   |
//| but all its elements (except for C[0,0], C[0,1] and C[0,N*N-1])  |
//| will be zero.                                                    |
//| INPUT PARAMETERS:                                                |
//|     S       -   solver                                           |
//|     C       -   array[K,N*N+1] - coefficients of constraints     |
//|                 (see above for complete description)             |
//|     CT      -   array[K] - constraint types                      |
//|                 (see above for complete description)             |
//|     K       -   number of equality/inequality constraints, K>=0: |
//|                 * if given, only leading K elements of C/CT are  |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   sizes of C/CT                                  |
//+------------------------------------------------------------------+
void CAlglib::MCPDSetLC(CMCPDStateShell &s,CMatrixDouble &c,
                        int &ct[],const int k)
  {
   CMarkovCPD::MCPDSetLC(s.GetInnerObj(),c,ct,k);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MCPDSetLC(CMCPDStateShell &s,CMatrixDouble &c,
                        CRowInt &ct,const int k)
  {
   CMarkovCPD::MCPDSetLC(s.GetInnerObj(),c,ct,k);
  }
//+------------------------------------------------------------------+
//| This function is used to set linear equality/inequality          |
//| constraints on the elements of the transition matrix P.          |
//| This function can be used to set one or several general linear   |
//| constraints on the elements of P. Two types of constraints are   |
//| supported:                                                       |
//| * equality constraints                                           |
//| * inequality constraints (both less-or-equal and                 |
//|   greater-or-equal)                                              |
//| Coefficients of constraints are specified by matrix C (one of the|
//| parameters). One row of C corresponds to one constraint.         |
//| Because transition matrix P has N*N elements, we need N*N columns|
//| to store all coefficients  (they  are  stored row by row), and   |
//| one more column to store right part - hence C has N*N+1 columns. |
//| Constraint kind is stored in the CT array.                       |
//| Thus, I-th linear constraint is                                  |
//|     P[0,0]*C[I,0] + P[0,1]*C[I,1] + .. + P[0,N-1]*C[I,N-1] +     |
//|         + P[1,0]*C[I,N] + P[1,1]*C[I,N+1] + ... +                |
//|         + P[N-1,N-1]*C[I,N*N-1]  ?=?  C[I,N*N]                   |
//| where ?=? can be either "=" (CT[i]=0), "<=" (CT[i]<0) or ">="    |
//| (CT[i]>0).                                                       |
//| Your constraint may involve only some subset of P (less than N*N |
//| elements).                                                       |
//| For example it can be something like                             |
//|     P[0,0] + P[0,1] = 0.5                                        |
//| In this case you still should pass matrix  with N*N+1 columns,   |
//| but all its elements (except for C[0,0], C[0,1] and C[0,N*N-1])  |
//| will be zero.                                                    |
//| INPUT PARAMETERS:                                                |
//|     S       -   solver                                           |
//|     C       -   array[K,N*N+1] - coefficients of constraints     |
//|                 (see above for complete description)             |
//|     CT      -   array[K] - constraint types                      |
//|                 (see above for complete description)             |
//|     K       -   number of equality/inequality constraints, K>=0: |
//|                 * if given, only leading K elements of C/CT are  |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   sizes of C/CT                                  |
//+------------------------------------------------------------------+
void CAlglib::MCPDSetLC(CMCPDStateShell &s,CMatrixDouble &c,int &ct[])
  {
//--- check
   if((CAp::Rows(c)!=CAp::Len(ct)))
     {
      Print("Error while calling " + __FUNCTION__ + ": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int k=(int)CAp::Rows(c);
//--- function call
   CMarkovCPD::MCPDSetLC(s.GetInnerObj(),c,ct,k);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MCPDSetLC(CMCPDStateShell &s,CMatrixDouble &c,CRowInt &ct)
  {
//--- check
   if((CAp::Rows(c)!=CAp::Len(ct)))
     {
      Print("Error while calling " + __FUNCTION__ + ": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int k=(int)CAp::Rows(c);
//--- function call
   CMarkovCPD::MCPDSetLC(s.GetInnerObj(),c,ct,k);
  }
//+------------------------------------------------------------------+
//| This function allows to tune amount of Tikhonov regularization   |
//| being applied to your problem.                                   |
//| By default, regularizing term is equal to r*||P-prior_P||^2,     |
//| where r is a small non-zero value,  P is transition matrix,      |
//| prior_P is identity matrix, ||X||^2 is a sum of squared elements |
//| of X.                                                            |
//| This function allows you to change coefficient r. You can also   |
//| change prior values with MCPDSetPrior() function.                |
//| INPUT PARAMETERS:                                                |
//|     S      -   solver                                            |
//|     V      -   regularization  coefficient, finite non-negative  |
//|                value. It is not recommended to specify zero      |
//|                value unless you are pretty sure that you want it.|
//+------------------------------------------------------------------+
void CAlglib::MCPDSetTikhonovRegularizer(CMCPDStateShell &s,
                                         const double v)
  {
   CMarkovCPD::MCPDSetTikhonovRegularizer(s.GetInnerObj(),v);
  }
//+------------------------------------------------------------------+
//| This function allows to set prior values used for regularization |
//| of your problem.                                                 |
//| By default, regularizing term is equal to r*||P-prior_P||^2,     |
//| where r is a small non-zero value,  P is transition matrix,      |
//| prior_P is identity matrix, ||X||^2 is a sum of squared elements |
//| of X.                                                            |
//| This function allows you to change prior values prior_P. You can |
//| also change r with MCPDSetTikhonovRegularizer() function.        |
//| INPUT PARAMETERS:                                                |
//|     S       -   solver                                           |
//|     PP      -   array[N,N], matrix of prior values:              |
//|                 1. elements must be real numbers from [0,1]      |
//|                 2. columns must sum to 1.0.                      |
//|                 First property is checked (exception is thrown   |
//|                 otherwise), while second one is not              |
//|                 checked/enforced.                                |
//+------------------------------------------------------------------+
void CAlglib::MCPDSetPrior(CMCPDStateShell &s,CMatrixDouble &pp)
  {
   CMarkovCPD::MCPDSetPrior(s.GetInnerObj(),pp);
  }
//+------------------------------------------------------------------+
//| This function is used to change prediction weights               |
//| MCPD solver scales prediction errors as follows                  |
//|     Error(P) = ||W*(y-P*x)||^2                                   |
//| where                                                            |
//|     x is a system state at time t                                |
//|     y is a system state at time t+1                              |
//|     P is a transition matrix                                     |
//|     W is a diagonal scaling matrix                               |
//| By default, weights are chosen in order to minimize relative     |
//| prediction error instead of absolute one. For example, if one    |
//| component of state is about 0.5 in magnitude and another one is  |
//| about 0.05, then algorithm will make corresponding weights equal |
//| to 2.0 and 20.0.                                                 |
//| INPUT PARAMETERS:                                                |
//|     S       -   solver                                           |
//|     PW      -   array[N], weights:                               |
//|                 * must be non-negative values (exception will be |
//|                 thrown otherwise)                                |
//|                 * zero values will be replaced by automatically  |
//|                 chosen values                                    |
//+------------------------------------------------------------------+
void CAlglib::MCPDSetPredictionWeights(CMCPDStateShell &s,
                                       double &pw[])
  {
   CMarkovCPD::MCPDSetPredictionWeights(s.GetInnerObj(),pw);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MCPDSetPredictionWeights(CMCPDStateShell &s,
                                       CRowDouble &pw)
  {
   CMarkovCPD::MCPDSetPredictionWeights(s.GetInnerObj(),pw);
  }
//+------------------------------------------------------------------+
//| This function is used to start solution of the MCPD problem.     |
//| After return from this function, you can use MCPDResults() to get|
//| solution and completion code.                                    |
//+------------------------------------------------------------------+
void CAlglib::MCPDSolve(CMCPDStateShell &s)
  {
   CMarkovCPD::MCPDSolve(s.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| MCPD results                                                     |
//| INPUT PARAMETERS:                                                |
//|     State   -   algorithm state                                  |
//| OUTPUT PARAMETERS:                                               |
//|     P      -   array[N,N], transition matrix                     |
//|     Rep    -   optimization report. You should check Rep.        |
//|                TerminationType in order to distinguish successful|
//|                termination from unsuccessful one. Speaking short,|
//|                positive values denote success, negative ones are |
//|                failures. More information about fields of this   |
//|                structure  can befound in the comments on         |
//|                MCPDReport datatype.                              |
//+------------------------------------------------------------------+
void CAlglib::MCPDResults(CMCPDStateShell &s,CMatrixDouble &p,
                          CMCPDReportShell &rep)
  {
   CMarkovCPD::MCPDResults(s.GetInnerObj(),p,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Neural network training using modified Levenberg-Marquardt with  |
//| exact Hessian calculation and regularization. Subroutine trains  |
//| neural network with restarts from random positions. Algorithm is |
//| well suited for small                                            |
//| and medium scale problems (hundreds of weights).                 |
//| INPUT PARAMETERS:                                                |
//|     Network     -   neural network with initialized geometry     |
//|     XY          -   training set                                 |
//|     NPoints     -   training set size                            |
//|     Decay       -   weight decay constant, >=0.001               |
//|                     Decay term 'Decay*||Weights||^2' is added to |
//|                     error function.                              |
//|                     If you don't know what Decay to choose, use  |
//|                     0.001.                                       |
//|     Restarts    -   number of restarts from random position, >0. |
//|                     If you don't know what Restarts to choose,   |
//|                     use 2.                                       |
//| OUTPUT PARAMETERS:                                               |
//|     Network     -   trained neural network.                      |
//|     Info        -   return code:                                 |
//|                     * -9, if internal matrix inverse subroutine  |
//|                           failed                                 |
//|                     * -2, if there is a point with class number  |
//|                           outside of [0..NOut-1].                |
//|                     * -1, if wrong parameters specified          |
//|                           (NPoints<0, Restarts<1).               |
//|                     *  2, if task has been solved.               |
//|     Rep         -   training report                              |
//+------------------------------------------------------------------+
void CAlglib::MLPTrainLM(CMultilayerPerceptronShell &network,
                         CMatrixDouble &xy,const int npoints,
                         const double decay,const int restarts,
                         int &info,CMLPReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMLPTrain::MLPTrainLM(network.GetInnerObj(),xy,npoints,decay,restarts,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Neural network training using L-BFGS algorithm with              |
//| regularization. Subroutine trains neural network with restarts   |
//| from random positions. Algorithm is well suited for problems of  |
//| any dimensionality (memory requirements and step complexity are  |
//| linear by weights number).                                       |
//| INPUT PARAMETERS:                                                |
//|     Network    -   neural network with initialized geometry      |
//|     XY         -   training set                                  |
//|     NPoints    -   training set size                             |
//|     Decay      -   weight decay constant, >=0.001                |
//|                    Decay term 'Decay*||Weights||^2' is added to  |
//|                    error function.                               |
//|                    If you don't know what Decay to choose, use   |
//|                    0.001.                                        |
//|     Restarts   -   number of restarts from random position, >0.  |
//|                    If you don't know what Restarts to choose,    |
//|                    use 2.                                        |
//|     WStep      -   stopping criterion. Algorithm stops if step   |
//|                    size is less than WStep. Recommended          |
//|                    value - 0.01. Zero step size means stopping   |
//|                    after MaxIts iterations.                      |
//|     MaxIts     -   stopping criterion. Algorithm stops after     |
//|                    MaxIts iterations (NOT gradient calculations).|
//|                    Zero MaxIts means stopping when step is       |
//|                    sufficiently small.                           |
//| OUTPUT PARAMETERS:                                               |
//|     Network     -   trained neural network.                      |
//|     Info        -   return code:                                 |
//|                     * -8, if both WStep=0 and MaxIts=0           |
//|                     * -2, if there is a point with class number  |
//|                           outside of [0..NOut-1].                |
//|                     * -1, if wrong parameters specified          |
//|                           (NPoints<0, Restarts<1).               |
//|                     *  2, if task has been solved.               |
//|     Rep         -   training report                              |
//+------------------------------------------------------------------+
void CAlglib::MLPTrainLBFGS(CMultilayerPerceptronShell &network,
                            CMatrixDouble &xy,const int npoints,
                            const double decay,const int restarts,
                            const double wstep,int maxits,
                            int &info,CMLPReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMLPTrain::MLPTrainLBFGS(network.GetInnerObj(),xy,npoints,decay,restarts,wstep,maxits,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Neural network training using early stopping (base algorithm -   |
//| L-BFGS with regularization).                                     |
//| INPUT PARAMETERS:                                                |
//|     Network     -   neural network with initialized geometry     |
//|     TrnXY       -   training set                                 |
//|     TrnSize     -   training set size                            |
//|     ValXY       -   validation set                               |
//|     ValSize     -   validation set size                          |
//|     Decay       -   weight decay constant, >=0.001               |
//|                     Decay term 'Decay*||Weights||^2' is added to |
//|                     error function.                              |
//|                     If you don't know what Decay to choose, use  |
//|                     0.001.                                       |
//|     Restarts    -   number of restarts from random position, >0. |
//|                     If you don't know what Restarts to choose,   |
//|                     use 2.                                       |
//| OUTPUT PARAMETERS:                                               |
//|     Network     -   trained neural network.                      |
//|     Info        -   return code:                                 |
//|                     * -2, if there is a point with class number  |
//|                           outside of [0..NOut-1].                |
//|                     * -1, if wrong parameters specified          |
//|                           (NPoints<0, Restarts<1, ...).          |
//|                     *  2, task has been solved, stopping         |
//|                           criterion met - sufficiently small     |
//|                           step size. Not expected (we use EARLY  |
//|                           stopping) but possible and not an error|
//|                     *  6, task has been solved, stopping         |
//|                           criterion  met - increasing of         |
//|                           validation set error.                  |
//|     Rep         -   training report                              |
//| NOTE:                                                            |
//| Algorithm stops if validation set error increases for a long     |
//| enough or step size is small enought (there are task where       |
//| validation set may decrease for eternity). In any case solution  |
//| returned corresponds to the minimum of validation set error.     |
//+------------------------------------------------------------------+
void CAlglib::MLPTrainES(CMultilayerPerceptronShell &network,
                         CMatrixDouble &trnxy,const int trnsize,
                         CMatrixDouble &valxy,const int valsize,
                         const double decay,const int restarts,
                         int &info,CMLPReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMLPTrain::MLPTrainES(network.GetInnerObj(),trnxy,trnsize,valxy,valsize,decay,restarts,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Cross-validation estimate of generalization error.               |
//| Base algorithm - L-BFGS.                                         |
//| INPUT PARAMETERS:                                                |
//|     Network     -   neural network with initialized geometry.    |
//|                     Network is not changed during                |
//|                     cross-validation - it is used only as a      |
//|                     representative of its architecture.          |
//|     XY          -   training set.                                |
//|     SSize       -   training set size                            |
//|     Decay       -   weight  decay, same as in MLPTrainLBFGS      |
//|     Restarts    -   number of restarts, >0.                      |
//|                     restarts are counted for each partition      |
//|                     separately, so total number of restarts will |
//|                     be Restarts*FoldsCount.                      |
//|     WStep       -   stopping criterion, same as in MLPTrainLBFGS |
//|     MaxIts      -   stopping criterion, same as in MLPTrainLBFGS |
//|     FoldsCount  -   number of folds in k-fold cross-validation,  |
//|                     2<=FoldsCount<=SSize.                        |
//|                     recommended value: 10.                       |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   return code, same as in MLPTrainLBFGS        |
//|     Rep         -   report, same as in MLPTrainLM/MLPTrainLBFGS  |
//|     CVRep       -   generalization error estimates               |
//+------------------------------------------------------------------+
void CAlglib::MLPKFoldCVLBFGS(CMultilayerPerceptronShell &network,
                              CMatrixDouble &xy,const int npoints,
                              const double decay,const int restarts,
                              const double wstep,const int maxits,
                              const int foldscount,int &info,
                              CMLPReportShell &rep,CMLPCVReportShell &cvrep)
  {
//--- initialization
   info=0;
//--- function call
   CMLPTrain::MLPKFoldCVLBFGS(network.GetInnerObj(),xy,npoints,decay,restarts,wstep,maxits,foldscount,info,rep.GetInnerObj(),cvrep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Cross-validation estimate of generalization error.               |
//| Base algorithm - Levenberg-Marquardt.                            |
//| INPUT PARAMETERS:                                                |
//|     Network     -   neural network with initialized geometry.    |
//|                     Network is not changed during                |
//|                     cross-validation - it is used only as a      |
//|                     representative of its architecture.          |
//|     XY          -   training set.                                |
//|     SSize       -   training set size                            |
//|     Decay       -   weight  decay, same as in MLPTrainLBFGS      |
//|     Restarts    -   number of restarts, >0.                      |
//|                     restarts are counted for each partition      |
//|                     separately, so total number of restarts will |
//|                     be Restarts*FoldsCount.                      |
//|     FoldsCount  -   number of folds in k-fold cross-validation,  |
//|                     2<=FoldsCount<=SSize.                        |
//|                     recommended value: 10.                       |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   return code, same as in MLPTrainLBFGS        |
//|     Rep         -   report, same as in MLPTrainLM/MLPTrainLBFGS  |
//|     CVRep       -   generalization error estimates               |
//+------------------------------------------------------------------+
void CAlglib::MLPKFoldCVLM(CMultilayerPerceptronShell &network,
                           CMatrixDouble &xy,const int npoints,
                           const double decay,const int restarts,
                           const int foldscount,int &info,
                           CMLPReportShell &rep,CMLPCVReportShell &cvrep)
  {
//--- initialization
   info=0;
//--- function call
   CMLPTrain::MLPKFoldCVLM(network.GetInnerObj(),xy,npoints,decay,restarts,foldscount,info,rep.GetInnerObj(),cvrep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Creation of the network trainer object for regression networks   |
//| INPUT PARAMETERS:                                                |
//|   NIn         -  number of inputs, NIn>=1                        |
//|   NOut        -  number of outputs, NOut>=1                      |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  neural network trainer object.                  |
//| This structure can be used to train any regression network with  |
//| NIn inputs and NOut outputs.                                     |
//+------------------------------------------------------------------+
void CAlglib::MLPCreateTrainer(int nin,int nout,CMLPTrainer &s)
  {
   CMLPTrain::MLPCreateTrainer(nin,nout,s);
  }
//+------------------------------------------------------------------+
//| Creation of the network trainer object for classification        |
//| networks                                                         |
//| INPUT PARAMETERS:                                                |
//|   NIn         -  number of inputs, NIn>=1                        |
//|   NClasses    -  number of classes, NClasses>=2                  |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  neural network trainer object.                  |
//| This structure can be used to train any classification network   |
//| with NIn inputs and NOut outputs.                                |
//+------------------------------------------------------------------+
void CAlglib::MLPCreateTrainerCls(int nin,int nclasses,CMLPTrainer &s)
  {
   CMLPTrain::MLPCreateTrainerCls(nin,nclasses,s);
  }
//+------------------------------------------------------------------+
//| This function sets "current dataset" of the trainer object to one|
//| passed by user.                                                  |
//| INPUT PARAMETERS:                                                |
//|   S           -  trainer object                                  |
//|   XY          -  training set, see below for information on the  |
//|                  training set format. This function checks       |
//|                  correctness of the dataset (no NANs/INFs, class |
//|                  numbers are correct) and throws exception when  |
//|                  incorrect dataset is passed.                    |
//|   NPoints     -  points count, >=0.                              |
//| DATASET FORMAT:                                                  |
//|   This function uses two different dataset formats - one for     |
//|   regression networks, another one for classification networks.  |
//| For regression networks with NIn inputs and NOut outputs         |
//| following dataset format is used:                                |
//|      * dataset is given by NPoints*(NIn+NOut) matrix             |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, next NOut columns are       |
//|        outputs                                                   |
//| For classification networks with NIn inputs and NClasses clases  |
//| following datasetformat is used:                                 |
//|      * dataset is given by NPoints*(NIn+1) matrix                |
//|      * each row corresponds to one example                       |
//|      * first NIn columns are inputs, last column stores class    |
//|        number (from 0 to NClasses-1).                            |
//+------------------------------------------------------------------+
void CAlglib::MLPSetDataset(CMLPTrainer &s,CMatrixDouble &xy,int npoints)
  {
   CMLPTrain::MLPSetDataset(s,xy,npoints);
  }
//+------------------------------------------------------------------+
//| This function sets "current dataset" of the trainer object to one|
//| passed by user (sparse matrix is used to store dataset).         |
//| INPUT PARAMETERS:                                                |
//|   S        -  trainer object                                     |
//|   XY       -  training set, see below for information on the     |
//|               training set format. This function checks          |
//|               correctness of the dataset (no NANs/INFs, class    |
//|               numbers are correct) and throws exception when     |
//|               incorrect dataset is passed. Any sparse storage    |
//|               format can be used: Hash-table, CRS...             |
//|   NPoints  -  points count, >=0                                  |
//| DATASET FORMAT:                                                  |
//|   This function uses two different dataset formats - one for     |
//|   regression networks, another one for classification networks.  |
//| For regression networks with NIn inputs and NOut outputs         |
//| following dataset format is used:                                |
//|   * dataset is given by NPoints*(NIn+NOut) matrix                |
//|   * each row corresponds to one example                          |
//|   * first NIn columns are inputs, next NOut columns are outputs  |
//| For classification networks with NIn inputs and NClasses clases  |
//| following datasetformat is used:                                 |
//|   * dataset is given by NPoints*(NIn+1) matrix                   |
//|   * each row corresponds to one example                          |
//|   * first NIn columns are inputs, last column stores class number|
//|     (from 0 to NClasses-1).                                      |
//+------------------------------------------------------------------+
void CAlglib::MLPSetSparseDataset(CMLPTrainer &s,CSparseMatrix &xy,int npoints)
  {
   CMLPTrain::MLPSetSparseDataset(s,xy,npoints);
  }
//+------------------------------------------------------------------+
//| This function sets weight decay coefficient which is used for    |
//| training.                                                        |
//| INPUT PARAMETERS:                                                |
//|   S        -  trainer object                                     |
//|   Decay    -  weight decay coefficient, >=0. Weight decay term   |
//|               'Decay*||Weights||^2' is added to error function.  |
//|               If you don't know what Decay to choose, use 1.0E-3.|
//|               Weight decay can be set to zero, in this case      |
//|               network is trained without weight decay.           |
//| NOTE: by default network uses some small nonzero value for weight|
//| decay.                                                           |
//+------------------------------------------------------------------+
void CAlglib::MLPSetDecay(CMLPTrainer &s,double decay)
  {
   CMLPTrain::MLPSetDecay(s,decay);
  }
//+------------------------------------------------------------------+
//| This function sets stopping criteria for the optimizer.          |
//| INPUT PARAMETERS:                                                |
//|   S        -  trainer object                                     |
//|   WStep    -  stopping criterion. Algorithm stops if step size is|
//|               less than WStep. Recommended value - 0.01. Zero    |
//|               step size means stopping after MaxIts iterations.  |
//|               WStep>=0.                                          |
//|   MaxIts   -  stopping criterion. Algorithm stops after MaxIts   |
//|               epochs (full passes over entire dataset). Zero     |
//|               MaxIts means stopping when step is sufficiently    |
//|               small. MaxIts>=0.                                  |
//| NOTE: by default, WStep=0.005 and MaxIts=0 are used. These values|
//|       are also used when MLPSetCond() is called with WStep=0 and |
//|       MaxIts=0.                                                  |
//| NOTE: these stopping criteria are used for all kinds of neural   |
//|       training-from "conventional" networks to early stopping  |
//|       ensembles. When used for "conventional" networks, they are |
//|       used as the only stopping criteria. When combined with     |
//|       early stopping, they used as ADDITIONAL stopping criteria  |
//|       which can terminate early stopping algorithm.              |
//+------------------------------------------------------------------+
void CAlglib::MLPSetCond(CMLPTrainer &s,double wstep,int maxits)
  {
   CMLPTrain::MLPSetCond(s,wstep,maxits);
  }
//+------------------------------------------------------------------+
//| This function sets training algorithm: batch training using      |
//| L-BFGS will be used.                                             |
//| This algorithm:                                                  |
//|   * the most robust for small-scale problems, but may be too slow|
//|     for large scale ones.                                        |
//|   * perfoms full pass through the dataset before performing step |
//|   * uses conditions specified by MLPSetCond() for stopping       |
//|   * is default one used by trainer object                        |
//| INPUT PARAMETERS:                                                |
//|   S        -  trainer object                                     |
//+------------------------------------------------------------------+
void CAlglib::MLPSetAlgoBatch(CMLPTrainer &s)
  {
   CMLPTrain::MLPSetAlgoBatch(s);
  }
//+------------------------------------------------------------------+
//| This function trains neural network passed to this function,     |
//| using current dataset (one which was passed to MLPSetDataset()   |
//| or MLPSetSparseDataset()) and current training settings. Training|
//| from NRestarts random starting positions is performed, best      |
//| network is chosen.                                               |
//| Training is performed using current training algorithm.          |
//| INPUT PARAMETERS:                                                |
//|   S        -  trainer object                                     |
//|   Network  -  neural network. It must have same number of inputs |
//|               and output/classes as was specified during creation|
//|               of the trainer object.                             |
//|   NRestarts-  number of restarts, >=0:                           |
//|               * NRestarts>0 means that specified number of random|
//|                 restarts are performed, best network is chosen   |
//|                 after training                                   |
//|               * NRestarts=0 means that current state of the      |
//|                 network is used for training.                    |
//| OUTPUT PARAMETERS:                                               |
//|   Network  -  trained network                                    |
//| NOTE: when no dataset was specified with MLPSetDataset /         |
//|       SetSparseDataset(), network is filled by zero values. Same |
//|       behavior for functions MLPStartTraining and                |
//|       MLPContinueTraining.                                       |
//| NOTE: this method uses sum-of-squares error function for training|
//+------------------------------------------------------------------+
void CAlglib::MLPTrainNetwork(CMLPTrainer &s,
                              CMultilayerPerceptronShell &network,
                              int nrestarts,CMLPReportShell &rep)
  {
   CMLPTrain::MLPTrainNetwork(s,network.GetInnerObj(),nrestarts,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| IMPORTANT: this is an "expert" version of the MLPTrain() function|
//|            We do not recommend you to use it unless you are      |
//|            pretty sure that you need ability to monitor training |
//|            progress.                                             |
//| This function performs step-by-step training of the neural       |
//| network. Here "step-by-step" means that training starts with     |
//| MLPStartTraining() call, and then user subsequently calls        |
//| MLPContinueTraining() to perform one more iteration of the       |
//| training.                                                        |
//| After call to this function trainer object remembers network and |
//| is ready to train it. However, no training is performed until    |
//| first call to MLPContinueTraining() function. Subsequent calls   |
//| to MLPContinueTraining() will advance training progress one      |
//| iteration further.                                               |
//| EXAMPLE:                                                         |
//|   >                                                              |
//|   > ...initialize network and trainer object....                 |
//|   >                                                              |
//|   > MLPStartTraining(Trainer, Network, True)                     |
//|   > while MLPContinueTraining(Trainer, Network) do               |
//|   >     ...visualize training progress...                        |
//|   >                                                              |
//| INPUT PARAMETERS:                                                |
//|   S        -  trainer object                                     |
//|   Network  -  neural network. It must have same number of inputs |
//|               and output/classes as was specified during creation|
//|               of the trainer object.                             |
//|   RandomStart -  randomize network before training or not:       |
//|               * True means that network is randomized and its    |
//|                 initial state (one which was passed to the       |
//|                 trainer object) is lost.                         |
//|               * False means that training is started from the    |
//|                 current state of the network                     |
//| OUTPUT PARAMETERS:                                               |
//|   Network  -  neural network which is ready to training (weights |
//|               are initialized, preprocessor is initialized using |
//|               current training set)                              |
//| NOTE: this method uses sum-of-squares error function for training|
//| NOTE: it is expected that trainer object settings are NOT changed|
//|       during step-by-step training, i.e. no one changes stopping |
//|       criteria or training set during training. It is possible   |
//|       and there is no defense against such actions, but algorithm|
//|       behavior in such cases is undefined and can be             |
//|       unpredictable.                                             |
//+------------------------------------------------------------------+
void CAlglib::MLPStartTraining(CMLPTrainer &s,
                               CMultilayerPerceptronShell &network,
                               bool randomstart)
  {
   CMLPTrain::MLPStartTraining(s,network.GetInnerObj(),randomstart);
  }
//+------------------------------------------------------------------+
//| IMPORTANT: this is an "expert" version of the MLPTrain() function|
//|            We do not recommend you to use it unless you are      |
//|            pretty sure that you need ability to monitor training |
//|            progress.                                             |
//| This function performs step-by-step training of the neural       |
//| network. Here "step-by-step" means that training starts with     |
//| MLPStartTraining() call, and then user subsequently calls        |
//| MLPContinueTraining() to perform one more iteration of the       |
//| training.                                                        |
//| This function performs one more iteration of the training and    |
//| returns either True (training continues) or False (training      |
//| stopped). In case True was returned, Network weights are updated |
//| according to the  current  state of the optimization progress.   |
//| In case False was returned, no additional updates is performed   |
//| (previous update of the network weights moved us to the final    |
//| point, and no additional updates is needed).                     |
//| EXAMPLE:                                                         |
//|   >                                                              |
//|   > [initialize network and trainer object]                      |
//|   >                                                              |
//|   > MLPStartTraining(Trainer, Network, True)                     |
//|   > while MLPContinueTraining(Trainer, Network) do               |
//|   >     [visualize training progress]                            |
//|   >                                                              |
//| INPUT PARAMETERS:                                                |
//|   S        -  trainer object                                     |
//|   Network  -  neural network structure, which is used to store   |
//|               current state of the training process.             |
//| OUTPUT PARAMETERS:                                               |
//|   Network  -  weights of the neural network are rewritten by the |
//|               current approximation.                             |
//| NOTE: this method uses sum-of-squares error function for training|
//| NOTE: it is expected that trainer object settings are NOT changed|
//|       during step-by-step training, i.e. no one changes stopping |
//|       criteria or training set during training. It is possible   |
//|       and there is no defense against such actions, but algorithm|
//|       behavior in such cases is undefined and can be             |
//|       unpredictable.                                             |
//| NOTE: It is expected that Network is the same one which was      |
//|       passed to MLPStartTraining() function. However, THIS       |
//|       function checks only following:                            |
//|         * that number of network inputs is consistent with       |
//|           trainer object settings                                |
//|         * that number of network outputs / classes is consistent |
//|           with trainer object settings                           |
//|         * that number of network weights is the same as number of|
//|           weights in the network passed to MLPStartTraining()    |
//|           function Exception is thrown when these conditions are |
//|           violated.                                              |
//| It is also expected that you do not change state of the network  |
//| on your own - the only party who has right to change network     |
//| during its training is a trainer object. Any attempt to interfere|
//| with trainer may lead to unpredictable results.                  |
//+------------------------------------------------------------------+
bool CAlglib::MLPContinueTraining(CMLPTrainer &s,
                                  CMultilayerPerceptronShell &network)
  {
   return(CMLPTrain::MLPContinueTraining(s,network.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This function trains neural network ensemble passed to this      |
//| function using current dataset and early stopping training       |
//| algorithm. Each early stopping round performs NRestarts random   |
//| restarts (thus, EnsembleSize*NRestarts training rounds is        |
//| performed in total).                                             |
//| INPUT PARAMETERS:                                                |
//|   S           -  trainer object;                                 |
//|   Ensemble    -  neural network ensemble. It must have same      |
//|                  number of inputs and outputs/classes as was     |
//|                  specified during creation of the trainer object.|
//|   NRestarts   -  number of restarts, >=0:                        |
//|                  * NRestarts>0 means that specified number of    |
//|                    random restarts are performed during each ES  |
//|                    round;                                        |
//|                  * NRestarts=0 is silently replaced by 1.        |
//| OUTPUT PARAMETERS:                                               |
//|   Ensemble    -  trained ensemble;                               |
//|   Rep         -  it contains all type of errors.                 |
//| NOTE: this training method uses BOTH early stopping and weight   |
//|       decay! So, you should select weight decay before starting  |
//|       training just as you select it before training             |
//|       "conventional" networks.                                   |
//| NOTE: when no dataset was specified with MLPSetDataset /         |
//|       SetSparseDataset(), or single-point dataset was passed,    |
//|       ensemble is filled by zero values.                         |
//| NOTE: this method uses sum-of-squares error function for training|
//+------------------------------------------------------------------+
void CAlglib::MLPTrainEnsembleES(CMLPTrainer &s,
                                 CMLPEnsembleShell &ensemble,
                                 int nrestarts,
                                 CMLPReportShell &rep)
  {
   CMLPTrain::MLPTrainEnsembleES(s,ensemble.GetInnerObj(),nrestarts,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreate0, but for ensembles.                              |
//+------------------------------------------------------------------+
void CAlglib::MLPECreate0(const int nin,const int nout,const int ensemblesize,
                          CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreate0(nin,nout,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreate1, but for ensembles.                              |
//+------------------------------------------------------------------+
void CAlglib::MLPECreate1(const int nin,int nhid,const int nout,
                          const int ensemblesize,
                          CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreate1(nin,nhid,nout,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreate2, but for ensembles.                              |
//+------------------------------------------------------------------+
void CAlglib::MLPECreate2(const int nin,const int nhid1,const int nhid2,
                          const int nout,const int ensemblesize,
                          CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreate2(nin,nhid1,nhid2,nout,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreateB0, but for ensembles.                             |
//+------------------------------------------------------------------+
void CAlglib::MLPECreateB0(const int nin,const int nout,const double b,
                           const double d,const int ensemblesize,
                           CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreateB0(nin,nout,b,d,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreateB1, but for ensembles.                             |
//+------------------------------------------------------------------+
void CAlglib::MLPECreateB1(const int nin,int nhid,const int nout,
                           const double b,const double d,const int ensemblesize,
                           CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreateB1(nin,nhid,nout,b,d,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreateB2, but for ensembles.                             |
//+------------------------------------------------------------------+
void CAlglib::MLPECreateB2(const int nin,const int nhid1,const int nhid2,
                           const int nout,const double b,const double d,
                           const int ensemblesize,CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreateB2(nin,nhid1,nhid2,nout,b,d,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreateR0, but for ensembles.                             |
//+------------------------------------------------------------------+
void CAlglib::MLPECreateR0(const int nin,const int nout,const double a,
                           const double b,const int ensemblesize,
                           CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreateR0(nin,nout,a,b,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreateR1, but for ensembles.                             |
//+------------------------------------------------------------------+
void CAlglib::MLPECreateR1(const int nin,int nhid,const int nout,
                           const double a,const double b,const int ensemblesize,
                           CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreateR1(nin,nhid,nout,a,b,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreateR2, but for ensembles.                             |
//+------------------------------------------------------------------+
void CAlglib::MLPECreateR2(const int nin,const int nhid1,const int nhid2,
                           const int nout,const double a,const double b,
                           const int ensemblesize,CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreateR2(nin,nhid1,nhid2,nout,a,b,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreateC0, but for ensembles.                             |
//+------------------------------------------------------------------+
void CAlglib::MLPECreateC0(const int nin,const int nout,
                           const int ensemblesize,CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreateC0(nin,nout,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreateC1, but for ensembles.                             |
//+------------------------------------------------------------------+
void CAlglib::MLPECreateC1(const int nin,int nhid,const int nout,
                           const int ensemblesize,CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreateC1(nin,nhid,nout,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Like MLPCreateC2, but for ensembles.                             |
//+------------------------------------------------------------------+
void CAlglib::MLPECreateC2(const int nin,const int nhid1,const int nhid2,
                           const int nout,const int ensemblesize,
                           CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreateC2(nin,nhid1,nhid2,nout,ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Creates ensemble from network. Only network geometry is copied.  |
//+------------------------------------------------------------------+
void CAlglib::MLPECreateFromNetwork(CMultilayerPerceptronShell &network,
                                    const int ensemblesize,
                                    CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPECreateFromNetwork(network.GetInnerObj(),ensemblesize,ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Randomization of MLP ensemble                                    |
//+------------------------------------------------------------------+
void CAlglib::MLPERandomize(CMLPEnsembleShell &ensemble)
  {
   CMLPE::MLPERandomize(ensemble.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Return ensemble properties (number of inputs and outputs).       |
//+------------------------------------------------------------------+
void CAlglib::MLPEProperties(CMLPEnsembleShell &ensemble,
                             int &nin,int &nout)
  {
//--- initialization
   nin=0;
   nout=0;
//--- function call
   CMLPE::MLPEProperties(ensemble.GetInnerObj(),nin,nout);
  }
//+------------------------------------------------------------------+
//| Return normalization type (whether ensemble is SOFTMAX-normalized|
//| or not).                                                         |
//+------------------------------------------------------------------+
bool CAlglib::MLPEIsSoftMax(CMLPEnsembleShell &ensemble)
  {
   return(CMLPE::MLPEIsSoftMax(ensemble.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| Procesing                                                        |
//| INPUT PARAMETERS:                                                |
//|     Ensemble-   neural networks ensemble                         |
//|     X       -   input vector,  array[0..NIn-1].                  |
//|     Y       -   (possibly) preallocated buffer; if size of Y is  |
//|                 less than NOut, it will be reallocated. If it is |
//|                 large enough, it is NOT reallocated, so we can   |
//|                 save some time on reallocation.                  |
//| OUTPUT PARAMETERS:                                               |
//|     Y       -   result. Regression estimate when solving         |
//|                 regression task, vector of posterior             |
//|                 probabilities for classification task.           |
//+------------------------------------------------------------------+
void CAlglib::MLPEProcess(CMLPEnsembleShell &ensemble,
                          double &x[],double &y[])
  {
   CMLPE::MLPEProcess(ensemble.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//| 'interactive' variant of MLPEProcess for languages like Python   |
//| which support constructs like "Y = MLPEProcess(LM,X)" and        |
//| interactive mode of the interpreter                              |
//| This function allocates new array on each call, so it is         |
//| significantly slower than its 'non-interactive' counterpart, but |
//| it is more convenient when you call it from command line.        |
//+------------------------------------------------------------------+
void CAlglib::MLPEProcessI(CMLPEnsembleShell &ensemble,
                           double &x[],double &y[])
  {
   CMLPE::MLPEProcessI(ensemble.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//| Relative classification error on the test set                    |
//| INPUT PARAMETERS:                                                |
//|     Ensemble-   ensemble                                         |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     percent of incorrectly classified cases.                     |
//|     Works both for classifier betwork and for regression networks|
//|     which are used as classifiers.                               |
//+------------------------------------------------------------------+
double CAlglib::MLPERelClsError(CMLPEnsembleShell &ensemble,
                                CMatrixDouble &xy,const int npoints)
  {
   return(CMLPE::MLPERelClsError(ensemble.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average cross-entropy (in bits per element) on the test set      |
//| INPUT PARAMETERS:                                                |
//|     Ensemble-   ensemble                                         |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     CrossEntropy/(NPoints*LN(2)).                                |
//|     Zero if ensemble solves regression task.                     |
//+------------------------------------------------------------------+
double CAlglib::MLPEAvgCE(CMLPEnsembleShell &ensemble,
                          CMatrixDouble &xy,const int npoints)
  {
   return(CMLPE::MLPEAvgCE(ensemble.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| RMS error on the test set                                        |
//| INPUT PARAMETERS:                                                |
//|     Ensemble-   ensemble                                         |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     root mean square error.                                      |
//|     Its meaning for regression task is obvious. As for           |
//|     classification task RMS error means error when estimating    |
//|     posterior probabilities.                                     |
//+------------------------------------------------------------------+
double CAlglib::MLPERMSError(CMLPEnsembleShell &ensemble,
                             CMatrixDouble &xy,const int npoints)
  {
   return(CMLPE::MLPERMSError(ensemble.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average error on the test set                                    |
//| INPUT PARAMETERS:                                                |
//|     Ensemble-   ensemble                                         |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     Its meaning for regression task is obvious. As for           |
//|     classification task it means average error when estimating   |
//|     posterior probabilities.                                     |
//+------------------------------------------------------------------+
double CAlglib::MLPEAvgError(CMLPEnsembleShell &ensemble,
                             CMatrixDouble &xy,const int npoints)
  {
   return(CMLPE::MLPEAvgError(ensemble.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average relative error on the test set                           |
//| INPUT PARAMETERS:                                                |
//|     Ensemble-   ensemble                                         |
//|     XY      -   test set                                         |
//|     NPoints -   test set size                                    |
//| RESULT:                                                          |
//|     Its meaning for regression task is obvious. As for           |
//|     classification task it means average relative error when     |
//|     estimating posterior probabilities.                          |
//+------------------------------------------------------------------+
double CAlglib::MLPEAvgRelError(CMLPEnsembleShell &ensemble,
                                CMatrixDouble &xy,const int npoints)
  {
   return(CMLPE::MLPEAvgRelError(ensemble.GetInnerObj(),xy,npoints));
  }
//+------------------------------------------------------------------+
//| Training neural networks ensemble using  bootstrap  aggregating  |
//| (bagging).                                                       |
//| Modified Levenberg-Marquardt algorithm is used as base training  |
//| method.                                                          |
//| INPUT PARAMETERS:                                                |
//|     Ensemble    -   model with initialized geometry              |
//|     XY          -   training set                                 |
//|     NPoints     -   training set size                            |
//|     Decay       -   weight decay coefficient, >=0.001            |
//|     Restarts    -   restarts, >0.                                |
//| OUTPUT PARAMETERS:                                               |
//|     Ensemble    -   trained model                                |
//|     Info        -   return code:                                 |
//|                     * -2, if there is a point with class number  |
//|                           outside of [0..NClasses-1].            |
//|                     * -1, if incorrect parameters was passed     |
//|                           (NPoints<0, Restarts<1).               |
//|                     *  2, if task has been solved.               |
//|     Rep         -   training report.                             |
//|     OOBErrors   -   out-of-bag generalization error estimate     |
//+------------------------------------------------------------------+
void CAlglib::MLPEBaggingLM(CMLPEnsembleShell &ensemble,CMatrixDouble &xy,
                            const int npoints,const double decay,
                            const int restarts,int &info,
                            CMLPReportShell &rep,CMLPCVReportShell &ooberrors)
  {
//--- initialization
   info=0;
//--- function call
   CMLPTrain::MLPEBaggingLM(ensemble.GetInnerObj(),xy,npoints,decay,restarts,info,rep.GetInnerObj(),ooberrors.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Training neural networks ensemble using  bootstrap aggregating   |
//| (bagging). L-BFGS algorithm is used as base training method.     |
//| INPUT PARAMETERS:                                                |
//|     Ensemble    -   model with initialized geometry              |
//|     XY          -   training set                                 |
//|     NPoints     -   training set size                            |
//|     Decay       -   weight decay coefficient, >=0.001            |
//|     Restarts    -   restarts, >0.                                |
//|     WStep       -   stopping criterion, same as in MLPTrainLBFGS |
//|     MaxIts      -   stopping criterion, same as in MLPTrainLBFGS |
//| OUTPUT PARAMETERS:                                               |
//|     Ensemble    -   trained model                                |
//|     Info        -   return code:                                 |
//|                     * -8, if both WStep=0 and MaxIts=0           |
//|                     * -2, if there is a point with class number  |
//|                           outside of [0..NClasses-1].            |
//|                     * -1, if incorrect parameters was passed     |
//|                           (NPoints<0, Restarts<1).               |
//|                     *  2, if task has been solved.               |
//|     Rep         -   training report.                             |
//|     OOBErrors   -   out-of-bag generalization error estimate     |
//+------------------------------------------------------------------+
void CAlglib::MLPEBaggingLBFGS(CMLPEnsembleShell &ensemble,CMatrixDouble &xy,
                               const int npoints,const double decay,
                               const int restarts,const double wstep,
                               const int maxits,int &info,
                               CMLPReportShell &rep,
                               CMLPCVReportShell &ooberrors)
  {
//--- initialization
   info=0;
//--- function call
   CMLPTrain::MLPEBaggingLBFGS(ensemble.GetInnerObj(),xy,npoints,decay,restarts,wstep,maxits,info,rep.GetInnerObj(),ooberrors.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Training neural networks ensemble using early stopping.          |
//| INPUT PARAMETERS:                                                |
//|     Ensemble    -   model with initialized geometry              |
//|     XY          -   training set                                 |
//|     NPoints     -   training set size                            |
//|     Decay       -   weight decay coefficient, >=0.001            |
//|     Restarts    -   restarts, >0.                                |
//| OUTPUT PARAMETERS:                                               |
//|     Ensemble    -   trained model                                |
//|     Info        -   return code:                                 |
//|                     * -2, if there is a point with class number  |
//|                           outside of [0..NClasses-1].            |
//|                     * -1, if incorrect parameters was passed     |
//|                           (NPoints<0, Restarts<1).               |
//|                     *  6, if task has been solved.               |
//|     Rep         -   training report.                             |
//|     OOBErrors   -   out-of-bag generalization error estimate     |
//+------------------------------------------------------------------+
void CAlglib::MLPETrainES(CMLPEnsembleShell &ensemble,CMatrixDouble &xy,
                          const int npoints,const double decay,
                          const int restarts,int &info,
                          CMLPReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMLPTrain::MLPETrainES(ensemble.GetInnerObj(),xy,npoints,decay,restarts,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Principal components analysis                                    |
//| Subroutine builds orthogonal basis where first axis corresponds  |
//| to direction with maximum variance, second axis maximizes        |
//| variance in subspace orthogonal to first axis and so on.         |
//| It should be noted that, unlike LDA, PCA does not use class      |
//| labels.                                                          |
//| INPUT PARAMETERS:                                                |
//|     X           -   dataset, array[0..NPoints-1,0..NVars-1].     |
//|                     matrix contains ONLY INDEPENDENT VARIABLES.  |
//|     NPoints     -   dataset size, NPoints>=0                     |
//|     NVars       -   number of independent variables, NVars>=1    |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   return code:                                 |
//|                     * -4, if SVD subroutine haven't converged    |
//|                     * -1, if wrong parameters has been passed    |
//|                           (NPoints<0, NVars<1)                   |
//|                     *  1, if task is solved                      |
//|     S2          -   array[0..NVars-1]. variance values           |
//|                     corresponding to basis vectors.              |
//|     V           -   array[0..NVars-1,0..NVars-1]                 |
//|                     matrix, whose columns store basis vectors.   |
//+------------------------------------------------------------------+
void CAlglib::PCABuildBasis(CMatrixDouble &x,const int npoints,
                            const int nvars,int &info,double &s2[],
                            CMatrixDouble &v)
  {
//--- initialization
   info=0;
//--- function call
   CPCAnalysis::PCABuildBasis(x,npoints,nvars,info,s2,v);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::PCABuildBasis(CMatrixDouble &x,const int npoints,
                            const int nvars,int &info,CRowDouble &s2,
                            CMatrixDouble &v)
  {
//--- initialization
   info=0;
//--- function call
   CPCAnalysis::PCABuildBasis(x,npoints,nvars,info,s2,v);
  }
//+------------------------------------------------------------------+
//| Principal components analysis                                    |
//| This function performs truncated PCA, i.e. returns just a few    |
//| most important directions.                                       |
//| Internally it uses iterative eigensolver which is very efficient |
//| when only a minor fraction of full basis is required. Thus, if   |
//| you need full basis, it is better to use pcabuildbasis() function|
//| It should be noted that, unlike LDA, PCA does not use class      |
//| labels.                                                          |
//| INPUT PARAMETERS:                                                |
//|   X        -  dataset, array[0..NPoints-1,0..NVars-1] matrix     |
//|               contains ONLY INDEPENDENT VARIABLES.               |
//|   NPoints  -  dataset size, NPoints>=0                           |
//|   NVars    -  number of independent variables, NVars>=1          |
//|   NNeeded  -  number of requested components, in [1,NVars] range;|
//|               this function is efficient only for NNeeded<<NVars.|
//|   Eps      -  desired precision of vectors returned; underlying  |
//|               solver will stop iterations as soon as absolute    |
//|               error in corresponding singular values reduces to  |
//|               roughly eps*MAX(lambda[]), with lambda[] being     |
//|               array of eigen values.                             |
//|               Zero value means that algorithm performs number of |
//|               iterations specified by maxits parameter, without  |
//|               paying attention to precision.                     |
//|   MaxIts   -  number of iterations performed by subspace         |
//|               iteration method. Zero value means that no limit on|
//|               iteration count is placed (eps-based stopping      |
//|               condition is used).                                |
//| OUTPUT PARAMETERS:                                               |
//|   S2       -  array[NNeeded]. Variance values corresponding to   |
//|               basis vectors.                                     |
//|   V        -  array[NVars,NNeeded] matrix, whose columns store   |
//|               basis vectors.                                     |
//| NOTE: passing eps=0 and maxits=0 results in small eps being      |
//|      selected as stopping condition. Exact value of automatically|
//|      selected eps is version-dependent.                          |
//+------------------------------------------------------------------+
void CAlglib::PCATruncatedSubspace(CMatrixDouble &x,int npoints,int nvars,
                                   int nneeded,double eps,int maxits,
                                   CRowDouble &s2,CMatrixDouble &v)
  {
   s2.Resize(0);
   v.Resize(0,0);
//--- function call
   CPCAnalysis::PCATruncatedSubSpace(x,npoints,nvars,nneeded,eps,maxits,s2,v);
  }
//+------------------------------------------------------------------+
//| Sparse truncated principal components analysis                   |
//| This function performs sparse truncated PCA, i.e. returns just a |
//| few most important principal components for a sparse input X.    |
//| Internally it uses iterative eigensolver which is very efficient |
//| when only a minor fraction of full basis is required.            |
//| It should be noted that, unlike LDA, PCA does not use class      |
//| labels.                                                          |
//| INPUT PARAMETERS:                                                |
//|   X        -  sparse dataset, sparse npoints*nvars matrix. It is |
//|               recommended to use CRS sparse storage format;      |
//|               non-CRS input will be internally converted to CRS. |
//|               Matrix contains ONLY INDEPENDENT VARIABLES,  and   |
//|               must be EXACTLY npoints*nvars.                     |
//|   NPoints  -  dataset size, NPoints>=0                           |
//|   NVars    -  number of independent variables, NVars>=1          |
//|   NNeeded  -  number of requested components, in [1,NVars] range;|
//|               this function is efficient only for NNeeded<<NVars.|
//|   Eps      -  desired precision of vectors returned; underlying  |
//|               solver will stop iterations as soon as absolute    |
//|               error in corresponding singular values reduces  to |
//|               roughly eps*MAX(lambda[]), with lambda[] being     |
//|               array of eigen values.                             |
//|               Zero value means that algorithm performs number of |
//|               iterations specified by maxits parameter, without  |
//|               paying attention to precision.                     |
//|   MaxIts   -  number of iterations performed by subspace         |
//|               iteration method. Zero value means that no limit on|
//|               iteration count is placed (eps-based stopping      |
//|               condition is used).                                |
//| OUTPUT PARAMETERS:                                               |
//|   S2       -  array[NNeeded]. Variance values corresponding to   |
//|               basis vectors.                                     |
//|   V        -  array[NVars,NNeeded] matrix, whose columns store   |
//|               basis vectors.                                     |
//| NOTE: passing eps=0 and maxits=0 results in small eps being      |
//|       selected as a stopping condition. Exact value of           |
//|       automatically selected eps is version-dependent.           |
//| NOTE: zero MaxIts is silently replaced by some reasonable value  |
//|       which prevents eternal loops (possible when inputs are     |
//|       degenerate and too stringent stopping criteria are         |
//|       specified). In current version it is 50+2*NVars.           |
//+------------------------------------------------------------------+
void CAlglib::PCATruncatedSubspaceSparse(CSparseMatrix &x,int npoints,
                                         int nvars,int nneeded,double eps,
                                         int maxits,CRowDouble &s2,
                                         CMatrixDouble &v)
  {
   s2.Resize(0);
   v.Resize(0,0);
//--- function call
   CPCAnalysis::PCATruncatedSubSpaceSparse(x,npoints,nvars,nneeded,eps,maxits,s2,v);
  }
//+------------------------------------------------------------------+
//| Cash-Karp adaptive ODE solver.                                   |
//| This subroutine solves ODE  Y'=f(Y,x) with initial conditions    |
//| Y(xs)=Ys (here Y may be single variable or vector of N variables)|
//| INPUT PARAMETERS:                                                |
//|     Y       -   initial conditions, array[0..N-1].               |
//|                 contains values of Y[] at X[0]                   |
//|     N       -   system size                                      |
//|     X       -   points at which Y should be tabulated,           |
//|                 array[0..M-1] integrations starts at X[0], ends  |
//|                 at X[M-1], intermediate values at X[i] are       |
//|                 returned too.                                    |
//|                 SHOULD BE ORDERED BY ASCENDING OR BY DESCENDING!!|
//|     M       -   number of intermediate points + first point +    |
//|                 last point:                                      |
//|                 * M>2 means that you need both Y(X[M-1]) and M-2 |
//|                   values at intermediate points                  |
//|                 * M=2 means that you want just to integrate from |
//|                   X[0] to X[1] and don't interested in           |
//|                   intermediate values.                           |
//|                 * M=1 means that you don't want to integrate :)  |
//|                   it is degenerate case, but it will be handled  |
//|                   correctly.                                     |
//|                 * M<1 means error                                |
//|     Eps     -   tolerance (absolute/relative error on each step  |
//|                 will be less than Eps). When passing:            |
//|                 * Eps>0, it means desired ABSOLUTE error         |
//|                 * Eps<0, it means desired RELATIVE error.        |
//|                   Relative errors are calculated with respect to |
//|                   maximum values of Y seen so far. Be careful to |
//|                   use this criterion when starting from Y[] that |
//|                   are close to zero.                             |
//|     H       -   initial step lenth, it will be adjusted          |
//|                 automatically after the first step. If H=0, step |
//|                 will be selected automatically (usualy it will   |
//|                 be equal to 0.001 of min(x[i]-x[j])).            |
//| OUTPUT PARAMETERS                                                |
//|     State   -   structure which stores algorithm state between   |
//|                 subsequent calls of OdeSolverIteration. Used     |
//|                 for reverse communication. This structure should |
//|                 be passed to the OdeSolverIteration subroutine.  |
//| SEE ALSO                                                         |
//|     AutoGKSmoothW, AutoGKSingular, AutoGKIteration, AutoGKResults|
//+------------------------------------------------------------------+
void CAlglib::ODESolverRKCK(double &y[],const int n,double &x[],
                            const int m,const double eps,const double h,
                            CODESolverStateShell &state)
  {
   CODESolver::ODESolverRKCK(y,n,x,m,eps,h,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Cash-Karp adaptive ODE solver.                                   |
//| This subroutine solves ODE  Y'=f(Y,x) with initial conditions    |
//| Y(xs)=Ys (here Y may be single variable or vector of N variables)|
//| INPUT PARAMETERS:                                                |
//|     Y       -   initial conditions, array[0..N-1].               |
//|                 contains values of Y[] at X[0]                   |
//|     N       -   system size                                      |
//|     X       -   points at which Y should be tabulated,           |
//|                 array[0..M-1] integrations starts at X[0], ends  |
//|                 at X[M-1], intermediate values at X[i] are       |
//|                 returned too.                                    |
//|                 SHOULD BE ORDERED BY ASCENDING OR BY DESCENDING!!|
//|     M       -   number of intermediate points + first point +    |
//|                 last point:                                      |
//|                 * M>2 means that you need both Y(X[M-1]) and M-2 |
//|                   values at intermediate points                  |
//|                 * M=2 means that you want just to integrate from |
//|                   X[0] to X[1] and don't interested in           |
//|                   intermediate values.                           |
//|                 * M=1 means that you don't want to integrate :)  |
//|                   it is degenerate case, but it will be handled  |
//|                   correctly.                                     |
//|                 * M<1 means error                                |
//|     Eps     -   tolerance (absolute/relative error on each step  |
//|                 will be less than Eps). When passing:            |
//|                 * Eps>0, it means desired ABSOLUTE error         |
//|                 * Eps<0, it means desired RELATIVE error.        |
//|                   Relative errors are calculated with respect to |
//|                   maximum values of Y seen so far. Be careful to |
//|                   use this criterion when starting from Y[] that |
//|                   are close to zero.                             |
//|     H       -   initial step lenth, it will be adjusted          |
//|                 automatically after the first step. If H=0, step |
//|                 will be selected automatically (usualy it will   |
//|                 be equal to 0.001 of min(x[i]-x[j])).            |
//| OUTPUT PARAMETERS                                                |
//|     State   -   structure which stores algorithm state between   |
//|                 subsequent calls of OdeSolverIteration. Used     |
//|                 for reverse communication. This structure should |
//|                 be passed to the OdeSolverIteration subroutine.  |
//| SEE ALSO                                                         |
//|     AutoGKSmoothW, AutoGKSingular, AutoGKIteration, AutoGKResults|
//+------------------------------------------------------------------+
void CAlglib::ODESolverRKCK(double &y[],double &x[],const double eps,
                            const double h,CODESolverStateShell &state)
  {
//--- initialization
   int n=CAp::Len(y);
   int m=CAp::Len(x);
//--- function call
   CODESolver::ODESolverRKCK(y,n,x,m,eps,h,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function provides reverse communication interface           |
//| Reverse communication interface is not documented or recommended |
//| to use.                                                          |
//| See below for functions which provide better documented API      |
//+------------------------------------------------------------------+
bool CAlglib::ODESolverIteration(CODESolverStateShell &state)
  {
   return(CODESolver::ODESolverIteration(state.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This function is used to launcn iterations of ODE solver         |
//| It accepts following parameters:                                 |
//|     diff    -   callback which calculates dy/dx for given y and x|
//|     obj     -   optional object which is passed to diff; can be  |
//|                 NULL                                             |
//+------------------------------------------------------------------+
void CAlglib::ODESolverSolve(CODESolverStateShell &state,
                             CNDimensional_ODE_RP &diff,
                             CObject &obj)
  {
//--- cycle
   while(CAlglib::ODESolverIteration(state))
     {
      //--- check
      if(state.GetNeedDY())
        {
         diff.ODE_RP(state.GetInnerObj().m_y,state.GetInnerObj().m_x,state.GetInnerObj().m_dy,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: unexpected error in 'odesolversolve'");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| ODE solver results                                               |
//| Called after OdeSolverIteration returned False.                  |
//| INPUT PARAMETERS:                                                |
//|     State   -   algorithm state (used by OdeSolverIteration).    |
//| OUTPUT PARAMETERS:                                               |
//|     M       -   number of tabulated values, M>=1                 |
//|     XTbl    -   array[0..M-1], values of X                       |
//|     YTbl    -   array[0..M-1,0..N-1], values of Y in X[i]        |
//|     Rep     -   solver report:                                   |
//|                 * Rep.TerminationType completetion code:         |
//|                     * -2    X is not ordered  by                 |
//|                             ascending/descending or there are    |
//|                             non-distinct X[], i.e.  X[i]=X[i+1]  |
//|                     * -1    incorrect parameters were specified  |
//|                     *  1    task has been solved                 |
//|                 * Rep.NFEV contains number of function           |
//|                   calculations                                   |
//+------------------------------------------------------------------+
void CAlglib::ODESolverResults(CODESolverStateShell &state,int &m,
                               double &xtbl[],CMatrixDouble &ytbl,
                               CODESolverReportShell &rep)
  {
//--- initialization
   m=0;
//--- function call
   CODESolver::ODESolverResults(state.GetInnerObj(),m,xtbl,ytbl,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Filters: simple moving averages (unsymmetric).                   |
//| This filter replaces array by results of SMA(K) filter. SMA(K)   |
//| is defined as filter which averages at most K previous points    |
//| (previous - not points AROUND central point) - or less, in case  |
//| of the first K-1 points.                                         |
//| INPUT PARAMETERS:                                                |
//|   X           -  array[N], array to process. It can be larger    |
//|                  than N, in this case only first N points are    |
//|                  processed.                                      |
//|   N           -  points count, N>=0                              |
//|   K           -  K>=1 (K can be larger than N, such cases will   |
//|                  be correctly handled). Window width. K=1        |
//|                  corresponds to identity transformation (nothing |
//|                  changes).                                       |
//| OUTPUT PARAMETERS:                                               |
//|   X           -  array, whose first N elements were processed    |
//|                  with SMA(K)                                     |
//| NOTE 1: this function uses efficient in-place algorithm which    |
//|         does not allocate temporary arrays.                      |
//| NOTE 2: this algorithm makes only one pass through array and     |
//|         uses running sum to speed-up calculation of the averages.|
//|         Additional measures are taken to ensure that running sum |
//|         on a long sequence of zero elements will be correctly    |
//|         reset to zero even in the presence of round-off error.   |
//| NOTE 3: this is unsymmetric version of the algorithm, which does |
//|         NOT averages points after the current one. Only          |
//|         X[i], X[i-1], ... are used when calculating new value    |
//|         of X[i]. We should also note that this algorithm uses    |
//|         BOTH previous points and  current  one,  i.e. new value  |
//|         of X[i] depends on BOTH previous point and X[i] itself.  |
//+------------------------------------------------------------------+
void CAlglib::FilterSMA(CRowDouble &x,int n,int k)
  {
   CFilters::FilterSMA(x,n,k);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FilterSMA(CRowDouble &x,int k)
  {
   int n=CAp::Len(x);
   CFilters::FilterSMA(x,n,k);
  }
//+------------------------------------------------------------------+
//| Filters: exponential moving averages.                            |
//| This filter replaces array by results of EMA(alpha) filter.      |
//| EMA(alpha) is defined as filter which replaces X[] by S[]:       |
//|      S[0] = X[0]                                                 |
//|      S[t] = alpha * X[t] + (1 - alpha) * S[t - 1]                |
//| INPUT PARAMETERS:                                                |
//|   X           -  array[N], array to process. It can be larger    |
//|                  than N, in this case only first N points are    |
//|                  processed.                                      |
//|   N           -  points count, N >= 0                            |
//|   alpha       -  0 < alpha <= 1, smoothing parameter.            |
//| OUTPUT PARAMETERS:                                               |
//|   X           -  array, whose first N elements were processed    |
//|                  with EMA(alpha)                                 |
//| NOTE 1: this function uses efficient in-place algorithm which    |
//|         does not allocate temporary arrays.                      |
//| NOTE 2: this algorithm uses BOTH previous points and current one,|
//|         i.e. new value of X[i] depends on BOTH previous point and|
//|         X[i] itself.                                             |
//| NOTE 3: technical analytis users quite often work with  EMA      |
//|         coefficient expressed in DAYS instead of fractions. If   |
//|         you want to calculate EMA(N), where N is a number of     |
//|         days, you can use alpha = 2 / (N + 1).                   |
//+------------------------------------------------------------------+
void CAlglib::FilterEMA(CRowDouble &x,int n,double alpha)
  {
   CFilters::FilterEMA(x,n,alpha);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FilterEMA(CRowDouble &x,double alpha)
  {
   int n=CAp::Len(x);
   CFilters::FilterEMA(x,n,alpha);
  }
//+------------------------------------------------------------------+
//| Filters: linear regression moving averages.                      |
//| This filter replaces array by results of LRMA(K) filter.         |
//| LRMA(K) is defined as filter which, for each data point, builds  |
//| linear regression model using K prevous points (point itself is  |
//| included in these K points) and calculates value of this linear  |
//| model at the point in question.                                  |
//| INPUT PARAMETERS:                                                |
//|   X           -  array[N], array to process. It can be larger    |
//|                  than N, in this case only first N points are    |
//|                  processed.                                      |
//|   N           -  points count, N >= 0                            |
//|   K           -  K >= 1(K can be larger than N, such cases will  |
//|                  be correctly handled). Window width. K = 1      |
//|                  corresponds to identity transformation(nothing  |
//|                  changes).                                       |
//| OUTPUT PARAMETERS:                                               |
//|   X           -  array, whose first N elements were processed    |
//|                  with SMA(K)                                     |
//| NOTE 1: this function uses efficient in-place algorithm which    |
//|         does not allocate temporary arrays.                      |
//| NOTE 2: this algorithm makes only one pass through array and     |
//|         uses running sum to speed-up calculation of the averages.|
//|         Additional measures are taken to ensure that running sum |
//|         on a long sequence of zero elements will be correctly    |
//|         reset to zero even in the presence of round - off error. |
//| NOTE 3: this is unsymmetric version of the algorithm, which does |
//|         NOT averages points after the current one. Only          |
//|         X[i], X[i - 1], ... are used when calculating new value  |
//|         of X[i]. We should also note that this algorithm uses    |
//|         BOTH previous points and current one, i.e. new value of  |
//|         X[i] depends on BOTH previous point and X[i] itself.     |
//+------------------------------------------------------------------+
void CAlglib::FilterLRMA(CRowDouble &x,int n,int k)
  {
   CFilters::FilterLRMA(x,n,k);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FilterLRMA(CRowDouble &x,int k)
  {
   int n=CAp::Len(x);
//--- function call
   CFilters::FilterLRMA(x,n,k);
  }
//+------------------------------------------------------------------+
//| This function creates SSA model object. Right after creation     |
//| model is in "dummy" mode - you can add data, but analyzing /     |
//| prediction will return just zeros (it assumes that basis is      |
//| empty).                                                          |
//| HOW TO USE SSA MODEL:                                            |
//|   1. create model with SSACreate()                               |
//|   2. add data with one/many SSAAddSequence() calls               |
//|   3. choose SSA algorithm with one of SSASetAlgo...() functions: |
//|      * SSASetAlgoTopKDirect() for direct one-run analysis        |
//|      * SSASetAlgoTopKRealtime() for algorithm optimized for many |
//|         subsequent runs with warm-start capabilities             |
//|      * SSASetAlgoPrecomputed() for user-supplied basis           |
//|   4. set window width with SSASetWindow()                        |
//|   5. perform one of the analysis-related activities:             |
//|      a) call SSAGetBasis() to get basis                          |
//|      b) call SSAAnalyzeLast() SSAAnalyzeSequence() or            |
//|         SSAAnalyzeLastWindow() to perform analysis (trend/noise  |
//|         separation)                                              |
//|      c) call one of the forecasting functions (SSAForecastLast() |
//|         or SSAForecastSequence()) to perform prediction;         |
//|         alternatively, you can extract linear recurrence         |
//|         coefficients with SSAGetLRR().                           |
//| SSA analysis will be performed during first call to analysis -   |
//| related function. SSA model is smart enough to track all changes |
//| in the dataset and model settings, to cache previously computed  |
//| basis and to re-evaluate basis only when necessary.              |
//| Additionally, if your setting involves constant stream  of       |
//| incoming data, you can perform quick update already calculated   |
//| model with one of the incremental append-and-update  functions:  |
//| SSAAppendPointAndUpdate() or SSAAppendSequenceAndUpdate().       |
//| NOTE: steps (2), (3), (4) can be performed in arbitrary order.   |
//| INPUT PARAMETERS:                                                |
//|      none                                                        |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  structure which stores model state              |
//+------------------------------------------------------------------+
void CAlglib::SSACreate(CSSAModel &s)
  {
   CSSA::SSACreate(s);
  }
//+------------------------------------------------------------------+
//| This function sets window width for SSA model. You should call it|
//| before analysis phase. Default window width is 1 (not for real   |
//| use).                                                            |
//| Special notes:                                                   |
//|   * this function call can be performed at any moment before     |
//|     first call to analysis-related functions                     |
//|   * changing window width invalidates internally stored basis;   |
//|     if you change window width AFTER you call analysis-related   |
//|     function, next analysis phase will require re-calculation of |
//|     the basis according to current algorithm.                    |
//|   * calling this function with exactly same window width as      |
//|     current one has no effect                                    |
//|   * if you specify window width larger than any data sequence    |
//|     stored in the model, analysis will return zero basis.        |
//| INPUT PARAMETERS:                                                |
//|   S           -   SSA model created with SSACreate()             |
//|   WindowWidth -   >=1, new window width                          |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  SSA model, updated                              |
//+------------------------------------------------------------------+
void CAlglib::SSASetWindow(CSSAModel &s,int windowwidth)
  {
   CSSA::SSASetWindow(s,windowwidth);
  }
//+------------------------------------------------------------------+
//| This function sets seed which is used to initialize internal RNG |
//| when we make pseudorandom decisions on model updates.            |
//| By default, deterministic seed is used - which results in same   |
//| sequence of pseudorandom decisions every time you run SSA model. |
//| If you specify non-deterministic seed value, then SSA model may  |
//| return slightly different results after each run.                |
//| This function can be useful when you have several SSA models     |
//| updated with SSAAppendPointAndUpdate() called with 0<UpdateIts<1 |
//| (fractional value) and due to performance limitations want them  |
//| to perform updates at different moments.                         |
//| INPUT PARAMETERS:                                                |
//|   S           -  SSA model                                       |
//|   Seed        -  seed:                                           |
//|                  * positive values = use deterministic seed for  |
//|                    each run of algorithms which depend on random |
//|                    initialization                                |
//|                  * zero or negative values=use non-deterministic |
//|                    seed                                          |
//+------------------------------------------------------------------+
void CAlglib::SSASetSeed(CSSAModel &s,int seed)
  {
   CSSA::SSASetSeed(s,seed);
  }
//+------------------------------------------------------------------+
//| This function sets length of power-up cycle for real-time        |
//| algorithm.                                                       |
//| By default, this algorithm performs costly O(N*WindowWidth^2)    |
//| init phase followed by full run of truncated EVD. However, if you|
//| are ready to live with a bit lower-quality basis during first few|
//| iterations, you can split this O(N*WindowWidth^2) initialization |
//| between several subsequent append-and-update rounds. It results  |
//| in better latency of the algorithm.                              |
//| This function invalidates basis/solver, next analysis call will  |
//| result in full recalculation of everything.                      |
//| INPUT PARAMETERS:                                                |
//|   S           -  SSA model                                       |
//|   PWLen       -  length of the power-up stage:                   |
//|                  * 0 means that no power-up is requested         |
//|                  * 1 is the same as 0                            |
//|                  * >1 means that delayed power-up is performed   |
//+------------------------------------------------------------------+
void CAlglib::SSASetPowerUpLength(CSSAModel &s,int pwlen)
  {
   CSSA::SSASetPowerUpLength(s,pwlen);
  }
//+------------------------------------------------------------------+
//| This function sets memory limit of SSA analysis.                 |
//| Straightforward SSA with sequence length T and window width W    |
//| needs O(T*W) memory. It is possible to reduce memory consumption |
//| by splitting task into smaller chunks.                           |
//| Thus function allows you to specify approximate memory limit     |
//| (measured in double precision numbers used for buffers). Actual  |
//| memory consumption will be comparable to the number specified by |
//| you.                                                             |
//| Default memory limit is 50.000.000 (400Mbytes) in current        |
//| version.                                                         |
//| INPUT PARAMETERS:                                                |
//|   S        -  SSA model                                          |
//|   MemLimit -  memory limit, >=0. Zero value means no limit.      |
//+------------------------------------------------------------------+
void CAlglib::SSASetMemoryLimit(CSSAModel &s,int memlimit)
  {
   CSSA::SSASetMemoryLimit(s,memlimit);
  }
//+------------------------------------------------------------------+
//| This function adds data sequence to SSA model. Only single-      |
//| dimensional sequences are supported.                             |
//| What is a sequences? Following definitions/requirements apply:   |
//|   * a sequence is an array of values measured in subsequent,     |
//|     equally separated time moments (ticks).                      |
//|   * you may have many sequences in your dataset; say, one        |
//|     sequence may correspond to one trading session.              |
//|   * sequence length should be larger than current window length  |
//|     (shorter sequences will be ignored during analysis).         |
//|   * analysis is performed within a sequence; different sequences |
//|     are NOT stacked together to produce one large contiguous     |
//|     stream of data.                                              |
//|   * analysis is performed for all sequences at once, i.e. same   |
//|     set of basis vectors is computed for all sequences           |
//| INCREMENTAL ANALYSIS                                             |
//| This function is non intended for incremental updates of         |
//| previously found SSA basis. Calling it invalidates all previous  |
//| analysis results (basis is reset and will be recalculated from   |
//| zero during next analysis).                                      |
//| If you want to perform incremental/real-time SSA, consider using |
//| following functions:                                             |
//|   * SSAAppendPointAndUpdate() for appending one point            |
//|   * SSAAppendSequenceAndUpdate() for appending new sequence      |
//| INPUT PARAMETERS:                                                |
//|   S           -  SSA model created with SSACreate()              |
//|   X           -  array[N], data, can be larger (additional values|
//|                  are ignored)                                    |
//|   N           -  data length, can be automatically determined    |
//|                  from the array length. N>=0.                    |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  SSA model, updated                              |
//| NOTE: you can clear dataset with SSAClearData()                  |
//+------------------------------------------------------------------+
void CAlglib::SSAAddSequence(CSSAModel &s,CRowDouble &x,int n)
  {
   CSSA::SSAAddSequence(s,x,n);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SSAAddSequence(CSSAModel &s,CRowDouble &x)
  {
   int n=CAp::Len(x);
//--- function call
   CSSA::SSAAddSequence(s,x,n);
  }
//+------------------------------------------------------------------+
//| This function appends single point to last data sequence stored  |
//| in the SSA model and tries to update model in the incremental    |
//| manner (if possible with current algorithm).                     |
//| If you want to add more than one point at once:                  |
//|   * if you want to add M points to the same sequence, perform    |
//|     M-1 calls with UpdateIts parameter set to 0.0, and last call |
//|     with non-zero UpdateIts.                                     |
//|   * if you want to add new sequence, use                         |
//|     SSAAppendSequenceAndUpdate()                                 |
//| Running time of this function does NOT depend on dataset size,   |
//| only on window width and number of singular vectors. Depending   |
//| on algorithm being used, incremental update has complexity:      |
//|   * for top-K real time   -  O(UpdateIts*K*Width^2), with        |
//|                              fractional UpdateIts                |
//|   * for top-K direct      -  O(Width^3) for any non-zero         |
//|                              UpdateIts                           |
//|   * for precomputed basis -  O(1), no update is performed        |
//| INPUT PARAMETERS:                                                |
//|   S           -  SSA model created with SSACreate()              |
//|   X           -  new point                                       |
//|   UpdateIts   -  >=0, floating point(!) value, desired update    |
//|                  frequency:                                      |
//|            * zero value means that point is stored, but no update|
//|              is performed                                        |
//|            * integer part of the value means that specified      |
//|              number of iterations is always performed            |
//|            * fractional part of the value means that one         |
//|              iteration is performed with this probability.       |
//| Recommended value: 0<UpdateIts<=1. Values larger than 1 are VERY |
//| seldom needed. If your dataset changes slowly, you can set it to |
//| 0.1 and skip 90% of updates.                                     |
//| In any case, no information is lost even with zero value of      |
//| UpdateIts! It will be incorporated into model, sooner or later.  |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  SSA model, updated                              |
//| NOTE: this function uses internal RNG to handle fractional values|
//|       of UpdateIts. By default it is initialized with fixed seed |
//|       during initial calculation of basis. Thus subsequent calls |
//|       to this function will result in the same sequence of       |
//|       pseudorandom decisions.                                    |
//| However, if you have several SSA models which are calculated     |
//| simultaneously, and if you want to reduce computational          |
//| bottlenecks by performing random updates at random moments, then |
//| fixed seed is not an option - all updates will fire at same      |
//| moments.                                                         |
//| You may change it with SSASetSeed() function.                    |
//| NOTE: this function throws an exception if called for empty      |
//|       dataset (there is no "last" sequence to modify).           |
//+------------------------------------------------------------------+
void CAlglib::SSAAppendPointAndUpdate(CSSAModel &s,double x,double updateits)
  {
   CSSA::SSAAppendPointAndUpdate(s,x,updateits);
  }
//+------------------------------------------------------------------+
//| This function appends new sequence to dataset stored in the SSA  |
//| model and tries to update model in the incremental manner (if    |
//| possible with current algorithm).                                |
//| Notes:                                                           |
//|   * if you want to add M sequences at once, perform M-1 calls    |
//|     with UpdateIts parameter set to 0.0, and last call with      |
//|     non-zero UpdateIts.                                          |
//|   * if you want to add just one point, use                       |
//|     SSAAppendPointAndUpdate()                                    |
//| Running time of this function does NOT depend on dataset size,   |
//| only on sequence length, window width and number of singular     |
//| vectors. Depending on algorithm being used, incremental update   |
//| has complexity:                                                  |
//|   * for top-K real time   -  O(UpdateIts*K*Width^2+              |
//|                                (NTicks-Width)*Width^2)           |
//|   * for top-K direct      -  O(Width^3+(NTicks-Width)*Width^2)   |
//|   * for precomputed basis -  O(1), no update is performed        |
//| INPUT PARAMETERS:                                                |
//|   S           -  SSA model created with SSACreate()              |
//|   X           -  new sequence, array[NTicks] or larget           |
//|   NTicks      -  >=1, number of ticks in the sequence            |
//|   UpdateIts   -  >=0, floating point(!) value, desired update    |
//|                  frequency:                                      |
//|               * zero value means that point is stored, but no    |
//|                 update is performed                              |
//|               * integer part of the value means  that  specified |
//|                 number of iterations is always performed         |
//|               * fractional part of the value means that one      |
//|                 iteration is performed with this probability.    |
//| Recommended value: 0<UpdateIts<=1. Values larger than 1 are VERY |
//| seldom needed. If your dataset changes slowly, you can set it to |
//| 0.1 and skip 90% of updates.                                     |
//| In any case, no information is lost even with zero value of      |
//| UpdateIts! It will be incorporated into model, sooner or later.  |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  SSA model, updated                              |
//| NOTE: this function uses internal RNG to handle fractional values|
//|       of UpdateIts. By default it is initialized with fixed seed |
//|       during initial calculation of basis. Thus subsequent calls |
//|       to this function will result in the same sequence of       |
//|       pseudorandom decisions.                                    |
//| However, if you have several SSA models which are calculated     |
//| simultaneously, and if you want to reduce computational          |
//| bottlenecks by performing random updates at random moments, then |
//| fixed seed is not an option - all updates will fire at same      |
//| moments.                                                         |
//| You may change it with SSASetSeed() function.                    |
//+------------------------------------------------------------------+
void CAlglib::SSAAppendSequenceAndUpdate(CSSAModel &s,CRowDouble &x,
                                         int nticks,double updateits)
  {
   CSSA::SSAAppendSequenceAndUpdate(s,x,nticks,updateits);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SSAAppendSequenceAndUpdate(CSSAModel &s,CRowDouble &x,
                                         double updateits)
  {
   int nticks=CAp::Len(x);
//--- function call
   CSSA::SSAAppendSequenceAndUpdate(s,x,nticks,updateits);
  }
//+------------------------------------------------------------------+
//| This function sets SSA algorithm to "precomputed vectors"        |
//| algorithm.                                                       |
//| This algorithm uses precomputed set of orthonormal(orthogonal    |
//| AND normalized) basis vectors supplied by user. Thus, basis      |
//| calculation phase is not performed - we already have our basis - |
//| and only analysis/forecasting phase requires actual calculations.|
//| This algorithm may handle "append" requests which add just one/  |
//| few ticks to the end of the last sequence in O(1) time.          |
//| NOTE: this algorithm accepts both basis and window width, because|
//|       these two parameters are naturally aligned. Calling this   |
//|       function sets window width; if you call SSASetWindow()     |
//|       with other window width, then during analysis stage        |
//|       algorithm will detect conflict and reset to zero basis.    |
//| INPUT PARAMETERS:                                                |
//|   S           -  SSA model                                       |
//|   A           -  array[WindowWidth, NBasis], orthonormalized     |
//|                  basis; this function does NOT control           |
//|                  orthogonality and does NOT perform any kind of  |
//|                  renormalization. It is your responsibility to   |
//|                  provide it with correct basis.                  |
//|   WindowWidth -  window width, >= 1                              |
//|   NBasis      -  number of basis vectors,                        |
//|                  1 <= NBasis <= WindowWidth                      |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  updated model                                   |
//| NOTE: calling this function invalidates basis in all cases.      |
//+------------------------------------------------------------------+
void CAlglib::SSASetAlgoPrecomputed(CSSAModel &s,CMatrixDouble &a,int windowwidth,int nbasis)
  {
   CSSA::SSASetAlgoPrecomputed(s,a,windowwidth,nbasis);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SSASetAlgoPrecomputed(CSSAModel &s,CMatrixDouble &a)
  {
   int windowwidth=CAp::Rows(a);
   int nbasis=CAp::Cols(a);
//--- function call
   CSSA::SSASetAlgoPrecomputed(s,a,windowwidth,nbasis);
  }
//+------------------------------------------------------------------+
//| This function sets SSA algorithm to "direct top-K" algorithm.    |
//| "Direct top-K" algorithm performs full SVD of the N*WINDOW       |
//| trajectory matrix (hence its name - direct solver is used), then |
//| extracts top K components. Overall running time is               |
//| O(N * WINDOW ^ 2), where N is a number of ticks in the dataset,  |
//| WINDOW is window width.                                          |
//| This algorithm may handle "append" requests which add just one / |
//| few ticks to the end of the last sequence in O(WINDOW ^ 3) time, |
//| which is ~N/WINDOW times faster than re-computing everything from|
//| scratch.                                                         |
//| INPUT PARAMETERS:                                                |
//|   S           -  SSA model                                       |
//|   TopK        -  number of components to analyze; TopK >= 1.     |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  updated model                                   |
//| NOTE: TopK>WindowWidth is silently decreased to WindowWidth      |
//|       during analysis phase                                      |
//| NOTE: calling this function invalidates basis, except for the    |
//|       situation when this algorithm was already set with same    |
//|       parameters.                                                |
//+------------------------------------------------------------------+
void CAlglib::SSASetAlgoTopKDirect(CSSAModel &s,int topk)
  {
   CSSA::SSASetAlgoTopKDirect(s,topk);
  }
//+------------------------------------------------------------------+
//| This function sets SSA algorithm to "top-K real time algorithm". |
//| This algo extracts K components with largest singular values.    |
//| It is real-time version of top-K algorithm which is optimized for|
//| incremental processing and fast start-up. Internally it uses     |
//| subspace eigensolver for truncated SVD. It results in ability to |
//| perform quick updates of the basis when only a few points /      |
//| sequences is added to dataset.                                   |
//| Performance profile of the algorithm is given below:             |
//|   * O(K * WindowWidth ^ 2) running time for incremental update   |
//|     of the dataset with one of the "append-and-update" functions |
//|     (SSAAppendPointAndUpdate() or SSAAppendSequenceAndUpdate()). |
//|   * O(N * WindowWidth ^ 2) running time for initial basis        |
//|     evaluation(N = size  of dataset)                             |
//|   * ability to split costly initialization across several        |
//|     incremental updates of the basis(so called "Power-Up"        |
//|     functionality, activated by SSASetPowerUpLength() function)  |
//| INPUT PARAMETERS:                                                |
//|   S           -  SSA model                                       |
//|   TopK        -  number of components to analyze; TopK >= 1.     |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  updated model                                   |
//| NOTE: this algorithm is optimized for large-scale tasks with     |
//|       large datasets. On toy problems with just  5-10 points it  |
//|       can return basis which is slightly different from that     |
//|       returned by direct algorithm (SSASetAlgoTopKDirect()       |
//|       function). However, the difference becomes negligible as   |
//|       dataset grows.                                             |
//| NOTE: TopK > WindowWidth is silently decreased to WindowWidth    |
//|       during analysis phase                                      |
//| NOTE: calling this function invalidates basis, except for the    |
//|       situation when this algorithm was already set with same    |
//|       parameters.                                                |
//+------------------------------------------------------------------+
void CAlglib::SSASetAlgoTopKRealtime(CSSAModel &s,int topk)
  {
   CSSA::SSASetAlgoTopKRealtime(s,topk);
  }

//+------------------------------------------------------------------+
//| This function clears all data stored in the model and invalidates|
//| all basis components found so far.                               |
//| INPUT PARAMETERS:                                                |
//|   S        -  SSA model created with SSACreate()                 |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  SSA model, updated                                 |
//+------------------------------------------------------------------+
void CAlglib::SSAClearData(CSSAModel &s)
  {
   CSSA::SSAClearData(s);
  }
//+------------------------------------------------------------------+
//| This function executes SSA on internally stored dataset and      |
//| returns basis found by current method.                           |
//| INPUT PARAMETERS:                                                |
//|   S        -  SSA model                                          |
//| OUTPUT PARAMETERS:                                               |
//|   A        -  array[WindowWidth, NBasis], basis; vectors are     |
//|               stored in matrix columns, by descreasing variance  |
//|   SV       -  array[NBasis]:                                     |
//|            * zeros - for model initialized with                  |
//|              SSASetAlgoPrecomputed()                             |
//|            * singular values - for other algorithms              |
//|   WindowWidth -  current window                                  |
//|   NBasis   -  basis size                                         |
//| CACHING / REUSE OF THE BASIS                                     |
//| Caching / reuse of previous results is performed:                |
//|   * first call performs full run of SSA; basis is stored in the  |
//|     cache                                                        |
//|   * subsequent calls reuse previously cached basis               |
//|   * if you call any function which changes model properties      |
//|     (window length, algorithm, dataset), internal basis will be  |
//|     invalidated.                                                 |
//|   * the only calls which do NOT invalidate basis are listed      |
//|     below:                                                       |
//|      a) SSASetWindow() with same window length                   |
//|      b) SSAAppendPointAndUpdate()                                |
//|      c) SSAAppendSequenceAndUpdate()                             |
//|      d) SSASetAlgoTopK...() with exactly same K Calling these    |
//|         functions will result in reuse of previously found basis.|
//| HANDLING OF DEGENERATE CASES                                     |
//| Calling this function in degenerate cases(no data or all data are|
//| shorter than window size; no algorithm is specified) returns     |
//| basis with just one zero vector.                                 |
//+------------------------------------------------------------------+
void CAlglib::SSAGetBasis(CSSAModel &s,CMatrixDouble &a,CRowDouble &sv,int &windowwidth,int &nbasis)
  {
   a.Resize(0,0);
   sv.Resize(0);
   windowwidth=0;
   nbasis=0;
//--- function call
   CSSA::SSAGetBasis(s,a,sv,windowwidth,nbasis);
  }
//+------------------------------------------------------------------+
//| This function returns linear recurrence relation(LRR)            |
//| coefficients found by current SSA algorithm.                     |
//| INPUT PARAMETERS:                                                |
//|   S        -  SSA model                                          |
//| OUTPUT PARAMETERS:                                               |
//|   A        -  array[WindowWidth - 1]. Coefficients of the linear |
//|               recurrence of the form:                            |
//|               X[W - 1] = X[W - 2] * A[W - 2] +                   |
//|                          X[W - 3] * A[W - 3] + ... + X[0] * A[0].|
//|               Empty array for WindowWidth = 1.                   |
//|   WindowWidth -  current window width                            |
//| CACHING / REUSE OF THE BASIS                                     |
//| Caching / reuse of previous results is performed:                |
//|   * first call performs full run of SSA; basis is stored in the  |
//|     cache                                                        |
//|   * subsequent calls reuse previously cached basis               |
//|   * if you call any function which changes model properties      |
//|     (window length, algorithm, dataset), internal basis will be  |
//|     invalidated.                                                 |
//|   * the only calls which do NOT invalidate basis are listed      |
//|     below:                                                       |
//|      a) SSASetWindow() with same window length                   |
//|      b) SSAAppendPointAndUpdate()                                |
//|      c) SSAAppendSequenceAndUpdate()                             |
//|      d) SSASetAlgoTopK...() with exactly same K                  |
//| Calling these functions will result in reuse of previously found |
//| basis.                                                           |
//| HANDLING OF DEGENERATE CASES                                     |
//| Calling this function in degenerate cases (no data or all data   |
//| are shorter than window size; no algorithm is specified) returns |
//| zeros.                                                           |
//+------------------------------------------------------------------+
void CAlglib::SSAGetLRR(CSSAModel &s,CRowDouble &a,int &windowwidth)
  {
   a.Resize(0);
   windowwidth=0;
//--- function call
   CSSA::SSAGetLRR(s,a,windowwidth);
  }
//+------------------------------------------------------------------+
//| This function executes SSA on internally stored dataset and      |
//| returns analysis for the last window of the last sequence. Such  |
//| analysis is an lightweight alternative for full scale            |
//| reconstruction (see below).                                      |
//| Typical use case for this function is real-time setting, when    |
//| you are interested in quick-and-dirty (very quick and very dirty)|
//| processing of just a few last ticks of the trend.                |
//| IMPORTANT: full scale SSA involves analysis of the ENTIRE        |
//|            dataset, with reconstruction being done for all       |
//|            positions of sliding window with subsequent           |
//|            hankelization (diagonal averaging) of the resulting   |
//|            matrix.                                               |
//| Such analysis requires O((DataLen - Window)*Window*NBasis) FLOPs |
//| and can be quite costly. However, it has nice noise - canceling  |
//| effects due to averaging.                                        |
//| This function performs REDUCED analysis of the last window. It   |
//| is much faster - just O(Window*NBasis), but its results are      |
//| DIFFERENT from that of SSAAnalyzeLast(). In particular, first few|
//| points of the trend are much more prone to noise.                |
//| INPUT PARAMETERS:                                                |
//|   S           -  SSA model                                       |
//| OUTPUT PARAMETERS:                                               |
//|   Trend       -  array[WindowSize], reconstructed trend line     |
//|   Noise       -  array[WindowSize], the rest of the signal; it   |
//|                  holds that ActualData = Trend + Noise.          |
//|   NTicks      -  current WindowSize                              |
//| CACHING / REUSE OF THE BASIS                                     |
//| Caching / reuse of previous results is performed:                |
//|   * first call performs full run of SSA; basis is stored in the  |
//|     cache                                                        |
//|   * subsequent calls reuse previously cached basis               |
//|   * if you call any function which changes model properties      |
//|     (window length, algorithm, dataset), internal basis will     |
//|     be invalidated.                                              |
//|   * the only calls which do NOT invalidate basis are listed      |
//|     below:                                                       |
//|         a) SSASetWindow() with same window length                |
//|         b) SSAAppendPointAndUpdate()                             |
//|         c) SSAAppendSequenceAndUpdate()                          |
//|         d) SSASetAlgoTopK...() with exactly same K               |
//| Calling these functions will result in reuse of previously found |
//| basis.                                                           |
//| In any case, only basis is reused. Reconstruction is performed   |
//| from scratch every time you call this function.                  |
//| HANDLING OF DEGENERATE CASES                                     |
//| Following degenerate cases may happen:                           |
//|   * dataset is empty(no analysis can be done)                    |
//|   * all sequences are shorter than the window length, no analysis|
//|     can be done                                                  |
//|   * no algorithm is specified(no analysis can be done)           |
//|   * last sequence is shorter than the window length (analysis    |
//|     can be done, but we can not perform reconstruction on the    |
//|     last sequence)                                               |
//| Calling this function in degenerate cases returns following      |
//| result:                                                          |
//|   * in any case, WindowWidth ticks is returned                   |
//|   * trend is assumed to be zero                                  |
//|   * noise is initialized by the last sequence; if last sequence  |
//|     is shorter than the window size, it is moved to the end of   |
//|     the array, and the beginning of the noise array is filled by |
//|     zeros                                                        |
//| No analysis is performed in degenerate cases (we immediately     |
//| return dummy values, no basis is constructed).                   |
//+------------------------------------------------------------------+
void CAlglib::SSAAnalyzeLastWindow(CSSAModel &s,CRowDouble &trend,CRowDouble &noise,int &nticks)
  {
   trend.Resize(0);
   noise.Resize(0);
   nticks=0;
//--- function call
   CSSA::SSAAnalyzeLastWindow(s,trend,noise,nticks);
  }
//+------------------------------------------------------------------+
//| This function:                                                   |
//|   * builds SSA basis using internally stored(entire) dataset     |
//|   * returns reconstruction for the last NTicks of the last       |
//|     sequence                                                     |
//| If you want to analyze some other sequence, use                  |
//| SSAAnalyzeSequence().                                            |
//| Reconstruction phase involves  generation of NTicks-WindowWidth  |
//| sliding windows, their decomposition using empirical orthogonal  |
//| functions found by SSA, followed by averaging of each data point |
//| across several overlapping windows. Thus, every point in the     |
//| output trend is reconstructed using up to WindowWidth overlapping|
//| windows(WindowWidth windows exactly in the inner points, just one|
//| window at the extremal points).                                  |
//| IMPORTANT: due to averaging this function returns different      |
//|            results for different values of NTicks. It is expected|
//|            and not a bug.                                        |
//| For example:                                                     |
//|   * Trend[NTicks - 1] is always same because it is not averaged  |
//|     in any case(same applies to Trend[0]).                       |
//|   * Trend[NTicks - 2] has different values fo NTicks=WindowWidth |
//|     and NTicks=WindowWidth+1 because former case means that no   |
//|     averaging is performed, and latter case means that averaging |
//|     using two sliding windows is performed. Larger values of     |
//|     NTicks produce same results as NTicks = WindowWidth + 1.     |
//|   * ...and so on...                                              |
//| PERFORMANCE: this function has                                   |
//|         O((NTicks - WindowWidth) * WindowWidth*NBasis)           |
//| running time. If you work in time-constrained setting and have   |
//| to analyze just a few last ticks, choosing NTicks equal to       |
//| WindowWidth + SmoothingLen, with SmoothingLen = 1...WindowWidth  |
//| will result in good compromise between noise cancellation and    |
//| analysis speed.                                                  |
//| INPUT PARAMETERS:                                                |
//|   S        -  SSA model                                          |
//|   NTicks   -  number of ticks to analyze, Nticks >= 1.           |
//|            * special case of NTicks<=WindowWidth  is  handled    |
//|              by analyzing last window and returning NTicks       |
//|              last ticks.                                         |
//|            * special case NTicks>LastSequenceLen is handled by   |
//|              prepending result with NTicks-LastSequenceLen zeros.|
//| OUTPUT PARAMETERS:                                               |
//|   Trend    -  array[NTicks], reconstructed trend line            |
//|   Noise    -  array[NTicks], the rest of the signal; it holds    |
//|               that ActualData = Trend + Noise.                   |
//| CACHING / REUSE OF THE BASIS                                     |
//| Caching / reuse of previous results is performed:                |
//|      * first call performs full run of SSA; basis is stored in   |
//|        the cache                                                 |
//|      * subsequent calls reuse previously cached basis            |
//|      * if you call any function which changes model properties   |
//|        (window length, algorithm, dataset), internal basis will  |
//|        be invalidated.                                           |
//|      * the only calls which do NOT invalidate basis are listed   |
//|        below:                                                    |
//|            a) SSASetWindow() with same window length             |
//|            b) SSAAppendPointAndUpdate()                          |
//|            c) SSAAppendSequenceAndUpdate()                       |
//|            d) SSASetAlgoTopK...() with exactly same K            |
//| Calling these functions will result in reuse of previously found |
//| basis.                                                           |
//| In any case, only basis is reused. Reconstruction is performed   |
//| from scratch every time you call this function.                  |
//| HANDLING OF DEGENERATE CASES                                     |
//| Following degenerate cases may happen:                           |
//|      * dataset is empty(no analysis can be done)                 |
//|      * all sequences are shorter than the window length, no      |
//|        analysis can be done                                      |
//|      * no algorithm is specified(no analysis can be done)        |
//|      * last sequence is shorter than the window length(analysis  |
//|        can be done, but we can not perform reconstruction on the |
//|        last sequence)                                            |
//| Calling this function in degenerate cases returns following      |
//| result:                                                          |
//|      * in any case, NTicks ticks is returned                     |
//|      * trend is assumed to be zero                               |
//|      * noise is initialized by the last sequence; if last        |
//|        sequence is shorter than the window size, it is moved     |
//|        to the end of the array, and the beginning of the noise   |
//|        array is filled by zeros                                  |
//| No analysis is performed in degenerate cases(we immediately      |
//| return dummy values, no basis is constructed).                   |
//+------------------------------------------------------------------+
void CAlglib::SSAAnalyzeLast(CSSAModel &s,int nticks,CRowDouble &trend,CRowDouble &noise)
  {
   trend.Resize(0);
   noise.Resize(0);
//--- function call
   CSSA::SSAAnalyzeLast(s,nticks,trend,noise);
  }
//+------------------------------------------------------------------+
//| This function:                                                   |
//|      * builds SSA basis using internally stored(entire) dataset  |
//|      * returns reconstruction for the sequence being passed to   |
//|        this function                                             |
//| If you want to analyze last sequence stored in the model, use    |
//| SSAAnalyzeLast().                                                |
//| Reconstruction phase involves generation of NTicks-WindowWidth   |
//| sliding windows, their decomposition using empirical orthogonal  |
//| functions found by SSA, followed by averaging of each data point |
//| across several overlapping windows. Thus, every point in the     |
//| output trend is reconstructed using up to WindowWidth overlapping|
//| windows(WindowWidth windows exactly in the inner points, just one|
//| window at the extremal points).                                  |
//| PERFORMANCE: this function has                                   |
//|         O((NTicks - WindowWidth)*WindowWidth*NBasis)             |
//| running time. If you work in time-constrained setting and have   |
//| to analyze just a few last ticks, choosing NTicks equal to       |
//| WindowWidth + SmoothingLen, with SmoothingLen = 1...WindowWidth  |
//| will result in good compromise between noise cancellation and    |
//| analysis speed.                                                  |
//| INPUT PARAMETERS:                                                |
//|   S           -  SSA model                                       |
//|   Data        -  array[NTicks], can be larger(only NTicks leading|
//|                  elements will be used)                          |
//|   NTicks      -  number of ticks to analyze, Nticks >= 1.        |
//|               * special case of NTicks<WindowWidth is handled by |
//|                 returning zeros as trend, and signal as noise    |
//| OUTPUT PARAMETERS:                                               |
//|   Trend       -  array[NTicks], reconstructed trend line         |
//|   Noise       -  array[NTicks], the rest of the signal; it holds |
//|                  that ActualData = Trend + Noise.                |
//| CACHING / REUSE OF THE BASIS                                     |
//| Caching / reuse of previous results is performed:                |
//|      * first call performs full run of SSA; basis is stored in   |
//|        the cache                                                 |
//|      * subsequent calls reuse previously cached basis            |
//|      * if you call any function which changes model properties   |
//|        (window  length, algorithm, dataset), internal basis will |
//|        be invalidated.                                           |
//|      * the only calls which do NOT invalidate basis are listed   |
//|        below:                                                    |
//|         a) SSASetWindow() with same window length                |
//|         b) SSAAppendPointAndUpdate()                             |
//|         c) SSAAppendSequenceAndUpdate()                          |
//|         d) SSASetAlgoTopK...() with exactly same K               |
//| Calling these functions will result in reuse of previously found |
//| basis.                                                           |
//| In any case, only basis is reused. Reconstruction is performed   |
//| from scratch every time you call this function.                  |
//| HANDLING OF DEGENERATE CASES                                     |
//| Following degenerate cases may happen:                           |
//|      * dataset is empty(no analysis can be done)                 |
//|      * all sequences are shorter than the window length, no      |
//|        analysis can be done                                      |
//|      * no algorithm is specified(no analysis can be done)        |
//|      * sequence being passed is shorter than the window length   |
//| Calling this function in degenerate cases returns following      |
//| result:                                                          |
//|      * in any case, NTicks ticks is returned                     |
//|      * trend is assumed to be zero                               |
//|      * noise is initialized by the sequence.                     |
//| No analysis is performed in degenerate cases(we immediately      |
//| return dummy values, no basis is constructed).                   |
//+------------------------------------------------------------------+
void CAlglib::SSAAnalyzeSequence(CSSAModel &s,CRowDouble &data,int nticks,CRowDouble &trend,CRowDouble &noise)
  {
   trend.Resize(0);
   noise.Resize(0);
//--- function call
   CSSA::SSAAnalyzeSequence(s,data,nticks,trend,noise);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SSAAnalyzeSequence(CSSAModel &s,CRowDouble &data,CRowDouble &trend,CRowDouble &noise)
  {
   trend.Resize(0);
   noise.Resize(0);
   int nticks=CAp::Len(data);
//--- function call
   CSSA::SSAAnalyzeSequence(s,data,nticks,trend,noise);
  }

//+------------------------------------------------------------------+
//| This function builds SSA basis and performs forecasting for a    |
//| specified number of ticks, returning value of trend.             |
//| Forecast is performed as follows:                                |
//|      * SSA trend extraction is applied to last WindowWidth       |
//|        elements of the internally stored dataset; this step is   |
//|        basically a noise reduction.                              |
//|      * linear recurrence relation is applied to extracted trend  |
//| This function has following running time:                        |
//|      * O(NBasis*WindowWidth) for trend extraction phase (always  |
//|                              performed)                          |
//|      * O(WindowWidth*NTicks) for forecast phase                  |
//| NOTE: noise reduction is ALWAYS applied by this algorithm; if you|
//|       want to apply recurrence relation to raw unprocessed data, |
//|       use another function - SSAForecastSequence() which allows  |
//|       to turn on and off noise reduction phase.                  |
//| NOTE: this algorithm performs prediction using only one-last -   |
//|       sliding window. Predictions produced by such approach are  |
//|       smooth continuations of the reconstructed trend line, but  |
//|       they can be easily corrupted by noise. If you need noise - |
//|       resistant prediction, use SSAForecastAvgLast() function,   |
//|       which averages predictions built using several sliding     |
//|       windows.                                                   |
//| INPUT PARAMETERS:                                                |
//|   S        -  SSA model                                          |
//|   NTicks   -  number of ticks to forecast, NTicks >= 1           |
//| OUTPUT PARAMETERS:                                               |
//|   Trend    -  array[NTicks], predicted trend line                |
//| CACHING / REUSE OF THE BASIS                                     |
//| Caching / reuse of previous results is performed:                |
//|      * first call performs full run of SSA; basis is stored in   |
//|        the cache                                                 |
//|      * subsequent calls reuse previously cached basis            |
//|      * if you call any function which changes model properties   |
//|        (window length, algorithm, dataset), internal basis will  |
//|        be invalidated.                                           |
//|      * the only calls which do NOT invalidate basis are listed   |
//|        below:                                                    |
//|         a) SSASetWindow() with same window length                |
//|         b) SSAAppendPointAndUpdate()                             |
//|         c) SSAAppendSequenceAndUpdate()                          |
//|         d) SSASetAlgoTopK...() with exactly same K               |
//| Calling these functions will result in reuse of previously found |
//| basis.                                                           |
//| HANDLING OF DEGENERATE CASES                                     |
//| Following degenerate cases may happen:                           |
//|      * dataset is empty(no analysis can be done)                 |
//|      * all sequences are shorter than the window length, no      |
//|        analysis can be done                                      |
//|      * no algorithm is specified(no analysis can be done)        |
//|      * last sequence is shorter than the WindowWidth(analysis can|
//|         be done, but we can not perform forecasting on the last  |
//|         sequence)                                                |
//|      * window lentgh is 1(impossible to use for forecasting)     |
//|      * SSA analysis algorithm is configured to extract basis     |
//|        whose size is equal to window length(impossible to use for|
//|        forecasting; only basis whose size is less than window    |
//|        length can be used).                                      |
//| Calling this function in degenerate cases returns following      |
//| result:                                                          |
//|      * NTicks copies of the last value is returned for non-empty |
//|        task with large enough dataset, but with overcomplete     |
//|        basis (window width = 1 or basis size is equal to window  |
//|        width)                                                    |
//|      * zero trend with length = NTicks is returned for empty task|
//| No analysis is performed in degenerate cases (we immediately     |
//| return dummy values, no basis is ever constructed).              |
//+------------------------------------------------------------------+
void CAlglib::SSAForecastLast(CSSAModel &s,int nticks,CRowDouble &trend)
  {
   trend.Resize(0);
//--- function call
   CSSA::SSAForecastLast(s,nticks,trend);
  }
//+------------------------------------------------------------------+
//| This function builds SSA basis and performs forecasting for  a   |
//| user - specified sequence, returning value of trend.             |
//| Forecasting is done in two stages:                               |
//|      * first,  we  extract  trend from the WindowWidth last      |
//|        elements of the sequence. This stage is optional, you can |
//|        turn it off if you pass data which are already processed  |
//|        with SSA. Of course, you can turn it off even for raw     |
//|        data, but it is not recommended - noise suppression is    |
//|        very important for correct prediction.                    |
//|      * then, we apply LRR for last WindowWidth - 1 elements of   |
//|        the extracted trend.                                      |
//| This function has following running time:                        |
//|      * O(NBasis*WindowWidth)    for trend extraction phase       |
//|      * O(WindowWidth*NTicks)    for forecast phase               |
//| NOTE: this algorithm performs prediction using only one-last -   |
//|       sliding window. Predictions produced by such approach are  |
//|       smooth continuations of the reconstructed trend line, but  |
//|       they can be easily corrupted by noise. If you need noise - |
//|       resistant prediction, use SSAForecastAvgSequence()         |
//|       function, which averages predictions built using several   |
//|       sliding windows.                                           |
//| INPUT PARAMETERS:                                                |
//|   S        -  SSA model                                          |
//|   Data     -  array[NTicks], data to forecast                    |
//|   DataLen  -  number of ticks in the data, DataLen >= 1          |
//|   ForecastLen -  number of ticks to predict, ForecastLen >= 1    |
//|   ApplySmoothing - whether to apply smoothing trend extraction or|
//|               not; if you do not know what to specify, pass True.|
//| OUTPUT PARAMETERS:                                               |
//|   Trend    -  array[ForecastLen], forecasted trend               |
//| CACHING / REUSE OF THE BASIS                                     |
//| Caching / reuse of previous results is performed:                |
//|      * first call performs full run of SSA; basis is stored in   |
//|        the cache                                                 |
//|      * subsequent calls reuse previously cached basis            |
//|      * if you call any function which changes model properties   |
//|        (window length, algorithm, dataset), internal basis will  |
//|        be invalidated.                                           |
//|      * the only calls which do NOT invalidate basis are listed   |
//|        below:                                                    |
//|         a) SSASetWindow() with same window length                |
//|         b) SSAAppendPointAndUpdate()                             |
//|         c) SSAAppendSequenceAndUpdate()                          |
//|         d) SSASetAlgoTopK...() with exactly same K               |
//| Calling these functions will result in reuse of previously found |
//| basis.                                                           |
//| HANDLING OF DEGENERATE CASES                                     |
//| Following degenerate cases may happen:                           |
//|      * dataset is empty(no analysis can be done)                 |
//|      * all sequences are shorter than the window length, no      |
//|        analysis can be done                                      |
//|      * no algorithm is specified(no analysis can be done)        |
//|      * data sequence is shorter than the WindowWidth(analysis can|
//|        be done, but we can not perform forecasting on the last   |
//|        sequence)                                                 |
//|      * window lentgh is 1(impossible to use for forecasting)     |
//|      * SSA analysis algorithm is configured to extract basis     |
//|        whose size is equal to window length (impossible to use   |
//|        for forecasting; only basis whose size is less than window|
//|        length can be used).                                      |
//| Calling this function in degenerate cases returns following      |
//| result:                                                          |
//|      * ForecastLen copies of the last value is returned for      |
//|        non-empty task with large enough dataset, but with        |
//|        overcomplete basis (window width = 1 or basis size is     |
//|        equal to window width)                                    |
//|      * zero trend with length = ForecastLen is returned for empty|
//|        task                                                      |
//| No analysis is performed in degenerate cases (we immediately     |
//| return dummy values, no basis is ever constructed).              |
//+------------------------------------------------------------------+
void CAlglib::SSAForecastSequence(CSSAModel &s,CRowDouble &data,
                                  int datalen,int forecastlen,
                                  bool applysmoothing,CRowDouble &trend)
  {
   trend.Resize(0);
//--- function call
   CSSA::SSAForecastSequence(s,data,datalen,forecastlen,applysmoothing,trend);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SSAForecastSequence(CSSAModel &s,CRowDouble &data,int forecastlen,CRowDouble &trend)
  {
   trend.Resize(0);
   int datalen=CAp::Len(data);
   bool applysmoothing=true;
//--- function call
   CSSA::SSAForecastSequence(s,data,datalen,forecastlen,applysmoothing,trend);
  }
//+------------------------------------------------------------------+
//| This function builds SSA basis and performs forecasting for a    |
//| specified number of ticks, returning value of trend.             |
//| Forecast is performed as follows:                                |
//|      * SSA  trend extraction is applied to last M sliding windows|
//|        of the internally stored dataset                          |
//|      * for each of M sliding windows, M predictions are built    |
//|      * average value of M predictions is returned                |
//| This function has following running time:                        |
//|      * O(NBasis*WindowWidth*M)  for trend extraction phase       |
//|                                 (always performed)               |
//|      * O(WindowWidth*NTicks*M)  for forecast phase               |
//| NOTE: noise reduction is ALWAYS applied by this algorithm; if you|
//|       want to apply recurrence relation to raw unprocessed data, |
//|       use another function - SSAForecastSequence() which allows  |
//|       to turn on and off noise reduction phase.                  |
//| NOTE: combination of several predictions results in lesser       |
//|       sensitivity to noise, but it may produce undesirable       |
//|       discontinuities between last point of the trend and first  |
//|       point of the prediction. The reason is that last point of  |
//|       the trend is usually corrupted by noise, but average value |
//|       of several predictions is less sensitive to noise, thus    |
//|       discontinuity appears. It is not a bug.                    |
//| INPUT PARAMETERS:                                                |
//|   S        -  SSA model                                          |
//|   M        -  number of sliding windows to combine, M >= 1. If   |
//|               your dataset has less than M sliding windows, this |
//|               parameter will be silently reduced.                |
//|   NTicks   -  number of ticks to forecast, NTicks >= 1           |
//| OUTPUT PARAMETERS:                                               |
//|   Trend    -  array[NTicks], predicted trend line                |
//| CACHING / REUSE OF THE BASIS                                     |
//| Caching / reuse of previous results is performed:                |
//|      * first call performs full run of SSA; basis is stored in   |
//|        the cache                                                 |
//|      * subsequent calls reuse previously cached basis            |
//|      * if you call any function which changes model properties   |
//|        (window length, algorithm, dataset), internal basis will  |
//|        be invalidated.                                           |
//|      * the only calls which do NOT invalidate basis are listed   |
//|        below:                                                    |
//|            a) SSASetWindow() with same window length             |
//|            b) SSAAppendPointAndUpdate()                          |
//|            c) SSAAppendSequenceAndUpdate()                       |
//|            d) SSASetAlgoTopK...() with exactly same K            |
//| Calling these functions will result in reuse of previously found |
//| basis.                                                           |
//| HANDLING OF DEGENERATE CASES                                     |
//| Following degenerate cases may happen:                           |
//|      * dataset is empty(no analysis can be done)                 |
//|      * all sequences are shorter than the window length, no      |
//|        analysis can be done                                      |
//|      * no algorithm is specified(no analysis can be done)        |
//|      * last sequence is shorter than the WindowWidth(analysis can|
//|        be done, but we can not perform forecasting on the last   |
//|        sequence)                                                 |
//|      * window lentgh is 1(impossible to use for forecasting)     |
//|      * SSA analysis algorithm is configured to extract basis     |
//|        whose size is equal to window length(impossible to use for|
//|        forecasting; only basis whose size is less than window    |
//|        length can be used).                                      |
//| Calling this function in degenerate cases returns following      |
//| result:                                                          |
//|   * NTicks copies of the last value is returned for non-empty    |
//|     task with large enough dataset, but with overcomplete basis  |
//|     (window width = 1 or basis size is equal to window width)    |
//|   * zero trend with length = NTicks is returned for empty task   |
//| No analysis is performed in degenerate cases (we immediately     |
//| return dummy values, no basis is ever constructed).              |
//+------------------------------------------------------------------+
void CAlglib::SSAForecastAvgLast(CSSAModel &s,int m,int nticks,CRowDouble &trend)
  {
   trend.Resize(0);
//--- function call
   CSSA::SSAForecastAvgLast(s,m,nticks,trend);
  }
//+------------------------------------------------------------------+
//| This function builds SSA basis and performs forecasting for a    |
//| user - specified sequence, returning value of trend.             |
//| Forecasting is done in two stages:                               |
//|   * first, we extract trend from M last sliding windows of the   |
//|     sequence. This stage is optional, you can turn it off i you  |
//|     pass data which are already processed with SSA. Of course,   |
//|     you can turn it off even for raw data, but it is not         |
//|     recommended - noise suppression is very important for correct|
//|     prediction.                                                  |
//|   * then, we apply LRR independently for M sliding windows       |
//|   * average of M predictions is returned                         |
//| This function has following running time:                        |
//|   * O(NBasis*WindowWidth*M)     for trend extraction phase       |
//|   * O(WindowWidth*NTicks*M)     for forecast phase               |
//| NOTE: combination of several predictions results in lesser       |
//|       sensitivity to noise, but it may produce undesirable       |
//|       discontinuities between last point of the trend and first  |
//|       point of the prediction. The reason is that last point of  |
//|       the trend is usually corrupted by noise, but average value |
//|       of several predictions is less sensitive to noise, thus    |
//|       discontinuity appears. It is not a bug.                    |
//| INPUT PARAMETERS:                                                |
//|   S           -  SSA model                                       |
//|   Data        -  array[NTicks], data to forecast                 |
//|   DataLen     -  number of ticks in the data, DataLen >= 1       |
//|   M           -  number of sliding windows to combine, M >= 1.   |
//|                  If your dataset has less than M sliding windows,|
//|                  this parameter will be silently reduced.        |
//|   ForecastLen -  number of ticks to predict, ForecastLen >= 1    |
//|   ApplySmoothing - whether to apply smoothing trend extraction   |
//|                  or not. if you do not know what to specify,     |
//|                  pass true.                                      |
//| OUTPUT PARAMETERS:                                               |
//|   Trend       -  array[ForecastLen], forecasted trend            |
//| CACHING / REUSE OF THE BASIS                                     |
//| Caching / reuse of previous results is performed:                |
//|   * first call performs full run of SSA; basis is stored in      |
//|     the cache                                                    |
//|   * subsequent calls reuse previously cached basis               |
//|   * if you call any function which changes model properties      |
//|     (window length, algorithm, dataset), internal basis will be  |
//|     invalidated.                                                 |
//|   * the only calls which do NOT invalidate basis are listed      |
//|     below:                                                       |
//|      a) SSASetWindow() with same window length                   |
//|      b) SSAAppendPointAndUpdate()                                |
//|      c) SSAAppendSequenceAndUpdate()                             |
//|      d) SSASetAlgoTopK...() with exactly same K                  |
//| Calling these functions will result in reuse of previously found |
//| basis.                                                           |
//| HANDLING OF DEGENERATE CASES                                     |
//| Following degenerate cases may happen:                           |
//|   * dataset is empty(no analysis can be done)                    |
//|   * all sequences are shorter than the window length, no analysis|
//|     can be done                                                  |
//|   * no algorithm is specified(no analysis can be done)           |
//|   * data sequence is shorter than the WindowWidth (analysis can  |
//|     be done, but we can not perform forecasting on the last      |
//|     sequence)                                                    |
//|   * window lentgh is 1 (impossible to use for forecasting)       |
//|   * SSA analysis algorithm is configured to extract basis whose  |
//|     size is equal to window length (impossible to use for        |
//|     forecasting; only basis whose size is less than window length|
//|     can be used).                                                |
//| Calling this function in degenerate cases returns following      |
//| result:                                                          |
//|   * ForecastLen copies of the last value is returned for         |
//|     non-empty task with large enough dataset, but with           |
//|     overcomplete basis (window width = 1 or basis size           |
//|     is equal to window width)                                    |
//|   * zero trend with length = ForecastLen is returned for         |
//|     empty task                                                   |
//| No analysis is performed in degenerate case s(we immediately     |
//| return dummy values, no basis is ever constructed).              |
//+------------------------------------------------------------------+
void CAlglib::SSAForecastAvgSequence(CSSAModel &s,CRowDouble &data,
                                     int datalen,int m,int forecastlen,
                                     bool applysmoothing,CRowDouble &trend)
  {
   trend.Resize(0);
//--- function call
   CSSA::SSAForecastAvgSequence(s,data,datalen,m,forecastlen,applysmoothing,trend);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SSAForecastAvgSequence(CSSAModel &s,CRowDouble &data,
                                     int m,int forecastlen,
                                     CRowDouble &trend)
  {
   trend.Resize(0);
   int datalen=CAp::Len(data);
   bool applysmoothing=true;
//--- function call
   CSSA::SSAForecastAvgSequence(s,data,datalen,m,forecastlen,applysmoothing,trend);
  }
//+------------------------------------------------------------------+
//| This function serializes data structure to string.               |
//| Important properties of s_out:                                   |
//|   * it contains alphanumeric characters, dots, underscores, minus|
//|     signs                                                        |
//|   * these symbols are grouped into words, which are separated by |
//|     spaces and Windows-style (CR+LF) newlines                    |
//|   * although  serializer  uses  spaces and CR+LF as separators,  |
//|     you can replace any separator character by arbitrary         |
//|     combination of spaces, tabs, Windows or Unix newlines. It    |
//|     allows flexible reformatting of the string in case you want  |
//|     to include it into text or XML file. But you should not      |
//|     insert separators into the middle of the "words" nor you     |
//|     should change case of letters.                               |
//|   * s_out can be freely moved between 32-bit and 64-bit systems, |
//|     little and big endian machines, and so on. You can serialize |
//|     structure on 32-bit machine and unserialize it on 64-bit one |
//|     (or vice versa), or serialize it on SPARC and unserialize on |
//|     x86. You can also serialize  it  in  C# version of ALGLIB and|
//|     unserialize in C++ one, and vice versa.                      |
//+------------------------------------------------------------------+
void CAlglib::KNNSerialize(CKNNModel &obj,string &s_out)
  {
//--- create a variable
   CSerializer s;
//--- serialization start
   s.Alloc_Start();
//--- function call
   CKNN::KNNAlloc(s,obj);
//--- serialization
   s.SStart_Str();
   CKNN::KNNSerialize(s,obj);
   s.Stop();
   s_out=s.Get_String();
  }
//+------------------------------------------------------------------+
//| This function unserializes data structure from string.           |
//+------------------------------------------------------------------+
void CAlglib::KNNUnserialize(const string s_in,CKNNModel &obj)
  {
   CSerializer s;
   s.UStart_Str(s_in);
   CKNN::KNNUnserialize(s,obj);
   s.Stop();
  }
//+------------------------------------------------------------------+
//| This function creates buffer structure which can be used to      |
//| perform parallel KNN requests.                                   |
//| KNN subpackage provides two sets of computing functions - ones   |
//| which use internal buffer of KNN model (these  functions are     |
//| single-threaded because they use same buffer, which can not      |
//| shared between threads), and ones which use external buffer.     |
//| This function is used to initialize external buffer.             |
//| INPUT PARAMETERS                                                 |
//|   Model       -  KNN model which is associated with newly created|
//|                  buffer                                          |
//| OUTPUT PARAMETERS                                                |
//|   Buf         -  external buffer.                                |
//| IMPORTANT: buffer object should be used only with model which was|
//|            used to initialize buffer. Any attempt to  use  buffer|
//|            with different object is dangerous - you  may   get   |
//|            integrity check failure (exception) because sizes of  |
//|            internal arrays do not fit to dimensions of the model |
//|            structure.                                            |
//+------------------------------------------------------------------+
void CAlglib::KNNCreateBuffer(CKNNModel &model,CKNNBuffer &buf)
  {
   CKNN::KNNCreateBuffer(model,buf);
  }
//+------------------------------------------------------------------+
//| This subroutine creates KNNBuilder object which is used to train |
//| KNN models.                                                      |
//| By default, new builder stores empty dataset and some reasonable |
//| default settings. At the very least, you should specify dataset  |
//| prior to building KNN model. You can also tweak settings of the  |
//| model construction algorithm (recommended, although default      |
//| settings should work well).                                      |
//| Following actions are mandatory:                                 |
//|   * calling knnbuildersetdataset() to specify dataset            |
//|   * calling KNNBuilderBuildKNNModel() to build KNN model using   |
//|     current dataset and default settings                         |
//| Additionally, you may call:                                      |
//|   * KNNBuilderSetNorm() to change norm being used                |
//| INPUT PARAMETERS:                                                |
//|   none                                                           |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  KNN builder                                     |
//+------------------------------------------------------------------+
void CAlglib::KNNBuilderCreate(CKNNBuilder &s)
  {
   CKNN::KNNBuilderCreate(s);
  }
//+------------------------------------------------------------------+
//| Specifies regression problem (one or more continuous output      |
//| variables are predicted). There also exists "classification"     |
//| version of this function.                                        |
//| This subroutine adds dense dataset to the internal storage of the|
//| builder object. Specifying your dataset in the dense format means|
//| that the dense version of the KNN construction algorithm will be |
//| invoked.                                                         |
//| INPUT PARAMETERS:                                                |
//|   S           -  KNN builder object                              |
//|   XY          -  array[NPoints,NVars+NOut] (note: actual size can|
//|                  be larger, only leading part is used anyway),   |
//|                  dataset:                                        |
//|                  * first NVars elements of each row store values |
//|                    of the independent variables                  |
//|                  * next NOut elements store  values  of  the     |
//|                    dependent variables                           |
//|   NPoints     -  number of rows in the dataset, NPoints>=1       |
//|   NVars       -  number of independent variables, NVars>=1       |
//|   NOut        -  number of dependent variables, NOut>=1          |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  KNN builder                                     |
//+------------------------------------------------------------------+
void CAlglib::KNNBuilderSetDatasetReg(CKNNBuilder &s,CMatrixDouble &xy,
                                      int npoints,int nvars,int nout)
  {
   CKNN::KNNBuilderSetDatasetReg(s,xy,npoints,nvars,nout);
  }
//+------------------------------------------------------------------+
//| Specifies classification problem (two or more classes are        |
//| predicted). There also exists "regression" version of this       |
//| function.                                                        |
//| This subroutine adds dense dataset to the internal storage of the|
//| builder object. Specifying your dataset in the dense format means|
//| that the dense version of the KNN construction algorithm will be |
//| invoked.                                                         |
//| INPUT PARAMETERS:                                                |
//|   S        -  KNN builder object                                 |
//|   XY       -  array[NPoints, NVars + 1] (note: actual size can be|
//|               larger, only leading part is used anyway), dataset:|
//|               * first NVars elements of each row store values of |
//|                 the independent variables                        |
//|               * next element stores class index, in [0, NClasses)|
//|   NPoints  -  number of rows in the dataset, NPoints >= 1        |
//|   NVars    -  number of independent variables, NVars >= 1        |
//|   NClasses -  number of classes, NClasses >= 2                   |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  KNN builder                                        |
//+------------------------------------------------------------------+
void CAlglib::KNNBuilderSetDatasetCLS(CKNNBuilder &s,CMatrixDouble &xy,
                                      int npoints,int nvars,int nclasses)
  {
   CKNN::KNNBuilderSetDatasetCLS(s,xy,npoints,nvars,nclasses);
  }
//+------------------------------------------------------------------+
//| This function sets norm type used for neighbor search.           |
//| INPUT PARAMETERS:                                                |
//|   S           -  decision forest builder object                  |
//|   NormType    -  norm type:                                      |
//|                  * 0      inf-norm                               |
//|                  * 1      1-norm                                 |
//|                  * 2      Euclidean norm(default)                |
//| OUTPUT PARAMETERS:                                               |
//|   S           -  decision forest builder                         |
//+------------------------------------------------------------------+
void CAlglib::KNNBuilderSetNorm(CKNNBuilder &s,int nrmtype)
  {
   CKNN::KNNBuilderSetNorm(s,nrmtype);
  }
//+------------------------------------------------------------------+
//| This subroutine builds KNN model according to current settings,  |
//| using dataset internally stored in the builder object.           |
//| The model being built performs inference using Eps-approximate   |
//| K nearest neighbors search algorithm, with:                      |
//|     *K=1,  Eps=0 corresponding to the "nearest neighbor    |
//|                        algorithm"                                |
//|     *K>1,  Eps=0 corresponding to the "K nearest neighbors |
//|                        algorithm"                                |
//|     *K>=1, Eps>0 corresponding to "approximate nearest     |
//|                        neighbors algorithm"                      |
//| An approximate KNN is a good option for high-dimensional datasets|
//| (exact KNN works slowly when dimensions count grows).            |
//| An ALGLIB implementation of kd-trees is used to perform k-nn     |
//| searches.                                                        |
//| INPUT PARAMETERS:                                                |
//|   S           -  KNN builder object                              |
//|   K           -  number of neighbors to search for, K >= 1       |
//|   Eps         -  approximation factor:                           |
//|               * Eps = 0 means that exact kNN search is performed |
//|               * Eps > 0 means that(1 + Eps) - approximate search |
//|                         is performed                             |
//| OUTPUT PARAMETERS:                                               |
//|   Model       -  KNN model                                       |
//|   Rep         -  report                                          |
//+------------------------------------------------------------------+
void CAlglib::KNNBuilderBuildKNNModel(CKNNBuilder &s,int k,double eps,
                                      CKNNModel &model,CKNNReport &rep)
  {
   CKNN::KNNBuilderBuildKNNModel(s,k,eps,model,rep);
  }
//+------------------------------------------------------------------+
//| Changing search settings of KNN model.                           |
//| K and EPS parameters of KNN(AKNN) search are specified  during   |
//| model construction. However, plain KNN algorithm with Euclidean  |
//| distance allows you to change them at any moment.                |
//| NOTE: future versions of KNN model may support advanced versions |
//|       of KNN, such as NCA or LMNN. It is possible that such      |
//|       algorithms won't allow you to change search settings on the|
//|       fly. If you call this function for an algorithm which does |
//|       not support on-the-fly changes, it  will throw an exception|
//| INPUT PARAMETERS:                                                |
//|   Model       -  KNN model                                       |
//|   K           -  K >= 1, neighbors count                         |
//|   EPS         -  accuracy of the EPS-approximate NN search. Set  |
//|                  to 0.0, if you want to perform "classic" KNN    |
//|                  search. Specify larger values if you need to    |
//|                  speed-up high-dimensional KNN queries.          |
//| OUTPUT PARAMETERS:                                               |
//|      nothing on success, exception on failure                    |
//+------------------------------------------------------------------+
void CAlglib::KNNRewriteKEps(CKNNModel &model,int k,double eps)
  {
   CKNN::KNNRewriteKEps(model,k,eps);
  }
//+------------------------------------------------------------------+
//| Inference using KNN model.                                       |
//| See also KNNProcess0(), KNNProcessI() and KNNClassify() for      |
//| options with a bit more convenient interface.                    |
//| INPUT PARAMETERS:                                                |
//|   Model    -  KNN model                                          |
//|   X        -  input vector,  array[0..NVars - 1].                |
//|   Y        -  possible preallocated buffer. Reused if long enough|
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  result. Regression estimate when solving regression|
//|               task, vector of posterior probabilities for        |
//|               classification task.                               |
//+------------------------------------------------------------------+
void CAlglib::KNNProcess(CKNNModel &model,CRowDouble &x,CRowDouble &y)
  {
   CKNN::KNNProcess(model,x,y);
  }
//+------------------------------------------------------------------+
//| This function returns first component of the inferred vector     |
//| (i.e.one with index #0).                                         |
//| It is a convenience wrapper for KNNProcess() intended for either:|
//|      * 1 - dimensional regression problems                       |
//|      * 2 - class classification problems                         |
//| In the former case this function returns inference result as     |
//| scalar, which is definitely more convenient that wrapping it as  |
//| vector. In the latter case it returns probability of object      |
//| belonging to class #0.                                           |
//| If you call it for anything different from two cases above, it   |
//| will work as defined, i.e. return y[0], although it is of less   |
//| use in such cases.                                               |
//| INPUT PARAMETERS:                                                |
//|   Model    -  KNN model                                          |
//|   X        -  input vector,  array[0..NVars - 1].                |
//| RESULT:                                                          |
//|   Y[0]                                                           |
//+------------------------------------------------------------------+
double CAlglib::KNNProcess0(CKNNModel &model,CRowDouble &x)
  {
   return(CKNN::KNNProcess0(model,x));
  }
//+------------------------------------------------------------------+
//| This function returns most probable class number for an  input X.|
//| It is same as calling KNNProcess(model, x, y), then determining  |
//| i = argmax(y[i]) and returning i.                                |
//| A class number in [0, NOut) range in returned for classification |
//| problems, -1 is returned when this function is called for        |
//| regression problems.                                             |
//| INPUT PARAMETERS:                                                |
//|   Model    -  KNN model                                          |
//|   X        -  input vector,  array[0..NVars - 1].                |
//| RESULT:                                                          |
//|   class number, -1 for regression tasks                          |
//+------------------------------------------------------------------+
int CAlglib::KNNClassify(CKNNModel &model,CRowDouble &x)
  {
   return(CKNN::KNNClassify(model,x));
  }
//+------------------------------------------------------------------+
//| 'interactive' variant of KNNProcess() which support constructs   |
//| like "y = KNNProcessI(model,x)" and interactive mode of the      |
//| interpreter.                                                     |
//| This function allocates new array on each call, so it is         |
//| significantly slower than its 'non-interactive' counterpart, but |
//| it is more convenient when you call it from command line.        |
//+------------------------------------------------------------------+
void CAlglib::KNNProcessI(CKNNModel &model,CRowDouble &x,CRowDouble &y)
  {
   y.Resize(0);
//--- function call
   CKNN::KNNProcessI(model,x,y);
  }
//+------------------------------------------------------------------+
//| Thread - safe procesing using external buffer for temporaries.   |
//| This function is thread-safe(i.e. you can use same KNN model from|
//| multiple threads) as long as you use different buffer objects for|
//| different threads.                                               |
//| INPUT PARAMETERS:                                                |
//|   Model    -  KNN model                                          |
//|   Buf      -  buffer object, must be allocated specifically for  |
//|               this model with KNNCreateBuffer().                 |
//|   X        -  input vector,  array[NVars]                        |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  result, array[NOut]. Regression estimate when      |
//|               solving regression task, vector of posterior       |
//|               probabilities for a classification task.           |
//+------------------------------------------------------------------+
void CAlglib::KNNTsProcess(CKNNModel &model,CKNNBuffer &buf,
                           CRowDouble &x,CRowDouble &y)
  {
   CKNN::KNNTsProcess(model,buf,x,y);
  }
//+------------------------------------------------------------------+
//| Relative classification error on the test set                    |
//| INPUT PARAMETERS:                                                |
//|   Model    -  KNN model                                          |
//|   XY       -  test set                                           |
//|   NPoints  -  test set size                                      |
//| RESULT:                                                          |
//|   percent of incorrectly classified cases.                       |
//|   Zero if model solves regression task.                          |
//| NOTE: if you need several different kinds of error metrics, it is|
//|       better to use KNNAllErrors() which computes all error      |
//|       metric with just one pass over dataset.                    |
//+------------------------------------------------------------------+
double CAlglib::KNNRelClsError(CKNNModel &model,CMatrixDouble &xy,
                               int npoints)
  {
   return(CKNN::KNNRelClsError(model,xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average cross-entropy (in bits per element) on the test set      |
//| INPUT PARAMETERS:                                                |
//|   Model    -  KNN model                                          |
//|   XY       -  test set                                           |
//|   NPoints  -  test set size                                      |
//| RESULT:                                                          |
//|   CrossEntropy / NPoints.                                        |
//|   Zero if model solves regression task.                          |
//| NOTE: the cross-entropy metric is too unstable when used         |
//|       to evaluate KNN models (such models can report exactly     |
//|       zero probabilities), so we do not recommend using it.      |
//| NOTE:  if you need several different kinds of error metrics, it  |
//|        is better to use KNNAllErrors() which computes all error  |
//|        metric with just one pass over dataset.                   |
//+------------------------------------------------------------------+
double CAlglib::KNNAvgCE(CKNNModel &model,CMatrixDouble &xy,int npoints)
  {
   return(CKNN::KNNAvgCE(model,xy,npoints));
  }
//+------------------------------------------------------------------+
//| RMS error on the test set.                                       |
//| Its meaning for regression task is obvious. As for classification|
//| problems, RMS error means error when estimating posterior        |
//| probabilities.                                                   |
//| INPUT PARAMETERS:                                                |
//|   Model    -  KNN model                                          |
//|   XY       -  test set                                           |
//|   NPoints  -  test set size                                      |
//| RESULT:                                                          |
//|   root mean square error.                                        |
//| NOTE: if you need several different kinds of error metrics, it   |
//|       is better to use KNNAllErrors() which computes all error   |
//|       metric with just one pass over dataset.                    |
//+------------------------------------------------------------------+
double CAlglib::KNNRMSError(CKNNModel &model,CMatrixDouble &xy,
                            int npoints)
  {
   return(CKNN::KNNRMSError(model,xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average error on the test set                                    |
//| Its meaning for regression task is obvious. As for classification|
//| problems, average error means error when estimating posterior    |
//| probabilities.                                                   |
//| INPUT PARAMETERS:                                                |
//|   Model    -  KNN model                                          |
//|   XY       -  test set                                           |
//|   NPoints  -  test set size                                      |
//| RESULT:                                                          |
//|   average error                                                  |
//| NOTE: if you need several different kinds of error metrics, it   |
//|       is better to use KNNAllErrors() which computes all error   |
//|       metric with just one pass over dataset.                    |
//+------------------------------------------------------------------+
double CAlglib::KNNAvgError(CKNNModel &model,CMatrixDouble &xy,int npoints)
  {
   return(CKNN::KNNAvgError(model,xy,npoints));
  }
//+------------------------------------------------------------------+
//| Average relative error on the test set                           |
//| Its meaning for regression task is obvious. As for classification|
//| problems, average relative error means error when estimating     |
//| posterior probabilities.                                         |
//| INPUT PARAMETERS:                                                |
//|   Model    -  KNN model                                          |
//|   XY       -  test set                                           |
//|   NPoints  -  test set size                                      |
//| RESULT:                                                          |
//|   average relative error                                         |
//| NOTE: if you need several different kinds of error metrics, it   |
//|       is better to use KNNAllErrors() which computes all error   |
//|       metric with just one pass over dataset.                    |
//+------------------------------------------------------------------+
double CAlglib::KNNAvgRelError(CKNNModel &model,CMatrixDouble &xy,int npoints)
  {
   return(CKNN::KNNAvgRelError(model,xy,npoints));
  }
//+------------------------------------------------------------------+
//| Calculates all kinds of errors for the model in one call.        |
//| INPUT PARAMETERS:                                                |
//|   Model    -  KNN model                                          |
//|   XY       -  test set:                                          |
//|               * one row per point                                |
//|               * first NVars columns store independent variables  |
//|               * depending on problem type:                       |
//|                  * next column stores class number               |
//|                    in [0, NClasses) - for classification         |
//|                    problems                                      |
//|                  * next NOut columns store dependent             |
//|                    variables - for regression problems           |
//|   NPoints  -  test set size, NPoints >= 0                        |
//| OUTPUT PARAMETERS:                                               |
//|   Rep      -  following fields are loaded with errors for both   |
//|               regression and classification models:              |
//|               * rep.RMSError - RMS error for the output          |
//|               * rep.AvgError - average error                     |
//|               * rep.AvgRelError - average relative error         |
//|            following fields are set only for classification      |
//|            models, zero for regression ones:                     |
//|               * relclserror   - relative classification error,   |
//|                                 in [0, 1]                        |
//|               * avgce - average cross-entropy in bits per        |
//|                         dataset entry                            |
//| NOTE: the cross-entropy metric is too unstable when used to      |
//|       evaluate KNN models (such models can report exactly zero   |
//|       probabilities), so we do not recommend using it.           |
//+------------------------------------------------------------------+
void CAlglib::KNNAllErrors(CKNNModel &model,CMatrixDouble &xy,
                           int npoints,CKNNReport &rep)
  {
   CKNN::KNNAllErrors(model,xy,npoints,rep);
  }
//+------------------------------------------------------------------+
//| 1-dimensional complex FFT.                                       |
//| Array size N may be arbitrary number (composite or prime).       |
//| Composite N's are handled with cache-oblivious variation of a    |
//| Cooley-Tukey algorithm. Small prime-factors are transformed using|
//| hard coded codelets (similar to FFTW codelets, but without       |
//| low-level optimization), large prime-factors are handled with    |
//| Bluestein's algorithm.                                           |
//| Fastests transforms are for smooth N's (prime factors are 2, 3,  |
//| 5 only), most fast for powers of 2. When N have prime factors    |
//| larger than these, but orders of magnitude smaller than N,       |
//| computations will be about 4 times slower than for nearby highly |
//| composite N's. When N itself is prime, speed will be 6 times     |
//| lower.                                                           |
//| Algorithm has O(N*logN) complexity for any N (composite or       |
//| prime).                                                          |
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..N-1] - complex function to be transformed   |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     A   -   DFT of a input array, array[0..N-1]                  |
//|             A_out[j] = SUM(A_in[k]*exp(-2*pi*sqrt(-1)*j*k/N),    |
//|             k = 0..N-1)                                          |
//+------------------------------------------------------------------+
void CAlglib::FFTC1D(complex &a[],const int n)
  {
   CFastFourierTransform::FFTC1D(a,n);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FFTC1D(CRowComplex &a,const int n)
  {
   CFastFourierTransform::FFTC1D(a,n);
  }
//+------------------------------------------------------------------+
//| 1-dimensional complex FFT.                                       |
//| Array size N may be arbitrary number (composite or prime).       |
//| Composite N's are handled with cache-oblivious variation of a    |
//| Cooley-Tukey algorithm. Small prime-factors are transformed using|
//| hard coded codelets (similar to FFTW codelets, but without       |
//| low-level optimization), large prime-factors are handled with    |
//| Bluestein's algorithm.                                           |
//| Fastests transforms are for smooth N's (prime factors are 2, 3,  |
//| 5 only), most fast for powers of 2. When N have prime factors    |
//| larger than these, but orders of magnitude smaller than N,       |
//| computations will be about 4 times slower than for nearby highly |
//| composite N's. When N itself is prime, speed will be 6 times     |
//| lower.                                                           |
//| Algorithm has O(N*logN) complexity for any N (composite or       |
//| prime).                                                          |
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..N-1] - complex function to be transformed   |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     A   -   DFT of a input array, array[0..N-1]                  |
//|             A_out[j] = SUM(A_in[k]*exp(-2*pi*sqrt(-1)*j*k/N),    |
//|             k = 0..N-1)                                          |
//+------------------------------------------------------------------+
void CAlglib::FFTC1D(complex &a[])
  {
//--- initialization
   int n=CAp::Len(a);
//--- function call
   CFastFourierTransform::FFTC1D(a,n);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FFTC1D(CRowComplex &a)
  {
//--- initialization
   int n=CAp::Len(a);
//--- function call
   CFastFourierTransform::FFTC1D(a,n);
  }
//+------------------------------------------------------------------+
//| 1-dimensional complex inverse FFT.                               |
//| Array size N may be arbitrary number (composite or prime).       |
//| Algorithm has O(N*logN) complexity for any N (composite or prime)|
//| See FFTC1D() description for more information about algorithm    |
//| performance.                                                     |
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..N-1] - complex array to be transformed      |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     A   -   inverse DFT of a input array, array[0..N-1]          |
//|             A_out[j] = SUM(A_in[k]/N*exp(+2*pi*sqrt(-1)*j*k/N),  |
//|             k = 0..N-1)                                          |
//+------------------------------------------------------------------+
void CAlglib::FFTC1DInv(complex &a[],const int n)
  {
   CFastFourierTransform::FFTC1DInv(a,n);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FFTC1DInv(CRowComplex &a,const int n)
  {
   CFastFourierTransform::FFTC1DInv(a,n);
  }
//+------------------------------------------------------------------+
//| 1-dimensional complex inverse FFT.                               |
//| Array size N may be arbitrary number (composite or prime).       |
//| Algorithm has O(N*logN) complexity for any N (composite or prime)|
//| See FFTC1D() description for more information about algorithm    |
//| performance.                                                     |
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..N-1] - complex array to be transformed      |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     A   -   inverse DFT of a input array, array[0..N-1]          |
//|             A_out[j] = SUM(A_in[k]/N*exp(+2*pi*sqrt(-1)*j*k/N),  |
//|             k = 0..N-1)                                          |
//+------------------------------------------------------------------+
void CAlglib::FFTC1DInv(complex &a[])
  {
//--- initialization
   int n=CAp::Len(a);
//--- function call
   CFastFourierTransform::FFTC1DInv(a,n);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FFTC1DInv(CRowComplex &a)
  {
//--- initialization
   int n=CAp::Len(a);
//--- function call
   CFastFourierTransform::FFTC1DInv(a,n);
  }
//+------------------------------------------------------------------+
//| 1-dimensional real FFT.                                          |
//| Algorithm has O(N*logN) complexity for any N (composite or       |
//| prime).                                                          |
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..N-1] - real function to be transformed      |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     F   -   DFT of a input array, array[0..N-1]                  |
//|             F[j] = SUM(A[k]*exp(-2*pi*sqrt(-1)*j*k/N),           |
//|             k = 0..N-1)                                          |
//| NOTE:                                                            |
//|     F[] satisfies symmetry property F[k] = conj(F[N-k]), so just |
//| one half of array is usually needed. But for convinience         |
//| subroutine returns full complex array (with frequencies above    |
//| N/2), so its result may be used by other FFT-related subroutines.|
//+------------------------------------------------------------------+
void CAlglib::FFTR1D(double &a[],const int n,complex &f[])
  {
   CFastFourierTransform::FFTR1D(a,n,f);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FFTR1D(CRowDouble &a,const int n,CRowComplex &f)
  {
   CFastFourierTransform::FFTR1D(a,n,f);
  }
//+------------------------------------------------------------------+
//| 1-dimensional real FFT.                                          |
//| Algorithm has O(N*logN) complexity for any N (composite or       |
//| prime).                                                          |
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..N-1] - real function to be transformed      |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     F   -   DFT of a input array, array[0..N-1]                  |
//|             F[j] = SUM(A[k]*exp(-2*pi*sqrt(-1)*j*k/N),           |
//|             k = 0..N-1)                                          |
//| NOTE:                                                            |
//|     F[] satisfies symmetry property F[k] = conj(F[N-k]), so just |
//| one half of array is usually needed. But for convinience         |
//| subroutine returns full complex array (with frequencies above    |
//| N/2), so its result may be used by other FFT-related subroutines.|
//+------------------------------------------------------------------+
void CAlglib::FFTR1D(double &a[],complex &f[])
  {
//--- initialization
   int n=CAp::Len(a);
//--- function call
   CFastFourierTransform::FFTR1D(a,n,f);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FFTR1D(CRowDouble &a,CRowComplex &f)
  {
//--- initialization
   int n=CAp::Len(a);
//--- function call
   CFastFourierTransform::FFTR1D(a,n,f);
  }
//+------------------------------------------------------------------+
//| 1-dimensional real inverse FFT.                                  |
//| Algorithm has O(N*logN) complexity for any N (composite or       |
//| prime).                                                          |
//| INPUT PARAMETERS                                                 |
//|     F   -   array[0..floor(N/2)] - frequencies from forward real |
//|             FFT                                                  |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     A   -   inverse DFT of a input array, array[0..N-1]          |
//| NOTE:                                                            |
//|     F[] should satisfy symmetry property F[k] = conj(F[N-k]),    |
//| so just one half of frequencies array is needed - elements from 0|
//| to floor(N/2). F[0] is ALWAYS real. If N is even F[floor(N/2)] is|
//| real too. If N is odd, then F[floor(N/2)] has no special         |
//| properties.                                                      |
//| Relying on properties noted above, FFTR1DInv subroutine uses only|
//| elements from 0th to floor(N/2)-th. It ignores imaginary part of |
//| F[0], and in case N is even it ignores imaginary part of         |
//| F[floor(N/2)] too.                                               |
//| When you call this function using full arguments list -          |
//| "FFTR1DInv(F,N,A)"                                               |
//| - you can pass either either frequencies array with N elements or|
//| reduced array with roughly N/2 elements - subroutine will        |
//| successfully transform both.                                     |
//| If you call this function using reduced arguments list -         |
//| "FFTR1DInv(F,A)" - you must pass FULL array with N elements      |
//| (although higher N/2 are still not used) because array size is   |
//| used to automatically determine FFT length                       |
//+------------------------------------------------------------------+
void CAlglib::FFTR1DInv(complex &f[],const int n,double &a[])
  {
   CFastFourierTransform::FFTR1DInv(f,n,a);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FFTR1DInv(CRowComplex &f,const int n,CRowDouble &a)
  {
   CFastFourierTransform::FFTR1DInv(f,n,a);
  }
//+------------------------------------------------------------------+
//| 1-dimensional real inverse FFT.                                  |
//| Algorithm has O(N*logN) complexity for any N (composite or       |
//| prime).                                                          |
//| INPUT PARAMETERS                                                 |
//|     F   -   array[0..floor(N/2)] - frequencies from forward real |
//|             FFT                                                  |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     A   -   inverse DFT of a input array, array[0..N-1]          |
//| NOTE:                                                            |
//|     F[] should satisfy symmetry property F[k] = conj(F[N-k]),    |
//| so just one half of frequencies array is needed - elements from 0|
//| to floor(N/2). F[0] is ALWAYS real. If N is even F[floor(N/2)] is|
//| real too. If N is odd, then F[floor(N/2)] has no special         |
//| properties.                                                      |
//| Relying on properties noted above, FFTR1DInv subroutine uses only|
//| elements from 0th to floor(N/2)-th. It ignores imaginary part of |
//| F[0], and in case N is even it ignores imaginary part of         |
//| F[floor(N/2)] too.                                               |
//| When you call this function using full arguments list -          |
//| "FFTR1DInv(F,N,A)"                                               |
//| - you can pass either either frequencies array with N elements or|
//| reduced array with roughly N/2 elements - subroutine will        |
//| successfully transform both.                                     |
//| If you call this function using reduced arguments list -         |
//| "FFTR1DInv(F,A)" - you must pass FULL array with N elements      |
//| (although higher N/2 are still not used) because array size is   |
//| used to automatically determine FFT length                       |
//+------------------------------------------------------------------+
void CAlglib::FFTR1DInv(complex &f[],double &a[])
  {
//--- initialization
   int n=CAp::Len(f);
//--- function call
   CFastFourierTransform::FFTR1DInv(f,n,a);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::FFTR1DInv(CRowComplex &f,CRowDouble &a)
  {
//--- initialization
   int n=CAp::Len(f);
//--- function call
   CFastFourierTransform::FFTR1DInv(f,n,a);
  }
//+------------------------------------------------------------------+
//| 1-dimensional complex convolution.                               |
//| For given A/B returns conv(A,B) (non-circular). Subroutine can   |
//| automatically choose between three implementations:              |
//| straightforward O(M*N) formula for very small N (or M),          |
//| significantly larger than min(M,N), but O(M*N) algorithm is too  |
//| slow, and general FFT-based formula for cases where two previois |
//| algorithms are too slow.                                         |
//| Algorithm has max(M,N)*log(max(M,N)) complexity for any M/N.     |
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..M-1] - complex function to be transformed   |
//|     M   -   problem size                                         |
//|     B   -   array[0..N-1] - complex function to be transformed   |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     R   -   convolution: A*B. array[0..N+M-2].                   |
//| NOTE:                                                            |
//|     It is assumed that A is zero at T<0, B is zero too. If one or|
//| both functions have non-zero values at negative T's, you can     |
//| still use this subroutine - just shift its result                |
//| correspondingly.                                                 |
//+------------------------------------------------------------------+
void CAlglib::ConvC1D(complex &a[],const int m,complex &b[],
                      const int n,complex &r[])
  {
   CConv::ConvC1D(a,m,b,n,r);
  }
//+------------------------------------------------------------------+
//| 1-dimensional complex non-circular deconvolution (inverse of     |
//| ConvC1D()).                                                      |
//| Algorithm has M*log(M)) complexity for any M (composite or prime)|
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..M-1] - convolved signal, A = conv(R, B)     |
//|     M   -   convolved signal length                              |
//|     B   -   array[0..N-1] - response                             |
//|     N   -   response length, N<=M                                |
//| OUTPUT PARAMETERS                                                |
//|     R   -   deconvolved signal. array[0..M-N].                   |
//| NOTE:                                                            |
//|     deconvolution is unstable process and may result in division |
//| by zero (if your response function is degenerate, i.e. has zero  |
//| Fourier coefficient).                                            |
//| NOTE:                                                            |
//|     It is assumed that A is zero at T<0, B is zero too. If one   |
//| or both functions have non-zero values at negative T's, you can  |
//| still use this subroutine - just shift its result correspondingly|
//+------------------------------------------------------------------+
void CAlglib::ConvC1DInv(complex &a[],const int m,complex &b[],
                         const int n,complex &r[])
  {
   CConv::ConvC1DInv(a,m,b,n,r);
  }
//+------------------------------------------------------------------+
//| 1-dimensional circular complex convolution.                      |
//| For given S/R returns conv(S,R) (circular). Algorithm has        |
//| linearithmic complexity for any M/N.                             |
//| IMPORTANT:  normal convolution is commutative, i.e. it is        |
//| symmetric - conv(A,B)=conv(B,A). Cyclic convolution IS NOT. One  |
//| function - S - is a signal, periodic function, and another - R - |
//| is a response, non-periodic function with limited length.        |
//| INPUT PARAMETERS                                                 |
//|     S   -   array[0..M-1] - complex periodic signal              |
//|     M   -   problem size                                         |
//|     B   -   array[0..N-1] - complex non-periodic response        |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     R   -   convolution: A*B. array[0..M-1].                     |
//| NOTE:                                                            |
//|     It is assumed that B is zero at T<0. If it has non-zero      |
//| values at negative T's, you can still use this subroutine - just |
//| shift its result correspondingly.                                |
//+------------------------------------------------------------------+
void CAlglib::ConvC1DCircular(complex &s[],const int m,complex &r[],
                              const int n,complex &c[])
  {
   CConv::ConvC1DCircular(s,m,r,n,c);
  }
//+------------------------------------------------------------------+
//| 1-dimensional circular complex deconvolution (inverse of         |
//| ConvC1DCircular()).                                              |
//| Algorithm has M*log(M)) complexity for any M (composite or prime)|
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..M-1] - convolved periodic signal,           |
//|             A = conv(R, B)                                       |
//|     M   -   convolved signal length                              |
//|     B   -   array[0..N-1] - non-periodic response                |
//|     N   -   response length                                      |
//| OUTPUT PARAMETERS                                                |
//|     R   -   deconvolved signal. array[0..M-1].                   |
//| NOTE:                                                            |
//|     deconvolution is unstable process and may result in division |
//| by zero (if your response function is degenerate, i.e. has zero  |
//| Fourier coefficient).                                            |
//| NOTE:                                                            |
//|     It is assumed that B is zero at T<0. If it has non-zero      |
//| values at negative T's, you can still use this subroutine - just |
//| shift its result correspondingly.                                |
//+------------------------------------------------------------------+
void CAlglib::ConvC1DCircularInv(complex &a[],const int m,complex &b[],
                                 const int n,complex &r[])
  {
   CConv::ConvC1DCircularInv(a,m,b,n,r);
  }
//+------------------------------------------------------------------+
//| 1-dimensional real convolution.                                  |
//| Analogous to ConvC1D(), see ConvC1D() comments for more details. |
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..M-1] - real function to be transformed      |
//|     M   -   problem size                                         |
//|     B   -   array[0..N-1] - real function to be transformed      |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     R   -   convolution: A*B. array[0..N+M-2].                   |
//| NOTE:                                                            |
//|     It is assumed that A is zero at T<0, B is zero too. If one   |
//| or both functions have non-zero values at negative T's, you can  |
//| still use this subroutine - just shift its result correspondingly|
//+------------------------------------------------------------------+
void CAlglib::ConvR1D(double &a[],const int m,double &b[],
                      const int n,double &r[])
  {
   CConv::ConvR1D(a,m,b,n,r);
  }
//+------------------------------------------------------------------+
//| 1-dimensional real deconvolution (inverse of ConvC1D()).         |
//| Algorithm has M*log(M)) complexity for any M (composite or prime)|
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..M-1] - convolved signal, A = conv(R, B)     |
//|     M   -   convolved signal length                              |
//|     B   -   array[0..N-1] - response                             |
//|     N   -   response length, N<=M                                |
//| OUTPUT PARAMETERS                                                |
//|     R   -   deconvolved signal. array[0..M-N].                   |
//| NOTE:                                                            |
//|     deconvolution is unstable process and may result in division |
//| by zero (if your response function is degenerate, i.e. has zero  |
//| Fourier coefficient).                                            |
//| NOTE:                                                            |
//|     It is assumed that A is zero at T<0, B is zero too. If one or|
//| both functions have non-zero values at negative T's, you can     |
//| still use this subroutine - just shift its result correspondingly|
//+------------------------------------------------------------------+
void CAlglib::ConvR1DInv(double &a[],const int m,double &b[],
                         const int n,double &r[])
  {
   CConv::ConvR1DInv(a,m,b,n,r);
  }
//+------------------------------------------------------------------+
//| 1-dimensional circular real convolution.                         |
//| Analogous to ConvC1DCircular(), see ConvC1DCircular() comments   |
//| for more details.                                                |
//| INPUT PARAMETERS                                                 |
//|     S   -   array[0..M-1] - real signal                          |
//|     M   -   problem size                                         |
//|     B   -   array[0..N-1] - real response                        |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     R   -   convolution: A*B. array[0..M-1].                     |
//| NOTE:                                                            |
//|     It is assumed that B is zero at T<0. If it has non-zero      |
//| values at negative T's, you can still use this subroutine - just |
//| shift its result correspondingly.                                |
//+------------------------------------------------------------------+
void CAlglib::ConvR1DCircular(double &s[],const int m,double &r[],
                              const int n,double &c[])
  {
   CConv::ConvR1DCircular(s,m,r,n,c);
  }
//+------------------------------------------------------------------+
//| 1-dimensional complex deconvolution (inverse of ConvC1D()).      |
//| Algorithm has M*log(M)) complexity for any M (composite or prime)|
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..M-1] - convolved signal, A = conv(R, B)     |
//|     M   -   convolved signal length                              |
//|     B   -   array[0..N-1] - response                             |
//|     N   -   response length                                      |
//| OUTPUT PARAMETERS                                                |
//|     R   -   deconvolved signal. array[0..M-N].                   |
//| NOTE:                                                            |
//|     deconvolution is unstable process and may result in division |
//| by zero (if your response function is degenerate, i.e. has zero  |
//| Fourier coefficient).                                            |
//| NOTE:                                                            |
//|     It is assumed that B is zero at T<0. If it has non-zero      |
//| values at negative T's, you can still use this subroutine - just |
//| shift its result correspondingly.                                |
//+------------------------------------------------------------------+
void CAlglib::ConvR1DCircularInv(double &a[],const int m,double &b[],
                                 const int n,double &r[])
  {
   CConv::ConvR1DCircularInv(a,m,b,n,r);
  }
//+------------------------------------------------------------------+
//| 1-dimensional complex cross-correlation.                         |
//| For given Pattern/Signal returns corr(Pattern,Signal)            |
//| (non-circular).                                                  |
//| Correlation is calculated using reduction to convolution.        |
//| Algorithm with max(N,N)*log(max(N,N)) complexity is used (see    |
//| ConvC1D() for more info about performance).                      |
//| IMPORTANT:                                                       |
//|     for historical reasons subroutine accepts its parameters in  |
//|     reversed order: CorrC1D(Signal, Pattern) = Pattern x Signal  |
//|     (using traditional definition of cross-correlation, denoting |
//|     cross-correlation as "x").                                   |
//| INPUT PARAMETERS                                                 |
//|     Signal  -   array[0..N-1] - complex function to be           |
//|                 transformed, signal containing pattern           |
//|     N       -   problem size                                     |
//|     Pattern -   array[0..M-1] - complex function to be           |
//|                 transformed, pattern to search withing signal    |
//|     M       -   problem size                                     |
//| OUTPUT PARAMETERS                                                |
//|     R       -   cross-correlation, array[0..N+M-2]:              |
//|                 * positive lags are stored in R[0..N-1],         |
//|                   R[i] = sum(conj(pattern[j])*signal[i+j]        |
//|                 * negative lags are stored in R[N..N+M-2],       |
//|                   R[N+M-1-i] = sum(conj(pattern[j])*signal[-i+j] |
//| NOTE:                                                            |
//|     It is assumed that pattern domain is [0..M-1]. If Pattern is |
//| non-zero on [-K..M-1], you can still use this subroutine, just   |
//| shift result by K.                                               |
//+------------------------------------------------------------------+
void CAlglib::CorrC1D(complex &signal[],const int n,complex &pattern[],
                      const int m,complex &r[])
  {
   CCorr::CorrC1D(signal,n,pattern,m,r);
  }
//+------------------------------------------------------------------+
//| 1-dimensional circular complex cross-correlation.                |
//| For given Pattern/Signal returns corr(Pattern,Signal) (circular).|
//| Algorithm has linearithmic complexity for any M/N.               |
//| IMPORTANT:                                                       |
//|     for historical reasons subroutine accepts its parameters in  |
//|     reversed order: CorrC1DCircular(Signal, Pattern) = Pattern x |
//|     Signal (using traditional definition of cross-correlation,   |
//|     denoting cross-correlation as "x").                          |
//| INPUT PARAMETERS                                                 |
//|     Signal  -   array[0..N-1] - complex function to be           |
//|                 transformed, periodic signal containing pattern  |
//|     N       -   problem size                                     |
//|     Pattern -   array[0..M-1] - complex function to be           |
//|                 transformed, non-periodic pattern to search      |
//|                 withing signal                                   |
//|     M       -   problem size                                     |
//| OUTPUT PARAMETERS                                                |
//|     R   -   convolution: A*B. array[0..M-1].                     |
//+------------------------------------------------------------------+
void CAlglib::CorrC1DCircular(complex &signal[],const int m,
                              complex &pattern[],const int n,
                              complex &c[])
  {
   CCorr::CorrC1DCircular(signal,m,pattern,n,c);
  }
//+------------------------------------------------------------------+
//| 1-dimensional real cross-correlation.                            |
//| For given Pattern/Signal returns corr(Pattern,Signal)            |
//| (non-circular).                                                  |
//| Correlation is calculated using reduction to convolution.        |
//| Algorithm with max(N,N)*log(max(N,N)) complexity is used (see    |
//| ConvC1D() for more info about performance).                      |
//| IMPORTANT:                                                       |
//|     for  historical reasons subroutine accepts its parameters in |
//|     reversed order: CorrR1D(Signal, Pattern) = Pattern x Signal  |
//|     (using  traditional definition of cross-correlation, denoting|
//|     cross-correlation as "x").                                   |
//| INPUT PARAMETERS                                                 |
//|     Signal  -   array[0..N-1] - real function to be transformed, |
//|                 signal containing pattern                        |
//|     N       -   problem size                                     |
//|     Pattern -   array[0..M-1] - real function to be transformed, |
//|                 pattern to search withing signal                 |
//|     M       -   problem size                                     |
//| OUTPUT PARAMETERS                                                |
//|     R       -   cross-correlation, array[0..N+M-2]:              |
//|                 * positive lags are stored in R[0..N-1],         |
//|                   R[i] = sum(pattern[j]*signal[i+j]              |
//|                 * negative lags are stored in R[N..N+M-2],       |
//|                   R[N+M-1-i] = sum(pattern[j]*signal[-i+j]       |
//| NOTE:                                                            |
//|     It is assumed that pattern domain is [0..M-1]. If Pattern is |
//| non-zero on [-K..M-1],  you can still use this subroutine, just  |
//| shift result by K.                                               |
//+------------------------------------------------------------------+
void CAlglib::CorrR1D(double &signal[],const int n,double &pattern[],
                      const int m,double &r[])
  {
   CCorr::CorrR1D(signal,n,pattern,m,r);
  }
//+------------------------------------------------------------------+
//| 1-dimensional circular real cross-correlation.                   |
//| For given Pattern/Signal returns corr(Pattern,Signal) (circular).|
//| Algorithm has linearithmic complexity for any M/N.               |
//| IMPORTANT:                                                       |
//|     for  historical reasons subroutine accepts its parameters in |
//|     reversed order: CorrR1DCircular(Signal, Pattern) = Pattern x |
//|     Signal (using traditional definition of cross-correlation,   |
//|     denoting cross-correlation as "x").                          |
//| INPUT PARAMETERS                                                 |
//|     Signal  -   array[0..N-1] - real function to be transformed, |
//|                 periodic signal containing pattern               |
//|     N       -   problem size                                     |
//|     Pattern -   array[0..M-1] - real function to be transformed, |
//|                 non-periodic pattern to search withing signal    |
//|     M       -   problem size                                     |
//| OUTPUT PARAMETERS                                                |
//|     R   -   convolution: A*B. array[0..M-1].                     |
//+------------------------------------------------------------------+
void CAlglib::CorrR1DCircular(double &signal[],const int m,
                              double &pattern[],const int n,
                              double &c[])
  {
   CCorr::CorrR1DCircular(signal,m,pattern,n,c);
  }
//+------------------------------------------------------------------+
//| 1-dimensional Fast Hartley Transform.                            |
//| Algorithm has O(N*logN) complexity for any N (composite or prime)|
//| INPUT PARAMETERS                                                 |
//|     A  -  array[0..N-1] - real function to be transformed        |
//|     N  -  problem size                                           |
//| OUTPUT PARAMETERS                                                |
//|     A  -  FHT of a input array, array[0..N-1],                   |
//|           A_out[k]=sum(A_in[j]*(cos(2*pi*j*k/N)+sin(2*pi*j*k/N)),|
//|           j=0..N-1)                                              |
//+------------------------------------------------------------------+
void CAlglib::FHTR1D(double &a[],const int n)
  {
   CFastHartleyTransform::FHTR1D(a,n);
  }
//+------------------------------------------------------------------+
//| 1-dimensional inverse FHT.                                       |
//| Algorithm has O(N*logN) complexity for any N (composite or prime)|
//| INPUT PARAMETERS                                                 |
//|     A   -   array[0..N-1] - complex array to be transformed      |
//|     N   -   problem size                                         |
//| OUTPUT PARAMETERS                                                |
//|     A   -   inverse FHT of a input array, array[0..N-1]          |
//+------------------------------------------------------------------+
void CAlglib::FHTR1DInv(double &a[],const int n)
  {
   CFastHartleyTransform::FHTR1DInv(a,n);
  }
//+------------------------------------------------------------------+
//| Computation of nodes and weights for a Gauss quadrature formula  |
//| The algorithm generates the N-point Gauss quadrature formula     |
//| with weight function given by coefficients alpha and beta of a   |
//| recurrence relation which generates a system of orthogonal       |
//| polynomials:                                                     |
//| P-1(x)   =  0                                                    |
//| P0(x)    =  1                                                    |
//| Pn+1(x)  =  (x-alpha(n))*Pn(x)  -  beta(n)*Pn-1(x)               |
//| and zeroth moment Mu0                                            |
//| Mu0 = integral(W(x)dx,a,b)                                       |
//| INPUT PARAMETERS:                                                |
//|     Alpha   ?   array[0..N-1], alpha coefficients                |
//|     Beta    ?   array[0..N-1], beta coefficients                 |
//|                 Zero-indexed element is not used and may be      |
//|                 arbitrary. Beta[I]>0.                            |
//|     Mu0     ?   zeroth moment of the weight function.            |
//|     N       ?   number of nodes of the quadrature formula, N>=1  |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   error code:                                      |
//|                 * -3    internal eigenproblem solver hasn't      |
//|                         converged                                |
//|                 * -2    Beta[i]<=0                               |
//|                 * -1    incorrect N was passed                   |
//|                 *  1    OK                                       |
//|     X       -   array[0..N-1] - array of quadrature nodes,       |
//|                 in ascending order.                              |
//|     W       -   array[0..N-1] - array of quadrature weights.     |
//+------------------------------------------------------------------+
void CAlglib::GQGenerateRec(double &alpha[],double &beta[],
                            const double mu0,const int n,
                            int &info,double &x[],double &w[])
  {
//--- initialization
   info=0;
//--- function call
   CGaussQ::GQGenerateRec(alpha,beta,mu0,n,info,x,w);
  }
//+------------------------------------------------------------------+
//| Computation of nodes and weights for a Gauss-Lobatto quadrature  |
//| formula                                                          |
//| The algorithm generates the N-point Gauss-Lobatto quadrature     |
//| formula with weight function given by coefficients alpha and beta|
//| of a recurrence which generates a system of orthogonal           |
//| polynomials.                                                     |
//| P-1(x)   =  0                                                    |
//| P0(x)    =  1                                                    |
//| Pn+1(x)  =  (x-alpha(n))*Pn(x)  -  beta(n)*Pn-1(x)               |
//| and zeroth moment Mu0                                            |
//| Mu0 = integral(W(x)dx,a,b)                                       |
//| INPUT PARAMETERS:                                                |
//|     Alpha   ?   array[0..N-2], alpha coefficients                |
//|     Beta    ?   array[0..N-2], beta coefficients.                |
//|                 Zero-indexed element is not used, may be         |
//|                 arbitrary. Beta[I]>0                             |
//|     Mu0     ?   zeroth moment of the weighting function.         |
//|     A       ?   left boundary of the integration interval.       |
//|     B       ?   right boundary of the integration interval.      |
//|     N       ?   number of nodes of the quadrature formula, N>=3  |
//|                 (including the left and right boundary nodes).   |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   error code:                                      |
//|                 * -3    internal eigenproblem solver hasn't      |
//|                         converged                                |
//|                 * -2    Beta[i]<=0                               |
//|                 * -1    incorrect N was passed                   |
//|                 *  1    OK                                       |
//|     X       -   array[0..N-1] - array of quadrature nodes,       |
//|                 in ascending order.                              |
//|     W       -   array[0..N-1] - array of quadrature weights.     |
//+------------------------------------------------------------------+
void CAlglib::GQGenerateGaussLobattoRec(double &alpha[],double &beta[],
                                        const double mu0,const double a,
                                        const double b,const int n,
                                        int &info,double &x[],double &w[])
  {
//--- initialization
   info=0;
//--- function call
   CGaussQ::GQGenerateGaussLobattoRec(alpha,beta,mu0,a,b,n,info,x,w);
  }
//+------------------------------------------------------------------+
//| Computation of nodes and weights for a Gauss-Radau quadrature    |
//| formula                                                          |
//| The algorithm generates the N-point Gauss-Radau  quadrature      |
//| formula with weight function given by the coefficients alpha and |
//| beta of a recurrence which generates a system of orthogonal      |
//| polynomials.                                                     |
//| P-1(x)   =  0                                                    |
//| P0(x)    =  1                                                    |
//| Pn+1(x)  =  (x-alpha(n))*Pn(x)  -  beta(n)*Pn-1(x)               |
//| and zeroth moment Mu0                                            |
//| Mu0 = integral(W(x)dx,a,b)                                       |
//| INPUT PARAMETERS:                                                |
//|     Alpha   ?   array[0..N-2], alpha coefficients.               |
//|     Beta    ?   array[0..N-1], beta coefficients                 |
//|                 Zero-indexed element is not used.                |
//|                 Beta[I]>0                                        |
//|     Mu0     ?   zeroth moment of the weighting function.         |
//|     A       ?   left boundary of the integration interval.       |
//|     N       ?   number of nodes of the quadrature formula, N>=2  |
//|                 (including the left boundary node).              |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   error code:                                      |
//|                 * -3    internal eigenproblem solver hasn't      |
//|                         converged                                |
//|                 * -2    Beta[i]<=0                               |
//|                 * -1    incorrect N was passed                   |
//|                 *  1    OK                                       |
//|     X       -   array[0..N-1] - array of quadrature nodes,       |
//|                 in ascending order.                              |
//|     W       -   array[0..N-1] - array of quadrature weights.     |
//+------------------------------------------------------------------+
void CAlglib::GQGenerateGaussRadauRec(double &alpha[],double &beta[],
                                      const double mu0,const double a,
                                      const int n,int &info,
                                      double &x[],double &w[])
  {
//--- initialization
   info=0;
//--- function call
   CGaussQ::GQGenerateGaussRadauRec(alpha,beta,mu0,a,n,info,x,w);
  }
//+------------------------------------------------------------------+
//| Returns nodes/weights for Gauss-Legendre quadrature on [-1,1]    |
//| with N nodes.                                                    |
//| INPUT PARAMETERS:                                                |
//|     N           -   number of nodes, >=1                         |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   error code:                                  |
//|                     * -4    an error was detected when           |
//|                             calculating weights/nodes. N is too  |
//|                             large to obtain weights/nodes with   |
//|                             high enough accuracy. Try to use     |
//|                             multiple precision version.          |
//|                     * -3    internal eigenproblem solver hasn't  |
//|                             converged                            |
//|                     * -1    incorrect N was passed               |
//|                     * +1    OK                                   |
//|     X           -   array[0..N-1] - array of quadrature nodes,   |
//|                     in ascending order.                          |
//|     W           -   array[0..N-1] - array of quadrature weights. |
//+------------------------------------------------------------------+
void CAlglib::GQGenerateGaussLegendre(const int n,int &info,
                                      double &x[],double &w[])
  {
//--- initialization
   info=0;
//--- function call
   CGaussQ::GQGenerateGaussLegendre(n,info,x,w);
  }
//+------------------------------------------------------------------+
//| Returns  nodes/weights  for  Gauss-Jacobi quadrature on [-1,1]   |
//| with weight function W(x)=Power(1-x,Alpha)*Power(1+x,Beta).      |
//| INPUT PARAMETERS:                                                |
//|     N           -   number of nodes, >=1                         |
//|     Alpha       -   power-law coefficient, Alpha>-1              |
//|     Beta        -   power-law coefficient, Beta>-1               |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   error code:                                  |
//|                     * -4    an error was detected when           |
//|                             calculating weights/nodes. Alpha or  |
//|                             Beta are too close to -1 to obtain   |
//|                             weights/nodes with high enough       |
//|                             accuracy, or, may be, N is too large.|
//|                             Try to use multiple precision version|
//|                     * -3    internal eigenproblem solver hasn't  |
//|                             converged                            |
//|                     * -1    incorrect N/Alpha/Beta was passed    |
//|                     * +1    OK                                   |
//|     X           -   array[0..N-1] - array of quadrature nodes,   |
//|                     in ascending order.                          |
//|     W           -   array[0..N-1] - array of quadrature weights. |
//+------------------------------------------------------------------+
void CAlglib::GQGenerateGaussJacobi(const int n,const double alpha,
                                    const double beta,int &info,
                                    double &x[],double &w[])
  {
//--- initialization
   info=0;
//--- function call
   CGaussQ::GQGenerateGaussJacobi(n,alpha,beta,info,x,w);
  }
//+------------------------------------------------------------------+
//| Returns nodes/weights for Gauss-Laguerre quadrature on [0,+inf)  |
//| with weight function W(x)=Power(x,Alpha)*Exp(-x)                 |
//| INPUT PARAMETERS:                                                |
//|     N           -   number of nodes, >=1                         |
//|     Alpha       -   power-law coefficient, Alpha>-1              |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   error code:                                  |
//|                     * -4    an error was detected when           |
//|                             calculating weights/nodes. Alpha is  |
//|                             too close to -1 to obtain            |
//|                             weights/nodes with high enough       |
//|                             accuracy or, may  be, N is too large.|
//|                             Try  to  use multiple precision      |
//|                             version.                             |
//|                     * -3    internal eigenproblem solver hasn't  |
//|                             converged                            |
//|                     * -1    incorrect N/Alpha was passed         |
//|                     * +1    OK                                   |
//|     X           -   array[0..N-1] - array of quadrature nodes,   |
//|                     in ascending order.                          |
//|     W           -   array[0..N-1] - array of quadrature weights. |
//+------------------------------------------------------------------+
void CAlglib::GQGenerateGaussLaguerre(const int n,const double alpha,
                                      int &info,double &x[],double &w[])
  {
//--- initialization
   info=0;
//--- function call
   CGaussQ::GQGenerateGaussLaguerre(n,alpha,info,x,w);
  }
//+------------------------------------------------------------------+
//| Returns  nodes/weights  for  Gauss-Hermite  quadrature on        |
//| (-inf,+inf) with weight function W(x)=Exp(-x*x)                  |
//| INPUT PARAMETERS:                                                |
//|     N           -   number of nodes, >=1                         |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   error code:                                  |
//|                     * -4    an error was detected when           |
//|                             calculating weights/nodes. May be, N |
//|                             is too large. Try to use multiple    |
//|                             precision version.                   |
//|                     * -3    internal eigenproblem solver hasn't  |
//|                             converged                            |
//|                     * -1    incorrect N/Alpha was passed         |
//|                     * +1    OK                                   |
//|     X           -   array[0..N-1] - array of quadrature nodes,   |
//|                     in ascending order.                          |
//|     W           -   array[0..N-1] - array of quadrature weights. |
//+------------------------------------------------------------------+
void CAlglib::GQGenerateGaussHermite(const int n,int &info,
                                     double &x[],double &w[])
  {
//--- initialization
   info=0;
//--- function call
   CGaussQ::GQGenerateGaussHermite(n,info,x,w);
  }
//+------------------------------------------------------------------+
//| Computation of nodes and weights of a Gauss-Kronrod quadrature   |
//| formula                                                          |
//| The algorithm generates the N-point Gauss-Kronrod quadrature     |
//| formula with weight function given by coefficients alpha and beta|
//| of a recurrence relation which generates a system of orthogonal  |
//| polynomials:                                                     |
//|     P-1(x)   =  0                                                |
//|     P0(x)    =  1                                                |
//|     Pn+1(x)  =  (x-alpha(n))*Pn(x)  -  beta(n)*Pn-1(x)           |
//| and zero moment Mu0                                              |
//|     Mu0 = integral(W(x)dx,a,b)                                   |
//| INPUT PARAMETERS:                                                |
//|     Alpha       ?   alpha coefficients, array[0..floor(3*K/2)].  |
//|     Beta        ?   beta coefficients,  array[0..ceil(3*K/2)].   |
//|                     Beta[0] is not used and may be arbitrary.    |
//|                     Beta[I]>0.                                   |
//|     Mu0         ?   zeroth moment of the weight function.        |
//|     N           ?   number of nodes of the Gauss-Kronrod         |
//|                     quadrature formula,                          |
//|                     N >= 3,                                      |
//|                     N =  2*K+1.                                  |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   error code:                                  |
//|                     * -5    no real and positive Gauss-Kronrod   |
//|                             formula can be created for such a    |
//|                             weight function with a given number  |
//|                             of nodes.                            |
//|                     * -4    N is too large, task may be ill      |
//|                             conditioned - x[i]=x[i+1] found.     |
//|                     * -3    internal eigenproblem solver hasn't  |
//|                             converged                            |
//|                     * -2    Beta[i]<=0                           |
//|                     * -1    incorrect N was passed               |
//|                     * +1    OK                                   |
//|     X           -   array[0..N-1] - array of quadrature nodes,   |
//|                     in ascending order.                          |
//|     WKronrod    -   array[0..N-1] - Kronrod weights              |
//|     WGauss      -   array[0..N-1] - Gauss weights (interleaved   |
//|                     with zeros corresponding to extended Kronrod |
//|                     nodes).                                      |
//+------------------------------------------------------------------+
void CAlglib::GKQGenerateRec(double &alpha[],double &beta[],
                             const double mu0,const int n,
                             int &info,double &x[],
                             double &wkronrod[],double &wgauss[])
  {
//--- initialization
   info=0;
//--- function call
   CGaussKronrodQ::GKQGenerateRec(alpha,beta,mu0,n,info,x,wkronrod,wgauss);
  }
//+------------------------------------------------------------------+
//| Returns Gauss and Gauss-Kronrod nodes/weights for Gauss-Legendre |
//| quadrature with N points.                                        |
//| GKQLegendreCalc (calculation) or GKQLegendreTbl (precomputed     |
//| table) is used depending on machine precision and number of      |
//| nodes.                                                           |
//| INPUT PARAMETERS:                                                |
//|     N           -   number of Kronrod nodes, must be odd number, |
//|                     >=3.                                         |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   error code:                                  |
//|                     * -4    an error was detected when           |
//|                             calculating weights/nodes. N is too  |
//|                             obtain large to weights/nodes with   |
//|                             high enough accuracy. Try to use     |
//|                             multiple precision version.          |
//|                     * -3    internal eigenproblem solver hasn't  |
//|                             converged                            |
//|                     * -1    incorrect N was passed               |
//|                     * +1    OK                                   |
//|     X           -   array[0..N-1] - array of quadrature nodes,   |
//|                     ordered in ascending order.                  |
//|     WKronrod    -   array[0..N-1] - Kronrod weights              |
//|     WGauss      -   array[0..N-1] - Gauss weights (interleaved   |
//|                     with zeros corresponding to extended Kronrod |
//|                     nodes).                                      |
//+------------------------------------------------------------------+
void CAlglib::GKQGenerateGaussLegendre(const int n,int &info,
                                       double &x[],double &wkronrod[],
                                       double &wgauss[])
  {
//--- initialization
   info=0;
//--- function call
   CGaussKronrodQ::GKQGenerateGaussLegendre(n,info,x,wkronrod,wgauss);
  }
//+------------------------------------------------------------------+
//| Returns Gauss and Gauss-Kronrod nodes/weights for Gauss-Jacobi   |
//| quadrature on [-1,1] with weight function                        |
//|     W(x)=Power(1-x,Alpha)*Power(1+x,Beta).                       |
//| INPUT PARAMETERS:                                                |
//|     N           -   number of Kronrod nodes, must be odd number, |
//|                     >=3.                                         |
//|     Alpha       -   power-law coefficient, Alpha>-1              |
//|     Beta        -   power-law coefficient, Beta>-1               |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   error code:                                  |
//|                     * -5    no real and positive Gauss-Kronrod   |
//|                             formula can be created for such a    |
//|                             weight function with a given number  |
//|                             of nodes.                            |
//|                     * -4    an  error was detected when          |
//|                             calculating weights/nodes. Alpha or  |
//|                             Beta are too close to -1 to obtain   |
//|                             weights/nodes with high enough       |
//|                             accuracy, or, may be, N is too large.|
//|                             Try to use multiple precision version|
//|                     * -3    internal eigenproblem solver hasn't  |
//|                             converged                            |
//|                     * -1    incorrect N was passed               |
//|                     * +1    OK                                   |
//|                     * +2    OK, but quadrature rule have exterior|
//|                             nodes, x[0]<-1 or x[n-1]>+1          |
//|     X           -   array[0..N-1] - array of quadrature nodes,   |
//|                     ordered in ascending order.                  |
//|     WKronrod    -   array[0..N-1] - Kronrod weights              |
//|     WGauss      -   array[0..N-1] - Gauss weights (interleaved   |
//|                     with zeros corresponding to extended Kronrod |
//|                     nodes).                                      |
//+------------------------------------------------------------------+
void CAlglib::GKQGenerateGaussJacobi(const int n,const double alpha,
                                     const double beta,int &info,
                                     double &x[],double &wkronrod[],
                                     double &wgauss[])
  {
//--- initialization
   info=0;
//--- function call
   CGaussKronrodQ::GKQGenerateGaussJacobi(n,alpha,beta,info,x,wkronrod,wgauss);
  }
//+------------------------------------------------------------------+
//| Returns Gauss and Gauss-Kronrod nodes for quadrature with N      |
//| points.                                                          |
//| Reduction to tridiagonal eigenproblem is used.                   |
//| INPUT PARAMETERS:                                                |
//|     N           -   number of Kronrod nodes, must be odd number, |
//|                     >=3.                                         |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   error code:                                  |
//|                     * -4    an error was detected when           |
//|                             calculating weights/nodes. N is too  |
//|                             large to obtain weights/nodes with   |
//|                             high enough accuracy.                |
//|                             Try to use multiple precision        |
//|                             version.                             |
//|                     * -3    internal eigenproblem solver hasn't  |
//|                             converged                            |
//|                     * -1    incorrect N was passed               |
//|                     * +1    OK                                   |
//|     X           -   array[0..N-1] - array of quadrature nodes,   |
//|                     ordered in ascending order.                  |
//|     WKronrod    -   array[0..N-1] - Kronrod weights              |
//|     WGauss      -   array[0..N-1] - Gauss weights (interleaved   |
//|                     with zeros corresponding to extended Kronrod |
//|                     nodes).                                      |
//+------------------------------------------------------------------+
void CAlglib::GKQLegendreCalc(const int n,int &info,double &x[],
                              double &wkronrod[],double &wgauss[])
  {
//--- initialization
   info=0;
//--- function call
   CGaussKronrodQ::GKQLegendreCalc(n,info,x,wkronrod,wgauss);
  }
//+------------------------------------------------------------------+
//| Returns Gauss and Gauss-Kronrod nodes for quadrature with N      |
//| points using pre-calculated table. Nodes/weights were computed   |
//| with accuracy up to 1.0E-32 (if MPFR version of ALGLIB is used). |
//| In standard double precision accuracy reduces to something about |
//| 2.0E-16 (depending  on your compiler's handling of long floating |
//| point constants).                                                |
//| INPUT PARAMETERS:                                                |
//|     N           -   number of Kronrod nodes.                     |
//|                     N can be 15, 21, 31, 41, 51, 61.             |
//| OUTPUT PARAMETERS:                                               |
//|     X           -   array[0..N-1] - array of quadrature nodes,   |
//|                     ordered in ascending order.                  |
//|     WKronrod    -   array[0..N-1] - Kronrod weights              |
//|     WGauss      -   array[0..N-1] - Gauss weights (interleaved   |
//|                     with zeros corresponding to extended Kronrod |
//|                     nodes).                                      |
//+------------------------------------------------------------------+
void CAlglib::GKQLegendreTbl(const int n,double &x[],double &wkronrod[],
                             double &wgauss[],double &eps)
  {
//--- initialization
   eps=0;
//--- function call
   CGaussKronrodQ::GKQLegendreTbl(n,x,wkronrod,wgauss,eps);
  }
//+------------------------------------------------------------------+
//| Integration of a smooth function F(x) on a finite interval [a,b].|
//| Fast-convergent algorithm based on a Gauss-Kronrod formula is    |
//| used. Result is calculated with accuracy close to the machine    |
//| precision.                                                       |
//| Algorithm works well only with smooth integrands. It may be used |
//| with continuous non-smooth integrands, but with less performance.|
//| It should never be used with integrands which have integrable    |
//| singularities at lower or upper limits - algorithm may crash.    |
//| Use AutoGKSingular in such cases.                                |
//| INPUT PARAMETERS:                                                |
//|     A, B    -   interval boundaries (A<B, A=B or A>B)            |
//| OUTPUT PARAMETERS                                                |
//|     State   -   structure which stores algorithm state           |
//| SEE ALSO                                                         |
//|     AutoGKSmoothW, AutoGKSingular, AutoGKResults.                |
//+------------------------------------------------------------------+
void CAlglib::AutoGKSmooth(const double a,const double b,
                           CAutoGKStateShell &state)
  {
   CAutoGK::AutoGKSmooth(a,b,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Integration of a smooth function F(x) on a finite interval [a,b].|
//| This subroutine is same as AutoGKSmooth(), but it guarantees that|
//| interval [a,b] is partitioned into subintervals which have width |
//| at most XWidth.                                                  |
//| Subroutine can be used when integrating nearly-constant function |
//| with narrow "bumps" (about XWidth wide). If "bumps" are too      |
//| narrow, AutoGKSmooth subroutine can overlook them.               |
//| INPUT PARAMETERS:                                                |
//|     A, B    -   interval boundaries (A<B, A=B or A>B)            |
//| OUTPUT PARAMETERS                                                |
//|     State   -   structure which stores algorithm state           |
//| SEE ALSO                                                         |
//|     AutoGKSmooth, AutoGKSingular, AutoGKResults.                 |
//+------------------------------------------------------------------+
void CAlglib::AutoGKSmoothW(const double a,const double b,
                            double xwidth,CAutoGKStateShell &state)
  {
   CAutoGK::AutoGKSmoothW(a,b,xwidth,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Integration on a finite interval [A,B].                          |
//| Integrand have integrable singularities at A/B.                  |
//| F(X) must diverge as "(x-A)^alpha" at A, as "(B-x)^beta" at B,   |
//| with known alpha/beta (alpha>-1, beta>-1). If alpha/beta are not |
//| known, estimates from below can be used (but these estimates     |
//| should be greater than -1 too).                                  |
//| One of alpha/beta variables (or even both alpha/beta) may be     |
//| equal to 0, which means than function F(x) is non-singular at    |
//| A/B. Anyway (singular at bounds or not), function F(x) is        |
//| supposed to be continuous on (A,B).                              |
//| Fast-convergent algorithm based on a Gauss-Kronrod formula is    |
//| used. Result is calculated with accuracy close to the machine    |
//| precision.                                                       |
//| INPUT PARAMETERS:                                                |
//|     A, B    -   interval boundaries (A<B, A=B or A>B)            |
//|     Alpha   -   power-law coefficient of the F(x) at A,          |
//|                 Alpha>-1                                         |
//|     Beta    -   power-law coefficient of the F(x) at B,          |
//|                 Beta>-1                                          |
//| OUTPUT PARAMETERS                                                |
//|     State   -   structure which stores algorithm state           |
//| SEE ALSO                                                         |
//|     AutoGKSmooth, AutoGKSmoothW, AutoGKResults.                  |
//+------------------------------------------------------------------+
void CAlglib::AutoGKSingular(const double a,const double b,const double alpha,
                             const double beta,CAutoGKStateShell &state)
  {
   CAutoGK::AutoGKSingular(a,b,alpha,beta,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function provides reverse communication interface           |
//| Reverse communication interface is not documented or recommended |
//| to use.                                                          |
//| See below for functions which provide better documented API      |
//+------------------------------------------------------------------+
bool CAlglib::AutoGKIteration(CAutoGKStateShell &state)
  {
   return(CAutoGK::AutoGKIteration(state.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This function is used to launcn iterations of ODE solver         |
//| It accepts following parameters:                                 |
//|     diff    -   callback which calculates dy/dx for given y and x|
//|     obj     -   optional object which is passed to diff; can be  |
//|                 NULL                                             |
//+------------------------------------------------------------------+
void CAlglib::AutoGKIntegrate(CAutoGKStateShell &state,
                              CIntegrator1_Func &func,
                              CObject &obj)
  {
//--- cycle
   while(CAlglib::AutoGKIteration(state))
     {
      //--- check
      if(state.GetNeedF())
        {
         func.Int_Func(state.GetX(),state.GetXMinusA(),state.GetBMinusX(),state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: unexpected error in 'autogksolve'");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| Adaptive integration results                                     |
//| Called after AutoGKIteration returned False.                     |
//| Input parameters:                                                |
//|     State   -   algorithm state (used by AutoGKIteration).       |
//| Output parameters:                                               |
//|     V       -   integral(f(x)dx,a,b)                             |
//|     Rep     -   optimization report (see AutoGKReport            |
//|                 description)                                     |
//+------------------------------------------------------------------+
void CAlglib::AutoGKResults(CAutoGKStateShell &state,double &v,
                            CAutoGKReportShell &rep)
  {
//--- initialization
   v=0;
//--- function call
   CAutoGK::AutoGKResults(state.GetInnerObj(),v,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function serializes data structure to string.               |
//| Important properties of s_out:                                   |
//|   * it contains alphanumeric characters, dots, underscores, minus|
//|     signs                                                        |
//|   * these symbols are grouped into words, which are separated by |
//|     spaces and Windows-style (CR+LF) newlines                    |
//|   * although  serializer  uses  spaces and CR+LF as separators,  |
//|     you can  replace any separator character by arbitrary        |
//|     combination of spaces, tabs, Windows or Unix newlines. It    |
//|     allows flexible reformatting  of the  string  in  case you   |
//|     want to include it into text or XML file. But you should not |
//|     insert separators into the middle of the "words" nor you     |
//|     should change case of letters.                               |
//|   * s_out can be freely moved between 32-bit and 64-bit systems, |
//|     little and big endian machines, and so on. You can serialize |
//|     structure on 32-bit machine and unserialize it on 64-bit one |
//|     (or vice versa), or serialize it on  SPARC  and  unserialize |
//|     on x86. You can also serialize it in C# version of ALGLIB and|
//|     unserialize in C++ one, and vice versa.                      |
//+------------------------------------------------------------------+
void CAlglib::IDWSerialize(CIDWModelShell &obj,string &s_out)
  {
//--- create a variable
   CSerializer s;
//--- serialization start
   s.Alloc_Start();
//--- function call
   CIDWInt::IDWAlloc(s,obj.GetInnerObj());
//--- serialization
   s.SStart_Str();
   CIDWInt::IDWSerialize(s,obj.GetInnerObj());
   s.Stop();
   s_out=s.Get_String();
  }
//+------------------------------------------------------------------+
//| This function unserializes data structure from string.           |
//+------------------------------------------------------------------+
void CAlglib::IDWUnserialize(string s_in,CIDWModelShell &obj)
  {
   CSerializer s;
   s.UStart_Str(s_in);
   CIDWInt::IDWUnserialize(s,obj.GetInnerObj());
   s.Stop();
  }
//+------------------------------------------------------------------+
//| This function creates buffer structure which can be used to      |
//| perform parallel IDW model evaluations (with one IDW model       |
//| instance being used from multiple threads, as long as different  |
//| threads use different instances of buffer).                      |
//| This buffer object can be used with IDWTsCalcBuf() function (here|
//| "ts" stands for "thread-safe", "buf" is a suffix which denotes   |
//| function which reuses previously allocated output space).        |
//| How to use it:                                                   |
//|   * create IDW model structure or load it from file              |
//|   * call IDWCreateCalcBuffer(), once per thread working with IDW |
//|     model (you should call this function only AFTER model        |
//|     initialization, see below for more information)              |
//|   * call IDWTsCalcBuf() from different threads, with each thread |
//|     working with its own copy of buffer object.                  |
//| INPUT PARAMETERS:                                                |
//|   S        -  IDW model                                          |
//| OUTPUT PARAMETERS:                                               |
//|   Buf      -  external buffer.                                   |
//| IMPORTANT: buffer object should be used only with IDW model      |
//|            object which was used to initialize buffer. Any       |
//|            attempt to use buffer with different object is        |
//|            dangerous - you may get memory violation error because|
//|            sizes of internal arrays do not fit to dimensions of  |
//|            the IDW structure.                                    |
//| IMPORTANT: you should call this function only for model which was|
//|            built with model builder (or unserialized from file). |
//|            Sizes of some internal structures are determined only |
//|            after model is built, so buffer object created before |
//|            model construction stage will be useless (and any     |
//|            attempt to use it will result in exception).          |
//+------------------------------------------------------------------+
void CAlglib::IDWCreateCalcBuffer(CIDWModelShell &s,CIDWCalcBuffer &buf)
  {
   CIDWInt::IDWCreateCalcBuffer(s.GetInnerObj(),buf);
  }
//+------------------------------------------------------------------+
//| This subroutine creates builder object used to generate IDW model|
//| from irregularly sampled (scattered) dataset. Multidimensional   |
//| scalar/vector-valued are supported.                              |
//| Builder object is used to fit model to data as follows:          |
//|   * builder object is created with idwbuildercreate() function   |
//|   * dataset is added with IDWBuilderSetPoints() function         |
//|   * one of the modern IDW algorithms is chosen with either:      |
//|      * IDWBuilderSetAlgoMSTAB() - Multilayer STABilized algorithm|
//|                                   (interpolation).               |
//| Alternatively, one of the textbook algorithms can be chosen (not |
//| recommended):                                                    |
//|   * IDWBuilderSetAlgoTextBookShepard()   -  textbook Shepard     |
//|                                             algorithm            |
//|   * IDWBuilderSetAlgoTextBookModShepard()-  textbook modified    |
//|                                             Shepard algorithm    |
//|   * finally, model construction is performed with IDWFit()       |
//|     function.                                                    |
//| INPUT PARAMETERS:                                                |
//|   NX       -  dimensionality of the argument, NX>=1              |
//|   NY       -  dimensionality of the function being modeled,      |
//|               NY>=1; NY=1 corresponds to classic scalar function,|
//|               NY>=1 corresponds to vector-valued function.       |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  builder object                                     |
//+------------------------------------------------------------------+
void CAlglib::IDWBuilderCreate(int nx,int ny,CIDWBuilder &state)
  {
   CIDWInt::IDWBuilderCreate(nx,ny,state);
  }
//+------------------------------------------------------------------+
//| This function changes number of layers used by IDW-MSTAB         |
//| algorithm.                                                       |
//| The more layers you have, the finer details can be reproduced    |
//| with IDW model. The less layers you have, the less memory and CPU|
//| time is consumed by the model.                                   |
//| Memory consumption grows linearly with layers count, running time|
//| grows sub-linearly.                                              |
//| The default number of layers is 16, which allows you to reproduce|
//| details at distance down to SRad/65536. You will rarely need to  |
//| change it.                                                       |
//| INPUT PARAMETERS:                                                |
//|   State    -  builder object                                     |
//|   NLayers  -  NLayers>=1, the number of layers used by the model.|
//+------------------------------------------------------------------+
void CAlglib::IDWBuilderSetNLayers(CIDWBuilder &state,int nlayers)
  {
   CIDWInt::IDWBuilderSetNLayers(state,nlayers);
  }
//+------------------------------------------------------------------+
//| This function adds dataset to the builder object.                |
//| This function overrides results of the previous calls, i.e.      |
//| multiple calls of this function will result in only the last set |
//| being added.                                                     |
//| INPUT PARAMETERS:                                                |
//|   State    -  builder object                                     |
//|   XY       -  points, array[N, NX+NY]. One row corresponds to one |
//|               point in the dataset. First NX elements are        |
//|               coordinates, next NY elements are function values. |
//|               Array may be larger than specified, in this case   |
//|               only leading [N,NX+NY] elements will be used.      |
//|   N        -  number of points in the dataset, N>=0.             |
//+------------------------------------------------------------------+
void CAlglib::IDWBuilderSetPoints(CIDWBuilder &state,CMatrixDouble &xy,int n)
  {
   CIDWInt::IDWBuilderSetPoints(state,xy,n);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::IDWBuilderSetPoints(CIDWBuilder &state,CMatrixDouble &xy)
  {
   int n=CAp::Rows(xy);
//--- function call
   CIDWInt::IDWBuilderSetPoints(state,xy,n);
  }
//+------------------------------------------------------------------+
//| This function sets IDW model construction algorithm to the       |
//| Multilayer Stabilized IDW method (IDW-MSTAB), a latest           |
//| incarnation of the inverse distance weighting interpolation which|
//| fixes shortcomings of the original and modified Shepard's        |
//| variants.                                                        |
//| The distinctive features of IDW-MSTAB are:                       |
//|   1) exact interpolation is pursued (as opposed to fitting and   |
//|      noise suppression)                                          |
//|   2) improved robustness when compared with that of other        |
//|      algorithms:                                                 |
//|      * MSTAB shows almost no strange fitting artifacts like      |
//|        ripples and sharp spikes (unlike N-dimensional splines    |
//|        and HRBFs)                                                |
//|      * MSTAB does not return function values far from the        |
//|        interval spanned by the dataset; say, if all your points  |
//|        have |f|<=1, you can be sure that model value won't       |
//|        deviate too much from [-1,+1]                             |
//|   3) good model construction time competing with that of HRBFs   |
//|      and bicubic splines                                         |
//|   4) ability to work with any number of dimensions, starting     |
//|      from NX=1                                                   |
//| The drawbacks of IDW-MSTAB (and all IDW algorithms in general)   |
//| are:                                                             |
//|   1) dependence of the model evaluation time on the search radius|
//|   2) bad extrapolation properties, models built by this method   |
//|      are usually conservative in their predictions               |
//| Thus, IDW-MSTAB is a good "default" option if you want to perform|
//| scattered multidimensional interpolation. Although it has its    |
//| drawbacks, it is easy to use and robust, which makes it a good   |
//| first step.                                                      |
//| INPUT PARAMETERS:                                                |
//|   State    -  builder object                                     |
//|   SRad     -  initial search radius, SRad>0 is required. A model |
//|               value is obtained by "smart" averaging of the      |
//|               dataset points within search radius.               |
//| NOTE 1: IDW interpolation can correctly handle ANY dataset,      |
//|         including datasets with non-distinct points. In case     |
//|         non-distinct points are found, an average value for this |
//|         point will be calculated.                                |
//| NOTE 2: the memory requirements for model storage are            |
//|         O(NPoints*NLayers). The model construction needs twice   |
//|         as much memory as model storage.                         |
//| NOTE 3: by default 16 IDW layers are built which is enough for   |
//|         most cases. You can change this parameter with           |
//|         IDWBuilderSetNLayers() method. Larger values may be      |
//|         necessary if you need to reproduce extrafine details at  |
//|         distances smaller than SRad/65536. Smaller value  may    |
//|         be necessary if you have to save memory and computing    |
//|         time, and ready to sacrifice some model quality.         |
//| ALGORITHM DESCRIPTION:                                           |
//|   ALGLIB implementation of IDW is somewhat similar to the        |
//|   modified Shepard's method (one with search radius R) but       |
//|   overcomes several of its drawbacks, namely:                    |
//|      1) a tendency to show stepwise behavior for uniform datasets|
//|      2) a tendency to show terrible interpolation properties for |
//|         highly nonuniform datasets which often arise in          |
//|         geospatial tasks (function values are densely sampled    |
//|         across multiple separated "tracks")                      |
//| IDW-MSTAB method performs several passes over dataset and builds |
//| a sequence of progressively refined IDW models (layers), which   |
//| starts from one with largest search radius SRad and continues    |
//| to smaller search radii until required number of layers is built.|
//| Highest layers reproduce global behavior of the target function  |
//| at larger distances whilst lower layers reproduce fine details at|
//| smaller distances.                                               |
//| Each layer is an IDW model built with following modifications:   |
//|   * weights go to zero when distance approach to the current     |
//|     search radius                                                |
//|   * an additional regularizing term is added to the distance:    |
//|     w=1/(d^2+lambda)                                             |
//|   * an additional fictional term with unit weight and zero       |
//|     function value is added in order to promote continuity       |
//|     properties at the isolated and boundary points               |
//| By default, 16 layers is built, which is enough for most cases.  |
//| You can change this parameter with IDWBuilderSetNLayers() method.|
//+------------------------------------------------------------------+
void CAlglib::IDWBuilderSetAlgoMSTAB(CIDWBuilder &state,double srad)
  {
   CIDWInt::IDWBuilderSetAlgoMSTAB(state,srad);
  }
//+------------------------------------------------------------------+
//| This function sets IDW model construction algorithm to the       |
//| textbook Shepard's algorithm with custom (user-specified) power  |
//| parameter.                                                       |
//| IMPORTANT: we do NOT recommend using textbook IDW algorithms     |
//|            because they have terrible interpolation properties.  |
//|            Use MSTAB in all cases.                               |
//| INPUT PARAMETERS:                                                |
//|   State    -  builder object                                     |
//|   P        -  power parameter, P>0; good value to start with is  |
//|               2.0                                                |
//| NOTE 1: IDW interpolation can correctly handle ANY dataset,      |
//|         including datasets with non-distinct points. In case     |
//|         non-distinct points are found, an average value for this |
//|         point will be calculated.                                |
//+------------------------------------------------------------------+
void CAlglib::IDWBuilderSetAlgoTextBookShepard(CIDWBuilder &state,double p)
  {
   CIDWInt::IDWBuilderSetAlgoTextBookShepard(state,p);
  }
//+------------------------------------------------------------------+
//| This function sets IDW model construction algorithm to the       |
//| 'textbook' modified Shepard's algorithm with user-specified      |
//| search radius.                                                   |
//| IMPORTANT: we do NOT recommend using textbook IDW algorithms     |
//|            because they have terrible interpolation properties.  |
//|            Use MSTAB in all cases.                               |
//| INPUT PARAMETERS:                                                |
//|   State    -  builder object                                     |
//|   R        -  search radius                                      |
//| NOTE 1: IDW interpolation can correctly handle ANY dataset,      |
//|         including datasets with non-distinct points. In case     |
//|         non-distinct points are found, an average value for this |
//|         point will be calculated.                                |
//+------------------------------------------------------------------+
void CAlglib::IDWBuilderSetAlgoTextBookModShepard(CIDWBuilder &state,double r)
  {
   CIDWInt::IDWBuilderSetAlgoTextBookModShepard(state,r);
  }
//+------------------------------------------------------------------+
//| This function sets prior term (model value at infinity) as       |
//| user-specified value.                                            |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline builder                                     |
//|   V        -  value for user-defined prior                       |
//| NOTE: for vector-valued models all components of the prior are   |
//|       set to same user-specified value                           |
//+------------------------------------------------------------------+
void CAlglib::IDWBuilderSetUserTerm(CIDWBuilder &state,double v)
  {
   CIDWInt::IDWBuilderSetUserTerm(state,v);
  }
//+------------------------------------------------------------------+
//| This function sets constant prior term (model value at infinity).|
//| Constant prior term is determined as mean value over dataset.    |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline builder                                     |
//+------------------------------------------------------------------+
void CAlglib::IDWBuilderSetConstTerm(CIDWBuilder &state)
  {
   CIDWInt::IDWBuilderSetConstTerm(state);
  }
//+------------------------------------------------------------------+
//| This function sets zero prior term (model value at infinity).    |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline builder                                     |
//+------------------------------------------------------------------+
void CAlglib::IDWBuilderSetZeroTerm(CIDWBuilder &state)
  {
   CIDWInt::IDWBuilderSetZeroTerm(state);
  }
//+------------------------------------------------------------------+
//| IDW interpolation: scalar target, 1-dimensional argument         |
//| NOTE: this function modifies internal temporaries of the IDW     |
//|       model, thus IT IS NOT THREAD-SAFE! If you want to perform  |
//|       parallel model evaluation from the multiple threads, use   |
//|       IDWTsCalcBuf() with per-thread buffer object.              |
//| INPUT PARAMETERS:                                                |
//|   S        -  IDW interpolant built with IDW builder             |
//|   X0       -  argument value                                     |
//| Result:                                                          |
//|   IDW interpolant S(X0)                                          |
//+------------------------------------------------------------------+
double CAlglib::IDWCalc1(CIDWModelShell &s,double x0)
  {
   return(CIDWInt::IDWCalc1(s.GetInnerObj(),x0));
  }
//+------------------------------------------------------------------+
//| IDW interpolation: scalar target, 2-dimensional argument         |
//| NOTE: this function modifies internal temporaries of the IDW     |
//|       model, thus IT IS NOT THREAD-SAFE! If you want to perform  |
//|       parallel model evaluation from the multiple threads, use   |
//|       IDWTsCalcBuf() with per- thread buffer object.             |
//| INPUT PARAMETERS:                                                |
//|   S        -  IDW interpolant built with IDW builder             |
//|   X0, X1   -  argument value                                     |
//| Result:                                                          |
//|   IDW interpolant S(X0,X1)                                       |
//+------------------------------------------------------------------+
double CAlglib::IDWCalc2(CIDWModelShell &s,double x0,double x1)
  {
   return(CIDWInt::IDWCalc2(s.GetInnerObj(),x0,x1));
  }
//+------------------------------------------------------------------+
//| IDW interpolation: scalar target, 3-dimensional argument         |
//| NOTE: this function modifies internal temporaries of the IDW     |
//|       model, thus IT IS NOT THREAD-SAFE! If you want to perform  |
//|       parallel model evaluation from the multiple threads, use   |
//|      IDWTsCalcBuf() with per- thread buffer object.              |
//| INPUT PARAMETERS:                                                |
//|   S        -  IDW interpolant built with IDW builder             |
//|   X0,X1,X2 -  argument value                                     |
//| Result:                                                          |
//|   IDW interpolant S(X0,X1,X2)                                    |
//+------------------------------------------------------------------+
double CAlglib::IDWCalc3(CIDWModelShell &s,double x0,double x1,double x2)
  {
   return(CIDWInt::IDWCalc3(s.GetInnerObj(),x0,x1,x2));
  }
//+------------------------------------------------------------------+
//| This function calculates values of the IDW model at the given    |
//| point.                                                           |
//| This is general function which can be used for arbitrary NX      |
//| (dimension of the space of arguments) and NY (dimension of the   |
//| function itself). However when you have NY=1 you may find more   |
//| convenient to use IDWCalc1(), IDWCalc2() or IDWCalc3().          |
//| NOTE: this function modifies internal temporaries of the IDW     |
//|       model, thus IT IS NOT THREAD-SAFE! If you want to perform  |
//|       parallel model evaluation from the multiple threads, use   |
//|       IDWTsCalcBuf() with per-thread buffer object.              |
//| INPUT PARAMETERS:                                                |
//|   S        -  IDW model                                          |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY]. Y is out-parameter and  |
//|               will be reallocated after call to this function. In|
//|               case you want to reuse previously allocated Y, you |
//|               may use IDWCalcBuf(), which reallocates Y only when|
//|               it is too small.                                   |
//+------------------------------------------------------------------+
void CAlglib::IDWCalc(CIDWModelShell &s,CRowDouble &x,CRowDouble &y)
  {
   CIDWInt::IDWCalc(s.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the IDW model at the given    |
//| point.                                                           |
//| Same as IDWCalc(), but does not reallocate Y when in is large    |
//| enough to store function values.                                 |
//| NOTE: this function modifies internal temporaries of the IDW     |
//|       model, thus IT IS NOT THREAD-SAFE! If you want to perform  |
//|       parallel model evaluation from the multiple threads, use   |
//|       IDWTsCalcBuf() with per-thread buffer object.              |
//| INPUT PARAMETERS:                                                |
//|   S        -  IDW model                                          |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//|   Y        -  possibly preallocated array                        |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY]. Y is not reallocated    |
//|               when it is larger than NY.                         |
//+------------------------------------------------------------------+
void CAlglib::IDWCalcBuf(CIDWModelShell &s,CRowDouble &x,CRowDouble &y)
  {
   CIDWInt::IDWCalcBuf(s.GetInnerObj(),x,y);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the IDW model at the given    |
//| point, using external buffer object (internal temporaries of IDW |
//| model are not modified).                                         |
//| This function allows to use same IDW model object in different   |
//| threads, assuming that different  threads use different instances|
//| of the buffer structure.                                         |
//| INPUT PARAMETERS:                                                |
//|   S        -  IDW model, may be shared between different threads |
//|   Buf      -  buffer object created for this particular instance |
//|               of IDW model with IDWCreateCalcBuffer().           |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//|   Y        -  possibly preallocated array                        |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY]. Y is not reallocated    |
//|               when it is larger than NY.                         |
//+------------------------------------------------------------------+
void CAlglib::IDWTsCalcBuf(CIDWModelShell &s,CIDWCalcBuffer &buf,
                           CRowDouble &x,CRowDouble &y)
  {
   CIDWInt::IDWTsCalcBuf(s.GetInnerObj(),buf,x,y);
  }
//+------------------------------------------------------------------+
//| This function fits IDW model to the dataset using current IDW    |
//| construction algorithm. A model being built and fitting report   |
//| are returned.                                                    |
//| INPUT PARAMETERS:                                                |
//|   State    -  builder object                                     |
//| OUTPUT PARAMETERS:                                               |
//|   Model    -  an IDW model built with current algorithm          |
//|   Rep      -  model fitting report, fields of this structure     |
//|               contain information about average fitting errors.  |
//| NOTE: although IDW-MSTAB algorithm is an interpolation method,   |
//|       i.e. it tries to fit the model exactly, it can handle      |
//|       datasets with non-distinct points which can not be fit     |
//|       exactly; in such cases least-squares fitting is performed. |
//+------------------------------------------------------------------+
void CAlglib::IDWFit(CIDWBuilder &state,CIDWModelShell &model,CIDWReport &rep)
  {
   CIDWInt::IDWFit(state,model.GetInnerObj(),rep);
  }
//+------------------------------------------------------------------+
//| Rational interpolation using barycentric formula                 |
//| F(t)=SUM(i=0,n-1,w[i]*f[i]/(t-x[i])) / SUM(i=0,n-1,w[i]/(t-x[i]))|
//| Input parameters:                                                |
//|     B   -   barycentric interpolant built with one of model      |
//|             building subroutines.                                |
//|     T   -   interpolation point                                  |
//| Result:                                                          |
//|     barycentric interpolant F(t)                                 |
//+------------------------------------------------------------------+
double CAlglib::BarycentricCalc(CBarycentricInterpolantShell &b,
                                const double t)
  {
   return(CRatInt::BarycentricCalc(b.GetInnerObj(),t));
  }
//+------------------------------------------------------------------+
//| Differentiation of barycentric interpolant: first derivative.    |
//| Algorithm used in this subroutine is very robust and should not  |
//| fail until provided with values too close to MaxRealNumber       |
//| (usually  MaxRealNumber/N or greater will overflow).             |
//| INPUT PARAMETERS:                                                |
//|     B   -   barycentric interpolant built with one of model      |
//|             building subroutines.                                |
//|     T   -   interpolation point                                  |
//| OUTPUT PARAMETERS:                                               |
//|     F   -   barycentric interpolant at T                         |
//|     DF  -   first derivative                                     |
//+------------------------------------------------------------------+
void CAlglib::BarycentricDiff1(CBarycentricInterpolantShell &b,
                               const double t,double &f,double &df)
  {
//--- initialization
   f=0;
   df=0;
//--- function call
   CRatInt::BarycentricDiff1(b.GetInnerObj(),t,f,df);
  }
//+------------------------------------------------------------------+
//| Differentiation of barycentric interpolant: first/second         |
//| derivatives.                                                     |
//| INPUT PARAMETERS:                                                |
//|     B   -   barycentric interpolant built with one of model      |
//|             building subroutines.                                |
//|     T   -   interpolation point                                  |
//| OUTPUT PARAMETERS:                                               |
//|     F   -   barycentric interpolant at T                         |
//|     DF  -   first derivative                                     |
//|     D2F -   second derivative                                    |
//| NOTE: this algorithm may fail due to overflow/underflor if used  |
//| on data whose values are close to MaxRealNumber or MinRealNumber.|
//| Use more robust BarycentricDiff1() subroutine in such cases.     |
//+------------------------------------------------------------------+
void CAlglib::BarycentricDiff2(CBarycentricInterpolantShell &b,
                               const double t,double &f,double &df,
                               double &d2f)
  {
//--- initialization
   f=0;
   df=0;
   d2f=0;
//--- function call
   CRatInt::BarycentricDiff2(b.GetInnerObj(),t,f,df,d2f);
  }
//+------------------------------------------------------------------+
//| This subroutine performs linear transformation of the argument.  |
//| INPUT PARAMETERS:                                                |
//|     B       -   rational interpolant in barycentric form         |
//|     CA, CB  -   transformation coefficients: x = CA*t + CB       |
//| OUTPUT PARAMETERS:                                               |
//|     B       -   transformed interpolant with X replaced by T     |
//+------------------------------------------------------------------+
void CAlglib::BarycentricLinTransX(CBarycentricInterpolantShell &b,
                                   const double ca,const double cb)
  {
   CRatInt::BarycentricLinTransX(b.GetInnerObj(),ca,cb);
  }
//+------------------------------------------------------------------+
//| This subroutine performs linear transformation of the barycentric|
//| interpolant.                                                     |
//| INPUT PARAMETERS:                                                |
//|     B       -   rational interpolant in barycentric form         |
//|     CA, CB  -   transformation coefficients: B2(x) = CA*B(x) + CB|
//| OUTPUT PARAMETERS:                                               |
//|     B       -   transformed interpolant                          |
//+------------------------------------------------------------------+
void CAlglib::BarycentricLinTransY(CBarycentricInterpolantShell &b,
                                   const double ca,const double cb)
  {
   CRatInt::BarycentricLinTransY(b.GetInnerObj(),ca,cb);
  }
//+------------------------------------------------------------------+
//| Extracts X/Y/W arrays from rational interpolant                  |
//| INPUT PARAMETERS:                                                |
//|     B   -   barycentric interpolant                              |
//| OUTPUT PARAMETERS:                                               |
//|     N   -   nodes count, N>0                                     |
//|     X   -   interpolation nodes, array[0..N-1]                   |
//|     F   -   function values, array[0..N-1]                       |
//|     W   -   barycentric weights, array[0..N-1]                   |
//+------------------------------------------------------------------+
void CAlglib::BarycentricUnpack(CBarycentricInterpolantShell &b,
                                int &n,double &x[],double &y[],
                                double &w[])
  {
//--- initialization
   n=0;
//--- function call
   CRatInt::BarycentricUnpack(b.GetInnerObj(),n,x,y,w);
  }
//+------------------------------------------------------------------+
//| Rational interpolant from X/Y/W arrays                           |
//| F(t)=SUM(i=0,n-1,w[i]*f[i]/(t-x[i])) / SUM(i=0,n-1,w[i]/(t-x[i]))|
//| INPUT PARAMETERS:                                                |
//|     X   -   interpolation nodes, array[0..N-1]                   |
//|     F   -   function values, array[0..N-1]                       |
//|     W   -   barycentric weights, array[0..N-1]                   |
//|     N   -   nodes count, N>0                                     |
//| OUTPUT PARAMETERS:                                               |
//|     B   -   barycentric interpolant built from (X, Y, W)         |
//+------------------------------------------------------------------+
void CAlglib::BarycentricBuildXYW(double &x[],double &y[],double &w[],
                                  const int n,CBarycentricInterpolantShell &b)
  {
   CRatInt::BarycentricBuildXYW(x,y,w,n,b.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Rational interpolant without poles                               |
//| The subroutine constructs the rational interpolating function    |
//| without real poles (see 'Barycentric rational interpolation with |
//| no poles and high rates of approximation', Michael S. Floater.   |
//| and Kai Hormann, for more information on this subject).          |
//| Input parameters:                                                |
//|     X   -   interpolation nodes, array[0..N-1].                  |
//|     Y   -   function values, array[0..N-1].                      |
//|     N   -   number of nodes, N>0.                                |
//|     D   -   order of the interpolation scheme, 0 <= D <= N-1.    |
//|             D<0 will cause an error.                             |
//|             D>=N it will be replaced with D=N-1.                 |
//|             if you don't know what D to choose, use small value  |
//|             about 3-5.                                           |
//| Output parameters:                                               |
//|     B   -   barycentric interpolant.                             |
//| Note:                                                            |
//|     this algorithm always succeeds and calculates the weights    |
//|     with close to machine precision.                             |
//+------------------------------------------------------------------+
void CAlglib::BarycentricBuildFloaterHormann(double &x[],double &y[],
                                             const int n,const int d,
                                             CBarycentricInterpolantShell &b)
  {
   CRatInt::BarycentricBuildFloaterHormann(x,y,n,d,b.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Conversion from barycentric representation to Chebyshev basis.   |
//| This function has O(N^2) complexity.                             |
//| INPUT PARAMETERS:                                                |
//|     P   -   polynomial in barycentric form                       |
//|     A,B -   base interval for Chebyshev polynomials (see below)  |
//|             A<>B                                                 |
//| OUTPUT PARAMETERS                                                |
//|     T   -   coefficients of Chebyshev representation;            |
//|             P(x) = sum { T[i]*Ti(2*(x-A)/(B-A)-1), i=0..N-1 },   |
//|             where Ti - I-th Chebyshev polynomial.                |
//| NOTES:                                                           |
//|     barycentric interpolant passed as P may be either polynomial |
//|     obtained from polynomial interpolation/ fitting or rational  |
//|     function which is NOT polynomial. We can't distinguish       |
//|     between these two cases, and this algorithm just tries to    |
//|     work assuming that P IS a polynomial. If not, algorithm will |
//|     return results, but they won't have any meaning.             |
//+------------------------------------------------------------------+
void CAlglib::PolynomialBar2Cheb(CBarycentricInterpolantShell &p,
                                 const double a,const double b,
                                 double &t[])
  {
   CPolInt::PolynomialBar2Cheb(p.GetInnerObj(),a,b,t);
  }
//+------------------------------------------------------------------+
//| Conversion from Chebyshev basis to barycentric representation.   |
//| This function has O(N^2) complexity.                             |
//| INPUT PARAMETERS:                                                |
//|     T   -   coefficients of Chebyshev representation;            |
//|             P(x) = sum { T[i]*Ti(2*(x-A)/(B-A)-1), i=0..N },     |
//|             where Ti - I-th Chebyshev polynomial.                |
//|     N   -   number of coefficients:                              |
//|             * if given, only leading N elements of T are used    |
//|             * if not given, automatically determined from size   |
//|               of T                                               |
//|     A,B -   base interval for Chebyshev polynomials (see above)  |
//|             A<B                                                  |
//| OUTPUT PARAMETERS                                                |
//|     P   -   polynomial in barycentric form                       |
//+------------------------------------------------------------------+
void CAlglib::PolynomialCheb2Bar(double &t[],const int n,const double a,
                                 const double b,
                                 CBarycentricInterpolantShell &p)
  {
   CPolInt::PolynomialCheb2Bar(t,n,a,b,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Conversion from Chebyshev basis to barycentric representation.   |
//| This function has O(N^2) complexity.                             |
//| INPUT PARAMETERS:                                                |
//|     T   -   coefficients of Chebyshev representation;            |
//|             P(x) = sum { T[i]*Ti(2*(x-A)/(B-A)-1), i=0..N },     |
//|             where Ti - I-th Chebyshev polynomial.                |
//|     N   -   number of coefficients:                              |
//|             * if given, only leading N elements of T are used    |
//|             * if not given, automatically determined from size   |
//|               of T                                               |
//|     A,B -   base interval for Chebyshev polynomials (see above)  |
//|             A<B                                                  |
//| OUTPUT PARAMETERS                                                |
//|     P   -   polynomial in barycentric form                       |
//+------------------------------------------------------------------+
void CAlglib::PolynomialCheb2Bar(double &t[],const double a,
                                 const double b,
                                 CBarycentricInterpolantShell &p)
  {
//--- initialization
   int n=CAp::Len(t);
//--- function call
   CPolInt::PolynomialCheb2Bar(t,n,a,b,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Conversion from barycentric representation to power basis.       |
//| This function has O(N^2) complexity.                             |
//| INPUT PARAMETERS:                                                |
//|     P   -   polynomial in barycentric form                       |
//|     C   -   offset (see below); 0.0 is used as default value.    |
//|     S   -   scale (see below); 1.0 is used as default value.     |
//|             S<>0.                                                |
//| OUTPUT PARAMETERS                                                |
//|     A   -   coefficients,                                        |
//|             P(x) = sum { A[i]*((X-C)/S)^i, i=0..N-1 }            |
//|     N   -   number of coefficients (polynomial degree plus 1)    |
//| NOTES:                                                           |
//| 1.  this function accepts offset and scale, which can be set to  |
//|     improve numerical properties of polynomial. For example, if  |
//|     P was obtained as result of interpolation on [-1,+1], you can|
//|     set C=0 and S=1 and represent P as sum of 1, x, x^2, x^3 and |
//|     so on. In most cases you it is exactly what you need.        |
//|     However, if your interpolation model was built on [999,1001],|
//|     you will see significant growth of numerical errors when     |
//|     using {1, x, x^2, x^3} as basis. Representing P as sum of 1, |
//|     (x-1000), (x-1000)^2, (x-1000)^3 will be better option. Such |
//|     representation can be  obtained  by  using 1000.0 as offset  |
//|     C and 1.0 as scale S.                                        |
//| 2.  power basis is ill-conditioned and tricks described above    |
//|     can't solve this problem completely. This function  will     |
//|     return coefficients in any case, but for N>8 they will become|
//|     unreliable. However, N's less than 5 are pretty safe.        |
//| 3.  barycentric interpolant passed as P may be either polynomial |
//|     obtained from polynomial interpolation/ fitting or rational  |
//|     function which is NOT polynomial. We can't distinguish       |
//|     between these two cases, and this algorithm just tries to    |
//|     work assuming that P IS a polynomial. If not, algorithm will |
//|     return results, but they won't have any meaning.             |
//+------------------------------------------------------------------+
void CAlglib::PolynomialBar2Pow(CBarycentricInterpolantShell &p,
                                const double c,const double s,
                                double &a[])
  {
   CPolInt::PolynomialBar2Pow(p.GetInnerObj(),c,s,a);
  }
//+------------------------------------------------------------------+
//| Conversion from barycentric representation to power basis.       |
//| This function has O(N^2) complexity.                             |
//| INPUT PARAMETERS:                                                |
//|     P   -   polynomial in barycentric form                       |
//|     C   -   offset (see below); 0.0 is used as default value.    |
//|     S   -   scale (see below); 1.0 is used as default value.     |
//|             S<>0.                                                |
//| OUTPUT PARAMETERS                                                |
//|     A   -   coefficients,                                        |
//|             P(x) = sum { A[i]*((X-C)/S)^i, i=0..N-1 }            |
//|     N   -   number of coefficients (polynomial degree plus 1)    |
//| NOTES:                                                           |
//| 1.  this function accepts offset and scale, which can be set to  |
//|     improve numerical properties of polynomial. For example, if  |
//|     P was obtained as result of interpolation on [-1,+1], you can|
//|     set C=0 and S=1 and represent P as sum of 1, x, x^2, x^3 and |
//|     so on. In most cases you it is exactly what you need.        |
//|     However, if your interpolation model was built on [999,1001],|
//|     you will see significant growth of numerical errors when     |
//|     using {1, x, x^2, x^3} as basis. Representing P as sum of 1, |
//|     (x-1000), (x-1000)^2, (x-1000)^3 will be better option. Such |
//|     representation can be  obtained  by  using 1000.0 as offset  |
//|     C and 1.0 as scale S.                                        |
//| 2.  power basis is ill-conditioned and tricks described above    |
//|     can't solve this problem completely. This function  will     |
//|     return coefficients in any case, but for N>8 they will become|
//|     unreliable. However, N's less than 5 are pretty safe.        |
//| 3.  barycentric interpolant passed as P may be either polynomial |
//|     obtained from polynomial interpolation/ fitting or rational  |
//|     function which is NOT polynomial. We can't distinguish       |
//|     between these two cases, and this algorithm just tries to    |
//|     work assuming that P IS a polynomial. If not, algorithm will |
//|     return results, but they won't have any meaning.             |
//+------------------------------------------------------------------+
void CAlglib::PolynomialBar2Pow(CBarycentricInterpolantShell &p,
                                double &a[])
  {
//--- initialization
   double c=0;
   double s=1;
//--- function call
   CPolInt::PolynomialBar2Pow(p.GetInnerObj(),c,s,a);
  }
//+------------------------------------------------------------------+
//| Conversion from power basis to barycentric representation.       |
//| This function has O(N^2) complexity.                             |
//| INPUT PARAMETERS:                                                |
//|     A   -   coefficients, P(x)=sum { A[i]*((X-C)/S)^i, i=0..N-1 }|
//|     N   -   number of coefficients (polynomial degree plus 1)    |
//|             * if given, only leading N elements of A are used    |
//|             * if not given, automatically determined from size   |
//|               of A                                               |
//|     C   -   offset (see below); 0.0 is used as default value.    |
//|     S   -   scale (see below); 1.0 is used as default value.     |
//|             S<>0.                                                |
//| OUTPUT PARAMETERS                                                |
//|     P   -   polynomial in barycentric form                       |
//| NOTES:                                                           |
//| 1.  this function accepts offset and scale, which can be set to  |
//|     improve numerical properties of polynomial. For example, if  |
//|     you interpolate on [-1,+1], you can set C=0 and S=1 and      |
//|     convert from sum of 1, x, x^2, x^3 and so on. In most cases  |
//|     you it is exactly what you need.                             |
//|     However, if your interpolation model was built on [999,1001],|
//|     you will see significant growth of numerical errors when     |
//|     using {1, x, x^2, x^3} as input basis. Converting from sum   |
//|     of 1, (x-1000), (x-1000)^2, (x-1000)^3 will be better option |
//|     (you have to specify 1000.0 as offset C and 1.0 as scale S). |
//| 2.  power basis is ill-conditioned and tricks described above    |
//|     can't solve this problem completely. This function will      |
//|     return barycentric model in any case, but for N>8 accuracy   |
//|     well degrade. However, N's less than 5 are pretty safe.      |
//+------------------------------------------------------------------+
void CAlglib::PolynomialPow2Bar(double &a[],const int n,const double c,
                                const double s,CBarycentricInterpolantShell &p)
  {
   CPolInt::PolynomialPow2Bar(a,n,c,s,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Conversion from power basis to barycentric representation.       |
//| This function has O(N^2) complexity.                             |
//| INPUT PARAMETERS:                                                |
//|     A   -   coefficients, P(x)=sum { A[i]*((X-C)/S)^i, i=0..N-1 }|
//|     N   -   number of coefficients (polynomial degree plus 1)    |
//|             * if given, only leading N elements of A are used    |
//|             * if not given, automatically determined from size   |
//|               of A                                               |
//|     C   -   offset (see below); 0.0 is used as default value.    |
//|     S   -   scale (see below); 1.0 is used as default value.     |
//|             S<>0.                                                |
//| OUTPUT PARAMETERS                                                |
//|     P   -   polynomial in barycentric form                       |
//| NOTES:                                                           |
//| 1.  this function accepts offset and scale, which can be set to  |
//|     improve numerical properties of polynomial. For example, if  |
//|     you interpolate on [-1,+1], you can set C=0 and S=1 and      |
//|     convert from sum of 1, x, x^2, x^3 and so on. In most cases  |
//|     you it is exactly what you need.                             |
//|     However, if your interpolation model was built on [999,1001],|
//|     you will see significant growth of numerical errors when     |
//|     using {1, x, x^2, x^3} as input basis. Converting from sum   |
//|     of 1, (x-1000), (x-1000)^2, (x-1000)^3 will be better option |
//|     (you have to specify 1000.0 as offset C and 1.0 as scale S). |
//| 2.  power basis is ill-conditioned and tricks described above    |
//|     can't solve this problem completely. This function will      |
//|     return barycentric model in any case, but for N>8 accuracy   |
//|     well degrade. However, N's less than 5 are pretty safe.      |
//+------------------------------------------------------------------+
void CAlglib::PolynomialPow2Bar(double &a[],CBarycentricInterpolantShell &p)
  {
//--- initialization
   int    n=CAp::Len(a);
   double c=0;
   double s=1;
//--- function call
   CPolInt::PolynomialPow2Bar(a,n,c,s,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Lagrange intepolant: generation of the model on the general grid.|
//| This function has O(N^2) complexity.                             |
//| INPUT PARAMETERS:                                                |
//|     X   -   abscissas, array[0..N-1]                             |
//|     Y   -   function values, array[0..N-1]                       |
//|     N   -   number of points, N>=1                               |
//| OUTPUT PARAMETERS                                                |
//|     P   -   barycentric model which represents Lagrange          |
//|             interpolant (see ratint unit info and                |
//|             BarycentricCalc() description for more information). |
//+------------------------------------------------------------------+
void CAlglib::PolynomialBuild(double &x[],double &y[],const int n,
                              CBarycentricInterpolantShell &p)
  {
   CPolInt::PolynomialBuild(x,y,n,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Lagrange intepolant: generation of the model on the general grid.|
//| This function has O(N^2) complexity.                             |
//| INPUT PARAMETERS:                                                |
//|     X   -   abscissas, array[0..N-1]                             |
//|     Y   -   function values, array[0..N-1]                       |
//|     N   -   number of points, N>=1                               |
//| OUTPUT PARAMETERS                                                |
//|     P   -   barycentric model which represents Lagrange          |
//|             interpolant (see ratint unit info and                |
//|             BarycentricCalc() description for more information). |
//+------------------------------------------------------------------+
void CAlglib::PolynomialBuild(double &x[],double &y[],
                              CBarycentricInterpolantShell &p)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'polynomialbuild': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CPolInt::PolynomialBuild(x,y,n,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Lagrange intepolant: generation of the model on equidistant grid.|
//| This function has O(N) complexity.                               |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     Y   -   function values at the nodes, array[0..N-1]          |
//|     N   -   number of points, N>=1                               |
//|             for N=1 a constant model is constructed.             |
//| OUTPUT PARAMETERS                                                |
//|     P   -   barycentric model which represents Lagrange          |
//|             interpolant (see ratint unit info and                |
//|             BarycentricCalc() description for more information). |
//+------------------------------------------------------------------+
void CAlglib::PolynomialBuildEqDist(const double a,const double b,
                                    double &y[],const int n,
                                    CBarycentricInterpolantShell &p)
  {
   CPolInt::PolynomialBuildEqDist(a,b,y,n,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Lagrange intepolant: generation of the model on equidistant grid.|
//| This function has O(N) complexity.                               |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     Y   -   function values at the nodes, array[0..N-1]          |
//|     N   -   number of points, N>=1                               |
//|             for N=1 a constant model is constructed.             |
//| OUTPUT PARAMETERS                                                |
//|     P   -   barycentric model which represents Lagrange          |
//|             interpolant (see ratint unit info and                |
//|             BarycentricCalc() description for more information). |
//+------------------------------------------------------------------+
void CAlglib::PolynomialBuildEqDist(const double a,const double b,
                                    double &y[],
                                    CBarycentricInterpolantShell &p)
  {
//--- initialization
   int n=CAp::Len(y);
//--- function call
   CPolInt::PolynomialBuildEqDist(a,b,y,n,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Lagrange intepolant on Chebyshev grid (first kind).              |
//| This function has O(N) complexity.                               |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     Y   -   function values at the nodes, array[0..N-1],         |
//|             Y[I] = Y(0.5*(B+A) + 0.5*(B-A)*Cos(PI*(2*i+1)/(2*n)))|
//|     N   -   number of points, N>=1                               |
//|             for N=1 a constant model is constructed.             |
//| OUTPUT PARAMETERS                                                |
//|     P   -   barycentric model which represents Lagrange          |
//|             interpolant (see ratint unit info and                |
//|             BarycentricCalc() description for more information). |
//+------------------------------------------------------------------+
void CAlglib::PolynomialBuildCheb1(const double a,const double b,
                                   double &y[],const int n,
                                   CBarycentricInterpolantShell &p)
  {
   CPolInt::PolynomialBuildCheb1(a,b,y,n,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Lagrange intepolant on Chebyshev grid (first kind).              |
//| This function has O(N) complexity.                               |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     Y   -   function values at the nodes, array[0..N-1],         |
//|             Y[I] = Y(0.5*(B+A) + 0.5*(B-A)*Cos(PI*(2*i+1)/(2*n)))|
//|     N   -   number of points, N>=1                               |
//|             for N=1 a constant model is constructed.             |
//| OUTPUT PARAMETERS                                                |
//|     P   -   barycentric model which represents Lagrange          |
//|             interpolant (see ratint unit info and                |
//|             BarycentricCalc() description for more information). |
//+------------------------------------------------------------------+
void CAlglib::PolynomialBuildCheb1(const double a,const double b,
                                   double &y[],
                                   CBarycentricInterpolantShell &p)
  {
//--- initialization
   int n=CAp::Len(y);
//--- function call
   CPolInt::PolynomialBuildCheb1(a,b,y,n,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Lagrange intepolant on Chebyshev grid (second kind).             |
//| This function has O(N) complexity.                               |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     Y   -   function values at the nodes, array[0..N-1],         |
//|             Y[I] = Y(0.5*(B+A) + 0.5*(B-A)*Cos(PI*i/(n-1)))      |
//|     N   -   number of points, N>=1                               |
//|             for N=1 a constant model is constructed.             |
//| OUTPUT PARAMETERS                                                |
//|     P   -   barycentric model which represents Lagrange          |
//|             interpolant (see ratint unit info and                |
//|             BarycentricCalc() description for more information). |
//+------------------------------------------------------------------+
void CAlglib::PolynomialBuildCheb2(const double a,const double b,
                                   double &y[],const int n,
                                   CBarycentricInterpolantShell &p)
  {
   CPolInt::PolynomialBuildCheb2(a,b,y,n,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Lagrange intepolant on Chebyshev grid (second kind).             |
//| This function has O(N) complexity.                               |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     Y   -   function values at the nodes, array[0..N-1],         |
//|             Y[I] = Y(0.5*(B+A) + 0.5*(B-A)*Cos(PI*i/(n-1)))      |
//|     N   -   number of points, N>=1                               |
//|             for N=1 a constant model is constructed.             |
//| OUTPUT PARAMETERS                                                |
//|     P   -   barycentric model which represents Lagrange          |
//|             interpolant (see ratint unit info and                |
//|             BarycentricCalc() description for more information). |
//+------------------------------------------------------------------+
void CAlglib::PolynomialBuildCheb2(const double a,const double b,
                                   double &y[],
                                   CBarycentricInterpolantShell &p)
  {
//--- initialization
   int n=CAp::Len(y);
//--- function call
   CPolInt::PolynomialBuildCheb2(a,b,y,n,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Fast equidistant polynomial interpolation function with O(N)     |
//| complexity                                                       |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     F   -   function values, array[0..N-1]                       |
//|     N   -   number of points on equidistant grid, N>=1           |
//|             for N=1 a constant model is constructed.             |
//|     T   -   position where P(x) is calculated                    |
//| RESULT                                                           |
//|     value of the Lagrange interpolant at T                       |
//| IMPORTANT                                                        |
//|     this function provides fast interface which is not           |
//|     overflow-safe nor it is very precise.                        |
//|     the best option is to use PolynomialBuildEqDist() or         |
//|     BarycentricCalc() subroutines unless you are pretty sure that|
//|     your data will not result in overflow.                       |
//+------------------------------------------------------------------+
double CAlglib::PolynomialCalcEqDist(const double a,const double b,
                                     double &f[],const int n,
                                     const double t)
  {
   return(CPolInt::PolynomialCalcEqDist(a,b,f,n,t));
  }
//+------------------------------------------------------------------+
//| Fast equidistant polynomial interpolation function with O(N)     |
//| complexity                                                       |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     F   -   function values, array[0..N-1]                       |
//|     N   -   number of points on equidistant grid, N>=1           |
//|             for N=1 a constant model is constructed.             |
//|     T   -   position where P(x) is calculated                    |
//| RESULT                                                           |
//|     value of the Lagrange interpolant at T                       |
//| IMPORTANT                                                        |
//|     this function provides fast interface which is not           |
//|     overflow-safe nor it is very precise.                        |
//|     the best option is to use PolynomialBuildEqDist() or         |
//|     BarycentricCalc() subroutines unless you are pretty sure that|
//|     your data will not result in overflow.                       |
//+------------------------------------------------------------------+
double CAlglib::PolynomialCalcEqDist(const double a,const double b,
                                     double &f[],const double t)
  {
//--- initialization
   int n=CAp::Len(f);
//--- return result
   return(CPolInt::PolynomialCalcEqDist(a,b,f,n,t));
  }
//+------------------------------------------------------------------+
//| Fast polynomial interpolation function on Chebyshev points (first|
//| kind) with O(N) complexity.                                      |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     F   -   function values, array[0..N-1]                       |
//|     N   -   number of points on Chebyshev grid (first kind),     |
//|             X[i] = 0.5*(B+A) + 0.5*(B-A)*Cos(PI*(2*i+1)/(2*n))   |
//|             for N=1 a constant model is constructed.             |
//|     T   -   position where P(x) is calculated                    |
//| RESULT                                                           |
//|     value of the Lagrange interpolant at T                       |
//| IMPORTANT                                                        |
//|     this function provides fast interface which is not           |
//|     overflow-safe nor it is very precise                         |
//|     the best option is to use  PolIntBuildCheb1() or             |
//|     BarycentricCalc() subroutines unless you are pretty sure that|
//|     your data will not result in overflow.                       |
//+------------------------------------------------------------------+
double CAlglib::PolynomialCalcCheb1(const double a,const double b,
                                    double &f[],const int n,
                                    const double t)
  {
   return(CPolInt::PolynomialCalcCheb1(a,b,f,n,t));
  }
//+------------------------------------------------------------------+
//| Fast polynomial interpolation function on Chebyshev points (first|
//| kind) with O(N) complexity.                                      |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     F   -   function values, array[0..N-1]                       |
//|     N   -   number of points on Chebyshev grid (first kind),     |
//|             X[i] = 0.5*(B+A) + 0.5*(B-A)*Cos(PI*(2*i+1)/(2*n))   |
//|             for N=1 a constant model is constructed.             |
//|     T   -   position where P(x) is calculated                    |
//| RESULT                                                           |
//|     value of the Lagrange interpolant at T                       |
//| IMPORTANT                                                        |
//|     this function provides fast interface which is not           |
//|     overflow-safe nor it is very precise                         |
//|     the best option is to use  PolIntBuildCheb1() or             |
//|     BarycentricCalc() subroutines unless you are pretty sure that|
//|     your data will not result in overflow.                       |
//+------------------------------------------------------------------+
double CAlglib::PolynomialCalcCheb1(const double a,const double b,
                                    double &f[],const double t)
  {
//--- initialization
   int n=CAp::Len(f);
//--- return result
   return(CPolInt::PolynomialCalcCheb1(a,b,f,n,t));
  }
//+------------------------------------------------------------------+
//| Fast polynomial interpolation function on Chebyshev points       |
//| (second kind) with O(N) complexity.                              |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     F   -   function values, array[0..N-1]                       |
//|     N   -   number of points on Chebyshev grid (second kind),    |
//|             X[i] = 0.5*(B+A) + 0.5*(B-A)*Cos(PI*i/(n-1))         |
//|             for N=1 a constant model is constructed.             |
//|     T   -   position where P(x) is calculated                    |
//| RESULT                                                           |
//|     value of the Lagrange interpolant at T                       |
//| IMPORTANT                                                        |
//|     this function provides fast interface which is not           |
//|     overflow-safe nor it is very precise.                        |
//|     the best option is to use PolIntBuildCheb2() or              |
//|     BarycentricCalc() subroutines unless you are pretty sure that|
//|     your data will not result in overflow.                       |
//+------------------------------------------------------------------+
double CAlglib::PolynomialCalcCheb2(const double a,const double b,
                                    double &f[],const int n,
                                    const double t)
  {
   return(CPolInt::PolynomialCalcCheb2(a,b,f,n,t));
  }
//+------------------------------------------------------------------+
//| Fast polynomial interpolation function on Chebyshev points       |
//| (second kind) with O(N) complexity.                              |
//| INPUT PARAMETERS:                                                |
//|     A   -   left boundary of [A,B]                               |
//|     B   -   right boundary of [A,B]                              |
//|     F   -   function values, array[0..N-1]                       |
//|     N   -   number of points on Chebyshev grid (second kind),    |
//|             X[i] = 0.5*(B+A) + 0.5*(B-A)*Cos(PI*i/(n-1))         |
//|             for N=1 a constant model is constructed.             |
//|     T   -   position where P(x) is calculated                    |
//| RESULT                                                           |
//|     value of the Lagrange interpolant at T                       |
//| IMPORTANT                                                        |
//|     this function provides fast interface which is not           |
//|     overflow-safe nor it is very precise.                        |
//|     the best option is to use PolIntBuildCheb2() or              |
//|     BarycentricCalc() subroutines unless you are pretty sure that|
//|     your data will not result in overflow.                       |
//+------------------------------------------------------------------+
double CAlglib::PolynomialCalcCheb2(const double a,const double b,
                                    double &f[],const double t)
  {
//--- initialization
   int n=CAp::Len(f);
//--- return result
   return(CPolInt::PolynomialCalcCheb2(a,b,f,n,t));
  }
//+------------------------------------------------------------------+
//| This subroutine builds linear spline interpolant                 |
//| INPUT PARAMETERS:                                                |
//|     X   -   spline nodes, array[0..N-1]                          |
//|     Y   -   function values, array[0..N-1]                       |
//|     N   -   points count (optional):                             |
//|             * N>=2                                               |
//|             * if given, only first N points are used to build    |
//|               spline                                             |
//|             * if not given, automatically detected from X/Y      |
//|               sizes (len(X) must be equal to len(Y))             |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   spline interpolant                                   |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildLinear(double &x[],double &y[],const int n,
                                  CSpline1DInterpolantShell &c)
  {
   CSpline1D::Spline1DBuildLinear(x,y,n,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine builds linear spline interpolant                 |
//| INPUT PARAMETERS:                                                |
//|     X   -   spline nodes, array[0..N-1]                          |
//|     Y   -   function values, array[0..N-1]                       |
//|     N   -   points count (optional):                             |
//|             * N>=2                                               |
//|             * if given, only first N points are used to build    |
//|               spline                                             |
//|             * if not given, automatically detected from X/Y      |
//|               sizes (len(X) must be equal to len(Y))             |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   spline interpolant                                   |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildLinear(double &x[],double &y[],
                                  CSpline1DInterpolantShell &c)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dbuildlinear': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CSpline1D::Spline1DBuildLinear(x,y,n,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine builds cubic spline interpolant.                 |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes, array[0..N-1].                 |
//|     Y           -   function values, array[0..N-1].              |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points are used to  |
//|                       build spline                               |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//| OUTPUT PARAMETERS:                                               |
//|     C           -   spline interpolant                           |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|             Y[first]).                                           |
//|     *  0, which  corresponds to the parabolically terminated     |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildCubic(double &x[],double &y[],const int n,
                                 const int boundltype,const double boundl,
                                 const int boundrtype,const double boundr,
                                 CSpline1DInterpolantShell &c)
  {
   CSpline1D::Spline1DBuildCubic(x,y,n,boundltype,boundl,boundrtype,boundr,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine builds cubic spline interpolant.                 |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes, array[0..N-1].                 |
//|     Y           -   function values, array[0..N-1].              |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points are used to  |
//|                       build spline                               |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//| OUTPUT PARAMETERS:                                               |
//|     C           -   spline interpolant                           |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|             Y[first]).                                           |
//|     *  0, which  corresponds to the parabolically terminated     |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildCubic(double &x[],double &y[],
                                 CSpline1DInterpolantShell &c)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dbuildcubic': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int    n=CAp::Len(x);
   int    boundltype=0;
   double boundl=0;
   int    boundrtype=0;
   double boundr=0;
//--- function call
   CSpline1D::Spline1DBuildCubic(x,y,n,boundltype,boundl,boundrtype,boundr,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function solves following problem: given table y[] of       |
//| function values at nodes x[], it calculates and returns table of |
//| function derivatives  d[] (calculated at the same nodes x[]).    |
//| This function yields same result as Spline1DBuildCubic() call    |
//| followed  by sequence of Spline1DDiff() calls, but it can be     |
//| several times faster when called for ordered X[] and X2[].       |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes                                 |
//|     Y           -   function values                              |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points are used     |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//| OUTPUT PARAMETERS:                                               |
//|     D           -   derivative values at X[]                     |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array. Derivative values are correctly reordered on     |
//| return, so D[I] is always equal to S'(X[I]) independently of     |
//| points order.                                                    |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|           Y[first]).                                             |
//|     *  0, which corresponds to the parabolically terminated      |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DGridDiffCubic(double &x[],double &y[],
                                    const int n,const int boundltype,
                                    const double boundl,const int boundrtype,
                                    const double boundr,double &d[])
  {
   CSpline1D::Spline1DGridDiffCubic(x,y,n,boundltype,boundl,boundrtype,boundr,d);
  }
//+------------------------------------------------------------------+
//| This function solves following problem: given table y[] of       |
//| function values at nodes x[], it calculates and returns table of |
//| function derivatives  d[] (calculated at the same nodes x[]).    |
//| This function yields same result as Spline1DBuildCubic() call    |
//| followed  by sequence of Spline1DDiff() calls, but it can be     |
//| several times faster when called for ordered X[] and X2[].       |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes                                 |
//|     Y           -   function values                              |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points are used     |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//| OUTPUT PARAMETERS:                                               |
//|     D           -   derivative values at X[]                     |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array. Derivative values are correctly reordered on     |
//| return, so D[I] is always equal to S'(X[I]) independently of     |
//| points order.                                                    |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|           Y[first]).                                             |
//|     *  0, which corresponds to the parabolically terminated      |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DGridDiffCubic(double &x[],double &y[],
                                    double &d[])
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dgriddiffcubic': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int    n=CAp::Len(x);
   int    boundltype=0;
   double boundl=0;
   int    boundrtype=0;
   double boundr=0;
//--- function call
   CSpline1D::Spline1DGridDiffCubic(x,y,n,boundltype,boundl,boundrtype,boundr,d);
  }
//+------------------------------------------------------------------+
//| This function solves following problem: given table y[] of       |
//| function values at nodes x[], it calculates and returns tables of|
//| first and second function derivatives d1[] and d2[] (calculated  |
//| at the same nodes x[]).                                          |
//| This function yields same result as Spline1DBuildCubic() call    |
//| followed  by sequence of Spline1DDiff() calls, but it can be     |
//| several times faster when called for ordered X[] and X2[].       |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes                                 |
//|     Y           -   function values                              |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points are used     |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//| OUTPUT PARAMETERS:                                               |
//|     D1          -   S' values at X[]                             |
//|     D2          -   S'' values at X[]                            |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array. Derivative values are correctly reordered on     |
//| return, so D[I] is always equal to S'(X[I]) independently of     |
//| points order.                                                    |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|           Y[first]).                                             |
//|     *  0, which corresponds to the parabolically terminated      |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point].                                    |
//| However, this subroutine doesn't require you to specify equal    |
//| values for the first and last points - it automatically forces   |
//| them to be equal by copying Y[first_point] (corresponds to the   |
//| leftmost, minimal X[]) to Y[last_point]. However it is           |
//| recommended to pass consistent values of Y[], i.e. to make       |
//| Y[first_point]=Y[last_point].                                    |
//+------------------------------------------------------------------+
void CAlglib::Spline1DGridDiff2Cubic(double &x[],double &y[],
                                     const int n,const int boundltype,
                                     const double boundl,const int boundrtype,
                                     const double boundr,double &d1[],
                                     double &d2[])
  {
   CSpline1D::Spline1DGridDiff2Cubic(x,y,n,boundltype,boundl,boundrtype,boundr,d1,d2);
  }
//+------------------------------------------------------------------+
//| This function solves following problem: given table y[] of       |
//| function values at nodes x[], it calculates and returns tables of|
//| first and second function derivatives d1[] and d2[] (calculated  |
//| at the same nodes x[]).                                          |
//| This function yields same result as Spline1DBuildCubic() call    |
//| followed  by sequence of Spline1DDiff() calls, but it can be     |
//| several times faster when called for ordered X[] and X2[].       |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes                                 |
//|     Y           -   function values                              |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points are used     |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//| OUTPUT PARAMETERS:                                               |
//|     D1          -   S' values at X[]                             |
//|     D2          -   S'' values at X[]                            |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array. Derivative values are correctly reordered on     |
//| return, so D[I] is always equal to S'(X[I]) independently of     |
//| points order.                                                    |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|           Y[first]).                                             |
//|     *  0, which corresponds to the parabolically terminated      |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point].                                    |
//| However, this subroutine doesn't require you to specify equal    |
//| values for the first and last points - it automatically forces   |
//| them to be equal by copying Y[first_point] (corresponds to the   |
//| leftmost, minimal X[]) to Y[last_point]. However it is           |
//| recommended to pass consistent values of Y[], i.e. to make       |
//| Y[first_point]=Y[last_point].                                    |
//+------------------------------------------------------------------+
void CAlglib::Spline1DGridDiff2Cubic(double &x[],double &y[],
                                     double &d1[],double &d2[])
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dgriddiff2cubic': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int    n=CAp::Len(x);
   int    boundltype=0;
   double boundl=0;
   int    boundrtype=0;
   double boundr=0;
//--- function call
   CSpline1D::Spline1DGridDiff2Cubic(x,y,n,boundltype,boundl,boundrtype,boundr,d1,d2);
  }
//+------------------------------------------------------------------+
//| This function solves following problem: given table y[] of       |
//| function values at old nodes x[]  and new nodes  x2[], it        |
//| calculates and returns table of function values y2[] (calculated |
//| at x2[]).                                                        |
//| This function yields same result as Spline1DBuildCubic() call    |
//| followed  by sequence of Spline1DDiff() calls, but it can be     |
//| several times faster when called for ordered X[] and X2[].       |
//| INPUT PARAMETERS:                                                |
//|     X           -   old spline nodes                             |
//|     Y           -   function values                              |
//|     X2           -  new spline nodes                             |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points from X/Y are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//|     N2          -   new points count:                            |
//|                     * N2>=2                                      |
//|                     * if given, only first N2 points from X2 are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X2 size                                    |
//| OUTPUT PARAMETERS:                                               |
//|     F2          -   function values at X2[]                      |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller  may pass       |
//| unsorted array. Function  values  are correctly reordered on     |
//| return, so F2[I] is always equal to S(X2[I]) independently of    |
//| points order.                                                    |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|           Y[first]).                                             |
//|     *  0, which corresponds to the parabolically terminated      |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DConvCubic(double &x[],double &y[],const int n,
                                const int boundltype,const double boundl,
                                const int boundrtype,const double boundr,
                                double &x2[],int n2,double &y2[])
  {
   CSpline1D::Spline1DConvCubic(x,y,n,boundltype,boundl,boundrtype,boundr,x2,n2,y2);
  }
//+------------------------------------------------------------------+
//| This function solves following problem: given table y[] of       |
//| function values at old nodes x[]  and new nodes  x2[], it        |
//| calculates and returns table of function values y2[] (calculated |
//| at x2[]).                                                        |
//| This function yields same result as Spline1DBuildCubic() call    |
//| followed  by sequence of Spline1DDiff() calls, but it can be     |
//| several times faster when called for ordered X[] and X2[].       |
//| INPUT PARAMETERS:                                                |
//|     X           -   old spline nodes                             |
//|     Y           -   function values                              |
//|     X2           -  new spline nodes                             |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points from X/Y are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//|     N2          -   new points count:                            |
//|                     * N2>=2                                      |
//|                     * if given, only first N2 points from X2 are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X2 size                                    |
//| OUTPUT PARAMETERS:                                               |
//|     F2          -   function values at X2[]                      |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller  may pass       |
//| unsorted array. Function  values  are correctly reordered on     |
//| return, so F2[I] is always equal to S(X2[I]) independently of    |
//| points order.                                                    |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|           Y[first]).                                             |
//|     *  0, which corresponds to the parabolically terminated      |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DConvCubic(double &x[],double &y[],
                                double &x2[],double &y2[])
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dconvcubic': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int    n=CAp::Len(x);
   int    boundltype=0;
   double boundl=0;
   int    boundrtype=0;
   double boundr=0;
   int    n2=CAp::Len(x2);
//--- function call
   CSpline1D::Spline1DConvCubic(x,y,n,boundltype,boundl,boundrtype,boundr,x2,n2,y2);
  }
//+------------------------------------------------------------------+
//| This function solves following problem: given table y[] of       |
//| function values at old nodes x[] and new nodes x2[], it          |
//| calculates and returns table of function values y2[] and         |
//| derivatives d2[] (calculated at x2[]).                           |
//| This function yields same result as Spline1DBuildCubic() call    |
//| followed by sequence of Spline1DDiff() calls, but it can be      |
//| several times faster when called for ordered X[] and X2[].       |
//| INPUT PARAMETERS:                                                |
//|     X           -   old spline nodes                             |
//|     Y           -   function values                              |
//|     X2           -  new spline nodes                             |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points from X/Y are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//|     N2          -   new points count:                            |
//|                     * N2>=2                                      |
//|                     * if given, only first N2 points from X2 are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X2 size                                    |
//| OUTPUT PARAMETERS:                                               |
//|     F2          -   function values at X2[]                      |
//|     D2          -   first derivatives at X2[]                    |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array. Function  values  are correctly reordered on     |
//| return, so F2[I] is always equal to S(X2[I]) independently of    |
//| points order.                                                    |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|             Y[first]).                                           |
//|     *  0, which corresponds to the parabolically terminated      |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DConvDiffCubic(double &x[],double &y[],
                                    const int n,const int boundltype,
                                    const double boundl,const int boundrtype,
                                    const double boundr,double &x2[],
                                    int n2,double &y2[],double &d2[])
  {
   CSpline1D::Spline1DConvDiffCubic(x,y,n,boundltype,boundl,boundrtype,boundr,x2,n2,y2,d2);
  }
//+------------------------------------------------------------------+
//| This function solves following problem: given table y[] of       |
//| function values at old nodes x[] and new nodes x2[], it          |
//| calculates and returns table of function values y2[] and         |
//| derivatives d2[] (calculated at x2[]).                           |
//| This function yields same result as Spline1DBuildCubic() call    |
//| followed by sequence of Spline1DDiff() calls, but it can be      |
//| several times faster when called for ordered X[] and X2[].       |
//| INPUT PARAMETERS:                                                |
//|     X           -   old spline nodes                             |
//|     Y           -   function values                              |
//|     X2           -  new spline nodes                             |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points from X/Y are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//|     N2          -   new points count:                            |
//|                     * N2>=2                                      |
//|                     * if given, only first N2 points from X2 are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X2 size                                    |
//| OUTPUT PARAMETERS:                                               |
//|     F2          -   function values at X2[]                      |
//|     D2          -   first derivatives at X2[]                    |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array. Function  values  are correctly reordered on     |
//| return, so F2[I] is always equal to S(X2[I]) independently of    |
//| points order.                                                    |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|             Y[first]).                                           |
//|     *  0, which corresponds to the parabolically terminated      |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DConvDiffCubic(double &x[],double &y[],
                                    double &x2[],double &y2[],
                                    double &d2[])
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dconvdiffcubic': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int    n=CAp::Len(x);
   int    boundltype=0;
   double boundl=0;
   int    boundrtype=0;
   double boundr=0;
   int    n2=CAp::Len(x2);
//--- function call
   CSpline1D::Spline1DConvDiffCubic(x,y,n,boundltype,boundl,boundrtype,boundr,x2,n2,y2,d2);
  }
//+------------------------------------------------------------------+
//| This function solves following problem: given table y[] of       |
//| function values at old nodes x[] and new nodes  x2[], it         |
//| calculates and returns table of function values y2[], first and  |
//| second derivatives d2[] and dd2[] (calculated at x2[]).          |
//| This function yields same result as Spline1DBuildCubic() call    |
//| followed  by sequence of Spline1DDiff() calls, but it can be     |
//| several times faster when called for ordered X[] and X2[].       |
//| INPUT PARAMETERS:                                                |
//|     X           -   old spline nodes                             |
//|     Y           -   function values                              |
//|     X2           -  new spline nodes                             |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points from X/Y are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//|     N2          -   new points count:                            |
//|                     * N2>=2                                      |
//|                     * if given, only first N2 points from X2 are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X2 size                                    |
//| OUTPUT PARAMETERS:                                               |
//|     F2          -   function values at X2[]                      |
//|     D2          -   first derivatives at X2[]                    |
//|     DD2         -   second derivatives at X2[]                   |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array. Function values are correctly reordered on       |
//| return, so F2[I] is always equal to S(X2[I]) independently of    |
//| points order.                                                    |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|             Y[first]).                                           |
//|     *  0, which corresponds to the parabolically terminated      |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DConvDiff2Cubic(double &x[],double &y[],
                                     const int n,const int boundltype,
                                     const double boundl,const int boundrtype,
                                     const double boundr,double &x2[],
                                     const int n2,double &y2[],
                                     double &d2[],double &dd2[])
  {
   CSpline1D::Spline1DConvDiff2Cubic(x,y,n,boundltype,boundl,boundrtype,boundr,x2,n2,y2,d2,dd2);
  }
//+------------------------------------------------------------------+
//| This function solves following problem: given table y[] of       |
//| function values at old nodes x[] and new nodes  x2[], it         |
//| calculates and returns table of function values y2[], first and  |
//| second derivatives d2[] and dd2[] (calculated at x2[]).          |
//| This function yields same result as Spline1DBuildCubic() call    |
//| followed  by sequence of Spline1DDiff() calls, but it can be     |
//| several times faster when called for ordered X[] and X2[].       |
//| INPUT PARAMETERS:                                                |
//|     X           -   old spline nodes                             |
//|     Y           -   function values                              |
//|     X2           -  new spline nodes                             |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points from X/Y are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundLType  -   boundary condition type for the left boundary|
//|     BoundL      -   left boundary condition (first or second     |
//|                     derivative, depending on the BoundLType)     |
//|     BoundRType  -   boundary condition type for the right        |
//|                     boundary                                     |
//|     BoundR      -   right boundary condition (first or second    |
//|                     derivative, depending on the BoundRType)     |
//|     N2          -   new points count:                            |
//|                     * N2>=2                                      |
//|                     * if given, only first N2 points from X2 are |
//|                       used                                       |
//|                     * if not given, automatically detected from  |
//|                       X2 size                                    |
//| OUTPUT PARAMETERS:                                               |
//|     F2          -   function values at X2[]                      |
//|     D2          -   first derivatives at X2[]                    |
//|     DD2         -   second derivatives at X2[]                   |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array. Function values are correctly reordered on       |
//| return, so F2[I] is always equal to S(X2[I]) independently of    |
//| points order.                                                    |
//| SETTING BOUNDARY VALUES:                                         |
//| The BoundLType/BoundRType parameters can have the following      |
//| values:                                                          |
//|     * -1, which corresonds to the periodic (cyclic) boundary     |
//|           conditions. In this case:                              |
//|           * both BoundLType and BoundRType must be equal to -1.  |
//|           * BoundL/BoundR are ignored                            |
//|           * Y[last] is ignored (it is assumed to be equal to     |
//|             Y[first]).                                           |
//|     *  0, which corresponds to the parabolically terminated      |
//|           spline (BoundL and/or BoundR are ignored).             |
//|     *  1, which corresponds to the first derivative boundary     |
//|           condition                                              |
//|     *  2, which corresponds to the second derivative boundary    |
//|           condition                                              |
//|     *  by default, BoundType=0 is used                           |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DConvDiff2Cubic(double &x[],double &y[],
                                     double &x2[],double &y2[],
                                     double &d2[],double &dd2[])
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dconvdiff2cubic': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=CAp::Len(x);
   int boundltype=0;
   double boundl=0;
   int    boundrtype=0;
   double boundr=0;
   int    n2=CAp::Len(x2);
//--- function call
   CSpline1D::Spline1DConvDiff2Cubic(x,y,n,boundltype,boundl,boundrtype,boundr,x2,n2,y2,d2,dd2);
  }
//+------------------------------------------------------------------+
//| This subroutine builds Catmull-Rom spline interpolant.           |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes, array[0..N-1].                 |
//|     Y           -   function values, array[0..N-1].              |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points are used to  |
//|                       build spline                               |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundType   -   boundary condition type:                     |
//|                     * -1 for periodic boundary condition         |
//|                     *  0 for parabolically terminated spline     |
//|                        (default)                                 |
//|     Tension     -   tension parameter:                           |
//|                     * tension=0   corresponds to classic         |
//|                       Catmull-Rom spline (default)               |
//|                     * 0<tension<1 corresponds to more general    |
//|                       form - cardinal spline                     |
//| OUTPUT PARAMETERS:                                               |
//|     C           -   spline interpolant                           |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildCatmullRom(double &x[],double &y[],
                                      const int n,const int boundtype,
                                      const double tension,
                                      CSpline1DInterpolantShell &c)
  {
   CSpline1D::Spline1DBuildCatmullRom(x,y,n,boundtype,tension,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine builds Catmull-Rom spline interpolant.           |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes, array[0..N-1].                 |
//|     Y           -   function values, array[0..N-1].              |
//| OPTIONAL PARAMETERS:                                             |
//|     N           -   points count:                                |
//|                     * N>=2                                       |
//|                     * if given, only first N points are used to  |
//|                       build spline                               |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//|     BoundType   -   boundary condition type:                     |
//|                     * -1 for periodic boundary condition         |
//|                     *  0 for parabolically terminated spline     |
//|                        (default)                                 |
//|     Tension     -   tension parameter:                           |
//|                     * tension=0   corresponds to classic         |
//|                       Catmull-Rom spline (default)               |
//|                     * 0<tension<1 corresponds to more general    |
//|                       form - cardinal spline                     |
//| OUTPUT PARAMETERS:                                               |
//|     C           -   spline interpolant                           |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//| PROBLEMS WITH PERIODIC BOUNDARY CONDITIONS:                      |
//| Problems with periodic boundary conditions have                  |
//| Y[first_point]=Y[last_point]. However, this subroutine doesn't   |
//| require you to specify equal values for the first and last       |
//| points - it automatically forces them to be equal by copying     |
//| Y[first_point] (corresponds to the leftmost, minimal X[]) to     |
//| Y[last_point]. However it is recommended to pass consistent      |
//| values of Y[], i.e. to make Y[first_point]=Y[last_point].        |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildCatmullRom(double &x[],double &y[],
                                      CSpline1DInterpolantShell &c)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dbuildcatmullrom': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int    n=CAp::Len(x);
   int    boundtype=0;
   double tension=0;
//--- function call
   CSpline1D::Spline1DBuildCatmullRom(x,y,n,boundtype,tension,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine builds Hermite spline interpolant.               |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes, array[0..N-1]                  |
//|     Y           -   function values, array[0..N-1]               |
//|     D           -   derivatives, array[0..N-1]                   |
//|     N           -   points count (optional):                     |
//|                     * N>=2                                       |
//|                     * if given, only first N points are used to  |
//|                       build spline                               |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//| OUTPUT PARAMETERS:                                               |
//|     C           -   spline interpolant.                          |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildHermite(double &x[],double &y[],double &d[],
                                   const int n,CSpline1DInterpolantShell &c)
  {
   CSpline1D::Spline1DBuildHermite(x,y,d,n,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine builds Hermite spline interpolant.               |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes, array[0..N-1]                  |
//|     Y           -   function values, array[0..N-1]               |
//|     D           -   derivatives, array[0..N-1]                   |
//|     N           -   points count (optional):                     |
//|                     * N>=2                                       |
//|                     * if given, only first N points are used to  |
//|                       build spline                               |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//| OUTPUT PARAMETERS:                                               |
//|     C           -   spline interpolant.                          |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildHermite(double &x[],double &y[],double &d[],
                                   CSpline1DInterpolantShell &c)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)) || (CAp::Len(x)!=CAp::Len(d)))
     {
      Print("Error while calling 'spline1dbuildhermite': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CSpline1D::Spline1DBuildHermite(x,y,d,n,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine builds Akima spline interpolant                  |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes, array[0..N-1]                  |
//|     Y           -   function values, array[0..N-1]               |
//|     N           -   points count (optional):                     |
//|                     * N>=5                                       |
//|                     * if given, only first N points are used to  |
//|                       build spline                               |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//| OUTPUT PARAMETERS:                                               |
//|     C           -   spline interpolant                           |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildAkima(double &x[],double &y[],const int n,
                                 CSpline1DInterpolantShell &c)
  {
   CSpline1D::Spline1DBuildAkima(x,y,n,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine builds Akima spline interpolant                  |
//| INPUT PARAMETERS:                                                |
//|     X           -   spline nodes, array[0..N-1]                  |
//|     Y           -   function values, array[0..N-1]               |
//|     N           -   points count (optional):                     |
//|                     * N>=5                                       |
//|                     * if given, only first N points are used to  |
//|                       build spline                               |
//|                     * if not given, automatically detected from  |
//|                       X/Y sizes (len(X) must be equal to len(Y)) |
//| OUTPUT PARAMETERS:                                               |
//|     C           -   spline interpolant                           |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildAkima(double &x[],double &y[],
                                 CSpline1DInterpolantShell &c)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dbuildakima': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CSpline1D::Spline1DBuildAkima(x,y,n,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine calculates the value of the spline at the given  |
//| point X.                                                         |
//| INPUT PARAMETERS:                                                |
//|     C   -   spline interpolant                                   |
//|     X   -   point                                                |
//| Result:                                                          |
//|     S(x)                                                         |
//+------------------------------------------------------------------+
double CAlglib::Spline1DCalc(CSpline1DInterpolantShell &c,const double x)
  {
   return(CSpline1D::Spline1DCalc(c.GetInnerObj(),x));
  }
//+------------------------------------------------------------------+
//| This subroutine differentiates the spline.                       |
//| INPUT PARAMETERS:                                                |
//|     C   -   spline interpolant.                                  |
//|     X   -   point                                                |
//| Result:                                                          |
//|     S   -   S(x)                                                 |
//|     DS  -   S'(x)                                                |
//|     D2S -   S''(x)                                               |
//+------------------------------------------------------------------+
void CAlglib::Spline1DDiff(CSpline1DInterpolantShell &c,const double x,
                           double &s,double &ds,double &d2s)
  {
//--- initialization
   s=0;
   ds=0;
   d2s=0;
//--- function call
   CSpline1D::Spline1DDiff(c.GetInnerObj(),x,s,ds,d2s);
  }
//+------------------------------------------------------------------+
//| This subroutine unpacks the spline into the coefficients table.  |
//| INPUT PARAMETERS:                                                |
//|     C   -   spline interpolant.                                  |
//|     X   -   point                                                |
//| Result:                                                          |
//|     Tbl -   coefficients table, unpacked format, array[0..N-2,   |
//|             0..5].                                               |
//|             For I = 0...N-2:                                     |
//|                 Tbl[I,0] = X[i]                                  |
//|                 Tbl[I,1] = X[i+1]                                |
//|                 Tbl[I,2] = C0                                    |
//|                 Tbl[I,3] = C1                                    |
//|                 Tbl[I,4] = C2                                    |
//|                 Tbl[I,5] = C3                                    |
//|             On [x[i], x[i+1]] spline is equals to:               |
//|                 S(x) = C0 + C1*t + C2*t^2 + C3*t^3               |
//|                 t = x-x[i]                                       |
//+------------------------------------------------------------------+
void CAlglib::Spline1DUnpack(CSpline1DInterpolantShell &c,int &n,
                             CMatrixDouble &tbl)
  {
//--- initialization
   n=0;
//--- function call
   CSpline1D::Spline1DUnpack(c.GetInnerObj(),n,tbl);
  }
//+------------------------------------------------------------------+
//| This subroutine performs linear transformation of the spline     |
//| argument.                                                        |
//| INPUT PARAMETERS:                                                |
//|     C   -   spline interpolant.                                  |
//|     A, B-   transformation coefficients: x = A*t + B             |
//| Result:                                                          |
//|     C   -   transformed spline                                   |
//+------------------------------------------------------------------+
void CAlglib::Spline1DLinTransX(CSpline1DInterpolantShell &c,
                                const double a,const double b)
  {
   CSpline1D::Spline1DLinTransX(c.GetInnerObj(),a,b);
  }
//+------------------------------------------------------------------+
//| This subroutine performs linear transformation of the spline.    |
//| INPUT PARAMETERS:                                                |
//|     C   -   spline interpolant.                                  |
//|     A,B-   transformation coefficients: S2(x)=A*S(x) + B         |
//| Result:                                                          |
//|     C   -   transformed spline                                   |
//+------------------------------------------------------------------+
void CAlglib::Spline1DLinTransY(CSpline1DInterpolantShell &c,
                                const double a,const double b)
  {
   CSpline1D::Spline1DLinTransY(c.GetInnerObj(),a,b);
  }
//+------------------------------------------------------------------+
//| This subroutine integrates the spline.                           |
//| INPUT PARAMETERS:                                                |
//|     C   -   spline interpolant.                                  |
//|     X   -   right bound of the integration interval [a, x],      |
//|             here 'a' denotes min(x[])                            |
//| Result:                                                          |
//|     integral(S(t)dt,a,x)                                         |
//+------------------------------------------------------------------+
double CAlglib::Spline1DIntegrate(CSpline1DInterpolantShell &c,
                                  const double x)
  {
   return(CSpline1D::Spline1DIntegrate(c.GetInnerObj(),x));
  }
//+------------------------------------------------------------------+
//| Fitting by smoothing (penalized) cubic spline.                   |
//| This function approximates N scattered points (some of X[] may   |
//| be equal to each other) by cubic spline with M  nodes  at        |
//| equidistant  grid  spanning interval [min(x,xc),max(x,xc)].      |
//| The problem is regularized by adding nonlinearity penalty to     |
//| usual  least squares penalty function:                           |
//|               MERIT_FUNC = F_LS + F_NL                           |
//| where F_LS is a least squares error  term,  and  F_NL  is  a     |
//| nonlinearity penalty which is roughly proportional to            |
//| LambdaNS*integral{ S''(x)^2*dx }. Algorithm applies automatic    |
//| renormalization of F_NL  which  makes  penalty term roughly      |
//| invariant to scaling of X[] and changes in M.                    |
//| This function is a new edition  of  penalized  regression  spline|
//| fitting, a fast and compact one which needs much less resources  |
//| that  its  previous version: just O(maxMN) memory and            |
//| O(maxMN*log(maxMN)) time.                                        |
//| NOTE: it is OK to run this function with both M<<N and M>>N; say,|
//|       it is possible to process 100 points with 1000-node spline.|
//| INPUT PARAMETERS:                                                |
//|   X        -  points, array[0..N-1].                             |
//|   Y        -  function values, array[0..N-1].                    |
//|   N        -  number of points (optional):                       |
//|               * N>0                                              |
//|               * if given, only first N elements of X/Y are       |
//|                 processed                                        |
//|               * if not given, automatically determined from      |
//|                 lengths                                          |
//|   M        -  number of basis functions ( = number_of_nodes),    |
//|               M>=4.                                              |
//|   LambdaNS -  LambdaNS>=0, regularization  constant  passed by   |
//|               user. It penalizes nonlinearity in the regression  |
//|               spline. Possible values to start from are 0.00001, |
//|               0.1, 1                                             |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  spline interpolant.                                |
//|   Rep      -  Following fields are set:                          |
//|               * RMSError      rms error on the (X,Y).            |
//|               * AvgError      average error on the (X,Y).        |
//|               * AvgRelError   average relative error on the      |
//|                               non-zero Y                         |
//|               * MaxError      maximum error                      |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFit(double &x[],double &y[],int n,int m,
                          double lambdans,CSpline1DInterpolantShell &s,
                          CSpline1DFitReportShell &rep)
  {
   CSpline1D::Spline1DFit(x,y,n,m,lambdans,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFit(double &x[],double &y[],int m,double lambdans,
                          CSpline1DInterpolantShell &s,CSpline1DFitReportShell &rep)
  {
//--- check
   if(!CAp::Assert(CAp::Len(x)==CAp::Len(y),"Error while calling 'Spline1DFit': looks like one of arguments has wrong size"))
      return;
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CSpline1D::Spline1DFit(x,y,n,m,lambdans,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function builds monotone cubic Hermite interpolant. This    |
//| interpolant is monotonic in [x(0),x(n-1)] and is constant outside|
//| of this interval.                                                |
//| In  case  y[]  form  non-monotonic  sequence,  interpolant  is   |
//| piecewise monotonic.  Say, for x=(0,1,2,3,4)  and  y=(0,1,2,1,0) |
//| interpolant  will monotonically grow at [0..2] and monotonically |
//| decrease at [2..4].                                              |
//| INPUT PARAMETERS:                                                |
//|   X        -  spline nodes, array[0..N-1]. Subroutine            |
//|               automatically sorts points, so caller may pass     |
//|               unsorted array.                                    |
//|   Y        -  function values, array[0..N-1]                     |
//|   N        -  the number of points(N>=2).                        |
//| OUTPUT PARAMETERS:                                               |
//|   C        -  spline interpolant.                                |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildMonotone(double &x[],double &y[],int n,CSpline1DInterpolantShell &c)
  {
   CSpline1D::Spline1DBuildMonotone(x,y,n,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildMonotone(CRowDouble &x,CRowDouble &y,CSpline1DInterpolantShell &c)
  {
//--- create variables
   double X[];
   double Y[];
//--- initialization
   x.ToArray(X);
   y.ToArray(Y);
//--- function call
   Spline1DBuildMonotone(X,Y,c);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::Spline1DBuildMonotone(double &x[],double &y[],CSpline1DInterpolantShell &c)
  {
//--- check
   if(!CAp::Assert(CAp::Len(x)==CAp::Len(y),"Error while calling 'Spline1DBuildMonotone': looks like one of arguments has wrong size"))
      return;
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CSpline1D::Spline1DBuildMonotone(x,y,n,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Fitting by polynomials in barycentric form. This function        |
//| provides simple unterface for unconstrained unweighted fitting.  |
//| See PolynomialFitWC() if you need constrained fitting.           |
//| Task is linear, so linear least squares solver is used.          |
//| Complexity of this computational scheme is O(N*M^2), mostly      |
//| dominated by least squares solver                                |
//| SEE ALSO:                                                        |
//|     PolynomialFitWC()                                            |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     N   -   number of points, N>0                                |
//|             * if given, only leading N elements of X/Y are used  |
//|             * if not given, automatically determined from sizes  |
//|               of X/Y                                             |
//|     M   -   number of basis functions (= polynomial_degree + 1), |
//|             M>=1                                                 |
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearW() subroutine:         |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|     P   -   interpolant in barycentric form.                     |
//|     Rep -   report, same format as in LSFitLinearW() subroutine. |
//|             Following fields are set:                            |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//| NOTES:                                                           |
//|     you can convert P from barycentric form to the power or      |
//|     Chebyshev basis with PolynomialBar2Pow() or                  |
//|     PolynomialBar2Cheb() functions from POLINT subpackage.       |
//+------------------------------------------------------------------+
void CAlglib::PolynomialFit(double &x[],double &y[],const int n,
                            const int m,int &info,CBarycentricInterpolantShell &p,
                            CPolynomialFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::PolynomialFit(x,y,n,m,info,p.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Fitting by polynomials in barycentric form. This function        |
//| provides simple unterface for unconstrained unweighted fitting.  |
//| See PolynomialFitWC() if you need constrained fitting.           |
//| Task is linear, so linear least squares solver is used.          |
//| Complexity of this computational scheme is O(N*M^2), mostly      |
//| dominated by least squares solver                                |
//| SEE ALSO:                                                        |
//|     PolynomialFitWC()                                            |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     N   -   number of points, N>0                                |
//|             * if given, only leading N elements of X/Y are used  |
//|             * if not given, automatically determined from sizes  |
//|               of X/Y                                             |
//|     M   -   number of basis functions (= polynomial_degree + 1), |
//|             M>=1                                                 |
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearW() subroutine:         |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|     P   -   interpolant in barycentric form.                     |
//|     Rep -   report, same format as in LSFitLinearW() subroutine. |
//|             Following fields are set:                            |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//| NOTES:                                                           |
//|     you can convert P from barycentric form to the power or      |
//|     Chebyshev basis with PolynomialBar2Pow() or                  |
//|     PolynomialBar2Cheb() functions from POLINT subpackage.       |
//+------------------------------------------------------------------+
void CAlglib::PolynomialFit(double &x[],double &y[],const int m,
                            int &info,CBarycentricInterpolantShell &p,
                            CPolynomialFitReportShell &rep)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'polynomialfit': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=CAp::Len(x);
//--- function call
   CLSFit::PolynomialFit(x,y,n,m,info,p.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted  fitting by polynomials in barycentric form, with       |
//| constraints  on function values or first derivatives.            |
//| Small regularizing term is used when solving constrained tasks   |
//| (to improve stability).                                          |
//| Task is linear, so linear least squares solver is used.          |
//| Complexity of this computational scheme is O(N*M^2), mostly      |
//| dominated by least squares solver                                |
//| SEE ALSO:                                                        |
//|     PolynomialFit()                                              |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     W   -   weights, array[0..N-1]                               |
//|             Each summand in square sum of approximation          |
//|             deviations from given values is multiplied by the    |
//|             square of corresponding weight. Fill it by 1's if you|
//|             don't want to solve weighted task.                   |
//|     N   -   number of points, N>0.                               |
//|             * if given, only leading N elements of X/Y/W are used|
//|             * if not given, automatically determined from sizes  |
//|               of X/Y/W                                           |
//|     XC  -   points where polynomial values/derivatives are       |
//|             constrained, array[0..K-1].                          |
//|     YC  -   values of constraints, array[0..K-1]                 |
//|     DC  -   array[0..K-1], types of constraints:                 |
//|             * DC[i]=0   means that P(XC[i])=YC[i]                |
//|             * DC[i]=1   means that P'(XC[i])=YC[i]               |
//|             SEE BELOW FOR IMPORTANT INFORMATION ON CONSTRAINTS   |
//|     K   -   number of constraints, 0<=K<M.                       |
//|             K=0 means no constraints (XC/YC/DC are not used in   |
//|             such cases)                                          |
//|     M   -   number of basis functions (= polynomial_degree + 1), |
//|             M>=1                                                 |
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearW() subroutine:         |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                         -3 means inconsistent constraints        |
//|     P   -   interpolant in barycentric form.                     |
//|     Rep -   report, same format as in LSFitLinearW() subroutine. |
//|             Following fields are set:                            |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//| NOTES:                                                           |
//|     you can convert P from barycentric form to the power or      |
//|     Chebyshev basis with PolynomialBar2Pow() or                  |
//|     PolynomialBar2Cheb() functions from POLINT subpackage.       |
//| SETTING CONSTRAINTS - DANGERS AND OPPORTUNITIES:                 |
//| Setting constraints can lead to undesired results, like          |
//| ill-conditioned behavior, or inconsistency being detected.       |
//| From the other side, it allows us to improve quality of the fit. |
//| Here we summarize our experience with constrained regression     |
//| splines:                                                         |
//| * even simple constraints can be inconsistent, see Wikipedia     |
//|   article on this subject:                                       |
//|   http://en.wikipedia.org/wiki/Birkhoff_interpolation            |
//| * the greater is M (given fixed constraints), the more chances   |
//|   that constraints will be consistent                            |
//| * in the general case, consistency of constraints is NOT         |
//|   GUARANTEED.                                                    |
//| * in the one special cases, however, we can guarantee            |
//|   consistency. This case  is:  M>1  and constraints on the       |
//|   function values (NOT DERIVATIVES)                              |
//| Our final recommendation is to use constraints WHEN AND ONLY when|
//| you can't solve your task without them. Anything beyond special  |
//| cases given above is not guaranteed and may result in            |
//| inconsistency.                                                   |
//+------------------------------------------------------------------+
void CAlglib::PolynomialFitWC(double &x[],double &y[],double &w[],
                              const int n,double &xc[],double &yc[],
                              int &dc[],const int k,const int m,
                              int &info,CBarycentricInterpolantShell &p,
                              CPolynomialFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::PolynomialFitWC(x,y,w,n,xc,yc,dc,k,m,info,p.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted  fitting by polynomials in barycentric form, with       |
//| constraints  on function values or first derivatives.            |
//| Small regularizing term is used when solving constrained tasks   |
//| (to improve stability).                                          |
//| Task is linear, so linear least squares solver is used.          |
//| Complexity of this computational scheme is O(N*M^2), mostly      |
//| dominated by least squares solver                                |
//| SEE ALSO:                                                        |
//|     PolynomialFit()                                              |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     W   -   weights, array[0..N-1]                               |
//|             Each summand in square sum of approximation          |
//|             deviations from given values is multiplied by the    |
//|             square of corresponding weight. Fill it by 1's if you|
//|             don't want to solve weighted task.                   |
//|     N   -   number of points, N>0.                               |
//|             * if given, only leading N elements of X/Y/W are used|
//|             * if not given, automatically determined from sizes  |
//|               of X/Y/W                                           |
//|     XC  -   points where polynomial values/derivatives are       |
//|             constrained, array[0..K-1].                          |
//|     YC  -   values of constraints, array[0..K-1]                 |
//|     DC  -   array[0..K-1], types of constraints:                 |
//|             * DC[i]=0   means that P(XC[i])=YC[i]                |
//|             * DC[i]=1   means that P'(XC[i])=YC[i]               |
//|             SEE BELOW FOR IMPORTANT INFORMATION ON CONSTRAINTS   |
//|     K   -   number of constraints, 0<=K<M.                       |
//|             K=0 means no constraints (XC/YC/DC are not used in   |
//|             such cases)                                          |
//|     M   -   number of basis functions (= polynomial_degree + 1), |
//|             M>=1                                                 |
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearW() subroutine:         |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                         -3 means inconsistent constraints        |
//|     P   -   interpolant in barycentric form.                     |
//|     Rep -   report, same format as in LSFitLinearW() subroutine. |
//|             Following fields are set:                            |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//| NOTES:                                                           |
//|     you can convert P from barycentric form to the power or      |
//|     Chebyshev basis with PolynomialBar2Pow() or                  |
//|     PolynomialBar2Cheb() functions from POLINT subpackage.       |
//| SETTING CONSTRAINTS - DANGERS AND OPPORTUNITIES:                 |
//| Setting constraints can lead to undesired results, like          |
//| ill-conditioned behavior, or inconsistency being detected.       |
//| From the other side, it allows us to improve quality of the fit. |
//| Here we summarize our experience with constrained regression     |
//| splines:                                                         |
//| * even simple constraints can be inconsistent, see Wikipedia     |
//|   article on this subject:                                       |
//|   http://en.wikipedia.org/wiki/Birkhoff_interpolation            |
//| * the greater is M (given fixed constraints), the more chances   |
//|   that constraints will be consistent                            |
//| * in the general case, consistency of constraints is NOT         |
//|   GUARANTEED.                                                    |
//| * in the one special cases, however, we can guarantee            |
//|   consistency. This case  is:  M>1  and constraints on the       |
//|   function values (NOT DERIVATIVES)                              |
//| Our final recommendation is to use constraints WHEN AND ONLY when|
//| you can't solve your task without them. Anything beyond special  |
//| cases given above is not guaranteed and may result in            |
//| inconsistency.                                                   |
//+------------------------------------------------------------------+
void CAlglib::PolynomialFitWC(double &x[],double &y[],double &w[],
                              double &xc[],double &yc[],int &dc[],
                              const int m,int &info,CBarycentricInterpolantShell &p,
                              CPolynomialFitReportShell &rep)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)) || (CAp::Len(x)!=CAp::Len(w)))
     {
      Print("Error while calling 'polynomialfitwc': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
   if((CAp::Len(xc)!=CAp::Len(yc)) || (CAp::Len(xc)!=CAp::Len(dc)))
     {
      Print("Error while calling 'polynomialfitwc': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=CAp::Len(x);
   int k=CAp::Len(xc);
//--- function call
   CLSFit::PolynomialFitWC(x,y,w,n,xc,yc,dc,k,m,info,p.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weghted rational least squares fitting using Floater-Hormann     |
//| rational functions with optimal D chosen from [0,9], with        |
//| constraints and individual weights.                              |
//| Equidistant grid with M node on [min(x),max(x)] is used to build |
//| basis functions. Different values of D are tried, optimal D      |
//| (least WEIGHTED root mean square error) is chosen. Task is       |
//| linear, so linear least squares solver is used. Complexity of    |
//| this computational scheme is O(N*M^2) (mostly dominated by the   |
//| least squares solver).                                           |
//| SEE ALSO                                                         |
//|*BarycentricFitFloaterHormann(), "lightweight" fitting without  |
//|   invididual weights and constraints.                            |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     W   -   weights, array[0..N-1]                               |
//|             Each summand in square sum of approximation          |
//|             deviations from given values is multiplied by the    |
//|             square of corresponding weight. Fill it by 1's if    |
//|             you don't want to solve weighted task.               |
//|     N   -   number of points, N>0.                               |
//|     XC  -   points where function values/derivatives are         |
//|             constrained, array[0..K-1].                          |
//|     YC  -   values of constraints, array[0..K-1]                 |
//|     DC  -   array[0..K-1], types of constraints:                 |
//|             * DC[i]=0   means that S(XC[i])=YC[i]                |
//|             * DC[i]=1   means that S'(XC[i])=YC[i]               |
//|             SEE BELOW FOR IMPORTANT INFORMATION ON CONSTRAINTS   |
//|     K   -   number of constraints, 0<=K<M.                       |
//|             K=0 means no constraints (XC/YC/DC are not used in   |
//|             such cases)                                          |
//|     M   -   number of basis functions ( = number_of_nodes),      |
//|             M>=2.                                                |
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearWC() subroutine.        |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                         -3 means inconsistent constraints        |
//|                         -1 means another errors in parameters    |
//|                            passed (N<=0, for example)            |
//|     B   -   barycentric interpolant.                             |
//|     Rep -   report, same format as in LSFitLinearWC() subroutine.|
//|             Following fields are set:                            |
//|             * DBest         best value of the D parameter        |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//| IMPORTANT:                                                       |
//|     this subroutine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//| SETTING CONSTRAINTS - DANGERS AND OPPORTUNITIES:                 |
//| Setting constraints can lead to undesired results, like          |
//| ill-conditioned behavior, or inconsistency being detected. From  |
//| the other side, it allows us to improve quality of the fit. Here |
//| we summarize our experience with constrained barycentric         |
//| interpolants:                                                    |
//| * excessive constraints can be inconsistent. Floater-Hormann     |
//|   basis functions aren't as flexible as splines (although they   |
//|   are very smooth).                                              |
//| * the more evenly constraints are spread across [min(x),max(x)], |
//|   the more chances that they will be consistent                  |
//| * the greater is M (given  fixed  constraints), the more chances |
//|   that constraints will be consistent                            |
//| * in the general case, consistency of constraints IS NOT         |
//|   GUARANTEED.                                                    |
//| * in the several special cases, however, we CAN guarantee        |
//|   consistency.                                                   |
//| * one of this cases is constraints on the function VALUES at the |
//|   interval boundaries. Note that consustency of the constraints  |
//|   on the function DERIVATIVES is NOT guaranteed (you can use in  |
//|   such cases cubic splines which are more flexible).             |
//| * another special case is ONE constraint on the function value   |
//|   (OR, but not AND, derivative) anywhere in the interval         |
//| Our final recommendation is to use constraints WHEN AND ONLY     |
//| WHEN you can't solve your task without them. Anything beyond     |
//| special cases given above is not guaranteed and may result in    |
//| inconsistency.                                                   |
//+------------------------------------------------------------------+
void CAlglib::BarycentricFitFloaterHormannWC(double &x[],double &y[],
                                             double &w[],const int n,
                                             double &xc[],double &yc[],
                                             int &dc[],const int k,
                                             const int m,int &info,
                                             CBarycentricInterpolantShell &b,
                                             CBarycentricFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::BarycentricFitFloaterHormannWC(x,y,w,n,xc,yc,dc,k,m,info,b.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Rational least squares fitting using Floater-Hormann rational    |
//| functions with optimal D chosen from [0,9].                      |
//| Equidistant grid with M node on [min(x),max(x)] is used to build |
//| basis functions. Different values of D are tried, optimal D      |
//| (least root mean square error) is chosen.  Task is linear, so    |
//| linear least squares solver is used. Complexity of this          |
//| computational scheme is O(N*M^2) (mostly dominated by the least  |
//| squares solver).                                                 |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     N   -   number of points, N>0.                               |
//|     M   -   number of basis functions ( = number_of_nodes), M>=2.|
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearWC() subroutine.        |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                         -3 means inconsistent constraints        |
//|     B   -   barycentric interpolant.                             |
//|     Rep -   report, same format as in LSFitLinearWC() subroutine.|
//|             Following fields are set:                            |
//|             * DBest         best value of the D parameter        |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//+------------------------------------------------------------------+
void CAlglib::BarycentricFitFloaterHormann(double &x[],double &y[],
                                           const int n,const int m,
                                           int &info,CBarycentricInterpolantShell &b,
                                           CBarycentricFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::BarycentricFitFloaterHormann(x,y,n,m,info,b.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Rational least squares fitting using Floater-Hormann rational    |
//| functions with optimal D chosen from [0,9].                      |
//| Equidistant grid with M node on [min(x),max(x)] is used to build |
//| basis functions. Different values of D are tried, optimal D      |
//| (least root mean square error) is chosen. Task is linear, so     |
//| linear least squares solver is used. Complexity of this          |
//| computational scheme is O(N*M^2) (mostly dominated by the least  |
//| squares solver).                                                 |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     N   -   number of points, N>0.                               |
//|     M   -   number of basis functions ( = number_of_nodes), M>=2.|
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearWC() subroutine.        |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                         -3 means inconsistent constraints        |
//|     B   -   barycentric interpolant.                             |
//|     Rep -   report, same format as in LSFitLinearWC() subroutine.|
//|             Following fields are set:                            |
//|             * DBest         best value of the D parameter        |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitPenalized(double &x[],double &y[],const int n,
                                   const int m,const double rho,int &info,
                                   CSpline1DInterpolantShell &s,
                                   CSpline1DFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CIntComp::Spline1DFitPenalized(x,y,n,m,rho,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Rational least squares fitting using Floater-Hormann rational    |
//| functions with optimal D chosen from [0,9].                      |
//| Equidistant grid with M node on [min(x),max(x)] is used to build |
//| basis functions. Different values of D are tried, optimal D      |
//| (least root mean square error) is chosen. Task is linear, so     |
//| linear least squares solver is used. Complexity of this          |
//| computational scheme is O(N*M^2) (mostly dominated by the least  |
//| squares solver).                                                 |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     N   -   number of points, N>0.                               |
//|     M   -   number of basis functions ( = number_of_nodes), M>=2.|
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearWC() subroutine.        |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                         -3 means inconsistent constraints        |
//|     B   -   barycentric interpolant.                             |
//|     Rep -   report, same format as in LSFitLinearWC() subroutine.|
//|             Following fields are set:                            |
//|             * DBest         best value of the D parameter        |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitPenalized(double &x[],double &y[],const int m,
                                   const double rho,int &info,
                                   CSpline1DInterpolantShell &s,
                                   CSpline1DFitReportShell &rep)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dfitpenalized': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=CAp::Len(x);
//--- function call
   CIntComp::Spline1DFitPenalized(x,y,n,m,rho,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted fitting by penalized cubic spline.                      |
//| Equidistant grid with M nodes on [min(x,xc),max(x,xc)] is used to|
//| build basis functions. Basis functions are cubic splines with    |
//| natural boundary conditions. Problem is regularized by adding    |
//| non-linearity penalty to the usual least squares penalty         |
//| function:                                                        |
//|     S(x) = arg min { LS + P }, where                             |
//|     LS   = SUM { w[i]^2*(y[i] - S(x[i]))^2 } - least squares     |
//|            penalty                                               |
//|     P    = C*10^rho*integral{ S''(x)^2*dx } - non-linearity      |
//|            penalty                                               |
//|     rho  - tunable constant given by user                        |
//|     C    - automatically determined scale parameter,             |
//|            makes penalty invariant with respect to scaling of X, |
//|            Y, W.                                                 |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     W   -   weights, array[0..N-1]                               |
//|             Each summand in square sum of approximation          |
//|             deviations from given values is multiplied by the    |
//|             square of corresponding weight. Fill it by 1's if    |
//|             you don't want to solve weighted problem.            |
//|     N   -   number of points (optional):                         |
//|             * N>0                                                |
//|             * if given, only first N elements of X/Y/W are       |
//|               processed                                          |
//|             * if not given, automatically determined from X/Y/W  |
//|               sizes                                              |
//|     M   -   number of basis functions ( = number_of_nodes), M>=4.|
//|     Rho -   regularization constant passed by user. It penalizes |
//|             nonlinearity in the regression spline. It is         |
//|             logarithmically scaled, i.e. actual value of         |
//|             regularization constant is calculated as 10^Rho. It  |
//|             is automatically scaled so that:                     |
//|             * Rho=2.0 corresponds to moderate amount of          |
//|               nonlinearity                                       |
//|             * generally, it should be somewhere in the           |
//|               [-8.0,+8.0]                                        |
//|             If you do not want to penalize nonlineary,           |
//|             pass small Rho. Values as low as -15 should work.    |
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearWC() subroutine.        |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                            or Cholesky decomposition; problem    |
//|                            may be too ill-conditioned (very      |
//|                            rare)                                 |
//|     S   -   spline interpolant.                                  |
//|     Rep -   Following fields are set:                            |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//| NOTE 1: additional nodes are added to the spline outside of the  |
//| fitting interval to force linearity when x<min(x,xc) or          |
//| x>max(x,xc). It is done for consistency - we penalize            |
//| non-linearity at [min(x,xc),max(x,xc)], so it is natural to      |
//| force linearity outside of this interval.                        |
//| NOTE 2: function automatically sorts points, so caller may pass  |
//| unsorted array.                                                  |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitPenalizedW(double &x[],double &y[],
                                    double &w[],const int n,
                                    const int m,const double rho,
                                    int &info,CSpline1DInterpolantShell &s,
                                    CSpline1DFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CIntComp::Spline1DFitPenalizedW(x,y,w,n,m,rho,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted fitting by penalized cubic spline.                      |
//| Equidistant grid with M nodes on [min(x,xc),max(x,xc)] is used to|
//| build basis functions. Basis functions are cubic splines with    |
//| natural boundary conditions. Problem is regularized by adding    |
//| non-linearity penalty to the usual least squares penalty         |
//| function:                                                        |
//|     S(x) = arg min { LS + P }, where                             |
//|     LS   = SUM { w[i]^2*(y[i] - S(x[i]))^2 } - least squares     |
//|            penalty                                               |
//|     P    = C*10^rho*integral{ S''(x)^2*dx } - non-linearity      |
//|            penalty                                               |
//|     rho  - tunable constant given by user                        |
//|     C    - automatically determined scale parameter,             |
//|            makes penalty invariant with respect to scaling of X, |
//|            Y, W.                                                 |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     W   -   weights, array[0..N-1]                               |
//|             Each summand in square sum of approximation          |
//|             deviations from given values is multiplied by the    |
//|             square of corresponding weight. Fill it by 1's if    |
//|             you don't want to solve weighted problem.            |
//|     N   -   number of points (optional):                         |
//|             * N>0                                                |
//|             * if given, only first N elements of X/Y/W are       |
//|               processed                                          |
//|             * if not given, automatically determined from X/Y/W  |
//|               sizes                                              |
//|     M   -   number of basis functions ( = number_of_nodes), M>=4.|
//|     Rho -   regularization constant passed by user. It penalizes |
//|             nonlinearity in the regression spline. It is         |
//|             logarithmically scaled, i.e. actual value of         |
//|             regularization constant is calculated as 10^Rho. It  |
//|             is automatically scaled so that:                     |
//|             * Rho=2.0 corresponds to moderate amount of          |
//|               nonlinearity                                       |
//|             * generally, it should be somewhere in the           |
//|               [-8.0,+8.0]                                        |
//|             If you do not want to penalize nonlineary,           |
//|             pass small Rho. Values as low as -15 should work.    |
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearWC() subroutine.        |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                            or Cholesky decomposition; problem    |
//|                            may be too ill-conditioned (very      |
//|                            rare)                                 |
//|     S   -   spline interpolant.                                  |
//|     Rep -   Following fields are set:                            |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//| NOTE 1: additional nodes are added to the spline outside of the  |
//| fitting interval to force linearity when x<min(x,xc) or          |
//| x>max(x,xc). It is done for consistency - we penalize            |
//| non-linearity at [min(x,xc),max(x,xc)], so it is natural to      |
//| force linearity outside of this interval.                        |
//| NOTE 2: function automatically sorts points, so caller may pass  |
//| unsorted array.                                                  |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitPenalizedW(double &x[],double &y[],
                                    double &w[],const int m,
                                    const double rho,int &info,
                                    CSpline1DInterpolantShell &s,
                                    CSpline1DFitReportShell &rep)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)) || (CAp::Len(x)!=CAp::Len(w)))
     {
      Print("Error while calling 'spline1dfitpenalizedw': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=CAp::Len(x);
//--- function call
   CIntComp::Spline1DFitPenalizedW(x,y,w,n,m,rho,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted fitting by cubic spline, with constraints on function   |
//| values or derivatives.                                           |
//| Equidistant grid with M-2 nodes on [min(x,xc),max(x,xc)] is used |
//| to build basis functions. Basis functions are cubic splines with |
//| continuous second derivatives and non-fixed first derivatives at |
//| interval ends. Small regularizing term is used when solving      |
//| constrained tasks (to improve stability).                        |
//| Task is linear, so linear least squares solver is used.          |
//| Complexity of this computational scheme is O(N*M^2), mostly      |
//| dominated by least squares solver                                |
//| SEE ALSO                                                         |
//|     Spline1DFitHermiteWC()  -   fitting by Hermite splines (more |
//|                                 flexible, less smooth)           |
//|     Spline1DFitCubic()     -  "lightweight" fitting by cubic   |
//|                                 splines, without invididual      |
//|                                 weights and constraints          |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     W   -   weights, array[0..N-1]                               |
//|             Each summand in square sum of approximation          |
//|             deviations from given values is multiplied by the    |
//|             square of corresponding weight. Fill it by 1's if you|
//|             don't want to solve weighted task.                   |
//|     N   -   number of points (optional):                         |
//|             * N>0                                                |
//|             * if given, only first N elements of X/Y/W are       |
//|               processed                                          |
//|             * if not given, automatically determined from X/Y/W  |
//|               sizes                                              |
//|     XC  -   points where spline values/derivatives are           |
//|             constrained, array[0..K-1].                          |
//|     YC  -   values of constraints, array[0..K-1]                 |
//|     DC  -   array[0..K-1], types of constraints:                 |
//|             * DC[i]=0   means that S(XC[i])=YC[i]                |
//|             * DC[i]=1   means that S'(XC[i])=YC[i]               |
//|             SEE BELOW FOR IMPORTANT INFORMATION ON CONSTRAINTS   |
//|     K   -   number of constraints (optional):                    |
//|             * 0<=K<M.                                            |
//|             * K=0 means no constraints (XC/YC/DC are not used)   |
//|             * if given, only first K elements of XC/YC/DC are    |
//|               used                                               |
//|             * if not given, automatically determined from        |
//|               XC/YC/DC                                           |
//|     M   -   number of basis functions ( = number_of_nodes+2),    |
//|             M>=4.                                                |
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearWC() subroutine.        |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                         -3 means inconsistent constraints        |
//|     S   -   spline interpolant.                                  |
//|     Rep -   report, same format as in LSFitLinearWC() subroutine.|
//|             Following fields are set:                            |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//| SETTING CONSTRAINTS - DANGERS AND OPPORTUNITIES:                 |
//| Setting constraints can lead  to undesired  results, like        |
//| ill-conditioned behavior, or inconsistency being detected. From  |
//| the other side, it allows us to improve quality of the fit.      |
//| Here we summarize our experience with constrained regression     |
//| splines:                                                         |
//| * excessive constraints can be inconsistent. Splines are         |
//|   piecewise cubic functions, and it is easy to create an         |
//|   example, where large number of constraints  concentrated in    |
//|   small area will result in inconsistency. Just because spline   |
//|   is not flexible enough to satisfy all of them. And same        |
//|   constraints spread across the [min(x),max(x)] will be          |
//|   perfectly consistent.                                          |
//| * the more evenly constraints are spread across [min(x),max(x)], |
//|   the more chances that they will be consistent                  |
//| * the greater is M (given fixed constraints), the more chances   |
//|   that constraints will be consistent                            |
//| * in the general case, consistency of constraints IS NOT         |
//|   GUARANTEED.                                                    |
//| * in the several special cases, however, we CAN guarantee        |
//|   consistency.                                                   |
//| * one of this cases is constraints on the function values        |
//|   AND/OR its derivatives at the interval boundaries.             |
//| * another special case is ONE constraint on the function value   |
//|   (OR, but not AND, derivative) anywhere in the interval         |
//| Our final recommendation is to use constraints WHEN AND ONLY WHEN|
//| you can't solve your task without them. Anything beyond special  |
//| cases given above is not guaranteed and may result in            |
//| inconsistency.                                                   |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitCubicWC(double &x[],double &y[],double &w[],
                                 const int n,double &xc[],double &yc[],
                                 int &dc[],const int k,const int m,
                                 int &info,CSpline1DInterpolantShell &s,
                                 CSpline1DFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::Spline1DFitCubicWC(x,y,w,n,xc,yc,dc,k,m,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted fitting by cubic spline, with constraints on function   |
//| values or derivatives.                                           |
//| Equidistant grid with M-2 nodes on [min(x,xc),max(x,xc)] is used |
//| to build basis functions. Basis functions are cubic splines with |
//| continuous second derivatives and non-fixed first derivatives at |
//| interval ends. Small regularizing term is used when solving      |
//| constrained tasks (to improve stability).                        |
//| Task is linear, so linear least squares solver is used.          |
//| Complexity of this computational scheme is O(N*M^2), mostly      |
//| dominated by least squares solver                                |
//| SEE ALSO                                                         |
//|     Spline1DFitHermiteWC()  -   fitting by Hermite splines (more |
//|                                 flexible, less smooth)           |
//|     Spline1DFitCubic()     -  "lightweight" fitting by cubic   |
//|                                 splines, without invididual      |
//|                                 weights and constraints          |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     W   -   weights, array[0..N-1]                               |
//|             Each summand in square sum of approximation          |
//|             deviations from given values is multiplied by the    |
//|             square of corresponding weight. Fill it by 1's if you|
//|             don't want to solve weighted task.                   |
//|     N   -   number of points (optional):                         |
//|             * N>0                                                |
//|             * if given, only first N elements of X/Y/W are       |
//|               processed                                          |
//|             * if not given, automatically determined from X/Y/W  |
//|               sizes                                              |
//|     XC  -   points where spline values/derivatives are           |
//|             constrained, array[0..K-1].                          |
//|     YC  -   values of constraints, array[0..K-1]                 |
//|     DC  -   array[0..K-1], types of constraints:                 |
//|             * DC[i]=0   means that S(XC[i])=YC[i]                |
//|             * DC[i]=1   means that S'(XC[i])=YC[i]               |
//|             SEE BELOW FOR IMPORTANT INFORMATION ON CONSTRAINTS   |
//|     K   -   number of constraints (optional):                    |
//|             * 0<=K<M.                                            |
//|             * K=0 means no constraints (XC/YC/DC are not used)   |
//|             * if given, only first K elements of XC/YC/DC are    |
//|               used                                               |
//|             * if not given, automatically determined from        |
//|               XC/YC/DC                                           |
//|     M   -   number of basis functions ( = number_of_nodes+2),    |
//|             M>=4.                                                |
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearWC() subroutine.        |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                         -3 means inconsistent constraints        |
//|     S   -   spline interpolant.                                  |
//|     Rep -   report, same format as in LSFitLinearWC() subroutine.|
//|             Following fields are set:                            |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//| ORDER OF POINTS                                                  |
//| Subroutine automatically sorts points, so caller may pass        |
//| unsorted array.                                                  |
//| SETTING CONSTRAINTS - DANGERS AND OPPORTUNITIES:                 |
//| Setting constraints can lead  to undesired  results, like        |
//| ill-conditioned behavior, or inconsistency being detected. From  |
//| the other side, it allows us to improve quality of the fit.      |
//| Here we summarize our experience with constrained regression     |
//| splines:                                                         |
//| * excessive constraints can be inconsistent. Splines are         |
//|   piecewise cubic functions, and it is easy to create an         |
//|   example, where large number of constraints  concentrated in    |
//|   small area will result in inconsistency. Just because spline   |
//|   is not flexible enough to satisfy all of them. And same        |
//|   constraints spread across the [min(x),max(x)] will be          |
//|   perfectly consistent.                                          |
//| * the more evenly constraints are spread across [min(x), max(x)], |
//|   the more chances that they will be consistent                  |
//| * the greater is M (given fixed constraints), the more chances   |
//|   that constraints will be consistent                            |
//| * in the general case, consistency of constraints IS NOT         |
//|   GUARANTEED.                                                    |
//| * in the several special cases, however, we CAN guarantee        |
//|   consistency.                                                   |
//| * one of this cases is constraints on the function values        |
//|   AND/OR its derivatives at the interval boundaries.             |
//| * another special case is ONE constraint on the function value   |
//|   (OR, but not AND, derivative) anywhere in the interval         |
//| Our final recommendation is to use constraints WHEN AND ONLY WHEN|
//| you can't solve your task without them. Anything beyond special  |
//| cases given above is not guaranteed and may result in            |
//| inconsistency.                                                   |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitCubicWC(double &x[],double &y[],double &w[],
                                 double &xc[],double &yc[],int &dc[],
                                 const int m,int &info,CSpline1DInterpolantShell &s,
                                 CSpline1DFitReportShell &rep)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)) || (CAp::Len(x)!=CAp::Len(w)))
     {
      Print("Error while calling 'spline1dfitcubicwc': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
   if((CAp::Len(xc)!=CAp::Len(yc)) || (CAp::Len(xc)!=CAp::Len(dc)))
     {
      Print("Error while calling 'spline1dfitcubicwc': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info=0;
   int n=CAp::Len(x);
   int k=CAp::Len(xc);
//--- function call
   CLSFit::Spline1DFitCubicWC(x,y,w,n,xc,yc,dc,k,m,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted fitting by Hermite spline, with constraints on function |
//| values or first derivatives.                                     |
//| Equidistant grid with M nodes on [min(x,xc),max(x,xc)] is used to|
//| build basis functions. Basis functions are Hermite splines. Small|
//| regularizing term is used when solving constrained tasks (to     |
//| improve stability).                                              |
//| Task is linear, so linear least squares solver is used.          |
//| Complexity of this computational scheme is O(N*M^2), mostly      |
//| dominated by least squares solver                                |
//| SEE ALSO                                                         |
//|     Spline1DFitCubicWC()    -   fitting by Cubic splines (less   |
//|                                 flexible, more smooth)           |
//|     Spline1DFitHermite()   -  "lightweight" Hermite fitting,   |
//|                                 without invididual weights and   |
//|                                 constraints                      |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     W   -   weights, array[0..N-1]                               |
//|             Each summand in square sum of approximation          |
//|             deviations from given values is multiplied by the    |
//|             square of corresponding weight. Fill it by 1's if    |
//|             you don't want to solve weighted task.               |
//|     N   -   number of points (optional):                         |
//|             * N>0                                                |
//|             * if given, only first N elements of X/Y/W are       |
//|               processed                                          |
//|             * if not given, automatically determined from X/Y/W  |
//|               sizes                                              |
//|     XC  -   points where spline values/derivatives are           |
//|             constrained, array[0..K-1].                          |
//|     YC  -   values of constraints, array[0..K-1]                 |
//|     DC  -   array[0..K-1], types of constraints:                 |
//|             * DC[i]=0   means that S(XC[i])=YC[i]                |
//|             * DC[i]=1   means that S'(XC[i])=YC[i]               |
//|             SEE BELOW FOR IMPORTANT INFORMATION ON CONSTRAINTS   |
//|     K   -   number of constraints (optional):                    |
//|             * 0<=K<M.                                            |
//|             * K=0 means no constraints (XC/YC/DC are not used)   |
//|             * if given, only first K elements of XC/YC/DC are    |
//|               used                                               |
//|             * if not given, automatically determined from        |
//|               XC/YC/DC                                           |
//|     M   -   number of basis functions (= 2 * number of nodes),   |
//|             M>=4,                                                |
//|             M IS EVEN!                                           |
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearW() subroutine:         |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                         -3 means inconsistent constraints        |
//|                         -2 means odd M was passed (which is not  |
//|                            supported)                            |
//|                         -1 means another errors in parameters    |
//|                            passed (N<=0, for example)            |
//|     S   -   spline interpolant.                                  |
//|     Rep -   report, same format as in LSFitLinearW() subroutine. |
//|             Following fields are set:                            |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//| IMPORTANT:                                                       |
//|     this subroitine supports only even M's                       |
//| ORDER OF POINTS                                                  |
//| ubroutine automatically sorts points, so caller may pass         |
//| unsorted array.                                                  |
//| SETTING CONSTRAINTS - DANGERS AND OPPORTUNITIES:                 |
//| Setting constraints can lead to undesired results, like          |
//| ill-conditioned behavior, or inconsistency being detected. From  |
//| the other side, it allows us to improve quality of the fit. Here |
//| we summarize our experience  with constrained regression splines:|
//| * excessive constraints can be inconsistent. Splines are         |
//|   piecewise cubic functions, and it is easy to create an example,|
//|   where large number of constraints concentrated in small area   |
//|   will result in inconsistency. Just because spline is not       |
//|   flexible enough to satisfy all of them. And same constraints   |
//|   spread across the [min(x),max(x)] will be perfectly consistent.|
//| * the more evenly constraints are spread across [min(x),max(x)], |
//|   the more chances that they will be consistent                  |
//| * the greater is M (given  fixed  constraints), the more chances |
//|   that constraints will be consistent                            |
//| * in the general case, consistency of constraints is NOT         |
//|   GUARANTEED.                                                    |
//| * in the several special cases, however, we can guarantee        |
//|   consistency.                                                   |
//| * one of this cases is M>=4 and constraints on the function      |
//|   value (AND/OR its derivative) at the interval boundaries.      |
//| * another special case is M>=4 and ONE constraint on the         |
//|   function value (OR, BUT NOT AND, derivative) anywhere in       |
//|   [min(x),max(x)]                                                |
//| Our final recommendation is to use constraints WHEN AND ONLY when|
//| you can't solve your task without them. Anything beyond  special |
//| cases given above is not guaranteed and may result in            |
//| inconsistency.                                                   |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitHermiteWC(double &x[],double &y[],double &w[],
                                   const int n,double &xc[],double &yc[],
                                   int &dc[],const int k,const int m,
                                   int &info,CSpline1DInterpolantShell &s,
                                   CSpline1DFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::Spline1DFitHermiteWC(x,y,w,n,xc,yc,dc,k,m,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted fitting by Hermite spline, with constraints on function |
//| values or first derivatives.                                     |
//| Equidistant grid with M nodes on [min(x,xc),max(x,xc)] is used to|
//| build basis functions. Basis functions are Hermite splines. Small|
//| regularizing term is used when solving constrained tasks (to     |
//| improve stability).                                              |
//| Task is linear, so linear least squares solver is used.          |
//| Complexity of this computational scheme is O(N*M^2), mostly      |
//| dominated by least squares solver                                |
//| SEE ALSO                                                         |
//|     Spline1DFitCubicWC()    -   fitting by Cubic splines (less   |
//|                                 flexible, more smooth)           |
//|     Spline1DFitHermite()   -  "lightweight" Hermite fitting,   |
//|                                 without invididual weights and   |
//|                                 constraints                      |
//| INPUT PARAMETERS:                                                |
//|     X   -   points, array[0..N-1].                               |
//|     Y   -   function values, array[0..N-1].                      |
//|     W   -   weights, array[0..N-1]                               |
//|             Each summand in square sum of approximation          |
//|             deviations from given values is multiplied by the    |
//|             square of corresponding weight. Fill it by 1's if    |
//|             you don't want to solve weighted task.               |
//|     N   -   number of points (optional):                         |
//|             * N>0                                                |
//|             * if given, only first N elements of X/Y/W are       |
//|               processed                                          |
//|             * if not given, automatically determined from X/Y/W  |
//|               sizes                                              |
//|     XC  -   points where spline values/derivatives are           |
//|             constrained, array[0..K-1].                          |
//|     YC  -   values of constraints, array[0..K-1]                 |
//|     DC  -   array[0..K-1], types of constraints:                 |
//|             * DC[i]=0   means that S(XC[i])=YC[i]                |
//|             * DC[i]=1   means that S'(XC[i])=YC[i]               |
//|             SEE BELOW FOR IMPORTANT INFORMATION ON CONSTRAINTS   |
//|     K   -   number of constraints (optional):                    |
//|             * 0<=K<M.                                            |
//|             * K=0 means no constraints (XC/YC/DC are not used)   |
//|             * if given, only first K elements of XC/YC/DC are    |
//|               used                                               |
//|             * if not given, automatically determined from        |
//|               XC/YC/DC                                           |
//|     M   -   number of basis functions (= 2 * number of nodes),   |
//|             M>=4,                                                |
//|             M IS EVEN!                                           |
//| OUTPUT PARAMETERS:                                               |
//|     Info-   same format as in LSFitLinearW() subroutine:         |
//|             * Info>0    task is solved                           |
//|             * Info<=0   an error occured:                        |
//|                         -4 means inconvergence of internal SVD   |
//|                         -3 means inconsistent constraints        |
//|                         -2 means odd M was passed (which is not  |
//|                            supported)                            |
//|                         -1 means another errors in parameters    |
//|                            passed (N<=0, for example)            |
//|     S   -   spline interpolant.                                  |
//|     Rep -   report, same format as in LSFitLinearW() subroutine. |
//|             Following fields are set:                            |
//|             * RMSError      rms error on the (X,Y).              |
//|             * AvgError      average error on the (X,Y).          |
//|             * AvgRelError   average relative error on the        |
//|                             non-zero Y                           |
//|             * MaxError      maximum error                        |
//|                             NON-WEIGHTED ERRORS ARE CALCULATED   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//| IMPORTANT:                                                       |
//|     this subroitine supports only even M's                       |
//| ORDER OF POINTS                                                  |
//| ubroutine automatically sorts points, so caller may pass         |
//| unsorted array.                                                  |
//| SETTING CONSTRAINTS - DANGERS AND OPPORTUNITIES:                 |
//| Setting constraints can lead to undesired results, like          |
//| ill-conditioned behavior, or inconsistency being detected. From  |
//| the other side, it allows us to improve quality of the fit. Here |
//| we summarize our experience  with constrained regression splines:|
//| * excessive constraints can be inconsistent. Splines are         |
//|   piecewise cubic functions, and it is easy to create an example,|
//|   where large number of constraints concentrated in small area   |
//|   will result in inconsistency. Just because spline is not       |
//|   flexible enough to satisfy all of them. And same constraints   |
//|   spread across the [min(x),max(x)] will be perfectly consistent.|
//| * the more evenly constraints are spread across [min(x),max(x)], |
//|   the more chances that they will be consistent                  |
//| * the greater is M (given  fixed  constraints), the more chances |
//|   that constraints will be consistent                            |
//| * in the general case, consistency of constraints is NOT         |
//|   GUARANTEED.                                                    |
//| * in the several special cases, however, we can guarantee        |
//|   consistency.                                                   |
//| * one of this cases is M>=4 and constraints on the function      |
//|   value (AND/OR its derivative) at the interval boundaries.      |
//| * another special case is M>=4 and ONE constraint on the         |
//|   function value (OR, BUT NOT AND, derivative) anywhere in       |
//|   [min(x),max(x)]                                                |
//| Our final recommendation is to use constraints WHEN AND ONLY when|
//| you can't solve your task without them. Anything beyond  special |
//| cases given above is not guaranteed and may result in            |
//| inconsistency.                                                   |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitHermiteWC(double &x[],double &y[],double &w[],
                                   double &xc[],double &yc[],int &dc[],
                                   const int m,int &info,
                                   CSpline1DInterpolantShell &s,
                                   CSpline1DFitReportShell &rep)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)) || (CAp::Len(x)!=CAp::Len(w)))
     {
      Print("Error while calling 'spline1dfithermitewc': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
   if((CAp::Len(xc)!=CAp::Len(yc)) || (CAp::Len(xc)!=CAp::Len(dc)))
     {
      Print("Error while calling 'spline1dfithermitewc': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=CAp::Len(x);
   int k=CAp::Len(xc);
//--- function call
   CLSFit::Spline1DFitHermiteWC(x,y,w,n,xc,yc,dc,k,m,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Least squares fitting by cubic spline.                           |
//| This subroutine is "lightweight" alternative for more complex    |
//| and feature - rich Spline1DFitCubicWC(). See Spline1DFitCubicWC()|
//| for more information about subroutine parameters (we don't       |
//| duplicate it here because of length)                             |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitCubic(double &x[],double &y[],const int n,
                               const int m,int &info,
                               CSpline1DInterpolantShell &s,
                               CSpline1DFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::Spline1DFitCubic(x,y,n,m,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Least squares fitting by cubic spline.                           |
//| This subroutine is "lightweight" alternative for more complex    |
//| and feature - rich Spline1DFitCubicWC(). See Spline1DFitCubicWC()|
//| for more information about subroutine parameters (we don't       |
//| duplicate it here because of length)                             |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitCubic(double &x[],double &y[],const int m,
                               int &info,CSpline1DInterpolantShell &s,
                               CSpline1DFitReportShell &rep)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dfitcubic': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=CAp::Len(x);
//--- function call
   CLSFit::Spline1DFitCubic(x,y,n,m,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Least squares fitting by Hermite spline.                         |
//| This subroutine is "lightweight" alternative for more complex    |
//| and feature - rich Spline1DFitHermiteWC(). See                   |
//| Spline1DFitHermiteWC() description for more information about    |
//| subroutine parameters (we don't duplicate it here because of     |
//| length).                                                         |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitHermite(double &x[],double &y[],const int n,
                                 const int m,int &info,
                                 CSpline1DInterpolantShell &s,
                                 CSpline1DFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::Spline1DFitHermite(x,y,n,m,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Least squares fitting by Hermite spline.                         |
//| This subroutine is "lightweight" alternative for more complex    |
//| and feature - rich Spline1DFitHermiteWC(). See                   |
//| Spline1DFitHermiteWC() description for more information about    |
//| subroutine parameters (we don't duplicate it here because of     |
//| length).                                                         |
//+------------------------------------------------------------------+
void CAlglib::Spline1DFitHermite(double &x[],double &y[],const int m,
                                 int &info,CSpline1DInterpolantShell &s,
                                 CSpline1DFitReportShell &rep)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'spline1dfithermite': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=CAp::Len(x);
//--- function call
   CLSFit::Spline1DFitHermite(x,y,n,m,info,s.GetInnerObj(),rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted linear least squares fitting.                           |
//| QR decomposition is used to reduce task to MxM, then triangular  |
//| solver or SVD-based solver is used depending on condition number |
//| of the system. It allows to maximize speed and retain decent     |
//| accuracy.                                                        |
//| INPUT PARAMETERS:                                                |
//|     Y       -   array[0..N-1] Function values in N points.       |
//|     W       -   array[0..N-1] Weights corresponding to function  |
//|                 values. Each summand in square sum of            |
//|                 approximation deviations from given values is    |
//|                 multiplied by the square of corresponding weight.|
//|     FMatrix -   a table of basis functions values,               |
//|                 array[0..N-1, 0..M-1]. FMatrix[I, J] - value of  |
//|                 J-th basis function in I-th point.               |
//|     N       -   number of points used. N>=1.                     |
//|     M       -   number of basis functions, M>=1.                 |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   error code:                                      |
//|                 * -4    internal SVD decomposition subroutine    |
//|                         failed (very rare and for degenerate     |
//|                         systems only)                            |
//|                 * -1    incorrect N/M were specified             |
//|                 *  1    task is solved                           |
//|     C       -   decomposition coefficients, array[0..M-1]        |
//|     Rep     -   fitting report. Following fields are set:        |
//|                 * Rep.TaskRCond     reciprocal of condition      |
//|                                     number                       |
//|                 * RMSError          rms error on the (X,Y).      |
//|                 * AvgError          average error on the (X,Y).  |
//|                 * AvgRelError       average relative error on the|
//|                                     non-zero Y                   |
//|                 * MaxError          maximum error                |
//|                                     NON-WEIGHTED ERRORS ARE      |
//|                                     CALCULATED                   |
//+------------------------------------------------------------------+
void CAlglib::LSFitLinearW(double &y[],double &w[],CMatrixDouble &fmatrix,
                           const int n,const int m,int &info,
                           double &c[],CLSFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::LSFitLinearW(y,w,fmatrix,n,m,info,c,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted linear least squares fitting.                           |
//| QR decomposition is used to reduce task to MxM, then triangular  |
//| solver or SVD-based solver is used depending on condition number |
//| of the system. It allows to maximize speed and retain decent     |
//| accuracy.                                                        |
//| INPUT PARAMETERS:                                                |
//|     Y       -   array[0..N-1] Function values in N points.       |
//|     W       -   array[0..N-1] Weights corresponding to function  |
//|                 values. Each summand in square sum of            |
//|                 approximation deviations from given values is    |
//|                 multiplied by the square of corresponding weight.|
//|     FMatrix -   a table of basis functions values,               |
//|                 array[0..N-1, 0..M-1]. FMatrix[I, J] - value of  |
//|                 J-th basis function in I-th point.               |
//|     N       -   number of points used. N>=1.                     |
//|     M       -   number of basis functions, M>=1.                 |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   error code:                                      |
//|                 * -4    internal SVD decomposition subroutine    |
//|                         failed (very rare and for degenerate     |
//|                         systems only)                            |
//|                 * -1    incorrect N/M were specified             |
//|                 *  1    task is solved                           |
//|     C       -   decomposition coefficients, array[0..M-1]        |
//|     Rep     -   fitting report. Following fields are set:        |
//|                 * Rep.TaskRCond     reciprocal of condition      |
//|                                     number                       |
//|                 * RMSError          rms error on the (X,Y).      |
//|                 * AvgError          average error on the (X,Y).  |
//|                 * AvgRelError       average relative error on the|
//|                                     non-zero Y                   |
//|                 * MaxError          maximum error                |
//|                                     NON-WEIGHTED ERRORS ARE      |
//|                                     CALCULATED                   |
//+------------------------------------------------------------------+
void CAlglib::LSFitLinearW(double &y[],double &w[],CMatrixDouble &fmatrix,
                           int &info,double &c[],CLSFitReportShell &rep)
  {
//--- check
   if((CAp::Len(y)!=CAp::Len(w)) || (CAp::Len(y)!=CAp::Rows(fmatrix)))
     {
      Print("Error while calling 'lsfitlinearw': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=CAp::Len(y);
   int m=(int)CAp::Cols(fmatrix);
//--- function call
   CLSFit::LSFitLinearW(y,w,fmatrix,n,m,info,c,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted constained linear least squares fitting.                |
//| This is variation of LSFitLinearW(), which searchs for           |
//| min|A*x=b| given that K additional constaints C*x=bc are         |
//| satisfied. It reduces original task to modified one: min|B*y-d|  |
//| WITHOUT constraints, then LSFitLinearW() is called.              |
//| INPUT PARAMETERS:                                                |
//|     Y       -   array[0..N-1] Function values in  N  points.     |
//|     W       -   array[0..N-1] Weights corresponding to function  |
//|                 values. Each summand in square sum of            |
//|                 approximation deviations from given values is    |
//|                 multiplied by the square of corresponding        |
//|                 weight.                                          |
//|     FMatrix -   a table of basis functions values,               |
//|                 array[0..N-1,0..M-1]. FMatrix[I,J] - value of    |
//|                 J-th basis function in I-th point.               |
//|     CMatrix -   a table of constaints, array[0..K-1,0..M].       |
//|                 I-th row of CMatrix corresponds to I-th linear   |
//|                 constraint: CMatrix[I,0]*C[0] + ... +            |
//|                 + CMatrix[I,M-1]*C[M-1] = CMatrix[I,M]           |
//|     N       -   number of points used. N>=1.                     |
//|     M       -   number of basis functions, M>=1.                 |
//|     K       -   number of constraints, 0 <= K < M                |
//|                 K=0 corresponds to absence of constraints.       |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   error code:                                      |
//|                 * -4    internal SVD decomposition subroutine    |
//|                         failed (very rare and for degenerate     |
//|                         systems only)                            |
//|                 * -3    either too many constraints (M or more), |
//|                         degenerate constraints (some constraints |
//|                         are repetead twice) or inconsistent      |
//|                         constraints were specified.              |
//|                 *  1    task is solved                           |
//|     C       -   decomposition coefficients, array[0..M-1]        |
//|     Rep     -   fitting report. Following fields are set:        |
//|                 * RMSError          rms error on the (X,Y).      |
//|                 * AvgError          average error on the (X,Y).  |
//|                 * AvgRelError       average relative error on the|
//|                                     non-zero Y                   |
//|                 * MaxError          maximum error                |
//|                                     NON-WEIGHTED ERRORS ARE      |
//|                                     CALCULATED                   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//+------------------------------------------------------------------+
void CAlglib::LSFitLinearWC(double &y[],double &w[],CMatrixDouble &fmatrix,
                            CMatrixDouble &cmatrix,const int n,
                            const int m,const int k,int &info,
                            double &c[],CLSFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::LSFitLinearWC(y,w,fmatrix,cmatrix,n,m,k,info,c,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted constained linear least squares fitting.                |
//| This is variation of LSFitLinearW(), which searchs for           |
//| min|A*x=b| given that K additional constaints C*x=bc are         |
//| satisfied. It reduces original task to modified one: min|B*y-d|  |
//| WITHOUT constraints, then LSFitLinearW() is called.              |
//| INPUT PARAMETERS:                                                |
//|     Y       -   array[0..N-1] Function values in  N  points.     |
//|     W       -   array[0..N-1] Weights corresponding to function  |
//|                 values. Each summand in square sum of            |
//|                 approximation deviations from given values is    |
//|                 multiplied by the square of corresponding        |
//|                 weight.                                          |
//|     FMatrix -   a table of basis functions values,               |
//|                 array[0..N-1,0..M-1]. FMatrix[I,J] - value of    |
//|                 J-th basis function in I-th point.               |
//|     CMatrix -   a table of constaints, array[0..K-1,0..M].       |
//|                 I-th row of CMatrix corresponds to I-th linear   |
//|                 constraint: CMatrix[I,0]*C[0] + ... +            |
//|                 + CMatrix[I,M-1]*C[M-1] = CMatrix[I,M]           |
//|     N       -   number of points used. N>=1.                     |
//|     M       -   number of basis functions, M>=1.                 |
//|     K       -   number of constraints, 0 <= K < M                |
//|                 K=0 corresponds to absence of constraints.       |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   error code:                                      |
//|                 * -4    internal SVD decomposition subroutine    |
//|                         failed (very rare and for degenerate     |
//|                         systems only)                            |
//|                 * -3    either too many constraints (M or more), |
//|                         degenerate constraints (some constraints |
//|                         are repetead twice) or inconsistent      |
//|                         constraints were specified.              |
//|                 *  1    task is solved                           |
//|     C       -   decomposition coefficients, array[0..M-1]        |
//|     Rep     -   fitting report. Following fields are set:        |
//|                 * RMSError          rms error on the (X,Y).      |
//|                 * AvgError          average error on the (X,Y).  |
//|                 * AvgRelError       average relative error on the|
//|                                     non-zero Y                   |
//|                 * MaxError          maximum error                |
//|                                     NON-WEIGHTED ERRORS ARE      |
//|                                     CALCULATED                   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//+------------------------------------------------------------------+
void CAlglib::LSFitLinearWC(double &y[],double &w[],CMatrixDouble &fmatrix,
                            CMatrixDouble &cmatrix,int &info,
                            double &c[],CLSFitReportShell &rep)
  {
//--- check
   if((CAp::Len(y)!=CAp::Len(w)) || (CAp::Len(y)!=CAp::Rows(fmatrix)))
     {
      Print("Error while calling 'lsfitlinearwc': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
   if((CAp::Cols(fmatrix)!=CAp::Cols(cmatrix)-1))
     {
      Print("Error while calling 'lsfitlinearwc': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=CAp::Len(y);
   int m=(int)CAp::Cols(fmatrix);
   int k=(int)CAp::Rows(cmatrix);
//--- function call
   CLSFit::LSFitLinearWC(y,w,fmatrix,cmatrix,n,m,k,info,c,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Linear least squares fitting.                                    |
//| QR decomposition is used to reduce task to MxM, then triangular  |
//| solver or SVD-based solver is used depending on condition number |
//| of the system. It allows to maximize speed and retain decent     |
//| accuracy.                                                        |
//| INPUT PARAMETERS:                                                |
//|     Y       -   array[0..N-1] Function values in  N  points.     |
//|     FMatrix -   a table of basis functions values,               |
//|                 array[0..N-1, 0..M-1].                           |
//|                 FMatrix[I, J] - value of J-th basis function in  |
//|                 I-th point.                                      |
//|     N       -   number of points used. N>=1.                     |
//|     M       -   number of basis functions, M>=1.                 |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   error code:                                      |
//|                 * -4    internal SVD decomposition subroutine    |
//|                         failed (very rare and for degenerate     |
//|                         systems only)                            |
//|                 *  1    task is solved                           |
//|     C       -   decomposition coefficients, array[0..M-1]        |
//|     Rep     -   fitting report. Following fields are set:        |
//|                 * Rep.TaskRCond     reciprocal of condition      |
//|                                     number                       |
//|                 * RMSError          rms error on the (X,Y).      |
//|                 * AvgError          average error on the (X,Y).  |
//|                 * AvgRelError       average relative error on the|
//|                                     non-zero Y                   |
//|                 * MaxError          maximum error                |
//|                                     NON-WEIGHTED ERRORS ARE      |
//|                                     CALCULATED                   |
//+------------------------------------------------------------------+
void CAlglib::LSFitLinear(double &y[],CMatrixDouble &fmatrix,
                          const int n,const int m,int &info,
                          double &c[],CLSFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::LSFitLinear(y,fmatrix,n,m,info,c,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Linear least squares fitting.                                    |
//| QR decomposition is used to reduce task to MxM, then triangular  |
//| solver or SVD-based solver is used depending on condition number |
//| of the system. It allows to maximize speed and retain decent     |
//| accuracy.                                                        |
//| INPUT PARAMETERS:                                                |
//|     Y       -   array[0..N-1] Function values in  N  points.     |
//|     FMatrix -   a table of basis functions values,               |
//|                 array[0..N-1, 0..M-1].                           |
//|                 FMatrix[I, J] - value of J-th basis function in  |
//|                 I-th point.                                      |
//|     N       -   number of points used. N>=1.                     |
//|     M       -   number of basis functions, M>=1.                 |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   error code:                                      |
//|                 * -4    internal SVD decomposition subroutine    |
//|                         failed (very rare and for degenerate     |
//|                         systems only)                            |
//|                 *  1    task is solved                           |
//|     C       -   decomposition coefficients, array[0..M-1]        |
//|     Rep     -   fitting report. Following fields are set:        |
//|                 * Rep.TaskRCond     reciprocal of condition      |
//|                                     number                       |
//|                 * RMSError          rms error on the (X,Y).      |
//|                 * AvgError          average error on the (X,Y).  |
//|                 * AvgRelError       average relative error on the|
//|                                     non-zero Y                   |
//|                 * MaxError          maximum error                |
//|                                     NON-WEIGHTED ERRORS ARE      |
//|                                     CALCULATED                   |
//+------------------------------------------------------------------+
void CAlglib::LSFitLinear(double &y[],CMatrixDouble &fmatrix,
                          int &info,double &c[],CLSFitReportShell &rep)
  {
//--- check
   if((CAp::Len(y)!=CAp::Rows(fmatrix)))
     {
      Print("Error while calling 'lsfitlinear': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=CAp::Len(y);
   int m=(int)CAp::Cols(fmatrix);
//--- function call
   CLSFit::LSFitLinear(y,fmatrix,n,m,info,c,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Constained linear least squares fitting.                         |
//| This is variation of LSFitLinear(), which searchs for min|A*x=b| |
//| given that K additional constaints C*x=bc are satisfied. It      |
//| reduces original task to modified one: min|B*y-d| WITHOUT        |
//| constraints, then LSFitLinear() is called.                       |
//| INPUT PARAMETERS:                                                |
//|     Y       -   array[0..N-1] Function values in N points.       |
//|     FMatrix -   a table of basis functions values,               |
//|                 array[0..N-1,0..M-1]. FMatrix[I,J] - value of    |
//|                 J-th basis function in I-th point.               |
//|     CMatrix -   a table of constaints, array[0..K-1,0..M].       |
//|                 I-th row of CMatrix corresponds to I-th linear   |
//|                 constraint: CMatrix[I,0]*C[0] + ... +            |
//|                 + CMatrix[I,M-1]*C[M-1] = CMatrix[I,M]           |
//|     N       -   number of points used. N>=1.                     |
//|     M       -   number of basis functions, M>=1.                 |
//|     K       -   number of constraints, 0 <= K < M                |
//|                 K=0 corresponds to absence of constraints.       |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   error code:                                      |
//|                 * -4    internal SVD decomposition subroutine    |
//|                         failed (very rare and for degenerate     |
//|                         systems only)                            |
//|                 * -3    either too many constraints (M or more), |
//|                         degenerate constraints (some constraints |
//|                         are repetead twice) or inconsistent      |
//|                         constraints were specified.              |
//|                 *  1    task is solved                           |
//|     C       -   decomposition coefficients, array[0..M-1]        |
//|     Rep     -   fitting report. Following fields are set:        |
//|                 * RMSError          rms error on the (X,Y).      |
//|                 * AvgError          average error on the (X,Y).  |
//|                 * AvgRelError       average relative error on the|
//|                                     non-zero Y                   |
//|                 * MaxError          maximum error                |
//|                                     NON-WEIGHTED ERRORS ARE      |
//|                                     CALCULATED                   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//+------------------------------------------------------------------+
void CAlglib::LSFitLinearC(double &y[],CMatrixDouble &fmatrix,
                           CMatrixDouble &cmatrix,const int n,
                           const int m,const int k,int &info,
                           double &c[],CLSFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::LSFitLinearC(y,fmatrix,cmatrix,n,m,k,info,c,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Constained linear least squares fitting.                         |
//| This is variation of LSFitLinear(), which searchs for min|A*x=b| |
//| given that K additional constaints C*x=bc are satisfied. It      |
//| reduces original task to modified one: min|B*y-d| WITHOUT        |
//| constraints, then LSFitLinear() is called.                       |
//| INPUT PARAMETERS:                                                |
//|     Y       -   array[0..N-1] Function values in N points.       |
//|     FMatrix -   a table of basis functions values,               |
//|                 array[0..N-1,0..M-1]. FMatrix[I,J] - value of    |
//|                 J-th basis function in I-th point.               |
//|     CMatrix -   a table of constaints, array[0..K-1,0..M].       |
//|                 I-th row of CMatrix corresponds to I-th linear   |
//|                 constraint: CMatrix[I,0]*C[0] + ... +            |
//|                 + CMatrix[I,M-1]*C[M-1] = CMatrix[I,M]           |
//|     N       -   number of points used. N>=1.                     |
//|     M       -   number of basis functions, M>=1.                 |
//|     K       -   number of constraints, 0 <= K < M                |
//|                 K=0 corresponds to absence of constraints.       |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   error code:                                      |
//|                 * -4    internal SVD decomposition subroutine    |
//|                         failed (very rare and for degenerate     |
//|                         systems only)                            |
//|                 * -3    either too many constraints (M or more), |
//|                         degenerate constraints (some constraints |
//|                         are repetead twice) or inconsistent      |
//|                         constraints were specified.              |
//|                 *  1    task is solved                           |
//|     C       -   decomposition coefficients, array[0..M-1]        |
//|     Rep     -   fitting report. Following fields are set:        |
//|                 * RMSError          rms error on the (X,Y).      |
//|                 * AvgError          average error on the (X,Y).  |
//|                 * AvgRelError       average relative error on the|
//|                                     non-zero Y                   |
//|                 * MaxError          maximum error                |
//|                                     NON-WEIGHTED ERRORS ARE      |
//|                                     CALCULATED                   |
//| IMPORTANT:                                                       |
//|     this subroitine doesn't calculate task's condition number    |
//|     for K<>0.                                                    |
//+------------------------------------------------------------------+
void CAlglib::LSFitLinearC(double &y[],CMatrixDouble &fmatrix,
                           CMatrixDouble &cmatrix,int &info,
                           double &c[],CLSFitReportShell &rep)
  {
//--- check
   if((CAp::Len(y)!=CAp::Rows(fmatrix)))
     {
      Print("Error while calling 'lsfitlinearc': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
   if((CAp::Cols(fmatrix)!=CAp::Cols(cmatrix)-1))
     {
      Print("Error while calling 'lsfitlinearc': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=CAp::Len(y);
   int m=(int)CAp::Cols(fmatrix);
   int k=(int)CAp::Rows(cmatrix);
//--- function call
   CLSFit::LSFitLinearC(y,fmatrix,cmatrix,n,m,k,info,c,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted nonlinear least squares fitting using function values   |
//| only.                                                            |
//| Combination of numerical differentiation and secant updates is   |
//| used to obtain function Jacobian.                                |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = (w[0]*(f(c,x[0])-y[0]))^2 + ... +                     |
//|     + (w[n-1]*(f(c,x[n-1])-y[n-1]))^2,                           |
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * w is an N-dimensional vector of weight coefficients,       |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|       vector,                                                    |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses only f(c,x[i]).                             |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     W       -   weights, array[0..N-1]                           |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//|     DiffStep-   numerical differentiation step;                  |
//|                 should not be very small or large;               |
//|                 large = loss of accuracy                         |
//|                 small = growth of round-off errors               |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateWF(CMatrixDouble &x,double &y[],double &w[],
                            double &c[],const int n,const int m,
                            const int k,const double diffstep,
                            CLSFitStateShell &state)
  {
   CLSFit::LSFitCreateWF(x,y,w,c,n,m,k,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted nonlinear least squares fitting using function values   |
//| only.                                                            |
//| Combination of numerical differentiation and secant updates is   |
//| used to obtain function Jacobian.                                |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = (w[0]*(f(c,x[0])-y[0]))^2 + ... +                     |
//|     + (w[n-1]*(f(c,x[n-1])-y[n-1]))^2,                           |
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * w is an N-dimensional vector of weight coefficients,       |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|       vector,                                                    |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses only f(c,x[i]).                             |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     W       -   weights, array[0..N-1]                           |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//|     DiffStep-   numerical differentiation step;                  |
//|                 should not be very small or large;               |
//|                 large = loss of accuracy                         |
//|                 small = growth of round-off errors               |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateWF(CMatrixDouble &x,double &y[],double &w[],
                            double &c[],const double diffstep,
                            CLSFitStateShell &state)
  {
//--- check
   if((CAp::Rows(x)!=CAp::Len(y)) || (CAp::Rows(x)!=CAp::Len(w)))
     {
      Print("Error while calling 'lsfitcreatewf': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=(int)CAp::Rows(x);
   int m=(int)CAp::Cols(x);
   int k=CAp::Len(c);
//--- function call
   CLSFit::LSFitCreateWF(x,y,w,c,n,m,k,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Nonlinear least squares fitting using function values only.      |
//| Combination of numerical differentiation and secant updates is   |
//| used to obtain function Jacobian.                                |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = (f(c,x[0])-y[0])^2 + ... + (f(c,x[n-1])-y[n-1])^2,    |
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * w is an N-dimensional vector of weight coefficients,       |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|       vector,                                                    |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses only f(c,x[i]).                             |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//|     DiffStep-   numerical differentiation step;                  |
//|                 should not be very small or large;               |
//|                 large = loss of accuracy                         |
//|                 small = growth of round-off errors               |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateF(CMatrixDouble &x,double &y[],double &c[],
                           const int n,const int m,const int k,
                           const double diffstep,CLSFitStateShell &state)
  {
   CLSFit::LSFitCreateF(x,y,c,n,m,k,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Nonlinear least squares fitting using function values only.      |
//| Combination of numerical differentiation and secant updates is   |
//| used to obtain function Jacobian.                                |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = (f(c,x[0])-y[0])^2 + ... + (f(c,x[n-1])-y[n-1])^2,    |
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * w is an N-dimensional vector of weight coefficients,       |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|       vector,                                                    |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses only f(c,x[i]).                             |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//|     DiffStep-   numerical differentiation step;                  |
//|                 should not be very small or large;               |
//|                 large = loss of accuracy                         |
//|                 small = growth of round-off errors               |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateF(CMatrixDouble &x,double &y[],double &c[],
                           const double diffstep,CLSFitStateShell &state)
  {
//--- check
   if((CAp::Rows(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'lsfitcreatef': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=(int)CAp::Rows(x);
   int m=(int)CAp::Cols(x);
   int k=CAp::Len(c);
//--- function call
   CLSFit::LSFitCreateF(x,y,c,n,m,k,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted nonlinear least squares fitting using gradient only.    |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = (w[0]*(f(c,x[0])-y[0]))^2 + ... +                     |
//|     + (w[n-1]*(f(c,x[n-1])-y[n-1]))^2,                           |
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * w is an N-dimensional vector of weight coefficients,       |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|       vector,                                                    |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses only f(c,x[i]) and its gradient.            |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     W       -   weights, array[0..N-1]                           |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//|     CheapFG -   boolean flag, which is:                          |
//|                 * True if both function and gradient calculation |
//|                        complexity are less than O(M^2). An       |
//|                        improved algorithm can be used which      |
//|                        corresponds to FGJ scheme from MINLM unit.|
//|                 * False otherwise.                               |
//|                        Standard Jacibian-bases                   |
//|                        Levenberg-Marquardt algo will be used (FJ |
//|                        scheme).                                  |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| See also:                                                        |
//|     LSFitResults                                                 |
//|     LSFitCreateFG (fitting without weights)                      |
//|     LSFitCreateWFGH (fitting using Hessian)                      |
//|     LSFitCreateFGH (fitting using Hessian, without weights)      |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateWFG(CMatrixDouble &x,double &y[],double &w[],
                             double &c[],const int n,const int m,
                             const int k,const bool cheapfg,
                             CLSFitStateShell &state)
  {
   CLSFit::LSFitCreateWFG(x,y,w,c,n,m,k,cheapfg,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted nonlinear least squares fitting using gradient only.    |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = (w[0]*(f(c,x[0])-y[0]))^2 + ... +                     |
//|     + (w[n-1]*(f(c,x[n-1])-y[n-1]))^2,                           |
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * w is an N-dimensional vector of weight coefficients,       |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|       vector,                                                    |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses only f(c,x[i]) and its gradient.            |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     W       -   weights, array[0..N-1]                           |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//|     CheapFG -   boolean flag, which is:                          |
//|                 * True if both function and gradient calculation |
//|                        complexity are less than O(M^2). An       |
//|                        improved algorithm can be used which      |
//|                        corresponds to FGJ scheme from MINLM unit.|
//|                 * False otherwise.                               |
//|                        Standard Jacibian-bases                   |
//|                        Levenberg-Marquardt algo will be used (FJ |
//|                        scheme).                                  |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| See also:                                                        |
//|     LSFitResults                                                 |
//|     LSFitCreateFG (fitting without weights)                      |
//|     LSFitCreateWFGH (fitting using Hessian)                      |
//|     LSFitCreateFGH (fitting using Hessian, without weights)      |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateWFG(CMatrixDouble &x,double &y[],double &w[],
                             double &c[],const bool cheapfg,
                             CLSFitStateShell &state)
  {
//--- check
   if((CAp::Rows(x)!=CAp::Len(y)) || (CAp::Rows(x)!=CAp::Len(w)))
     {
      Print("Error while calling 'lsfitcreatewfg': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=(int)CAp::Rows(x);
   int m=(int)CAp::Cols(x);
   int k=CAp::Len(c);
//--- function call
   CLSFit::LSFitCreateWFG(x,y,w,c,n,m,k,cheapfg,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Nonlinear least squares fitting using gradient only, without     |
//| individual weights.                                              |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = ((f(c,x[0])-y[0]))^2 + ... + ((f(c,x[n-1])-y[n-1]))^2,|
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|       vector,                                                    |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses only f(c,x[i]) and its gradient.            |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//|     CheapFG -   boolean flag, which is:                          |
//|                 * True  if both function and gradient calculation|
//|                         complexity are less than O(M^2). An      |
//|                         improved algorithm can be used which     |
//|                         corresponds to FGJ scheme from MINLM     |
//|                         unit.                                    |
//|                 * False otherwise.                               |
//|                         Standard Jacibian-bases                  |
//|                         Levenberg-Marquardt algo will be used    |
//|                         (FJ scheme).                             |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateFG(CMatrixDouble &x,double &y[],double &c[],
                            const int n,const int m,const int k,
                            const bool cheapfg,CLSFitStateShell &state)
  {
   CLSFit::LSFitCreateFG(x,y,c,n,m,k,cheapfg,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Nonlinear least squares fitting using gradient only, without     |
//| individual weights.                                              |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = ((f(c,x[0])-y[0]))^2 + ... + ((f(c,x[n-1])-y[n-1]))^2,|
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|       vector,                                                    |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses only f(c,x[i]) and its gradient.            |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//|     CheapFG -   boolean flag, which is:                          |
//|                 * True  if both function and gradient calculation|
//|                         complexity are less than O(M^2). An      |
//|                         improved algorithm can be used which     |
//|                         corresponds to FGJ scheme from MINLM     |
//|                         unit.                                    |
//|                 * False otherwise.                               |
//|                         Standard Jacibian-bases                  |
//|                         Levenberg-Marquardt algo will be used    |
//|                         (FJ scheme).                             |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateFG(CMatrixDouble &x,double &y[],double &c[],
                            const bool cheapfg,CLSFitStateShell &state)
  {
//--- check
   if((CAp::Rows(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'lsfitcreatefg': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=(int)CAp::Rows(x);
   int m=(int)CAp::Cols(x);
   int k=CAp::Len(c);
//--- function call
   CLSFit::LSFitCreateFG(x,y,c,n,m,k,cheapfg,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted nonlinear least squares fitting using gradient/Hessian. |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = (w[0]*(f(c,x[0])-y[0]))^2 + ... +                     |
//|     (w[n-1]*(f(c,x[n-1])-y[n-1]))^2,                             |
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * w is an N-dimensional vector of weight coefficients,       |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|     vector,                                                      |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses f(c,x[i]), its gradient and its Hessian.    |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     W       -   weights, array[0..N-1]                           |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateWFGH(CMatrixDouble &x,double &y[],double &w[],
                              double &c[],const int n,const int m,
                              const int k,CLSFitStateShell &state)
  {
   CLSFit::LSFitCreateWFGH(x,y,w,c,n,m,k,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Weighted nonlinear least squares fitting using gradient/Hessian. |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = (w[0]*(f(c,x[0])-y[0]))^2 + ... +                     |
//|     (w[n-1]*(f(c,x[n-1])-y[n-1]))^2,                             |
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * w is an N-dimensional vector of weight coefficients,       |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|     vector,                                                      |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses f(c,x[i]), its gradient and its Hessian.    |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     W       -   weights, array[0..N-1]                           |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateWFGH(CMatrixDouble &x,double &y[],double &w[],
                              double &c[],CLSFitStateShell &state)
  {
//--- check
   if((CAp::Rows(x)!=CAp::Len(y)) || (CAp::Rows(x)!=CAp::Len(w)))
     {
      Print("Error while calling 'lsfitcreatewfgh': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=(int)CAp::Rows(x);
   int m=(int)CAp::Cols(x);
   int k=CAp::Len(c);
//--- function call
   CLSFit::LSFitCreateWFGH(x,y,w,c,n,m,k,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Nonlinear least squares fitting using gradient/Hessian, without  |
//| individial weights.                                              |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = ((f(c,x[0])-y[0]))^2 + ... +                          |
//|     ((f(c,x[n-1])-y[n-1]))^2,                                    |
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|       vector,                                                    |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses f(c,x[i]), its gradient and its Hessian.    |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateFGH(CMatrixDouble &x,double &y[],double &c[],
                             const int n,const int m,const int k,
                             CLSFitStateShell &state)
  {
   CLSFit::LSFitCreateFGH(x,y,c,n,m,k,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Nonlinear least squares fitting using gradient/Hessian, without  |
//| individial weights.                                              |
//| Nonlinear task min(F(c)) is solved, where                        |
//|     F(c) = ((f(c,x[0])-y[0]))^2 + ... +                          |
//|     ((f(c,x[n-1])-y[n-1]))^2,                                    |
//|     * N is a number of points,                                   |
//|     * M is a dimension of a space points belong to,              |
//|     * K is a dimension of a space of parameters being fitted,    |
//|     * x is a set of N points, each of them is an M-dimensional   |
//|       vector,                                                    |
//|     * c is a K-dimensional vector of parameters being fitted     |
//| This subroutine uses f(c,x[i]), its gradient and its Hessian.    |
//| INPUT PARAMETERS:                                                |
//|     X       -   array[0..N-1,0..M-1], points (one row = one      |
//|                 point)                                           |
//|     Y       -   array[0..N-1], function values.                  |
//|     C       -   array[0..K-1], initial approximation to the      |
//|                 solution,                                        |
//|     N       -   number of points, N>1                            |
//|     M       -   dimension of space                               |
//|     K       -   number of parameters being fitted                |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::LSFitCreateFGH(CMatrixDouble &x,double &y[],double &c[],
                             CLSFitStateShell &state)
  {
//--- check
   if((CAp::Rows(x)!=CAp::Len(y)))
     {
      Print("Error while calling 'lsfitcreatefgh': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=(int)CAp::Rows(x);
   int m=(int)CAp::Cols(x);
   int k=CAp::Len(c);
//--- function call
   CLSFit::LSFitCreateFGH(x,y,c,n,m,k,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Stopping conditions for nonlinear least squares fitting.         |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     EpsF    -   stopping criterion. Algorithm stops if           |
//|                 |F(k+1)-F(k)| <= EpsF*max{|F(k)|, |F(k+1)|, 1}   |
//|     EpsX    -   >=0                                              |
//|                 The subroutine finishes its work if on k+1-th    |
//|                 iteration the condition |v|<=EpsX is fulfilled,  |
//|                 where:                                           |
//|                 * |.| means Euclidian norm                       |
//|                 * v - scaled step vector, v[i]=dx[i]/s[i]        |
//|                 * dx - ste pvector, dx=X(k+1)-X(k)               |
//|                 * s - scaling coefficients set by LSFitSetScale()|
//|     MaxIts  -   maximum number of iterations. If MaxIts=0, the   |
//|                 number of iterations is unlimited. Only          |
//|                 Levenberg-Marquardt iterations are counted       |
//|                 (L-BFGS/CG iterations are NOT counted because    |
//|                 their cost is very low compared to that of LM).  |
//| NOTE                                                             |
//| Passing EpsF=0, EpsX=0 and MaxIts=0 (simultaneously) will lead to|
//| automatic stopping criterion selection (according to the scheme  |
//| used by MINLM unit).                                             |
//+------------------------------------------------------------------+
void CAlglib::LSFitSetCond(CLSFitStateShell &state,
                           const double epsx,const int maxits)
  {
   CLSFit::LSFitSetCond(state.GetInnerObj(),epsx,maxits);
  }
//+------------------------------------------------------------------+
//| This function sets maximum step length                           |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     StpMax  -   maximum step length, >=0. Set StpMax to 0.0, if  |
//|                 you don't want to limit step length.             |
//| Use this subroutine when you optimize target function which      |
//| contains exp() or other fast growing functions, and optimization |
//| algorithm makes too large steps which leads to overflow. This    |
//| function allows us to reject steps that are too large (and       |
//| therefore expose us to the possible overflow) without actually   |
//| calculating function value at the x+stp*d.                       |
//| NOTE: non-zero StpMax leads to moderate performance degradation  |
//| because intermediate step of preconditioned L-BFGS optimization  |
//| is incompatible with limits on step size.                        |
//+------------------------------------------------------------------+
void CAlglib::LSFitSetStpMax(CLSFitStateShell &state,const double stpmax)
  {
   CLSFit::LSFitSetStpMax(state.GetInnerObj(),stpmax);
  }
//+------------------------------------------------------------------+
//| This function turns on/off reporting.                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     NeedXRep-   whether iteration reports are needed or not      |
//| When reports are needed, State.C (current parameters) and State. |
//| F (current value of fitting function) are reported.              |
//+------------------------------------------------------------------+
void CAlglib::LSFitSetXRep(CLSFitStateShell &state,const bool needxrep)
  {
   CLSFit::LSFitSetXRep(state.GetInnerObj(),needxrep);
  }
//+------------------------------------------------------------------+
//| This function sets scaling coefficients for underlying optimizer.|
//| ALGLIB optimizers use scaling matrices to test stopping          |
//| conditions (step size and gradient are scaled before comparison  |
//| with tolerances). Scale of the I-th variable is a translation    |
//| invariant measure of:                                            |
//| a) "how large" the variable is                                   |
//| b) how large the step should be to make significant changes in   |
//| the function                                                     |
//| Generally, scale is NOT considered to be a form of               |
//| preconditioner. But LM optimizer is unique in that it uses       |
//| scaling matrix both in the stopping condition tests and as       |
//| Marquardt damping factor.                                        |
//| Proper scaling is very important for the algorithm performance.  |
//| It is less important for the quality of results, but still has   |
//| some influence (it is easier to converge when variables are      |
//| properly scaled, so premature stopping is possible when very     |
//| badly scalled variables are combined with relaxed stopping       |
//| conditions).                                                     |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure stores algorithm state                 |
//|     S       -   array[N], non-zero scaling coefficients          |
//|                 S[i] may be negative, sign doesn't matter.       |
//+------------------------------------------------------------------+
void CAlglib::LSFitSetScale(CLSFitStateShell &state,double &s[])
  {
   CLSFit::LSFitSetScale(state.GetInnerObj(),s);
  }
//+------------------------------------------------------------------+
//| This function sets boundary constraints for underlying optimizer |
//| Boundary constraints are inactive by default (after initial      |
//| creation). They are preserved until explicitly turned off with   |
//| another SetBC() call.                                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure stores algorithm state                 |
//|     BndL    -   lower bounds, array[K].                          |
//|                 If some (all) variables are unbounded, you may   |
//|                 specify very small number or -INF (latter is     |
//|                 recommended because it will allow solver to use  |
//|                 better algorithm).                               |
//|     BndU    -   upper bounds, array[K].                          |
//|                 If some (all) variables are unbounded, you may   |
//|                 specify very large number or +INF (latter is     |
//|                 recommended because it will allow solver to use  |
//|                 better algorithm).                               |
//| NOTE 1: it is possible to specify BndL[i]=BndU[i]. In this case  |
//| I-th variable will be "frozen" at X[i]=BndL[i]=BndU[i].          |
//| NOTE 2: unlike other constrained optimization algorithms, this   |
//| solver has following useful properties:                          |
//| * bound constraints are always satisfied exactly                 |
//| * function is evaluated only INSIDE area specified by bound      |
//|   constraints                                                    |
//+------------------------------------------------------------------+
void CAlglib::LSFitSetBC(CLSFitStateShell &state,double &bndl[],
                         double &bndu[])
  {
   CLSFit::LSFitSetBC(state.GetInnerObj(),bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function provides reverse communication interface           |
//| Reverse communication interface is not documented or recommended |
//| to use.                                                          |
//| See below for functions which provide better documented API      |
//+------------------------------------------------------------------+
bool CAlglib::LSFitIteration(CLSFitStateShell &state)
  {
   return(CLSFit::LSFitIteration(state.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear fitter                                                 |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     hess    -   callback which calculates function (or merit     |
//|                 function) value func, gradient grad and Hessian  |
//|                 hess at given point x                            |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. this algorithm is somewhat unusual because it works with      |
//|    parameterized function f(C,X), where X is a function argument |
//|    (we have many points which are characterized by different     |
//|    argument values), and C is a parameter to fit.                |
//|    For example, if we want to do linear fit by                   |
//|    f(c0,c1,x)=c0*x+c1, then x will be argument, and {c0,c1} will |
//|    be parameters.                                                |
//|    It is important to understand that this algorithm finds       |
//|    minimum in the space of function PARAMETERS (not arguments),  |
//|    so it needs derivatives of f() with respect to C, not X.      |
//|    In the example above it will need f=c0*x+c1 and               |
//|    {df/dc0,df/dc1}={x,1} instead of {df/dx}={c0}.                |
//| 2. Callback functions accept C as the first parameter, and X as  |
//|    the second                                                    |
//| 3. If state was created with LSFitCreateFG(), algorithm needs    |
//|    just function and its gradient, but if state wascreated with  |
//|    LSFitCreateFGH(), algorithm will need function, gradient and  |
//|    Hessian.                                                      |
//|    According to the said above, there ase several versions of    |
//|    this function, which accept different sets of callbacks.      |
//|    This flexibility opens way to subtle errors - you may create  |
//|    state with LSFitCreateFGH() (optimization using Hessian), but |
//|    call function which does not accept Hessian. So when algorithm|
//|    will request Hessian, there will be no callback to call. In   |
//|    this case exception will be thrown.                           |
//|    Be careful to avoid such errors because there is no way to    |
//|    find them at compile time - you can see them at runtime only. |
//+------------------------------------------------------------------+
void CAlglib::LSFitFit(CLSFitStateShell &state,CNDimensional_PFunc &func,
                       CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::LSFitIteration(state))
     {
      //--- check
      if(state.GetNeedF())
        {
         func.PFunc(state.GetInnerObj().m_c,state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_c,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'lsfitfit' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear fitter                                                 |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     hess    -   callback which calculates function (or merit     |
//|                 function) value func, gradient grad and Hessian  |
//|                 hess at given point x                            |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. this algorithm is somewhat unusual because it works with      |
//|    parameterized function f(C,X), where X is a function argument |
//|    (we have many points which are characterized by different     |
//|    argument values), and C is a parameter to fit.                |
//|    For example, if we want to do linear fit by                   |
//|    f(c0,c1,x)=c0*x+c1, then x will be argument, and {c0,c1} will |
//|    be parameters.                                                |
//|    It is important to understand that this algorithm finds       |
//|    minimum in the space of function PARAMETERS (not arguments),  |
//|    so it needs derivatives of f() with respect to C, not X.      |
//|    In the example above it will need f=c0*x+c1 and               |
//|    {df/dc0,df/dc1}={x,1} instead of {df/dx}={c0}.                |
//| 2. Callback functions accept C as the first parameter, and X as  |
//|    the second                                                    |
//| 3. If state was created with LSFitCreateFG(), algorithm needs    |
//|    just function and its gradient, but if state wascreated with  |
//|    LSFitCreateFGH(), algorithm will need function, gradient and  |
//|    Hessian.                                                      |
//|    According to the said above, there ase several versions of    |
//|    this function, which accept different sets of callbacks.      |
//|    This flexibility opens way to subtle errors - you may create  |
//|    state with LSFitCreateFGH() (optimization using Hessian), but |
//|    call function which does not accept Hessian. So when algorithm|
//|    will request Hessian, there will be no callback to call. In   |
//|    this case exception will be thrown.                           |
//|    Be careful to avoid such errors because there is no way to    |
//|    find them at compile time - you can see them at runtime only. |
//+------------------------------------------------------------------+
void CAlglib::LSFitFit(CLSFitStateShell &state,CNDimensional_PFunc &func,
                       CNDimensional_PGrad &grad,CNDimensional_Rep &rep,
                       bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::LSFitIteration(state))
     {
      //--- check
      if(state.GetNeedF())
        {
         func.PFunc(state.GetInnerObj().m_c,state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetNeedFG())
        {
         grad.PGrad(state.GetInnerObj().m_c,state.GetInnerObj().m_x,state.GetInnerObj().m_f,state.GetInnerObj().m_g,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_c,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'lsfitfit' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear fitter                                                 |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     hess    -   callback which calculates function (or merit     |
//|                 function) value func, gradient grad and Hessian  |
//|                 hess at given point x                            |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. this algorithm is somewhat unusual because it works with      |
//|    parameterized function f(C,X), where X is a function argument |
//|    (we have many points which are characterized by different     |
//|    argument values), and C is a parameter to fit.                |
//|    For example, if we want to do linear fit by                   |
//|    f(c0,c1,x)=c0*x+c1, then x will be argument, and {c0,c1} will |
//|    be parameters.                                                |
//|    It is important to understand that this algorithm finds       |
//|    minimum in the space of function PARAMETERS (not arguments),  |
//|    so it needs derivatives of f() with respect to C, not X.      |
//|    In the example above it will need f=c0*x+c1 and               |
//|    {df/dc0,df/dc1}={x,1} instead of {df/dx}={c0}.                |
//| 2. Callback functions accept C as the first parameter, and X as  |
//|    the second                                                    |
//| 3. If state was created with LSFitCreateFG(), algorithm needs    |
//|    just function and its gradient, but if state wascreated with  |
//|    LSFitCreateFGH(), algorithm will need function, gradient and  |
//|    Hessian.                                                      |
//|    According to the said above, there ase several versions of    |
//|    this function, which accept different sets of callbacks.      |
//|    This flexibility opens way to subtle errors - you may create  |
//|    state with LSFitCreateFGH() (optimization using Hessian), but |
//|    call function which does not accept Hessian. So when algorithm|
//|    will request Hessian, there will be no callback to call. In   |
//|    this case exception will be thrown.                           |
//|    Be careful to avoid such errors because there is no way to    |
//|    find them at compile time - you can see them at runtime only. |
//+------------------------------------------------------------------+
void CAlglib::LSFitFit(CLSFitStateShell &state,CNDimensional_PFunc &func,
                       CNDimensional_PGrad &grad,CNDimensional_PHess &hess,
                       CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::LSFitIteration(state))
     {
      //--- check
      if(state.GetNeedF())
        {
         func.PFunc(state.GetInnerObj().m_c,state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetNeedFG())
        {
         grad.PGrad(state.GetInnerObj().m_c,state.GetInnerObj().m_x,state.GetInnerObj().m_f,state.GetInnerObj().m_g,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetNeedFGH())
        {
         hess.PHess(state.GetInnerObj().m_c,state.GetInnerObj().m_x,state.GetInnerObj().m_f,state.GetInnerObj().m_g,state.GetInnerObj().m_h,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_c,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'lsfitfit' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| This function calculates value of four-parameter logistic (4PL)  |
//| model  at specified point X. 4PL model has following form:       |
//|         F(x|A,B,C,D) = D+(A-D)/(1+Power(x/C,B))                  |
//| INPUT PARAMETERS:                                                |
//|   X           -  current point, X>=0:                            |
//|                  * zero X is correctly handled even for B<=0     |
//|                  * negative X results in exception.              |
//|   A, B, C, D  -  parameters of 4PL model:                        |
//|                  * A is unconstrained                            |
//|                  * B is unconstrained; zero or negative values   |
//|                      are handled correctly.                      |
//|                  * C>0, non-positive value results in exception  |
//|                  * D is unconstrained                            |
//| RESULT:                                                          |
//|   model value at X                                               |
//| NOTE: if B=0, denominator is assumed to be equal to 2.0 even  for|
//|       zero  X (strictly speaking, 0^0 is undefined).             |
//| NOTE: this function also throws exception if all input parameters|
//|       are correct, but overflow was detected during calculations.|
//| NOTE: this function performs a lot of checks; if you need really |
//|       high performance, consider evaluating model yourself,      |
//|       without checking for degenerate cases.                     |
//+------------------------------------------------------------------+
double CAlglib::LogisticCalc4(double x,double a,double b,double c,
                              double d)
  {
   return(CLSFit::LogisticCalc4(x,a,b,c,d));
  }
//+------------------------------------------------------------------+
//| This function calculates value of five-parameter logistic (5PL)  |
//| model at specified point X. 5PL model has following form:        |
//|         F(x|A,B,C,D,G) = D+(A-D)/Power(1+Power(x/C,B),G)         |
//| INPUT PARAMETERS:                                                |
//|   X           -  current point, X>=0:                            |
//|                  * zero X is correctly handled even for B<=0     |
//|                  * negative X results in exception.              |
//|   A, B, C, D, G- parameters of 5PL model:                        |
//|                  * A is unconstrained                            |
//|                  * B is unconstrained; zero or negative values   |
//|                      are handled correctly.                      |
//|                  * C>0, non-positive value results in exception  |
//|                  * D is unconstrained                            |
//|                  * G>0, non-positive value results in exception  |
//| RESULT:                                                          |
//|   model value at X                                               |
//| NOTE: if B=0, denominator is assumed to be equal to Power(2.0,G) |
//|       even for zero X (strictly speaking, 0^0 is undefined).     |
//| NOTE: this function also throws exception if all input parameters|
//|       are correct, but overflow was detected during calculations.|
//| NOTE: this function performs a lot of checks; if you need really |
//|       high performance, consider evaluating model yourself,      |
//|       without checking for degenerate cases.                     |
//+------------------------------------------------------------------+
double CAlglib::LogisticCalc5(double x,double a,double b,double c,
                              double d,double g)
  {
   return(CLSFit::LogisticCalc5(x,a,b,c,d,g));
  }
//+------------------------------------------------------------------+
//| This function fits four-parameter logistic (4PL) model  to  data |
//| provided by user. 4PL model has following form:                  |
//|            F(x|A,B,C,D) = D+(A-D)/(1+Power(x/C,B))               |
//| Here:                                                            |
//|   * A, D      -  unconstrained (see LogisticFit4EC() for         |
//|                  constrained 4PL)                                |
//|   * B>=0                                                         |
//|   * C>0                                                          |
//| IMPORTANT: output of this function is constrained in  such  way  |
//|            that  B>0. Because 4PL model is symmetric with respect|
//|            to B, there  is  no need to explore B<0. Constraining |
//|            B  makes  algorithm easier to stabilize and debug.    |
//|            Users  who  for  some  reason  prefer to work with    |
//|            negative B's should transform output themselves (swap |
//|            A and D, replace B  by -B).                           |
//| 4PL fitting is implemented as follows:                           |
//|   * we perform small number of restarts from random locations    |
//|     which helps to solve problem of bad local extrema. Locations |
//|     are only partially  random - we use input data to determine  |
//|     good  initial  guess,  but  we  include controlled amount of |
//|     randomness.                                                  |
//|   * we perform Levenberg-Marquardt fitting with very  tight      |
//|     constraints on parameters B and C - it allows us to find good|
//|     initial  guess  for  the second stage without risk of running|
//|     into "flat spot".                                            |
//|   * second  Levenberg-Marquardt  round  is   performed   without |
//|     excessive constraints. Results from the previous round are   |
//|     used as initial guess.                                       |
//|   * after fitting is done, we compare results with best values   |
//|     found so far, rewrite "best solution" if needed, and move to |
//|     next random location.                                        |
//| Overall algorithm is very stable and is not prone to  bad  local |
//| extrema. Furthermore, it automatically scales when input data    |
//| have very large  or very small range.                            |
//| INPUT PARAMETERS:                                                |
//|   X        -  array[N], stores X-values.                         |
//|               MUST include only non-negative numbers  (but  may  |
//|               include zero values). Can be unsorted.             |
//|   Y        -  array[N], values to fit.                           |
//|   N        -  number of points. If N is less than  length  of    |
//|               X/Y, only leading N elements are used.             |
//| OUTPUT PARAMETERS:                                               |
//|   A, B, C, D- parameters of 4PL model                            |
//|   Rep      -  fitting report. This structure has many fields,    |
//|               but ONLY ONES LISTED BELOW ARE SET:                |
//|               * Rep.IterationsCount - number of iterations       |
//|                                       performed                  |
//|               * Rep.RMSError        - root-mean-square error     |
//|               * Rep.AvgError        - average absolute error     |
//|               * Rep.AvgRelError     - average relative error     |
//|                                       (calculated for non-zero   |
//|                                       Y-values)                  |
//|               * Rep.MaxError        - maximum absolute error     |
//|               * Rep.R2            - coefficient of determination,|
//|                                       R-squared. This coefficient|
//|                                       is  calculated  as         |
//|                                       R2=1-RSS/TSS  (in case of  |
//|                                       nonlinear  regression there|
//|                                       are  multiple  ways  to    |
//|                                       define R2, each of them    |
//|                                       giving different results). |
//| NOTE: for stability reasons the B parameter is restricted by     |
//|       [1/1000,1000] range. It prevents  algorithm from making    |
//|       trial steps  deep into the area of bad parameters.         |
//| NOTE: after you obtained coefficients, you  can  evaluate  model |
//|       with LogisticCalc4() function.                             |
//| NOTE: if you need better control over fitting process than       |
//|       provided by this function, you may use LogisticFit45X().   |
//| NOTE: step is automatically scaled according to scale of         |
//|       parameters  being fitted before we compare its length with |
//|       EpsX. Thus,  this  function can be used to fit data with   |
//|       very small or very large values without changing EpsX.     |
//+------------------------------------------------------------------+
void CAlglib::LogisticFit4(CRowDouble &x,CRowDouble &y,int n,
                           double &a,double &b,double &c,
                           double &d,CLSFitReportShell &rep)
  {
   CLSFit::LogisticFit4(x,y,n,a,b,c,d,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function fits four-parameter logistic (4PL) model  to  data |
//| provided by user. 4PL model has following form:                  |
//|            F(x|A,B,C,D) = D+(A-D)/(1+Power(x/C,B))               |
//| Here:                                                            |
//|   * A, D      -  unconstrained (see LogisticFit4EC() for         |
//|                  constrained 4PL)                                |
//|   * B>=0                                                         |
//|   * C>0                                                          |
//| IMPORTANT: output of this function is constrained in  such  way  |
//|            that  B>0. Because 4PL model is symmetric with respect|
//|            to B, there  is  no need to explore B<0. Constraining |
//|            B  makes  algorithm easier to stabilize and debug.    |
//|            Users  who  for  some  reason  prefer to work with    |
//|            negative B's should transform output themselves (swap |
//|            A and D, replace B  by -B).                           |
//| 4PL fitting is implemented as follows:                           |
//|   * we perform small number of restarts from random locations    |
//|     which helps to solve problem of bad local extrema. Locations |
//|     are only partially  random - we use input data to determine  |
//|     good  initial  guess,  but  we  include controlled amount of |
//|     randomness.                                                  |
//|   * we perform Levenberg-Marquardt fitting with very  tight      |
//|     constraints on parameters B and C - it allows us to find good|
//|     initial  guess  for  the second stage without risk of running|
//|     into "flat spot".                                            |
//|   * second  Levenberg-Marquardt  round  is   performed   without |
//|     excessive constraints. Results from the previous round are   |
//|     used as initial guess.                                       |
//|   * after fitting is done, we compare results with best values   |
//|     found so far, rewrite "best solution" if needed, and move to |
//|     next random location.                                        |
//| Overall algorithm is very stable and is not prone to  bad  local |
//| extrema. Furthermore, it automatically scales when input data    |
//| have very large  or very small range.                            |
//| INPUT PARAMETERS:                                                |
//|   X        -  array[N], stores X-values.                         |
//|               MUST include only non-negative numbers  (but  may  |
//|               include zero values). Can be unsorted.             |
//|   Y        -  array[N], values to fit.                           |
//|   N        -  number of points. If N is less than  length  of    |
//|               X/Y, only leading N elements are used.             |
//|   CnstrLeft-  optional equality constraint for model value at the|
//|               left boundary (at X=0). Specify NAN (Not-a-Number) |
//|               if  you  do not need constraint on the model value |
//|               at X=0. See below, section "EQUALITY  CONSTRAINTS" |
//|               for more information about constraints.            |
//|   CnstrRight- optional equality constraint for model value at    |
//|               X=infinity. Specify NAN (Not-a-Number) if you do   |
//|               not need constraint on the model value. See  below,|
//|               section  "EQUALITY  CONSTRAINTS"   for   more      |
//|               information about constraints.                     |
//| OUTPUT PARAMETERS:
//| OUTPUT PARAMETERS:                                               |
//|   A, B, C, D- parameters of 4PL model                            |
//|   Rep      -  fitting report. This structure has many fields,    |
//|               but ONLY ONES LISTED BELOW ARE SET:                |
//|               * Rep.IterationsCount - number of iterations       |
//|                                       performed                  |
//|               * Rep.RMSError        - root-mean-square error     |
//|               * Rep.AvgError        - average absolute error     |
//|               * Rep.AvgRelError     - average relative error     |
//|                                       (calculated for non-zero   |
//|                                       Y-values)                  |
//|               * Rep.MaxError        - maximum absolute error     |
//|               * Rep.R2            - coefficient of determination,|
//|                                       R-squared. This coefficient|
//|                                       is  calculated  as         |
//|                                       R2=1-RSS/TSS  (in case of  |
//|                                       nonlinear  regression there|
//|                                       are  multiple  ways  to    |
//|                                       define R2, each of them    |
//|                                       giving different results). |
//| NOTE: for stability reasons the B parameter is restricted by     |
//|       [1/1000,1000] range. It prevents  algorithm from making    |
//|       trial steps  deep into the area of bad parameters.         |
//| NOTE: after you obtained coefficients, you  can  evaluate  model |
//|       with LogisticCalc4() function.                             |
//| NOTE: if you need better control over fitting process than       |
//|       provided by this function, you may use LogisticFit45X().   |
//| NOTE: step is automatically scaled according to scale of         |
//|       parameters  being fitted before we compare its length with |
//|       EpsX. Thus,  this  function can be used to fit data with   |
//|       very small or very large values without changing EpsX.     |
//| EQUALITY CONSTRAINTS ON PARAMETERS                               |
//| 4PL/5PL solver supports equality constraints on model values at  |
//| the left boundary (X=0) and right  boundary  (X=infinity).  These|
//| constraints  are completely optional and you can specify both of |
//| them, only one - or no constraints at all.                       |
//| Parameter  CnstrLeft  contains  left  constraint (or NAN for     |
//| unconstrained fitting), and CnstrRight contains right  one.  For |
//| 4PL,  left  constraint ALWAYS corresponds to parameter A, and    |
//| right one is ALWAYS  constraint  on D. That's because 4PL model  |
//| is normalized in such way that B>=0.                             |
//+------------------------------------------------------------------+
void CAlglib::LogisticFit4ec(CRowDouble &x,CRowDouble &y,int n,
                             double cnstrleft,double cnstrright,
                             double &a,double &b,double &c,
                             double &d,CLSFitReportShell &rep)
  {
   CLSFit::LogisticFit4ec(x,y,n,cnstrleft,cnstrright,a,b,c,d,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function fits five-parameter logistic (5PL) model  to  data |
//| provided by user. 5PL model has following form:                  |
//|         F(x|A,B,C,D,G) = D+(A-D)/Power(1+Power(x/C,B),G)         |
//| Here:                                                            |
//|   * A, D         -  unconstrained                                |
//|   * B            -  unconstrained                                |
//|   * C>0                                                          |
//|   * G>0                                                          |
//| IMPORTANT: unlike in  4PL  fitting,  output  of  this  function  |
//|            is NOT constrained in  such  way that B is guaranteed |
//|            to be positive. Furthermore,  unlike  4PL,  5PL model |
//|            is  NOT  symmetric with respect to B, so you can NOT  |
//|            transform model to equivalent one, with B having      |
//|            desired sign (>0 or <0).                              |
//| 5PL fitting is implemented as follows:                           |
//|   * we perform small number of restarts from random locations    |
//|     which helps to solve problem of bad local extrema. Locations |
//|     are only partially random - we use input data to determine   |
//|     good  initial  guess,  but  we  include controlled amount of |
//|     randomness.                                                  |
//|   * we perform Levenberg - Marquardt fitting with very  tight    |
//|     constraints on parameters B and C - it allows us to find good|
//|     initial  guess  for  the second stage without risk of running|
//|     into "flat spot".  Parameter  G  is fixed at G = 1.          |
//|   * second  Levenberg - Marquardt  round  is  performed  without |
//|     excessive constraints on B and C, but with G still equal to 1|
//|     Results from the previous round are used as initial guess.   |
//|   * third Levenberg - Marquardt round relaxes constraints on G   |
//|     and  tries  two different models - one with B > 0 and one    |
//|     with B < 0.                                                  |
//|   * after fitting is done, we compare results with best values   |
//|     found so far, rewrite "best solution" if needed, and move to |
//|     next random location.                                        |
//| Overall algorithm is very stable and is not prone to  bad  local |
//| extrema. Furthermore, it automatically scales when input data    |
//| have  very  large  or very small range.                          |
//| INPUT PARAMETERS:                                                |
//|   X           -  array[N], stores X - values.                    |
//|                  MUST include only non - negative numbers(but may|
//|                  include zero values). Can be unsorted.          |
//|   Y           -  array[N], values to fit.                        |
//|   N           -  number of points. If N is less than  length  of |
//|                  X / Y, only leading N elements are used.        |
//| OUTPUT PARAMETERS:                                               |
//|   A, B, C, D, G -  parameters of 5PL model                       |
//|   Rep         -  fitting report. This structure has many fields, |
//|                  but  ONLY ONES LISTED BELOW ARE SET:            |
//|            * Rep.IterationsCount - number of iterations performed|
//|            * Rep.RMSError        - root - mean - square error    |
//|            * Rep.AvgError        - average absolute error        |
//|            * Rep.AvgRelError     - average relative error        |
//|                                    (calculated for non - zero    |
//|                                    Y - values)                   |
//|            * Rep.MaxError        - maximum absolute error        |
//|            * Rep.R2              - coefficient of determination, |
//|                                    R - squared.  This coefficient|
//|                                    is  calculated as             |
//|                                    R2 = 1 - RSS / TSS (in case   |
//|                                    of nonlinear  regression there|
//|                                    are  multiple  ways  to define|
//|                                    R2, each of them giving       |
//|                                    different results).           |
//| NOTE: for better stability B  parameter is restricted by         |
//|       [+-1/1000, +-1000] range, and G is restricted by [1/10, 10]|
//|       range. It prevents algorithm from making trial steps deep  |
//|       into the area of bad parameters.                           |
//| NOTE: after  you  obtained  coefficients,  you  can  evaluate    |
//|       model  with LogisticCalc5() function.                      |
//| NOTE: if you need better control over fitting process than       |
//|       provided by this function, you may use LogisticFit45X().   |
//| NOTE: step is automatically scaled according to scale of         |
//|       parameters being fitted before we compare its length with  |
//|       EpsX. Thus,  this  function can be used to fit data with   |
//|       very small or very large values without changing EpsX.     |
//+------------------------------------------------------------------+
void CAlglib::LogisticFit5(CRowDouble &x,CRowDouble &y,int n,
                           double &a,double &b,double &c,double &d,
                           double &g,CLSFitReportShell &rep)
  {
   CLSFit::LogisticFit5(x,y,n,a,b,c,d,g,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function fits five-parameter logistic (5PL) model  to  data |
//| provided by user. 5PL model has following form:                  |
//|         F(x|A,B,C,D,G) = D+(A-D)/Power(1+Power(x/C,B),G)         |
//| Here:                                                            |
//|   * A, D         -  unconstrained                                |
//|   * B            -  unconstrained                                |
//|   * C>0                                                          |
//|   * G>0                                                          |
//| IMPORTANT: unlike in  4PL  fitting,  output  of  this  function  |
//|            is NOT constrained in  such  way that B is guaranteed |
//|            to be positive. Furthermore,  unlike  4PL,  5PL model |
//|            is  NOT  symmetric with respect to B, so you can NOT  |
//|            transform model to equivalent one, with B having      |
//|            desired sign (>0 or <0).                              |
//| 5PL fitting is implemented as follows:                           |
//|   * we perform small number of restarts from random locations    |
//|     which helps to solve problem of bad local extrema. Locations |
//|     are only partially random - we use input data to determine   |
//|     good  initial  guess,  but  we  include controlled amount of |
//|     randomness.                                                  |
//|   * we perform Levenberg - Marquardt fitting with very  tight    |
//|     constraints on parameters B and C - it allows us to find good|
//|     initial  guess  for  the second stage without risk of running|
//|     into "flat spot".  Parameter  G  is fixed at G = 1.          |
//|   * second  Levenberg - Marquardt  round  is  performed  without |
//|     excessive constraints on B and C, but with G still equal to 1|
//|     Results from the previous round are used as initial guess.   |
//|   * third Levenberg - Marquardt round relaxes constraints on G   |
//|     and  tries  two different models - one with B > 0 and one    |
//|     with B < 0.                                                  |
//|   * after fitting is done, we compare results with best values   |
//|     found so far, rewrite "best solution" if needed, and move to |
//|     next random location.                                        |
//| Overall algorithm is very stable and is not prone to  bad  local |
//| extrema. Furthermore, it automatically scales when input data    |
//| have  very  large  or very small range.                          |
//| INPUT PARAMETERS:                                                |
//|   X           -  array[N], stores X - values.                    |
//|                  MUST include only non - negative numbers(but may|
//|                  include zero values). Can be unsorted.          |
//|   Y           -  array[N], values to fit.                        |
//|   N           -  number of points. If N is less than  length  of |
//|                  X / Y, only leading N elements are used.        |
//|   CnstrLeft   -  optional equality constraint for model value at |
//|                  the left boundary(at X = 0).                    |
//|                  Specify NAN(Not - a - Number)  if  you  do not  |
//|                  need constraint on the model value at X = 0.    |
//|                  See  below,  section  "EQUALITY  CONSTRAINTS"   |
//|                  for more information about constraints.         |
//|   CnstrRight  -  optional equality constraint for model value at |
//|                  X = infinity.                                   |
//|                  Specify NAN(Not - a - Number)  if  you  do not  |
//|                  need constraint on the model value at X = 0.    |
//|                  See  below,  section  "EQUALITY  CONSTRAINTS"   |
//|                  for more information about constraints.         |
//| OUTPUT PARAMETERS:                                               |
//|   A, B, C, D, G -  parameters of 5PL model                       |
//|   Rep         -  fitting report. This structure has many fields, |
//|                  but  ONLY ONES LISTED BELOW ARE SET:            |
//|            * Rep.IterationsCount - number of iterations performed|
//|            * Rep.RMSError        - root - mean - square error    |
//|            * Rep.AvgError        - average absolute error        |
//|            * Rep.AvgRelError     - average relative error        |
//|                                    (calculated for non - zero    |
//|                                    Y - values)                   |
//|            * Rep.MaxError        - maximum absolute error        |
//|            * Rep.R2              - coefficient of determination, |
//|                                    R - squared.  This coefficient|
//|                                    is  calculated as             |
//|                                    R2 = 1 - RSS / TSS (in case   |
//|                                    of nonlinear  regression there|
//|                                    are  multiple  ways  to define|
//|                                    R2, each of them giving       |
//|                                    different results).           |
//| NOTE: for better stability B  parameter is restricted by         |
//|       [+-1/1000, +-1000] range, and G is restricted by [1/10, 10]|
//|       range. It prevents algorithm from making trial steps deep  |
//|       into the area of bad parameters.                           |
//| NOTE: after  you  obtained  coefficients,  you  can  evaluate    |
//|       model  with LogisticCalc5() function.                      |
//| NOTE: if you need better control over fitting process than       |
//|       provided by this function, you may use LogisticFit45X().   |
//| NOTE: step is automatically scaled according to scale of         |
//|       parameters being fitted before we compare its length with  |
//|       EpsX. Thus,  this  function can be used to fit data with   |
//|       very small or very large values without changing EpsX.     |
//| EQUALITY CONSTRAINTS ON PARAMETERS                               |
//| 5PL solver supports equality constraints on model  values  at the|
//| left boundary(X = 0) and right  boundary(X = infinity).  These   |
//| constraints  are completely optional and you can specify both of |
//| them, only one - or no constraints at all.                       |
//| Parameter  CnstrLeft  contains  left  constraint (or NAN for     |
//| unconstrained fitting), and CnstrRight contains right  one.      |
//| Unlike 4PL one, 5PL model is NOT symmetric with respect to change|
//| in sign of B. Thus, negative B's are possible, and left          |
//| constraint  may  constrain parameter A(for positive B's)  -  or  |
//| parameter  D  (for  negative  B's). Similarly changes meaning of |
//| right constraint.                                                |
//| You do not have to decide what parameter to constrain - algorithm|
//| will automatically determine correct parameters as fitting       |
//| progresses. However, question highlighted above is important when|
//| you interpret fitting results.                                   |
//+------------------------------------------------------------------+
void CAlglib::LogisticFit5ec(CRowDouble &x,CRowDouble &y,int n,
                             double cnstrleft,double cnstrright,
                             double &a,double &b,double &c,double &d,
                             double &g,CLSFitReportShell &rep)
  {
   CLSFit::LogisticFit5ec(x,y,n,cnstrleft,cnstrright,a,b,c,d,g,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This is "expert" 4PL / 5PL fitting function, which can be used if|
//| you  need better control over fitting process than provided  by  |
//| LogisticFit4() or LogisticFit5().                                |
//| This function fits model of the form                             |
//|      F(x|A,B,C,D) = D+(A-D)/(1+Power(x/C,B))   (4PL model)       |
//| or                                                               |
//|      F(x|A,B,C,D,G) = D+(A-D)/Power(1+Power(x/C,B),G)(5PL model) |
//| Here:                                                            |
//|   * A, D         -  unconstrained                                |
//|   * B >= 0 for 4PL, unconstrained for 5PL                        |
//|   * C > 0                                                        |
//|   * G > 0(if present)                                            |
//| INPUT PARAMETERS:                                                |
//|   X           -  array[N], stores X - values.                    |
//|                  MUST include only non-negative numbers(but  may |
//|                  include zero values). Can be unsorted.          |
//|   Y           -  array[N], values to fit.                        |
//|   N           -  number of points. If N is less than  length  of |
//|                  X / Y, only leading N elements are used.        |
//|   CnstrLeft   -  optional equality constraint for model value at |
//|                  the left boundary(at X = 0).                    |
//|                  Specify NAN (Not-a-Number) if you do not need   |
//|                  constraint on the model value at X = 0.         |
//|                  See  below,  section  "EQUALITY  CONSTRAINTS"   |
//|                  for   more information about constraints.       |
//|   CnstrRight  -  optional equality constraint for model value at |
//|                  X = infinity.                                   |
//|                  Specify NAN (Not-a-Number) if you do not need   |
//|                  constraint on the model value at X = 0.         |
//|                  See  below,  section  "EQUALITY  CONSTRAINTS"   |
//|                  for   more information about constraints.       |
//|   Is4PL       -  whether 4PL or 5PL models are fitted            |
//|   LambdaV     -  regularization coefficient, LambdaV >= 0. Set it|
//|                  to zero unless you know what you are doing.     |
//|   EpsX        -  stopping condition(step size), EpsX >= 0. Zero  |
//|                  value means that small step is automatically    |
//|                  chosen. See notes below for more information.   |
//|   RsCnt       -  number of repeated restarts from  random points.|
//|                  4PL/5PL models are prone to problem of bad local|
//|                  extrema. Utilizing multiple random restarts     |
//|                  allows  us  to  improve algorithm convergence.  |
//|                  RsCnt >= 0. Zero value means that function      |
//|                  automatically choose  small amount of restarts  |
//|                  (recommended).                                  |
//| OUTPUT PARAMETERS:                                               |
//|   A, B, C, D  -  parameters of 4PL model                         |
//|   G           -  parameter of 5PL model; for Is4PL = True, G = 1 |
//|                  is returned.                                    |
//|   Rep         -  fitting report. This structure has many fields, |
//|                  but  ONLY ONES LISTED BELOW ARE SET:            |
//|            * Rep.IterationsCount - number of iterations performed|
//|            * Rep.RMSError        - root - mean - square error    |
//|            * Rep.AvgError        - average absolute error        |
//|            * Rep.AvgRelError     - average relative error        |
//|                                    (calculated for non - zero    |
//|                                    Y - values)                   |
//|            * Rep.MaxError        - maximum absolute error        |
//|            * Rep.R2              - coefficient of determination, |
//|                                    R - squared.  This coefficient|
//|                                    is  calculated as             |
//|                                    R2 = 1 - RSS / TSS (in case   |
//|                                    of nonlinear  regression there|
//|                                    are  multiple  ways  to define|
//|                                    R2, each of them giving       |
//|                                    different results).           |
//| NOTE: for better stability B  parameter is restricted by         |
//|       [+-1/1000, +-1000] range, and G is restricted by [1/10, 10]|
//|       range. It prevents algorithm from making trial steps deep  |
//|       into the area of bad parameters.                           |
//| NOTE: after  you  obtained  coefficients,  you  can  evaluate    |
//|       model  with LogisticCalc5() function.                      |
//| NOTE: if you need better control over fitting process than       |
//|       provided by this function, you may use LogisticFit45X().   |
//| NOTE: step is automatically scaled according to scale of         |
//|       parameters being fitted before we compare its length with  |
//|       EpsX. Thus,  this  function can be used to fit data with   |
//|       very small or very large values without changing EpsX.     |
//| EQUALITY CONSTRAINTS ON PARAMETERS                               |
//| 4PL/5PL solver supports equality constraints on model values at  |
//| the left boundary(X = 0) and right boundary(X = infinity). These |
//| constraints are completely optional and you can specify both of  |
//| them, only one - or no constraints at all.                       |
//| Parameter  CnstrLeft  contains  left  constraint (or NAN for     |
//| unconstrained fitting), and CnstrRight contains right one. For   |
//| 4PL, left constraint ALWAYS corresponds to parameter A, and right|
//| one is ALWAYS  constraint on D. That's because 4PL model is      |
//| normalized in such way that B>=0.                                |
//| For 5PL model things are different. Unlike 4PL one, 5PL model is |
//| NOT symmetric with respect to  change  in  sign  of  B. Thus,    |
//| negative B's are possible, and left constraint may constrain     |
//| parameter A(for positive B's) - or parameter D(for negative B's).|
//| Similarly changes  meaning  of  right constraint.                |
//| You do not have to decide what parameter to constrain - algorithm|
//| will automatically determine correct parameters as fitting       |
//| progresses. However, question highlighted above is important when|
//| you interpret fitting results.                                   |
//+------------------------------------------------------------------+
void CAlglib::LogisticFit45x(CRowDouble &x,CRowDouble &y,int n,
                             double cnstrleft,double cnstrright,
                             bool is4pl,double lambdav,double epsx,
                             int rscnt,double &a,double &b,double &c,
                             double &d,double &g,CLSFitReportShell &rep)
  {
   CLSFit::LogisticFit45x(x,y,n,cnstrleft,cnstrright,is4pl,lambdav,epsx,rscnt,a,b,c,d,g,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Nonlinear least squares fitting results.                         |
//| Called after return from LSFitFit().                             |
//| INPUT PARAMETERS:                                                |
//|     State   -   algorithm state                                  |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   completetion code:                               |
//|                     *  1    relative function improvement is no  |
//|                             more than EpsF.                      |
//|                     *  2    relative step is no more than EpsX.  |
//|                     *  4    gradient norm is no more than EpsG   |
//|                     *  5    MaxIts steps was taken               |
//|                     *  7    stopping conditions are too          |
//|                             stringent, further improvement is    |
//|                             impossible                           |
//|     C       -   array[0..K-1], solution                          |
//|     Rep     -   optimization report. Following fields are set:   |
//|                 * Rep.TerminationType completetion code:         |
//|                 * RMSError          rms error on the (X,Y).      |
//|                 * AvgError          average error on the (X,Y).  |
//|                 * AvgRelError       average relative error on the|
//|                                     non-zero Y                   |
//|                 * MaxError          maximum error                |
//|                                     NON-WEIGHTED ERRORS ARE      |
//|                                     CALCULATED                   |
//|                 * WRMSError         weighted rms error on the    |
//|                                     (X,Y).                       |
//+------------------------------------------------------------------+
void CAlglib::LSFitResults(CLSFitStateShell &state,int &info,
                           double &c[],CLSFitReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CLSFit::LSFitResults(state.GetInnerObj(),info,c,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Fits least squares (LS) circle (or NX-dimensional sphere) to data|
//| (a set of points in NX-dimensional space).                       |
//| Least squares circle minimizes sum of squared deviations between |
//| distances from points to the center and  some "candidate" radius,|
//| which  is  also fitted to the data.                              |
//| INPUT PARAMETERS:                                                |
//|   XY       -  array[NPoints,NX] (or larger), contains dataset.   |
//|               One row = one point in NX-dimensional space.       |
//|   NPoints  -  dataset size, NPoints>0                            |
//|   NX       -  space dimensionality, NX>0(1, 2, 3, 4, 5 and so on)|
//| OUTPUT PARAMETERS:                                               |
//|   CX       -  central point for a sphere                         |
//|   R        -  radius                                             |
//+------------------------------------------------------------------+
void CAlglib::FitSphereLS(CMatrixDouble &xy,int npoints,int nx,
                          CRowDouble &cx,double &r)
  {
   r=0;
//--- function call
   CFitSphere::FitSphereLS(xy,npoints,nx,cx,r);
  }
//+------------------------------------------------------------------+
//| Fits minimum circumscribed (MC) circle (or NX-dimensional sphere)|
//| to data (a set of points in NX-dimensional space).               |
//| INPUT PARAMETERS:                                                |
//|   XY       -  array[NPoints,NX] (or larger), contains dataset.   |
//|               One row = one point in NX-dimensional space.       |
//|   NPoints  -  dataset size, NPoints>0                            |
//|   NX       -  space dimensionality, NX>0(1, 2, 3, 4, 5 and so on)|
//| OUTPUT PARAMETERS:                                               |
//|   CX       -  central point for a sphere                         |
//|   RHi      -  radius                                             |
//| NOTE: this function is an easy-to-use wrapper around more        |
//|       powerful "expert" function FitSphereX().                   |
//| This wrapper is optimized for ease of use and stability - at the |
//| cost of somewhat lower performance (we have to use very tight    |
//| stopping criteria for inner optimizer because we want to  make   |
//| sure that it will converge on any dataset).                      |
//| If  you  are  ready  to  experiment with settings of  "expert"   |
//| function,  you  can  achieve  ~2-4x  speedup  over  standard     |
//| "bulletproof" settings.                                          |
//+------------------------------------------------------------------+
void CAlglib::FitSphereMC(CMatrixDouble &xy,int npoints,int nx,
                          CRowDouble &cx,double &rhi)
  {
   CFitSphere::FitSphereMC(xy,npoints,nx,cx,rhi);
  }
//+------------------------------------------------------------------+
//| Fits maximum inscribed circle (or NX-dimensional sphere) to data |
//| (a set of points in NX-dimensional space).                       |
//| INPUT PARAMETERS:                                                |
//|   XY       -  array[NPoints,NX] (or larger), contains dataset.   |
//|               One row = one point in NX-dimensional space.       |
//|   NPoints  -  dataset size, NPoints>0                            |
//|   NX       -  space dimensionality, NX>0(1, 2, 3, 4, 5 and so on)|
//| OUTPUT PARAMETERS:                                               |
//|   CX       -  central point for a sphere                         |
//|   RLo      -  radius                                             |
//| NOTE:   this  function  is  an  easy-to-use wrapper around more  |
//|         powerful "expert" function FitSphereX().                 |
//| This  wrapper  is optimized  for  ease of use and stability - at |
//| the cost of somewhat lower  performance  (we  have  to  use  very|
//| tight stopping criteria for inner optimizer because we want to   |
//| make  sure that it will converge on any dataset).                |
//| If  you  are  ready  to  experiment  with settings of  "expert"  |
//| function,  you  can  achieve  ~2-4x  speedup  over  standard     |
//| "bulletproof" settings.                                          |
//+------------------------------------------------------------------+
void CAlglib::FitSphereMI(CMatrixDouble &xy,int npoints,int nx,
                          CRowDouble &cx,double &rlo)
  {
   CFitSphere::FitSphereMI(xy,npoints,nx,cx,rlo);
  }
//+------------------------------------------------------------------+
//| Fits minimum zone circle (or NX-dimensional sphere) to data  (a  |
//| set of points in NX-dimensional space).                          |
//| INPUT PARAMETERS:                                                |
//|   XY       -  array[NPoints,NX] (or larger), contains dataset.   |
//|               One row = one point in NX-dimensional space.       |
//|   NPoints  -  dataset size, NPoints>0                            |
//|   NX       -  space dimensionality, NX>0(1, 2, 3, 4, 5 and so on)|
//| OUTPUT PARAMETERS:                                               |
//|   CX       -  central point for a sphere                         |
//|   RLo      -  radius of inscribed circle                         |
//|   RHo      -  radius of circumscribed circle                     |
//| NOTE:   this  function  is  an  easy-to-use wrapper around more  |
//|         powerful "expert" function FitSphereX().                 |
//| This  wrapper  is optimized  for  ease of use and stability - at |
//| the cost of somewhat lower  performance  (we  have  to  use  very|
//| tight stopping criteria for inner optimizer because we want to   |
//| make  sure that it will converge on any dataset).                |
//| If  you  are  ready  to  experiment  with settings of  "expert"  |
//| function,  you  can  achieve  ~2-4x  speedup  over  standard     |
//| "bulletproof" settings.                                          |
//+------------------------------------------------------------------+
void CAlglib::FitSphereMZ(CMatrixDouble &xy,int npoints,int nx,
                          CRowDouble &cx,double &rlo,double &rhi)
  {
   CFitSphere::FitSphereMZ(xy,npoints,nx,cx,rlo,rhi);
  }
//+------------------------------------------------------------------+
//| Fitting minimum circumscribed, maximum inscribed or minimum zone |
//| circles (or NX-dimensional spheres)  to  data  (a  set of points |
//| in NX-dimensional space).                                        |
//| This is expert function which allows to tweak many parameters of |
//| underlying nonlinear solver:                                     |
//|   * stopping criteria for inner iterations                       |
//|   * number of outer iterations                                   |
//|   * penalty coefficient used to handle nonlinear constraints (we |
//|     convert unconstrained nonsmooth optimization problem ivolving|
//|     max() and/or min() operations to quadratically constrained   |
//|     smooth one).                                                 |
//| You may tweak all these parameters or only some of them, leaving |
//| other ones at their default state - just specify zero value, and |
//| solver  will fill it with appropriate default one.               |
//| These comments also include some discussion of approach used to  |
//| handle such unusual fitting problem, its stability, drawbacks of |
//| alternative methods, and convergence properties.                 |
//| INPUT PARAMETERS:                                                |
//|   XY       -  array[NPoints,NX] (or larger), contains dataset.   |
//|               One row = one point in NX-dimensional space.       |
//|   NPoints  -  dataset size, NPoints>0                            |
//|   NX       -  space dimensionality, NX>0(1, 2, 3, 4, 5 and so on)|
//|   ProblemType - used to encode problem type:                     |
//|               * 0 for least squares circle                       |
//|               * 1 for minimum circumscribed circle/sphere fitting|
//|                   (MC)                                           |
//|               * 2 for maximum inscribed circle/sphere fitting(MI)|
//|               * 3 for minimum zone circle fitting (difference    |
//|                   between Rhi and Rlo is minimized), denoted as  |
//|                   MZ                                             |
//|   EpsX     -  stopping condition for NLC optimizer:              |
//|               * must be non-negative                             |
//|               * use 0 to choose default value (1.0E-12 is used by|
//|                 default)                                         |
//|               * you may specify larger values, up to 1.0E-6, if  |
//|                 you want to speed-up solver; NLC solver performs |
//|                 several preconditioned outer iterations, so final|
//|                 result typically has precision much better than  |
//|                 EpsX.                                            |
//|   AULIts   -  number of outer iterations performed by NLC        |
//|               optimizer:                                         |
//|               * must be non-negative                             |
//|               * use 0 to choose default value (20 is used by     |
//|                 default)                                         |
//|               * you may specify values smaller than 20 if you    |
//|                 want to speed up solver; 10 often results in good|
//|                 combination of precision and speed; sometimes you|
//|                 may get good results with just 6 outer iterations|
//|                 Ignored for ProblemType=0.                       |
//|   Penalty  -  penalty coefficient for NLC optimizer:             |
//|               * must be non-negative                             |
//|               * use 0 to choose default value (1.0E6 in current  |
//|                 version)                                         |
//|               * it should be really large, 1.0E6...1.0E7 is a    |
//|                 good value to start from;                        |
//|               * generally, default value is good enough          |
//|               Ignored for ProblemType=0.                         |
//| OUTPUT PARAMETERS:                                               |
//|   CX       -  central point for a sphere                         |
//|   RLo      -  radius:                                            |
//|               * for ProblemType=2,3, radius of the inscribed     |
//|                                      sphere                      |
//|               * for ProblemType=0 - radius of the least squares  |
//|                                      sphere                      |
//|               * for ProblemType=1 - zero                         |
//|   RHo      -  radius:                                            |
//|               * for ProblemType=1,3, radius of the circumscribed |
//|                                      sphere                      |
//|               * for ProblemType=0 - radius of the least squares  |
//|                                      sphere                      |
//|               * for ProblemType=2 - zero                         |
//| NOTE: ON THE UNIQUENESS OF SOLUTIONS                             |
//| ALGLIB provides solution to several related circle fitting       |
//| problems: MC (minimum circumscribed), MI (maximum inscribed) and |
//| MZ (minimum zone) fitting, LS (least squares) fitting.           |
//| It is important to note that among these problems only MC and LS |
//| are convex and have unique solution independently from starting  |
//| point.                                                           |
//| As for MI, it may (or may not, depending on dataset properties)  |
//| have multiple solutions, and it always has one degenerate        |
//| solution C=infinity which corresponds to infinitely large radius.|
//| Thus, there are no guarantees that solution to  MI returned by   |
//| this solver will be the best one (and no one can provide you with|
//| such guarantee because problem is NP-hard). The only guarantee   |
//| you have is that this solution is locally optimal, i.e. it can   |
//| not be improved by infinitesimally small tweaks in the parameters|
//| It is also possible to "run away" to infinity when started from  |
//| bad initial point located outside of point cloud (or when point  |
//| cloud does not span entire circumference/surface of the sphere). |
//| Finally, MZ (minimum zone circle) stands somewhere between MC and|
//| MI in stability. It is somewhat regularized by "circumscribed"   |
//| term of the merit function; however, solutions to  MZ may be     |
//| non-unique, and in some unlucky cases it is also possible to "run|
//| away to infinity".                                               |
//| NOTE: ON THE NONLINEARLY CONSTRAINED PROGRAMMING APPROACH        |
//| The problem formulation for MC (minimum circumscribed circle; for|
//| the sake of simplicity we omit MZ and MI here) is:               |
//|               [     [         ]2 ]                               |
//|           min [ max [ XY[i]-C ]  ]                               |
//|            C  [  i  [         ]  ]                               |
//| i.e. it is unconstrained nonsmooth optimization problem of       |
//| finding "best" central point, with radius R being unambiguously  |
//| determined from C. In order to move away from non-smoothness we  |
//| use following reformulation:                                     |
//|            [   ]                  [         ]2                   |
//|        min [ R ] subject to R>=0, [ XY[i]-C ]  <= R^2            |
//|        C,R [   ]                  [         ]                    |
//| i.e. it becomes smooth quadratically constrained optimization    |
//| problem with linear target function. Such problem statement is   |
//| 100% equivalent to the original nonsmooth one, but much easier   |
//| to approach. We solve it with MinNLC solver provided by ALGLIB.  |
//| NOTE: ON INSTABILITY OF SEQUENTIAL LINEARIZATION APPROACH        |
//| ALGLIB has nonlinearly constrained solver which proved to be     |
//| stable on such problems. However, some authors proposed to       |
//| linearize constraints in the vicinity of current approximation   |
//| (Ci,Ri) and to get next approximate solution (Ci+1,Ri+1) as      |
//| solution to linear programming problem. Obviously, LP problems   |
//| are easier than nonlinearly constrained ones.                    |
//| Indeed, such approach to MC/MI/MZ resulted in ~10-20x increase in|
//| performance (when compared with NLC solver). However, it turned  |
//| out that in some cases linearized model fails to predict correct |
//| direction for next step and tells us that we converged to        |
//| solution even when we are still 2-4 digits of precision away from|
//| it.                                                              |
//| It is important that it is not failure of LP solver - it is      |
//| failure of the linear model; even when solved exactly, it fails  |
//| to handle subtle nonlinearities which arise near the solution.   |
//| We validated it by comparing results returned by ALGLIB linear   |
//| solver with that of MATLAB.                                      |
//| In our experiments with linearization:                           |
//|   * MC failed most often, at both realistic and synthetic        |
//|     datasets                                                     |
//|   * MI sometimes failed, but sometimes succeeded                 |
//|   * MZ often succeeded; our guess is that presence of two        |
//|     independent sets of constraints (one set for Rlo and another |
//|     one for Rhi) and two terms in the target function (Rlo and   |
//|     Rhi) regularizes task, so when linear model fails to handle  |
//|     nonlinearities from Rlo, it uses Rhi as a hint (and vice     |
//|     versa).                                                      |
//| Because linearization approach failed to achieve stable results, |
//| we do not include it in ALGLIB.                                  |
//+------------------------------------------------------------------+
void CAlglib::FitSphereX(CMatrixDouble &xy,int npoints,int nx,
                         int problemtype,double epsx,int aulits,
                         double penalty,CRowDouble &cx,double &rlo,
                         double &rhi)
  {
   CFitSphere::FitSphereX(xy,npoints,nx,problemtype,epsx,aulits,penalty,cx,rlo,rhi);
  }
//+------------------------------------------------------------------+
//| This function builds non-periodic 2-dimensional parametric       |
//| spline which starts at (X[0],Y[0]) and ends at (X[N-1],Y[N-1]).  |
//| INPUT PARAMETERS:                                                |
//|     XY  -   points, array[0..N-1,0..1].                          |
//|             XY[I,0:1] corresponds to the Ith point.              |
//|             Order of points is important!                        |
//|     N   -   points count, N>=5 for Akima splines, N>=2 for other |
//|             types of splines.                                    |
//|     ST  -   spline type:                                         |
//|             * 0     Akima spline                                 |
//|             * 1     parabolically terminated Catmull-Rom spline  |
//|                     (Tension=0)                                  |
//|             * 2     parabolically terminated cubic spline        |
//|     PT  -   parameterization type:                               |
//|             * 0     uniform                                      |
//|             * 1     chord length                                 |
//|             * 2     centripetal                                  |
//| OUTPUT PARAMETERS:                                               |
//|     P   -   parametric spline interpolant                        |
//| NOTES:                                                           |
//| * this function assumes that there all consequent points are     |
//|   distinct. I.e. (x0,y0)<>(x1,y1), (x1,y1)<>(x2,y2),             |
//|   (x2,y2)<>(x3,y3) and so on. However, non-consequent points may |
//|   coincide, i.e. we can have (x0,y0) = (x2,y2).                  |
//+------------------------------------------------------------------+
void CAlglib::PSpline2Build(CMatrixDouble &xy,const int n,const int st,
                            const int pt,CPSpline2InterpolantShell &p)
  {
   CPSpline::PSpline2Build(xy,n,st,pt,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function builds non-periodic 3-dimensional parametric spline|
//| which starts at (X[0],Y[0],Z[0]) and ends at                     |
//| (X[N-1],Y[N-1],Z[N-1]).                                          |
//| Same as PSpline2Build() function, but for 3D, so we won't        |
//| duplicate its description here.                                  |
//+------------------------------------------------------------------+
void CAlglib::PSpline3Build(CMatrixDouble &xy,const int n,const int st,
                            const int pt,CPSpline3InterpolantShell &p)
  {
   CPSpline::PSpline3Build(xy,n,st,pt,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function builds periodic 2-dimensional parametric spline    |
//| which starts at (X[0],Y[0]), goes through all points to          |
//| (X[N-1],Y[N-1]) and then back to (X[0],Y[0]).                    |
//| INPUT PARAMETERS:                                                |
//|     XY  -   points, array[0..N-1,0..1].                          |
//|             XY[I,0:1] corresponds to the Ith point.              |
//|             XY[N-1,0:1] must be different from XY[0,0:1].        |
//|             Order of points is important!                        |
//|     N   -   points count, N>=3 for other types of splines.       |
//|     ST  -   spline type:                                         |
//|             * 1     Catmull-Rom spline (Tension=0) with cyclic   |
//|                     boundary conditions                          |
//|             * 2     cubic spline with cyclic boundary conditions |
//|     PT  -   parameterization type:                               |
//|             * 0     uniform                                      |
//|             * 1     chord length                                 |
//|             * 2     centripetal                                  |
//| OUTPUT PARAMETERS:                                               |
//|     P   -   parametric spline interpolant                        |
//| NOTES:                                                           |
//| * this function assumes that there all consequent points are     |
//|   distinct. I.e. (x0,y0)<>(x1,y1), (x1,y1)<>(x2,y2),             |
//|   (x2,y2)<>(x3,y3) and so on. However, non-consequent points may |
//|   coincide, i.e. we can  have (x0,y0) = (x2,y2).                 |
//| * last point of sequence is NOT equal to the first point. You    |
//|   shouldn't make curve "explicitly periodic" by making them      |
//|   equal.                                                         |
//+------------------------------------------------------------------+
void CAlglib::PSpline2BuildPeriodic(CMatrixDouble &xy,const int n,
                                    const int st,const int pt,
                                    CPSpline2InterpolantShell &p)
  {
   CPSpline::PSpline2BuildPeriodic(xy,n,st,pt,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function builds periodic 3-dimensional parametric spline    |
//| which starts at (X[0],Y[0],Z[0]), goes through all points to     |
//| (X[N-1],Y[N-1],Z[N-1]) and then back to (X[0],Y[0],Z[0]).        |
//| Same as PSpline2Build() function, but for 3D, so we won't        |
//| duplicate its description here.                                  |
//+------------------------------------------------------------------+
void CAlglib::PSpline3BuildPeriodic(CMatrixDouble &xy,const int n,
                                    const int st,const int pt,
                                    CPSpline3InterpolantShell &p)
  {
   CPSpline::PSpline3BuildPeriodic(xy,n,st,pt,p.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function returns vector of parameter values correspoding to |
//| points.                                                          |
//| I.e. for P created from (X[0],Y[0])...(X[N-1],Y[N-1]) and        |
//| U=TValues(P) we have                                             |
//|     (X[0],Y[0]) = PSpline2Calc(P,U[0]),                          |
//|     (X[1],Y[1]) = PSpline2Calc(P,U[1]),                          |
//|     (X[2],Y[2]) = PSpline2Calc(P,U[2]),                          |
//|     ...                                                          |
//| INPUT PARAMETERS:                                                |
//|     P   -   parametric spline interpolant                        |
//| OUTPUT PARAMETERS:                                               |
//|     N   -   array size                                           |
//|     T   -   array[0..N-1]                                        |
//| NOTES:                                                           |
//| * for non-periodic splines U[0]=0, U[0]<U[1]<...<U[N-1], U[N-1]=1|
//| * for periodic splines     U[0]=0, U[0]<U[1]<...<U[N-1], U[N-1]<1|
//+------------------------------------------------------------------+
void CAlglib::PSpline2ParameterValues(CPSpline2InterpolantShell &p,
                                      int &n,double &t[])
  {
//--- initialization
   n=0;
//--- function call
   CPSpline::PSpline2ParameterValues(p.GetInnerObj(),n,t);
  }
//+------------------------------------------------------------------+
//| This function returns vector of parameter values correspoding to |
//| points.                                                          |
//| Same as PSpline2ParameterValues(), but for 3D.                   |
//+------------------------------------------------------------------+
void CAlglib::PSpline3ParameterValues(CPSpline3InterpolantShell &p,
                                      int &n,double &t[])
  {
//--- initialization
   n=0;
//--- function call
   CPSpline::PSpline3ParameterValues(p.GetInnerObj(),n,t);
  }
//+------------------------------------------------------------------+
//| This function calculates the value of the parametric spline for a|
//| given value of parameter T                                       |
//| INPUT PARAMETERS:                                                |
//|     P   -   parametric spline interpolant                        |
//|     T   -   point:                                               |
//|             * T in [0,1] corresponds to interval spanned by      |
//|               points                                             |
//|             * for non-periodic splines T<0 (or T>1) correspond to|
//|               parts of the curve before the first (after the     |
//|               last) point                                        |
//|             * for periodic splines T<0 (or T>1) are projected    |
//|               into [0,1] by making T=T-floor(T).                 |
//| OUTPUT PARAMETERS:                                               |
//|     X   -   X-position                                           |
//|     Y   -   Y-position                                           |
//+------------------------------------------------------------------+
void CAlglib::PSpline2Calc(CPSpline2InterpolantShell &p,const double t,
                           double &x,double &y)
  {
//--- initialization
   x=0;
   y=0;
//--- function call
   CPSpline::PSpline2Calc(p.GetInnerObj(),t,x,y);
  }
//+------------------------------------------------------------------+
//| This function calculates the value of the parametric spline for a|
//| given value of parameter T.                                      |
//| INPUT PARAMETERS:                                                |
//|     P   -   parametric spline interpolant                        |
//|     T   -   point:                                               |
//|             * T in [0,1] corresponds to interval spanned by      |
//|               points                                             |
//|             * for non-periodic splines T<0 (or T>1) correspond   |
//|               to parts of the curve before the first (after the  |
//|               last) point                                        |
//|             * for periodic splines T<0 (or T>1) are projected    |
//|               into [0,1] by making T=T-floor(T).                 |
//| OUTPUT PARAMETERS:                                               |
//|     X   -   X-position                                           |
//|     Y   -   Y-position                                           |
//|     Z   -   Z-position                                           |
//+------------------------------------------------------------------+
void CAlglib::PSpline3Calc(CPSpline3InterpolantShell &p,const double t,
                           double &x,double &y,double &z)
  {
//--- initialization
   x=0;
   y=0;
   z=0;
//--- function call
   CPSpline::PSpline3Calc(p.GetInnerObj(),t,x,y,z);
  }
//+------------------------------------------------------------------+
//| This function calculates tangent vector for a given value of     |
//| parameter T                                                      |
//| INPUT PARAMETERS:                                                |
//|     P   -   parametric spline interpolant                        |
//|     T   -   point:                                               |
//|             * T in [0,1] corresponds to interval spanned by      |
//|               points                                             |
//|             * for non-periodic splines T<0 (or T>1) correspond to|
//|               parts of the curve before the first (after the     |
//|               last) point                                        |
//|             * for periodic splines T<0 (or T>1) are projected    |
//|               into [0,1] by making T=T-floor(T).                 |
//| OUTPUT PARAMETERS:                                               |
//|     X    -   X-component of tangent vector (normalized)          |
//|     Y    -   Y-component of tangent vector (normalized)          |
//| NOTE:                                                            |
//|     X^2+Y^2 is either 1 (for non-zero tangent vector) or 0.      |
//+------------------------------------------------------------------+
void CAlglib::PSpline2Tangent(CPSpline2InterpolantShell &p,const double t,
                              double &x,double &y)
  {
//--- initialization
   x=0;
   y=0;
//--- function call
   CPSpline::PSpline2Tangent(p.GetInnerObj(),t,x,y);
  }
//+------------------------------------------------------------------+
//| This function calculates tangent vector for a given value of     |
//| parameter T                                                      |
//| INPUT PARAMETERS:                                                |
//|     P   -   parametric spline interpolant                        |
//|     T   -   point:                                               |
//|             * T in [0,1] corresponds to interval spanned by      |
//|               points                                             |
//|             * for non-periodic splines T<0 (or T>1) correspond to|
//|               parts of the curve before the first (after the     |
//|               last) point                                        |
//|             * for periodic splines T<0 (or T>1) are projected    |
//|               into [0,1] by making T=T-floor(T).                 |
//| OUTPUT PARAMETERS:                                               |
//|     X    -   X-component of tangent vector (normalized)          |
//|     Y    -   Y-component of tangent vector (normalized)          |
//|     Z    -   Z-component of tangent vector (normalized)          |
//| NOTE:                                                            |
//|     X^2+Y^2+Z^2 is either 1 (for non-zero tangent vector) or 0.  |
//+------------------------------------------------------------------+
void CAlglib::PSpline3Tangent(CPSpline3InterpolantShell &p,const double t,
                              double &x,double &y,double &z)
  {
//--- initialization
   x=0;
   y=0;
   z=0;
//--- function call
   CPSpline::PSpline3Tangent(p.GetInnerObj(),t,x,y,z);
  }
//+------------------------------------------------------------------+
//| This function calculates derivative, i.e. it returns             |
//| (dX/dT,dY/dT).                                                   |
//| INPUT PARAMETERS:                                                |
//|     P   -   parametric spline interpolant                        |
//|     T   -   point:                                               |
//|             * T in [0,1] corresponds to interval spanned by      |
//|               points                                             |
//|             * for non-periodic splines T<0 (or T>1) correspond to|
//|               parts of the curve before the first (after the     |
//|               last) point                                        |
//|             * for periodic splines T<0 (or T>1) are projected    |
//|               into [0,1] by making T=T-floor(T).                 |
//| OUTPUT PARAMETERS:                                               |
//|     X   -   X-value                                              |
//|     DX  -   X-derivative                                         |
//|     Y   -   Y-value                                              |
//|     DY  -   Y-derivative                                         |
//+------------------------------------------------------------------+
void CAlglib::PSpline2Diff(CPSpline2InterpolantShell &p,const double t,
                           double &x,double &dx,double &y,double &dy)
  {
//--- initialization
   x=0;
   dx=0;
   y=0;
   dy=0;
//--- function call
   CPSpline::PSpline2Diff(p.GetInnerObj(),t,x,dx,y,dy);
  }
//+------------------------------------------------------------------+
//| This function calculates derivative, i.e. it returns             |
//| (dX/dT,dY/dT,dZ/dT).                                             |
//| INPUT PARAMETERS:                                                |
//|     P   -   parametric spline interpolant                        |
//|     T   -   point:                                               |
//|             * T in [0,1] corresponds to interval spanned by      |
//|               points                                             |
//|             * for non-periodic splines T<0 (or T>1) correspond to|
//|               parts of the curve before the first (after the     |
//|               last) point                                        |
//|             * for periodic splines T<0 (or T>1) are projected    |
//|               into [0,1] by making T=T-floor(T).                 |
//| OUTPUT PARAMETERS:                                               |
//|     X   -   X-value                                              |
//|     DX  -   X-derivative                                         |
//|     Y   -   Y-value                                              |
//|     DY  -   Y-derivative                                         |
//|     Z   -   Z-value                                              |
//|     DZ  -   Z-derivative                                         |
//+------------------------------------------------------------------+
void CAlglib::PSpline3Diff(CPSpline3InterpolantShell &p,const double t,
                           double &x,double &dx,double &y,double &dy
                           ,double &z,double &dz)
  {
//--- initialization
   x=0;
   dx=0;
   y=0;
   dy=0;
   z=0;
   dz=0;
//--- function call
   CPSpline::PSpline3Diff(p.GetInnerObj(),t,x,dx,y,dy,z,dz);
  }
//+------------------------------------------------------------------+
//| This function calculates first and second derivative with respect|
//| to T.                                                            |
//| INPUT PARAMETERS:                                                |
//|     P   -   parametric spline interpolant                        |
//|     T   -   point:                                               |
//|             * T in [0,1] corresponds to interval spanned by      |
//|               points                                             |
//|             * for non-periodic splines T<0 (or T>1) correspond to|
//|               parts of the curve before the first (after the     |
//|               last) point                                        |
//|             * for periodic splines T<0 (or T>1) are projected    |
//|               into [0,1] by making T=T-floor(T).                 |
//| OUTPUT PARAMETERS:                                               |
//|     X   -   X-value                                              |
//|     DX  -   derivative                                           |
//|     D2X -   second derivative                                    |
//|     Y   -   Y-value                                              |
//|     DY  -   derivative                                           |
//|     D2Y -   second derivative                                    |
//+------------------------------------------------------------------+
void CAlglib::PSpline2Diff2(CPSpline2InterpolantShell &p,const double t,
                            double &x,double &dx,double &d2x,double &y,
                            double &dy,double &d2y)
  {
//--- initialization
   x=0;
   dx=0;
   d2x=0;
   y=0;
   dy=0;
   d2y=0;
//--- function call
   CPSpline::PSpline2Diff2(p.GetInnerObj(),t,x,dx,d2x,y,dy,d2y);
  }
//+------------------------------------------------------------------+
//| This function calculates first and second derivative with respect|
//| to T.                                                            |
//| INPUT PARAMETERS:                                                |
//|     P   -   parametric spline interpolant                        |
//|     T   -   point:                                               |
//|             * T in [0,1] corresponds to interval spanned by      |
//|               points                                             |
//|             * for non-periodic splines T<0 (or T>1) correspond to|
//|               parts of the curve before the first (after the     |
//|               last) point                                        |
//|             * for periodic splines T<0 (or T>1) are projected    |
//|               into [0,1] by making T=T-floor(T).                 |
//| OUTPUT PARAMETERS:                                               |
//|     X   -   X-value                                              |
//|     DX  -   derivative                                           |
//|     D2X -   second derivative                                    |
//|     Y   -   Y-value                                              |
//|     DY  -   derivative                                           |
//|     D2Y -   second derivative                                    |
//|     Z   -   Z-value                                              |
//|     DZ  -   derivative                                           |
//|     D2Z -   second derivative                                    |
//+------------------------------------------------------------------+
void CAlglib::PSpline3Diff2(CPSpline3InterpolantShell &p,const double t,
                            double &x,double &dx,double &d2x,double &y,
                            double &dy,double &d2y,double &z,
                            double &dz,double &d2z)
  {
//--- initialization
   x=0;
   dx=0;
   d2x=0;
   y=0;
   dy=0;
   d2y=0;
   z=0;
   dz=0;
   d2z=0;
//--- function call
   CPSpline::PSpline3Diff2(p.GetInnerObj(),t,x,dx,d2x,y,dy,d2y,z,dz,d2z);
  }
//+------------------------------------------------------------------+
//| This function calculates arc length, i.e. length of curve between|
//| t=a and t=b.                                                     |
//| INPUT PARAMETERS:                                                |
//|     P   -   parametric spline interpolant                        |
//|     A,B -   parameter values corresponding to arc ends:          |
//|             * B>A will result in positive length returned        |
//|             * B<A will result in negative length returned        |
//| RESULT:                                                          |
//|     length of arc starting at T=A and ending at T=B.             |
//+------------------------------------------------------------------+
double CAlglib::PSpline2ArcLength(CPSpline2InterpolantShell &p,
                                  const double a,const double b)
  {
   return(CPSpline::PSpline2ArcLength(p.GetInnerObj(),a,b));
  }
//+------------------------------------------------------------------+
//| This function calculates arc length, i.e. length of curve between|
//| t=a and t=b.                                                     |
//| INPUT PARAMETERS:                                                |
//|     P   -   parametric spline interpolant                        |
//|     A,B -   parameter values corresponding to arc ends:          |
//|             * B>A will result in positive length returned        |
//|             * B<A will result in negative length returned        |
//| RESULT:                                                          |
//|     length of arc starting at T=A and ending at T=B.             |
//+------------------------------------------------------------------+
double CAlglib::PSpline3ArcLength(CPSpline3InterpolantShell &p,
                                  const double a,const double b)
  {
   return(CPSpline::PSpline3ArcLength(p.GetInnerObj(),a,b));
  }
//+------------------------------------------------------------------+
//| This subroutine fits piecewise linear curve to points with       |
//| Ramer-Douglas-Peucker algorithm. This  function  performs        |
//| PARAMETRIC fit, i.e. it can be used to fit curves like circles.  |
//| On  input  it  accepts dataset which describes parametric        |
//| multidimensional curve X(t), with X being vector, and t taking   |
//| values in [0,N), where N  is a number of points in dataset. As   |
//| result, it returns reduced  dataset  X2, which can be used to    |
//| build  parametric  curve  X2(t),  which  approximates X(t) with  |
//| desired precision (or has specified number of sections).         |
//| INPUT PARAMETERS:                                                |
//|   X        -  array of multidimensional points:                  |
//|               * at least N elements, leading N elements are used |
//|                 if more than N elements were specified           |
//|               * order of points is IMPORTANT because  it  is     |
//|                 parametric fit                                   |
//|               * each row of array is one point which has D       |
//|                 coordinates                                      |
//|   N        -  number of elements in X                            |
//|   D        -  number of dimensions (elements per row of X)       |
//|   StopM    -  stopping condition - desired number of sections:   |
//|               * at most M sections are generated by this function|
//|               * less than M sections can be generated if we have |
//|                 N<M (or some X are non-distinct).                |
//|               * zero StopM means that algorithm does not stop    |
//|                 after achieving some pre-specified section count |
//|   StopEps  -  stopping condition - desired precision:            |
//|               * algorithm stops after error in each section is at|
//|                 most Eps                                         |
//|               * zero Eps means that algorithm does not stop after|
//|                 achieving some pre-specified precision           |
//| OUTPUT PARAMETERS:                                               |
//|   X2       -  array of corner points for piecewise approximation,|
//|               has length NSections+1 or zero (for NSections=0).  |
//|   Idx2     -  array of indexes (parameter values):               |
//|               * has length NSections+1 or zero (for NSections=0).|
//|               * each element of Idx2 corresponds to same-numbered|
//|                 element of X2                                    |
//|               * each element of Idx2 is index of  corresponding  |
//|                 element of X2 at original array X, i.e. I-th row |
//|                 of X2 is Idx2[I]-th row of X.                    |
//|               * elements of Idx2 can be treated as parameter     |
//|                 values which should be used when building new    |
//|                 parametric curve                                 |
//|               * Idx2[0]=0, Idx2[NSections]=N-1                   |
//|   NSections - number of sections found by algorithm,NSections<=M,|
//|               NSections can be zero for degenerate datasets (N<=1|
//|               or all X[] are non-distinct).                      |
//| NOTE: algorithm stops after:                                     |
//|   a) dividing curve into StopM sections                          |
//|   b) achieving required precision StopEps                        |
//|   c) dividing curve into N-1 sections                            |
//| If both StopM and StopEps are non-zero, algorithm is stopped by  |
//| the FIRST criterion which is satisfied. In case both StopM and   |
//| StopEps are zero, algorithm stops because of (c).                |
//+------------------------------------------------------------------+
void CAlglib::ParametricRDPFixed(CMatrixDouble &x,int n,int d,
                                 int stopm,double stopeps,
                                 CMatrixDouble &x2,int &idx2[],
                                 int &nsections)
  {
   CPSpline::ParametricRDPFixed(x,n,d,stopm,stopeps,x2,idx2,nsections);
  }
//+------------------------------------------------------------------+
//| This function serializes data structure to string.               |
//| Important properties of s_out:                                   |
//|   * it contains alphanumeric characters, dots, underscores, minus|
//|     signs                                                        |
//|   * these symbols are grouped into words, which are separated by |
//|     spaces and Windows-style (CR+LF) newlines                    |
//|   * although  serializer  uses  spaces and CR+LF as separators,  |
//|     you can  replace any separator character by arbitrary        |
//|     combination of spaces, tabs, Windows or Unix newlines. It    |
//|     allows flexible reformatting  of the  string  in  case you   |
//|     want to include it into text or XML file. But you should not |
//|     insert separators into the middle of the "words" nor you     |
//|     should change case of letters.                               |
//|   * s_out can be freely moved between 32-bit and 64-bit systems, |
//|     little and big endian machines, and so on. You can serialize |
//|     structure on 32-bit machine and unserialize it on 64-bit one |
//|     (or vice versa), or serialize it on  SPARC  and  unserialize |
//|     on x86. You can also serialize it in C# version of ALGLIB and|
//|     unserialize in C++ one, and vice versa.                      |
//+------------------------------------------------------------------+
void CAlglib::Spline2DSerialize(CSpline2DInterpolantShell &obj,string &s_out)
  {
//--- create a variable
   CSerializer s;
//--- serialization start
   s.Alloc_Start();
//--- function call
   CSpline2D::Spline2DAlloc(s,obj.GetInnerObj());
//--- serialization
   s.SStart_Str();
   CSpline2D::Spline2DSerialize(s,obj.GetInnerObj());
   s.Stop();
   s_out=s.Get_String();
  }
//+------------------------------------------------------------------+
//| This function unserializes data structure from string.           |
//+------------------------------------------------------------------+
void CAlglib::Spline2DUnserialize(string s_in,CSpline2DInterpolantShell &obj)
  {
   CSerializer s;
   s.UStart_Str(s_in);
   CSpline2D::Spline2DUnserialize(s,obj.GetInnerObj());
   s.Stop();
  }
//+------------------------------------------------------------------+
//| This subroutine builds bilinear vector-valued spline.            |
//| Input parameters:                                                |
//|   X        -  spline abscissas, array[0..N-1]                    |
//|   Y        -  spline ordinates, array[0..M-1]                    |
//|   F        -  function values, array[0..M*N*D-1]:                |
//|               * first D elements store D values at (X[0],Y[0])   |
//|               * next D elements store D values at (X[1],Y[0])    |
//|               * general form - D function values at (X[i],Y[j])  |
//|                 are stored at F[D*(J*N+I)...D*(J*N+I)+D-1].      |
//|   M,N      -  grid size, M>=2, N>=2                              |
//|   D        -  vector dimension, D>=1                             |
//| Output parameters:                                               |
//|   C        -  spline interpolant                                 |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuildBilinearV(CRowDouble &x,int n,CRowDouble &y,
                                     int m,CRowDouble &f,int d,
                                     CSpline2DInterpolantShell &c)
  {
   CSpline2D::Spline2DBuildBilinearV(x,n,y,m,f,d,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine builds bicubic vector-valued spline.             |
//| Input parameters:                                                |
//|   X        -  spline abscissas, array[0..N-1]                    |
//|   Y        -  spline ordinates, array[0..M-1]                    |
//|   F        -  function values, array[0..M*N*D-1]:                |
//|               * first D elements store D values at (X[0],Y[0])   |
//|               * next D elements store D values at (X[1],Y[0])    |
//|               * general form - D function values at (X[i],Y[j])  |
//|                 are stored at F[D*(J*N+I)...D*(J*N+I)+D-1].      |
//|   M,N      -  grid size, M>=2, N>=2                              |
//|   D        -  vector dimension, D>=1                             |
//| Output parameters:                                               |
//|   C        -  spline interpolant                                 |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuildBicubicV(CRowDouble &x,int n,CRowDouble &y,
                                    int m,CRowDouble &f,int d,
                                    CSpline2DInterpolantShell &c)
  {
   CSpline2D::Spline2DBuildBicubicV(x,n,y,m,f,d,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine unpacks two-dimensional spline into the          |
//| coefficients table                                               |
//| Input parameters:                                                |
//|   C        -  spline interpolant.                                |
//| Result:                                                          |
//|   M, N     -  grid size (x-axis and y-axis)                      |
//|   D        -  number of components                               |
//|   Tbl      -  coefficients table, unpacked format,               |
//|   D        -  components: [0..(N-1)*(M-1)*D-1, 0..19].           |
//| For T=0..D-1 (component index), I = 0...N-2 (x index), J=0..M-2  |
//| (y index):                                                       |
//|               K :=  T + I*D + J*D*(N-1)                          |
//| K-th row stores decomposition for T-th component of the          |
//| vector-valued function                                           |
//|         Tbl[K,0] = X[i]                                          |
//|         Tbl[K,1] = X[i+1]                                        |
//|         Tbl[K,2] = Y[j]                                          |
//|         Tbl[K,3] = Y[j+1]                                        |
//|         Tbl[K,4] = C00                                           |
//|         Tbl[K,5] = C01                                           |
//|         Tbl[K,6] = C02                                           |
//|         Tbl[K,7] = C03                                           |
//|         Tbl[K,8] = C10                                           |
//|         Tbl[K,9] = C11                                           |
//|               ...                                                |
//|         Tbl[K,19] = C33                                          |
//| On each grid square spline is equals to:                         |
//|         S(x) = SUM(c[i,j]*(t^i)*(u^j), i=0..3, j=0..3)           |
//|            t = x-x[j]                                            |
//|            u = y-y[i]                                            |
//+------------------------------------------------------------------+
void CAlglib::Spline2DUnpackV(CSpline2DInterpolantShell &c,int &m,
                              int &n,int &d,CMatrixDouble &tbl)
  {
   CSpline2D::Spline2DUnpackV(c.GetInnerObj(),m,n,d,tbl);
  }
//+------------------------------------------------------------------+
//| This subroutine was deprecated in ALGLIB 3.6.0                   |
//| We recommend you to switch  to  Spline2DBuildBilinearV(),        |
//| which  is  more flexible and accepts its arguments in more       |
//| convenient order.                                                |
//| This subroutine builds bilinear spline coefficients table.       |
//| Input parameters:                                                |
//|     X   -   spline abscissas, array[0..N-1]                      |
//|     Y   -   spline ordinates, array[0..M-1]                      |
//|     F   -   function values, array[0..M-1,0..N-1]                |
//|     M,N -   grid size, M>=2, N>=2                                |
//| Output parameters:                                               |
//|     C   -   spline interpolant                                   |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuildBilinear(double &x[],double &y[],
                                    CMatrixDouble &f,const int m,
                                    const int n,CSpline2DInterpolantShell &c)
  {
   CSpline2D::Spline2DBuildBilinear(x,y,f,m,n,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine was deprecated in ALGLIB 3.6.0                   |
//| We recommend you to switch  to  Spline2DBuildBicubicV(),  which  |
//| is  more flexible and accepts its arguments in more convenient   |
//| order.                                                           |
//| This subroutine builds bicubic spline coefficients table.        |
//| Input parameters:                                                |
//|     X   -   spline abscissas, array[0..N-1]                      |
//|     Y   -   spline ordinates, array[0..M-1]                      |
//|     F   -   function values, array[0..M-1,0..N-1]                |
//|     M,N -   grid size, M>=2, N>=2                                |
//| Output parameters:                                               |
//|     C   -   spline interpolant                                   |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuildBicubic(double &x[],double &y[],CMatrixDouble &f,
                                   const int m,const int n,
                                   CSpline2DInterpolantShell &c)
  {
   CSpline2D::Spline2DBuildBicubic(x,y,f,m,n,c.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine calculates the value of the bilinear or bicubic  |
//| spline at the given point X.                                     |
//| Input parameters:                                                |
//|     C   -   coefficients table.                                  |
//|             Built by BuildBilinearSpline or BuildBicubicSpline.  |
//|     X, Y-   point                                                |
//| Result:                                                          |
//|     S(x,y)                                                       |
//+------------------------------------------------------------------+
double CAlglib::Spline2DCalc(CSpline2DInterpolantShell &c,
                             const double x,const double y)
  {
   return(CSpline2D::Spline2DCalc(c.GetInnerObj(),x,y));
  }
//+------------------------------------------------------------------+
//| This subroutine calculates the value of the bilinear or bicubic  |
//| spline at the given point X and its derivatives.                 |
//| Input parameters:                                                |
//|     C   -   spline interpolant.                                  |
//|     X, Y-   point                                                |
//| Output parameters:                                               |
//|     F   -   S(x,y)                                               |
//|     FX  -   dS(x,y)/dX                                           |
//|     FY  -   dS(x,y)/dY                                           |
//|     FXY -   d2S(x,y)/dXdY                                        |
//+------------------------------------------------------------------+
void CAlglib::Spline2DDiff(CSpline2DInterpolantShell &c,const double x,
                           const double y,double &f,double &fx,
                           double &fy,double &fxy)
  {
//--- initialization
   f=0;
   fx=0;
   fy=0;
   fxy=0;
//--- function call
   CSpline2D::Spline2DDiff(c.GetInnerObj(),x,y,f,fx,fy,fxy);
  }
//+------------------------------------------------------------------+
//| This subroutine calculates bilinear or bicubic vector-valued     |
//| spline at the given point (X,Y).                                 |
//| If you need just some specific component of vector-valued spline,|
//| you can use Spline2DCalcVi() function.                           |
//| INPUT PARAMETERS:                                                |
//|   C        -  spline interpolant.                                |
//|   X, Y     -  point                                              |
//|   F        -  output buffer, possibly preallocated array. In case|
//|               array size is large enough to store result, it is  |
//|               not reallocated.  Array which is too short will be |
//|               reallocated                                        |
//| OUTPUT PARAMETERS:                                               |
//|   F        -   array[D] (or larger) which stores function values |
//+------------------------------------------------------------------+
void CAlglib::Spline2DCalcVBuf(CSpline2DInterpolantShell &c,double x,
                               double y,CRowDouble &f)
  {
   CSpline2D::Spline2DCalcVBuf(c.GetInnerObj(),x,y,f);
  }
//+------------------------------------------------------------------+
//| This subroutine calculates specific component of vector-valued   |
//| bilinear or bicubic spline at the given point (X,Y).             |
//| INPUT PARAMETERS:                                                |
//|   C        -  spline interpolant.                                |
//|   X, Y     -  point                                              |
//|   I        -  component index, in [0,D). An exception is         |
//|               generated for out of range values.                 |
//| RESULT:                                                          |
//|   value of I-th component                                        |
//+------------------------------------------------------------------+
double CAlglib::Spline2DCalcVi(CSpline2DInterpolantShell &c,double x,
                               double y,int i)
  {
   return(CSpline2D::Spline2DCalcVi(c.GetInnerObj(),x,y,i));
  }
//+------------------------------------------------------------------+
//| This subroutine calculates bilinear or bicubic vector-valued     |
//| spline at the given point (X,Y).                                 |
//| INPUT PARAMETERS:                                                |
//|   C        -  spline interpolant.                                |
//|   X, Y     -  point                                              |
//| OUTPUT PARAMETERS:                                               |
//|   F        -  array[D] which stores function values. F is        |
//|               out-parameter and it is reallocated after call to  |
//|               this function. In case you want to reuse previously|
//|               allocated F, you may use Spline2DCalcVBuf(), which |
//|               reallocates F only when it is too small.           |
//+------------------------------------------------------------------+
void CAlglib::Spline2DCalcV(CSpline2DInterpolantShell &c,double x,
                            double y,CRowDouble &f)
  {
   CSpline2D::Spline2DCalcV(c.GetInnerObj(),x,y,f);
  }
//+------------------------------------------------------------------+
//| This subroutine calculates value of specific component of        |
//| bilinear or bicubic vector-valued spline and its derivatives.    |
//| Input parameters:                                                |
//|   C        -  spline interpolant.                                |
//|   X, Y     -  point                                              |
//|   I        -  component index, in [0,D)                          |
//| Output parameters:                                               |
//|   F        -  S(x,y)                                             |
//|   FX       -  dS(x,y)/dX                                         |
//|   FY       -  dS(x,y)/dY                                         |
//|   FXY      -  d2S(x,y)/dXdY                                      |
//+------------------------------------------------------------------+
void CAlglib::Spline2DDiffVi(CSpline2DInterpolantShell &c,double x,
                             double y,int i,double &f,double &fx,
                             double &fy,double &fxy)
  {
   CSpline2D::Spline2DDiffVi(c.GetInnerObj(),x,y,i,f,fx,fy,fxy);
  }
//+------------------------------------------------------------------+
//| This subroutine was deprecated in ALGLIB 3.6.0                   |
//| We recommend you to switch  to  Spline2DUnpackV(),  which is     |
//| more flexible and accepts its arguments in more convenient order.|
//| This subroutine unpacks two-dimensional spline into the          |
//| coefficients table                                               |
//| Input parameters:                                                |
//|     C   -   spline interpolant.                                  |
//| Result:                                                          |
//|     M, N-   grid size (x-axis and y-axis)                        |
//|     Tbl -   coefficients table, unpacked format,                 |
//|             [0..(N-1)*(M-1)-1, 0..19].                           |
//|             For I = 0...M-2, J=0..N-2:                           |
//|                 K =  I*(N-1)+J                                   |
//|                 Tbl[K,0] = X[j]                                  |
//|                 Tbl[K,1] = X[j+1]                                |
//|                 Tbl[K,2] = Y[i]                                  |
//|                 Tbl[K,3] = Y[i+1]                                |
//|                 Tbl[K,4] = C00                                   |
//|                 Tbl[K,5] = C01                                   |
//|                 Tbl[K,6] = C02                                   |
//|                 Tbl[K,7] = C03                                   |
//|                 Tbl[K,8] = C10                                   |
//|                 Tbl[K,9] = C11                                   |
//|                 ...                                              |
//|                 Tbl[K,19] = C33                                  |
//|             On each grid square spline is equals to:             |
//|                 S(x) = SUM(c[i,j]*(x^i)*(y^j), i=0..3, j=0..3)   |
//|                 t = x-x[j]                                       |
//|                 u = y-y[i]                                       |
//+------------------------------------------------------------------+
void CAlglib::Spline2DUnpack(CSpline2DInterpolantShell &c,int &m,
                             int &n,CMatrixDouble &tbl)
  {
//--- initialization
   m=0;
   n=0;
//--- function call
   CSpline2D::Spline2DUnpack(c.GetInnerObj(),m,n,tbl);
  }
//+------------------------------------------------------------------+
//| This subroutine performs linear transformation of the spline     |
//| argument.                                                        |
//| Input parameters:                                                |
//|     C       -   spline interpolant                               |
//|     AX, BX  -   transformation coefficients: x = A*t + B         |
//|     AY, BY  -   transformation coefficients: y = A*u + B         |
//| Result:                                                          |
//|     C   -   transformed spline                                   |
//+------------------------------------------------------------------+
void CAlglib::Spline2DLinTransXY(CSpline2DInterpolantShell &c,
                                 const double ax,const double bx,
                                 const double ay,const double by)
  {
   CSpline2D::Spline2DLinTransXY(c.GetInnerObj(),ax,bx,ay,by);
  }
//+------------------------------------------------------------------+
//| This subroutine performs linear transformation of the spline.    |
//| Input parameters:                                                |
//|     C   -   spline interpolant.                                  |
//|     A, B-   transformation coefficients: S2(x,y) = A*S(x,y) + B  |
//| Output parameters:                                               |
//|     C   -   transformed spline                                   |
//+------------------------------------------------------------------+
void CAlglib::Spline2DLinTransF(CSpline2DInterpolantShell &c,
                                const double a,const double b)
  {
   CSpline2D::Spline2DLinTransF(c.GetInnerObj(),a,b);
  }
//+------------------------------------------------------------------+
//| This subroutine makes the copy of the spline model.              |
//| Input parameters:                                                |
//|     C   -   spline interpolant                                   |
//| Output parameters:                                               |
//|     CC  -   spline copy                                          |
//+------------------------------------------------------------------+
void CAlglib::Spline2DCopy(CSpline2DInterpolantShell &c,
                           CSpline2DInterpolantShell &cc)
  {
   CSpline2D::Spline2DCopy(c.GetInnerObj(),cc.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Bicubic spline resampling                                        |
//| Input parameters:                                                |
//|     A           -   function values at the old grid,             |
//|                     array[0..OldHeight-1, 0..OldWidth-1]         |
//|     OldHeight   -   old grid height, OldHeight>1                 |
//|     OldWidth    -   old grid width, OldWidth>1                   |
//|     NewHeight   -   new grid height, NewHeight>1                 |
//|     NewWidth    -   new grid width, NewWidth>1                   |
//| Output parameters:                                               |
//|     B           -   function values at the new grid,             |
//|                     array[0..NewHeight-1, 0..NewWidth-1]         |
//+------------------------------------------------------------------+
void CAlglib::Spline2DResampleBicubic(CMatrixDouble &a,const int oldheight,
                                      const int oldwidth,CMatrixDouble &b,
                                      const int newheight,const int newwidth)
  {
   CSpline2D::Spline2DResampleBicubic(a,oldheight,oldwidth,b,newheight,newwidth);
  }
//+------------------------------------------------------------------+
//| Bilinear spline resampling                                       |
//| Input parameters:                                                |
//|     A           -   function values at the old grid,             |
//|                     array[0..OldHeight-1, 0..OldWidth-1]         |
//|     OldHeight   -   old grid height, OldHeight>1                 |
//|     OldWidth    -   old grid width, OldWidth>1                   |
//|     NewHeight   -   new grid height, NewHeight>1                 |
//|     NewWidth    -   new grid width, NewWidth>1                   |
//| Output parameters:                                               |
//|     B           -   function values at the new grid,             |
//|                     array[0..NewHeight-1, 0..NewWidth-1]         |
//+------------------------------------------------------------------+
void CAlglib::Spline2DResampleBilinear(CMatrixDouble &a,const int oldheight,
                                       const int oldwidth,CMatrixDouble &b,
                                       const int newheight,const int newwidth)
  {
   CSpline2D::Spline2DResampleBilinear(a,oldheight,oldwidth,b,newheight,newwidth);
  }
//+------------------------------------------------------------------+
//| This subroutine creates least squares solver used to fit 2D      |
//| splines to irregularly sampled (scattered) data.                 |
//| Solver object is used to perform spline fits as follows:         |
//|   * solver object is created with Spline2DBuilderCreate()        |
//|     function                                                     |
//|   * dataset is added with Spline2DBuilderSetPoints() function    |
//|   * fit area is chosen:                                          |
//|      * Spline2DBuilderSetArea()    - for user-defined area       |
//|      * Spline2DBuilderSetAreaAuto()- for automatically chosen    |
//|                                      area                        |
//|   * number of grid nodes is chosen with Spline2DBuilderSetGrid() |
//|   * prior term is chosen with one of the following functions:    |
//|      * Spline2DBuilderSetLinTerm() to set linear prior           |
//|      * Spline2DBuilderSetConstTerm() to set constant prior       |
//|      * Spline2DBuilderSetZeroTerm() to set zero prior            |
//|      * Spline2DBuilderSetUserTerm() to set user-defined constant |
//|                                     prior                        |
//|   * solver algorithm is chosen with either:                      |
//|      * Spline2DBuilderSetAlgoBlockLLS()  -  BlockLLS algorithm,  |
//|                                             medium-scale problems|
//|      * Spline2DBuilderSetAlgoFastDDM()   -  FastDDM algorithm,   |
//|                                             large-scale problems |
//|   * finally, fitting itself is performed with Spline2DFit()      |
//|     function.                                                    |
//| Most of the steps above can be omitted, solver is configured with|
//| good defaults. The minimum is to call:                           |
//|   * Spline2DBuilderCreate() to create solver object              |
//|   * Spline2DBuilderSetPoints() to specify dataset                |
//|   * Spline2DBuilderSetGrid() to tell how many nodes you need     |
//|   * Spline2DFit() to perform fit                                 |
//| INPUT PARAMETERS:                                                |
//|   D        -  positive number, number of Y-components: D=1 for   |
//|               simple scalar fit, D>1 for vector-valued spline    |
//|               fitting.                                           |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  solver object                                      |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderCreate(int d,CSpline2DBuilder &state)
  {
   CSpline2D::Spline2DBuilderCreate(d,state);
  }
//+------------------------------------------------------------------+
//| This function sets constant prior term (model is a sum of bicubic|
//| spline and global prior, which can be linear, constant,          |
//| user-defined constant or zero).                                  |
//| Constant prior term is determined by least squares fitting.      |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline builder                                     |
//|   V        -  value for user-defined prior                       |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderSetUserTerm(CSpline2DBuilder &state,double v)
  {
   CSpline2D::Spline2DBuilderSetUserTerm(state,v);
  }
//+------------------------------------------------------------------+
//| This function sets linear prior term (model is a sum of bicubic  |
//| spline and global prior, which can be linear, constant,          |
//| user-defined constant or zero).                                  |
//| Linear prior term is determined by least squares fitting.        |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline builder                                     |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderSetLinTerm(CSpline2DBuilder &state)
  {
   CSpline2D::Spline2DBuilderSetLinTerm(state);
  }
//+------------------------------------------------------------------+
//| This function sets constant prior term (model is a sum of bicubic|
//| spline and global prior, which can be linear, constant,          |
//| user-defined constant or zero).                                  |
//| Constant prior term is determined by least squares fitting.      |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline builder                                     |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderSetConstTerm(CSpline2DBuilder &state)
  {
   CSpline2D::Spline2DBuilderSetConstTerm(state);
  }
//+------------------------------------------------------------------+
//| This function sets zero prior term (model is a sum of bicubic    |
//| spline and global prior, which can be linear, constant,          |
//| user-defined constant or zero).                                  |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline builder                                     |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderSetZeroTerm(CSpline2DBuilder &state)
  {
   CSpline2D::Spline2DBuilderSetZeroTerm(state);
  }
//+------------------------------------------------------------------+
//| This function adds dataset to the builder object.                |
//| This function overrides results of the previous calls, i.e.      |
//| multiple calls of this function will result in only the last     |
//| set being added.                                                 |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline 2D builder object                           |
//|   XY       -  points, array[N,2+D]. One row corresponds to one   |
//|               point in the dataset. First 2 elements are         |
//|               coordinates, next D elements are function values.  |
//|               Array may be larger than  specified, in this case  |
//|               only leading [N,NX+NY] elements will be used.      |
//|   N        -  number of points in the dataset                    |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderSetPoints(CSpline2DBuilder &state,
                                       CMatrixDouble &xy,int n)
  {
   CSpline2D::Spline2DBuilderSetPoints(state,xy,n);
  }
//+------------------------------------------------------------------+
//| This function sets area where 2D spline interpolant is built.    |
//| "Auto" means that area extent is determined automatically from   |
//| dataset extent.                                                  |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline 2D builder object                           |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderSetAreaAuto(CSpline2DBuilder &state)
  {
   CSpline2D::Spline2DBuilderSetAreaAuto(state);
  }
//+------------------------------------------------------------------+
//| This function sets area where 2D spline interpolant is  built to |
//| user-defined one: [XA,XB]*[YA,YB]                                |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline 2D builder object                           |
//|   XA,XB    -  spatial extent in the first (X) dimension, XA<XB   |
//|   YA,YB    -  spatial extent in the second (Y) dimension, YA<YB  |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderSetArea(CSpline2DBuilder &state,
                                     double xa,double xb,
                                     double ya,double yb)
  {
   CSpline2D::Spline2DBuilderSetArea(state,xa,xb,ya,yb);
  }
//+------------------------------------------------------------------+
//| This function sets nodes count for 2D spline interpolant. Fitting|
//| is performed on area defined with one of the "setarea" functions;|
//| this one sets number of nodes placed upon the fitting area.      |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline 2D builder object                           |
//|   KX       -  nodes count for the first (X) dimension; fitting   |
//|               interval [XA,XB] is separated into KX-1            |
//|               subintervals, with KX nodes created at the         |
//|               boundaries.                                        |
//|   KY       -  nodes count for the first (Y) dimension; fitting   |
//|               interval [YA,YB] is separated into KY-1            |
//|               subintervals, with KY nodes created at the         |
//|               boundaries.                                        |
//| NOTE: at least 4 nodes is created in each dimension, so KX and KY|
//|       are silently increased if needed.                          |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderSetGrid(CSpline2DBuilder &state,
                                     int kx,int ky)
  {
   CSpline2D::Spline2DBuilderSetGrid(state,kx,ky);
  }
//+------------------------------------------------------------------+
//| This function allows you to choose least squares solver used to  |
//| perform fitting. This function sets solver algorithm to "FastDDM"|
//| which performs fast parallel fitting by splitting problem into   |
//| smaller chunks and merging results together.                     |
//| This solver is optimized for large-scale problems, starting from |
//| 256x256 grids, and up to 10000x10000 grids. Of course, it will   |
//| work for smaller grids too.                                      |
//| More detailed description of the algorithm is given below:       |
//|   * algorithm generates hierarchy of nested grids, ranging from  |
//|     ~16x16 (topmost "layer" of the model) to ~KX*KY one (final   |
//|     layer). Upper layers model global behavior of the function,  |
//|     lower layers are used to model fine details. Moving from     |
//|     layer to layer doubles grid density.                         |
//|   * fitting is started from topmost layer, subsequent layers are |
//|     fitted using residuals from previous ones.                   |
//|   * user may choose to skip generation of upper layers and       |
//|     generate only a few bottom ones, which will result in much   |
//|     better performance and parallelization efficiency, at the    |
//|     cost of algorithm inability to "patch" large holes in the    |
//|     dataset.                                                     |
//|   * every layer is regularized using progressively increasing    |
//|     regularization coefficient; thus, increasing LambdaV         |
//|     penalizes fine details first, leaving lower frequencies      |
//|     almost intact for a while.                                   |
//|   * after fitting is done, all layers are merged together into   |
//|     one bicubic spline                                           |
//| IMPORTANT: regularization coefficient used by this solver is     |
//|            different from the one used by BlockLLS. Latter       |
//|            utilizes nonlinearity penalty, which is global in     |
//|            nature (large regularization results in global linear |
//|            trend being extracted); this solver uses another,     |
//|            localized form of penalty, which is suitable for      |
//|            parallel processing.                                  |
//| Notes on memory and performance:                                 |
//|   * memory requirements: most memory is consumed during modeling |
//|     of the higher layers; ~[512*NPoints] bytes is required for a |
//|     model with full hierarchy of grids being generated. However, |
//|     if you skip a few topmost layers, you will get nearly        |
//|     constant (wrt. points count and grid size) memory consumption|
//|   * serial running time: O(K*K)+O(NPoints) for a KxK grid        |
//|   * parallelism potential: good. You may get nearly linear       |
//|     speed-up when performing fitting with just a few layers.     |
//|     Adding more layers results in model becoming more global,    |
//|     which somewhat reduces efficiency of the parallel code.      |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline 2D builder object                           |
//|   NLayers  -  number of layers in the model:                     |
//|               * NLayers>=1 means that up to chosen number of     |
//|                 bottom layers is fitted                          |
//|               * NLayers=0 means that maximum number of layers is |
//|                 chosen (according to current grid size)          |
//|               * NLayers<=-1 means that up to |NLayers| topmost   |
//|                 layers is skipped                                |
//|               Recommendations:                                   |
//|              *good "default" value is 2 layers                 |
//|               * you may need more layers, if your dataset is very|
//|                 irregular and you want to "patch" large holes.   |
//|                 For a grid step H (equal to AreaWidth/GridSize)  |
//|                 you may expect that last layer reproduces        |
//|                 variations at distance H (and can patch holes    |
//|                 that wide); that higher layers operate at        |
//|                 distances 2*H, 4*H, 8*H and so on.               |
//|              *good value for "bullletproof" mode is NLayers=0, |
//|                 which results in complete hierarchy of layers    |
//|                 being generated.                                 |
//|   LambdaV  -  regularization coefficient, chosen in such a way   |
//|               that it penalizes bottom layers (fine details)     |
//|               first. LambdaV>=0, zero value means that no penalty|
//|               is applied.                                        |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderSetAlgoFastDDM(CSpline2DBuilder &state,
                                            int nlayers,double lambdav)
  {
   CSpline2D::Spline2DBuilderSetAlgoFastDDM(state,nlayers,lambdav);
  }
//+------------------------------------------------------------------+
//| This function allows you to choose least squares solver used to  |
//| perform fitting. This function sets solver algorithm to          |
//| "BlockLLS", which performs least squares fitting with fast sparse|
//| direct solver, with optional nonsmoothness penalty being applied.|
//| Nonlinearity penalty has the following form:                     |
//|                    [                                      ]      |
//| P()~Lambda*integral[(d2S/dx2)^2+2*(d2S/dxdy)^2+(d2S/dy2)^2]dxdy  |
//|                    [                                      ]      |
//| here integral is calculated over entire grid, and "~" means      |
//| "proportional" because integral is normalized after calcilation. |
//| Extremely large values of Lambda result in linear fit being      |
//| performed.                                                       |
//| NOTE: this algorithm is the most robust and controllable one, but|
//|       it is limited by 512x512 grids and (say) up to 1.000.000   |
//|       points. However, ALGLIB has one more spline solver: FastDDM|
//|       algorithm, which is intended for really large-scale        |
//|       problems (in 10M-100M range). FastDDM algorithm also has   |
//|       better parallelism properties.                             |
//| More information on BlockLLS solver:                             |
//|   * memory requirements: ~[32*K^3+256*NPoints] bytes for KxK grid|
//|     with NPoints-sized dataset                                   |
//|   * serial running time: O(K^4+NPoints)                          |
//|   * parallelism potential: limited. You may get some sublinear   |
//|     gain when working with large grids (K's in 256..512 range)   |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline 2D builder object                           |
//|   LambdaNS -  non-negative value:                                |
//|               * positive value means that some smoothing is      |
//|                 applied                                          |
//|               * zero value means that no smoothing is applied,   |
//|                 and corresponding entries of design matrix are   |
//|                 numerically zero and dropped from consideration. |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderSetAlgoBlockLLS(CSpline2DBuilder &state,
                                             double lambdans)
  {
   CSpline2D::Spline2DBuilderSetAlgoBlockLLS(state,lambdans);
  }

//+------------------------------------------------------------------+
//| This function allows you to choose least squares solver used to  |
//| perform fitting. This function sets solver algorithm to          |
//| "NaiveLLS".                                                      |
//| IMPORTANT: NaiveLLS is NOT intended to be used in real life code!|
//|            This algorithm solves problem by generated dense      |
//|            (K^2)x(K^2+NPoints) matrix and solves linear least    |
//|            squares problem with dense solver.                    |
//|            It is here just to test BlockLLS against reference    |
//|            solver (and maybe for someone trying to compare well  |
//|            optimized solver against straightforward approach to  |
//|            the LLS problem).                                     |
//| More information on naive LLS solver:                            |
//|   * memory requirements: ~[8*K^4+256*NPoints] bytes for KxK grid.|
//|   * serial running time: O(K^6+NPoints) for KxK grid             |
//|   * when compared with BlockLLS, NaiveLLS has ~K larger memory   |
//|     demand and ~K^2 larger running time.                         |
//| INPUT PARAMETERS:                                                |
//|   S        -  spline 2D builder object                           |
//|   LambdaNS -  nonsmoothness penalty                              |
//+------------------------------------------------------------------+
void CAlglib::Spline2DBuilderSetAlgoNaiveLLS(CSpline2DBuilder &state,
                                             double lambdans)
  {
   CSpline2D::Spline2DBuilderSetAlgoNaiveLLS(state,lambdans);
  }
//+------------------------------------------------------------------+
//| This function fits bicubic spline to current dataset, using      |
//| current area/grid and current LLS solver.                        |
//| INPUT PARAMETERS:                                                |
//|   State    -  spline 2D builder object                           |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  2D spline, fit result                              |
//|   Rep      -  fitting report, which provides some additional info|
//|               about errors, R2 coefficient and so on.            |
//+------------------------------------------------------------------+
void CAlglib::Spline2DFit(CSpline2DBuilder &state,
                          CSpline2DInterpolantShell &s,
                          CSpline2DFitReport &rep)
  {
   CSpline2D::Spline2DFit(state,s.GetInnerObj(),rep);
  }
//+------------------------------------------------------------------+
//| This subroutine calculates the value of the trilinear or tricubic|
//| spline at the given point (X,Y,Z).                               |
//| INPUT PARAMETERS:                                                |
//|   C        -  coefficients table. Built by BuildBilinearSpline or|
//|               BuildBicubicSpline.                                |
//|   X, Y,                                                          |
//|   Z        -  point                                              |
//| Result:                                                          |
//|   S(x,y,z)                                                       |
//+------------------------------------------------------------------+
double CAlglib::Spline3DCalc(CSpline3DInterpolant &c,double x,
                             double y,double z)
  {
   return(CSpline3D::Spline3DCalc(c,x,y,z));
  }
//+------------------------------------------------------------------+
//| This subroutine performs linear transformation of the spline     |
//| argument.                                                        |
//| INPUT PARAMETERS:                                                |
//|   C        -  spline interpolant                                 |
//|   AX, BX   -  transformation coefficients: x = A*u + B           |
//|   AY, BY   -  transformation coefficients: y = A*v + B           |
//|   AZ, BZ   -  transformation coefficients: z = A*w + B           |
//| OUTPUT PARAMETERS:                                               |
//|   C        -  transformed spline                                 |
//+------------------------------------------------------------------+
void CAlglib::Spline3DLinTransXYZ(CSpline3DInterpolant &c,double ax,
                                  double bx,double ay,double by,
                                  double az,double bz)
  {
   CSpline3D::Spline3DLinTransXYZ(c,ax,bx,ay,by,az,bz);
  }
//+------------------------------------------------------------------+
//| This subroutine performs linear transformation of the spline.    |
//| INPUT PARAMETERS:                                                |
//|   C        -  spline interpolant.                                |
//|   A, B     -  transformation coefficients: S2(x,y)=A*S(x,y,z)+B  |
//| OUTPUT PARAMETERS:                                               |
//|   C        -  transformed spline                                 |
//+------------------------------------------------------------------+
void CAlglib::Spline3DLinTransF(CSpline3DInterpolant &c,double a,
                                double b)
  {
   CSpline3D::Spline3DLinTransF(c,a,b);
  }
//+------------------------------------------------------------------+
//| Trilinear spline resampling                                      |
//| INPUT PARAMETERS:                                                |
//|   A        -  array[0..OldXCount*OldYCount*OldZCount-1], function|
//|               values at the old grid:                            |
//|               A[0]    x=0,y=0,z=0                                |
//|               A[1]    x=1,y=0,z=0                                |
//|               A[..]    ...                                       |
//|               A[..]    x=oldxcount-1,y=0,z=0                     |
//|               A[..]    x=0,y=1,z=0                               |
//|               A[..]    ...                                       |
//|                        ...                                       |
//|               OldZCount  -  old Z-count, OldZCount>1             |
//|               OldYCount  -  old Y-count, OldYCount>1             |
//|               OldXCount  -  old X-count, OldXCount>1             |
//|               NewZCount  -  new Z-count, NewZCount>1             |
//|               NewYCount  -  new Y-count, NewYCount>1             |
//|               NewXCount  -  new X-count, NewXCount>1             |
//| OUTPUT PARAMETERS:                                               |
//|   B        -  array[0..NewXCount*NewYCount*NewZCount-1], function|
//|               values at the new grid:                            |
//|               B[0]    x=0,y=0,z=0                                |
//|               B[1]    x=1,y=0,z=0                                |
//|               B[..]    ...                                       |
//|               B[..]    x=newxcount-1,y=0,z=0                     |
//|               B[..]    x=0,y=1,z=0                               |
//|               B[..]    ...                                       |
//|                        ...                                       |
//+------------------------------------------------------------------+
void CAlglib::Spline3DResampleTrilinear(CRowDouble &a,int oldzcount,
                                        int oldycount,int oldxcount,
                                        int newzcount,int newycount,
                                        int newxcount,CRowDouble &b)
  {
   CSpline3D::Spline3DResampleTrilinear(a,oldzcount,oldycount,oldxcount,newzcount,newycount,newxcount,b);
  }
//+------------------------------------------------------------------+
//| This subroutine builds trilinear vector-valued spline.           |
//| INPUT PARAMETERS:                                                |
//|   X        -  spline abscissas, array[0..N-1]                    |
//|   Y        -  spline ordinates, array[0..M-1]                    |
//|   Z        -  spline applicates, array[0..L-1]                   |
//|   F        -  function values, array[0..M*N*L*D-1]:              |
//|            * first D elements store D values at (X[0],Y[0],Z[0]) |
//|            * next D elements store D values at (X[1],Y[0],Z[0])  |
//|            * next D elements store D values at (X[2],Y[0],Z[0])  |
//|            *              ...                                    |
//|            * next D elements store D values at (X[0],Y[1],Z[0])  |
//|            * next D elements store D values at (X[1],Y[1],Z[0])  |
//|            * next D elements store D values at (X[2],Y[1],Z[0])  |
//|            *              ...                                    |
//|            * next D elements store D values at (X[0],Y[0],Z[1])  |
//|            * next D elements store D values at (X[1],Y[0],Z[1])  |
//|            * next D elements store D values at (X[2],Y[0],Z[1])  |
//|            *              ...                                    |
//|            * general form - D function values at (X[i],Y[j]) are |
//|              stored at F[D*(N*(M*K+J)+I)...D*(N*(M*K+J)+I)+D-1]. |
//|   M,N,                                                           |
//|   L        -  grid size, M>=2, N>=2, L>=2                        |
//|   D        -  vector dimension, D>=1                             |
//| OUTPUT PARAMETERS:                                               |
//|   C        -  spline interpolant                                 |
//+------------------------------------------------------------------+
void CAlglib::Spline3DBuildTrilinearV(CRowDouble &x,int n,
                                      CRowDouble &y,int m,
                                      CRowDouble &z,int l,
                                      CRowDouble &f,int d,
                                      CSpline3DInterpolant &c)
  {
   CSpline3D::Spline3DBuildTrilinearV(x,n,y,m,z,l,f,d,c);
  }
//+------------------------------------------------------------------+
//| This subroutine calculates bilinear or bicubic vector-valued     |
//| spline at the given point (X,Y,Z).                               |
//| INPUT PARAMETERS:                                                |
//|   C        -  spline interpolant.                                |
//|   X, Y,                                                          |
//|   Z        -  point                                              |
//|   F        -  output buffer, possibly preallocated array. In case|
//|               array size is large enough to store result, it is  |
//|               not reallocated. Array which is too short will be  |
//|               reallocated                                        |
//| OUTPUT PARAMETERS:                                               |
//|   F        -  array[D] (or larger) which stores function values  |
//+------------------------------------------------------------------+
void CAlglib::Spline3DCalcVBuf(CSpline3DInterpolant &c,double x,
                               double y,double z,CRowDouble &f)
  {
   CSpline3D::Spline3DCalcVBuf(c,x,y,z,f);
  }
//+------------------------------------------------------------------+
//| This subroutine calculates trilinear or tricubic vector-valued   |
//| spline at the given point (X,Y,Z).                               |
//| INPUT PARAMETERS:                                                |
//|   C        -  spline interpolant.                                |
//|   X, Y,                                                          |
//|   Z        -  point                                              |
//| OUTPUT PARAMETERS:                                               |
//|   F        -  array[D] which stores function values. F is        |
//|               out-parameter and it is reallocated after call to  |
//|               this function. In case you want to  reuse          |
//|               previously allocated F,  you  may  use             |
//|               Spline2DCalcVBuf(), which reallocates F only when  |
//|               it is too small.                                   |
//+------------------------------------------------------------------+
void CAlglib::Spline3DCalcV(CSpline3DInterpolant &c,double x,
                            double y,double z,CRowDouble &f)
  {
   CSpline3D::Spline3DCalcV(c,x,y,z,f);
  }
//+------------------------------------------------------------------+
//| This subroutine unpacks tri-dimensional spline into the          |
//| coefficients table                                               |
//| INPUT PARAMETERS:                                                |
//|   C        -  spline interpolant.                                |
//| Result:                                                          |
//|   N        -  grid size (X)                                      |
//|   M        -  grid size (Y)                                      |
//|   L        -  grid size (Z)                                      |
//|   D        -  number of components                               |
//|   SType    -  spline type. Currently, only one spline type is    |
//|               supported: trilinear spline, as indicated          |
//|               by SType=1.                                        |
//|   Tbl      -  spline coefficients:                               |
//|               [0..(N-1)*(M-1)*(L-1)*D-1, 0..13].                 |
//|               For T=0..D-1 (component index), I = 0...N-2        |
//|               (x index), J=0..M-2 (y index), K=0..L-2 (z index): |
//|                  Q := T + I*D + J*D*(N-1) + K*D*(N-1)*(M-1),     |
//|               Q-th row stores decomposition for T-th component   |
//|               of the vector-valued function                      |
//|                  Tbl[Q,0] = X[i]                                 |
//|                  Tbl[Q,1] = X[i+1]                               |
//|                  Tbl[Q,2] = Y[j]                                 |
//|                  Tbl[Q,3] = Y[j+1]                               |
//|                  Tbl[Q,4] = Z[k]                                 |
//|                  Tbl[Q,5] = Z[k+1]                               |
//|                  Tbl[Q,6] = C000                                 |
//|                  Tbl[Q,7] = C100                                 |
//|                  Tbl[Q,8] = C010                                 |
//|                  Tbl[Q,9] = C110                                 |
//|                  Tbl[Q,10]= C001                                 |
//|                  Tbl[Q,11]= C101                                 |
//|                  Tbl[Q,12]= C011                                 |
//|                  Tbl[Q,13]= C111                                 |
//|               On each grid square spline is equals to:           |
//|   S(x) = SUM(c[i,j,k]*(x^i)*(y^j)*(z^k), i=0..1, j=0..1, k=0..1) |
//|                  t = x-x[j]                                      |
//|                  u = y-y[i]                                      |
//|                  v = z-z[k]                                      |
//| NOTE: format of Tbl is given for SType=1. Future versions of     |
//|       ALGLIB can use different formats for different values of   |
//|       SType.                                                     |
//+------------------------------------------------------------------+
void CAlglib::Spline3DUnpackV(CSpline3DInterpolant &c,int &n,int &m,
                              int &l,int &d,int &stype,
                              CMatrixDouble &tbl)
  {
   CSpline3D::Spline3DUnpackV(c,n,m,l,d,stype,tbl);
  }
//+------------------------------------------------------------------+
//| This function serializes data structure to string.               |
//| Important properties of s_out:                                   |
//| * it contains alphanumeric characters, dots, underscores, minus  |
//|   signs                                                          |
//| * these symbols are grouped into words, which are separated by   |
//|   spaces and Windows-style (CR+LF) newlines                      |
//| * although serializer uses spaces and CR+LF as separators, you   |
//|   can replace any separator character by arbitrary combination   |
//|   of spaces, tabs, Windows or Unix newlines. It allows flexible  |
//|   reformatting of the string in case you want to include it into |
//|   text or XML file. But you should not insert separators into the|
//|   middle of the "words" nor you should change case of letters.   |
//| * s_out can be freely moved between 32-bit and 64-bit systems,   |
//|   little and big endian machines, and so on. You can serialize   |
//|   structure on 32-bit machine and unserialize it on 64-bit one   |
//|   (or vice versa), or serialize it on SPARC and unserialize on   |
//|   x86. You can also serialize it in C# version of ALGLIB and     |
//|   unserialize in C++ one,  and vice versa.                       |
//+------------------------------------------------------------------+
void CAlglib::RBFSerialize(CRBFModel &obj,string &s_out)
  {
//--- create a variable
   CSerializer s;
//--- serialization start
   s.Alloc_Start();
//--- function call
   CRBF::RBFAlloc(s,obj);
//--- serialization
   s.SStart_Str();
   CRBF::RBFSerialize(s,obj);
   s.Stop();
   s_out=s.Get_String();
  }
//+------------------------------------------------------------------+
//| This function unserializes data structure from string.           |
//+------------------------------------------------------------------+
void CAlglib::RBFUnserialize(string s_in,CRBFModel &obj)
  {
//--- create a variable
   CSerializer s;
//--- unserialization start
   s.UStart_Str(s_in);
//--- function call
   CRBF::RBFUnserialize(s,obj);
   s.Stop();
  }
//+------------------------------------------------------------------+
//| This function creates RBF model for a scalar(NY = 1) or vector   |
//| (NY > 1) function in a NX - dimensional space(NX >= 1).          |
//| Newly created model is empty. It can be used for interpolation   |
//| right after creation, but it just returns zeros. You have to add |
//| points to the model, tune interpolation settings, and then call  |
//| model construction function RBFBuildModel() which will update    |
//| model according to your specification.                           |
//| USAGE:                                                           |
//|   1. User creates model with RBFCreate()                         |
//|   2. User adds dataset with RBFSetPoints() or                    |
//|      RBFSetPointsAndScales()                                     |
//|   3. User selects RBF solver by calling:                         |
//|      * RBFSetAlgoHierarchical() - for a HRBF solver, a           |
//|        hierarchical large - scale Gaussian RBFs (works well for  |
//|        uniformly distributed point clouds, but may fail when the |
//|        data are non-uniform; use other solvers below in such     |
//|        cases)                                                    |
//|      * RBFSetAlgoThinPlateSpline() - for a large - scale DDM-RBF |
//|        solver with thin plate spline basis function being used   |
//|      * RBFSetAlgoBiharmonic() - for a large-scale DDM-RBF solver |
//|        with biharmonic basis function being used                 |
//|      * RBFSetAlgoMultiQuadricAuto() - for a large-scale DDM-RBF  |
//|        solver with multiquadric basis function being used        |
//|        (automatic selection of the scale parameter Alpha)        |
//|      * RBFSetAlgoMultiQuadricManual() - for a large-scale DDM-RBF|
//|        solver with multiquadric basis function being used (manual|
//|        selection of the scale parameter Alpha)                   |
//|   4.(OPTIONAL) User chooses polynomial term by calling:          |
//|      * RBFLinTerm() to set linear term (default)                 |
//|      * RBFConstTerm() to set constant term                       |
//|      * RBFZeroTerm() to set zero term                            |
//|   5. User calls RBFBuildModel() function which rebuilds model    |
//|      according to the specification                              |
//| INPUT PARAMETERS:                                                |
//|   NX       -  dimension of the space, NX >= 1                    |
//|   NY       -  function dimension, NY >= 1                        |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  RBF model(initially equals to zero)                |
//| NOTE 1: memory requirements. RBF models require amount of memory |
//|         which is proportional to the number of data points. Some |
//|         additional memory is allocated during model construction,|
//|         but most of this memory is freed after the model         |
//|         coefficients are  calculated. Amount of this additional  |
//|         memory depends on model construction algorithm being used|
//+------------------------------------------------------------------+
void CAlglib::RBFCreate(int nx,int ny,CRBFModel &s)
  {
   CRBF::RBFCreate(nx,ny,s);
  }
//+------------------------------------------------------------------+
//| This function creates buffer structure which can be used to      |
//| perform parallel RBF model evaluations (with one RBF model       |
//| instance being used from multiple threads, as long as different  |
//| threads use different instances of the buffer).                  |
//| This buffer object can be used with RBFTSCalcBuf() function (here|
//| "ts" stands for "thread-safe", "buf" is a suffix which denotes   |
//| function which reuses previously allocated output space).        |
//| A buffer creation function (this function) is also thread-safe.  |
//| I.e. you may safely create multiple buffers for the same RBF     |
//| model from multiple threads.                                     |
//| NOTE: the buffer object is just a collection of several          |
//|       preallocated dynamic arrays and precomputed values. If you |
//|       delete its "parent" RBF model when the buffer is still     |
//|       alive, nothing bad will happen (no dangling pointers or    |
//|       resource leaks). The buffer will simply become useless.    |
//| How to use it:                                                   |
//|   * create RBF model structure with RBFCreate()                  |
//|   * load data, tune parameters                                   |
//|   * call RBFBuildModel()                                         |
//|   * call RBFCreateCalcBuffer(), once per thread working with RBF |
//|     model (you should call this function only AFTER call to      |
//|     RBFBuildModel(), see below for more information)             |
//|   * call RBFTSCalcBuf() from different threads, with each thread |
//|     working with its own copy of buffer object.                  |
//|   * it is recommended to reuse buffer as much as possible because|
//|     buffer creation involves allocation of several large dynamic |
//|     arrays. It is a huge waste of resource to use it just once.  |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//| OUTPUT PARAMETERS:                                               |
//|   Buf      -  external buffer.                                   |
//| IMPORTANT: buffer object should be used only with RBF model      |
//|            object which was used to initialize buffer. Any       |
//|            attempt to use buffer with different object is        |
//|            dangerous - you may get memory violation error because|
//|            sizes of internal arrays do not fit to dimensions of  |
//|            RBF structure.                                        |
//| IMPORTANT: you should call this function only for model which was|
//|            built with RBFBuildModel() function, after successful |
//|            invocation of RBFBuildModel(). Sizes  of  some        |
//|            internal structures are determined only after model is|
//|            built, so buffer object created before model          |
//|            construction stage will be useless (and any attempt to|
//|            use it will result in exception).                     |
//+------------------------------------------------------------------+
void CAlglib::RBFCreateCalcBuffer(CRBFModel &s,CRBFCalcBuffer &buf)
  {
   CRBF::RBFCreateCalcBuffer(s,buf);
  }
//+------------------------------------------------------------------+
//| This function adds dataset.                                      |
//| This function overrides results of the previous calls, i.e.      |
//| multiple calls of this function will result in only the last set |
//| being added.                                                     |
//| IMPORTANT: ALGLIB version 3.11 and later allows you to specify a |
//|            set of per-dimension scales. Interpolation radii are  |
//|            multiplied by the scale vector. It may be useful if   |
//|            you have mixed spatio - temporal data (say, a set of  |
//|            3D slices recorded at different times). You should    |
//|            call RBFSetPointsAndScales() function to use this     |
//|            feature.                                              |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call.        |
//|   XY       -  points, array[N, NX + NY]. One row corresponds to  |
//|               one point in the dataset. First NX elements are    |
//|               coordinates, next NY elements are function values. |
//|               Array may be larger than specified, in this case   |
//|               only leading [N, NX+NY] elements will be used.     |
//|   N        -  number of points in the dataset                    |
//| After you've added dataset and (optionally) tuned algorithm      |
//| settings you should call RBFBuildModel() in order to build a     |
//| model for you.                                                   |
//| NOTE: dataset added by this function is not saved during model   |
//|       serialization. MODEL ITSELF is serialized, but data used   |
//|       to build it are not.                                       |
//| So, if you 1) add dataset to empty RBF model, 2) serialize and   |
//| unserialize it, then you will get an empty RBF model with no     |
//| dataset being attached.                                          |
//| From the other side, if you call RBFBuildModel() between(1) and  |
//| (2), then after(2) you will get your fully constructed RBF model-|
//| but again with no dataset attached, so subsequent calls to       |
//| RBFBuildModel() will produce empty model.                        |
//+------------------------------------------------------------------+
void CAlglib::RBFSetPoints(CRBFModel &s,CMatrixDouble &xy,int n)
  {
   CRBF::RBFSetPoints(s,xy,n);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::RBFSetPoints(CRBFModel &s,CMatrixDouble &xy)
  {
//--- initialization
   int n=CAp::Rows(xy);
//--- function call
   CRBF::RBFSetPoints(s,xy,n);
  }
//+------------------------------------------------------------------+
//| This function adds dataset and a vector of per-dimension scales. |
//| It may be useful if you have mixed spatio - temporal data - say, |
//| a set of 3D slices recorded at different times. Such data        |
//| typically require different RBF radii for spatial and temporal   |
//| dimensions. ALGLIB solves this problem by specifying single RBF  |
//| radius, which is (optionally) multiplied by the scale vector.    |
//| This function overrides results of the previous calls, i.e.      |
//| multiple calls of this function will result in only the last set |
//| being added.                                                     |
//| IMPORTANT: only modern RBF algorithms support variable scaling.  |
//|            Legacy algorithms like RBF-ML or QNN algorithms will  |
//|            result in - 3 completion code being returned(incorrect|
//|            algorithm).                                           |
//| INPUT PARAMETERS:                                                |
//|   R        -  RBF model, initialized by RBFCreate() call.        |
//|   XY       -  points, array[N, NX + NY]. One row corresponds to  |
//|               one point in the dataset. First NX elements are    |
//|               coordinates, next NY elements are function values. |
//|               Array may be larger than specified, in this case   |
//|               only leading [N, NX+NY] elements will be used.     |
//|   N        -  number of points in the dataset                    |
//|   S        -  array[NX], scale vector, S[i] > 0.                 |
//| After you've added dataset and (optionally) tuned algorithm      |
//| settings you should call RBFBuildModel() in order to build a     |
//| model for you.                                                   |
//| NOTE: dataset added by this function is not saved during model   |
//|       serialization. MODEL ITSELF is serialized, but data used   |
//|       to build it are not.                                       |
//| So, if you 1) add dataset to empty RBF model, 2) serialize and   |
//| unserialize it, then you will get an empty RBF model with no     |
//| dataset being attached.                                          |
//| From the other side, if you call RBFBuildModel() between(1) and  |
//| (2), then after(2) you will get your fully constructed RBF model-|
//| but again with no dataset attached, so subsequent calls to       |
//| RBFBuildModel() will produce empty model.                        |
//+------------------------------------------------------------------+
void CAlglib::RBFSetPointsAndScales(CRBFModel &r,CMatrixDouble &xy,
                                    int n,CRowDouble &s)
  {
   CRBF::RBFSetPointsAndScales(r,xy,n,s);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::RBFSetPointsAndScales(CRBFModel &r,CMatrixDouble &xy,
                                    CRowDouble &s)
  {
//--- initialization
   int n=CAp::Rows(xy);
//--- function call
   CRBF::RBFSetPointsAndScales(r,xy,n,s);
  }
//+------------------------------------------------------------------+
//| DEPRECATED: this function is deprecated. ALGLIB includes new RBF |
//|             model algorithms:                                    |
//| DDM - RBF (since version 3.19) and HRBF (since version 3.11).    |
//+------------------------------------------------------------------+
void CAlglib::RBFSetAlgoQNN(CRBFModel &s,double q=1.0,double z=5.0)
  {
   CRBF::RBFSetAlgoQNN(s,q,z);
  }
//+------------------------------------------------------------------+
//| DEPRECATED: this function is deprecated. ALGLIB includes new RBF |
//|             model algorithms:                                    |
//| DDM     - RBF(since version 3.19) and HRBF (since version 3.11). |
//+------------------------------------------------------------------+
void CAlglib::RBFSetAlgoMultilayer(CRBFModel &s,double rbase,int nlayers,double lambdav=0.01)
  {
   CRBF::RBFSetAlgoMultilayer(s,rbase,nlayers,lambdav);
  }
//+------------------------------------------------------------------+
//| This function chooses HRBF solver, a 2nd version of ALGLIB RBFs. |
//| This algorithm is called Hierarchical RBF. It similar to its     |
//| previous incarnation, RBF-ML, i.e. it also builds a sequence of  |
//| models with decreasing radii. However, it uses more economical   |
//| way of building upper layers (ones with large radii), which      |
//| results in faster model construction and evaluation, as well as  |
//| smaller memory footprint during construction.                    |
//| This algorithm has following important features:                 |
//|   * ability to handle millions of points                         |
//|   * controllable smoothing via nonlinearity penalization         |
//|   * support for specification of per - dimensional radii via     |
//|     scale vector, which is set by means of RBFSetPointsAndScales |
//|     function. This feature is useful if you solve spatio -       |
//|     temporal interpolation problems, where different radii are   |
//|     required for spatial and temporal dimensions.                |
//| Running times are roughly proportional to:                       |
//|   * N*log(N)                                                     |
//|   * NLayers   -  for the model construction                      |
//|   * N*NLayers -  for the model evaluation                        |
//| You may see that running time does not depend on search radius or|
//| points density, just on the number of layers in the hierarchy.   |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//|   RBase    -  RBase parameter, RBase > 0                         |
//|   NLayers  -  NLayers parameter, NLayers > 0, recommended value  |
//|               to start with - about 5.                           |
//|   LambdaNS -  >= 0, nonlinearity penalty coefficient, negative   |
//|               values are not allowed. This parameter adds        |
//|               controllable smoothing to the problem, which may   |
//|               reduce noise. Specification of non-zero lambda     |
//|               means that in addition to fitting error solver will|
//|               also minimize LambdaNS* | S''(x) | 2 (appropriately|
//|               generalized to multiple dimensions.                |
//| Specification of exactly zero value means that no penalty is     |
//| added (we do not even evaluate matrix of second derivatives which|
//| is necessary for smoothing).                                     |
//| Calculation of nonlinearity penalty is costly - it results in    |
//| several - fold increase of model construction time. Evaluation   |
//| time remains the same.                                           |
//| Optimal lambda is problem - dependent and requires trial and     |
//| error. Good value to start from is 1e-5...1e-6, which corresponds|
//| to slightly noticeable smoothing of the function. Value 1e-2     |
//| usually means that quite heavy smoothing is applied.             |
//| TUNING ALGORITHM                                                 |
//| In order to use this algorithm you have to choose three          |
//| parameters:                                                      |
//|   * initial radius RBase                                         |
//|   * number of layers in the model NLayers                        |
//|   * penalty coefficient LambdaNS                                 |
//| Initial radius is easy to choose - you can pick any number       |
//| several times larger than the average distance between points.   |
//| Algorithm won't break down if you choose radius which is too     |
//| large (model construction time will increase, but model will be  |
//| built correctly).                                                |
//| Choose such number of layers that RLast = RBase / 2^(NLayers - 1)|
//| (radius used by the last layer) will be smaller than the typical |
//| distance between points. In case model error is too large, you   |
//| can increase number of layers. Having more layers will make model|
//| construction and evaluation proportionally slower, but it will   |
//| allow you to have model which precisely fits your data. From the |
//| other side, if you want to suppress noise, you can DECREASE      |
//| number of layers to make your model less flexible (or specify    |
//| non-zero LambdaNS).                                              |
//| TYPICAL ERRORS:                                                  |
//|   1. Using too small number of layers - RBF models with large    |
//|      radius are not flexible enough to reproduce small variations|
//|      in the target function. You need many layers with different |
//|      radii, from large to small, in order to have good model.    |
//|   2. Using initial radius which is too small. You will get model |
//|      with "holes" in the areas which are too far away from       |
//|      interpolation centers. However, algorithm will work         |
//|      correctly (and quickly) in this case.                       |
//+------------------------------------------------------------------+
void CAlglib::RBFSetAlgoHierarchical(CRBFModel &s,double rbase,
                                     int nlayers,double lambdans)
  {
   CRBF::RBFSetAlgoHierarchical(s,rbase,nlayers,lambdans);
  }
//+------------------------------------------------------------------+
//| This function chooses a thin plate spline DDM-RBF solver, a fast |
//| RBF solver with f(r) = r ^ 2 * ln(r) basis function.             |
//| This algorithm has following important features:                 |
//|   * easy setup - no tunable parameters                           |
//|   * C1 continuous RBF model (gradient is defined everywhere, but |
//|     Hessian is undefined at nodes), high - quality interpolation |
//|   * fast model construction algorithm with O(N) memory and O(N^2)|
//|     running time requirements. Hundreds of thousands of points   |
//|     can be handled with this algorithm.                          |
//|   * controllable smoothing via optional nonlinearity penalty     |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//|   LambdaV  -  smoothing parameter, LambdaV >= 0, defaults to 0.0:|
//|               * LambdaV = 0 means that no smoothing is applied,  |
//|                             i.e. the spline tries to pass through|
//|                             all dataset points exactly           |
//|               * LambdaV > 0 means that a smoothing thin plate    |
//|                             spline is built, with larger LambdaV |
//|                             corresponding to models with less    |
//|                             nonlinearities. Smoothing spline     |
//|                             reproduces target values at nodes    |
//|                             with small error; from the other     |
//|                             side, it is much more stable.        |
//| Recommended values:                                              |
//|   * 1.0E-6 for minimal stability improving smoothing             |
//|   * 1.0E-3 a good value to start experiments; first results are  |
//|            visible                                               |
//|   * 1.0 for strong smoothing                                     |
//| IMPORTANT: this model construction algorithm was introduced in   |
//|            ALGLIB 3.19 and produces models which are INCOMPATIBLE|
//|            with previous versions of ALGLIB. You can not         |
//|            unserialize models produced with this function in     |
//|            ALGLIB 3.18 or earlier.                               |
//| NOTE: polyharmonic RBFs, including thin plate splines, are       |
//|       somewhat slower than compactly supported RBFs built with   |
//|       HRBF algorithm due to the fact that non-compact basis      |
//|       function does not vanish far away from the nodes. From the |
//|       other side, polyharmonic RBFs often produce much better    |
//|       results than HRBFs.                                        |
//| NOTE: this algorithm supports specification of per-dimensional   |
//|       radii via scale vector, which is set by means of           |
//|       RBFSetPointsAndScales() function. This feature is useful if|
//|       you solve spatio-temporal interpolation problems where     |
//|       different radii are required for spatial and temporal      |
//|       dimensions.                                                |
//+------------------------------------------------------------------+
void CAlglib::RBFSetAlgoThinPlateSpline(CRBFModel &s,double lambdav=0.0)
  {
   CRBF::RBFSetAlgoThinPlateSpline(s,lambdav);
  }
//+------------------------------------------------------------------+
//| This function chooses a multiquadric DDM - RBF solver, a fast RBF|
//| solver with f(r) = sqrt(r ^ 2 + Alpha ^ 2) as a basis function,  |
//| with manual choice of the scale parameter Alpha.                 |
//| This algorithm has following important features:                 |
//|   * C2 continuous RBF model(when Alpha > 0 is used; for Alpha = 0|
//|        the model is merely C0 continuous)                        |
//|   * fast model construction algorithm with O(N) memory and O(N^2)|
//|     running time requirements. Hundreds of thousands of points   |
//|     can be handled with this algorithm.                          |
//|   * controllable smoothing via optional nonlinearity penalty     |
//| One important point is that this algorithm includes tunable      |
//| parameter Alpha, which should be carefully chosen. Selecting too |
//| large value will result in extremely badly conditioned problems  |
//| (interpolation accuracy may degrade up to complete breakdown)    |
//| whilst selecting too small value may produce models that are     |
//| precise but nearly nonsmooth at the nodes.                       |
//| Good value to start from is mean distance between nodes.         |
//| Generally, choosing too small Alpha is better than choosing too  |
//| large - in the former case you still have model that reproduces  |
//| target values at the nodes.                                      |
//| In most cases, better option is to choose good Alpha             |
//| automatically - it is done by another version of the same        |
//| algorithm that is activated by calling RBFSetAlgoMultiQuadricAuto|
//| method.                                                          |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//|   Alpha    -  basis function parameter, Alpha >= 0:              |
//|               * Alpha > 0 means that multiquadric algorithm is   |
//|                           used which produces C2-continuous RBF  |
//|                           model                                  |
//|               * Alpha = 0 means that the multiquadric kernel     |
//|                           effectively becomes a biharmonic one:  |
//|                           f = r. As a result, the model becomes  |
//|                           nonsmooth at nodes, and hence is C0    |
//|                           continuous                             |
//|   LambdaV  -  smoothing parameter, LambdaV >= 0, defaults to 0.0:|
//|               * LambdaV = 0 means that no smoothing is applied,  |
//|                             i.e. the spline tries to pass through|
//|                             all dataset points exactly           |
//|               * LambdaV > 0 means that a multiquadric spline is  |
//|                             built with larger LambdaV            |
//|                             corresponding to models with less    |
//|                             nonlinearities. Smoothing  spline    |
//|                             reproduces target values at nodes    |
//|                             with small error; from the other     |
//|                             side, it is much more stable.        |
//| Recommended values:                                              |
//|   * 1.0E-6 for minimal stability improving smoothing             |
//|   * 1.0E-3 a good value to start experiments; first results are  |
//|            visible                                               |
//|   * 1.0 for strong smoothing                                     |
//| IMPORTANT: this model construction algorithm was introduced in   |
//|            ALGLIB 3.19 and produces models which are INCOMPATIBLE|
//|            with previous versions of ALGLIB. You can not         |
//|            unserialize models produced with this function in     |
//|            ALGLIB 3.18 or earlier.                               |
//| NOTE: polyharmonic RBFs, including thin plate splines, are       |
//|       somewhat slower than compactly supported RBFs built with   |
//|       HRBF algorithm due to the fact that non-compact basis      |
//|       function does not vanish far away from the nodes. From the |
//|       other side, polyharmonic RBFs often produce much better    |
//|       results than HRBFs.                                        |
//| NOTE: this algorithm supports specification of per-dimensional   |
//|       radii via scale vector, which is set by means of           |
//|       RBFSetPointsAndScales() function. This feature is useful if|
//|       you solve spatio-temporal interpolation problems where     |
//|       different radii are required for spatial and temporal      |
//|       dimensions.                                                |
//+------------------------------------------------------------------+
void CAlglib::RBFSetAlgoMultiQuadricManual(CRBFModel &s,double alpha,
                                           double lambdav=0.0)
  {
   CRBF::RBFSetAlgoMultiQuadricManual(s,alpha,lambdav);
  }
//+------------------------------------------------------------------+
//| This function chooses a multiquadric DDM-RBF solver, a fast RBF  |
//| solver with f(r) = sqrt(r ^ 2 + Alpha ^ 2) as a basis function,  |
//| with Alpha being automatically determined.                       |
//| This algorithm has following important features:                 |
//|   * easy setup - no need to tune Alpha, good value is            |
//|     automatically assigned                                       |
//|   * C2 continuous RBF model                                      |
//|   * fast model construction algorithm with O(N) memory and O(N^2)|
//|     running time requirements. Hundreds of thousands of points   |
//|     can be handled with this algorithm.                          |
//|   * controllable smoothing via optional nonlinearity penalty     |
//| This algorithm automatically selects Alpha as a mean distance to |
//| the nearest neighbor(ignoring neighbors that are too close).     |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//|   LambdaV  -  smoothing parameter, LambdaV >= 0, defaults to 0.0:|
//|               * LambdaV = 0 means that no smoothing is applied,  |
//|                             i.e. the spline tries to pass through|
//|                             all dataset points exactly           |
//|               * LambdaV > 0 means that a multiquadric spline is  |
//|                             built with larger LambdaV            |
//|                             corresponding to models with less    |
//|                             nonlinearities. Smoothing spline     |
//|                             reproduces target values at nodes    |
//|                             with small error; from the other     |
//|                             side, it is much more stable.        |
//| Recommended values:                                              |
//|   * 1.0E-6 for minimal stability improving smoothing             |
//|   * 1.0E-3 a good value to start experiments; first results are  |
//|            visible                                               |
//|   * 1.0    for strong smoothing                                  |
//| IMPORTANT: this model construction algorithm was introduced in   |
//|            ALGLIB 3.19 and produces models which are INCOMPATIBLE|
//|            with previous versions of ALGLIB. You can not         |
//|            unserialize models produced with this function in     |
//|            ALGLIB 3.18 or earlier.                               |
//| NOTE: polyharmonic RBFs, including thin plate splines, are       |
//|       somewhat slower than compactly supported RBFs built with   |
//|       HRBF algorithm due to the fact that non-compact basis      |
//|       function does not vanish far away from the nodes. From the |
//|       other side, polyharmonic RBFs often produce much better    |
//|       results than HRBFs.                                        |
//| NOTE: this algorithm supports specification of per-dimensional   |
//|       radii via scale vector, which is set by means of           |
//|       RBFSetPointsAndScales() function. This feature is useful if|
//|       you solve spatio - temporal interpolation problems where   |
//|       different radii are required for spatial and temporal      |
//|       dimensions.                                                |
//+------------------------------------------------------------------+
void CAlglib::RBFSetAlgoMultiQuadricAuto(CRBFModel &s,double lambdav=0.0)
  {
   CRBF::RBFSetAlgoMultiQuadricAuto(s,lambdav);
  }
//+------------------------------------------------------------------+
//| This function chooses a biharmonic DDM-RBF solver, a fast RBF    |
//| solver with              f(r) = r as a basis function.           |
//| This algorithm has following important features:                 |
//|   * no tunable parameters                                        |
//|   * C0 continuous RBF model (the model has discontinuous         |
//|     derivatives at the interpolation nodes)                      |
//|   * fast model construction algorithm with O(N) memory and O(N^2)|
//|     running time requirements. Hundreds of thousands of points   |
//|     can be handled with this algorithm.                          |
//|   * controllable smoothing via optional nonlinearity penalty     |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//|   LambdaV  -  smoothing parameter, LambdaV >= 0, defaults to 0.0:|
//|               * LambdaV = 0 means that no smoothing is applied,  |
//|                             i.e. the spline tries to pass through|
//|                             all dataset points exactly           |
//|               * LambdaV > 0 means that a multiquadric spline is  |
//|                             built with larger LambdaV            |
//|                             corresponding to models with less    |
//|                             nonlinearities. Smoothing spline     |
//|                             reproduces target values at nodes    |
//|                             with small error; from the other     |
//|                             side, it is much more stable.        |
//| Recommended values:                                              |
//|   * 1.0E-6 for minimal stability improving smoothing             |
//|   * 1.0E-3 a good value to start experiments; first results are  |
//|            visible                                               |
//|   * 1.0 for strong smoothing                                     |
//| IMPORTANT: this model construction algorithm was introduced in   |
//|            ALGLIB 3.19 and produces models which are INCOMPATIBLE|
//|            with previous versions of ALGLIB. You can not         |
//|            unserialize models produced with this function in     |
//|            ALGLIB 3.18 or earlier.                               |
//| NOTE: polyharmonic RBFs, including thin plate splines, are       |
//|       somewhat slower than compactly supported RBFs built with   |
//|       HRBF algorithm due to the fact that non-compact basis      |
//|       function does not vanish far away from the nodes. From the |
//|       other side, polyharmonic RBFs often produce much better    |
//|       results than HRBFs.                                        |
//| NOTE: this algorithm supports specification of per-dimensional   |
//|       radii via scale vector, which is set by means of           |
//|       RBFSetPointsAndScales() function. This feature is useful if|
//|       you solve spatio - temporal interpolation problems where   |
//|       different radii are required for spatial and temporal      |
//|       dimensions.                                                |
//+------------------------------------------------------------------+
void CAlglib::RBFSetAlgoBiharmonic(CRBFModel &s,double lambdav=0.0)
  {
   CRBF::RBFSetAlgoBiharmonic(s,lambdav);
  }
//+------------------------------------------------------------------+
//| This function sets linear term (model is a sum of radial basis   |
//| functions plus linear polynomial). This function won't have      |
//| effect until next call to RBFBuildModel().                       |
//| Using linear term is a default option and it is the best one-it  |
//| provides best convergence guarantees for all RBF model types:    |
//| legacy RBF-QNN and RBF-ML, Gaussian HRBFs and all types of       |
//| DDM-RBF models.                                                  |
//| Other options, like constant or zero term, work for HRBFs, almost|
//| always work for DDM-RBFs but provide no stability guarantees in  |
//| the latter case (e.g. the solver may fail on some carefully      |
//| prepared problems).                                              |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//+------------------------------------------------------------------+
void CAlglib::RBFSetLinTerm(CRBFModel &s)
  {
   CRBF::RBFSetLinTerm(s);
  }
//+------------------------------------------------------------------+
//| This function sets constant term (model is a sum of radial basis |
//| functions plus constant). This function won't have effect until  |
//| next call to RBFBuildModel().                                    |
//| IMPORTANT: thin plate splines require polynomial term to be      |
//|            linear, not constant, in order to provide             |
//|            interpolation guarantees. Although failures are       |
//|            exceptionally rare, some small toy problems may result|
//|            in degenerate linear systems. Thus, it is advised to  |
//|            use linear term when one fits data with TPS.          |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//+------------------------------------------------------------------+
void CAlglib::RBFSetConstTerm(CRBFModel &s)
  {
   CRBF::RBFSetConstTerm(s);
  }
//+------------------------------------------------------------------+
//| This function sets zero term (model is a sum of radial basis     |
//| functions without polynomial term). This function won't have     |
//| effect until next call to RBFBuildModel().                       |
//| IMPORTANT: only Gaussian RBFs(HRBF algorithm) provide            |
//|            interpolation guarantees when no polynomial term is   |
//|            used. Most other RBFs, including biharmonic splines,  |
//|            thin plate splines and multiquadrics, require at least|
//|            constant term(biharmonic and multiquadric) or linear  |
//|            one (thin plate splines) in order to guarantee        |
//|            non-degeneracy of linear systems being solved.        |
//| Although failures are exceptionally rare, some small toy problems|
//| still may result in degenerate linear systems. Thus, it is       |
//| advised to use constant / linear term, unless one is 100 % sure  |
//| that he needs zero term.                                         |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//+------------------------------------------------------------------+
void CAlglib::RBFSetZeroTerm(CRBFModel &s)
  {
   CRBF::RBFSetZeroTerm(s);
  }
//+------------------------------------------------------------------+
//| This function sets basis function type, which can be:            |
//|   * 0 for classic Gaussian                                       |
//|   * 1 for fast and compact bell - like basis function, which     |
//|       becomes exactly zero at distance equal to 3 * R (default   |
//|       option).                                                   |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//|   BF       -  basis function type:                               |
//|               * 0 - classic Gaussian                             |
//|               * 1 - fast and compact one                         |
//+------------------------------------------------------------------+
void CAlglib::RBFSetV2BF(CRBFModel &s,int bf)
  {
   CRBF::RBFSetV2BF(s,bf);
  }
//+------------------------------------------------------------------+
//| This function sets stopping criteria of the underlying linear    |
//| solver for hierarchical (version 2) RBF constructor.             |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//|   MaxIts   -  this criterion will stop algorithm after MaxIts    |
//|               iterations. Typically a few hundreds iterations is |
//|               required, with 400 being a good default value to   |
//|               start experimentation. Zero value means that       |
//|               default value will be selected.                    |
//+------------------------------------------------------------------+
void CAlglib::RBFSetV2Its(CRBFModel &s,int maxits)
  {
   CRBF::RBFSetV2Its(s,maxits);
  }
//+------------------------------------------------------------------+
//| This function sets support radius parameter of hierarchical      |
//| (version 2) RBF constructor.                                     |
//| Hierarchical RBF model achieves great speed-up by removing from  |
//| the model excessive (too dense) nodes. Say, if you have RBF      |
//| radius equal to 1 meter, and two nodes are just 1 millimeter     |
//| apart, you may remove one of them without reducing model quality.|
//| Support radius parameter is used to justify which points need    |
//| removal, and which do not. If two points are less than           |
//| SUPPORT_R*CUR_RADIUS units of distance apart, one of them is     |
//| removed from the model. The larger support radius is, the faster |
//| model construction AND evaluation are. However, too large values |
//| result in "bumpy" models.                                        |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//|   R        -  support radius coefficient, >= 0.                  |
//| Recommended values are [0.1, 0.4] range, with 0.1 being default  |
//| value.                                                           |
//+------------------------------------------------------------------+
void CAlglib::RBFSetV2SupportR(CRBFModel &s,double r)
  {
   CRBF::RBFSetV2SupportR(s,r);
  }
//+------------------------------------------------------------------+
//| This function builds RBF model and returns report (contains some |
//| information which can be used for evaluation of the algorithm    |
//| properties).                                                     |
//| Call to this function modifies RBF model by calculating its      |
//| centers/radii/weights and saving them into RBFModel structure.   |
//| Initially RBFModel contain zero coefficients, but after call to  |
//| this function we will have coefficients which were calculated in |
//| order to fit our dataset.                                        |
//| After you called this function you can call RBFCalc(),           |
//| RBFGridCalc() and other model calculation functions.             |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, initialized by RBFCreate() call         |
//|   Rep      -  report:                                            |
//|               * Rep.TerminationType:                             |
//|                  * -5 - non-distinct basis function centers were |
//|                         detected, interpolation aborted; only QNN|
//|                         returns this error code, other algorithms|
//|                         can handle non-distinct nodes.           |
//|                  * -4 - nonconvergence of the internal SVD solver|
//|                  * -3   incorrect model construction algorithm   |
//|                         was chosen: QNN or RBF-ML, combined with |
//|                         one of the incompatible features:        |
//|                        * NX = 1 or NX > 3                        |
//|                        * points with per - dimension scales.     |
//|                  * 1 - successful termination                    |
//|                  * 8 - a termination request was submitted via   |
//|                        RBFRequestTermination() function.         |
//| Fields which are set only by modern RBF solvers (hierarchical or |
//| nonnegative; older solvers like QNN and ML initialize these      |
//| fields by NANs):                                                 |
//|   * rep.m_rmserror - root-mean-square error at nodes             |
//|   * rep.m_maxerror - maximum error at nodes                      |
//| Fields are used for debugging purposes:                          |
//|   * Rep.IterationsCount - iterations count of the LSQR solver    |
//|   * Rep.NMV - number of matrix - vector products                 |
//|   * Rep.ARows - rows count for the system matrix                 |
//|   * Rep.ACols - columns count for the system matrix              |
//|   * Rep.ANNZ  - number of significantly non - zero elements      |
//|                 (elements above some algorithm - determined      |
//|                 threshold)                                       |
//| NOTE: failure to build model will leave current state of the     |
//|       structure unchanged.                                       |
//+------------------------------------------------------------------+
void CAlglib::RBFBuildModel(CRBFModel &s,CRBFReport &rep)
  {
   CRBF::RBFBuildModel(s,rep);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the 1-dimensional RBF model   |
//| with scalar output (NY = 1) at the given point.                  |
//| IMPORTANT: this function works only with modern (hierarchical)   |
//|            RBFs. It can not be used with legacy (version 1) RBFs |
//|            because older RBF code does not support 1-dimensional |
//|            models.                                               |
//| IMPORTANT: THIS FUNCTION IS THREAD - UNSAFE. It uses fields of   |
//|            CRBFModel as temporary arrays, i.e. it is impossible  |
//|            to perform parallel evaluation on the same CRBFModel  |
//|            object (parallel calls of this function for           |
//|            independent CRBFModel objects are safe). If you want  |
//|            to perform parallel model evaluation from multiple    |
//|            threads, use RBFTSCalcBuf() with per-thread buffer    |
//|            object.                                               |
//| This function returns 0.0 when:                                  |
//|   * the model is not initialized                                 |
//|   * NX<>1                                                        |
//|   * NY<>1                                                        |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X0       -  X - coordinate, finite number                      |
//| RESULT:                                                          |
//|   value of the model or 0.0 (as defined above)                   |
//+------------------------------------------------------------------+
double CAlglib::RBFCalc1(CRBFModel &s,double x0)
  {
   return(CRBF::RBFCalc1(s,x0));
  }
//+------------------------------------------------------------------+
//| This function calculates values of the 2-dimensional RBF model   |
//| with scalar output (NY = 1) at the given point.                  |
//| IMPORTANT: THIS FUNCTION IS THREAD - UNSAFE. It uses fields of   |
//|            CRBFModel as temporary arrays, i.e. it is impossible  |
//|            to perform parallel evaluation on the same CRBFModel  |
//|            object (parallel calls of this function for           |
//|            independent CRBFModel objects are safe). If you want  |
//|            to perform parallel model evaluation from multiple    |
//|            threads, use RBFTSCalcBuf() with per-thread buffer    |
//|            object.                                               |
//| This function returns 0.0 when:                                  |
//|   * model is not initialized                                     |
//|   * NX<>2                                                        |
//|   * NY<>1                                                        |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X0       -  first coordinate, finite number                    |
//|   X1       -  second coordinate, finite number                   |
//| RESULT:                                                          |
//|   value of the model or 0.0 (as defined above)                   |
//+------------------------------------------------------------------+
double CAlglib::RBFCalc2(CRBFModel &s,double x0,double x1)
  {
   return(CRBF::RBFCalc2(s,x0,x1));
  }
//+------------------------------------------------------------------+
//| This function calculates values of the 3-dimensional RBF model   |
//| with scalar output (NY = 1) at the given point.                  |
//| IMPORTANT: THIS FUNCTION IS THREAD - UNSAFE. It uses fields of   |
//|            CRBFModel as temporary arrays, i.e. it is impossible  |
//|            to perform parallel evaluation on the same CRBFModel  |
//|            object (parallel calls of this function for           |
//|            independent CRBFModel objects are safe). If you want  |
//|            to perform parallel model evaluation from multiple    |
//|            threads, use RBFTSCalcBuf() with per-thread buffer    |
//|            object.                                               |
//| This function returns 0.0 when:                                  |
//|   * model is not initialized                                     |
//|   * NX<>3                                                        |
//|   * NY<>1                                                        |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X0       -  first coordinate, finite number                    |
//|   X1       -  second coordinate, finite number                   |
//|   X2       -  third coordinate, finite number                    |
//| RESULT:                                                          |
//|   value of the model or 0.0 (as defined above)                   |
//+------------------------------------------------------------------+
double CAlglib::RBFCalc3(CRBFModel &s,double x0,double x1,double x2)
  {
   return(CRBF::RBFCalc3(s,x0,x1,x2));
  }
//+------------------------------------------------------------------+
//| This function calculates value and derivatives of the            |
//| 1-dimensional RBF model with scalar output (NY = 1) at the given |
//| point.                                                           |
//| IMPORTANT: THIS FUNCTION IS THREAD - UNSAFE. It uses fields of   |
//|            CRBFModel as temporary arrays, i.e. it is impossible  |
//|            to perform parallel evaluation on the same CRBFModel  |
//|            object (parallel calls of this function for           |
//|            independent CRBFModel objects are safe). If you want  |
//|            to perform parallel model evaluation from multiple    |
//|            threads, use RBFTSCalcBuf() with per-thread buffer    |
//|            object.                                               |
//| This function returns 0.0 in Y and/or DY in the following cases: |
//|   * the model is not initialized (Y = 0, DY = 0)                 |
//|   * NX<>1 or NY<>1 (Y = 0, DY = 0)                               |
//|   * the gradient is undefined at the trial point. Some basis     |
//|     functions have discontinuous derivatives at the interpolation|
//|     nodes:                                                       |
//|      * biharmonic splines f = r have no Hessian and no gradient  |
//|        at the nodes In these cases only DY is set to zero (Y is  |
//|        still returned)                                           |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X0       -  first coordinate, finite number                    |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  value of the model or 0.0 (as defined above)       |
//|   DY0      -  derivative with respect to X0                      |
//+------------------------------------------------------------------+
void CAlglib::RBFDiff1(CRBFModel &s,double x0,double &y,double &dy0)
  {
   CRBF::RBFDiff1(s,x0,y,dy0);
  }
//+------------------------------------------------------------------+
//| This function calculates value and derivatives of the            |
//| 2-dimensional RBF model with scalar output (NY = 1) at the given |
//| point.                                                           |
//| IMPORTANT: THIS FUNCTION IS THREAD - UNSAFE. It uses fields of   |
//|            CRBFModel as temporary arrays, i.e. it is impossible  |
//|            to perform parallel evaluation on the same CRBFModel  |
//|            object (parallel calls of this function for           |
//|            independent CRBFModel objects are safe). If you want  |
//|            to perform parallel model evaluation from multiple    |
//|            threads, use RBFTSCalcBuf() with per-thread buffer    |
//|            object.                                               |
//| This function returns 0.0 in Y and/or DY in the following cases: |
//|   * the model is not initialized(Y = 0, DY = 0)                  |
//|   * NX<>2 or NY<>1 (Y=0, DY=0)                                   |
//|   * the gradient is undefined at the trial point. Some basis     |
//|     functions have discontinuous derivatives at the interpolation|
//|     nodes:                                                       |
//|   * biharmonic splines f = r have no Hessian and no gradient at  |
//|     the nodes In these cases only DY is set to zero (Y is still  |
//|     returned)                                                    |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X0       -  first coordinate, finite number                    |
//|   X1       -  second coordinate, finite number                   |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  value of the model or 0.0 (as defined above)       |
//|   DY0      -  derivative with respect to X0                      |
//|   DY1      -  derivative with respect to X1                      |
//+------------------------------------------------------------------+
void CAlglib::RBFDiff2(CRBFModel &s,double x0,double x1,double &y,
                       double &dy0,double &dy1)
  {
   CRBF::RBFDiff2(s,x0,x1,y,dy0,dy1);
  }
//+------------------------------------------------------------------+
//| This function calculates value and derivatives of the            |
//| 3-dimensional RBF model with scalar output (NY = 1) at the given |
//| point.                                                           |
//| IMPORTANT: THIS FUNCTION IS THREAD - UNSAFE. It uses fields of   |
//|            CRBFModel as temporary arrays, i.e. it is impossible  |
//|            to perform parallel evaluation on the same CRBFModel  |
//|            object (parallel calls of this function for           |
//|            independent CRBFModel objects are safe). If you want  |
//|            to perform parallel model evaluation from multiple    |
//|            threads, use RBFTSCalcBuf() with per-thread buffer    |
//|            object.                                               |
//| This function returns 0.0 in Y and/or DY in the following cases: |
//|   * the model is not initialized (Y = 0, DY = 0)                 |
//|   * NX<>3 or NY<>1 (Y = 0, DY = 0)                               |
//|   * the gradient is undefined at the trial point. Some basis     |
//|     functions have discontinuous derivatives at the interpolation|
//|     nodes:                                                       |
//|      * biharmonic splines f = r have no Hessian and no gradient  |
//|        at the nodes In these cases only DY is set to zero (Y is  |
//|        still returned)                                           |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X0       -  first coordinate, finite number                    |
//|   X1       -  second coordinate, finite number                   |
//|   X2       -  third coordinate, finite number                    |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  value of the model or 0.0 (as defined above)       |
//|   DY0      -  derivative with respect to X0                      |
//|   DY1      -  derivative with respect to X1                      |
//|   DY2      -  derivative with respect to X2                      |
//+------------------------------------------------------------------+
void CAlglib::RBFDiff3(CRBFModel &s,double x0,double x1,double x2,
                       double &y,double &dy0,double &dy1,double &dy2)
  {
   CRBF::RBFDiff3(s,x0,x1,x2,y,dy0,dy1,dy2);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model at the given    |
//| point.                                                           |
//| This is general function which can be used for arbitrary NX      |
//| (dimension of the space of arguments) and NY (dimension of the   |
//| function itself). However when you have NY = 1 you may find more |
//| convenient to use RBFCalc2() or RBFCalc3().                      |
//| IMPORTANT: THIS FUNCTION IS THREAD - UNSAFE. It uses fields of   |
//|            CRBFModel as temporary arrays, i.e. it is impossible  |
//|            to perform parallel evaluation on the same CRBFModel  |
//|            object (parallel calls of this function for           |
//|            independent CRBFModel objects are safe). If you want  |
//|            to perform parallel model evaluation from multiple    |
//|            threads, use RBFTSCalcBuf() with per-thread buffer    |
//|            object.                                               |
//| This function returns 0.0 when model is not initialized.         |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY]. Y is out - parameter and|
//|               reallocated after call to this function. In case   |
//|               you want to reuse previously allocated Y, you may  |
//|               use RBFCalcBuf(), which reallocates Y only when it |
//|               is too small.                                      |
//+------------------------------------------------------------------+
void CAlglib::RBFCalc(CRBFModel &s,CRowDouble &x,CRowDouble &y)
  {
   CRBF::RBFCalc(s,x,y);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model and its         |
//| derivatives at the given point.                                  |
//| This is general function which can be used for arbitrary NX      |
//| (dimension of the space of arguments) and NY(dimension of the    |
//| function itself). However if you have NX = 3 and NY = 1, you may |
//| find more convenient to use RBFDiff3().                          |
//| IMPORTANT: THIS FUNCTION IS THREAD - UNSAFE. It uses fields of   |
//|            CRBFModel as temporary arrays, i.e. it is impossible  |
//|            to perform parallel evaluation on the same CRBFModel  |
//|            object (parallel calls of this function for           |
//|            independent CRBFModel objects are safe).              |
//| If you want to perform parallel model evaluation from multiple   |
//| threads, use RBFTSDiffBuf() with per-thread buffer object.       |
//| This function returns 0.0 in Y and/or DY in the following cases: |
//|   * the model is not initialized (Y = 0, DY = 0)                 |
//|   * the gradient is undefined at the trial point. Some basis     |
//|     functions have discontinuous derivatives at the interpolation|
//|     nodes:                                                       |
//|      * biharmonic splines f = r have no Hessian and no gradient  |
//|        at the nodes In these cases only DY is set to zero (Y is  |
//|        still returned)                                           |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY]. Y is out-parameter and  |
//|               reallocated after call to this function. In case   |
//|               you want to reuse previously allocated Y, you may  |
//|               use RBFDiffBuf(), which reallocates Y only when it |
//|               is too small.                                      |
//|   DY       -  derivatives, array[NX * NY]:                       |
//|               * Y[I * NX + J] with 0 <= I < NY and 0 <= J < NX   |
//|                 stores derivative of function component I with   |
//|                 respect to input J.                              |
//|               * for NY = 1 it is simply NX-dimensional gradient  |
//|                 of the scalar NX-dimensional function DY is      |
//|                 out-parameter and reallocated after call to this |
//|                 function. In case you want to reuse previously   |
//|                 allocated DY, you may use RBFDiffBuf(), which    |
//|                 reallocates DY only when it is too small to store|
//|                 the result.                                      |
//+------------------------------------------------------------------+
void CAlglib::RBFDiff(CRBFModel &s,CRowDouble &x,CRowDouble &y,
                      CRowDouble &dy)
  {
   CRBF::RBFDiff(s,x,y,dy);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model and its first   |
//| and second derivatives (Hessian matrix) at the given point.      |
//| This function supports both scalar (NY = 1) and vector - valued  |
//| (NY > 1) RBFs.                                                   |
//| IMPORTANT: THIS FUNCTION IS THREAD - UNSAFE. It uses fields of   |
//|            CRBFModel as temporary arrays, i.e. it is impossible  |
//|            to perform parallel evaluation on the same CRBFModel  |
//|            object (parallel calls of this function for           |
//|            independent CRBFModel objects are safe).              |
//| If you want to perform parallel model evaluation from multiple   |
//| threads, use RBFTsHessBuf() with per - thread buffer object.     |
//| This function returns 0 in Y and/or DY and/or D2Y in the         |
//| following cases:                                                 |
//|   * the model is not initialized (Y = 0, DY = 0, D2Y = 0)        |
//|   * the gradient and/or Hessian is undefined at the trial point. |
//|     Some basis functions have discontinuous derivatives at the   |
//|     interpolation nodes:                                         |
//|      * thin plate splines have no Hessian at the nodes           |
//|      * biharmonic splines f = r have no Hessian and no gradient  |
//|        at the nodes In these cases only corresponding derivative |
//|        is set to zero, and the rest of the derivatives is still  |
//|        returned.                                                 |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY]. Y is out-parameter and  |
//|               reallocated after call to this function. In case   |
//|               you want to reuse previously allocated Y, you may  |
//|               use RBFHessBuf(), which reallocates Y only when    |
//|               it is too small.                                   |
//|   DY       -  first derivatives, array[NY * NX]:                 |
//|               * Y[I * NX + J] with 0 <= I < NY and 0 <= J < NX   |
//|                 stores derivative of function component I with   |
//|                 respect to input J.                              |
//|               * for NY = 1 it is simply NX - dimensional gradient|
//|                 of the scalar NX-dimensional function DY is      |
//|                 out-parameter and reallocated after call to this |
//|                 function. In case you want to reuse previously   |
//|                 allocated DY, you may use RBFHessBuf(), which    |
//|                 reallocates DY only when it is too small to store|
//|                 the result.                                      |
//|   D2Y      -  second derivatives, array[NY * NX * NX]:           |
//|               * for NY = 1 it is NX*NX array that stores Hessian |
//|                 matrix, with Y[I * NX + J] = Y[J * NX + I].      |
//|               * for a vector - valued RBF with NY > 1 it contains|
//|                 NY subsequently stored Hessians: an element      |
//|                 Y[K * NX * NX + I * NX + J] with 0 <= K < NY,    |
//|                 0 <= I < NX and 0 <= J < NX  stores  second      |
//|                 derivative of the function #K with respect to    |
//|                 inputs #I and #J.                                |
//|               D2Y is out-parameter and reallocated after call to |
//|               this function. In case you want to reuse previously|
//|               allocated D2Y, you may use RBFHessBuf(), which     |
//|               reallocates D2Y only when it is too small to store |
//|               the result.                                        |
//+------------------------------------------------------------------+
void CAlglib::RBFHess(CRBFModel &s,CRowDouble &x,CRowDouble &y,
                      CRowDouble &dy,CRowDouble &d2y)
  {
   CRBF::RBFHess(s,x,y,dy,d2y);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model at the given    |
//| point.                                                           |
//| Same as RBFCalc(), but does not reallocate Y when in is large    |
//| enough to store function values.                                 |
//| IMPORTANT: THIS FUNCTION IS THREAD - UNSAFE. It uses fields of   |
//|            CRBFModel as temporary arrays, i.e. it is impossible  |
//|            to perform parallel evaluation on the same CRBFModel  |
//|            object (parallel calls of this function for           |
//|            independent CRBFModel objects are safe). If you want  |
//|            to perform parallel model evaluation from multiple    |
//|            threads, use RBFTSCalcBuf() with per-thread buffer    |
//|            object.                                               |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//|   Y        -  possibly preallocated array                        |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY]. Y is not reallocated    |
//|               when it is larger than NY.                         |
//+------------------------------------------------------------------+
void CAlglib::RBFCalcBuf(CRBFModel &s,CRowDouble &x,CRowDouble &y)
  {
   CRBF::RBFCalcBuf(s,x,y);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model and its         |
//| derivatives at the given point. It is a buffered version of the  |
//| RBFDiff() which tries to reuse possibly preallocated output      |
//| arrays Y / DY as much as possible.                               |
//| This is general function which can be used for arbitrary NX      |
//| (dimension of the space of arguments) and NY (dimension of the   |
//| function itself). However if you have NX = 1, 2 or 3 and NY = 1, |
//| you may find more convenient to use RBFDiff1(), RBFDiff2() or    |
//| RBFDiff3().                                                      |
//| This function returns 0.0 in Y and/or DY in the following cases: |
//|   * the model is not initialized (Y = 0, DY = 0)                 |
//|   * the gradient is undefined at the trial point. Some basis     |
//|     functions have discontinuous derivatives at the interpolation|
//|     nodes:                                                       |
//|      * biharmonic splines f = r have no Hessian and no gradient  |
//|        at the nodes In these cases only DY is set to zero (Y is  |
//|        still returned)                                           |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//|   Y, DY    -  possibly preallocated arrays; if array size is     |
//|               large enough to store results, this function does  |
//|               not reallocate array to fit output size exactly.   |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY].                         |
//|   DY       -  derivatives, array[NX * NY]:                       |
//|               * Y[I * NX + J] with 0 <= I < NY and 0 <= J < NX   |
//|                 stores derivative of function component I with   |
//|                 respect to input J.                              |
//|               * for NY = 1 it is simply NX - dimensional gradient|
//|                 of the scalar NX - dimensional function          |
//+------------------------------------------------------------------+
void CAlglib::RBFDiffBuf(CRBFModel &s,CRowDouble &x,CRowDouble &y,
                         CRowDouble &dy)
  {
   CRBF::RBFDiffBuf(s,x,y,dy);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model and its first   |
//| and second derivatives (Hessian matrix) at the given point. It is|
//| a buffered version that reuses memory allocated in output buffers|
//| Y/DY/D2Y as much as possible.                                    |
//| This function supports both scalar(NY = 1) and vector - valued   |
//| (NY > 1) RBFs.                                                   |
//| This function returns 0 in Y and/or DY and/or D2Y in the         |
//| following cases:                                                 |
//|   * the model is not initialized (Y = 0, DY = 0, D2Y = 0)        |
//|   * the gradient and/or Hessian is undefined at the trial point  |
//|     Some basis functions have discontinuous derivatives at the   |
//|     interpolation nodes:                                         |
//|      * thin plate splines have no Hessian at the nodes           |
//|      * biharmonic splines f = r have no Hessian and no gradient  |
//|        at the nodes In these cases only corresponding derivative |
//|        is set to zero, and the rest of the derivatives is still  |
//|        returned.                                                 |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//|   Y, DY, D2Y - possible preallocated output arrays. If these     |
//|               arrays are smaller than required to store the      |
//|               result, they are automatically reallocated. If     |
//|               array is large enough, it is not resized.          |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY].                         |
//|   DY       -  first derivatives, array[NY * NX]:                 |
//|               * Y[I * NX + J] with 0 <= I < NY and 0 <= J < NX   |
//|                 stores derivative of function component I with   |
//|                 respect to input J.                              |
//|               * for NY = 1 it is simply NX - dimensional gradient|
//|                 of the scalar NX - dimensional function          |
//|   D2Y      -  second derivatives, array[NY * NX * NX]:           |
//|               * for NY = 1 it is NX*NX array that stores Hessian |
//|                 matrix, with Y[I * NX + J] = Y[J * NX + I].      |
//|               * for a vector - valued RBF with NY > 1 it contains|
//|                 NY subsequently stored Hessians: an element      |
//|                 Y[K * NX * NX + I * NX + J] with 0 <= K < NY,    |
//|                 0 <= I < NX and 0 <= J < NX  stores  second      |
//|                 derivative of the function #K with respect to    |
//|                 inputs #I and #J.                                |
//+------------------------------------------------------------------+
void CAlglib::RBFHessBuf(CRBFModel &s,CRowDouble &x,CRowDouble &y,
                         CRowDouble &dy,CRowDouble &d2y)
  {
   CRBF::RBFHessBuf(s,x,y,dy,d2y);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model at the given    |
//| point, using external buffer object (internal temporaries of RBF |
//| model are not modified).                                         |
//| This function allows to use same RBF model object in different   |
//| threads, assuming that different  threads use different instances|
//| of buffer structure.                                             |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, may be shared between different threads |
//|   Buf      -  buffer object created for this particular instance |
//|               of RBF model with RBFCreateCalcBuffer().           |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//|   Y        -  possibly preallocated array                        |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY]. Y is not reallocated    |
//|               when it is larger than NY.                         |
//+------------------------------------------------------------------+
void CAlglib::RBFTSCalcBuf(CRBFModel &s,CRBFCalcBuffer &buf,
                           CRowDouble &x,CRowDouble &y)
  {
   CRBF::RBFTSCalcBuf(s,buf,x,y);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model and its         |
//| derivatives at the given point, using external buffer object     |
//| (internal temporaries of the RBF model are not modified).        |
//| This function allows to use same RBF model object in different   |
//| threads, assuming that different threads use different instances |
//| of the buffer structure.                                         |
//| This function returns 0.0 in Y and/or DY in the following        |
//| cases:                                                           |
//|   * the model is not initialized(Y = 0, DY = 0)                  |
//|   * the gradient is undefined at the trial point. Some basis     |
//|     functions have discontinuous derivatives at the interpolation|
//|     nodes:                                                       |
//|      * biharmonic splines f = r have no Hessian and no gradient  |
//|        at the nodes In these cases only DY is set to zero (Y is  |
//|        still returned)                                           |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, may be shared between different threads |
//|   Buf      -  buffer object created for this particular instance |
//|               of RBF model with RBFCreateCalcBuffer().           |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//|   Y, DY    -  possibly preallocated arrays; if array size is     |
//|               large enough to store results, this function does  |
//|               not reallocate array to fit output size exactly.   |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY].                         |
//|   DY       -  derivatives, array[NX * NY]:                       |
//|               * Y[I * NX + J] with 0 <= I < NY and 0 <= J < NX   |
//|                 stores derivative of function component I with   |
//|                 respect to input J.                              |
//|               * for NY = 1 it is simply NX-dimensional gradient  |
//|                 of the scalar NX-dimensional function            |
//|               Zero is returned when the first derivative is      |
//|               undefined.                                         |
//+------------------------------------------------------------------+
void CAlglib::RBFTSDiffBuf(CRBFModel &s,CRBFCalcBuffer &buf,
                           CRowDouble &x,CRowDouble &y,CRowDouble &dy)
  {
   CRBF::RBFTSDiffBuf(s,buf,x,y,dy);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model and its first   |
//| and second derivatives (Hessian matrix) at the given point, using|
//| external buffer object (internal temporaries of the RBF model are|
//| not modified).                                                   |
//| This function allows to use same RBF model object in different   |
//| threads, assuming that different  threads use different instances|
//| of the buffer structure.                                         |
//| This function returns 0 in Y and/or DY and/or D2Y in the         |
//| following cases:                                                 |
//|   * the model is not initialized (Y = 0, DY = 0, D2Y = 0)        |
//|   * the gradient and/or Hessian is undefined at the trial point. |
//|     Some basis functions have discontinuous derivatives at the   |
//|     interpolation nodes:                                         |
//|   * thin plate splines have no Hessian at the nodes              |
//|   * biharmonic splines f = r have no Hessian and no gradient at  |
//|     the nodes In these cases only corresponding derivative is set|
//|     to zero, and the rest of the derivatives is still returned.  |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, may be shared between different threads |
//|   Buf      -  buffer object created for this particular instance |
//|               of RBF model with RBFCreateCalcBuffer().           |
//|   X        -  coordinates, array[NX]. X may have more than NX    |
//|               elements, in this case only leading NX will be used|
//|   Y, DY, D2Y - possible preallocated output arrays. If these     |
//|               arrays are smaller than required to store the      |
//|               result, they are automatically reallocated. If     |
//|               array is large enough, it is not resized.          |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function value, array[NY].                         |
//|   DY       -  first derivatives, array[NY * NX]:                 |
//|               * Y[I * NX + J] with 0 <= I < NY and 0 <= J < NX   |
//|                 stores derivative of function component I with   |
//|                 respect to input J.                              |
//|               * for NY = 1 it is simply NX - dimensional gradient|
//|                 of the scalar NX - dimensional function Zero is  |
//|                 returned when the first derivative is undefined. |
//|   D2Y      -  second derivatives, array[NY * NX * NX]:           |
//|               * for NY = 1 it is NX*NX array that stores Hessian |
//|                 matrix, with Y[I * NX + J] = Y[J * NX + I].      |
//|               * for a vector - valued RBF with NY > 1 it contains|
//|                 NY subsequently stored Hessians: an element      |
//|                 Y[K * NX * NX + I * NX + J] with 0 <= K < NY,    |
//|                 0 <= I < NX and 0 <= J < NX  stores  second      |
//|                 derivative of the function #K with respect to    |
//|                 inputs and #J.                                   |
//|               Zero is returned when the second derivative is     |
//|               undefined.                                         |
//+------------------------------------------------------------------+
void CAlglib::RBFTSHessBuf(CRBFModel &s,CRBFCalcBuffer &buf,
                           CRowDouble &x,CRowDouble &y,
                           CRowDouble &dy,CRowDouble &d2y)
  {
   CRBF::RBFTSHessBuf(s,buf,x,y,dy,d2y);
  }
//+------------------------------------------------------------------+
//| This is legacy function for gridded calculation of RBF model.    |
//| It is superseded by RBFGridCalc2V() and RBFGridCalc2VSubset()    |
//| functions.                                                       |
//+------------------------------------------------------------------+
void CAlglib::RBFGridCalc2(CRBFModel &s,CRowDouble &x0,int n0,
                           CRowDouble &x1,int n1,CMatrixDouble &y)
  {
   CRBF::RBFGridCalc2(s,x0,n0,x1,n1,y);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model at the regular  |
//| grid, which has N0*N1 points, with Point[I, J] = (X0[I], X1[J]). |
//| Vector - valued RBF models are supported.                        |
//| This function returns 0.0 when:                                  |
//|   * model is not initialized                                     |
//|   * NX<>2                                                        |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, used in read - only mode, can be shared |
//|               between multiple  invocations of this function from|
//|               multiple threads.                                  |
//|   X0       -  array of grid nodes, first coordinates, array[N0]. |
//|               Must be ordered by ascending. Exception is         |
//|               generated if the array is not correctly ordered.   |
//|   N0       -  grid size(number of nodes) in the first dimension  |
//|   X1       -  array of grid nodes, second coordinates, array[N1] |
//|               Must be ordered by ascending. Exception is         |
//|               generated if the array is not correctly ordered.   |
//|   N1       -  grid size(number of nodes) in the second dimension |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function values, array[NY * N0 * N1], where NY is a|
//|               number of "output" vector values(this function     |
//|               supports vector - valued RBF models). Y is         |
//|               out-variable and is reallocated by this function.  |
//|               Y[K + NY * (I0 + I1 * N0)] = F_k(X0[I0], X1[I1]),  |
//|               for:                                               |
//|               * K = 0...NY - 1                                   |
//|               * I0 = 0...N0 - 1                                  |
//|               * I1 = 0...N1 - 1                                  |
//| NOTE: this function supports weakly ordered grid nodes, i.e. you |
//|       may have X[i] = X[i + 1] for some i. It does not provide   |
//|       you any performance benefits due to  duplication of points,|
//|       just convenience and flexibility.                          |
//| NOTE: this function is re-entrant, i.e. you may use same         |
//|       CRBFModel structure in multiple threads calling this       |
//|       function for different grids.                              |
//| NOTE: if you need function values on some subset of regular grid,|
//|       which may be described as "several compact and dense       |
//|       islands", you may use RBFGridCalc2VSubset().               |
//+------------------------------------------------------------------+
void CAlglib::RBFGridCalc2V(CRBFModel &s,CRowDouble &x0,int n0,
                            CRowDouble &x1,int n1,CRowDouble &y)
  {
   CRBF::RBFGridCalc2V(s,x0,n0,x1,n1,y);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model at some subset  |
//| of regular grid:                                                 |
//|   * grid has N0*N1 points, with Point[I, J] = (X0[I], X1[J])     |
//|   * only values at some subset of this grid are required         |
//| Vector - valued RBF models are supported.                        |
//| This function returns 0.0 when:                                  |
//|   * model is not initialized                                     |
//|   * NX<>2                                                        |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, used in read - only mode, can be shared |
//|               between multiple invocations of this function from |
//|               multiple threads.                                  |
//|   X0       -  array of grid nodes, first coordinates, array[N0]. |
//|               Must be ordered by ascending. Exception is         |
//|               generated if the array is not correctly ordered.   |
//|   N0       -  grid size (number of nodes) in the first dimension |
//|   X1       -  array of grid nodes, second coordinates, array[N1] |
//|               Must be ordered by ascending. Exception is         |
//|               generated if the array is not correctly ordered.   |
//|   N1       -  grid size(number of nodes) in the second dimension |
//|   FlagY    -  array[N0 * N1]:                                    |
//|               * Y[I0 + I1 * N0] corresponds to node (X0[I0],     |
//|                 X1[I1])                                          |
//|              *it is a "bitmap" array which contains False for  |
//|                 nodes which are NOT calculated, and True for     |
//|                 nodes which are required.                        |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function values, array[NY * N0 * N1 * N2], where NY|
//|               is a number of "output" vector values (this        |
//|               function supports vector - valued RBF models):     |
//|               * Y[K + NY * (I0 + I1 * N0)] = F_k(X0[I0],X1[I1]), |
//|                  for K = 0...NY-1, I0 = 0...N0-1, I1 = 0...N1-1. |
//|               * elements of Y[] which correspond to FlagY[]=True |
//|                  are loaded by model values(which may be exactly |
//|                  zero for some nodes).                           |
//|               * elements of Y[] which correspond to FlagY[]=False|
//|                  MAY be initialized by zeros OR may be calculated|
//|                  This function processes grid as a hierarchy of  |
//|                  nested blocks and micro-rows. If just one       |
//|                  element of micro-row is required, entire micro- |
//|                  row (up to 8 nodes in the current version, but  |
//|                  no promises) is calculated.                     |
//| NOTE: this function supports weakly ordered grid nodes, i.e. you |
//|       may have X[i] = X[i + 1] for some i. It does not provide   |
//|       you any performance benefits due to duplication of points, |
//|       just convenience and flexibility.                          |
//| NOTE: this function is re - entrant, i.e. you may use same       |
//|       CRBFModel structure in multiple threads calling this       |
//|       function for different grids.                              |
//+------------------------------------------------------------------+
void CAlglib::RBFGridCalc2VSubset(CRBFModel &s,CRowDouble &x0,int n0,
                                  CRowDouble &x1,int n1,bool &flagy[],
                                  CRowDouble &y)
  {
   CRBF::RBFGridCalc2VSubset(s,x0,n0,x1,n1,flagy,y);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model at the regular  |
//| grid, which has N0*N1*N2 points, with Point[I, J, K] = (X0[I],   |
//| X1[J], X2[K]). Vector - valued RBF models are supported.         |
//| This function returns 0.0 when:                                  |
//|   * model is not initialized                                     |
//|   * NX<>3                                                        |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, used in read-only mode, can be shared   |
//|               between multiple  invocations of this function from|
//|               multiple threads.                                  |
//|   X0       -  array of grid nodes, first coordinates, array[N0]. |
//|               Must be ordered by ascending. Exception is         |
//|               generated if the array is not correctly ordered.   |
//|   N0       -  grid size(number of nodes) in the first dimension  |
//|   X1       -  array of grid nodes, second coordinates, array[N1] |
//|               Must be ordered by ascending. Exception is         |
//|               generated if the array is not correctly ordered.   |
//|   N1       -  grid size(number of nodes) in the second dimension |
//|   X2       -  array of grid nodes, third coordinates, array[N2]  |
//|               Must be ordered by ascending. Exception is         |
//|               generated if the array is not correctly ordered.   |
//|   N2       -  grid size(number of nodes) in the third dimension  |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function values, array[NY * N0 * N1 * N2], where NY|
//|               is a number of "output" vector values (this        |
//|               function supports vector-valued RBF models). Y is  |
//|               out-variable and is reallocated by this function.  |
//|          Y[K+NY*(I0+I1*N0+I2*N0*N1)] = F_k(X0[I0],X1[I1],X2[I2]),|
//|               for:                                               |
//|               *  K = 0...NY - 1                                  |
//|               * I0 = 0...N0 - 1                                  |
//|               * I1 = 0...N1 - 1                                  |
//|               * I2 = 0...N2 - 1                                  |
//| NOTE: this function supports weakly ordered grid nodes, i.e. you |
//|       may have X[i] = X[i + 1] for some i. It does not provide   |
//|       you any performance benefits due to  duplication of points,|
//|       just convenience and flexibility.                          |
//| NOTE: this function is re-entrant, i.e. you may use same         |
//|       CRBFModel structure in multiple threads calling this       |
//|       function for different grids.                              |
//| NOTE: if you need function values on some subset of regular grid,|
//|       which may be described as "several compact and dense       |
//|       islands", you may use RBFGridCalc3VSubset().               |
//+------------------------------------------------------------------+
void CAlglib::RBFGridCalc3V(CRBFModel &s,CRowDouble &x0,int n0,
                            CRowDouble &x1,int n1,CRowDouble &x2,
                            int n2,CRowDouble &y)
  {
   CRBF::RBFGridCalc3V(s,x0,n0,x1,n1,x2,n2,y);
  }
//+------------------------------------------------------------------+
//| This function calculates values of the RBF model at some subset  |
//| of regular grid:                                                 |
//|   * grid has N0*N1*N2 points, with Point[I, J, K] = (X0[I],      |
//|     X1[J], X2[K])                                                |
//|   * only values at some subset of this grid are required         |
//|     Vector - valued RBF models are supported.                    |
//| This function returns 0.0 when:                                  |
//|   * model is not initialized                                     |
//|   * NX<>3                                                        |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model, used in read - only mode, can be shared |
//|               between multiple  invocations of this function from|
//|               multiple threads.                                  |
//|   X0       -  array of grid nodes, first coordinates, array[N0]. |
//|               Must be ordered by ascending. Exception is         |
//|               generated if the array is not correctly ordered.   |
//|   N0       -  grid size(number of nodes) in the first dimension  |
//|   X1       -  array of grid nodes, second coordinates, array[N1] |
//|               Must be ordered by ascending. Exception is         |
//|               generated if the array is not correctly ordered.   |
//|   N1       -  grid size(number of nodes) in the second dimension |
//|   X2       -  array of grid nodes, third coordinates, array[N2]  |
//|               Must be ordered by ascending. Exception is         |
//|               generated if the array is not correctly ordered.   |
//|   N2       -  grid size(number of nodes) in the third dimension  |
//|   FlagY    -  array[N0 * N1 * N2]:                               |
//|               * Y[I0 + I1 * N0 + I2 * N0 * N1] corresponds to    |
//|                 node (X0[I0], X1[I1], X2[I2])                    |
//|              *it is a "bitmap" array which contains False for  |
//|                 nodes which are NOT calculated, and True for     |
//|                 nodes which are required.                        |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  function values, array[NY * N0 * N1 * N2], where NY|
//|               is a number of "output" vector values(this function|
//|               supports vector- valued RBF models):               |
//|        * Y[K+NY*(I0+I1*N0+I2*N0*N1)] = F_k(X0[I0],X1[I1],X2[I2]),|
//|                 for K = 0...NY-1, I0 = 0...N0-1, I1 = 0...N1-1,  |
//|                 I2 = 0...N2-1.                                   |
//|               * elements of Y[] which correspond to FlagY[]=True |
//|                 are loaded by model values(which may be exactly  |
//|                 zero for some nodes).                            |
//|               * elements of Y[] which correspond to FlagY[]=False|
//|                 MAY be initialized by zeros OR may be calculated.|
//|                 This function processes grid as a hierarchy of   |
//|                 nested blocks and micro-rows. If just one element|
//|                 of micro-row is required, entire micro-row (up to|
//|                 8 nodes in the current version, but no promises) |
//|                 is calculated.                                   |
//| NOTE: this function supports weakly ordered grid nodes, i.e. you |
//|       may have X[i] = X[i + 1] for some i. It does not provide   |
//|       you any performance benefits due to  duplication of points,|
//|       just convenience and flexibility.                          |
//| NOTE: this function is re-entrant, i.e. you may use same         |
//|       CRBFModel structure in multiple threads calling this       |
//|       function for different grids.                              |
//+------------------------------------------------------------------+
void CAlglib::RBFGridCalc3VSubset(CRBFModel &s,CRowDouble &x0,int n0,
                                  CRowDouble &x1,int n1,
                                  CRowDouble &x2,int n2,
                                  bool &flagy[],CRowDouble &y)
  {
   CRBF::RBFGridCalc3VSubset(s,x0,n0,x1,n1,x2,n2,flagy,y);
  }
//+------------------------------------------------------------------+
//| This function "unpacks" RBF model by extracting its coefficients.|
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//| OUTPUT PARAMETERS:                                               |
//|   NX       -  dimensionality of argument                         |
//|   NY       -  dimensionality of the target function              |
//|   XWR      -  model information, 2D array. One row of the array  |
//|               corresponds to one basis function.                 |
//| For ModelVersion = 1 we have NX + NY + 1 columns:                |
//|   * first NX columns - coordinates of the center                 |
//|   * next NY columns  - weights, one per dimension of the function|
//|                        being modeled                             |
//|   * last column      - radius, same for all dimensions of the    |
//|                        function being modeled                    |
//| For ModelVersion = 2 we have NX + NY + NX columns:               |
//|   * first NX columns - coordinates of the center                 |
//|   * next NY columns  - weights, one per dimension of the function|
//|                        being modeled                             |
//|   * last NX columns  - radii, one per dimension                  |
//| For ModelVersion = 3 we have NX + NY + NX + 3 columns:           |
//|   * first NX columns - coordinates of the center                 |
//|   * next NY columns  - weights, one per dimension of the         |
//|                        function being modeled                    |
//|   * next NX columns  - radii, one per dimension                  |
//|   * next column      - basis function type:                      |
//|                        * 1 for f = r                             |
//|                        * 2 for f = r ^ 2 * ln(r)                 |
//|                        * 10 for multiquadric f=sqrt(r^2+alpha^2) |
//|   * next column      - basis function parameter:                 |
//|                        * alpha, for basis function type 10       |
//|                        * ignored(zero) for other basis function  |
//|                          types                                   |
//|   * next column      - point index in the original dataset, or -1|
//|                        for an artificial node created by the     |
//|                        solver. The algorithm may reorder the     |
//|                        nodes, drop some nodes or add artificial  |
//|                        nodes. Thus, one parsing this column      |
//|                        should expect all these kinds of          |
//|                        alterations in the dataset.               |
//|   NC          -  number of the centers                           |
//|   V           -  polynomial term, array[NY, NX + 1]. One row per |
//|                  one dimension of the function being modelled.   |
//|                  First NX elements are linear coefficients, V[NX]|
//|                  is equal to the constant part.                  |
//|   ModelVersion - version of the RBF model:                       |
//|                  * 1 - for models created by QNN and RBF-ML      |
//|                        algorithms, compatible with ALGLIB 3.10 or|
//|                        earlier.                                  |
//|                  * 2 - for models created by HierarchicalRBF,    |
//|                        requires ALGLIB 3.11 or later             |
//|                  * 3 - for models created by DDM-RBF, requires   |
//|                        ALGLIB 3.19 or later                      |
//+------------------------------------------------------------------+
void CAlglib::RBFUnpack(CRBFModel &s,int &nx,int &ny,
                        CMatrixDouble &xwr,int &nc,
                        CMatrixDouble &v,int &modelversion)
  {
   CRBF::RBFUnpack(s,nx,ny,xwr,nc,v,modelversion);
  }
//+------------------------------------------------------------------+
//|This function returns model version.                              |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model                                          |
//| RESULT:                                                          |
//|   * 1 - for models created by QNN and RBF-ML algorithms,         |
//|         compatible with ALGLIB 3.10 or earlier.                  |
//|   * 2 - for models created by HierarchicalRBF, requires          |
//|         ALGLIB 3.11 or later                                     |
//+------------------------------------------------------------------+
int CAlglib::RBFGetModelVersion(CRBFModel &s)
  {
   return(CRBF::RBFGetModelVersion(s));
  }
//+------------------------------------------------------------------+
//| This function is used to peek into hierarchical RBF construction |
//| process from some other thread and get current progress indicator|
//| It returns value in [0, 1].                                      |
//| IMPORTANT: only HRBFs (hierarchical RBFs) support peeking into   |
//|            progress indicator. Legacy RBF-ML and RBF-QNN do not  |
//|            support it. You will always get 0 value.              |
//| INPUT PARAMETERS:                                                |
//|   S        -  RBF model object                                   |
//| RESULT:                                                          |
//|   progress value, in [0, 1]                                      |
//+------------------------------------------------------------------+
double CAlglib::RBFPeekProgress(CRBFModel &s)
  {
   return(CRBF::RBFPeekProgress(s));
  }
//+------------------------------------------------------------------+
//| This function is used to submit a request for termination of the |
//| hierarchical RBF construction process from some other thread. As |
//| result, RBF construction is terminated smoothly (with proper     |
//| deallocation of all necessary resources) and resultant model is  |
//| filled by zeros.                                                 |
//| A rep.m_terminationtype = 8 will be returned upon receiving such |
//| request.                                                         |
//| IMPORTANT: only HRBFs(hierarchical RBFs) support termination     |
//|            requests. Legacy RBF-ML and RBF-QNN do not support it.|
//|            An attempt to terminate their construction will be    |
//|            ignored.                                              |
//| IMPORTANT: termination request flag is cleared when the model    |
//|            construction starts. Thus, any pre-construction       |
//|            termination requests will be silently ignored - only  |
//|            ones submitted AFTER construction has actually began  |
//|            will be handled.                                      |
//| INPUT PARAMETERS:                                                |
//| S       -  RBF model object                                      |
//+------------------------------------------------------------------+
void CAlglib::RBFRequestTermination(CRBFModel &s)
  {
   CRBF::RBFRequestTermination(s);
  }
//+------------------------------------------------------------------+
//| Cache-oblivous complex "copy-and-transpose"                      |
//| Input parameters:                                                |
//|     M   -   number of rows                                       |
//|     N   -   number of columns                                    |
//|     A   -   source matrix, MxN submatrix is copied and transposed|
//|     IA  -   submatrix offset (row index)                         |
//|     JA  -   submatrix offset (column index)                      |
//|     A   -   destination matrix                                   |
//|     IB  -   submatrix offset (row index)                         |
//|     JB  -   submatrix offset (column index)                      |
//+------------------------------------------------------------------+
void CAlglib::CMatrixTranspose(const int m,const int n,CMatrixComplex &a,
                               const int ia,const int ja,CMatrixComplex &b,
                               const int ib,const int jb)
  {
   CAblas::CMatrixTranspose(m,n,a,ia,ja,b,ib,jb);
  }
//+------------------------------------------------------------------+
//| Cache-oblivous real "copy-and-transpose"                         |
//| Input parameters:                                                |
//|     M   -   number of rows                                       |
//|     N   -   number of columns                                    |
//|     A   -   source matrix, MxN submatrix is copied and transposed|
//|     IA  -   submatrix offset (row index)                         |
//|     JA  -   submatrix offset (column index)                      |
//|     A   -   destination matrix                                   |
//|     IB  -   submatrix offset (row index)                         |
//|     JB  -   submatrix offset (column index)                      |
//+------------------------------------------------------------------+
void CAlglib::RMatrixTranspose(const int m,const int n,CMatrixDouble &a,
                               const int ia,const int ja,CMatrixDouble &b,
                               const int ib,const int jb)
  {
   CAblas::RMatrixTranspose(m,n,a,ia,ja,b,ib,jb);
  }
//+------------------------------------------------------------------+
//| This code enforces symmetricy of the matrix by copying Upper part|
//| to lower one (or vice versa).                                    |
//| INPUT PARAMETERS:                                                |
//|   A        -  matrix                                             |
//|   N        -  number of rows/columns                             |
//|   IsUpper  -  whether we want to copy upper triangle to lower    |
//|               one (True) or vice versa (False).                  |
//+------------------------------------------------------------------+
void CAlglib::RMatrixEnforceSymmetricity(CMatrixDouble &a,int n,bool IsUpper)
  {
   CAblas::RMatrixEnforceSymmetricity(a,n,IsUpper);
  }
//+------------------------------------------------------------------+
//| Copy                                                             |
//| Input parameters:                                                |
//|     M   -   number of rows                                       |
//|     N   -   number of columns                                    |
//|     A   -   source matrix, MxN submatrix is copied and transposed|
//|     IA  -   submatrix offset (row index)                         |
//|     JA  -   submatrix offset (column index)                      |
//|     B   -   destination matrix                                   |
//|     IB  -   submatrix offset (row index)                         |
//|     JB  -   submatrix offset (column index)                      |
//+------------------------------------------------------------------+
void CAlglib::CMatrixCopy(const int m,const int n,CMatrixComplex &a,
                          const int ia,const int ja,CMatrixComplex &b,
                          const int ib,const int jb)
  {
   CAblas::CMatrixCopy(m,n,a,ia,ja,b,ib,jb);
  }
//+------------------------------------------------------------------+
//| Copy                                                             |
//| Input parameters:                                                |
//|   N     -  subvector size                                        |
//|   A     -  source vector, N elements are copied                  |
//|   IA    -  source offset (first element index)                   |
//|   B     -  destination vector, must be large enough to store     |
//|            result                                                |
//|   IB    -  destination offset (first element index)              |
//+------------------------------------------------------------------+
void CAlglib::RVectorCopy(int n,CRowDouble &a,int ia,CRowDouble &b,int ib)
  {
   CAblas::RVectorCopy(n,a,ia,b,ib);
  }
//+------------------------------------------------------------------+
//| Copy                                                             |
//| Input parameters:                                                |
//|     M   -   number of rows                                       |
//|     N   -   number of columns                                    |
//|     A   -   source matrix, MxN submatrix is copied and transposed|
//|     IA  -   submatrix offset (row index)                         |
//|     JA  -   submatrix offset (column index)                      |
//|     B   -   destination matrix                                   |
//|     IB  -   submatrix offset (row index)                         |
//|     JB  -   submatrix offset (column index)                      |
//+------------------------------------------------------------------+
void CAlglib::RMatrixCopy(const int m,const int n,CMatrixDouble &a,
                          const int ia,const int ja,CMatrixDouble &b,
                          const int ib,const int jb)
  {
   CAblas::RMatrixCopy(m,n,a,ia,ja,b,ib,jb);
  }
//+------------------------------------------------------------------+
//| Performs generalized copy: B := Beta*B + Alpha*A.                |
//| If Beta=0, then previous contents of B is simply ignored. If     |
//| Alpha=0, then A is ignored and not referenced. If both Alpha and |
//| Beta are zero, B is filled by zeros.                             |
//| Input parameters:                                                |
//|   M     -  number of rows                                        |
//|   N     -  number of columns                                     |
//|   Alpha -  coefficient                                           |
//|   A     -  source matrix, MxN submatrix is copied and transposed |
//|   IA    -  submatrix offset (row index)                          |
//|   JA    -  submatrix offset (column index)                       |
//|   Beta  -  coefficient                                           |
//|   B     -  destination matrix, must be large enough to store     |
//|            result                                                |
//|   IB    -  submatrix offset (row index)                          |
//|   JB    -  submatrix offset (column index)                       |
//+------------------------------------------------------------------+
void CAlglib::RMatrixGenCopy(int m,int n,double alpha,
                             CMatrixDouble &a,int ia,int ja,
                             double beta,CMatrixDouble &b,
                             int ib,int jb)
  {
   CAblas::RMatrixGenCopy(m,n,alpha,a,ia,ja,beta,b,ib,jb);
  }
//+------------------------------------------------------------------+
//| Rank-1 correction: A := A + alpha*u*v'                           |
//| NOTE: this function expects A to be large enough to store result.|
//| No automatic preallocation happens for smaller arrays. No        |
//| integrity checks is performed for sizes of A, u, v.              |
//| INPUT PARAMETERS:                                                |
//|   M     -  number of rows                                        |
//|   N     -  number of columns                                     |
//|   A     -  target matrix, MxN submatrix is updated               |
//|   IA    -  submatrix offset (row index)                          |
//|   JA    -  submatrix offset (column index)                       |
//| Alpha   -  coefficient                                           |
//|   U     -  vector #1                                             |
//|   IU    -  subvector offset                                      |
//|   V     -  vector #2                                             |
//|   IV    -  subvector offset                                      |
//+------------------------------------------------------------------+
void CAlglib::RMatrixGer(int m,int n,CMatrixDouble &a,int ia,
                         int ja,double alpha,CRowDouble &u,
                         int iu,CRowDouble &v,int iv)
  {
   CAblas::RMatrixGer(m,n,a,ia,ja,alpha,u,iu,v,iv);
  }
//+------------------------------------------------------------------+
//| Rank-1 correction: A := A + u*v'                                 |
//| INPUT PARAMETERS:                                                |
//|     M   -   number of rows                                       |
//|     N   -   number of columns                                    |
//|     A   -   target matrix, MxN submatrix is updated              |
//|     IA  -   submatrix offset (row index)                         |
//|     JA  -   submatrix offset (column index)                      |
//|     U   -   vector #1                                            |
//|     IU  -   subvector offset                                     |
//|     V   -   vector #2                                            |
//|     IV  -   subvector offset                                     |
//+------------------------------------------------------------------+
void CAlglib::CMatrixRank1(const int m,const int n,CMatrixComplex &a,
                           const int ia,const int ja,complex &u[],
                           const int iu,complex &v[],const int iv)
  {
   CAblas::CMatrixRank1(m,n,a,ia,ja,u,iu,v,iv);
  }
//+------------------------------------------------------------------+
//| Rank-1 correction: A := A + u*v'                                 |
//| INPUT PARAMETERS:                                                |
//|     M   -   number of rows                                       |
//|     N   -   number of columns                                    |
//|     A   -   target matrix, MxN submatrix is updated              |
//|     IA  -   submatrix offset (row index)                         |
//|     JA  -   submatrix offset (column index)                      |
//|     U   -   vector #1                                            |
//|     IU  -   subvector offset                                     |
//|     V   -   vector #2                                            |
//|     IV  -   subvector offset                                     |
//+------------------------------------------------------------------+
void CAlglib::RMatrixRank1(const int m,const int n,CMatrixDouble &a,
                           const int ia,const int ja,double &u[],
                           const int iu,double &v[],const int iv)
  {
   CAblas::RMatrixRank1(m,n,a,ia,ja,u,iu,v,iv);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::RMatrixGemVect(int m,int n,double alpha,
                             CMatrixDouble &a,int ia,int ja,int opa,
                             CRowDouble &x,int ix,double beta,
                             CRowDouble &y,int iy)
  {
   CAblas::RMatrixGemVect(m,n,alpha,a,ia,ja,opa,x,ix,beta,y,iy);
  }
//+------------------------------------------------------------------+
//| Matrix-vector product: y := op(A)*x                              |
//| INPUT PARAMETERS:                                                |
//|     M   -   number of rows of op(A)                              |
//|             M>=0                                                 |
//|     N   -   number of columns of op(A)                           |
//|             N>=0                                                 |
//|     A   -   target matrix                                        |
//|     IA  -   submatrix offset (row index)                         |
//|     JA  -   submatrix offset (column index)                      |
//|     OpA -   operation type:                                      |
//|             * OpA=0     =>  op(A) = A                            |
//|             * OpA=1     =>  op(A) = A^T                          |
//|             * OpA=2     =>  op(A) = A^H                          |
//|     X   -   input vector                                         |
//|     IX  -   subvector offset                                     |
//|     IY  -   subvector offset                                     |
//| OUTPUT PARAMETERS:                                               |
//|     Y   -   vector which stores result                           |
//| if M=0, then subroutine does nothing.                            |
//| if N=0, Y is filled by zeros.                                    |
//+------------------------------------------------------------------+
void CAlglib::CMatrixMVect(const int m,const int n,CMatrixComplex &a,
                           const int ia,const int ja,const int opa,
                           complex &x[],const int ix,complex &y[],
                           const int iy)
  {
   CAblas::CMatrixMVect(m,n,a,ia,ja,opa,x,ix,y,iy);
  }
//+------------------------------------------------------------------+
//| Matrix-vector product: y := op(A)*x                              |
//| INPUT PARAMETERS:                                                |
//|     M   -   number of rows of op(A)                              |
//|     N   -   number of columns of op(A)                           |
//|     A   -   target matrix                                        |
//|     IA  -   submatrix offset (row index)                         |
//|     JA  -   submatrix offset (column index)                      |
//|     OpA -   operation type:                                      |
//|             * OpA=0     =>  op(A) = A                            |
//|             * OpA=1     =>  op(A) = A^T                          |
//|     X   -   input vector                                         |
//|     IX  -   subvector offset                                     |
//|     IY  -   subvector offset                                     |
//| OUTPUT PARAMETERS:                                               |
//|     Y   -   vector which stores result                           |
//| if M=0, then subroutine does nothing.                            |
//| if N=0, Y is filled by zeros.                                    |
//+------------------------------------------------------------------+
void CAlglib::RMatrixMVect(const int m,const int n,CMatrixDouble &a,
                           const int ia,const int ja,const int opa,
                           double &x[],const int ix,double &y[],
                           const int iy)
  {
   CAblas::RMatrixMVect(m,n,a,ia,ja,opa,x,ix,y,iy);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::RMatrixSymVect(int n,double alpha,CMatrixDouble &a,
                             int ia,int ja,bool IsUpper,CRowDouble &x,
                             int ix,double beta,CRowDouble &y,int iy)
  {
   CAblas::RMatrixSymVect(n,alpha,a,ia,ja,IsUpper,x,ix,beta,y,iy);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CAlglib::RMatrixSyvMVect(int n,CMatrixDouble &a,int ia,int ja,
                                bool IsUpper,CRowDouble &x,int ix,
                                CRowDouble &tmp)
  {
   return(CAblas::RMatrixSyvMVect(n,a,ia,ja,IsUpper,x,ix,tmp));
  }
//+------------------------------------------------------------------+
//| This subroutine solves linear system op(A)*x=b where:            |
//| * A is NxN upper/lower triangular/unitriangular matrix           |
//| * X and B are Nx1 vectors                                        |
//|*"op" may be identity transformation or transposition           |
//| Solution replaces X.                                             |
//| IMPORTANT: * no overflow/underflow/denegeracy tests is performed.|
//|            * no integrity checks for operand sizes, out-of-bounds|
//|              accesses and so on is performed                     |
//| INPUT PARAMETERS:                                                |
//|   N     -  matrix size, N>=0                                     |
//|   A     -  matrix, actial matrix is stored in                    |
//|            A[IA:IA+N-1,JA:JA+N-1]                                |
//|   IA    -  submatrix offset                                      |
//|   JA    -  submatrix offset                                      |
//|   IsUpper  -  whether matrix is upper triangular                 |
//|   IsUnit   -  whether matrix is unitriangular                    |
//|   OpType   -  transformation type:                               |
//|               * 0 - no transformation                            |
//|               * 1 - transposition                                |
//|   X     -  right part, actual vector is stored in X[IX:IX+N-1]   |
//|   IX    -  offset                                                |
//| OUTPUT PARAMETERS:                                               |
//|   X     -  solution replaces elements X[IX:IX+N-1]               |
//| (c) 2016 Reference BLAS level1 routine (LAPACK version 3.7.0)    |
//| Reference BLAS is a software package provided by Univ. of        |
//| Tennessee, Univ. of California Berkeley, Univ. of Colorado Denver|
//| and NAG Ltd.                                                     |
//+------------------------------------------------------------------+
void CAlglib::RMatrixTrsVect(int n,CMatrixDouble &a,int ia,int ja,
                             bool IsUpper,bool IsUnit,int OpType,
                             CRowDouble &x,int ix)
  {
   CAblas::RMatrixTrsVect(n,a,ia,ja,IsUpper,IsUnit,OpType,x,ix);
  }
//+------------------------------------------------------------------+
//| This subroutine calculates X*op(A^-1) where:                     |
//| * X is MxN general matrix                                        |
//| * A is NxN upper/lower triangular/unitriangular matrix           |
//|*"op" may be identity transformation, transposition, conjugate  |
//|   transposition                                                  |
//| Multiplication result replaces X.                                |
//| Cache-oblivious algorithm is used.                               |
//| INPUT PARAMETERS                                                 |
//|     N   -   matrix size, N>=0                                    |
//|     M   -   matrix size, N>=0                                    |
//|     A       -   matrix, actial matrix is stored in               |
//|                 A[I1:I1+N-1,J1:J1+N-1]                           |
//|     I1      -   submatrix offset                                 |
//|     J1      -   submatrix offset                                 |
//|     IsUpper -   whether matrix is upper triangular               |
//|     IsUnit  -   whether matrix is unitriangular                  |
//|     OpType  -   transformation type:                             |
//|                 * 0 - no transformation                          |
//|                 * 1 - transposition                              |
//|                 * 2 - conjugate transposition                    |
//|     C   -   matrix, actial matrix is stored in                   |
//|             C[I2:I2+M-1,J2:J2+N-1]                               |
//|     I2  -   submatrix offset                                     |
//|     J2  -   submatrix offset                                     |
//+------------------------------------------------------------------+
void CAlglib::CMatrixRightTrsM(const int m,const int n,CMatrixComplex &a,
                               const int i1,const int j1,const bool IsUpper,
                               const bool IsUnit,const int OpType,
                               CMatrixComplex &x,const int i2,const int j2)
  {
   CAblas::CMatrixRightTrsM(m,n,a,i1,j1,IsUpper,IsUnit,OpType,x,i2,j2);
  }
//+------------------------------------------------------------------+
//| This subroutine calculates op(A^-1)*X where:                     |
//| * X is MxN general matrix                                        |
//| * A is MxM upper/lower triangular/unitriangular matrix           |
//|*"op" may be identity transformation, transposition, conjugate  |
//|   transposition                                                  |
//| Multiplication result replaces X.                                |
//| Cache-oblivious algorithm is used.                               |
//| INPUT PARAMETERS                                                 |
//|     N   -   matrix size, N>=0                                    |
//|     M   -   matrix size, N>=0                                    |
//|     A       -   matrix, actial matrix is stored in               |
//|                 A[I1:I1+M-1,J1:J1+M-1]                           |
//|     I1      -   submatrix offset                                 |
//|     J1      -   submatrix offset                                 |
//|     IsUpper -   whether matrix is upper triangular               |
//|     IsUnit  -   whether matrix is unitriangular                  |
//|     OpType  -   transformation type:                             |
//|                 * 0 - no transformation                          |
//|                 * 1 - transposition                              |
//|                 * 2 - conjugate transposition                    |
//|     C   -   matrix, actial matrix is stored in                   |
//|             C[I2:I2+M-1,J2:J2+N-1]                               |
//|     I2  -   submatrix offset                                     |
//|     J2  -   submatrix offset                                     |
//+------------------------------------------------------------------+
void CAlglib::CMatrixLeftTrsM(const int m,const int n,CMatrixComplex &a,
                              const int i1,const int j1,const bool IsUpper,
                              const bool IsUnit,const int OpType,
                              CMatrixComplex &x,const int i2,const int j2)
  {
   CAblas::CMatrixLeftTrsM(m,n,a,i1,j1,IsUpper,IsUnit,OpType,x,i2,j2);
  }
//+------------------------------------------------------------------+
//| Same as CMatrixRightTRSM, but for real matrices                  |
//| OpType may be only 0 or 1.                                       |
//+------------------------------------------------------------------+
void CAlglib::RMatrixRightTrsM(const int m,const int n,CMatrixDouble &a,
                               const int i1,const int j1,const bool IsUpper,
                               const bool IsUnit,const int OpType,
                               CMatrixDouble &x,const int i2,const int j2)
  {
   CAblas::RMatrixRightTrsM(m,n,a,i1,j1,IsUpper,IsUnit,OpType,x,i2,j2);
  }
//+------------------------------------------------------------------+
//| Same as CMatrixLeftTRSM, but for real matrices                   |
//| OpType may be only 0 or 1.                                       |
//+------------------------------------------------------------------+
void CAlglib::RMatrixLeftTrsM(const int m,const int n,CMatrixDouble &a,
                              const int i1,const int j1,const bool IsUpper,
                              const bool IsUnit,const int OpType,
                              CMatrixDouble &x,const int i2,const int j2)
  {
   CAblas::RMatrixLeftTrsM(m,n,a,i1,j1,IsUpper,IsUnit,OpType,x,i2,j2);
  }
//+------------------------------------------------------------------+
//| This subroutine calculates  C=alpha*A*A^H+beta*C or              |
//| C=alpha*A^H*A+beta*C where:                                      |
//| * C is NxN Hermitian matrix given by its upper/lower triangle    |
//| * A is NxK matrix when A*A^H is calculated, KxN matrix otherwise |
//| Additional info:                                                 |
//| * cache-oblivious algorithm is used.                             |
//| * multiplication result replaces C. If Beta=0, C elements are not|
//|   used in calculations (not multiplied by zero - just not        |
//|   referenced)                                                    |
//| * if Alpha=0, A is not used (not multiplied by zero - just not   |
//|   referenced)                                                    |
//| * if both Beta and Alpha are zero, C is filled by zeros.         |
//| INPUT PARAMETERS                                                 |
//|     N       -   matrix size, N>=0                                |
//|     K       -   matrix size, K>=0                                |
//|     Alpha   -   coefficient                                      |
//|     A       -   matrix                                           |
//|     IA      -   submatrix offset                                 |
//|     JA      -   submatrix offset                                 |
//|     OpTypeA -   multiplication type:                             |
//|                 * 0 - A*A^H is calculated                        |
//|                 * 2 - A^H*A is calculated                        |
//|     Beta    -   coefficient                                      |
//|     C       -   matrix                                           |
//|     IC      -   submatrix offset                                 |
//|     JC      -   submatrix offset                                 |
//|     IsUpper -   whether C is upper triangular or lower triangular|
//+------------------------------------------------------------------+
void CAlglib::CMatrixSyrk(const int n,const int k,const double alpha,
                          CMatrixComplex &a,const int ia,const int ja,
                          const int optypea,const double beta,CMatrixComplex &c,
                          const int ic,const int jc,const bool IsUpper)
  {
   CAblas::CMatrixSyrk(n,k,alpha,a,ia,ja,optypea,beta,c,ic,jc,IsUpper);
  }
//+------------------------------------------------------------------+
//| Same as CMatrixSYRK, but for real matrices                       |
//| OpType may be only 0 or 1.                                       |
//+------------------------------------------------------------------+
void CAlglib::RMatrixSyrk(const int n,const int k,const double alpha,
                          CMatrixDouble &a,const int ia,const int ja,
                          const int optypea,const double beta,
                          CMatrixDouble &c,const int ic,
                          const int jc,const bool IsUpper)
  {
   CAblas::RMatrixSyrk(n,k,alpha,a,ia,ja,optypea,beta,c,ic,jc,IsUpper);
  }
//+------------------------------------------------------------------+
//| This subroutine calculates C = alpha*op1(A)*op2(B) +beta*C where:|
//| * C is MxN general matrix                                        |
//| * op1(A) is MxK matrix                                           |
//| * op2(B) is KxN matrix                                           |
//|*"op" may be identity transformation, transposition, conjugate  |
//| transposition                                                    |
//| Additional info:                                                 |
//| * cache-oblivious algorithm is used.                             |
//| * multiplication result replaces C. If Beta=0, C elements are not|
//|   used in calculations (not multiplied by zero - just not        |
//|   referenced)                                                    |
//| * if Alpha=0, A is not used (not multiplied by zero - just not   |
//|   referenced)                                                    |
//| * if both Beta and Alpha are zero, C is filled by zeros.         |
//| INPUT PARAMETERS                                                 |
//|     N       -   matrix size, N>0                                 |
//|     M       -   matrix size, N>0                                 |
//|     K       -   matrix size, K>0                                 |
//|     Alpha   -   coefficient                                      |
//|     A       -   matrix                                           |
//|     IA      -   submatrix offset                                 |
//|     JA      -   submatrix offset                                 |
//|     OpTypeA -   transformation type:                             |
//|                 * 0 - no transformation                          |
//|                 * 1 - transposition                              |
//|                 * 2 - conjugate transposition                    |
//|     B       -   matrix                                           |
//|     IB      -   submatrix offset                                 |
//|     JB      -   submatrix offset                                 |
//|     OpTypeB -   transformation type:                             |
//|                 * 0 - no transformation                          |
//|                 * 1 - transposition                              |
//|                 * 2 - conjugate transposition                    |
//|     Beta    -   coefficient                                      |
//|     C       -   matrix                                           |
//|     IC      -   submatrix offset                                 |
//|     JC      -   submatrix offset                                 |
//+------------------------------------------------------------------+
void CAlglib::CMatrixGemm(const int m,const int n,const int k,
                          complex alpha,CMatrixComplex &a,
                          const int ia,const int ja,const int optypea,
                          CMatrixComplex &b,const int ib,const int jb,
                          const int optypeb,complex beta,CMatrixComplex &c,
                          const int ic,const int jc)
  {
   CAblas::CMatrixGemm(m,n,k,alpha,a,ia,ja,optypea,b,ib,jb,optypeb,beta,c,ic,jc);
  }
//+------------------------------------------------------------------+
//| Same as CMatrixGEMM, but for real numbers.                       |
//| OpType may be only 0 or 1.                                       |
//+------------------------------------------------------------------+
void CAlglib::RMatrixGemm(const int m,const int n,const int k,
                          const double alpha,CMatrixDouble &a,
                          const int ia,const int ja,const int optypea,
                          CMatrixDouble &b,const int ib,const int jb,
                          const int optypeb,const double beta,
                          CMatrixDouble &c,const int ic,const int jc)
  {
   CAblas::RMatrixGemm(m,n,k,alpha,a,ia,ja,optypea,b,ib,jb,optypeb,beta,c,ic,jc);
  }
//+------------------------------------------------------------------+
//| QR decomposition of a rectangular matrix of size MxN             |
//| Input parameters:                                                |
//|     A   -   matrix A whose indexes range within [0..M-1, 0..N-1].|
//|     M   -   number of rows in matrix A.                          |
//|     N   -   number of columns in matrix A.                       |
//| Output parameters:                                               |
//|     A   -   matrices Q and R in compact form (see below).        |
//|     Tau -   array of scalar factors which are used to form       |
//|             matrix Q. Array whose index ranges within            |
//|             [0.. Min(M-1,N-1)].                                  |
//| Matrix A is represented as A = QR, where Q is an orthogonal      |
//| matrix of size MxM, R - upper triangular (or upper trapezoid)    |
//| matrix of size M x N.                                            |
//| The elements of matrix R are located on and above the main       |
//| diagonal of matrix A. The elements which are located in Tau      |
//| array and below the main diagonal of matrix A are used to form   |
//| matrix Q as follows:                                             |
//| Matrix Q is represented as a product of elementary reflections   |
//| Q = H(0)*H(2)*...*H(k-1),                                        |
//| where k = min(m,n), and each H(i) is in the form                 |
//| H(i) = 1 - tau * v * (v^T)                                       |
//| where tau is a scalar stored in Tau[I]; v - real vector,         |
//| so that v(0:i-1) = 0, v(i) = 1, v(i+1:m-1) stored in             |
//| A(i+1:m-1,i).                                                    |
//+------------------------------------------------------------------+
void CAlglib::RMatrixQR(CMatrixDouble &a,const int m,const int n,
                        double &tau[])
  {
   COrtFac::RMatrixQR(a,m,n,tau);
  }
//+------------------------------------------------------------------+
//| LQ decomposition of a rectangular matrix of size MxN             |
//| Input parameters:                                                |
//|     A   -   matrix A whose indexes range within [0..M-1, 0..N-1].|
//|     M   -   number of rows in matrix A.                          |
//|     N   -   number of columns in matrix A.                       |
//| Output parameters:                                               |
//|     A   -   matrices L and Q in compact form (see below)         |
//|     Tau -   array of scalar factors which are used to form       |
//|             matrix Q. Array whose index ranges within            |
//|             [0..Min(M,N)-1].                                     |
//| Matrix A is represented as A = LQ, where Q is an orthogonal      |
//| matrix of size MxM, L - lower triangular (or lower trapezoid)    |
//| matrix of size M x N.                                            |
//| The elements of matrix L are located on and below the main       |
//| diagonal of matrix A. The elements which are located in Tau      |
//| array and above the main diagonal of matrix A are used to form   |
//| matrix Q as follows:                                             |
//| Matrix Q is represented as a product of elementary reflections   |
//| Q = H(k-1)*H(k-2)*...*H(1)*H(0),                                 |
//| where k = min(m,n), and each H(i) is of the form                 |
//| H(i) = 1 - tau * v * (v^T)                                       |
//| where tau is a scalar stored in Tau[I]; v - real vector, so that |
//| v(0:i-1)=0, v(i) = 1, v(i+1:n-1) stored in A(i,i+1:n-1).         |
//+------------------------------------------------------------------+
void CAlglib::RMatrixLQ(CMatrixDouble &a,const int m,const int n,
                        double &tau[])
  {
   COrtFac::RMatrixLQ(a,m,n,tau);
  }
//+------------------------------------------------------------------+
//| QR decomposition of a rectangular complex matrix of size MxN     |
//| Input parameters:                                                |
//|     A   -   matrix A whose indexes range within [0..M-1, 0..N-1] |
//|     M   -   number of rows in matrix A.                          |
//|     N   -   number of columns in matrix A.                       |
//| Output parameters:                                               |
//|     A   -   matrices Q and R in compact form                     |
//|     Tau -   array of scalar factors which are used to form       |
//|             matrix Q. Array whose indexes range within           |
//|             [0.. Min(M,N)-1]                                     |
//| Matrix A is represented as A = QR, where Q is an orthogonal      |
//| matrix of size MxM, R - upper triangular (or upper trapezoid)    |
//| matrix of size MxN.                                              |
//|   -- LAPACK routine (version 3.0) --                             |
//|      Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd., |
//|      Courant Institute, Argonne National Lab, and Rice University|
//|      September 30, 1994                                          |
//+------------------------------------------------------------------+
void CAlglib::CMatrixQR(CMatrixComplex &a,const int m,const int n,
                        complex &tau[])
  {
   COrtFac::CMatrixQR(a,m,n,tau);
  }
//+------------------------------------------------------------------+
//| LQ decomposition of a rectangular complex matrix of size MxN     |
//| Input parameters:                                                |
//|     A   -   matrix A whose indexes range within [0..M-1, 0..N-1] |
//|     M   -   number of rows in matrix A.                          |
//|     N   -   number of columns in matrix A.                       |
//| Output parameters:                                               |
//|     A   -   matrices Q and L in compact form                     |
//|     Tau -   array of scalar factors which are used to form       |
//|             matrix Q. Array whose indexes range within           |
//|             [0.. Min(M,N)-1]                                     |
//| Matrix A is represented as A = LQ, where Q is an orthogonal      |
//| matrix of size MxM, L - lower triangular (or lower trapezoid)    |
//| matrix of size MxN.                                              |
//|   -- LAPACK routine (version 3.0) --                             |
//|      Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd., |
//|      Courant Institute, Argonne National Lab, and Rice University|
//|      September 30, 1994                                          |
//+------------------------------------------------------------------+
void CAlglib::CMatrixLQ(CMatrixComplex &a,const int m,const int n,
                        complex &tau[])
  {
   COrtFac::CMatrixLQ(a,m,n,tau);
  }
//+------------------------------------------------------------------+
//| Partial unpacking of matrix Q from the QR decomposition of a     |
//| matrix A                                                         |
//| Input parameters:                                                |
//|     A       -   matrices Q and R in compact form.                |
//|                 Output of RMatrixQR subroutine.                  |
//|     M       -   number of rows in given matrix A. M>=0.          |
//|     N       -   number of columns in given matrix A. N>=0.       |
//|     Tau     -   scalar factors which are used to form Q.         |
//|                 Output of the RMatrixQR subroutine.              |
//|     QColumns -  required number of columns of matrix Q.          |
//|                 M>=QColumns>=0.                                  |
//| Output parameters:                                               |
//|     Q       -   first QColumns columns of matrix Q.              |
//|                 Array whose indexes range within                 |
//|                 [0..M-1, 0..QColumns-1].                         |
//|                 If QColumns=0, the array remains unchanged.      |
//+------------------------------------------------------------------+
void CAlglib::RMatrixQRUnpackQ(CMatrixDouble &a,const int m,const int n,
                               double &tau[],const int qcolumns,
                               CMatrixDouble &q)
  {
   COrtFac::RMatrixQRUnpackQ(a,m,n,tau,qcolumns,q);
  }
//+------------------------------------------------------------------+
//| Unpacking of matrix R from the QR decomposition of a matrix A    |
//| Input parameters:                                                |
//|     A       -   matrices Q and R in compact form.                |
//|                 Output of RMatrixQR subroutine.                  |
//|     M       -   number of rows in given matrix A. M>=0.          |
//|     N       -   number of columns in given matrix A. N>=0.       |
//| Output parameters:                                               |
//|     R       -   matrix R, array[0..M-1, 0..N-1].                 |
//+------------------------------------------------------------------+
void CAlglib::RMatrixQRUnpackR(CMatrixDouble &a,const int m,
                               const int n,CMatrixDouble &r)
  {
   COrtFac::RMatrixQRUnpackR(a,m,n,r);
  }
//+------------------------------------------------------------------+
//| Partial unpacking of matrix Q from LQ decomposition of a complex |
//| matrix A.                                                        |
//| Input parameters:                                                |
//|     A           -   matrices Q and R in compact form.            |
//|                     Output of CMatrixLQ subroutine.              |
//|     M           -   number of rows in matrix A. M>=0.            |
//|     N           -   number of columns in matrix A. N>=0.         |
//|     Tau         -   scalar factors which are used to form Q.     |
//|                     Output of CMatrixLQ subroutine .             |
//|     QRows       -   required number of rows in matrix Q.         |
//|                     N>=QColumns>=0.                              |
//| Output parameters:                                               |
//|     Q           -   first QRows rows of matrix Q.                |
//|                     Array whose index ranges within [0..QRows-1, |
//|                     0..N-1].                                     |
//|                     If QRows=0, array isn't changed.             |
//+------------------------------------------------------------------+
void CAlglib::RMatrixLQUnpackQ(CMatrixDouble &a,const int m,const int n,
                               double &tau[],const int qrows,
                               CMatrixDouble &q)
  {
   COrtFac::RMatrixLQUnpackQ(a,m,n,tau,qrows,q);
  }
//+------------------------------------------------------------------+
//| Unpacking of matrix L from the LQ decomposition of a matrix A    |
//| Input parameters:                                                |
//|     A    -matrices Q and L in compact form.                      |
//|                 Output of RMatrixLQ subroutine.                  |
//|     M    -number of rows in given matrix A. M>=0.                |
//|     N    -number of columns in given matrix A. N>=0.             |
//| Output parameters:                                               |
//|     L    -matrix L, array[0..M-1, 0..N-1].                        |
//+------------------------------------------------------------------+
void CAlglib::RMatrixLQUnpackL(CMatrixDouble &a,const int m,
                               const int n,CMatrixDouble &l)
  {
   COrtFac::RMatrixLQUnpackL(a,m,n,l);
  }
//+------------------------------------------------------------------+
//| Partial unpacking of matrix Q from QR decomposition of a complex |
//| matrix A.                                                        |
//| Input parameters:                                                |
//|     A           -   matrices Q and R in compact form.            |
//|                     Output of CMatrixQR subroutine .             |
//|     M           -   number of rows in matrix A. M>=0.            |
//|     N           -   number of columns in matrix A. N>=0.         |
//|     Tau         -   scalar factors which are used to form Q.     |
//|                     Output of CMatrixQR subroutine .             |
//|     QColumns    -   required number of columns in matrix Q.      |
//|                     M>=QColumns>=0.                              |
//| Output parameters:                                               |
//|     Q           -   first QColumns columns of matrix Q.          |
//|                     Array whose index ranges within [0..M-1,     |
//|                     0..QColumns-1].                              |
//|                     If QColumns=0, array isn't changed.          |
//+------------------------------------------------------------------+
void CAlglib::CMatrixQRUnpackQ(CMatrixComplex &a,const int m,
                               const int n,complex &tau[],
                               const int qcolumns,CMatrixComplex &q)
  {
   COrtFac::CMatrixQRUnpackQ(a,m,n,tau,qcolumns,q);
  }
//+------------------------------------------------------------------+
//| Unpacking of matrix R from the QR decomposition of a matrix A    |
//| Input parameters:                                                |
//|     A       -   matrices Q and R in compact form.                |
//|                 Output of CMatrixQR subroutine.                  |
//|     M       -   number of rows in given matrix A. M>=0.          |
//|     N       -   number of columns in given matrix A. N>=0.       |
//| Output parameters:                                               |
//|     R       -   matrix R, array[0..M-1, 0..N-1].                 |
//+------------------------------------------------------------------+
void CAlglib::CMatrixQRUnpackR(CMatrixComplex &a,const int m,
                               const int n,CMatrixComplex &r)
  {
   COrtFac::CMatrixQRUnpackR(a,m,n,r);
  }
//+------------------------------------------------------------------+
//| Partial unpacking of matrix Q from LQ decomposition of a complex |
//| matrix A.                                                        |
//| Input parameters:                                                |
//|     A           -   matrices Q and R in compact form.            |
//|                     Output of CMatrixLQ subroutine.              |
//|     M           -   number of rows in matrix A. M>=0.            |
//|     N           -   number of columns in matrix A. N>=0.         |
//|     Tau         -   scalar factors which are used to form Q.     |
//|                     Output of CMatrixLQ subroutine .             |
//|     QRows       -   required number of rows in matrix Q.         |
//|                     N>=QColumns>=0.                              |
//| Output parameters:                                               |
//|     Q           -   first QRows rows of matrix Q.                |
//|                     Array whose index ranges within [0..QRows-1, |
//|                     0..N-1].                                     |
//|                     If QRows=0, array isn't changed.             |
//+------------------------------------------------------------------+
void CAlglib::CMatrixLQUnpackQ(CMatrixComplex &a,const int m,
                               const int n,complex &tau[],
                               const int qrows,CMatrixComplex &q)
  {
   COrtFac::CMatrixLQUnpackQ(a,m,n,tau,qrows,q);
  }
//+------------------------------------------------------------------+
//| Unpacking of matrix L from the LQ decomposition of a matrix A    |
//| Input parameters:                                                |
//|     A       -   matrices Q and L in compact form.                |
//|                 Output of CMatrixLQ subroutine.                  |
//|     M       -   number of rows in given matrix A. M>=0.          |
//|     N       -   number of columns in given matrix A. N>=0.       |
//| Output parameters:                                               |
//|     L       -   matrix L, array[0..M-1, 0..N-1].                 |
//+------------------------------------------------------------------+
void CAlglib::CMatrixLQUnpackL(CMatrixComplex &a,const int m,
                               const int n,CMatrixComplex &l)
  {
   COrtFac::CMatrixLQUnpackL(a,m,n,l);
  }
//+------------------------------------------------------------------+
//| Reduction of a rectangular matrix to  bidiagonal form            |
//| The algorithm reduces the rectangular matrix A to  bidiagonal    |
//| form by orthogonal transformations P and Q: A = Q*B*P.           |
//| Input parameters:                                                |
//|     A       -   source matrix. array[0..M-1, 0..N-1]             |
//|     M       -   number of rows in matrix A.                      |
//|     N       -   number of columns in matrix A.                   |
//| Output parameters:                                               |
//|     A       -   matrices Q, B, P in compact form (see below).    |
//|     TauQ    -   scalar factors which are used to form matrix Q.  |
//|     TauP    -   scalar factors which are used to form matrix P.  |
//| The main diagonal and one of the secondary diagonals of matrix A |
//| are replaced with bidiagonal matrix B. Other elements contain    |
//| elementary reflections which form MxM matrix Q and NxN matrix P, |
//| respectively.                                                    |
//| If M>=N, B is the upper bidiagonal MxN matrix and is stored in   |
//| the corresponding elements of matrix A. Matrix Q is represented  |
//| as a product of elementary reflections Q = H(0)*H(1)*...*H(n-1), |
//| where H(i) = 1-tau*v*v'. Here tau is a scalar which is stored in |
//| TauQ[i], and vector v has the following structure: v(0:i-1)=0,   |
//| v(i)=1, v(i+1:m-1) is stored in elements A(i+1:m-1,i).Matrix P is|
//| as follows: P = G(0)*G(1)*...*G(n-2), where G(i) = 1 - tau*u*u'. |
//| Tau is stored in TauP[i], u(0:i)=0, u(i+1)=1, u(i+2:n-1) is      |
//| stored in elements A(i,i+2:n-1).                                 |
//| If M<N, B is the lower bidiagonal MxN matrix and is stored in the|
//| corresponding elements of matrix A. Q = H(0)*H(1)*...*H(m-2),    |
//| where H(i) = 1 - tau*v*v', tau is stored in TauQ, v(0:i)=0,      |
//| v(i+1)=1, v(i+2:m-1) is stored in elements A(i+2:m-1,i).         |
//| P = G(0)*G(1)*...*G(m-1), G(i) = 1-tau*u*u', tau is stored in    |
//| TauP, u(0:i-1)=0, u(i)=1, u(i+1:n-1) is stored in A(i,i+1:n-1).  |
//| EXAMPLE:                                                         |
//| m=6, n=5 (m > n):               m=5, n=6 (m < n):                |
//| (  d   e   u1  u1  u1 )         (  d   u1  u1  u1  u1  u1 )      |
//| (  v1  d   e   u2  u2 )         (  e   d   u2  u2  u2  u2 )      |
//| (  v1  v2  d   e   u3 )         (  v1  e   d   u3  u3  u3 )      |
//| (  v1  v2  v3  d   e  )         (  v1  v2  e   d   u4  u4 )      |
//| (  v1  v2  v3  v4  d  )         (  v1  v2  v3  e   d   u5 )      |
//| (  v1  v2  v3  v4  v5 )                                          |
//| Here vi and ui are vectors which form H(i) and G(i), and d and   |
//| e - are the diagonal and off-diagonal elements of matrix B.      |
//+------------------------------------------------------------------+
void CAlglib::RMatrixBD(CMatrixDouble &a,const int m,const int n,
                        double &tauq[],double &taup[])
  {
   COrtFac::RMatrixBD(a,m,n,tauq,taup);
  }
//+------------------------------------------------------------------+
//| Unpacking matrix Q which reduces a matrix to bidiagonal form.    |
//| Input parameters:                                                |
//|     QP          -   matrices Q and P in compact form.            |
//|                     Output of ToBidiagonal subroutine.           |
//|     M           -   number of rows in matrix A.                  |
//|     N           -   number of columns in matrix A.               |
//|     TAUQ        -   scalar factors which are used to form Q.     |
//|                     Output of ToBidiagonal subroutine.           |
//|     QColumns    -   required number of columns in matrix Q.      |
//|                     M>=QColumns>=0.                              |
//| Output parameters:                                               |
//|     Q           -   first QColumns columns of matrix Q.          |
//|                     Array[0..M-1, 0..QColumns-1]                 |
//|                     If QColumns=0, the array is not modified.    |
//+------------------------------------------------------------------+
void CAlglib::RMatrixBDUnpackQ(CMatrixDouble &qp,const int m,
                               const int n,double &tauq[],
                               const int qcolumns,CMatrixDouble &q)
  {
   COrtFac::RMatrixBDUnpackQ(qp,m,n,tauq,qcolumns,q);
  }
//+------------------------------------------------------------------+
//| Multiplication by matrix Q which reduces matrix A to bidiagonal  |
//| form.                                                            |
//| The algorithm allows pre- or post-multiply by Q or Q'.           |
//| Input parameters:                                                |
//|     QP          -   matrices Q and P in compact form.            |
//|                     Output of ToBidiagonal subroutine.           |
//|     M           -   number of rows in matrix A.                  |
//|     N           -   number of columns in matrix A.               |
//|     TAUQ        -   scalar factors which are used to form Q.     |
//|                     Output of ToBidiagonal subroutine.           |
//|     Z           -   multiplied matrix.                           |
//|                     array[0..ZRows-1,0..ZColumns-1]              |
//|     ZRows       -   number of rows in matrix Z. If FromTheRight= |
//|                     =False, ZRows=M, otherwise ZRows can be      |
//|                     arbitrary.                                   |
//|     ZColumns    -   number of columns in matrix Z. If            |
//|                     FromTheRight=True, ZColumns=M, otherwise     |
//|                     ZColumns can be arbitrary.                   |
//|     FromTheRight -  pre- or post-multiply.                       |
//|     DoTranspose -   multiply by Q or Q'.                         |
//| Output parameters:                                               |
//|     Z           -   product of Z and Q.                          |
//|                     Array[0..ZRows-1,0..ZColumns-1]              |
//|                     If ZRows=0 or ZColumns=0, the array is not   |
//|                     modified.                                    |
//+------------------------------------------------------------------+
void CAlglib::RMatrixBDMultiplyByQ(CMatrixDouble &qp,const int m,
                                   const int n,double &tauq[],
                                   CMatrixDouble &z,const int zrows,
                                   const int zcolumns,const bool fromtheright,
                                   const bool dotranspose)
  {
   COrtFac::RMatrixBDMultiplyByQ(qp,m,n,tauq,z,zrows,zcolumns,fromtheright,dotranspose);
  }
//+------------------------------------------------------------------+
//| Unpacking matrix P which reduces matrix A to bidiagonal form.    |
//| The subroutine returns transposed matrix P.                      |
//| Input parameters:                                                |
//|     QP      -   matrices Q and P in compact form.                |
//|                 Output of ToBidiagonal subroutine.               |
//|     M       -   number of rows in matrix A.                      |
//|     N       -   number of columns in matrix A.                   |
//|     TAUP    -   scalar factors which are used to form P.         |
//|                 Output of ToBidiagonal subroutine.               |
//|     PTRows  -   required number of rows of matrix P^T.           |
//|                 N >= PTRows >= 0.                                |
//| Output parameters:                                               |
//|     PT      -   first PTRows columns of matrix P^T               |
//|                 Array[0..PTRows-1, 0..N-1]                       |
//|                 If PTRows=0, the array is not modified.          |
//+------------------------------------------------------------------+
void CAlglib::RMatrixBDUnpackPT(CMatrixDouble &qp,const int m,
                                const int n,double &taup[],
                                const int ptrows,CMatrixDouble &pt)
  {
   COrtFac::RMatrixBDUnpackPT(qp,m,n,taup,ptrows,pt);
  }
//+------------------------------------------------------------------+
//| Multiplication by matrix P which reduces matrix A to bidiagonal  |
//| form.                                                            |
//| The algorithm allows pre- or post-multiply by P or P'.           |
//| Input parameters:                                                |
//|     QP          -   matrices Q and P in compact form.            |
//|                     Output of RMatrixBD subroutine.              |
//|     M           -   number of rows in matrix A.                  |
//|     N           -   number of columns in matrix A.               |
//|     TAUP        -   scalar factors which are used to form P.     |
//|                     Output of RMatrixBD subroutine.              |
//|     Z           -   multiplied matrix.                           |
//|                     Array whose indexes range within             |
//|                     [0..ZRows-1,0..ZColumns-1].                  |
//|     ZRows       -   number of rows in matrix Z. If               |
//|                     FromTheRight=False, ZRows=N, otherwise ZRows |
//|                     can be arbitrary.                            |
//|     ZColumns    -   number of columns in matrix Z. If            |
//|                     FromTheRight=True, ZColumns=N, otherwise     |
//|                     ZColumns can be arbitrary.                   |
//|     FromTheRight -  pre- or post-multiply.                       |
//|     DoTranspose -   multiply by P or P'.                         |
//| Output parameters:                                               |
//|     Z - product of Z and P.                                      |
//|                 Array whose indexes range within                 |
//|                 [0..ZRows-1,0..ZColumns-1]. If ZRows=0 or        |
//|                 ZColumns=0, the array is not modified.           |
//+------------------------------------------------------------------+
void CAlglib::RMatrixBDMultiplyByP(CMatrixDouble &qp,const int m,
                                   const int n,double &taup[],
                                   CMatrixDouble &z,const int zrows,
                                   const int zcolumns,const bool fromtheright,
                                   const bool dotranspose)
  {
   COrtFac::RMatrixBDMultiplyByP(qp,m,n,taup,z,zrows,zcolumns,fromtheright,dotranspose);
  }
//+------------------------------------------------------------------+
//| Unpacking of the main and secondary diagonals of bidiagonal      |
//| decomposition of matrix A.                                       |
//| Input parameters:                                                |
//|     B   -   output of RMatrixBD subroutine.                      |
//|     M   -   number of rows in matrix B.                          |
//|     N   -   number of columns in matrix B.                       |
//| Output parameters:                                               |
//|     IsUpper -   True, if the matrix is upper bidiagonal.         |
//|                 otherwise IsUpper is False.                      |
//|     D       -   the main diagonal.                               |
//|                 Array whose index ranges within [0..Min(M,N)-1]. |
//|     E       -   the secondary diagonal (upper or lower, depending|
//|                 on the value of IsUpper).                        |
//|                 Array index ranges within [0..Min(M, N)-1], the   |
//|                 last element is not used.                        |
//+------------------------------------------------------------------+
void CAlglib::RMatrixBDUnpackDiagonals(CMatrixDouble &b,const int m,
                                       const int n,bool &IsUpper,
                                       double &d[],double &e[])
  {
//--- initialization
   IsUpper=false;
//--- function call
   COrtFac::RMatrixBDUnpackDiagonals(b,m,n,IsUpper,d,e);
  }
//+------------------------------------------------------------------+
//| Reduction of a square matrix to  upper Hessenberg form:          |
//| Q'*A*Q = H, where Q is an orthogonal matrix, H - Hessenberg      |
//| matrix.                                                          |
//| Input parameters:                                                |
//|     A       -   matrix A with elements [0..N-1, 0..N-1]          |
//|     N       -   size of matrix A.                                |
//| Output parameters:                                               |
//|     A       -   matrices Q and P in  compact form (see below).   |
//|     Tau     -   array of scalar factors which are used to form   |
//|                 matrix Q.                                        |
//|                 Array whose index ranges within [0..N-2]         |
//| Matrix H is located on the main diagonal, on the lower secondary |
//| diagonal and above the main diagonal of matrix A. The elements   |
//| which are used to form matrix Q are situated in array Tau and    |
//| below the lower secondary diagonal of matrix A as follows:       |
//| Matrix Q is represented as a product of elementary reflections   |
//| Q = H(0)*H(2)*...*H(n-2),                                        |
//| where each H(i) is given by                                      |
//| H(i) = 1 - tau * v * (v^T)                                       |
//| where tau is a scalar stored in Tau[I]; v - is a real vector,    |
//| so that v(0:i) = 0, v(i+1) = 1, v(i+2:n-1) stored in             |
//| A(i+2:n-1,i).                                                    |
//|   -- LAPACK routine (version 3.0) --                             |
//|      Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd., |
//|      Courant Institute, Argonne National Lab, and Rice University|
//|      October 31, 1992                                            |
//+------------------------------------------------------------------+
void CAlglib::RMatrixHessenberg(CMatrixDouble &a,const int n,
                                double &tau[])
  {
   COrtFac::RMatrixHessenberg(a,n,tau);
  }
//+------------------------------------------------------------------+
//| Unpacking matrix Q which reduces matrix A to upper Hessenberg    |
//| form                                                             |
//| Input parameters:                                                |
//|     A   -   output of RMatrixHessenberg subroutine.              |
//|     N   -   size of matrix A.                                    |
//|     Tau -   scalar factors which are used to form Q.             |
//|             Output of RMatrixHessenberg subroutine.              |
//| Output parameters:                                               |
//|     Q   -   matrix Q.                                            |
//|             Array whose indexes range within [0..N-1, 0..N-1].   |
//+------------------------------------------------------------------+
void CAlglib::RMatrixHessenbergUnpackQ(CMatrixDouble &a,const int n,
                                       double &tau[],CMatrixDouble &q)
  {
   COrtFac::RMatrixHessenbergUnpackQ(a,n,tau,q);
  }
//+------------------------------------------------------------------+
//| Unpacking matrix H (the result of matrix A reduction to upper    |
//| Hessenberg form)                                                 |
//| Input parameters:                                                |
//|     A   -   output of RMatrixHessenberg subroutine.              |
//|     N   -   size of matrix A.                                    |
//| Output parameters:                                               |
//|     H   -   matrix H. Array whose indexes range within           |
//|     [0..N-1, 0..N-1].                                            |
//+------------------------------------------------------------------+
void CAlglib::RMatrixHessenbergUnpackH(CMatrixDouble &a,const int n,
                                       CMatrixDouble &h)
  {
   COrtFac::RMatrixHessenbergUnpackH(a,n,h);
  }
//+------------------------------------------------------------------+
//| Reduction of a symmetric matrix which is given by its higher or  |
//| lower triangular part to a tridiagonal matrix using orthogonal   |
//| similarity transformation: Q'*A*Q=T.                             |
//| Input parameters:                                                |
//|     A       -   matrix to be transformed                         |
//|                 array with elements [0..N-1, 0..N-1].            |
//|     N       -   size of matrix A.                                |
//|     IsUpper -   storage format. If IsUpper = True, then matrix A |
//|                 is given by its upper triangle, and the lower    |
//|                 triangle is not used and not modified by the     |
//|                 algorithm, and vice versa if IsUpper = False.    |
//| Output parameters:                                               |
//|     A       -   matrices T and Q in  compact form (see lower)    |
//|     Tau     -   array of factors which are forming matrices H(i) |
//|                 array with elements [0..N-2].                    |
//|     D       -   main diagonal of symmetric matrix T.             |
//|                 array with elements [0..N-1].                    |
//|     E       -   secondary diagonal of symmetric matrix T.        |
//|                 array with elements [0..N-2].                    |
//|   If IsUpper=True, the matrix Q is represented as a product of   |
//|   elementary reflectors                                          |
//|      Q = H(n-2) . . . H(2) H(0).                                 |
//|   Each H(i) has the form                                         |
//|      H(i) = I - tau * v * v'                                     |
//|   where tau is a real scalar, and v is a real vector with        |
//|   v(i+1:n-1) = 0, v(i) = 1, v(0:i-1) is stored on exit in        |
//|   A(0:i-1,i+1), and tau in TAU(i).                               |
//|   If IsUpper=False, the matrix Q is represented as a product of  |
//|   elementary reflectors                                          |
//|      Q = H(0) H(2) . . . H(n-2).                                 |
//|   Each H(i) has the form                                         |
//|      H(i) = I - tau * v * v'                                     |
//|   where tau is a real scalar, and v is a real vector with        |
//|   v(0:i) = 0, v(i+1) = 1, v(i+2:n-1) is stored on exit in        |
//|   A(i+2:n-1,i), and tau in TAU(i).                               |
//|   The contents of A on exit are illustrated by the following     |
//|   examples with n = 5:                                           |
//|   if UPLO = 'U':                       if UPLO = 'L':            |
//|     (  d   e   v1  v2  v3 )              (  d                  ) |
//|     (      d   e   v2  v3 )              (  e   d              ) |
//|     (          d   e   v3 )              (  v0  e   d          ) |
//|     (              d   e  )              (  v0  v1  e   d      ) |
//|     (                  d  )              (  v0  v1  v2  e   d  ) |
//|   where d and e denote diagonal and off-diagonal elements of T,  |
//|   and vi denotes an element of the vector defining H(i).         |
//|   -- LAPACK routine (version 3.0) --                             |
//|      Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd., |
//|      Courant Institute, Argonne National Lab, and Rice University|
//|      October 31, 1992                                            |
//+------------------------------------------------------------------+
void CAlglib::SMatrixTD(CMatrixDouble &a,const int n,const bool IsUpper,
                        double &tau[],double &d[],double &e[])
  {
   COrtFac::SMatrixTD(a,n,IsUpper,tau,d,e);
  }
//+------------------------------------------------------------------+
//| Unpacking matrix Q which reduces symmetric matrix to a           |
//| tridiagonal form.                                                |
//| Input parameters:                                                |
//|     A       -   the result of a SMatrixTD subroutine             |
//|     N       -   size of matrix A.                                |
//|     IsUpper -   storage format (a parameter of SMatrixTD         |
//|                 subroutine)                                      |
//|     Tau     -   the result of a SMatrixTD subroutine             |
//| Output parameters:                                               |
//|     Q       -   transformation matrix.                           |
//|                 array with elements [0..N-1, 0..N-1].            |
//+------------------------------------------------------------------+
void CAlglib::SMatrixTDUnpackQ(CMatrixDouble &a,const int n,
                               const bool IsUpper,double &tau[],
                               CMatrixDouble &q)
  {
   COrtFac::SMatrixTDUnpackQ(a,n,IsUpper,tau,q);
  }
//+------------------------------------------------------------------+
//| Reduction of a Hermitian matrix which is given by its higher or  |
//| lower triangular part to a real tridiagonal matrix using unitary |
//| similarity transformation: Q'*A*Q = T.                           |
//| Input parameters:                                                |
//|     A       -   matrix to be transformed                         |
//|                 array with elements [0..N-1, 0..N-1].            |
//|     N       -   size of matrix A.                                |
//|     IsUpper -   storage format. If IsUpper = True, then matrix A |
//|                 is given by its upper triangle, and the lower    |
//|                 triangle is not used and not modified by the     |
//|                 algorithm, and vice versa if IsUpper = False.    |
//| Output parameters:                                               |
//|     A       -   matrices T and Q in  compact form (see lower)    |
//|     Tau     -   array of factors which are forming matrices H(i) |
//|                 array with elements [0..N-2].                    |
//|     D       -   main diagonal of real symmetric matrix T.        |
//|                 array with elements [0..N-1].                    |
//|     E       -   secondary diagonal of real symmetric matrix T.   |
//|                 array with elements [0..N-2].                    |
//|   If IsUpper=True, the matrix Q is represented as a product of   |
//|   elementary reflectors                                          |
//|      Q = H(n-2) . . . H(2) H(0).                                 |
//|   Each H(i) has the form                                         |
//|      H(i) = I - tau * v * v'                                     |
//|   where tau is a complex scalar, and v is a complex vector with  |
//|   v(i+1:n-1) = 0, v(i) = 1, v(0:i-1) is stored on exit in        |
//|   A(0:i-1,i+1), and tau in TAU(i).                               |
//|   If IsUpper=False, the matrix Q is represented as a product of  |
//|   elementary reflectors                                          |
//|      Q = H(0) H(2) . . . H(n-2).                                 |
//|   Each H(i) has the form                                         |
//|      H(i) = I - tau * v * v'                                     |
//|   where tau is a complex scalar, and v is a complex vector with  |
//|   v(0:i) = 0, v(i+1) = 1, v(i+2:n-1) is stored on exit in        |
//|   A(i+2:n-1,i), and tau in TAU(i).                               |
//|   The contents of A on exit are illustrated by the following     |
//|   examples with n = 5:                                           |
//|   if UPLO = 'U':                       if UPLO = 'L':            |
//|     (  d   e   v1  v2  v3 )              (  d                  ) |
//|     (      d   e   v2  v3 )              (  e   d              ) |
//|     (          d   e   v3 )              (  v0  e   d          ) |
//|     (              d   e  )              (  v0  v1  e   d      ) |
//|     (                  d  )              (  v0  v1  v2  e   d  ) |
//| where d and e denote diagonal and off-diagonal elements of T, and|
//| vi denotes an element of the vector defining H(i).               |
//|   -- LAPACK routine (version 3.0) --                             |
//|      Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd., |
//|      Courant Institute, Argonne National Lab, and Rice University|
//|      October 31, 1992                                            |
//+------------------------------------------------------------------+
void CAlglib::HMatrixTD(CMatrixComplex &a,const int n,const bool IsUpper,
                        complex &tau[],double &d[],double &e[])
  {
   COrtFac::HMatrixTD(a,n,IsUpper,tau,d,e);
  }
//+------------------------------------------------------------------+
//| Unpacking matrix Q which reduces a Hermitian matrix to a real    |
//| tridiagonal form.                                                |
//| Input parameters:                                                |
//|     A       -   the result of a HMatrixTD subroutine             |
//|     N       -   size of matrix A.                                |
//|     IsUpper -   storage format (a parameter of HMatrixTD         |
//|                 subroutine)                                      |
//|     Tau     -   the result of a HMatrixTD subroutine             |
//| Output parameters:                                               |
//|     Q       -   transformation matrix.                           |
//|                 array with elements [0..N-1, 0..N-1].            |
//+------------------------------------------------------------------+
void CAlglib::HMatrixTDUnpackQ(CMatrixComplex &a,const int n,
                               const bool IsUpper,complex &tau[],
                               CMatrixComplex &q)
  {
   COrtFac::HMatrixTDUnpackQ(a,n,IsUpper,tau,q);
  }
//+------------------------------------------------------------------+
//| This function initializes subspace iteration solver. This solver |
//| is used to solve symmetric real eigenproblems where just a few   |
//| (top K) eigenvalues and corresponding eigenvectors is required.  |
//| This solver can be significantly faster than complete EVD        |
//| decomposition in the following case:                             |
//|   * when only just a small fraction of top eigenpairs of dense   |
//|     matrix is required. When K approaches N, this solver is      |
//|     slower than complete dense EVD                               |
//|   * when problem matrix is sparse(and/or is not known explicitly,|
//|     i.e. only matrix-matrix product can be performed)            |
//| USAGE (explicit dense/sparse matrix):                            |
//|   1. User initializes algorithm state with EigSubSpaceCreate()   |
//|      call                                                        |
//|   2. [optional] User tunes solver parameters by calling          |
//|      eigsubspacesetcond() or other functions                     |
//|   3. User calls EigSubSpaceSolveDense() or                       |
//|      EigSubSpaceSolveSparse() methods, which take algorithm state|
//|      and 2D array or CSparseMatrix object.                       |
//| USAGE (out-of-core mode):                                        |
//|   1. User initializes algorithm state with EigSubSpaceCreate()   |
//|      call                                                        |
//|   2. [optional] User tunes solver parameters by calling          |
//|      EigSubSpaceSetCond() or other functions                     |
//|   3. User activates out-of-core mode of the solver and repeatedly|
//|      calls communication functions in a loop like below:         |
//|      > EigSubSpaceOOCStart(state)                                |
//|      > while EigSubSpaceOOCContinue(state) do                    |
//|      >     EigSubSpaceOOCGetRequestInfo(state, RequestType, M)   |
//|      >     EigSubSpaceOOCGetRequestData(state, X)                |
//|      >     [calculate  Y=A*X, with X=R^NxM]                      |
//|      >     EigSubSpaceOOCSendResult(state, Y)                    |
//|      > EigSubSpaceOOCStop(state, W, Z, Report)                   |
//| INPUT PARAMETERS:                                                |
//|   N        -  problem dimensionality, N>0                        |
//|   K        -  number of top eigenvector to calculate, 0<K<=N.    |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure which stores algorithm state             |
//| NOTE: if you solve many similar EVD problems you may find it     |
//|       useful to reuse previous subspace as warm-start point for  |
//|       new EVD problem. It can be done with                       |
//|       EigSubSpaceSetWarmStart() function.                        |
//+------------------------------------------------------------------+
void CAlglib::EigSubSpaceCreate(int n,int k,CEigSubSpaceState &state)
  {
   CEigenVDetect::EigSubSpaceCreate(n,k,state);
  }
//+------------------------------------------------------------------+
//| Buffered version of constructor which aims to reuse previously   |
//| allocated memory as much as possible.                            |
//+------------------------------------------------------------------+
void CAlglib::EigSubSpaceCreateBuf(int n,int k,CEigSubSpaceState &state)
  {
   CEigenVDetect::EigSubSpaceCreateBuf(n,k,state);
  }
//+------------------------------------------------------------------+
//| This function sets stopping critera for the solver:              |
//|   * error in eigenvector/value allowed by solver                 |
//|   * maximum number of iterations to perform                      |
//| INPUT PARAMETERS:                                                |
//|   State    -  solver structure                                   |
//|   Eps      -  eps>=0,  with non-zero value used to tell solver   |
//|               that it can stop after all eigenvalues converged   |
//|               with error roughly proportional to                 |
//|               eps*MAX(LAMBDA_MAX), where LAMBDA_MAX is a maximum |
//|               eigenvalue. Zero value means that no check for     |
//|               precision is performed.                            |
//|   MaxIts   -  maxits>=0, with non-zero value used to tell solver |
//|               that it can stop after maxits steps (no matter how |
//|               precise current estimate is)                       |
//| NOTE: passing eps=0 and maxits=0 results in automatic selection  |
//|      of moderate eps as stopping criteria (1.0E-6 in current     |
//|      implementation, but it may change without notice).          |
//| NOTE: very small values of eps are possible (say, 1.0E-12),      |
//|      although the larger problem you solve (N and/or K), the     |
//|      harder it is to find precise eigenvectors because rounding  |
//|      errors tend to accumulate.                                  |
//| NOTE: passing non-zero eps results in some performance penalty,  |
//|      roughly equal to 2N*(2K)^2 FLOPs per iteration. These       |
//|      additional computations are required in order to estimate   |
//|      current error in eigenvalues via Rayleigh-Ritz process.     |
//|      Most of this additional time is spent in construction of    |
//|      ~2Kx2K symmetric subproblem whose eigenvalues are checked   |
//|      with exact eigensolver.                                     |
//|      This additional time is negligible if you search for        |
//|      eigenvalues of the large dense matrix, but may become       |
//|      noticeable on highly sparse EVD problems, where cost of     |
//|      matrix-matrix product is low.                               |
//|      If you set eps to exactly zero, Rayleigh-Ritz phase is      |
//|      completely turned off.                                      |
//+------------------------------------------------------------------+
void CAlglib::EigSubSpaceSetCond(CEigSubSpaceState &state,double eps,int maxits)
  {
   CEigenVDetect::EigSubSpaceSetCond(state,eps,maxits);
  }
//+------------------------------------------------------------------+
//| This function sets warm-start mode of the solver: next call to   |
//| the solver will reuse previous subspace as warm-start point. It  |
//| can significantly speed-up convergence when you solve many       |
//| similar eigenproblems.                                           |
//| INPUT PARAMETERS:                                                |
//|   State          -  solver structure                             |
//|   UseWarmStart   -  either True or False                         |
//+------------------------------------------------------------------+
void CAlglib::EigSubSpaceSetWarmStart(CEigSubSpaceState &state,bool usewarmstart)
  {
   CEigenVDetect::EigSubSpaceSetWarmStart(state,usewarmstart);
  }
//+------------------------------------------------------------------+
//| This function initiates out-of-core mode of subspace eigensolver.|
//| It should be used in conjunction with other out-of-core-related  |
//| functions of this subspackage in a loop like below:              |
//|   > EigSubSpaceOOCStart(state)                                   |
//|   > while EigSubSpaceOOCContinue(state) do                       |
//|   >     EigSubSpaceOOCGetRequestInfo(state, RequestType, M)      |
//|   >     EigSubSpaceOOCGetRequestData(state, X)                   |
//|   >     [calculate  Y=A*X, with X=R^NxM]                         |
//|   >     EigSubSpaceOOCSendResult(state, Y)                       |
//|   > EigSubSpaceOOCStop(state, W, Z, Report)                      |
//| INPUT PARAMETERS:                                                |
//|   State          -  solver object                                |
//|   MType          -  matrix type:                                 |
//|         * 0 for real symmetric matrix (solver assumes that matrix|
//|           being processed is symmetric; symmetric direct         |
//|           eigensolver is used for smaller subproblems arising    |
//|           during solution of larger "full" task)                 |
//|         Future versions of ALGLIB may introduce support for other|
//|         matrix types; for now, only symmetric eigenproblems are  |
//|         supported.                                               |
//+------------------------------------------------------------------+
void CAlglib::EigSubSpaceOOCStart(CEigSubSpaceState &state,int mtype)
  {
   CEigenVDetect::EigSubSpaceOOCStart(state,mtype);
  }
//+------------------------------------------------------------------+
//| This function performs subspace iteration in the out-of-core mode|
//| It should be used in conjunction with other out-of-core-related  |
//| functions of this subspackage in a loop like below:              |
//|   > EigSubSpaceOOCStart(state)                                   |
//|   > while EigSubSpaceOOCContinue(state) do                       |
//|   >     EigSubSpaceOOCGetRequestInfo(state, RequestType, M)      |
//|   >     EigSubSpaceOOCGetRequestdData(state, X)                  |
//|   >     [calculate  Y=A*X, with X=R^NxM]                         |
//|   >     EigSubSpaceOOCSendResult(state, Y)                       |
//|   > EigSubSpaceOOCStop(state, W, Z, Report)                      |
//+------------------------------------------------------------------+
bool CAlglib::EigSubSpaceOOCContinue(CEigSubSpaceState &state)
  {
   return(CEigenVDetect::EigSubSpaceOOCContinue(state));
  }
//+------------------------------------------------------------------+
//| This function is used to retrieve information about out-of-core  |
//| request sent by solver to user code: request type (current       |
//| version of the solver sends only requests for matrix-matrix      |
//| products) and request size (size of the matrices being           |
//| multiplied).                                                     |
//| This function returns just request metrics; in order to get      |
//| contents of the matrices being multiplied, use                   |
//| EigSubSpaceOOCGetRequestData().                                  |
//| It should be used in conjunction with other out-of-core-related  |
//| functions of this subspackage in a loop like below:              |
//|   > EigSubSpaceOOCStart(state)                                   |
//|   > while EigSubSpaceOOCContinue(state) do                       |
//|   >     EigSubSpaceOOCGetRequestInfo(state, RequestType, M)      |
//|   >     EigSubSpaceOOCGetRequestData(state, X)                   |
//|   >     [calculate  Y=A*X, with X=R^NxM]                         |
//|   >     EigSubSpaceOOCSendResult(state, Y)                       |
//|   > EigSubSpaceOOCStop(state, W, Z, Report)                      |
//| INPUT PARAMETERS:                                                |
//|   State       -  solver running in out-of-core mode              |
//| OUTPUT PARAMETERS:                                               |
//|   RequestType -  type of the request to process:                 |
//|               * 0 - for matrix-matrix product A*X, with A being  |
//|                  NxN matrix whose eigenvalues/vectors are needed,|
//|                  and X being NxREQUESTSIZE one which is  returned|
//|                  by the eigsubspaceoocgetrequestdata().          |
//|   RequestSize -  size of the X matrix (number of columns),       |
//|                  usually it is several times larger than number  |
//|                  of vectors K requested by user.                 |
//+------------------------------------------------------------------+
void CAlglib::EigSubSpaceOOCGetRequestInfo(CEigSubSpaceState &state,
                                           int &requesttype,
                                           int &requestsize)
  {
   CEigenVDetect::EigSubSpaceOOCGetRequestInfo(state,requesttype,requestsize);
  }
//+------------------------------------------------------------------+
//| This function is used to retrieve information about out-of-core  |
//| request sent by solver to user code:                             |
//|   matrix X(array[N,RequestSize])                                 |
//| which have to be multiplied by out-of-core matrix A in a product |
//| A*X.                                                             |
//| This function returns just request data; in order to get size of |
//| the data prior to processing requestm, use                       |
//| EigSubSpaceOOCGetRequestInfo().                                  |
//| It should be used in conjunction with other out-of-core-related  |
//| functions of this subspackage in a loop like below:              |
//|   > EigSubSpaceOOCStart(state)                                   |
//|   > while EigSubSpaceOOCContinue(state) do                       |
//|   >     EigSubSpaceOOCGetRequestInfo(state, RequestType, M)      |
//|   >     EigSubSpaceOOCGetRequestData(state, X)                   |
//|   >     [calculate  Y=A*X, with X=R^NxM]                         |
//|   >     EigSubSpaceOOCSendResult(state, Y)                       |
//|   > EigSubSpaceOOCStop(state, W, Z, Report)                      |
//| INPUT PARAMETERS:                                                |
//|   State       -  solver running in out-of-core mode              |
//|   X           -  possibly preallocated storage; reallocated if   |
//|                  needed, left unchanged, if large enough to store|
//|                  request data.                                   |
//| OUTPUT PARAMETERS:                                               |
//|   X           -  array[N,RequestSize] or larger, leading         |
//|                  rectangle is filled with dense matrix X.        |
//+------------------------------------------------------------------+
void CAlglib::EigSubSpaceOOCGetRequestData(CEigSubSpaceState &state,
                                           CMatrixDouble &x)
  {
   CEigenVDetect::EigSubSpaceOOCGetRequestData(state,x);
  }
//+------------------------------------------------------------------+
//| This function is used to send user reply to out-of-core request  |
//| sent by solver. Usually it is product A*X for returned by solver |
//| matrix X.                                                        |
//| It should be used in conjunction with other out-of-core-related  |
//| functions of this subspackage in a loop like below:              |
//|   > EigSubSpaceOOCStart(state)                                   |
//|   > while EigSubSpaceOOCContinue(state) do                       |
//|   >     EigSubSpaceOOCGetRequestInfo(state, RequestType, M)      |
//|   >     EigSubSpaceOOCGetRequestData(state, X)                   |
//|   >     [calculate  Y=A*X, with X=R^NxM]                         |
//|   >     EigSubSpaceOOCSendResult(state, Y)                       |
//|   > EigSubSpaceOOCStop(state, W, Z, Report)                      |
//| INPUT PARAMETERS:                                                |
//|   State    -  solver running in out-of-core mode                 |
//|   AX       -  array[N,RequestSize] or larger, leading rectangle  |
//|               is filled with product A*X.                        |
//+------------------------------------------------------------------+
void CAlglib::EigSubSpaceOOCSendResult(CEigSubSpaceState &state,
                                       CMatrixDouble &ax)
  {
   CEigenVDetect::EigSubSpaceOOCSendResult(state,ax);
  }
//+------------------------------------------------------------------+
//| This function finalizes out-of-core mode of subspace eigensolver.|
//| It should be used in conjunction with other out-of-core-related  |
//| functions of this subspackage in a loop like below:              |
//|   > EigSubSpaceOOCStart(state)                                   |
//|   > while EigSubSpaceOOCContinue(state) do                       |
//|   >     EigSubSpaceOOCGetRequestInfo(state, RequestType, M)      |
//|   >     EigSubSpaceOOCGetRequestData(state, X)                   |
//|   >     [calculate  Y=A*X, with X=R^NxM]                         |
//|   >     EigSubSpaceOOCSendResult(state, Y)                       |
//|   > EigSubSpaceOOCStop(state, W, Z, Report)                      |
//| INPUT PARAMETERS:                                                |
//|   State    -  solver state                                       |
//| OUTPUT PARAMETERS:                                               |
//|   W        -  array[K], depending on solver settings:            |
//|            * top K eigenvalues ordered by descending - if        |
//|              EigenVectors are returned in Z                      |
//|            * zeros - if invariant subspace is returned in Z      |
//|   Z        -  array[N,K], depending on solver settings either:   |
//|            * matrix of eigenvectors found                        |
//|            * orthogonal basis of K-dimensional invariant subspace|
//|   Rep      -  report with additional parameters                  |
//+------------------------------------------------------------------+
void CAlglib::EigSubSpaceOOCStop(CEigSubSpaceState &state,CRowDouble &w,
                                 CMatrixDouble &z,CEigSubSpaceReport &rep)
  {
   CEigenVDetect::EigSubSpaceOOCStop(state,w,z,rep);
  }
//+------------------------------------------------------------------+
//| This function runs subspace eigensolver for dense NxN symmetric  |
//| matrix A, given by its upper or lower triangle.                  |
//| This function can not process nonsymmetric matrices.             |
//| INPUT PARAMETERS:                                                |
//|   State    -  solver state                                       |
//|   A        -  array[N,N], symmetric NxN matrix given by one of   |
//|               its triangles                                      |
//|   IsUpper  -  whether upper or lower triangle of A is given (the |
//|               other one is not referenced at all).               |
//| OUTPUT PARAMETERS:                                               |
//|   W        -  array[K], top K EigenValues ordered by descending  |
//|               of their absolute values                           |
//|   Z        -  array[N,K], matrix of eigenvectors found           |
//|   Rep      -  report with additional parameters                  |
//| NOTE: internally this function allocates a copy of NxN dense A.  |
//|      You should take it into account when working with very large|
//|      matrices occupying almost all RAM.                          |
//+------------------------------------------------------------------+
void CAlglib::EigSubSpaceSolveDenses(CEigSubSpaceState &state,
                                     CMatrixDouble &a,bool IsUpper,
                                     CRowDouble &w,CMatrixDouble &z,
                                     CEigSubSpaceReport &rep)
  {
   CEigenVDetect::EigSubSpaceSolveDenses(state,a,IsUpper,w,z,rep);
  }
//+------------------------------------------------------------------+
//| This function runs EigenSolver for dense NxN symmetric matrix A, |
//| given by upper or lower triangle.                                |
//| This function can not process nonsymmetric matrices.             |
//| INPUT PARAMETERS:                                                |
//|   State    -  solver state                                       |
//|   A        -  NxN symmetric matrix given by one of its triangles |
//|   IsUpper  -  whether upper or lower triangle of A is given (the |
//|               other one is not referenced at all).               |
//| OUTPUT PARAMETERS:                                               |
//|   W        -  array[K], top K eigenvalues ordered by descending  |
//|               of their absolute values                           |
//|   Z        -  array[N,K], matrix of eigenvectors found           |
//|   Rep      -  report with additional parameters                  |
//+------------------------------------------------------------------+
void CAlglib::EigSubSpaceSolveSparses(CEigSubSpaceState &state,
                                      CSparseMatrix &a,bool IsUpper,
                                      CRowDouble &w,CMatrixDouble &z,
                                      CEigSubSpaceReport &rep)
  {
   CEigenVDetect::EigSubSpaceSolveSparses(state,a,IsUpper,w,z,rep);
  }
//+------------------------------------------------------------------+
//| Finding the eigenvalues and eigenvectors of a symmetric matrix   |
//| The algorithm finds eigen pairs of a symmetric matrix by reducing|
//| it to tridiagonal form and using the QL/QR algorithm.            |
//| Input parameters:                                                |
//|     A       -   symmetric matrix which is given by its upper or  |
//|                 lower triangular part.                           |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..N-1].                                |
//|     N       -   size of matrix A.                                |
//|     ZNeeded -   flag controlling whether the eigenvectors are    |
//|                 needed or not.                                   |
//|                 If ZNeeded is equal to:                          |
//|                  * 0, the eigenvectors are not returned;         |
//|                  * 1, the eigenvectors are returned.             |
//|     IsUpper -   storage format.                                  |
//| Output parameters:                                               |
//|     D       -   eigenvalues in ascending order.                  |
//|                 Array whose index ranges within [0..N-1].        |
//|     Z       -   if ZNeeded is equal to:                          |
//|                  * 0, Z hasn?t changed;                          |
//|                  * 1, Z contains the eigenvectors.               |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..N-1].                                |
//|                 The eigenvectors are stored in the matrix        |
//|                 columns.                                         |
//| Result:                                                          |
//|     True, if the algorithm has converged.                        |
//|     False, if the algorithm hasn't converged (rare case).        |
//+------------------------------------------------------------------+
bool CAlglib::SMatrixEVD(CMatrixDouble &a,const int n,int zneeded,
                         const bool IsUpper,double &d[],
                         CMatrixDouble &z)
  {
   return(CEigenVDetect::SMatrixEVD(a,n,zneeded,IsUpper,d,z));
  }
//+------------------------------------------------------------------+
//| Subroutine for finding the eigenvalues (and eigenvectors) of a   |
//| symmetric matrix in a given half open interval (A, B] by using a |
//| bisection and inverse iteration                                  |
//| Input parameters:                                                |
//|     A       -   symmetric matrix which is given by its upper or  |
//|                 lower triangular part. Array [0..N-1, 0..N-1].   |
//|     N       -   size of matrix A.                                |
//|     ZNeeded -   flag controlling whether the eigenvectors are    |
//|                 needed or not.                                   |
//|                 If ZNeeded is equal to:                          |
//|                  * 0, the eigenvectors are not returned;         |
//|                  * 1, the eigenvectors are returned.             |
//|     IsUpperA -  storage format of matrix A.                      |
//|     B1, B2 -    half open interval (B1, B2] to search            |
//|                 eigenvalues in.                                  |
//| Output parameters:                                               |
//|     M       -   number of eigenvalues found in a given           |
//|                 half-interval (M>=0).                            |
//|     W       -   array of the eigenvalues found.                  |
//|                 Array whose index ranges within [0..M-1].        |
//|     Z       -   if ZNeeded is equal to:                          |
//|                  * 0, Z hasn?t changed;                          |
//|                  * 1, Z contains eigenvectors.                   |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..M-1].                                |
//|                 The eigenvectors are stored in the matrix        |
//|                 columns.                                         |
//| Result:                                                          |
//|     True, if successful. M contains the number of eigenvalues in |
//|     the given half-interval (could be equal to 0), W contains the|
//|     eigenvalues, Z contains the eigenvectors (if needed).        |
//|     False, if the bisection method subroutine wasn't able to find|
//|     the eigenvalues in the given interval or if the inverse      |
//|     iteration subroutine wasn't able to find all the             |
//|     corresponding eigenvectors. In that case, the eigenvalues    |
//|     and eigenvectors are not returned, M is equal to 0.          |
//+------------------------------------------------------------------+
bool CAlglib::SMatrixEVDR(CMatrixDouble &a,const int n,int zneeded,
                          const bool IsUpper,double b1,double b2,
                          int &m,double &w[],CMatrixDouble &z)
  {
//--- initialization
   m=0;
//--- return result
   return(CEigenVDetect::SMatrixEVDR(a,n,zneeded,IsUpper,b1,b2,m,w,z));
  }
//+------------------------------------------------------------------+
//| Subroutine for finding the eigenvalues and eigenvectors of a     |
//| symmetric matrix with given indexes by using bisection and       |
//| inverse iteration methods.                                       |
//| Input parameters:                                                |
//|     A       -   symmetric matrix which is given by its upper or  |
//|                 lower triangular part. Array whose indexes range |
//|                 within [0..N-1, 0..N-1].                         |
//|     N       -   size of matrix A.                                |
//|     ZNeeded -   flag controlling whether the eigenvectors are    |
//|                 needed or not.                                   |
//|                 If ZNeeded is equal to:                          |
//|                  * 0, the eigenvectors are not returned;         |
//|                  * 1, the eigenvectors are returned.             |
//|     IsUpperA -  storage format of matrix A.                      |
//|     I1, I2 -    index interval for searching (from I1 to I2).    |
//|                 0 <= I1 <= I2 <= N-1.                            |
//| Output parameters:                                               |
//|     W       -   array of the eigenvalues found.                  |
//|                 Array whose index ranges within [0..I2-I1].      |
//|     Z       -   if ZNeeded is equal to:                          |
//|                  * 0, Z hasn?t changed;                          |
//|                  * 1, Z contains eigenvectors.                   |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..I2-I1].                              |
//|                 In that case, the eigenvectors are stored in the |
//|                 matrix columns.                                  |
//| Result:                                                          |
//|     True, if successful. W contains the eigenvalues, Z contains  |
//|     the eigenvectors (if needed).                                |
//|     False, if the bisection method subroutine wasn't able to find|
//|     the eigenvalues in the given interval or if the inverse      |
//|     iteration subroutine wasn't able to find all the             |
//|     corresponding eigenvectors. In that case, the eigenvalues    |
//|     and eigenvectors are not returned.                           |
//+------------------------------------------------------------------+
bool CAlglib::SMatrixEVDI(CMatrixDouble &a,const int n,int zneeded,
                          const bool IsUpper,const int i1,
                          const int i2,double &w[],CMatrixDouble &z)
  {
   return(CEigenVDetect::SMatrixEVDI(a,n,zneeded,IsUpper,i1,i2,w,z));
  }
//+------------------------------------------------------------------+
//| Finding the eigenvalues and eigenvectors of a Hermitian matrix   |
//| The algorithm finds eigen pairs of a Hermitian matrix by reducing|
//| it to real tridiagonal form and using the QL/QR algorithm.       |
//| Input parameters:                                                |
//|     A       -   Hermitian matrix which is given by its upper or  |
//|                 lower triangular part.                           |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..N-1].                                |
//|     N       -   size of matrix A.                                |
//|     IsUpper -   storage format.                                  |
//|     ZNeeded -   flag controlling whether the eigenvectors are    |
//|                 needed or not. If ZNeeded is equal to:           |
//|                  * 0, the eigenvectors are not returned;         |
//|                  * 1, the eigenvectors are returned.             |
//| Output parameters:                                               |
//|     D       -   eigenvalues in ascending order.                  |
//|                 Array whose index ranges within [0..N-1].        |
//|     Z       -   if ZNeeded is equal to:                          |
//|                  * 0, Z hasn?t changed;                          |
//|                  * 1, Z contains the eigenvectors.               |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..N-1].                                |
//|                 The eigenvectors are stored in the matrix        |
//|                 columns.                                         |
//| Result:                                                          |
//|     True, if the algorithm has converged.                        |
//|     False, if the algorithm hasn't converged (rare case).        |
//| Note:                                                            |
//|     eigenvectors of Hermitian matrix are defined up to           |
//|     multiplication by a complex number L, such that |L|=1.       |
//+------------------------------------------------------------------+
bool CAlglib::HMatrixEVD(CMatrixComplex &a,const int n,const int zneeded,
                         const bool IsUpper,double &d[],CMatrixComplex &z)
  {
   return(CEigenVDetect::HMatrixEVD(a,n,zneeded,IsUpper,d,z));
  }
//+------------------------------------------------------------------+
//| Subroutine for finding the eigenvalues (and eigenvectors) of a   |
//| Hermitian matrix in a given half-interval (A, B] by using a      |
//| bisection and inverse iteration                                  |
//| Input parameters:                                                |
//|     A       -   Hermitian matrix which is given by its upper or  |
//|                 lower triangular part. Array whose indexes range |
//|                 within [0..N-1, 0..N-1].                         |
//|     N       -   size of matrix A.                                |
//|     ZNeeded -   flag controlling whether the eigenvectors are    |
//|                needed or not. If ZNeeded is equal to:            |
//|                  * 0, the eigenvectors are not returned;         |
//|                  * 1, the eigenvectors are returned.             |
//|     IsUpperA -  storage format of matrix A.                      |
//|     B1, B2 -    half-interval (B1, B2] to search eigenvalues in. |
//| Output parameters:                                               |
//|     M       -   number of eigenvalues found in a given           |
//|                 half-interval, M>=0                              |
//|     W       -   array of the eigenvalues found.                  |
//|                 Array whose index ranges within [0..M-1].        |
//|     Z       -   if ZNeeded is equal to:                          |
//|                  * 0, Z hasn?t changed;                          |
//|                  * 1, Z contains eigenvectors.                   |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..M-1].                                |
//|                 The eigenvectors are stored in the matrix        |
//|                 columns.                                         |
//| Result:                                                          |
//|     True, if successful. M contains the number of eigenvalues    |
//|     in the given half-interval (could be equal to 0), W contains |
//|     the eigenvalues, Z contains the eigenvectors (if needed).    |
//|     False, if the bisection method subroutine wasn't able to find|
//|     the eigenvalues in the given interval or if the inverse      |
//|     iteration subroutine wasn't able to find all the             |
//|     corresponding eigenvectors. In that case, the eigenvalues and|
//|     eigenvectors are not returned, M is equal to 0.              |
//| Note:                                                            |
//|     eigen vectors of Hermitian matrix are defined up to          |
//|     multiplication by a complex number L, such as |L|=1.         |
//+------------------------------------------------------------------+
bool CAlglib::HMatrixEVDR(CMatrixComplex &a,const int n,const int zneeded,
                          const bool IsUpper,double b1,double b2,
                          int &m,double &w[],CMatrixComplex &z)
  {
//--- initialization
   m=0;
//--- return result
   return(CEigenVDetect::HMatrixEVDR(a,n,zneeded,IsUpper,b1,b2,m,w,z));
  }
//+------------------------------------------------------------------+
//| Subroutine for finding the eigenvalues and eigenvectors of a     |
//| Hermitian matrix with given indexes by using bisection and       |
//| inverse iteration methods                                        |
//| Input parameters:                                                |
//|     A       -   Hermitian matrix which is given by its upper or  |
//|                 lower triangular part.                           |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..N-1].                                |
//|     N       -   size of matrix A.                                |
//|     ZNeeded -   flag controlling whether the eigenvectors are    |
//|                 needed or not. If ZNeeded is equal to:           |
//|                  * 0, the eigenvectors are not returned;         |
//|                  * 1, the eigenvectors are returned.             |
//|     IsUpperA -  storage format of matrix A.                      |
//|     I1, I2 -    index interval for searching (from I1 to I2).    |
//|                 0 <= I1 <= I2 <= N-1.                            |
//| Output parameters:                                               |
//|     W       -   array of the eigenvalues found.                  |
//|                 Array whose index ranges within [0..I2-I1].      |
//|     Z       -   if ZNeeded is equal to:                          |
//|                  * 0, Z hasn?t changed;                          |
//|                  * 1, Z contains eigenvectors.                   |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..I2-I1].                              |
//|                 In  that  case,  the eigenvectors are stored in  |
//|                 the matrix columns.                              |
//| Result:                                                          |
//|     True, if successful. W contains the eigenvalues, Z contains  |
//|     the eigenvectors (if needed).                                |
//|     False, if the bisection method subroutine wasn't able to find|
//|     the eigenvalues in the given interval or if the inverse      |
//|     corresponding eigenvectors. iteration subroutine wasn't able |
//|     to find all the corresponding  eigenvectors. In that case,   |
//|     the eigenvalues and  eigenvectors are not returned.          |
//| Note:                                                            |
//|     eigen vectors of Hermitian matrix are defined up to          |
//|     multiplication  by a complex number L, such as |L|=1.        |
//+------------------------------------------------------------------+
bool CAlglib::HMatrixEVDI(CMatrixComplex &a,const int n,const int zneeded,
                          const bool IsUpper,const int i1,const int i2,
                          double &w[],CMatrixComplex &z)
  {
   return(CEigenVDetect::HMatrixEVDI(a,n,zneeded,IsUpper,i1,i2,w,z));
  }
//+------------------------------------------------------------------+
//| Finding the eigenvalues and eigenvectors of a tridiagonal        |
//| symmetric matrix                                                 |
//| The algorithm finds the eigen pairs of a tridiagonal symmetric   |
//| matrix by using an QL/QR algorithm with implicit shifts.         |
//| Input parameters:                                                |
//|     D       -   the main diagonal of a tridiagonal matrix.       |
//|                 Array whose index ranges within [0..N-1].        |
//|     E       -   the secondary diagonal of a tridiagonal matrix.  |
//|                 Array whose index ranges within [0..N-2].        |
//|     N       -   size of matrix A.                                |
//|     ZNeeded -   flag controlling whether the eigenvectors are    |
//|                 needed or not.                                   |
//|                 If ZNeeded is equal to:                          |
//|                  * 0, the eigenvectors are not needed;           |
//|                  * 1, the eigenvectors of a tridiagonal matrix   |
//|                    are multiplied by the square matrix Z. It is  |
//|                    used if the tridiagonal matrix is obtained by |
//|                    the similarity transformation of a symmetric  |
//|                    matrix;                                       |
//|                  * 2, the eigenvectors of a tridiagonal matrix   |
//|                    replace the square matrix Z;                  |
//|                  * 3, matrix Z contains the first row of the     |
//|                    eigenvectors matrix.                          |
//|     Z       -   if ZNeeded=1, Z contains the square matrix by    |
//|                 which the eigenvectors are multiplied.           |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..N-1].                                |
//| Output parameters:                                               |
//|     D       -   eigenvalues in ascending order.                  |
//|                 Array whose index ranges within [0..N-1].        |
//|     Z       -   if ZNeeded is equal to:                          |
//|                  * 0, Z hasn?t changed;                          |
//|                  * 1, Z contains the product of a given matrix   |
//|                    (from the left) and the eigenvectors matrix   |
//|                    (from the right);                             |
//|                  * 2, Z contains the eigenvectors.               |
//|                  * 3, Z contains the first row of the            |
//|                       eigenvectors matrix.                       |
//|                 If ZNeeded<3, Z is the array whose indexes range |
//|                 within [0..N-1, 0..N-1].                         |
//|                 In that case, the eigenvectors are stored in the |
//|                 matrix columns.                                  |
//|                 If ZNeeded=3, Z is the array whose indexes range |
//|                 within [0..0, 0..N-1].                           |
//| Result:                                                          |
//|     True, if the algorithm has converged.                        |
//|     False, if the algorithm hasn't converged.                    |
//|   -- LAPACK routine (version 3.0) --                             |
//|      Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd., |
//|      Courant Institute, Argonne National Lab, and Rice University|
//|      September 30, 1994                                          |
//+------------------------------------------------------------------+
bool CAlglib::SMatrixTdEVD(double &d[],double &e[],const int n,
                           const int zneeded,CMatrixDouble &z)
  {
   return(CEigenVDetect::SMatrixTdEVD(d,e,n,zneeded,z));
  }
//+------------------------------------------------------------------+
//| Subroutine for finding the tridiagonal matrix eigenvalues/vectors|
//| in a given half-interval (A, B] by using bisection and inverse   |
//| iteration.                                                       |
//| Input parameters:                                                |
//|     D       -   the main diagonal of a tridiagonal matrix.       |
//|                 Array whose index ranges within [0..N-1].        |
//|     E       -   the secondary diagonal of a tridiagonal matrix.  |
//|                 Array whose index ranges within [0..N-2].        |
//|     N       -   size of matrix, N>=0.                            |
//|     ZNeeded -   flag controlling whether the eigenvectors are    |
//|                 needed or not. If ZNeeded is equal to:           |
//|                  * 0, the eigenvectors are not needed;           |
//|                  * 1, the eigenvectors of a tridiagonal matrix   |
//|                    are multiplied by the square matrix Z. It is  |
//|                    used if the tridiagonal matrix is obtained by |
//|                    the similarity transformation of a symmetric  |
//|                    matrix.                                       |
//|                  * 2, the eigenvectors of a tridiagonal matrix   |
//|                    replace matrix Z.                             |
//|     A, B    -   half-interval (A, B] to search eigenvalues in.   |
//|     Z       -   if ZNeeded is equal to:                          |
//|                  * 0, Z isn't used and remains unchanged;        |
//|                  * 1, Z contains the square matrix (array whose  |
//|                    indexes range within [0..N-1, 0..N-1]) which  |
//|                    reduces the given symmetric matrix to         |
//|                    tridiagonal form;                             |
//|                  * 2, Z isn't used (but changed on the exit).    |
//| Output parameters:                                               |
//|     D       -   array of the eigenvalues found.                  |
//|                 Array whose index ranges within [0..M-1].        |
//|     M       -   number of eigenvalues found in the given         |
//|                 half-interval (M>=0).                            |
//|     Z       -   if ZNeeded is equal to:                          |
//|                  * 0, doesn't contain any information;           |
//|                  * 1, contains the product of a given NxN matrix |
//|                    Z (from the left) and NxM matrix of the       |
//|                    eigenvectors found (from the right). Array    |
//|                    whose indexes range within [0..N-1, 0..M-1].  |
//|                  * 2, contains the matrix of the eigenvectors    |
//|                    found. Array whose indexes range within       |
//|                    [0..N-1, 0..M-1].                             |
//| Result:                                                          |
//|     True, if successful. In that case, M contains the number of  |
//|     eigenvalues in the given half-interval (could be equal to 0),|
//|     D contains the eigenvalues, Z contains the eigenvectors (if  |
//|     needed). It should be noted that the subroutine changes the  |
//|     size of arrays D and Z.                                      |
//|     False, if the bisection method subroutine wasn't able to find|
//|     the eigenvalues in the given interval or if the inverse      |
//|     iteration subroutine wasn't able to find all the             |
//|     corresponding eigenvectors. In that case, the eigenvalues and|
//|     eigenvectors are not returned, M is equal to 0.              |
//+------------------------------------------------------------------+
bool CAlglib::SMatrixTdEVDR(double &d[],double &e[],const int n,
                            const int zneeded,const double a,
                            const double b,int &m,CMatrixDouble &z)
  {
//--- initialization
   m=0;
//--- return result
   return(CEigenVDetect::SMatrixTdEVDR(d,e,n,zneeded,a,b,m,z));
  }
//+------------------------------------------------------------------+
//| Subroutine for finding tridiagonal matrix eigenvalues/vectors    |
//| with given indexes (in ascending order) by using the bisection   |
//| and inverse iteraion.                                            |
//| Input parameters:                                                |
//|     D       -   the main diagonal of a tridiagonal matrix.       |
//|                 Array whose index ranges within [0..N-1].        |
//|     E       -   the secondary diagonal of a tridiagonal matrix.  |
//|                 Array whose index ranges within [0..N-2].        |
//|     N       -   size of matrix. N>=0.                            |
//|     ZNeeded -   flag controlling whether the eigenvectors are    |
//|                 needed or not. If ZNeeded is equal to:           |
//|                  * 0, the eigenvectors are not needed;           |
//|                  * 1, the eigenvectors of a tridiagonal matrix   |
//|                    are multiplied by the square matrix Z. It is  |
//|                    used if the tridiagonal matrix is obtained by |
//|                    the similarity transformation of a symmetric  |
//|                    matrix.                                       |
//|                  * 2, the eigenvectors of a tridiagonal matrix   |
//|                    replace matrix Z.                             |
//|     I1, I2  -   index interval for searching (from I1 to I2).    |
//|                 0 <= I1 <= I2 <= N-1.                            |
//|     Z       -   if ZNeeded is equal to:                          |
//|                  * 0, Z isn't used and remains unchanged;        |
//|                  * 1, Z contains the square matrix (array whose  |
//|                    indexes range within [0..N-1, 0..N-1]) which  |
//|                    reduces the given symmetric matrix to         |
//|                    tridiagonal form;                             |
//|                  * 2, Z isn't used (but changed on the exit).    |
//| Output parameters:                                               |
//|     D       -   array of the eigenvalues found.                  |
//|                 Array whose index ranges within [0..I2-I1].      |
//|     Z       -   if ZNeeded is equal to:                          |
//|                  * 0, doesn't contain any information;           |
//|                  * 1, contains the product of a given NxN matrix |
//|                    Z (from the left) and Nx(I2-I1) matrix of the |
//|                    eigenvectors found (from the right). Array    |
//|                    whose indexes range within [0..N-1, 0..I2-I1].|
//|                  * 2, contains the matrix of the eigenvalues     |
//|                    found. Array whose indexes range within       |
//|                    [0..N-1, 0..I2-I1].                           |
//| Result:                                                          |
//|     True, if successful. In that case, D contains the            |
//|     eigenvalues, Z contains the eigenvectors (if needed).        |
//|     It should be noted that the subroutine changes the size of   |
//|     arrays D and Z.                                              |
//|     False, if the bisection method subroutine wasn't able to find|
//|     the eigenvalues in the given interval or if the inverse      |
//|     iteration subroutine wasn't able to find all the             |
//|     corresponding eigenvectors. In that case, the eigenvalues and|
//|     eigenvectors are not returned.                               |
//+------------------------------------------------------------------+
bool CAlglib::SMatrixTdEVDI(double &d[],double &e[],const int n,
                            const int zneeded,const int i1,
                            const int i2,CMatrixDouble &z)
  {
   return(CEigenVDetect::SMatrixTdEVDI(d,e,n,zneeded,i1,i2,z));
  }
//+------------------------------------------------------------------+
//| Finding eigenvalues and eigenvectors of a general matrix         |
//| The algorithm finds eigenvalues and eigenvectors of a general    |
//| matrix by using the QR algorithm with multiple shifts. The       |
//| algorithm can find eigenvalues and both left and right           |
//| eigenvectors.                                                    |
//| The right eigenvector is a vector x such that A*x = w*x, and the |
//| left eigenvector is a vector y such that y'*A = w*y' (here y'    |
//| implies a complex conjugate transposition of vector y).          |
//| Input parameters:                                                |
//|     A       -   matrix. Array whose indexes range within         |
//|                 [0..N-1, 0..N-1].                                |
//|     N       -   size of matrix A.                                |
//|     VNeeded -   flag controlling whether eigenvectors are needed |
//|                 or not. If VNeeded is equal to:                  |
//|                  * 0, eigenvectors are not returned;             |
//|                  * 1, right eigenvectors are returned;           |
//|                  * 2, left eigenvectors are returned;            |
//|                  * 3, both left and right eigenvectors are       |
//|                       returned.                                  |
//| Output parameters:                                               |
//|     WR      -   real parts of eigenvalues.                       |
//|                 Array whose index ranges within [0..N-1].        |
//|     WR      -   imaginary parts of eigenvalues.                  |
//|                 Array whose index ranges within [0..N-1].        |
//|     VL, VR  -   arrays of left and right eigenvectors (if they   |
//|                 are needed). If WI[i]=0, the respective          |
//|                 eigenvalue is a real number, and it corresponds  |
//|                 to the column number I of matrices VL/VR. If     |
//|                 WI[i]>0, we have a pair of complex conjugate     |
//|                     numbers with positive and negative imaginary |
//|                     parts: the first eigenvalue WR[i] +          |
//|                     + sqrt(-1)*WI[i]; the second eigenvalue      |
//|                     WR[i+1] + sqrt(-1)*WI[i+1];                  |
//|                     WI[i]>0                                      |
//|                     WI[i+1] = -WI[i] < 0                         |
//|                 In that case, the eigenvector  corresponding to  |
//|                 the first eigenvalue is located in i and i+1     |
//|                 columns of matrices VL/VR (the column number i   |
//|                 contains the real part, and the column number    |
//|                 i+1 contains the imaginary part), and the vector |
//|                 corresponding to the second eigenvalue is a      |
//|                 complex conjugate to the first vector.           |
//|                 Arrays whose indexes range within                |
//|                 [0..N-1, 0..N-1].                                |
//| Result:                                                          |
//|     True, if the algorithm has converged.                        |
//|     False, if the algorithm has not converged.                   |
//| Note 1:                                                          |
//|     Some users may ask the following question: what if WI[N-1]>0?|
//|     WI[N] must contain an eigenvalue which is complex conjugate  |
//|     to the N-th eigenvalue, but the array has only size N?       |
//|     The answer is as follows: such a situation cannot occur      |
//|     because the algorithm finds a pairs of eigenvalues,          |
//|     therefore, if WI[i]>0, I is strictly less than N-1.          |
//| Note 2:                                                          |
//|     The algorithm performance depends on the value of the        |
//|     internal parameter NS of the InternalSchurDecomposition      |
//|     subroutine which defines the number of shifts in the QR      |
//|     algorithm (similarly to the block width in block-matrix      |
//|     algorithms of linear algebra). If you require maximum        |
//|     performance on your machine, it is recommended to adjust     |
//|     this parameter manually.                                     |
//| See also the InternalTREVC subroutine.                           |
//| The algorithm is based on the LAPACK 3.0 library.                |
//+------------------------------------------------------------------+
bool CAlglib::RMatrixEVD(CMatrixDouble &a,const int n,const int vneeded,
                         double &wr[],double &wi[],CMatrixDouble &vl,
                         CMatrixDouble &vr)
  {
   return(CEigenVDetect::RMatrixEVD(a,n,vneeded,wr,wi,vl,vr));
  }
//+------------------------------------------------------------------+
//| Generation of a random uniformly distributed (Haar) orthogonal   |
//| matrix                                                           |
//| INPUT PARAMETERS:                                                |
//|     N   -   matrix size, N>=1                                    |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   orthogonal NxN matrix, array[0..N-1,0..N-1]          |
//+------------------------------------------------------------------+
void CAlglib::RMatrixRndOrthogonal(const int n,CMatrixDouble &a)
  {
   CMatGen::RMatrixRndOrthogonal(n,a);
  }
//+------------------------------------------------------------------+
//| Generation of random NxN matrix with given condition number and  |
//| norm2(A)=1                                                       |
//| INPUT PARAMETERS:                                                |
//|     N   -   matrix size                                          |
//|     C   -   condition number (in 2-norm)                         |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   random matrix with norm2(A)=1 and cond(A)=C          |
//+------------------------------------------------------------------+
void CAlglib::RMatrixRndCond(const int n,const double c,
                             CMatrixDouble &a)
  {
   CMatGen::RMatrixRndCond(n,c,a);
  }
//+------------------------------------------------------------------+
//| Generation of a random Haar distributed orthogonal complex matrix|
//| INPUT PARAMETERS:                                                |
//|     N   -   matrix size, N>=1                                    |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   orthogonal NxN matrix, array[0..N-1,0..N-1]          |
//+------------------------------------------------------------------+
void CAlglib::CMatrixRndOrthogonal(const int n,CMatrixComplex &a)
  {
   CMatGen::CMatrixRndOrthogonal(n,a);
  }
//+------------------------------------------------------------------+
//| Generation of random NxN complex matrix with given condition     |
//| number C and norm2(A)=1                                          |
//| INPUT PARAMETERS:                                                |
//|     N   -   matrix size                                          |
//|     C   -   condition number (in 2-norm)                         |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   random matrix with norm2(A)=1 and cond(A)=C          |
//+------------------------------------------------------------------+
void CAlglib::CMatrixRndCond(const int n,const double c,
                             CMatrixComplex &a)
  {
   CMatGen::CMatrixRndCond(n,c,a);
  }
//+------------------------------------------------------------------+
//| Generation of random NxN symmetric matrix with given condition   |
//| number and norm2(A)=1                                            |
//| INPUT PARAMETERS:                                                |
//|     N   -   matrix size                                          |
//|     C   -   condition number (in 2-norm)                         |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   random matrix with norm2(A)=1 and cond(A)=C          |
//+------------------------------------------------------------------+
void CAlglib::SMatrixRndCond(const int n,const double c,
                             CMatrixDouble &a)
  {
   CMatGen::SMatrixRndCond(n,c,a);
  }
//+------------------------------------------------------------------+
//| Generation of random NxN symmetric positive definite matrix with |
//| given condition number and norm2(A)=1                            |
//| INPUT PARAMETERS:                                                |
//|     N   -   matrix size                                          |
//|     C   -   condition number (in 2-norm)                         |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   random SPD matrix with norm2(A)=1 and cond(A)=C      |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixRndCond(const int n,const double c,
                               CMatrixDouble &a)
  {
   CMatGen::SPDMatrixRndCond(n,c,a);
  }
//+------------------------------------------------------------------+
//| Generation of random NxN Hermitian matrix with given condition   |
//| number and norm2(A)=1                                            |
//| INPUT PARAMETERS:                                                |
//|     N   -   matrix size                                          |
//|     C   -   condition number (in 2-norm)                         |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   random matrix with norm2(A)=1 and cond(A)=C          |
//+------------------------------------------------------------------+
void CAlglib::HMatrixRndCond(const int n,const double c,
                             CMatrixComplex &a)
  {
   CMatGen::HMatrixRndCond(n,c,a);
  }
//+------------------------------------------------------------------+
//| Generation of random NxN Hermitian positive definite matrix with |
//| given condition number and norm2(A)=1                            |
//| INPUT PARAMETERS:                                                |
//|     N   -   matrix size                                          |
//|     C   -   condition number (in 2-norm)                         |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   random HPD matrix with norm2(A)=1 and cond(A)=C      |
//+------------------------------------------------------------------+
void CAlglib::HPDMatrixRndCond(const int n,const double c,
                               CMatrixComplex &a)
  {
   CMatGen::HPDMatrixRndCond(n,c,a);
  }
//+------------------------------------------------------------------+
//| Multiplication of MxN matrix by NxN random Haar distributed      |
//| orthogonal matrix                                                |
//| INPUT PARAMETERS:                                                |
//|     A   -   matrix, array[0..M-1, 0..N-1]                        |
//|     M, N-   matrix size                                          |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   A*Q, where Q is random NxN orthogonal matrix         |
//+------------------------------------------------------------------+
void CAlglib::RMatrixRndOrthogonalFromTheRight(CMatrixDouble &a,
                                               const int m,const int n)
  {
   CMatGen::RMatrixRndOrthogonalFromTheRight(a,m,n);
  }
//+------------------------------------------------------------------+
//| Multiplication of MxN matrix by MxM random Haar distributed      |
//| orthogonal matrix                                                |
//| INPUT PARAMETERS:                                                |
//|     A   -   matrix, array[0..M-1, 0..N-1]                        |
//|     M, N-   matrix size                                          |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   Q*A, where Q is random MxM orthogonal matrix         |
//+------------------------------------------------------------------+
void CAlglib::RMatrixRndOrthogonalFromTheLeft(CMatrixDouble &a,
                                              const int m,const int n)
  {
   CMatGen::RMatrixRndOrthogonalFromTheLeft(a,m,n);
  }
//+------------------------------------------------------------------+
//| Multiplication of MxN complex matrix by NxN random Haar          |
//| distributed complex orthogonal matrix                            |
//| INPUT PARAMETERS:                                                |
//|     A   -   matrix, array[0..M-1, 0..N-1]                        |
//|     M, N-   matrix size                                          |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   A*Q, where Q is random NxN orthogonal matrix         |
//+------------------------------------------------------------------+
void CAlglib::CMatrixRndOrthogonalFromTheRight(CMatrixComplex &a,
                                               const int m,const int n)
  {
   CMatGen::CMatrixRndOrthogonalFromTheRight(a,m,n);
  }
//+------------------------------------------------------------------+
//| Multiplication of MxN complex matrix by MxM random Haar          |
//| distributed complex orthogonal matrix                            |
//| INPUT PARAMETERS:                                                |
//|     A   -   matrix, array[0..M-1, 0..N-1]                        |
//|     M, N-   matrix size                                          |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   Q*A, where Q is random MxM orthogonal matrix         |
//+------------------------------------------------------------------+
void CAlglib::CMatrixRndOrthogonalFromTheLeft(CMatrixComplex &a,
                                              const int m,const int n)
  {
   CMatGen::CMatrixRndOrthogonalFromTheLeft(a,m,n);
  }
//+------------------------------------------------------------------+
//| Symmetric multiplication of NxN matrix by random Haar            |
//| distributed orthogonal matrix                                    |
//| INPUT PARAMETERS:                                                |
//|     A   -   matrix, array[0..N-1, 0..N-1]                        |
//|     N   -   matrix size                                          |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   Q'*A*Q, where Q is random NxN orthogonal matrix      |
//+------------------------------------------------------------------+
void CAlglib::SMatrixRndMultiply(CMatrixDouble &a,const int n)
  {
   CMatGen::SMatrixRndMultiply(a,n);
  }
//+------------------------------------------------------------------+
//| Hermitian multiplication of NxN matrix by random Haar distributed|
//| complex orthogonal matrix                                        |
//| INPUT PARAMETERS:                                                |
//|     A   -   matrix, array[0..N-1, 0..N-1]                        |
//|     N   -   matrix size                                          |
//| OUTPUT PARAMETERS:                                               |
//|     A   -   Q^H*A*Q, where Q is random NxN orthogonal matrix     |
//+------------------------------------------------------------------+
void CAlglib::HMatrixRndMultiply(CMatrixComplex &a,const int n)
  {
   CMatGen::HMatrixRndMultiply(a,n);
  }
//+------------------------------------------------------------------+
//| This function serializes data structure to string.               |
//| Important properties of s_out:                                   |
//| * it contains alphanumeric characters, dots, underscores, minus  |
//|   signs                                                          |
//| * these symbols are grouped into words, which are separated by   |
//|   spaces and Windows-style (CR+LF) newlines                      |
//| * although serializer uses spaces and CR+LF as separators, you   |
//|   can replace any separator character by arbitrary combination   |
//|   of spaces, tabs, Windows or Unix newlines. It allows flexible  |
//|   reformatting of the string in case you want to include it into |
//|   text or XML file. But you should not insert separators into the|
//|   middle of the "words" nor you should change case of letters.   |
//| * s_out can be freely moved between 32-bit and 64-bit systems,   |
//|   little and big endian machines, and so on. You can serialize   |
//|   structure on 32-bit machine and unserialize it on 64-bit one   |
//|   (or vice versa), or serialize it on SPARC and unserialize on   |
//|   x86. You can also serialize it in C# version of ALGLIB and     |
//|   unserialize in C++ one,  and vice versa.                       |
//+------------------------------------------------------------------+
void CAlglib::SparseSerialize(CSparseMatrix &obj,string &s_out)
  {
//--- create a variable
   CSerializer s;
//--- serialization start
   s.Alloc_Start();
//--- function call
   CSparse::SparseAlloc(s,obj);
   s.SStart_Str();
   CSparse::SparseSerialize(s,obj);
   s.Stop();
   s_out=s.Get_String();
  }
//+------------------------------------------------------------------+
//| This function unserializes data structure from string.           |
//+------------------------------------------------------------------+
void CAlglib::SparseUunserialize(string s_in,CSparseMatrix &obj)
  {
//--- create a variable
   CSerializer s;
//--- unserialization start
   s.UStart_Str(s_in);
//--- function call
   CSparse::SparseUnserialize(s,obj);
   s.Stop();
  }
//+------------------------------------------------------------------+
//| This function creates sparse matrix in a Hash-Table format.      |
//| This function creates Hast-Table matrix, which can be converted  |
//| to CRS format after its initialization is over. Typical usage    |
//| scenario for a sparse matrix is:                                 |
//| 1. creation in a Hash-Table format                               |
//| 2. insertion of the matrix elements                              |
//| 3. conversion to the CRS representation                          |
//| 4. matrix is passed to some linear algebra algorithm             |
//| Some information about different matrix formats can be found     |
//| below, in the "NOTES" section.                                   |
//| INPUT PARAMETERS:                                                |
//|   M        -  number of rows in a matrix, M>=1                   |
//|   N        -  number of columns in a matrix, N>=1                |
//|   K        -  K>=0, expected number of non-zero elements in a    |
//|               matrix. K can be inexact approximation, can be less|
//|               than actual number of elements (table will grow    |
//|               when needed) or even zero).                        |
//| It is important to understand that although hash-table may grow  |
//| automatically, it's better to provide good estimate of data size.|
//| OUTPUT PARAMETERS:                                               |
//|   S        -  sparse M*N matrix in Hash-Table representation. All|
//|               elements of the matrix are zero.                   |
//| NOTE 1                                                           |
//| Hash-tables use memory inefficiently, and they have to keep some |
//| amount of the "spare memory" in order to have good performance.  |
//| Hash table for matrix with K non-zero elements will need         |
//| C*K*(8+2*sizeof(int)) bytes, where C is a small constant, about  |
//| 1.5-2 in magnitude.                                              |
//| CRS storage, from the other side, is more memory-efficient, and  |
//| needs just K*(8+sizeof(int))+M*sizeof(int) bytes, where M is a   |
//| number of rows in a matrix.                                      |
//| When you convert from the Hash-Table to CRS representation, all  |
//| unneeded memory will be freed.                                   |
//|                                                                  |
//| NOTE 2                                                           |
//| Comments of SparseMatrix structure outline information about     |
//| different sparse storage formats. We recommend you to read them  |
//| before starting to use ALGLIB sparse matrices.                   |
//|                                                                  |
//| NOTE 3                                                           |
//| This function completely overwrites S with new sparse matrix.    |
//| Previously allocated storage is NOT reused. If you want to reuse |
//| already allocated memory, call SparseCreateBuf function.         |
//+------------------------------------------------------------------+
void CAlglib::SparseCreate(int m,int n,int k,CSparseMatrix &s)
  {
   CSparse::SparseCreate(m,n,k,s);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SparseCreate(int m,int n,CSparseMatrix &s)
  {
//--- initialization
   int k=0;
//--- function call
   CSparse::SparseCreate(m,n,k,s);
  }
//+------------------------------------------------------------------+
//| This version of SparseCreate function creates sparse matrix in   |
//| Hash-Table format, reusing previously allocated storage as much  |
//| as possible.Read comments for SparseCreate() for more information|
//| INPUT PARAMETERS:                                                |
//|   M     -  number of rows in a matrix, M>=1                      |
//|   N     -  number of columns in a matrix, N>=1                   |
//|   K     -  K>=0, expected number of non-zero elements in a matrix|
//|            K can be inexact approximation, can be less than      |
//|            actual number of elements (table will grow when needed|
//|            or even zero).                                        |
//| It is important to understand that although hash-table may grow  |
//| automatically, it is better to provide good estimate of data size|
//|   S     -  SparseMatrix structure which MAY contain some already |
//|            allocated storage.                                    |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  sparse M*N matrix in Hash-Table representation. All   |
//|            elements of the matrix are zero. Previously allocated |
//|            storage is reused, if its size is compatible with     |
//|            expected number of non-zeros K.                       |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateBuf(int m,int n,int k,CSparseMatrix &s)
  {
   CSparse::SparseCreateBuf(m,n,k,s);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateBuf(int m,int n,CSparseMatrix &s)
  {
//--- initialization
   int k=0;
//--- function call
   CSparse::SparseCreateBuf(m,n,k,s);
  }
//+------------------------------------------------------------------+
//| This function creates sparse matrix in a CRS format (expert      |
//| function for situations when you are running out of memory).     |
//| This function creates CRS matrix. Typical usage scenario for a   |
//| CRS matrix is:                                                   |
//| 1. creation (you have to tell number of non-zero elements at each|
//|    row at this moment)                                           |
//| 2. insertion of the matrix elements (row by row, from left to    |
//|    right)                                                        |
//| 3. matrix is passed to some linear algebra algorithm             |
//| This function is a memory-efficient alternative to SparseCreate()|
//| but it is more complex because it requires you to know in advance|
//| how large your matrix is. Some information about different matrix|
//| formats can be found in comments on SparseMatrix structure. We   |
//| recommend you to read them before starting to use ALGLIB sparse  |
//| matrices..                                                       |
//| INPUT PARAMETERS:                                                |
//|   M     -  number of rows in a matrix, M>=1                      |
//|   N     -  number of columns in a matrix, N>=1                   |
//|   NER   -  number of elements at each row, array[M], NER[I]>=0   |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  sparse M*N matrix in CRS representation.              |
//|            You have to fill ALL non-zero elements by calling     |
//|            SparseSet() BEFORE you try to use this matrix.        |
//| NOTE: this function completely overwrites S with new sparse      |
//|       matrix. Previously allocated storage is NOT reused. If you |
//|       want to reuse already allocated memory, call               |
//|       SparseCreateCRSBuf function.                               |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateCRS(int m,int n,CRowInt &ner,
                              CSparseMatrix &s)
  {
   CSparse::SparseCreateCRS(m,n,ner,s);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateCRS(int m,int n,int &ner[],
                              CSparseMatrix &s)
  {
   CSparse::SparseCreateCRS(m,n,ner,s);
  }
//+------------------------------------------------------------------+
//| This function creates sparse matrix in a CRS format (expert      |
//| function for situations when you are running out of memory). This|
//| version of CRS matrix creation function may reuse memory already |
//| allocated in S.                                                  |
//| This function creates CRS matrix. Typical usage scenario for a   |
//| CRS matrix is:                                                   |
//| 1. creation (you have to tell number of non-zero elements at each|
//|    row at this moment)                                           |
//| 2. insertion of the matrix elements (row by row, from left to    |
//|    right)                                                        |
//| 3. matrix is passed to some linear algebra algorithm             |
//| This function is a memory-efficient alternative to SparseCreate()|
//| but it is more complex because it requires you to know in advance|
//| how large your matrix is. Some information about different matrix|
//| formats can be found in comments on SparseMatrix structure. We   |
//| recommend you to read them before starting to use ALGLIB sparse  |
//| matrices..                                                       |
//| INPUT PARAMETERS:                                                |
//|   M     -  number of rows in a matrix, M>=1                      |
//|   N     -  number of columns in a matrix, N>=1                   |
//|   NER   -  number of elements at each row, array[M], NER[I]>=0   |
//|   S     -  sparse matrix structure with possibly preallocated    |
//|            memory.                                               |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  sparse M*N matrix in CRS representation. You have to  |
//|            fill ALL non-zero elements by calling SparseSet()     |
//|            BEFORE you try to use this matrix.                    |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateCRSBuf(int m,int n,CRowInt &ner,
                                 CSparseMatrix &s)
  {
   CSparse::SparseCreateCRSBuf(m,n,ner,s);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateCRSBuf(int m,int n,int &ner[],
                                 CSparseMatrix &s)
  {
   CSparse::SparseCreateCRSBuf(m,n,ner,s);
  }
//+------------------------------------------------------------------+
//| This function creates sparse matrix in a SKS format (skyline     |
//| storage format). In most cases you do not need this function -CRS|
//| format better suits most use cases.                              |
//| INPUT PARAMETERS:                                                |
//|   M, N     -  number of rows(M) and columns(N) in a matrix:      |
//|               * M=N (as for now, ALGLIB supports only square SKS)|
//|               * N>=1                                             |
//|               * M>=1                                             |
//|   D       - "bottom" bandwidths, array[M],D[I]>=0. I-th element|
//|               stores number of non-zeros at I-th row, below the  |
//|               diagonal (diagonal itself is not included)         |
//|   U       - "top" bandwidths, array[N], U[I]>=0. I-th element  |
//|               stores number of non-zeros at I-th row, above the  |
//|               diagonal (diagonal itself is not included)         |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  sparse M*N matrix in SKS representation. All       |
//|               elements are filled by zeros. You may use          |
//|               SparseSet() to change their values.                |
//| NOTE: this function completely overwrites S with new sparse      |
//|       matrix. Previously allocated storage is NOT reused. If you |
//|       want to reuse already allocated memory, call               |
//|       SparseCreateSKSBuf function.                               |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateSKS(int m,int n,CRowInt &d,CRowInt &u,
                              CSparseMatrix &s)
  {
   CSparse::SparseCreateSKS(m,n,d,u,s);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateSKS(int m,int n,int &d[],int &u[],
                              CSparseMatrix &s)
  {
   CSparse::SparseCreateSKS(m,n,d,u,s);
  }
//+------------------------------------------------------------------+
//| This is "buffered" version of SparseCreateSKS() which reuses     |
//| memory previously allocated in S (of course, memory is           |
//| reallocated if needed).                                          |
//| This function creates sparse matrix in a SKS format (skyline     |
//| storage format). In most cases you do not need this function -   |
//| CRS format  better suits most use cases.                         |
//| INPUT PARAMETERS:                                                |
//|   M, N     -  number of rows(M) and columns (N) in a matrix:     |
//|               * M=N (as for now, ALGLIB supports only square SKS)|
//|               * N>=1                                             |
//|               * M>=1                                             |
//|   D       - "bottom" bandwidths, array[M], 0<=D[I]<=I.         |
//|              I-th element stores number of non-zeros at I-th row,|
//|              below the diagonal (diagonal itself is not included)|
//|   U       - "top" bandwidths, array[N], 0<=U[I]<=I. I-th       |
//|              element stores number of non-zeros at I-th row,above|
//|              the diagonal (diagonal itself is not included)      |
//| OUTPUT PARAMETERS:                                               |
//|   S        -  sparse M*N matrix in SKS representation. All       |
//|              elements are filled by zeros. You may use           |
//|              SparseSet() to change their values.                 |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateSKSBuf(int m,int n,CRowInt &d,CRowInt &u,CSparseMatrix &s)
  {
   CSparse::SparseCreateSKSBuf(m,n,d,u,s);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateSKSBuf(int m,int n,int &d[],int &u[],CSparseMatrix &s)
  {
   CSparse::SparseCreateSKSBuf(m,n,d,u,s);
  }
//+------------------------------------------------------------------+
//| This function creates sparse matrix in a SKS format (skyline     |
//| storage format). Unlike more general SparseCreateSKS(), this     |
//| function creates sparse matrix with constant bandwidth.          |
//| You may want to use this function instead of SparseCreateSKS()   |
//| when your matrix has constant or nearly-constant bandwidth, and  |
//| you want to simplify source code.                                |
//| INPUT PARAMETERS:                                                |
//|   M, N  -  number of rows(M) and columns (N) in a matrix:        |
//|            * M=N (as for now, ALGLIB supports only square SKS)   |
//|            * N>=1                                                |
//|            * M>=1                                                |
//|   BW    -  matrix bandwidth, BW>=0                               |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  sparse M*N matrix in SKS representation. All elements |
//|            are filled by zeros. You may use SparseSet() to change|
//|            their values.                                         |
//| NOTE: this function completely overwrites S with new sparse      |
//|       matrix. Previously allocated storage is NOT reused. If you |
//|       want to reuse already allocated memory, call               |
//|       SparseCreateSKSBandBuf function.                           |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateSKSBand(int m,int n,int bw,
                                  CSparseMatrix &s)
  {
   CSparse::SparseCreateSKSBand(m,n,bw,s);
  }
//+------------------------------------------------------------------+
//| This is "buffered" version of SparseCreateSKSBand() which reuses |
//| memory previously allocated in S(of course, memory is reallocated|
//| if needed).                                                      |
//| You may want to use this function instead of SparseCreateSKSBuf()|
//| when your matrix has constant or nearly-constant bandwidth, and  |
//| you want to simplify source code.                                |
//| INPUT PARAMETERS:                                                |
//|   M, N  -  number of rows(M) and columns (N) in a matrix:        |
//|            * M=N (as for now, ALGLIB supports only square SKS)   |
//|            * N>=1                                                |
//|            * M>=1                                                |
//|   BW    -  bandwidth, BW>=0                                      |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  sparse M*N matrix in SKS representation. All elements |
//|            are filled by zeros. You may use SparseSet() to change|
//|            their values.                                         |
//+------------------------------------------------------------------+
void CAlglib::SparseCreateSKSBandBuf(int m,int n,int bw,
                                     CSparseMatrix &s)
  {
   CSparse::SparseCreateSKSBandBuf(m,n,bw,s);
  }
//+------------------------------------------------------------------+
//| This function copies S0 to S1.                                   |
//| This function completely deallocates memory owned by S1 before   |
//| creating a copy of S0. If you want to reuse memory, use          |
//| SparseCopyBuf.                                                   |
//| NOTE: this function does not verify its arguments, it just copies|
//| all fields of the structure.                                     |
//+------------------------------------------------------------------+
void CAlglib::SparseCopy(CSparseMatrix &s0,CSparseMatrix &s1)
  {
   CSparse::SparseCopy(s0,s1);
  }
//+------------------------------------------------------------------+
//| This function copies S0 to S1.                                   |
//| Memory already allocated in S1 is reused as much as possible.    |
//| NOTE: this function does not verify its arguments, it just copies|
//| all fields of the structure.                                     |
//+------------------------------------------------------------------+
void CAlglib::SparseCopyBuf(CSparseMatrix &s0,CSparseMatrix &s1)
  {
   CSparse::SparseCopyBuf(s0,s1);
  }
//+------------------------------------------------------------------+
//| This function efficiently swaps contents of S0 and S1.           |
//+------------------------------------------------------------------+
void CAlglib::SparseSwap(CSparseMatrix &s0,CSparseMatrix &s1)
  {
   CSparse::SparseSwap(s0,s1);
  }
//+------------------------------------------------------------------+
//| This function adds value to S[i,j] - element of the sparse matrix|
//| Matrix must be in a Hash-Table mode.                             |
//| In case S[i,j] already exists in the table, V i added to its     |
//| value. In case S[i,j] is non-existent, it is inserted in the     |
//| table. Table automatically grows when necessary.                 |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix in Hash-Table representation.       |
//|            Exception will be thrown for CRS matrix.              |
//|   I     -  row index of the element to modify, 0<=I<M            |
//|   J     -  column index of the element to modify, 0<=J<N         |
//|   V     -  value to add, must be finite number                   |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  modified matrix                                       |
//| NOTE 1: when S[i,j] is exactly zero after modification, it is    |
//|         deleted from the table.                                  |
//+------------------------------------------------------------------+
void CAlglib::SparseAdd(CSparseMatrix &s,int i,int j,double v)
  {
   CSparse::SparseAdd(s,i,j,v);
  }
//+------------------------------------------------------------------+
//| This function modifies S[i,j] - element of the sparse matrix.    |
//| For Hash-based storage format:                                   |
//| * this function can be called at any moment - during matrix      |
//|   initialization or later                                        |
//| * new value can be zero or non-zero. In case new value of S[i,j] |
//|   is zero, this element is deleted from the table.               |
//| * this function has no effect when called with zero V for        |
//|   non-existent element.                                          |
//| For CRS-bases storage format:                                    |
//| * this function can be called ONLY DURING MATRIX INITIALIZATION  |
//| * zero values are stored in the matrix similarly to non-zero ones|
//| * elements must be initialized in correct order -  from top row  |
//|   to bottom, within row - from left to right.                    |
//| For SKS storage:                                                 |
//| * this function can be called at any moment - during matrix      |
//|   initialization or later                                        |
//| * zero values are stored in the matrix similarly to non-zero ones|
//| * this function CAN NOT be called for non-existent (outside of   |
//|   the band specified during SKS matrix creation) elements. Say,  |
//|   if you created SKS matrix with bandwidth=2 and tried to call   |
//|   SparseSet(s,0,10,VAL), an exception will be generated.         |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix in Hash-Table, SKS or CRS format.   |
//|   I     -  row index of the element to modify, 0<=I<M            |
//|   J     -  column index of the element to modify, 0<=J<N         |
//|   V     -  value to set, must be finite number, can be zero      |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  modified matrix                                       |
//+------------------------------------------------------------------+
void CAlglib::SparseSet(CSparseMatrix &s,int i,int j,double v)
  {
   CSparse::SparseSet(s,i,j,v);
  }
//+------------------------------------------------------------------+
//| This function returns S[i,j] - element of the sparse matrix.     |
//| Matrix can be in any mode (Hash-Table, CRS, SKS), but this       |
//| function is less efficient for CRS matrices. Hash-Table and SKS  |
//| matrices can find element in O(1) time, while CRS matrices need  |
//| O(log(RS)) time, where RS is an number of non-zero elements in a |
//| row.                                                             |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix                                     |
//|   I     -  row index of the element to modify, 0<=I<M            |
//|   J     -  column index of the element to modify, 0<=J<N         |
//| RESULT                                                           |
//| value of S[I,J] or zero (in case no element with such index is   |
//| found)                                                           |
//+------------------------------------------------------------------+
double CAlglib::SparseGet(CSparseMatrix &s,int i,int j)
  {
   return(CSparse::SparseGet(s,i,j));
  }
//+------------------------------------------------------------------+
//| This function checks whether S[i,j] is present in the sparse     |
//| matrix. It returns True even for elements that are numerically   |
//| zero (but still have place allocated for them).                  |
//| The matrix can be in any mode (Hash-Table, CRS, SKS), but this   |
//| function is less efficient for CRS matrices. Hash-Table and SKS  |
//| matrices can find element in O(1) time, while CRS matrices need  |
//| O(log(RS)) time, where RS is an number of non-zero elements in a |
//| row.                                                             |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix                                     |
//|   I     -  row index of the element to modify, 0<=I<M            |
//|   J     -  column index of the element to modify, 0<=J<N         |
//| RESULT                                                           |
//| whether S[I,J] is present in the data structure or not           |
//+------------------------------------------------------------------+
bool CAlglib::SparseExists(CSparseMatrix &s,int i,int j)
  {
   return(CSparse::SparseExists(s,i,j));
  }
//+------------------------------------------------------------------+
//| This function returns I-th diagonal element of the sparse matrix.|
//| Matrix can be in any mode (Hash-Table or CRS storage), but this  |
//| function is most efficient for CRS matrices - it requires less   |
//| than 50 CPU cycles to extract diagonal element. For Hash-Table   |
//| matrices we still have O(1) query time, but function is many     |
//| times slower.                                                    |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix in Hash-Table representation.       |
//|            Exception will be thrown for CRS matrix.              |
//|   I     -  index of the element to modify, 0<=I<min(M,N)         |
//| RESULT                                                           |
//| value of S[I,I] or zero (in case no element with such index is   |
//| found)                                                           |
//+------------------------------------------------------------------+
double CAlglib::SparseGetDiagonal(CSparseMatrix &s,int i)
  {
   return(CSparse::SparseGetDiagonal(s,i));
  }
//+------------------------------------------------------------------+
//| This function calculates matrix-vector product S*x. Matrix S must|
//| be stored in CRS or SKS format (exception will be thrown         |
//| otherwise).                                                      |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix in CRS or SKS format.               |
//|   X     -  array[N], input vector. For performance reasons we    |
//|            make only quick checks - we check that array size  is |
//|            at least N, but we do not check for NAN's or INF's.   |
//|   Y     -  output buffer, possibly preallocated. In case buffer  |
//|            size is too small to store result, this buffer is     |
//|            automatically resized.                                |
//| OUTPUT PARAMETERS:                                               |
//|   Y     -  array[M], S*x                                         |
//| NOTE: this function throws exception when called for             |
//|       non-CRS/SKS matrix. You must convert your matrix with      |
//|       SparseConvertToCRS/SKS() before using this function.       |
//+------------------------------------------------------------------+
void CAlglib::SparseMV(CSparseMatrix &s,CRowDouble &x,CRowDouble &y)
  {
   CSparse::SparseMV(s,x,y);
  }
//+------------------------------------------------------------------+
//| This function calculates matrix-vector product S^T*x. Matrix S   |
//| must be stored in CRS or SKS format (exception will be thrown    |
//| otherwise).                                                      |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix in CRS or SKS format.               |
//|   X     -  array[M], input vector. For performance reasons we    |
//|            make only quick checks - we check that array size is  |
//|            at least M, but we do not check for NAN's or INF's.   |
//|   Y     -  output buffer, possibly preallocated. In case buffer  |
//|            size is too small to store result, this buffer is     |
//|            automatically resized.                                |
//| OUTPUT PARAMETERS:                                               |
//|   Y     -  array[N], S^T*x                                       |
//| NOTE: this function throws exception when called for non-CRS/SKS |
//|       matrix.                                                    |
//| You must convert your matrix with SparseConvertToCRS/SKS() before|
//| using this function.                                             |
//+------------------------------------------------------------------+
void CAlglib::SparseMTV(CSparseMatrix &s,CRowDouble &x,CRowDouble &y)
  {
   CSparse::SparseMTV(s,x,y);
  }
//+------------------------------------------------------------------+
//| This function calculates generalized sparse matrix-vector product|
//| y := alpha*op(S)*x + beta*y                                      |
//| Matrix S must be stored in CRS or SKS format (exception  will be |
//| thrown otherwise). op(S) can be either S or S^T.                 |
//| NOTE: this function expects Y to be large enough to store result.|
//| No automatic preallocation happens for smaller arrays.           |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse matrix in CRS or SKS format.                   |
//|   Alpha -  source coefficient                                    |
//|   OpS   -  operation type:                                       |
//|            * OpS=0     =>  op(S) = S                             |
//|            * OpS=1     =>  op(S) = S^T                           |
//|   X     -  input vector, must have at least Cols(op(S))+IX       |
//|            elements                                              |
//|   IX    -  subvector offset                                      |
//|   Beta  -  destination coefficient                               |
//|   Y     -  preallocated output array, must have at least         |
//|            Rows(op(S))+IY elements                               |
//|   IY    -  subvector offset                                      |
//| OUTPUT PARAMETERS:                                               |
//|   Y     -  elements [IY...IY+Rows(op(S))-1] are replaced by      |
//|            result, other elements are not modified               |
//| HANDLING OF SPECIAL CASES:                                       |
//|   * below M=Rows(op(S)) and N=Cols(op(S)). Although current      |
//|     ALGLIB version does not allow you to create zero-sized sparse|
//|     matrices, internally ALGLIB can deal with such matrices. So, |
//|     comments for M or N equal to zero are for internal use only. |
//|   * if M=0, then subroutine does nothing. It does not even touch |
//|     arrays.                                                      |
//|   * if N=0 or Alpha=0.0, then:                                   |
//|   * if Beta=0, then Y is filled by zeros. S and X are not        |
//|     referenced at all. Initial values of Y are ignored (we do not|
//|     multiply Y by zero, we just rewrite it by zeros)             |
//|   * if Beta<>0, then Y is replaced by Beta*Y                     |
//|   * if M>0, N>0, Alpha<>0, but Beta=0, then Y is areplaced by    |
//|     alpha*op(S)*x initial state of Y is ignored (rewritten       |
//|     without initial multiplication by zeros).                    |
//| NOTE: this function throws exception when called for non-CRS/SKS |
//|     matrix.                                                      |
//| You must convert your matrix with SparseConvertToCRS/SKS() before|
//| using this function.                                             |
//+------------------------------------------------------------------+
void CAlglib::SparseGemV(CSparseMatrix &s,double alpha,int ops,
                         CRowDouble &x,int ix,double beta,
                         CRowDouble &y,int iy)
  {
   CSparse::SparseGemV(s,alpha,ops,x,ix,beta,y,iy);
  }
//+------------------------------------------------------------------+
//| This function simultaneously calculates two matrix-vector        |
//| products:                                                        |
//|                     S*x and S^T*x.                               |
//| S must be square (non-rectangular) matrix stored in CRS or SKS   |
//| format (exception will be thrown otherwise).                     |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse N*N matrix in CRS or SKS format.               |
//|   X     -  array[N], input vector. For  performance  reasons  we |
//|            make only quick checks - we check that array size  is |
//|            at least N, but we do not check for NAN's or INF's.   |
//|   Y0    -  output buffer, possibly preallocated. In case  buffer |
//|            size is too small to store  result,  this  buffer  is |
//|            automatically resized.                                |
//|   Y1    -  output buffer, possibly preallocated. In case  buffer |
//|            size is too small to store  result,  this  buffer  is |
//|            automatically resized.                                |
//| OUTPUT PARAMETERS:                                               |
//|   Y0    -  array[N], S*x                                         |
//|   Y1    -  array[N], S^T*x                                       |
//| NOTE: this function throws exception when called for non-CRS/SKS |
//|       matrix.                                                    |
//| You must convert your matrix with SparseConvertToCRS/SKS() before|
//| using this function.                                             |
//+------------------------------------------------------------------+
void CAlglib::SparseMV2(CSparseMatrix &s,CRowDouble &x,
                        CRowDouble &y0,CRowDouble &y1)
  {
   CSparse::SparseMV2(s,x,y0,y1);
  }
//+------------------------------------------------------------------+
//| This function calculates matrix-vector product S*x, when S is    |
//| symmetric matrix. Matrix S must be stored in CRS or SKS format   |
//| (exception will be thrown otherwise).                            |
//| INPUT PARAMETERS:                                                |
//|   S        -  sparse M*M matrix in CRS or SKS format.            |
//|   IsUpper  -  whether upper or lower triangle of S is given:     |
//|            * if upper triangle is given,  only   S[i,j] for j>=i |
//|              are used, and lower triangle is ignored (it can  be |
//|              empty - these elements are not referenced at all).  |
//|            * if lower triangle is given,  only   S[i,j] for j<=i |
//|              are used, and upper triangle is ignored.            |
//|   X        -  array[N], input vector. For performance reasons we |
//|              make only quick checks - we check that array size is|
//|              at least N, but we do not check for NAN's or INF's. |
//|   Y        -  output buffer, possibly preallocated.In case buffer|
//|              size is too small to store  result,  this  buffer is|
//|              automatically resized.                              |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  array[M], S*x                                      |
//| NOTE: this function throws exception when called for non-CRS/SKS |
//| matrix.                                                          |
//| You must convert your matrix with SparseConvertToCRS/SKS() before|
//| using this function.                                             |
//+------------------------------------------------------------------+
void CAlglib::SparseSMV(CSparseMatrix &s,bool IsUpper,
                        CRowDouble &x,CRowDouble &y)
  {
   CSparse::SparseSMV(s,IsUpper,x,y);
  }
//+------------------------------------------------------------------+
//| This function calculates vector-matrix-vector product x'*S*x,    |
//| where S is symmetric matrix. Matrix S must be stored in CRS or   |
//| SKS format (exception will be thrown otherwise).                 |
//| INPUT PARAMETERS:                                                |
//|   S        -  sparse M*M matrix in CRS or SKS format.            |
//|   IsUpper  -  whether upper or lower triangle of S is given:     |
//|            * if upper triangle is given,  only   S[i,j] for j>=i |
//|              are used, and lower triangle is ignored (it can  be |
//|              empty - these elements are not referenced at all).  |
//|            * if lower triangle is given,  only   S[i,j] for j<=i |
//|              are used, and upper triangle is ignored.            |
//|   X        -  array[N], input vector. For performance reasons we |
//|              make only quick checks - we check that array size is|
//|              at least N, but we do not check for NAN's or INF's. |
//| RESULT                                                           |
//|   x'*S*x                                                         |
//| NOTE: this function throws exception when called for non-CRS/SKS |
//|       matrix.                                                    |
//| You must convert your matrix with SparseConvertToCRS/SKS() before|
//| using this function.                                             |
//+------------------------------------------------------------------+
double CAlglib::SparseVSMV(CSparseMatrix &s,bool IsUpper,CRowDouble &x)
  {
   return(CSparse::SparseVSMV(s,IsUpper,x));
  }
//+------------------------------------------------------------------+
//| This function calculates matrix-matrix product S*A. Matrix S must|
//| be stored in CRS or SKS format (exception will be thrown         |
//| otherwise).                                                      |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix in CRS or SKS format.               |
//|   A     -  array[N,K], input dense matrix. For performance       |
//|            reasons we make only quick checks - we check that     |
//|            array size is at least N, but we do not check for     |
//|            NAN's or INF's.                                       |
//|   K     -  number of columns of matrix (A).                      |
//|   B     -  output buffer, possibly preallocated. In case buffer  |
//|            size is too small to store result, this buffer is     |
//|            automatically resized.                                |
//| OUTPUT PARAMETERS:                                               |
//|   B     -  array[M,K], S*A                                       |
//| NOTE: this function throws exception when called for non-CRS/SKS |
//|       matrix.                                                    |
//| You must convert your matrix with SparseConvertToCRS/SKS() before|
//| using this function.                                             |
//+------------------------------------------------------------------+
void CAlglib::SparseMM(CSparseMatrix &s,CMatrixDouble &a,int k,
                       CMatrixDouble &b)
  {
   CSparse::SparseMM(s,a,k,b);
  }
//+------------------------------------------------------------------+
//| This function calculates matrix-matrix product S^T*A. Matrix S   |
//| must be stored in CRS or SKS format (exception will be thrown    |
//| otherwise).                                                      |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix in CRS or SKS format.               |
//|   A     -  array[M,K], input dense matrix. For performance       |
//|            reasons we make only quick checks - we check that     |
//|            array size is at least M, but we do not check for     |
//|            NAN's or INF's.                                       |
//|   K     -  number of columns of matrix (A).                      |
//|   B     -  output buffer, possibly preallocated. In case  buffer |
//|            size is too small to store  result,  this  buffer  is |
//|            automatically resized.                                |
//| OUTPUT PARAMETERS:                                               |
//|   B     -  array[N,K], S^T*A                                     |
//| NOTE: this function throws exception when called for non-CRS/SKS |
//| matrix.                                                          |
//| You must convert your matrix with SparseConvertToCRS/SKS() before|
//| using this function.                                             |
//+------------------------------------------------------------------+
void CAlglib::SparseMTM(CSparseMatrix &s,CMatrixDouble &a,int k,
                        CMatrixDouble &b)
  {
   CSparse::SparseMTM(s,a,k,b);
  }
//+------------------------------------------------------------------+
//| This function simultaneously calculates two matrix-matrix        |
//| products:                                                        |
//|                        S*A and S^T*A.                            |
//| S must be  square (non-rectangular) matrix stored in CRS or  SKS |
//| format (exception will be thrown otherwise).                     |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse N*N matrix in CRS or SKS format.               |
//|   A     -  array[N,K], input dense matrix. For performance       |
//|            reasons we make only quick checks - we check that     |
//|            array size is at least N, but we do not check for     |
//|            NAN's or INF's.                                       |
//|   K     -  number of columns of matrix (A).                      |
//|   B0    -  output buffer, possibly preallocated. In case  buffer |
//|            size is too small to store  result,  this  buffer  is |
//|            automatically resized.                                |
//|   B1    -  output buffer, possibly preallocated. In case  buffer |
//|            size is too small to store  result,  this  buffer  is |
//|            automatically resized.                                |
//| OUTPUT PARAMETERS:                                               |
//|   B0    -  array[N,K], S*A                                       |
//|   B1    -  array[N,K], S^T*A                                     |
//| NOTE: this function throws exception when called for non-CRS/SKS |
//|       matrix.                                                    |
//| You must convert your matrix with SparseConvertToCRS/SKS() before|
//| using this function.                                             |
//+------------------------------------------------------------------+
void CAlglib::SparseMM2(CSparseMatrix &s,CMatrixDouble &a,int k,
                        CMatrixDouble &b0,CMatrixDouble &b1)
  {
   CSparse::SparseMM2(s,a,k,b0,b1);
  }
//+------------------------------------------------------------------+
//| This function calculates matrix-matrix product S*A, when S is    |
//| symmetric matrix. Matrix S must be stored in CRS or SKS format   |
//| (exception  will  be thrown otherwise).                          |
//| INPUT PARAMETERS:                                                |
//|   S        -  sparse M*M matrix in CRS or SKS format.            |
//|   IsUpper  -  whether upper or lower triangle of S is given:     |
//|            * if upper triangle is given,  only   S[i,j] for j>=i |
//|              are used, and lower triangle is ignored (it can  be |
//|              empty - these elements are not referenced at all).  |
//|            * if lower triangle is given,  only   S[i,j] for j<=i |
//|              are used, and upper triangle is ignored.            |
//|   A        -  array[N,K], input dense matrix. For performance    |
//|               reasons we make only quick checks - we check that  |
//|               array size is at least N, but we do not check for  |
//|               NAN's or INF's.                                    |
//|   K        -  number of columns of matrix (A).                   |
//|   B        -  output buffer, possibly preallocated. In case      |
//|               buffer size is too small to store result, this     |
//|               buffer is automatically resized.                   |
//| OUTPUT PARAMETERS:                                               |
//|   B        -  array[M,K], S*A                                    |
//| NOTE: this function throws exception when called for non-CRS/SKS |
//|       matrix.                                                    |
//| You must convert your matrix with SparseConvertToCRS/SKS() before|
//| using this function.                                             |
//+------------------------------------------------------------------+
void CAlglib::SparseSMM(CSparseMatrix &s,bool IsUpper,
                        CMatrixDouble &a,int k,CMatrixDouble &b)
  {
   CSparse::SparseSMM(s,IsUpper,a,k,b);
  }
//+------------------------------------------------------------------+
//| This function calculates matrix-vector product op(S)*x, when x is|
//| vector, S is symmetric triangular matrix, op(S) is transposition |
//| or no operation.                                                 |
//| Matrix S must be stored in CRS or SKS format (exception will be  |
//| thrown otherwise).                                               |
//| INPUT PARAMETERS:                                                |
//|   S        -  sparse square matrix in CRS or SKS format.         |
//|   IsUpper  -  whether upper or lower triangle of S is used:      |
//|            * if upper triangle is given,  only   S[i,j] for  j>=i|
//|              are used, and lower triangle is  ignored (it can  be|
//|              empty - these elements are not referenced at all).  |
//|            * if lower triangle is given,  only   S[i,j] for  j<=i|
//|              are used, and upper triangle is ignored.            |
//|   IsUnit   -  unit or non-unit diagonal:                         |
//|            * if True, diagonal elements of triangular matrix are |
//|              considered equal to 1.0. Actual elements  stored  in|
//|              S are not referenced at all.                        |
//|            * if False, diagonal stored in S is used              |
//|   OpType   -  operation type:                                    |
//|            * if 0, S*x is calculated                             |
//|            * if 1, (S^T)*x is calculated (transposition)         |
//|   X        -  array[N] which stores input vector. For performance|
//|               reasons we make only quick checks - we check that  |
//|               array size is at least N, but we do not check for  |
//|               NAN's or INF's.                                    |
//|   Y        -  possibly preallocated input buffer. Automatically  |
//|               resized if its size is too small.                  |
//| OUTPUT PARAMETERS:                                               |
//|   Y        -  array[N], op(S)*x                                  |
//| NOTE: this function throws exception when called for non-CRS/SKS |
//|       matrix.                                                    |
//| You must convert your matrix with SparseConvertToCRS/SKS() before|
//| using this function.                                             |
//+------------------------------------------------------------------+
void CAlglib::SparseTRMV(CSparseMatrix &s,bool IsUpper,bool IsUnit,
                         int OpType,CRowDouble &x,CRowDouble &y)
  {
   CSparse::SparseTRMV(s,IsUpper,IsUnit,OpType,x,y);
  }
//+------------------------------------------------------------------+
//| This function solves linear system op(S)*y=x where x is vector, S|
//| is symmetric triangular matrix, op(S) is transposition or no     |
//| operation.                                                       |
//| Matrix S must be stored in CRS or SKS format (exception will be  |
//| thrown otherwise).                                               |
//| INPUT PARAMETERS:                                                |
//|   S        -  sparse square matrix in CRS or SKS format.         |
//|   IsUpper  -  whether upper or lower triangle of S is used:      |
//|            * if upper triangle is given, only S[i,j] for j>=i are|
//|              used, and lower triangle is ignored (it can be      |
//|              empty - these elements are not referenced at all).  |
//|            * if lower triangle is given, only S[i,j] for j<=i are|
//|              used, and upper triangle is ignored.                |
//|   IsUnit   -  unit or non-unit diagonal:                         |
//|            * if True, diagonal elements of triangular matrix are |
//|              considered equal to 1.0. Actual elements stored in S|
//|              are not referenced at all.                          |
//|            * if False, diagonal stored in S is used. It is your  |
//|             responsibility to make sure that diagonal is non-zero|
//|   OpType   -  operation type:                                    |
//|            * if 0, S*x is calculated                             |
//|            * if 1, (S^T)*x is calculated (transposition)         |
//|   X        -  array[N] which stores input vector. For performance|
//|               reasons we make only quick checks - we check that  |
//|               array size is at least N, but we do not check for  |
//|               NAN's or INF's.                                    |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], inv(op(S))*x                             |
//| NOTE: this function throws exception when called for non-CRS/SKS |
//|       matrix.                                                    |
//| You must convert your matrix with SparseConvertToCRS/SKS() before|
//| using this function.                                             |
//| NOTE: no assertion or tests are done during algorithm operation. |
//| It is your responsibility to provide invertible matrix to        |
//| algorithm.                                                       |
//+------------------------------------------------------------------+
void CAlglib::SparseTRSV(CSparseMatrix &s,bool IsUpper,bool IsUnit,
                         int OpType,CRowDouble &x)
  {
   CSparse::SparseTRSV(s,IsUpper,IsUnit,OpType,x);
  }
//+------------------------------------------------------------------+
//| This function applies permutation given by permutation table P   |
//| (as opposed to product form of permutation) to sparse symmetric  |
//| matrix  A,  given  by either upper or lower triangle: B := P*A*P'|
//| This function allocates completely new instance of B. Use        |
//| buffered version SparseSymmPermTblBuf() if you want to reuse     |
//| already allocated structure.                                     |
//| INPUT PARAMETERS:                                                |
//|   A        -  sparse square matrix in CRS format.                |
//|   IsUpper  -  whether upper or lower triangle of A is used:      |
//|            * if upper triangle is given,  only   A[i,j] for  j>=i|
//|              are used, and lower triangle is  ignored (it can  be|
//|              empty - these elements are not referenced at all).  |
//|            * if lower triangle is given,  only   A[i,j] for  j<=i|
//|              are used, and upper triangle is ignored.            |
//|   P        -  array[N] which stores permutation table; P[I]=J    |
//|               means that I-th row/column of matrix A is moved to |
//|               J-th position. For performance reasons we do NOT   |
//|               check that P[] is a correct permutation (that there|
//|               is no repetitions, just that all its elements are  |
//|               in [0,N) range.                                    |
//| OUTPUT PARAMETERS:                                               |
//|   B        -  permuted matrix. Permutation is applied to A from  |
//|               the both sides, only upper or lower triangle       |
//|               (depending on IsUpper) is stored.                  |
//| NOTE: this function throws exception when called for non-CRS     |
//| matrix. You must convert your matrix with SparseConvertToCRS()   |
//| before using this function.                                      |
//+------------------------------------------------------------------+
void CAlglib::SparseSymmPermTbl(CSparseMatrix &a,bool IsUpper,
                                CRowInt &p,CSparseMatrix &b)
  {
   CSparse::SparseSymmPermTbl(a,IsUpper,p,b);
  }
//+------------------------------------------------------------------+
//| This function is a buffered version of SparseSymmPermTbl() that  |
//| reuses previously allocated storage in B as much as possible.    |
//| This function applies permutation given by permutation table P   |
//| (as opposed to product form of permutation) to sparse symmetric  |
//| matrix A, given by either upper or lower triangle: B := P*A*P'.  |
//| INPUT PARAMETERS:                                                |
//|   A        -  sparse square matrix in CRS format.                |
//|   IsUpper  -  whether upper or lower triangle of A is used:      |
//|            * if upper triangle is given,  only   A[i,j] for  j>=i|
//|              are used, and lower triangle is  ignored (it can  be|
//|              empty - these elements are not referenced at all).  |
//|            * if lower triangle is given,  only   A[i,j] for  j<=i|
//|               are used, and upper triangle is ignored.           |
//|   P        -  array[N] which stores permutation table; P[I]=J    |
//|               means that I-th row/column of matrix A is moved to |
//|               J-th position. For performance reasons we do NOT   |
//|               check that P[] is a correct permutation (that there|
//|               is no repetitions, just that all its elements are  |
//|               in [0,N) range.                                    |
//|   B        -  sparse matrix object that will hold output.        |
//|               Previously allocated memory will be reused as much |
//|               as possible.                                       |
//| OUTPUT PARAMETERS:                                               |
//|   B        -  permuted matrix. Permutation is applied to A from  |
//|               the both sides, only upper or lower triangle       |
//|               (depending on IsUpper) is stored.                  |
//| NOTE: this function throws exception when called for non-CRS     |
//| matrix. You must convert your matrix with SparseConvertToCRS()   |
//| before using this function.                                      |
//+------------------------------------------------------------------+
void CAlglib::SparseSymmPermTblBuf(CSparseMatrix &a,bool IsUpper,
                                   CRowInt &p,CSparseMatrix &b)
  {
   CSparse::SparseSymmPermTblBuf(a,IsUpper,p,b);
  }
//+------------------------------------------------------------------+
//| This procedure resizes Hash-Table matrix. It can be called when  |
//| you have deleted too many elements from the matrix, and you want |
//| to free unneeded memory.                                         |
//+------------------------------------------------------------------+
void CAlglib::SparseResizeMatrix(CSparseMatrix &s)
  {
   CSparse::SparseResizeMatrix(s);
  }
//+------------------------------------------------------------------+
//| This function is used to enumerate all elements of the sparse    |
//| matrix. Before first call user initializes T0 and T1 counters by |
//| zero. These counters are used to remember current position in a  |
//| matrix; after each call they are updated by the function.        |
//| Subsequent calls to this function return non-zero elements of the|
//| sparse matrix, one by one. If you enumerate CRS matrix, matrix is|
//| traversed from left to right, from top to bottom. In case you    |
//| enumerate matrix stored as Hash table, elements are returned in  |
//| random order.                                                    |
//| EXAMPLE                                                          |
//|   > T0=0                                                         |
//|   > T1=0                                                         |
//|   > while SparseEnumerate(S,T0,T1,I,J,V) do                      |
//|   >     ....do something with I,J,V                              |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix in Hash-Table or CRS representation.|
//|   T0    -  internal counter                                      |
//|   T1    -  internal counter                                      |
//| OUTPUT PARAMETERS:                                               |
//|   T0    -  new value of the internal counter                     |
//|   T1    -  new value of the internal counter                     |
//|   I     -  row index of non-zero element, 0<=I<M.                |
//|   J     -  column index of non-zero element, 0<=J<N              |
//|   V     -  value of the T-th element                             |
//| RESULT                                                           |
//|   True in case of success (next non-zero element was retrieved)  |
//|   False in case all non-zero elements were enumerated            |
//| NOTE: you may call SparseRewriteExisting() during enumeration,   |
//|       but it is THE ONLY matrix modification function you can    |
//|       call!!! Other matrix modification functions should not be  |
//|       called during enumeration!                                 |
//+------------------------------------------------------------------+
bool CAlglib::SparseEnumerate(CSparseMatrix &s,int &t0,int &t1,
                              int &i,int &j,double &v)
  {
   return(CSparse::SparseEnumerate(s,t0,t1,i,j,v));
  }
//+------------------------------------------------------------------+
//| This function rewrites existing (non-zero) element. It returns   |
//| True if element exists or False, when it is called for           |
//| non-existing (zero) element.                                     |
//| This function works with any kind of the matrix.                 |
//| The purpose of this function is to provide convenient thread-safe|
//| way to modify sparse matrix. Such modification (already existing |
//| element is rewritten) is guaranteed to be thread-safe without any|
//| synchronization, as long as different threads modify different   |
//| elements.                                                        |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix in any kind of representation (Hash,|
//|            SKS, CRS).                                            |
//|   I     -  row index of non-zero element to modify, 0<=I<M       |
//|   J     -  column index of non-zero element to modify, 0<=J<N    |
//|   V     -  value to rewrite, must be finite number               |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  modified matrix                                       |
//| RESULT                                                           |
//|   True in case when element exists                               |
//|   False in case when element doesn't exist or it is zero         |
//+------------------------------------------------------------------+
bool CAlglib::SparseRewriteExisting(CSparseMatrix &s,int i,
                                    int j,double v)
  {
   return(CSparse::SparseRewriteExisting(s,i,j,v));
  }
//+------------------------------------------------------------------+
//| This function returns I-th row of the sparse matrix. Matrix must |
//| be stored in CRS or SKS format.                                  |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix in CRS format                       |
//|   I     -  row index, 0<=I<M                                     |
//|   IRow  -  output buffer, can be  preallocated.  In  case  buffer|
//|            size  is  too  small  to  store  I-th   row,   it   is|
//|            automatically reallocated.                            |
//| OUTPUT PARAMETERS:                                               |
//|   IRow  -  array[M], I-th row.                                   |
//| NOTE: this function has O(N) running time, where N is a column   |
//|      count. It allocates and fills N-element array, even although|
//|      most of its elemets are zero.                               |
//| NOTE: If you have O(non-zeros-per-row) time and memory           |
//|      requirements, use SparseGetCompressedRow() function. It     |
//|      returns data in compressed format.                          |
//| NOTE: when incorrect I (outside of [0,M-1]) or matrix (non       |
//|      CRS/SKS) is passed, this function throws exception.         |
//+------------------------------------------------------------------+
void CAlglib::SparseGetRow(CSparseMatrix &s,int i,CRowDouble &irow)
  {
   CSparse::SparseGetRow(s,i,irow);
  }
//+------------------------------------------------------------------+
//| This function returns I-th row of the sparse matrix IN COMPRESSED|
//| FORMAT - only non-zero elements are returned (with their indexes)|
//| Matrix must be stored in CRS or SKS format.                      |
//| INPUT PARAMETERS:                                                |
//|   S        -  sparse M*N matrix in CRS format                    |
//|   I        -  row index, 0<=I<M                                  |
//|   ColIdx   -  output buffer for column indexes, can be           |
//|               preallocated. In case buffer size is too small to  |
//|               store I-th row, it is automatically reallocated.   |
//|   Vals     -  output buffer for values, can be preallocated. In  |
//|               case buffer size is too small to store I-th row, it|
//|               is automatically reallocated.                      |
//| OUTPUT PARAMETERS:                                               |
//|   ColIdx   -  column indexes of non-zero elements, sorted by     |
//|               ascending. Symbolically non-zero elements are      |
//|               counted (i.e. if you allocated place for element,  |
//|               but it has zero numerical value - it is counted).  |
//|   Vals     -  values. Vals[K] stores value of matrix element with|
//|               indexes (I,ColIdx[K]). Symbolically non-zero       |
//|               elements are counted (i.e. if you allocated place  |
//|               for element, but it has zero numerical value - it  |
//|               is counted).                                       |
//|   NZCnt    -  number of symbolically non-zero elements per row.  |
//| NOTE: when incorrect I (outside of [0,M-1]) or matrix (non       |
//|      CRS/SKS) is passed, this function throws exception.         |
//| NOTE: this function may allocate additional, unnecessary place   |
//|      for ColIdx and Vals arrays. It is dictated by performance   |
//|      reasons - on SKS matrices it is faster to allocate space at |
//|      the beginning with some "extra"-space, than performing two  |
//|      passes over matrix - first time to calculate exact space    |
//|      required for data, second time - to store data itself.      |
//+------------------------------------------------------------------+
void CAlglib::SparseGetCompressedRow(CSparseMatrix &s,int i,
                                     CRowInt &colidx,CRowDouble &vals,
                                     int &nzcnt)
  {
   CSparse::SparseGetCompressedRow(s,i,colidx,vals,nzcnt);
  }
//+------------------------------------------------------------------+
//| This function performs efficient in-place transpose of SKS matrix|
//| No additional memory is allocated during transposition.          |
//| This function supports only skyline storage format (SKS).        |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse matrix in SKS format.                          |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  sparse matrix, transposed.                            |
//+------------------------------------------------------------------+
void CAlglib::SparseTransposeSKS(CSparseMatrix &s)
  {
   CSparse::SparseTransposeSKS(s);
  }
//+------------------------------------------------------------------+
//| This function performs transpose of CRS matrix.                  |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse matrix in CRS format.                          |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  sparse matrix, transposed.                            |
//| NOTE: internal temporary copy is allocated for the purposes of   |
//|      transposition. It is deallocated after transposition.       |
//+------------------------------------------------------------------+
void CAlglib::SparseTransposeCRS(CSparseMatrix &s)
  {
   CSparse::SparseTransposeCRS(s);
  }
//+------------------------------------------------------------------+
//| This function performs copying with transposition of CRS matrix. |
//| INPUT PARAMETERS:                                                |
//|   S0    -  sparse matrix in CRS format.                          |
//| OUTPUT PARAMETERS:                                               |
//|   S1    -  sparse matrix, transposed                             |
//+------------------------------------------------------------------+
void CAlglib::SparseCopyTransposeCRS(CSparseMatrix &s0,CSparseMatrix &s1)
  {
   CSparse::SparseCopyTransposeCRS(s0,s1);
  }
//+------------------------------------------------------------------+
//| This function performs copying with transposition of CRS matrix  |
//| (buffered version which reuses memory already allocated by the   |
//| target as much as possible).                                     |
//| INPUT PARAMETERS:                                                |
//|   S0    -  sparse matrix in CRS format.                          |
//| OUTPUT PARAMETERS:                                               |
//|   S1    -  sparse matrix, transposed; previously allocated memory|
//|            is reused if possible.                                |
//+------------------------------------------------------------------+
void CAlglib::SparseCopyTransposeCRSBuf(CSparseMatrix &s0,CSparseMatrix &s1)
  {
   CSparse::SparseCopyTransposeCRSBuf(s0,s1);
  }
//+------------------------------------------------------------------+
//| This function performs in-place conversion to desired sparse     |
//| storage format.                                                  |
//| INPUT PARAMETERS:                                                |
//|   S0    -  sparse matrix in any format.                          |
//|   Fmt   -  desired storage format of the output, as returned by  |
//|            SparseGetMatrixType() function:                       |
//|         * 0 for hash-based storage                               |
//|         * 1 for CRS                                              |
//|         * 2 for SKS                                              |
//| OUTPUT PARAMETERS:                                               |
//|   S0    -  sparse matrix in requested format.                    |
//| NOTE: in-place conversion wastes a lot of memory which is  used  |
//|      to store temporaries. If you perform a lot of repeated      |
//|      conversions, we recommend to use out-of-place buffered      |
//|      conversion functions, like SparseCopyToBuf(), which can     |
//|      reuse already allocated memory.                             |
//+------------------------------------------------------------------+
void CAlglib::SparseConvertTo(CSparseMatrix &s0,int fmt)
  {
   CSparse::SparseConvertTo(s0,fmt);
  }
//+------------------------------------------------------------------+
//| This function performs out-of-place conversion to desired sparse |
//| storage format. S0 is copied to S1 and converted on-the-fly.     |
//| Memory  allocated  in S1 is reused to maximum extent possible.   |
//| INPUT PARAMETERS:                                                |
//|   S0    -  sparse matrix in any format.                          |
//|   Fmt   -  desired storage format of the output, as returned by  |
//|            SparseGetMatrixType() function:                       |
//|         * 0 for hash-based storage                               |
//|         * 1 for CRS                                              |
//|         * 2 for SKS                                              |
//| OUTPUT PARAMETERS:                                               |
//|   S1    -  sparse matrix in requested format.                    |
//+------------------------------------------------------------------+
void CAlglib::SparseCopyToBuf(CSparseMatrix &s0,int fmt,CSparseMatrix &s1)
  {
   CSparse::SparseCopyToBuf(s0,fmt,s1);
  }
//+------------------------------------------------------------------+
//| This function performs in-place conversion to Hash table storage.|
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse matrix in CRS format.                          |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  sparse matrix in Hash table format.                   |
//| NOTE: this function has no effect when called with matrix which  |
//|      is already in Hash table mode.                              |
//| NOTE: in-place conversion involves allocation of temporary arrays|
//|      If you perform a lot of repeated in-place conversions, it   |
//|      may lead to memory fragmentation. Consider using            |
//|      out-of-place SparseCopyToHashBuf() function in this case.   |
//+------------------------------------------------------------------+
void CAlglib::SparseConvertToHash(CSparseMatrix &s)
  {
   CSparse::SparseConvertToHash(s);
  }
//+------------------------------------------------------------------+
//| This function performs out-of-place conversion to Hash table     |
//| storage format. S0 is copied to S1 and converted on-the-fly.     |
//| INPUT PARAMETERS:                                                |
//|   S0    -  sparse matrix in any format.                          |
//| OUTPUT PARAMETERS:                                               |
//|   S1    -  sparse matrix in Hash table format.                   |
//| NOTE: if S0 is stored as Hash-table, it is just copied without   |
//|      conversion.                                                 |
//| NOTE: this function de-allocates memory occupied by S1 before    |
//|      starting conversion. If you perform a lot of repeated       |
//|      conversions, it may lead to memory fragmentation. In this   |
//|      case we recommend you to use SparseCopyToHashBuf() function |
//|      which re-uses memory in S1 as much as possible.             |
//+------------------------------------------------------------------+
void CAlglib::SparseCopyToHash(CSparseMatrix &s0,CSparseMatrix &s1)
  {
   CSparse::SparseCopyToHash(s0,s1);
  }
//+------------------------------------------------------------------+
//| This function performs out-of-place conversion to Hash table     |
//| storage format. S0 is copied to S1 and converted on-the-fly.     |
//| Memory allocated in S1 is reused to maximum extent possible.     |
//| INPUT PARAMETERS:                                                |
//|   S0    -  sparse matrix in any format.                          |
//| OUTPUT PARAMETERS:                                               |
//|   S1    -  sparse matrix in Hash table format.                   |
//| NOTE: if S0 is stored as Hash-table, it is just copied without   |
//|      conversion.                                                 |
//+------------------------------------------------------------------+
void CAlglib::SparseCopyToHashBuf(CSparseMatrix &s0,CSparseMatrix &s1)
  {
   CSparse::SparseCopyToHashBuf(s0,s1);
  }
//+------------------------------------------------------------------+
//| This function converts matrix to CRS format.                     |
//| Some algorithms (linear algebra ones, for example) require       |
//| matrices in CRS format. This function allows to perform in-place |
//| conversion.                                                      |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse M*N matrix in any format                       |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  matrix in CRS format                                  |
//| NOTE: this function has no effect when called with matrix which  |
//|      is already in CRS mode.                                     |
//| NOTE: this function allocates temporary memory to store a copy of|
//|      the matrix. If you perform a lot of repeated conversions, we|
//|      recommend you to use SparseCopyToCRSBuf() function, which   |
//|      can reuse previously allocated memory.                      |
//+------------------------------------------------------------------+
void CAlglib::SparseConvertToCRS(CSparseMatrix &s)
  {
   CSparse::SparseConvertToCRS(s);
  }
//+------------------------------------------------------------------+
//| This function performs out-of-place conversion to CRS format. S0 |
//| is copied to S1 and converted on-the-fly.                        |
//| INPUT PARAMETERS:                                                |
//|   S0    -  sparse matrix in any format.                          |
//| OUTPUT PARAMETERS:                                               |
//|   S1    -  sparse matrix in CRS format.                          |
//| NOTE: if S0 is stored as CRS, it is just copied without          |
//|      conversion.                                                 |
//| NOTE: this function de-allocates memory occupied by S1 before    |
//|      starting CRS conversion. If you perform a lot of repeated   |
//|      CRS conversions, it may lead to memory fragmentation. In    |
//|      this case we recommend you to use SparseCopyToCRSBuf()      |
//|      function which re-uses memory in S1 as much as possible.    |
//+------------------------------------------------------------------+
void CAlglib::SparseCopyToCRS(CSparseMatrix &s0,CSparseMatrix &s1)
  {
   CSparse::SparseCopyToCRS(s0,s1);
  }
//+------------------------------------------------------------------+
//| This function performs out-of-place conversion to CRS format. S0 |
//| is copied to S1 and converted on-the-fly. Memory allocated in S1 |
//| is reused to maximum extent possible.                            |
//| INPUT PARAMETERS:                                                |
//|   S0    -  sparse matrix in any format.                          |
//|   S1    -  matrix which may contain some pre-allocated memory, or|
//|            can be just uninitialized structure.                  |
//| OUTPUT PARAMETERS:                                               |
//|   S1    -  sparse matrix in CRS format.                          |
//| NOTE: if S0 is stored as CRS, it is just copied without          |
//|      conversion.                                                 |
//+------------------------------------------------------------------+
void CAlglib::SparseCopyToCRSBuf(CSparseMatrix &s0,CSparseMatrix &s1)
  {
   CSparse::SparseCopyToCRSBuf(s0,s1);
  }
//+------------------------------------------------------------------+
//| This function performs in-place conversion to SKS format.        |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse matrix in any format.                          |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  sparse matrix in SKS format.                          |
//| NOTE: this function has no effect when called with matrix which  |
//|      is already in SKS mode.                                     |
//| NOTE: in-place conversion involves allocation of temporary arrays|
//|     If you perform a lot of repeated in-place conversions, it may|
//|     lead to memory fragmentation. Consider using out-of-place    |
//|     SparseCopyToSKSBuf() function in this case.                  |
//+------------------------------------------------------------------+
void CAlglib::SparseConvertToSKS(CSparseMatrix &s)
  {
   CSparse::SparseConvertToSKS(s);
  }
//+------------------------------------------------------------------+
//| This function performs out-of-place conversion to SKS storage    |
//| format. S0 is copied to S1 and converted on-the-fly.             |
//| INPUT PARAMETERS:                                                |
//|   S0    -  sparse matrix in any format.                          |
//| OUTPUT PARAMETERS:                                               |
//|   S1    -  sparse matrix in SKS format.                          |
//| NOTE: if S0 is stored as SKS, it is just copied without          |
//|      conversion.                                                 |
//| NOTE: this function de-allocates memory occupied by S1 before    |
//|      starting conversion. If you perform a lot of repeated       |
//|      conversions, it may lead to memory fragmentation. In this   |
//|      case we recommend you to use SparseCopyToSKSBuf() function  |
//|      which re-uses memory in S1 as much as possible.             |
//+------------------------------------------------------------------+
void CAlglib::SparseCopyToSKS(CSparseMatrix &s0,CSparseMatrix &s1)
  {
   CSparse::SparseCopyToSKS(s0,s1);
  }
//+------------------------------------------------------------------+
//| This function performs out-of-place conversion to SKS format. S0 |
//| is copied to S1 and converted on-the-fly. Memory allocated in S1 |
//| is reused to maximum extent possible.                            |
//| INPUT PARAMETERS:                                                |
//|   S0    -  sparse matrix in any format.                          |
//| OUTPUT PARAMETERS:                                               |
//|   S1    -  sparse matrix in SKS format.                          |
//| NOTE: if S0 is stored as SKS, it is just copied without          |
//|      conversion.                                                 |
//+------------------------------------------------------------------+
void CAlglib::SparseCopyToSKSBuf(CSparseMatrix &s0,CSparseMatrix &s1)
  {
   CSparse::SparseCopyToSKSBuf(s0,s1);
  }
//+------------------------------------------------------------------+
//| This function returns type of the matrix storage format.         |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse matrix.                                        |
//| RESULT:                                                          |
//|   sparse storage format used by matrix:                          |
//|   0     -  Hash-table                                            |
//|   1     -  CRS (compressed row storage)                          |
//|   2     -  SKS (skyline)                                         |
//| NOTE: future versions of ALGLIB may include additional sparse    |
//|      storage formats.                                            |
//+------------------------------------------------------------------+
int CAlglib::SparseGetMatrixType(CSparseMatrix &s)
  {
   return(CSparse::SparseGetMatrixType(s));
  }
//+------------------------------------------------------------------+
//| This function checks matrix storage format and returns True when |
//| matrix is stored using Hash table representation.                |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse matrix.                                        |
//| RESULT:                                                          |
//|   True if matrix type is Hash table                              |
//|   False if matrix type is not Hash table                         |
//+------------------------------------------------------------------+
bool CAlglib::SparseIsHash(CSparseMatrix &s)
  {
   return(CSparse::SparseIsHash(s));
  }
//+------------------------------------------------------------------+
//| This function checks matrix storage format and returns True when |
//| matrix is stored using CRS representation.                       |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse matrix.                                        |
//| RESULT:                                                          |
//|   True if matrix type is CRS                                     |
//|   False if matrix type is not CRS                                |
//+------------------------------------------------------------------+
bool CAlglib::SparseIsCRS(CSparseMatrix &s)
  {
   return(CSparse::SparseIsCRS(s));
  }
//+------------------------------------------------------------------+
//| This function checks matrix storage format and returns True when |
//| matrix is stored using SKS representation.                       |
//| INPUT PARAMETERS:                                                |
//|   S     -  sparse matrix.                                        |
//| RESULT:                                                          |
//|   True if matrix type is SKS                                     |
//|   False if matrix type is not SKS                                |
//+------------------------------------------------------------------+
bool CAlglib::SparseIsSKS(CSparseMatrix &s)
  {
   return(CSparse::SparseIsSKS(s));
  }
//+------------------------------------------------------------------+
//| The function frees all memory occupied by sparse matrix. Sparse  |
//| matrix structure becomes unusable after this call.               |
//| OUTPUT PARAMETERS:                                               |
//|   S     -  sparse matrix to delete                               |
//+------------------------------------------------------------------+
void CAlglib::SparseFree(CSparseMatrix &s)
  {
   CSparse::SparseFree(s);
  }
//+------------------------------------------------------------------+
//| The function returns number of rows of a sparse matrix.          |
//| RESULT: number of rows of a sparse matrix.                       |
//+------------------------------------------------------------------+
int CAlglib::SparseGetNRows(CSparseMatrix &s)
  {
   return(CSparse::SparseGetNRows(s));
  }
//+------------------------------------------------------------------+
//| The function returns number of columns of a sparse matrix.       |
//| RESULT: number of columns of a sparse matrix.                    |
//+------------------------------------------------------------------+
int CAlglib::SparseGetNCols(CSparseMatrix &s)
  {
   return(CSparse::SparseGetNCols(s));
  }
//+------------------------------------------------------------------+
//| The function returns number of strictly upper triangular non-zero|
//| elements in the matrix. It counts SYMBOLICALLY non-zero elements,|
//| i.e. entries in the sparse matrix data structure. If some element|
//| has zero numerical value, it is still counted.                   |
//| This function has different cost for different types of matrices:|
//|   * for hash-based matrices it involves complete pass over entire|
//|     hash-table with O(NNZ) cost, where NNZ is number of non-zero |
//|     elements                                                     |
//|   * for CRS and SKS matrix types cost of counting is O(N)        |
//|     (N - matrix size).                                           |
//| RESULT: number of non-zero elements strictly above main diagonal |
//+------------------------------------------------------------------+
int CAlglib::SparseGetUpperCount(CSparseMatrix &s)
  {
   return(CSparse::SparseGetUpperCount(s));
  }
//+------------------------------------------------------------------+
//| The function returns number of strictly lower triangular non-zero|
//| elements in the matrix. It counts SYMBOLICALLY non-zero elements,|
//| i.e. entries in the sparse matrix data structure. If some element|
//| has zero numerical value, it is still counted.                   |
//| This function has different cost for different types of matrices:|
//|   * for hash-based matrices it involves complete pass over entire|
//|     hash-table with O(NNZ) cost, where NNZ is number of non-zero |
//|     elements                                                     |
//|   * for CRS and SKS matrix types cost of counting is O(N)        |
//|     (N - matrix size).                                           |
//| RESULT: number of non-zero elements strictly below main diagonal |
//+------------------------------------------------------------------+
int CAlglib::SparseGetLowerCount(CSparseMatrix &s)
  {
   return(CSparse::SparseGetLowerCount(s));
  }
//+------------------------------------------------------------------+
//| LU decomposition of a general real matrix with row pivoting      |
//| A is represented as A = P*L*U, where:                            |
//| * L is lower unitriangular matrix                                |
//| * U is upper triangular matrix                                   |
//| * P = P0*P1*...*PK, K=min(M,N)-1,                                |
//|   Pi - permutation matrix for I and Pivots[I]                    |
//| This is cache-oblivous implementation of LU decomposition.       |
//| It is optimized for square matrices. As for rectangular matrices:|
//| * best case - M>>N                                               |
//| * worst case - N>>M, small M, large N, matrix does not fit in CPU|
//|   cache                                                          |
//| INPUT PARAMETERS:                                                |
//|     A       -   array[0..M-1, 0..N-1].                           |
//|     M       -   number of rows in matrix A.                      |
//|     N       -   number of columns in matrix A.                   |
//| OUTPUT PARAMETERS:                                               |
//|     A       -   matrices L and U in compact form:                |
//|                 * L is stored under main diagonal                |
//|                 * U is stored on and above main diagonal         |
//|     Pivots  -   permutation matrix in compact form.              |
//|                 array[0..Min(M-1,N-1)].                          |
//+------------------------------------------------------------------+
void CAlglib::RMatrixLU(CMatrixDouble &a,const int m,const int n,
                        int &pivots[])
  {
   CTrFac::RMatrixLU(a,m,n,pivots);
  }
//+------------------------------------------------------------------+
//| LU decomposition of a general complex matrix with row pivoting   |
//| A is represented as A = P*L*U, where:                            |
//| * L is lower unitriangular matrix                                |
//| * U is upper triangular matrix                                   |
//| * P = P0*P1*...*PK, K=min(M,N)-1,                                |
//|   Pi - permutation matrix for I and Pivots[I]                    |
//| This is cache-oblivous implementation of LU decomposition. It is |
//| optimized for square matrices. As for rectangular matrices:      |
//| * best case - M>>N                                               |
//| * worst case - N>>M, small M, large N, matrix does not fit in CPU|
//| cache                                                            |
//| INPUT PARAMETERS:                                                |
//|     A       -   array[0..M-1, 0..N-1].                           |
//|     M       -   number of rows in matrix A.                      |
//|     N       -   number of columns in matrix A.                   |
//| OUTPUT PARAMETERS:                                               |
//|     A       -   matrices L and U in compact form:                |
//|                 * L is stored under main diagonal                |
//|                 * U is stored on and above main diagonal         |
//|     Pivots  -   permutation matrix in compact form.              |
//|                 array[0..Min(M-1,N-1)].                          |
//+------------------------------------------------------------------+
void CAlglib::CMatrixLU(CMatrixComplex &a,const int m,const int n,
                        int &pivots[])
  {
   CTrFac::CMatrixLU(a,m,n,pivots);
  }
//+------------------------------------------------------------------+
//| Cache-oblivious Cholesky decomposition                           |
//| The algorithm computes Cholesky decomposition of a Hermitian     |
//| positive - definite matrix. The result of an algorithm is a      |
//| representation of A as A=U'*U or A=L*L' (here X' detones         |
//| conj(X^T)).                                                      |
//| INPUT PARAMETERS:                                                |
//|     A       -   upper or lower triangle of a factorized matrix.  |
//|                 array with elements [0..N-1, 0..N-1].            |
//|     N       -   size of matrix A.                                |
//|     IsUpper -   if IsUpper=True, then A contains an upper        |
//|                 triangle of a symmetric matrix, otherwise A      |
//|                 contains a lower one.                            |
//| OUTPUT PARAMETERS:                                               |
//|     A       -   the result of factorization. If IsUpper=True,    |
//|                 then the upper triangle contains matrix U, so    |
//|                 that A = U'*U, and the elements below the main   |
//|                 diagonal are not modified. Similarly, if         |
//|                 IsUpper = False.                                 |
//| RESULT:                                                          |
//|     If the matrix is positive-definite, the function returns     |
//|     True. Otherwise, the function returns False. Contents of A is|
//|     not determined in such case.                                 |
//+------------------------------------------------------------------+
bool CAlglib::HPDMatrixCholesky(CMatrixComplex &a,const int n,
                                const bool IsUpper)
  {
   return(CTrFac::HPDMatrixCholesky(a,n,IsUpper));
  }
//+------------------------------------------------------------------+
//| Cache-oblivious Cholesky decomposition                           |
//| The algorithm computes Cholesky decomposition of a symmetric     |
//| positive - definite matrix. The result of an algorithm is a      |
//| representation of A as A=U^T*U  or A=L*L^T                       |
//| INPUT PARAMETERS:                                                |
//|     A       -   upper or lower triangle of a factorized matrix.  |
//|                 array with elements [0..N-1, 0..N-1].            |
//|     N       -   size of matrix A.                                |
//|     IsUpper -   if IsUpper=True, then A contains an upper        |
//|                 triangle of a symmetric matrix, otherwise A      |
//|                 contains a lower one.                            |
//| OUTPUT PARAMETERS:                                               |
//|     A       -   the result of factorization. If IsUpper=True,    |
//|                 then the upper triangle contains matrix U, so    |
//|                 that A = U^T*U, and the elements below the main  |
//|                 diagonal are not modified. Similarly, if         |
//|                 IsUpper = False.                                 |
//| RESULT:                                                          |
//|     If the matrix is positive-definite, the function returns     |
//|     True. Otherwise, the function returns False. Contents of A is|
//|     not determined in such case.                                 |
//+------------------------------------------------------------------+
bool CAlglib::SPDMatrixCholesky(CMatrixDouble &a,const int n,
                                const bool IsUpper)
  {
   return(CTrFac::SPDMatrixCholesky(a,n,IsUpper));
  }
//+------------------------------------------------------------------+
//| Update of Cholesky decomposition: rank-1 update to original A.   |
//| "Buffered" version which uses preallocated buffer which is saved |
//| between subsequent function calls.                               |
//| This function uses internally allocated buffer which is not saved|
//| between subsequent calls. So, if you perform a lot of subsequent |
//| updates, we recommend you to use "buffered" version of this      |
//| function: SPDMatrixCholeskyUpdateAdd1Buf().                      |
//| INPUT PARAMETERS:                                                |
//|   A        -  upper or lower Cholesky factor. array with elements|
//|               [0..N-1, 0..N-1]. Exception is thrown if array size|
//|               is too small.                                      |
//|   N        -  size of matrix A, N>0                              |
//|   IsUpper  -  if IsUpper=True, then A contains upper Cholesky    |
//|               factor; otherwise A contains a lower one.          |
//|   U        -  array[N], rank-1 update to A: A_mod = A + u*u'     |
//|               Exception is thrown if array size is too small.    |
//|   BufR     -  possibly preallocated buffer; automatically resized|
//|               if needed. It is recommended to reuse this buffer  |
//|               if you perform a lot of subsequent decompositions. |
//| OUTPUT PARAMETERS:                                               |
//|   A        -  updated factorization. If IsUpper=True, then the   |
//|               upper triangle contains matrix U, and the elements |
//|               below the main diagonal are not modified. Similarly|
//|               if IsUpper = False.                                |
//| NOTE: this function always succeeds, so it does not return       |
//|       completion code                                            |
//| NOTE: this function checks sizes of input arrays, but it does NOT|
//|       checks for presence of infinities or NAN's.                |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixCholeskyUpdateAdd1(CMatrixDouble &a,int n,
                                          bool IsUpper,CRowDouble &u)
  {
   CTrFac::SPDMatrixCholeskyUpdateAdd1(a,n,IsUpper,u);
  }
//+------------------------------------------------------------------+
//| Update of Cholesky decomposition: "fixing" some variables.       |
//| This function uses internally allocated buffer which is not saved|
//| between subsequent calls. So, if you perform a lot of subsequent |
//| updates, we recommend you to use "buffered" version of this      |
//| function: SPDMatrixCholeskyUpdateFixBuf().                       |
//| "FIXING" EXPLAINED:                                              |
//|   Suppose we have N*N positive definite matrix A. "Fixing" some  |
//|   variable means filling corresponding row/column of A by zeros, |
//|   and setting diagonal element to 1.                             |
//|   For example, if we fix 2nd variable in 4 * 4 matrix A, it      |
//|   becomes Af:                                                    |
//|         (A00  A01  A02  A03)       (Af00  0   Af02 Af03)         |
//|         (A10  A11  A12  A13)       ( 0    1    0    0  )         |
//|         (A20  A21  A22  A23)  =>   (Af20  0   Af22 Af23)         |
//|         (A30  A31  A32  A33)       (Af30  0   Af32 Af33)         |
//|   If we have Cholesky decomposition of A, it must be recalculated|
//|   after variables were fixed. However, it is possible to use     |
//|   efficient algorithm, which needs O(K*N^2) time to "fix" K  |
//|   variables, given Cholesky decomposition of original, "unfixed" |
//|   A.                                                             |
//| INPUT PARAMETERS:                                                |
//|   A        -  upper or lower Cholesky factor. Array with elements|
//|               [0..N - 1, 0..N - 1]. Exception is thrown if array |
//|               size is too small.                                 |
//|   N        -  size of matrix A, N > 0                            |
//|   IsUpper  -  if IsUpper = True, then A contains upper Cholesky  |
//|               factor; otherwise A contains a lower one.          |
//|   Fix      -  array[N], I-th element is True if I-th variable    |
//|               must be fixed. Exception is thrown if array size is|
//|               too small.                                         |
//|   BufR     -  possibly preallocated buffer; automatically resized|
//|               if needed. It is recommended to reuse this buffer  |
//|               if you perform a lot of subsequent decompositions. |
//| OUTPUT PARAMETERS:                                               |
//|   A        -  updated factorization. If IsUpper=True, then the   |
//|               upper triangle contains matrix U, and the elements |
//|               below the main diagonal are not modified.          |
//|               Similarly, if IsUpper=False.                       |
//| NOTE: this function always succeeds, so it does not return       |
//|       completion code                                            |
//| NOTE: this function checks sizes of input arrays, but it does NOT|
//|       checks for presence of infinities or NAN's.                |
//| NOTE: this function is efficient only for moderate amount of     |
//|       updated variables - say, 0.1*N or 0.3*N. For larger amount |
//|       of variables it will still work, but you may get better    |
//|       performance with straightforward Cholesky.                 |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixCholeskyUpdateFix(CMatrixDouble &a,int n,
                                         bool IsUpper,bool &fix[])
  {
   CTrFac::SPDMatrixCholeskyUpdateFix(a,n,IsUpper,fix);
  }
//+------------------------------------------------------------------+
//| Update of Cholesky decomposition: rank - 1 update to original A. |
//| "Buffered" version which uses preallocated buffer which is saved |
//| between subsequent function calls.                               |
//| See comments for SPDMatrixCholeskyUpdateAdd1() for more          |
//| information.                                                     |
//| INPUT PARAMETERS:                                                |
//|   A        -  upper or lower Cholesky factor. array with elements|
//|               [0..N - 1, 0..N - 1]. Exception is thrown if array |
//|               size is too small.                                 |
//|   N        -  size of matrix A, N > 0                            |
//|   IsUpper  -  if IsUpper = True, then A contains upper Cholesky  |
//|               factor; otherwise A contains a lower one.          |
//|   U        -  array[N], rank - 1 update to A: A_mod = A + u * u' |
//|               Exception is thrown if array size is too small.    |
//|   BufR     -  possibly preallocated buffer; automatically resized|
//|               if needed. It is recommended to reuse this buffer  |
//|               if you perform a lot of subsequent decompositions. |
//| OUTPUT PARAMETERS:                                               |
//|   A        -  updated factorization. If IsUpper=True, then the   |
//|               upper triangle contains matrix U, and the elements |
//|               below the main diagonal are not modified.          |
//|               Similarly, if IsUpper=False.                       |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixCholeskyUpdateAdd1Buf(CMatrixDouble &a,int n,
                                             bool IsUpper,CRowDouble &u,
                                             CRowDouble &bufr)
  {
   CTrFac::SPDMatrixCholeskyUpdateAdd1Buf(a,n,IsUpper,u,bufr);
  }
//+------------------------------------------------------------------+
//| Update of Cholesky  decomposition: "fixing" some variables.      |
//| "Buffered" version which uses preallocated buffer which is saved |
//| between subsequent function calls. See comments for              |
//| SPDMatrixCholeskyUpdateFix() for more information.               |
//| INPUT PARAMETERS:                                                |
//|   A        -  upper or lower Cholesky factor. Array with elements|
//|               [0..N - 1, 0..N - 1]. Exception is thrown if array |
//|               size is too small.                                 |
//|   N        -  size of matrix A, N > 0                            |
//|   IsUpper  -  if IsUpper = True, then A contains upper Cholesky  |
//|               factor; otherwise A contains a lower one.          |
//|   Fix      -  array[N], I-th element is True if I-th variable    |
//|               must be fixed. Exception is thrown if array size is|
//|               too small.                                         |
//|   BufR     -  possibly preallocated buffer; automatically resized|
//|               if needed. It is recommended to reuse this buffer  |
//|               if you perform a lot of subsequent decompositions. |
//| OUTPUT PARAMETERS:                                               |
//|   A        -  updated factorization. If IsUpper=True, then the   |
//|               upper triangle contains matrix U, and the elements |
//|               below the main diagonal are not modified.          |
//|               Similarly, if IsUpper = False.                     |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixCholeskyUpdateFixBuf(CMatrixDouble &a,int n,
                                            bool IsUpper,bool &fix[],
                                            CRowDouble &bufr)
  {
   CTrFac::SPDMatrixCholeskyUpdateFixBuf(a,n,IsUpper,fix,bufr);
  }
//+------------------------------------------------------------------+
//| Sparse LU decomposition with column pivoting for sparsity and row|
//| pivoting for stability. Input must be square sparse matrix stored|
//| in CRS format.                                                   |
//| The algorithm computes LU decomposition of a general square      |
//| matrix (rectangular ones are not supported). The result of an    |
//| algorithm is a representation of A as A = P * L * U * Q, where:  |
//|   * L is lower unitriangular matrix                              |
//|   * U is upper triangular matrix                                 |
//|   * P = P0 * P1 * ...*PK, K = N - 1, Pi - permutation matrix for |
//|     I and P[I]                                                   |
//|   * Q = QK * ...*Q1 * Q0, K = N - 1, Qi - permutation matrix for |
//|     I and Q[I]                                                   |
//| This function pivots columns for higher sparsity, and then pivots|
//| rows for stability(larger element at the diagonal).              |
//| INPUT PARAMETERS:                                                |
//|   A           -  sparse NxN matrix in CRS format. An exception is|
//|                  generated if matrix is non-CRS or non-square.   |
//|   PivotType   -  pivoting strategy:                              |
//|                  * 0 for best pivoting available (2 in current   |
//|                    version)                                      |
//|                  * 1 for row - only pivoting(NOT RECOMMENDED)    |
//|                  * 2 for complete pivoting which produces most   |
//|                    sparse outputs                                |
//| OUTPUT PARAMETERS:                                               |
//|   A           -  the result of factorization, matrices L and U   |
//|                  stored in compact form using CRS sparse storage |
//|                  format:                                         |
//|                  * lower unitriangular L is stored strictly under|
//|                    main diagonal                                 |
//|                  * upper triangilar U is stored ON and ABOVE main|
//|                    diagonal                                      |
//|   P           -  row permutation matrix in compact form, array[N]|
//|   Q           -  col permutation matrix in compact form, array[N]|
//| This function always succeeds, i.e. it ALWAYS returns valid      |
//| factorization, but for your convenience it also returns boolean  |
//| value which helps to detect symbolically degenerate matrices:    |
//|   * function returns TRUE, if the matrix was factorized AND      |
//|     symbolically non-degenerate                                  |
//|   * function returns FALSE, if the matrix was factorized but U   |
//|     has strictly zero elements at the diagonal(the factorization |
//|     is returned anyway).                                         |
//+------------------------------------------------------------------+
bool CAlglib::SparseLU(CSparseMatrix &a,int pivottype,CRowInt &p,
                       CRowInt &q)
  {
   return(CTrFac::SparseLU(a,pivottype,p,q));
  }
//+------------------------------------------------------------------+
//| Sparse Cholesky decomposition for skyline matrixm using in-place |
//| algorithm without allocating additional storage.                 |
//| The algorithm computes Cholesky decomposition of a symmetric     |
//| positive - definite sparse matrix. The result of an algorithm is |
//| a representation of A as A = U ^ T * U or A = L * L ^ T          |
//| This function allows to perform very efficient decomposition of  |
//| low - profile matrices(average bandwidth is ~5-10 elements). For |
//| larger matrices it is recommended to use supernodal Cholesky     |
//| decomposition: SparseCholeskyP() or                              |
//| SparseCholeskyAnalyze() / SparseCholeskyFactorize().             |
//| INPUT PARAMETERS:                                                |
//|   A        -  sparse matrix in skyline storage(SKS) format.      |
//|   N        -  size of matrix A(can be smaller than actual size   |
//|               of A)                                              |
//|   IsUpper  -  if IsUpper = True, then factorization is performed |
//|               on upper triangle. Another triangle is ignored (it |
//|               may contant some data, but it is not changed).     |
//| OUTPUT PARAMETERS:                                               |
//|   A        -  the result of factorization, stored in SKS. If     |
//|               IsUpper = True, then the upper triangle contains   |
//|               matrix U, such that A = U ^ T * U. Lower triangle  |
//|               is not changed. Similarly, if IsUpper = False. In  |
//|               this case L is returned, and we have A = L * (L^T).|
//| Note that THIS function does not perform permutation of rows to  |
//| reduce bandwidth.                                                |
//| RESULT:                                                          |
//|   If the matrix is positive - definite, the function returns True|
//|   Otherwise, the function returns False. Contents of A is not    |
//|   determined in such case.                                       |
//| NOTE: for performance reasons this function does NOT check that  |
//|       input matrix includes only finite values. It is your       |
//|       responsibility to make sure that there are no infinite or  |
//|       NAN values in the matrix.                                  |
//+------------------------------------------------------------------+
bool CAlglib::SparseCholeskySkyLine(CSparseMatrix &a,int n,bool IsUpper)
  {
   return(CTrFac::SparseCholeskySkyLine(a,n,IsUpper));
  }
//+------------------------------------------------------------------+
//| Sparse Cholesky decomposition for a matrix stored in any sparse  |
//| storage, without rows/cols permutation.                          |
//| This function is the most convenient(less parameters to specify),|
//| although less efficient, version of sparse Cholesky.             |
//| Internally it:                                                   |
//|   * calls SparseCholeskyAnalyze() function to perform symbolic   |
//|     analysis phase with no permutation being configured.         |
//|   * calls SparseCholeskyFactorize() function to perform numerical|
//|     phase of the factorization                                   |
//| Following alternatives may result in better performance:         |
//|   * using SparseCholeskyP(), which selects best pivoting         |
//|     available, which almost always results in improved sparsity  |
//|     and cache locality                                           |
//|   * using SparseCholeskyAnalyze() and SparseCholeskyFactorize()  |
//|     functions directly, which may improve performance of         |
//|     repetitive factorizations with same sparsity patterns.       |
//| The latter also allows one to perform LDLT factorization of      |
//| indefinite matrix(one with strictly diagonal D, which is known to|
//| be stable only in few special cases, like quasi - definite       |
//| matrices).                                                       |
//| INPUT PARAMETERS:                                                |
//|   A        -  a square NxN sparse matrix, stored in any storage  |
//|               format.                                            |
//|   IsUpper  -  if IsUpper=True, then factorization is performed on|
//|               upper triangle. Another triangle is ignored on     |
//|               input, dropped on output. Similarly, if            |
//|               IsUpper=False, the lower triangle is processed.    |
//| OUTPUT PARAMETERS:                                               |
//|   A        -  the result of factorization, stored in CRS format: |
//|      * if IsUpper = True, then the upper triangle contains matrix|
//|        U such that A = U ^ T * U and the lower triangle is empty.|
//|      * similarly, if IsUpper = False, then lower triangular L  is|
//|        returned and we have A = L * (L^T).                       |
//| Note that THIS function does not perform permutation of the rows |
//|      to reduce fill-in.                                          |
//| RESULT:                                                          |
//|   If the matrix is positive-definite, the function returns True. |
//|   Otherwise, the function returns False. Contents of A is        |
//|   undefined in such case.                                        |
//| NOTE: for performance reasons this function does NOT check that  |
//|       input matrix includes only finite values. It is your       |
//|       responsibility to make sure that there are no infinite or  |
//|       NAN values in the matrix.                                  |
//+------------------------------------------------------------------+
bool CAlglib::SparseCholesky(CSparseMatrix &a,bool IsUpper)
  {
   return(CTrFac::SparseCholesky(a,IsUpper));
  }
//+------------------------------------------------------------------+
//| Sparse Cholesky decomposition for a matrix stored in any sparse  |
//| storage format, with performance - enhancing permutation of      |
//| rows/cols.                                                       |
//| Present version is configured to perform supernodal permutation  |
//| which sparsity reducing ordering.                                |
//| This function is a wrapper around generic sparse decomposition   |
//| functions that internally :                                      |
//|   * calls SparseCholeskyAnalyze() function to perform symbolic   |
//|     analysis phase with best available permutation being         |
//|     configured.                                                  |
//|   * calls SparseCholeskyFactorize() function to perform numerical|
//|     phase of the factorization.                                  |
//| NOTE: using SparseCholeskyAnalyze() and SparseCholeskyFactorize()|
//|       directly may improve performance of repetitive             |
//|       factorizations with same sparsity patterns. It also allows |
//|       one to perform LDLT factorization of indefinite matrix - a |
//|       factorization with strictly diagonal D, which is known to  |
//|       be stable only in few special cases, like quasi - definite |
//|       matrices.                                                  |
//| INPUT PARAMETERS:                                                |
//|   A        -  a square NxN sparse matrix, stored in any storage  |
//|               format.                                            |
//|   IsUpper  -  if IsUpper=True, then factorization is performed on|
//|               upper triangle. Another triangle is ignored on     |
//|               input, dropped on output. Similarly, if            |
//|               IsUpper=False, the lower triangle is processed.    |
//| OUTPUT PARAMETERS:                                               |
//|   A        -  the result of factorization, stored in CRS format: |
//|      * if IsUpper = True, then the upper triangle contains matrix|
//|        U such that A = U ^ T * U and the lower triangle is empty.|
//|      * similarly, if IsUpper = False, then lower triangular L  is|
//|        returned and we have A = L * (L^T).                       |
//|   P        -  a row / column permutation, a product of           |
//|               P0 * P1 * ...*Pk, k = N - 1, with Pi being         |
//|               permutation of rows / cols I and P[I]              |
//| RESULT:                                                          |
//|   If the matrix is positive-definite, the function returns True. |
//|   Otherwise, the function returns False. Contents of A is        |
//|   undefined in such case.                                        |
//| NOTE: for performance reasons this function does NOT check that  |
//|       input matrix includes only finite values. It is your       |
//|       responsibility to make sure that there are no infinite or  |
//|       NAN values in the matrix.                                  |
//+------------------------------------------------------------------+
bool CAlglib::SparseCholeskyP(CSparseMatrix &a,bool IsUpper,CRowInt &p)
  {
   return(CTrFac::SparseCholeskyP(a,IsUpper,p));
  }
//+------------------------------------------------------------------+
//| Sparse Cholesky/LDLT decomposition: symbolic analysis phase.     |
//| This function is a part of the 'expert' sparse Cholesky API:     |
//|      * SparseCholeskyAnalyze(), that performs symbolic analysis  |
//|        phase and loads matrix to be factorized into internal     |
//|        storage                                                   |
//|      * SparseCholeskySetModType(), that allows to use modified   |
//|        Cholesky/LDLT with lower bounds on pivot magnitudes and   |
//|        additional overflow safeguards                            |
//|      * SparseCholeskyFactorize(),  that performs  numeric        |
//|        factorization using precomputed symbolic analysis and     |
//|        internally stored matrix - and outputs result             |
//|      * SparseCholeskyReload(), that reloads one more matrix with |
//|        same sparsity pattern into internal storage so one may    |
//|        reuse previously allocated temporaries and previously     |
//|        performed symbolic analysis                               |
//| This specific function performs preliminary analysis of the      |
//| Cholesky/LDLT factorization. It allows to choose different       |
//| permutation types and to choose between classic Cholesky and     |
//| indefinite LDLT factorization(the latter is computed with        |
//| strictly diagonal D, i.e. without Bunch-Kauffman pivoting).      |
//| NOTE: L*D*LT family of factorization may be used to  factorize   |
//|       indefinite matrices. However, numerical stability is       |
//|       guaranteed ONLY for a class of quasi - definite matrices.  |
//| NOTE: all internal processing is performed with lower triangular |
//|       matrices stored in CRS format. Any other storage formats   |
//|       and/or upper triangular storage means that one format      |
//|       conversion and/or one transposition will be performed      |
//|       internally for the analysis and factorization phases. Thus,|
//|       highest performance is achieved when input is a lower      |
//|       triangular CRS matrix.                                     |
//| INPUT PARAMETERS:                                                |
//|   A        -  sparse square matrix in any sparse storage format. |
//|   IsUpper  -  whether upper or lower triangle is decomposed (the |
//|               other one is ignored).                             |
//|   FactType -  factorization type:                                |
//|      * 0 for traditional Cholesky of SPD matrix                  |
//|      * 1 for LDLT decomposition with strictly diagonal D, which  |
//|          may have non - positive entries.                        |
//|   PermType -  permutation type:                                  |
//|      * -1 for absence of permutation                             |
//|      * 0 for best fill - in reducing  permutation  available,    |
//|          which is 3 in the current version                       |
//|      * 1 for supernodal ordering(improves locality and           |
//|          performance, does NOT change fill - in factor)          |
//|      * 2 for original AMD ordering                               |
//|      * 3 for  improved  AMD(approximate  minimum  degree)        |
//|          ordering with better handling of matrices with dense    |
//|          rows/columns                                            |
//| OUTPUT PARAMETERS:                                               |
//|   Analysis -  contains:                                          |
//|      * symbolic analysis of the matrix structure which will be   |
//|        used later to guide numerical factorization.              |
//|      * specific numeric values loaded into internal memory       |
//|        waiting for the factorization to be performed             |
//| This function fails if and only if the matrix A is symbolically  |
//| degenerate i.e. has diagonal element which is exactly zero. In   |
//| such case False is returned, contents of Analysis object is      |
//| undefined.                                                       |
//+------------------------------------------------------------------+
bool CAlglib::sparsecholeskyanalyze(CSparseMatrix &a,bool IsUpper,
                                    int facttype,int permtype,
                                    CSparseDecompositionAnalysis &analysis)
  {
   return(CTrFac::SparseCholeskyAnalyze(a,IsUpper,facttype,permtype,analysis));
  }
//+------------------------------------------------------------------+
//| Sparse Cholesky decomposition: numerical analysis phase.         |
//| This function is a part of the 'expert' sparse Cholesky API:     |
//|      * SparseCholeskyAnalyze(), that performs symbolic analysis  |
//|        phase and loads matrix to be factorized into internal     |
//|        storage                                                   |
//|      * SparseCholeskySetModType(), that allows to use modified   |
//|        Cholesky/LDLT with lower bounds on pivot magnitudes and   |
//|        additional overflow safeguards                            |
//|      * SparseCholeskyFactorize(),  that performs  numeric        |
//|        factorization using precomputed symbolic analysis and     |
//|        internally stored matrix - and outputs result             |
//|      * SparseCholeskyReload(), that reloads one more matrix with |
//|        same sparsity pattern into internal storage so one may    |
//|        reuse previously allocated temporaries and previously     |
//|        performed symbolic analysis                               |
//| Depending on settings specified during SparseCholeskyAnalyze()   |
//| call it may produce classic Cholesky or L*D*LT decomposition     |
//| (with strictly diagonal D), without permutation or with          |
//| performance - enhancing permutation P.                           |
//| NOTE: all internal processing is performed with lower triangular |
//|       matrices stored in CRS format. Any other storage formats   |
//|       and/or upper triangular storage means that one format      |
//|       conversion and/or one transposition will be performed      |
//|       internally for the analysis and factorization phases. Thus,|
//|       highest performance is achieved when input is a lower      |
//|       triangular CRS matrix, and lower triangular output is      |
//|       requested.                                                 |
//| NOTE: L*D*LT family of factorization may be used to factorize    |
//|       indefinite matrices. However, numerical stability is       |
//|       guaranteed ONLY for a class of quasi - definite matrices.  |
//| INPUT PARAMETERS:                                                |
//|   Analysis    -  prior analysis with internally stored matrix    |
//|                  which will be factorized                        |
//|   NeedUpper   -  whether upper triangular or lower triangular    |
//|                  output is needed                                |
//| OUTPUT PARAMETERS:                                               |
//|   A           -  Cholesky decomposition of A stored in lower     |
//|                  triangular CRS format, i.e. A = L * L' (or upper|
//|                  triangular CRS, with A = U'*U, depending on     |
//|                  NeedUpper parameter).                           |
//|   D           -  array[N], diagonal factor. If no diagonal factor|
//|                  was required during analysis phase, still       |
//|                  returned but filled with 1's                    |
//|   P           -  array[N], pivots. Permutation matrix P is a     |
//|                  product of P(0) * P(1) * ...*P(N - 1),          |
//|                  where P(i) is a permutation of row/col I and    |
//|                  P[I] (with P[I] >= I).                          |
//| If no permutation was requested during analysis phase, still     |
//| returned but filled with identity permutation.                   |
//| The function returns True when factorization resulted in         |
//| nondegenerate matrix. False is returned when factorization fails |
//| (Cholesky factorization of indefinite matrix) or LDLT            |
//| factorization has exactly zero elements at the diagonal. In the  |
//| latter case contents of A, D and P is undefined.                 |
//| The analysis object is not changed during  the  factorization.   |
//| Subsequent calls to SparseCholeskyFactorize() will result in same|
//| factorization being performed one more time.                     |
//+------------------------------------------------------------------+
bool CAlglib::SparseCholeskyFactorize(CSparseDecompositionAnalysis &analysis,
                                      bool needupper,CSparseMatrix &a,
                                      CRowDouble &d,CRowInt &p)
  {
   return(CTrFac::SparseCholeskyFactorize(analysis,needupper,a,d,p));
  }
//+------------------------------------------------------------------+
//| Sparse  Cholesky  decomposition: update internally stored matrix |
//| with another one with exactly same sparsity pattern.             |
//| This function is a part of the 'expert' sparse Cholesky API:     |
//|      * SparseCholeskyAnalyze(), that performs symbolic analysis  |
//|        phase and loads matrix to be factorized into internal     |
//|        storage                                                   |
//|      * SparseCholeskySetModType(), that allows to  use  modified |
//|        Cholesky/LDLT with lower bounds on pivot magnitudes and   |
//|        additional overflow safeguards                            |
//|      * SparseCholeskyFactorize(), that performs numeric          |
//|        factorization using precomputed symbolic analysis and     |
//|        internally stored matrix - and outputs result             |
//|      * SparseCholeskyReload(), that reloads one more matrix with |
//|        same sparsity pattern into internal storage so one may    |
//|        reuse previously allocated temporaries and previously     |
//|        performed symbolic analysis                               |
//| This specific function replaces internally stored numerical      |
//| values with ones from another sparse matrix (but having exactly  |
//| same sparsity pattern as one that was used for initial           |
//| SparseCholeskyAnalyze() call).                                   |
//| NOTE: all internal processing is performed with lower triangular |
//|       matrices stored in CRS format. Any other storage formats   |
//|       and/or upper triangular storage means that one format      |
//|       conversion  and/or one transposition will be performed     |
//|       internally for the analysis and factorization phases. Thus,|
//|       highest performance is achieved when input is a lower      |
//|       triangular CRS matrix.                                     |
//| INPUT PARAMETERS:                                                |
//|   Analysis -  analysis object                                    |
//|   A        -  sparse square matrix in any sparse storage format. |
//|               It MUST have exactly same sparsity pattern as that |
//|               of the matrix that was passed to                   |
//|               SparseCholeskyAnalyze(). Any difference (missing   |
//|               elements or additional elements) may result in     |
//|               unpredictable and undefined behavior - an algorithm|
//|               may fail due to memory access violation.           |
//|   IsUpper  -  whether upper or lower triangle is decomposed (the |
//|               other one is ignored).                             |
//| OUTPUT PARAMETERS:                                               |
//|   Analysis -  contains:                                          |
//|      * symbolic analysis of the matrix structure which will be   |
//|        used later to guide numerical factorization.              |
//|      * specific numeric values loaded into internal memory       |
//|        waiting for the factorization to be performed             |
//+------------------------------------------------------------------+
void CAlglib::SparseCholeskyReload(CSparseDecompositionAnalysis &analysis,
                                   CSparseMatrix &a,bool IsUpper)
  {
   CTrFac::SparseCholeskyReload(analysis,a,IsUpper);
  }
//+------------------------------------------------------------------+
//| Estimate of a matrix condition number (1-norm)                   |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| Input parameters:                                                |
//|     A   -   matrix. Array whose indexes range within             |
//|             [0..N-1, 0..N-1].                                    |
//|     N   -   size of matrix A.                                    |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::RMatrixRCond1(CMatrixDouble &a,const int n)
  {
   return(CRCond::RMatrixRCond1(a,n));
  }
//+------------------------------------------------------------------+
//| Estimate of a matrix condition number (infinity-norm).           |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| Input parameters:                                                |
//|     A   -   matrix. Array whose indexes range within             |
//|     [0..N-1, 0..N-1].                                            |
//|     N   -   size of matrix A.                                    |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::RMatrixRCondInf(CMatrixDouble &a,const int n)
  {
   return(CRCond::RMatrixRCondInf(a,n));
  }
//+------------------------------------------------------------------+
//| Condition number estimate of a symmetric positive definite       |
//| matrix.                                                          |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| It should be noted that 1-norm and inf-norm of condition numbers |
//| of symmetric matrices are equal, so the algorithm doesn't take   |
//| into account the differences between these types of norms.       |
//| Input parameters:                                                |
//|     A       -   symmetric positive definite matrix which is given|
//|                 by its upper or lower triangle depending on the  |
//|                 value of IsUpper. Array with elements            |
//|                 [0..N-1, 0..N-1].                                |
//|     N       -   size of matrix A.                                |
//|     IsUpper -   storage format.                                  |
//| Result:                                                          |
//|     1/LowerBound(cond(A)), if matrix A is positive definite,     |
//|    -1, if matrix A is not positive definite, and its condition   |
//|     number could not be found by this algorithm.                 |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::SPDMatrixRCond(CMatrixDouble &a,const int n,
                               const bool IsUpper)
  {
   return(CRCond::SPDMatrixRCond(a,n,IsUpper));
  }
//+------------------------------------------------------------------+
//| Triangular matrix: estimate of a condition number (1-norm)       |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| Input parameters:                                                |
//|     A       -   matrix. Array[0..N-1, 0..N-1].                   |
//|     N       -   size of A.                                       |
//|     IsUpper -   True, if the matrix is upper triangular.         |
//|     IsUnit  -   True, if the matrix has a unit diagonal.         |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::RMatrixTrRCond1(CMatrixDouble &a,const int n,
                                const bool IsUpper,const bool IsUnit)
  {
   return(CRCond::RMatrixTrRCond1(a,n,IsUpper,IsUnit));
  }
//+-------------------------------------------------------------------+
//| Triangular matrix: estimate of a matrix condition number          |
//| (infinity-norm).                                                  |
//| The algorithm calculates a lower bound of the condition number. In|
//| this case, the algorithm does not return a lower bound of the     |
//| condition number, but an inverse number (to avoid an overflow in  |
//| case of a singular matrix).                                       |
//| Input parameters:                                                 |
//|     A   -   matrix. Array whose indexes range within              |
//|             [0..N-1,0..N-1].                                      |
//|     N   -   size of matrix A.                                     |
//|     IsUpper -   True, if the matrix is upper triangular.          |
//|     IsUnit  -   True, if the matrix has a unit diagonal.          |
//| Result: 1/LowerBound(cond(A))                                     |
//| NOTE:                                                             |
//|     if k(A) is very large,then matrix is assumed degenerate,      |
//|     k(A)=INF, 0.0 is returned in such cases.                      |
//+-------------------------------------------------------------------+
double CAlglib::RMatrixTrRCondInf(CMatrixDouble &a,const int n,
                                  const bool IsUpper,const bool IsUnit)
  {
   return(CRCond::RMatrixTrRCondInf(a,n,IsUpper,IsUnit));
  }
//+------------------------------------------------------------------+
//| Condition number estimate of a Hermitian positive definite       |
//| matrix.                                                          |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| It should be noted that 1-norm and inf-norm of condition numbers |
//| of symmetric matrices are equal, so the algorithm doesn't take   |
//| into account the differences between these types of norms.       |
//| Input parameters:                                                |
//|     A       -   Hermitian positive definite matrix which is given|
//|                 by its upper or lower triangle depending on the  |
//|                 value of IsUpper. Array with elements            |
//|                 [0..N-1, 0..N-1].                                |
//|     N       -   size of matrix A.                                |
//|     IsUpper -   storage format.                                  |
//| Result:                                                          |
//|     1/LowerBound(cond(A)), if matrix A is positive definite,     |
//|    -1, if matrix A is not positive definite, and its condition   |
//|     number could not be found by this algorithm.                 |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::HPDMatrixRCond(CMatrixComplex &a,const int n,
                               const bool IsUpper)
  {
   return(CRCond::HPDMatrixRCond(a,n,IsUpper));
  }
//+------------------------------------------------------------------+
//| Estimate of a matrix condition number (1-norm)                   |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| Input parameters:                                                |
//|     A   -   matrix. Array whose indexes range within             |
//|             [0..N-1, 0..N-1].                                    |
//|     N   -   size of matrix A.                                    |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::CMatrixRCond1(CMatrixComplex &a,const int n)
  {
   return(CRCond::CMatrixRCond1(a,n));
  }
//+------------------------------------------------------------------+
//| Estimate of a matrix condition number (infinity-norm).           |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| Input parameters:                                                |
//|     A   -   matrix. Array whose indexes range within             |
//|             [0..N-1, 0..N-1].                                    |
//|     N   -   size of matrix A.                                    |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::CMatrixRCondInf(CMatrixComplex &a,const int n)
  {
   return(CRCond::CMatrixRCondInf(a,n));
  }
//+------------------------------------------------------------------+
//| Estimate of the condition number of a matrix given by its LU     |
//| decomposition (1-norm)                                           |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| Input parameters:                                                |
//|     LUA         -   LU decomposition of a matrix in compact form.|
//|                     Output of the RMatrixLU subroutine.          |
//|     N           -   size of matrix A.                            |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::RMatrixLURCond1(CMatrixDouble &lua,const int n)
  {
   return(CRCond::RMatrixLURCond1(lua,n));
  }
//+------------------------------------------------------------------+
//| Estimate of the condition number of a matrix given by its LU     |
//| decomposition (infinity norm).                                   |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| Input parameters:                                                |
//|     LUA     -   LU decomposition of a matrix in compact form.    |
//|                 Output of the RMatrixLU subroutine.              |
//|     N       -   size of matrix A.                                |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is  assumed  degenerate,  |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::RMatrixLURCondInf(CMatrixDouble &lua,const int n)
  {
   return(CRCond::RMatrixLURCondInf(lua,n));
  }
//+------------------------------------------------------------------+
//| Condition number estimate of a symmetric positive definite matrix|
//| given by Cholesky decomposition.                                 |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| It should be noted that 1-norm and inf-norm condition numbers of |
//| symmetric matrices are equal, so the algorithm doesn't take into |
//| account the differences between these types of norms.            |
//| Input parameters:                                                |
//|     CD  - Cholesky decomposition of matrix A,                    |
//|           output of SMatrixCholesky subroutine.                  |
//|     N   - size of matrix A.                                      |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::SPDMatrixCholeskyRCond(CMatrixDouble &a,const int n,
                                       const bool IsUpper)
  {
   return(CRCond::SPDMatrixCholeskyRCond(a,n,IsUpper));
  }
//+------------------------------------------------------------------+
//| Condition number estimate of a Hermitian positive definite matrix|
//| given by Cholesky decomposition.                                 |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| It should be noted that 1-norm and inf-norm condition numbers of |
//| symmetric matrices are equal, so the algorithm doesn't take into |
//| account the differences between these types of norms.            |
//| Input parameters:                                                |
//|     CD  - Cholesky decomposition of matrix A,                    |
//|           output of SMatrixCholesky subroutine.                  |
//|     N   - size of matrix A.                                      |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::HPDMatrixCholeskyRCond(CMatrixComplex &a,const int n,
                                       const bool IsUpper)
  {
   return(CRCond::HPDMatrixCholeskyRCond(a,n,IsUpper));
  }
//+------------------------------------------------------------------+
//| Estimate of the condition number of a matrix given by its LU     |
//| decomposition (1-norm)                                           |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| Input parameters:                                                |
//|     LUA         -   LU decomposition of a matrix in compact form.|
//|                     Output of the CMatrixLU subroutine.          |
//|     N           -   size of matrix A.                            |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::CMatrixLURCond1(CMatrixComplex &lua,const int n)
  {
   return(CRCond::CMatrixLURCond1(lua,n));
  }
//+------------------------------------------------------------------+
//| Estimate of the condition number of a matrix given by its LU     |
//| decomposition (infinity norm).                                   |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| Input parameters:                                                |
//|     LUA     -   LU decomposition of a matrix in compact form.    |
//|                 Output of the CMatrixLU subroutine.              |
//|     N       -   size of matrix A.                                |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::CMatrixLURCondInf(CMatrixComplex &lua,const int n)
  {
   return(CRCond::CMatrixLURCondInf(lua,n));
  }
//+------------------------------------------------------------------+
//| Triangular matrix: estimate of a condition number (1-norm)       |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| Input parameters:                                                |
//|     A       -   matrix. Array[0..N-1, 0..N-1].                   |
//|     N       -   size of A.                                       |
//|     IsUpper -   True, if the matrix is upper triangular.         |
//|     IsUnit  -   True, if the matrix has a unit diagonal.         |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::CMatrixTrRCond1(CMatrixComplex &a,const int n,
                                const bool IsUpper,const bool IsUnit)
  {
   return(CRCond::CMatrixTrRCond1(a,n,IsUpper,IsUnit));
  }
//+------------------------------------------------------------------+
//| Triangular matrix: estimate of a matrix condition number         |
//| (infinity-norm).                                                 |
//| The algorithm calculates a lower bound of the condition number.  |
//| In this case, the algorithm does not return a lower bound of the |
//| condition number, but an inverse number (to avoid an overflow in |
//| case of a singular matrix).                                      |
//| Input parameters:                                                |
//|     A   -   matrix. Array whose indexes range within             |
//|             [0..N-1, 0..N-1].                                    |
//|     N   -   size of matrix A.                                    |
//|     IsUpper -   True, if the matrix is upper triangular.         |
//|     IsUnit  -   True, if the matrix has a unit diagonal.         |
//| Result: 1/LowerBound(cond(A))                                    |
//| NOTE:                                                            |
//|     if k(A) is very large, then matrix is assumed degenerate,    |
//|     k(A)=INF, 0.0 is returned in such cases.                     |
//+------------------------------------------------------------------+
double CAlglib::CMatrixTrRCondInf(CMatrixComplex &a,const int n,
                                  const bool IsUpper,const bool IsUnit)
  {
   return(CRCond::CMatrixTrRCondInf(a,n,IsUpper,IsUnit));
  }
//+------------------------------------------------------------------+
//| This procedure initializes matrix norm estimator.                |
//| USAGE:                                                           |
//|   1. User initializes algorithm state with NormEstimatorCreate() |
//|      call                                                        |
//|   2. User calls NormEstimatorEstimateSparse() (or                |
//|      NormEstimatorIteration())                                   |
//|   3. User calls NormEstimatorResults() to get solution.          |
//| INPUT PARAMETERS:                                                |
//|   M        -  number of rows in the matrix being estimated, M>0  |
//|   N        -  number of columns in the matrix being estimated,   |
//|               N>0                                                |
//|   NStart   -  number of random starting vectors, recommended     |
//|               value - at least 5.                                |
//|   NIts     -  number of iterations to do with best starting      |
//|               vector recommended value - at least 5.             |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure which stores algorithm state             |
//| NOTE: this algorithm is effectively deterministic, i.e. it always|
//|       returns same result when repeatedly called for the same    |
//|       matrix. In fact, algorithm uses randomized starting v      |
//|       ectors, but internal random numbers generator always       |
//|       generates same sequence of the random values (it is a      |
//|       feature, not bug).                                         |
//| Algorithm can be made non-deterministic with                     |
//| NormEstimatorSetSeed(0) call.                                    |
//+------------------------------------------------------------------+
void CAlglib::NormEstimatorCreate(int m,int n,int nstart,int nits,
                                  CNormEstimatorState &state)
  {
   CNormEstimator::NormEstimatorCreate(m,n,nstart,nits,state);
  }
//+------------------------------------------------------------------+
//| This function changes seed value used by algorithm. In some cases|
//| we need deterministic processing, i.e. subsequent calls must     |
//| return equal results, in other cases we need non-deterministic   |
//| algorithm which returns different results for the same matrix on |
//| every pass.                                                      |
//| Setting zero seed will lead to non-deterministic algorithm, while|
//| non-zero value will make our algorithm deterministic.            |
//| INPUT PARAMETERS:                                                |
//|   State    -  norm estimator state, must be initialized with a   |
//|               call to NormEstimatorCreate()                      |
//|   SeedVal  -  seed value, >=0. Zero value=non-deterministic algo.|
//+------------------------------------------------------------------+
void CAlglib::NormEstimatorSetSeed(CNormEstimatorState &state,int seedval)
  {
   CNormEstimator::NormEstimatorSetSeed(state,seedval);
  }
//+------------------------------------------------------------------+
//| This function estimates norm of the sparse M*N matrix A.         |
//| INPUT PARAMETERS:                                                |
//|   State    -  norm estimator state, must be initialized with a   |
//|               call to NormEstimatorCreate()                      |
//|   A        -  sparse M*N matrix, must be converted to CRS format |
//|               prior to calling this function.                    |
//| After this function is over you can call NormEstimatorResults()  |
//| to get estimate of the norm(A).                                  |
//+------------------------------------------------------------------+
void CAlglib::NormEstimatorEstimateSparse(CNormEstimatorState &state,
                                          CSparseMatrix &a)
  {
   CNormEstimator::NormEstimatorEstimateSparse(state,a);
  }
//+------------------------------------------------------------------+
//| Matrix norm estimation results                                   |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm state                                    |
//| OUTPUT PARAMETERS:                                               |
//|   Nrm      -  estimate of the matrix norm, Nrm >= 0              |
//+------------------------------------------------------------------+
void CAlglib::NormEstimatorResults(CNormEstimatorState &state,double &nrm)
  {
   CNormEstimator::NormEstimatorResults(state,nrm);
  }

//+------------------------------------------------------------------+
//| Inversion of a matrix given by its LU decomposition.             |
//| INPUT PARAMETERS:                                                |
//|     A       -   LU decomposition of the matrix                   |
//|                 (output of RMatrixLU subroutine).                |
//|     Pivots  -   table of permutations                            |
//|                 (the output of RMatrixLU subroutine).            |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   return code:                                     |
//|                 * -3    A is singular, or VERY close to singular.|
//|                         it is filled by zeros in such cases.     |
//|                 *  1    task is solved (but matrix A may be      |
//|                         ill-conditioned, check R1/RInf parameters|
//|                         for condition numbers).                  |
//|     Rep     -   solver report, see below for more info           |
//|     A       -   inverse of matrix A.                             |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..N-1].                                |
//| SOLVER REPORT                                                    |
//| Subroutine sets following fields of the Rep structure:           |
//| * R1        reciprocal of condition number: 1/cond(A), 1-norm.   |
//| * RInf      reciprocal of condition number: 1/cond(A), inf-norm. |
//+------------------------------------------------------------------+
void CAlglib::RMatrixLUInverse(CMatrixDouble &a,int &pivots[],
                               const int n,int &info,
                               CMatInvReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMatInv::RMatrixLUInverse(a,pivots,n,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a matrix given by its LU decomposition.             |
//| INPUT PARAMETERS:                                                |
//|     A       -   LU decomposition of the matrix                   |
//|                 (output of RMatrixLU subroutine).                |
//|     Pivots  -   table of permutations                            |
//|                 (the output of RMatrixLU subroutine).            |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   return code:                                     |
//|                 * -3    A is singular, or VERY close to singular.|
//|                         it is filled by zeros in such cases.     |
//|                 *  1    task is solved (but matrix A may be      |
//|                         ill-conditioned, check R1/RInf parameters|
//|                         for condition numbers).                  |
//|     Rep     -   solver report, see below for more info           |
//|     A       -   inverse of matrix A.                             |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..N-1].                                |
//| SOLVER REPORT                                                    |
//| Subroutine sets following fields of the Rep structure:           |
//| * R1        reciprocal of condition number: 1/cond(A), 1-norm.   |
//| * RInf      reciprocal of condition number: 1/cond(A), inf-norm. |
//+------------------------------------------------------------------+
void CAlglib::RMatrixLUInverse(CMatrixDouble &a,int &pivots[],
                               int &info,CMatInvReportShell &rep)
  {
//--- check
   if((CAp::Cols(a)!=CAp::Rows(a)) || (CAp::Cols(a)!=CAp::Len(pivots)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=(int)CAp::Cols(a);
//--- function call
   CMatInv::RMatrixLUInverse(a,pivots,n,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a general matrix.                                   |
//| Input parameters:                                                |
//|     A       -   matrix.                                          |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//| Result:                                                          |
//|     True, if the matrix is not singular.                         |
//|     False, if the matrix is singular.                            |
//+------------------------------------------------------------------+
void CAlglib::RMatrixInverse(CMatrixDouble &a,const int n,int &info,
                             CMatInvReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMatInv::RMatrixInverse(a,n,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a general matrix.                                   |
//| Input parameters:                                                |
//|     A       -   matrix.                                          |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//| Result:                                                          |
//|     True, if the matrix is not singular.                         |
//|     False, if the matrix is singular.                            |
//+------------------------------------------------------------------+
void CAlglib::RMatrixInverse(CMatrixDouble &a,int &info,
                             CMatInvReportShell &rep)
  {
//--- check
   if((CAp::Cols(a)!=CAp::Rows(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=(int)CAp::Cols(a);
//--- function call
   CMatInv::RMatrixInverse(a,n,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a matrix given by its LU decomposition.             |
//| INPUT PARAMETERS:                                                |
//|     A       -   LU decomposition of the matrix                   |
//|                 (output of CMatrixLU subroutine).                |
//|     Pivots  -   table of permutations                            |
//|                 (the output of CMatrixLU subroutine).            |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::CMatrixLUInverse(CMatrixComplex &a,int &pivots[],
                               const int n,int &info,
                               CMatInvReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMatInv::CMatrixLUInverse(a,pivots,n,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a matrix given by its LU decomposition.             |
//| INPUT PARAMETERS:                                                |
//|     A       -   LU decomposition of the matrix                   |
//|                 (output of CMatrixLU subroutine).                |
//|     Pivots  -   table of permutations                            |
//|                 (the output of CMatrixLU subroutine).            |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//| OUTPUT PARAMETERS:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::CMatrixLUInverse(CMatrixComplex &a,int &pivots[],
                               int &info,CMatInvReportShell &rep)
  {
//--- check
   if((CAp::Cols(a)!=CAp::Rows(a)) || (CAp::Cols(a)!=CAp::Len(pivots)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=(int)CAp::Cols(a);
//--- function call
   CMatInv::CMatrixLUInverse(a,pivots,n,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a general matrix.                                   |
//| Input parameters:                                                |
//|     A       -   matrix                                           |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::CMatrixInverse(CMatrixComplex &a,const int n,int &info,
                             CMatInvReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMatInv::CMatrixInverse(a,n,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a general matrix.                                   |
//| Input parameters:                                                |
//|     A       -   matrix                                           |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::CMatrixInverse(CMatrixComplex &a,int &info,
                             CMatInvReportShell &rep)
  {
//--- check
   if((CAp::Cols(a)!=CAp::Rows(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info =0;
   int n=(int)CAp::Cols(a);
//--- function call
   CMatInv::CMatrixInverse(a,n,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a symmetric positive definite matrix which is given |
//| by Cholesky decomposition.                                       |
//| Input parameters:                                                |
//|     A       -   Cholesky decomposition of the matrix to be       |
//|                 inverted: A=U?*U or A = L*L'.                    |
//|                 Output of  SPDMatrixCholesky subroutine.         |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   storage type (optional):                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used/changed  by function                      |
//|                 * if not given, lower half is used.              |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixCholeskyInverse(CMatrixDouble &a,const int n,
                                       const bool IsUpper,int &info,
                                       CMatInvReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMatInv::SPDMatrixCholeskyInverse(a,n,IsUpper,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a symmetric positive definite matrix which is given |
//| by Cholesky decomposition.                                       |
//| Input parameters:                                                |
//|     A       -   Cholesky decomposition of the matrix to be       |
//|                 inverted: A=U?*U or A = L*L'.                    |
//|                 Output of  SPDMatrixCholesky subroutine.         |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   storage type (optional):                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used/changed  by function                      |
//|                 * if not given, lower half is used.              |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixCholeskyInverse(CMatrixDouble &a,int &info,
                                       CMatInvReportShell &rep)
  {
//--- check
   if((CAp::Cols(a)!=CAp::Rows(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info=0;
   int  n=(int)CAp::Cols(a);
   bool IsUpper=false;
//--- function call
   CMatInv::SPDMatrixCholeskyInverse(a,n,IsUpper,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a symmetric positive definite matrix.               |
//| Given an upper or lower triangle of a symmetric positive definite|
//| matrix, the algorithm generates matrix A^-1 and saves the upper  |
//| or lower triangle depending on the input.                        |
//| Input parameters:                                                |
//|     A       -   matrix to be inverted (upper or lower triangle). |
//|                 Array with elements [0..N-1,0..N-1].             |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   storage type (optional):                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if not given, both lower and upper triangles   |
//|                   must be filled.                                |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixInverse(CMatrixDouble &a,const int n,
                               const bool IsUpper,int &info,
                               CMatInvReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMatInv::SPDMatrixInverse(a,n,IsUpper,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a symmetric positive definite matrix.               |
//| Given an upper or lower triangle of a symmetric positive definite|
//| matrix, the algorithm generates matrix A^-1 and saves the upper  |
//| or lower triangle depending on the input.                        |
//| Input parameters:                                                |
//|     A       -   matrix to be inverted (upper or lower triangle). |
//|                 Array with elements [0..N-1,0..N-1].             |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   storage type (optional):                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if not given, both lower and upper triangles   |
//|                   must be filled.                                |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixInverse(CMatrixDouble &a,int &info,
                               CMatInvReportShell &rep)
  {
//--- check
   if((CAp::Cols(a)!=CAp::Rows(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
   if(!CAp::IsSymmetric(a))
     {
      Print(__FUNCTION__+": 'a' parameter is not symmetric matrix");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info=0;
   int  n=(int)CAp::Cols(a);
   bool IsUpper=false;
//--- function call
   CMatInv::SPDMatrixInverse(a,n,IsUpper,info,rep.GetInnerObj());
//--- check
   if(!CAp::ForceSymmetric(a))
     {
      Print(__FUNCTION__+": Internal error while forcing symmetricity of 'a' parameter");
      CAp::exception_happened=true;
     }
  }
//+------------------------------------------------------------------+
//| Inversion of a Hermitian positive definite matrix which is given |
//| by Cholesky decomposition.                                       |
//| Input parameters:                                                |
//|     A       -   Cholesky decomposition of the matrix to be       |
//|                 inverted: A=U?*U or A = L*L'.                    |
//|                 Output of  HPDMatrixCholesky subroutine.         |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   storage type (optional):                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if not given, lower half is used.              |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::HPDMatrixCholeskyInverse(CMatrixComplex &a,const int n,
                                       const bool IsUpper,int &info,
                                       CMatInvReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMatInv::HPDMatrixCholeskyInverse(a,n,IsUpper,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a Hermitian positive definite matrix which is given |
//| by Cholesky decomposition.                                       |
//| Input parameters:                                                |
//|     A       -   Cholesky decomposition of the matrix to be       |
//|                 inverted: A=U?*U or A = L*L'.                    |
//|                 Output of  HPDMatrixCholesky subroutine.         |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   storage type (optional):                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if not given, lower half is used.              |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::HPDMatrixCholeskyInverse(CMatrixComplex &a,int &info,
                                       CMatInvReportShell &rep)
  {
//--- check
   if((CAp::Cols(a)!=CAp::Rows(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info=0;
   int  n=(int)CAp::Cols(a);
   bool IsUpper=false;
//--- function call
   CMatInv::HPDMatrixCholeskyInverse(a,n,IsUpper,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a Hermitian positive definite matrix.               |
//| Given an upper or lower triangle of a Hermitian positive definite|
//| matrix, the algorithm generates matrix A^-1 and saves the upper  |
//| or lower triangle depending on the input.                        |
//| Input parameters:                                                |
//|     A       -   matrix to be inverted (upper or lower triangle). |
//|                 Array with elements [0..N-1,0..N-1].             |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   storage type (optional):                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if not given, both lower and upper triangles   |
//|                   must be filled.                                |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::HPDMatrixInverse(CMatrixComplex &a,const int n,
                               const bool IsUpper,int &info,
                               CMatInvReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMatInv::HPDMatrixInverse(a,n,IsUpper,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Inversion of a Hermitian positive definite matrix.               |
//| Given an upper or lower triangle of a Hermitian positive definite|
//| matrix, the algorithm generates matrix A^-1 and saves the upper  |
//| or lower triangle depending on the input.                        |
//| Input parameters:                                                |
//|     A       -   matrix to be inverted (upper or lower triangle). |
//|                 Array with elements [0..N-1,0..N-1].             |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   storage type (optional):                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if not given, both lower and upper triangles   |
//|                   must be filled.                                |
//| Output parameters:                                               |
//|     Info    -   return code, same as in RMatrixLUInverse         |
//|     Rep     -   solver report, same as in RMatrixLUInverse       |
//|     A       -   inverse of matrix A, same as in RMatrixLUInverse |
//+------------------------------------------------------------------+
void CAlglib::HPDMatrixInverse(CMatrixComplex &a,int &info,
                               CMatInvReportShell &rep)
  {
//--- check
   if((CAp::Cols(a)!=CAp::Rows(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
   if(!CAp::IsHermitian(a))
     {
      Print(__FUNCTION__+": 'a' parameter is not Hermitian matrix");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info=0;
   int  n=(int)CAp::Cols(a);
   bool IsUpper=false;
//--- function call
   CMatInv::HPDMatrixInverse(a,n,IsUpper,info,rep.GetInnerObj());
//--- check
   if(!CAp::ForceHermitian(a))
     {
      Print(__FUNCTION__+": Internal error while forcing Hermitian properties of 'a' parameter");
      CAp::exception_happened=true;
     }
  }
//+------------------------------------------------------------------+
//| Triangular matrix inverse (real)                                 |
//| The subroutine inverts the following types of matrices:          |
//|     * upper triangular                                           |
//|     * upper triangular with unit diagonal                        |
//|     * lower triangular                                           |
//|     * lower triangular with unit diagonal                        |
//| In case of an upper (lower) triangular matrix, the inverse matrix|
//| will also be upper (lower) triangular, and after the end of the  |
//| algorithm, the inverse matrix replaces the source matrix. The    |
//| elements below (above) the main diagonal are not changed by the  |
//| algorithm.                                                       |
//| If the matrix has a unit diagonal, the inverse matrix also has a |
//| unit diagonal, and the diagonal elements are not passed to the   |
//| algorithm.                                                       |
//| Input parameters:                                                |
//|     A       -   matrix, array[0..N-1, 0..N-1].                   |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   True, if the matrix is upper triangular.         |
//|     IsUnit  -   diagonal type (optional):                        |
//|                 * if True, matrix has unit diagonal (a[i,i] are  |
//|                   NOT used)                                      |
//|                 * if False, matrix diagonal is arbitrary         |
//|                 * if not given, False is assumed                 |
//| Output parameters:                                               |
//|     Info    -   same as for RMatrixLUInverse                     |
//|     Rep     -   same as for RMatrixLUInverse                     |
//|     A       -   same as for RMatrixLUInverse.                    |
//+------------------------------------------------------------------+
void CAlglib::RMatrixTrInverse(CMatrixDouble &a,const int n,
                               const bool IsUpper,const bool IsUnit,
                               int &info,CMatInvReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMatInv::RMatrixTrInverse(a,n,IsUpper,IsUnit,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Triangular matrix inverse (real)                                 |
//| The subroutine inverts the following types of matrices:          |
//|     * upper triangular                                           |
//|     * upper triangular with unit diagonal                        |
//|     * lower triangular                                           |
//|     * lower triangular with unit diagonal                        |
//| In case of an upper (lower) triangular matrix, the inverse matrix|
//| will also be upper (lower) triangular, and after the end of the  |
//| algorithm, the inverse matrix replaces the source matrix. The    |
//| elements below (above) the main diagonal are not changed by the  |
//| algorithm.                                                       |
//| If the matrix has a unit diagonal, the inverse matrix also has a |
//| unit diagonal, and the diagonal elements are not passed to the   |
//| algorithm.                                                       |
//| Input parameters:                                                |
//|     A       -   matrix, array[0..N-1, 0..N-1].                   |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   True, if the matrix is upper triangular.         |
//|     IsUnit  -   diagonal type (optional):                        |
//|                 * if True, matrix has unit diagonal (a[i,i] are  |
//|                   NOT used)                                      |
//|                 * if False, matrix diagonal is arbitrary         |
//|                 * if not given, False is assumed                 |
//| Output parameters:                                               |
//|     Info    -   same as for RMatrixLUInverse                     |
//|     Rep     -   same as for RMatrixLUInverse                     |
//|     A       -   same as for RMatrixLUInverse.                    |
//+------------------------------------------------------------------+
void CAlglib::RMatrixTrInverse(CMatrixDouble &a,const bool IsUpper,
                               int &info,CMatInvReportShell &rep)
  {
//--- check
   if((CAp::Cols(a)!=CAp::Rows(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info=0;
   int  n=(int)CAp::Cols(a);
   bool IsUnit=false;
//--- function call
   CMatInv::RMatrixTrInverse(a,n,IsUpper,IsUnit,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Triangular matrix inverse (complex)                              |
//| The subroutine inverts the following types of matrices:          |
//|     * upper triangular                                           |
//|     * upper triangular with unit diagonal                        |
//|     * lower triangular                                           |
//|     * lower triangular with unit diagonal                        |
//| In case of an upper (lower) triangular matrix, the inverse matrix|
//| will also be upper (lower) triangular, and after the end of the  |
//| algorithm, the inverse matrix replaces the source matrix. The    |
//| elements below (above) the main diagonal are not changed by the  |
//| algorithm.                                                       |
//| If the matrix has a unit diagonal, the inverse matrix also has a |
//| unit diagonal, and the diagonal elements are not passed to the   |
//| algorithm.                                                       |
//| Input parameters:                                                |
//|     A       -   matrix, array[0..N-1, 0..N-1].                   |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   True, if the matrix is upper triangular.         |
//|     IsUnit  -   diagonal type (optional):                        |
//|                 * if True, matrix has unit diagonal (a[i,i] are  |
//|                   NOT used)                                      |
//|                 * if False, matrix diagonal is arbitrary         |
//|                 * if not given, False is assumed                 |
//| Output parameters:                                               |
//|     Info    -   same as for RMatrixLUInverse                     |
//|     Rep     -   same as for RMatrixLUInverse                     |
//|     A       -   same as for RMatrixLUInverse.                    |
//+------------------------------------------------------------------+
void CAlglib::CMatrixTrInverse(CMatrixComplex &a,const int n,
                               const bool IsUpper,const bool IsUnit,
                               int &info,CMatInvReportShell &rep)
  {
//--- initialization
   info=0;
//--- function call
   CMatInv::CMatrixTrInverse(a,n,IsUpper,IsUnit,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Triangular matrix inverse (complex)                              |
//| The subroutine inverts the following types of matrices:          |
//|     * upper triangular                                           |
//|     * upper triangular with unit diagonal                        |
//|     * lower triangular                                           |
//|     * lower triangular with unit diagonal                        |
//| In case of an upper (lower) triangular matrix, the inverse matrix|
//| will also be upper (lower) triangular, and after the end of the  |
//| algorithm, the inverse matrix replaces the source matrix. The    |
//| elements below (above) the main diagonal are not changed by the  |
//| algorithm.                                                       |
//| If the matrix has a unit diagonal, the inverse matrix also has a |
//| unit diagonal, and the diagonal elements are not passed to the   |
//| algorithm.                                                       |
//| Input parameters:                                                |
//|     A       -   matrix, array[0..N-1, 0..N-1].                   |
//|     N       -   size of matrix A (optional) :                    |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, size is automatically determined |
//|                   from matrix size (A must be square matrix)     |
//|     IsUpper -   True, if the matrix is upper triangular.         |
//|     IsUnit  -   diagonal type (optional):                        |
//|                 * if True, matrix has unit diagonal (a[i,i] are  |
//|                   NOT used)                                      |
//|                 * if False, matrix diagonal is arbitrary         |
//|                 * if not given, False is assumed                 |
//| Output parameters:                                               |
//|     Info    -   same as for RMatrixLUInverse                     |
//|     Rep     -   same as for RMatrixLUInverse                     |
//|     A       -   same as for RMatrixLUInverse.                    |
//+------------------------------------------------------------------+
void CAlglib::CMatrixTrInverse(CMatrixComplex &a,const bool IsUpper,
                               int &info,CMatInvReportShell &rep)
  {
//--- check
   if((CAp::Cols(a)!=CAp::Rows(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   info=0;
   int  n=(int)CAp::Cols(a);
   bool IsUnit=false;
//--- function call
   CMatInv::CMatrixTrInverse(a,n,IsUpper,IsUnit,info,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Singular value decomposition of a bidiagonal matrix (extended    |
//| algorithm)                                                       |
//| The algorithm performs the singular value decomposition of a     |
//| bidiagonal matrix B (upper or lower) representing it as          |
//| B = Q*S*P^T, where Q and P - orthogonal matrices, S - diagonal   |
//| matrix with non-negative elements on the main diagonal, in       |
//| descending order.                                                |
//| The algorithm finds singular values. In addition, the algorithm  |
//| can calculate matrices Q and P (more precisely, not the matrices,|
//| but their product with given matrices U and VT - U*Q and         |
//| (P^T)*VT)). Of course, matrices U and VT can be of any type,     |
//| including identity. Furthermore, the algorithm can calculate Q'*C|
//| (this product is calculated more effectively than U*Q, because   |
//| this calculation operates with rows instead  of matrix columns). |
//| The feature of the algorithm is its ability to find all singular |
//| values including those which are arbitrarily close to 0 with     |
//| relative accuracy close to  machine precision. If the parameter  |
//| IsFractionalAccuracyRequired is set to True, all singular values |
//| will have high relative accuracy close to machine precision. If  |
//| the parameter is set to False, only the biggest singular value   |
//| will have relative accuracy close to machine precision. The      |
//| absolute error of other singular values is equal to the absolute |
//| error of the biggest singular value.                             |
//| Input parameters:                                                |
//|     D       -   main diagonal of matrix B.                       |
//|                 Array whose index ranges within [0..N-1].        |
//|     E       -   superdiagonal (or subdiagonal) of matrix B.      |
//|                 Array whose index ranges within [0..N-2].        |
//|     N       -   size of matrix B.                                |
//|     IsUpper -   True, if the matrix is upper bidiagonal.         |
//|     IsFractionalAccuracyRequired -                               |
//|                 accuracy to search singular values with.         |
//|     U       -   matrix to be multiplied by Q.                    |
//|                 Array whose indexes range within                 |
//|                 [0..NRU-1, 0..N-1].                              |
//|                 The matrix can be bigger, in that case only the  |
//|                 submatrix [0..NRU-1, 0..N-1] will be multiplied  |
//|                 by Q.                                            |
//|     NRU     -   number of rows in matrix U.                      |
//|     C       -   matrix to be multiplied by Q'.                   |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..NCC-1].                              |
//|                 The matrix can be bigger, in that case only the  |
//|                 submatrix [0..N-1, 0..NCC-1] will be multiplied  |
//|                 by Q'.                                           |
//|     NCC     -   number of columns in matrix C.                   |
//|     VT      -   matrix to be multiplied by P^T.                  |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..NCVT-1].                             |
//|                 The matrix can be bigger, in that case only the  |
//|                 submatrix [0..N-1, 0..NCVT-1] will be multiplied |
//|                 by P^T.                                          |
//|     NCVT    -   number of columns in matrix VT.                  |
//| Output parameters:                                               |
//|     D       -   singular values of matrix B in descending order. |
//|     U       -   if NRU>0, contains matrix U*Q.                   |
//|     VT      -   if NCVT>0, contains matrix (P^T)*VT.             |
//|     C       -   if NCC>0, contains matrix Q'*C.                  |
//| Result:                                                          |
//|     True, if the algorithm has converged.                        |
//|     False, if the algorithm hasn't converged (rare case).        |
//| Additional information:                                          |
//|     The type of convergence is controlled by the internal        |
//|     parameter TOL. If the parameter is greater than 0, the       |
//|     singular values will have relative accuracy TOL. If TOL<0,   |
//|     the singular values will have absolute accuracy              |
//|     ABS(TOL)*norm(B). By default, |TOL| falls within the range of|
//|     10*Epsilon and 100*Epsilon, where Epsilon is the machine     |
//|     precision. It is not recommended to use TOL less than        |
//|     10*Epsilon since this will considerably slow down the        |
//|     algorithm and may not lead to error decreasing.              |
//| History:                                                         |
//|     * 31 March, 2007.                                            |
//|         changed MAXITR from 6 to 12.                             |
//|   -- LAPACK routine (version 3.0) --                             |
//|      Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd., |
//|      Courant Institute, Argonne National Lab, and Rice University|
//|      October 31, 1999.                                           |
//+------------------------------------------------------------------+
bool CAlglib::RMatrixBdSVD(double &d[],double &e[],const int n,
                           const bool IsUpper,
                           bool isfractionalaccuracyrequired,
                           CMatrixDouble &u,const int nru,
                           CMatrixDouble &c,const int ncc,
                           CMatrixDouble &vt,const int ncvt)
  {
   return(CBdSingValueDecompose::RMatrixBdSVD(d,e,n,IsUpper,isfractionalaccuracyrequired,u,nru,c,ncc,vt,ncvt));
  }
//+------------------------------------------------------------------+
//| Singular value decomposition of a rectangular matrix.            |
//| The algorithm calculates the singular value decomposition of a   |
//| matrix of size MxN: A = U * S * V^T                              |
//| The algorithm finds the singular values and, optionally, matrices|
//| U and V^T. The algorithm can find both first min(M,N) columns of |
//| matrix U and rows of matrix V^T (singular vectors), and matrices |
//| U and V^T wholly (of sizes MxM and NxN respectively).            |
//| Take into account that the subroutine does not return matrix V   |
//| but V^T.                                                         |
//| Input parameters:                                                |
//|     A           -   matrix to be decomposed.                     |
//|                     Array whose indexes range within             |
//|                     [0..M-1, 0..N-1].                            |
//|     M           -   number of rows in matrix A.                  |
//|     N           -   number of columns in matrix A.               |
//|     UNeeded     -   0, 1 or 2. See the description of the        |
//|                     parameter U.                                 |
//|     VTNeeded    -   0, 1 or 2. See the description of the        |
//|                     parameter VT.                                |
//|     AdditionalMemory -                                           |
//|                     If the parameter:                            |
//|                      * equals 0, the algorithm doesn?t use       |
//|                        additional memory (lower requirements,    |
//|                        lower performance).                       |
//|                      * equals 1, the algorithm uses additional   |
//|                        memory of size min(M,N)*min(M,N) of real  |
//|                        numbers. It often speeds up the algorithm.|
//|                      * equals 2, the algorithm uses additional   |
//|                        memory of size M*min(M,N) of real numbers.|
//|                        It allows to get a maximum performance.   |
//|                     The recommended value of the parameter is 2. |
//| Output parameters:                                               |
//|     W           -   contains singular values in descending order.|
//|     U           -   if UNeeded=0, U isn't changed, the left      |
//|                     singular vectors are not calculated.         |
//|                     if Uneeded=1, U contains left singular       |
//|                     vectors (first min(M,N) columns of matrix U).|
//|                     Array whose indexes range within             |
//|                     [0..M-1, 0..Min(M,N)-1]. if UNeeded=2, U     |
//|                     contains matrix U wholly. Array whose indexes|
//|                     range within [0..M-1, 0..M-1].               |
//|     VT          -   if VTNeeded=0, VT isn?t changed, the right   |
//|                     singular vectors are not calculated.         |
//|                     if VTNeeded=1, VT contains right singular    |
//|                     vectors (first min(M,N) rows of matrix V^T). |
//|                     Array whose indexes range within             |
//|                     [0..min(M, N)-1,0..N-1]. if VTNeeded=2, VT   |
//|                     contains matrix V^T wholly. Array whose      |
//|                     indexes range within [0..N-1, 0..N-1].       |
//+------------------------------------------------------------------+
bool CAlglib::RMatrixSVD(CMatrixDouble &a,const int m,const int n,
                         const int uneeded,const int vtneeded,
                         const int additionalmemory,double &w[],
                         CMatrixDouble &u,CMatrixDouble &vt)
  {
   return(CSingValueDecompose::RMatrixSVD(a,m,n,uneeded,vtneeded,additionalmemory,w,u,vt));
  }
//+------------------------------------------------------------------+
//| Determinant calculation of the matrix given by its LU            |
//| decomposition.                                                   |
//| Input parameters:                                                |
//|     A       -   LU decomposition of the matrix (output of        |
//|                 RMatrixLU subroutine).                           |
//|     Pivots  -   table of permutations which were made during     |
//|                 the LU decomposition.                            |
//|                 Output of RMatrixLU subroutine.                  |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//| Result: matrix determinant.                                      |
//+------------------------------------------------------------------+
double CAlglib::RMatrixLUDet(CMatrixDouble &a,int &pivots[],const int n)
  {
   return(CMatDet::RMatrixLUDet(a,pivots,n));
  }
//+------------------------------------------------------------------+
//| Determinant calculation of the matrix given by its LU            |
//| decomposition.                                                   |
//| Input parameters:                                                |
//|     A       -   LU decomposition of the matrix (output of        |
//|                 RMatrixLU subroutine).                           |
//|     Pivots  -   table of permutations which were made during     |
//|                 the LU decomposition.                            |
//|                 Output of RMatrixLU subroutine.                  |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//| Result: matrix determinant.                                      |
//+------------------------------------------------------------------+
double CAlglib::RMatrixLUDet(CMatrixDouble &a,int &pivots[])
  {
//--- check
   if((CAp::Rows(a)!=CAp::Cols(a)) || (CAp::Rows(a)!=CAp::Len(pivots)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return(EMPTY_VALUE);
     }
//--- initialization
   int n=(int)CAp::Rows(a);
//--- return result
   return(CMatDet::RMatrixLUDet(a,pivots,n));
  }
//+------------------------------------------------------------------+
//| Calculation of the determinant of a general matrix               |
//| Input parameters:                                                |
//|     A       -   matrix, array[0..N-1, 0..N-1]                    |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//| Result: determinant of matrix A.                                 |
//+------------------------------------------------------------------+
double CAlglib::RMatrixDet(CMatrixDouble &a,const int n)
  {
   return(CMatDet::RMatrixDet(a,n));
  }
//+------------------------------------------------------------------+
//| Calculation of the determinant of a general matrix               |
//| Input parameters:                                                |
//|     A       -   matrix, array[0..N-1, 0..N-1]                    |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//| Result: determinant of matrix A.                                 |
//+------------------------------------------------------------------+
double CAlglib::RMatrixDet(CMatrixDouble &a)
  {
//--- check
   if((CAp::Rows(a)!=CAp::Cols(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return(EMPTY_VALUE);
     }
//--- initialization
   int n=(int)CAp::Rows(a);
//--- return result
   return(CMatDet::RMatrixDet(a,n));
  }
//+------------------------------------------------------------------+
//| Determinant calculation of the matrix given by its LU            |
//| decomposition.                                                   |
//| Input parameters:                                                |
//|     A       -   LU decomposition of the matrix (output of        |
//|                 RMatrixLU subroutine).                           |
//|     Pivots  -   table of permutations which were made during     |
//|                 the LU decomposition.                            |
//|                 Output of RMatrixLU subroutine.                  |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//| Result: matrix determinant.                                      |
//+------------------------------------------------------------------+
complex CAlglib::CMatrixLUDet(CMatrixComplex &a,int &pivots[],
                              const int n)
  {
   return(CMatDet::CMatrixLUDet(a,pivots,n));
  }
//+------------------------------------------------------------------+
//| Determinant calculation of the matrix given by its LU            |
//| decomposition.                                                   |
//| Input parameters:                                                |
//|     A       -   LU decomposition of the matrix (output of        |
//|                 RMatrixLU subroutine).                           |
//|     Pivots  -   table of permutations which were made during     |
//|                 the LU decomposition.                            |
//|                 Output of RMatrixLU subroutine.                  |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//| Result: matrix determinant.                                      |
//+------------------------------------------------------------------+
complex CAlglib::CMatrixLUDet(CMatrixComplex &a,int &pivots[])
  {
//--- check
   if((CAp::Rows(a)!=CAp::Cols(a)) || (CAp::Rows(a)!=CAp::Len(pivots)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return(EMPTY_VALUE);
     }
//--- initialization
   int n=(int)CAp::Rows(a);
//--- return result
   return(CMatDet::CMatrixLUDet(a,pivots,n));
  }
//+------------------------------------------------------------------+
//| Calculation of the determinant of a general matrix               |
//| Input parameters:                                                |
//|     A       -   matrix, array[0..N-1, 0..N-1]                    |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//| Result: determinant of matrix A.                                 |
//+------------------------------------------------------------------+
complex CAlglib::CMatrixDet(CMatrixComplex &a,const int n)
  {
   return(CMatDet::CMatrixDet(a,n));
  }
//+------------------------------------------------------------------+
//| Calculation of the determinant of a general matrix               |
//| Input parameters:                                                |
//|     A       -   matrix, array[0..N-1, 0..N-1]                    |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//| Result: determinant of matrix A.                                 |
//+------------------------------------------------------------------+
complex CAlglib::CMatrixDet(CMatrixComplex &a)
  {
//--- check
   if((CAp::Rows(a)!=CAp::Cols(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return(EMPTY_VALUE);
     }
//--- initialization
   int n=(int)CAp::Rows(a);
//--- return result
   return(CMatDet::CMatrixDet(a,n));
  }
//+------------------------------------------------------------------+
//| Determinant calculation of the matrix given by the Cholesky      |
//| decomposition.                                                   |
//| Input parameters:                                                |
//|     A       -   Cholesky decomposition,                          |
//|                 output of SMatrixCholesky subroutine.            |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//| As the determinant is equal to the product of squares of diagonal|
//| elements, it?s not necessary to specify which triangle - lower   |
//| or upper - the matrix is stored in.                              |
//| Result:                                                          |
//|     matrix determinant.                                          |
//+------------------------------------------------------------------+
double CAlglib::SPDMatrixCholeskyDet(CMatrixDouble &a,const int n)
  {
   return(CMatDet::SPDMatrixCholeskyDet(a,n));
  }
//+------------------------------------------------------------------+
//| Determinant calculation of the matrix given by the Cholesky      |
//| decomposition.                                                   |
//| Input parameters:                                                |
//|     A       -   Cholesky decomposition,                          |
//|                 output of SMatrixCholesky subroutine.            |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//| As the determinant is equal to the product of squares of diagonal|
//| elements, it?s not necessary to specify which triangle - lower   |
//| or upper - the matrix is stored in.                              |
//| Result:                                                          |
//|     matrix determinant.                                          |
//+------------------------------------------------------------------+
double CAlglib::SPDMatrixCholeskyDet(CMatrixDouble &a)
  {
//--- check
   if((CAp::Rows(a)!=CAp::Cols(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return(EMPTY_VALUE);
     }
//--- initialization
   int n=(int)CAp::Rows(a);
//--- return result
   return(CMatDet::SPDMatrixCholeskyDet(a,n));
  }
//+------------------------------------------------------------------+
//| Determinant calculation of the symmetric positive definite       |
//| matrix.                                                          |
//| Input parameters:                                                |
//|     A       -   matrix. Array with elements [0..N-1, 0..N-1].    |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//|     IsUpper -   (optional) storage type:                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used/changed  by function                      |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if not given, both lower and upper triangles   |
//|                   must be filled.                                |
//| Result:                                                          |
//|     determinant of matrix A.                                     |
//|     If matrix A is not positive definite, exception is thrown.   |
//+------------------------------------------------------------------+
double CAlglib::SPDMatrixDet(CMatrixDouble &a,const int n,
                             const bool IsUpper)
  {
   return(CMatDet::SPDMatrixDet(a,n,IsUpper));
  }
//+------------------------------------------------------------------+
//| Determinant calculation of the symmetric positive definite       |
//| matrix.                                                          |
//| Input parameters:                                                |
//|     A       -   matrix. Array with elements [0..N-1, 0..N-1].    |
//|     N       -   (optional) size of matrix A:                     |
//|                 * if given, only principal NxN submatrix is      |
//|                   processed and overwritten. other elements are  |
//|                   unchanged.                                     |
//|                 * if not given, automatically determined from    |
//|                   matrix size (A must be square matrix)          |
//|     IsUpper -   (optional) storage type:                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used/changed  by function                      |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used/changed by function                       |
//|                 * if not given, both lower and upper triangles   |
//|                   must be filled.                                |
//| Result:                                                          |
//|     determinant of matrix A.                                     |
//|     If matrix A is not positive definite, exception is thrown.   |
//+------------------------------------------------------------------+
double CAlglib::SPDMatrixDet(CMatrixDouble &a)
  {
//--- check
   if((CAp::Rows(a)!=CAp::Cols(a)))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return(EMPTY_VALUE);
     }
   if(!CAp::IsSymmetric(a))
     {
      Print(__FUNCTION__+": 'a' parameter is not symmetric matrix");
      CAp::exception_happened=true;
      return(EMPTY_VALUE);
     }
//--- initialization
   int  n=(int)CAp::Rows(a);
   bool IsUpper=false;
//--- return result
   return(CMatDet::SPDMatrixDet(a,n,IsUpper));
  }
//+------------------------------------------------------------------+
//| Algorithm for solving the following generalized symmetric        |
//| positive-definite eigenproblem:                                  |
//|     A*x = lambda*B*x (1) or                                      |
//|     A*B*x = lambda*x (2) or                                      |
//|     B*A*x = lambda*x (3).                                        |
//| where A is a symmetric matrix, B - symmetric positive-definite   |
//| matrix. The problem is solved by reducing it to an ordinary      |
//| symmetric eigenvalue problem.                                    |
//| Input parameters:                                                |
//|     A           -   symmetric matrix which is given by its upper |
//|                     or lower triangular part.                    |
//|                     Array whose indexes range within             |
//|                     [0..N-1, 0..N-1].                            |
//|     N           -   size of matrices A and B.                    |
//|     IsUpperA    -   storage format of matrix A.                  |
//|     B           -   symmetric positive-definite matrix which is  |
//|                     given by its upper or lower triangular part. |
//|                     Array whose indexes range within             |
//|                     [0..N-1, 0..N-1].                            |
//|     IsUpperB    -   storage format of matrix B.                  |
//|     ZNeeded     -   if ZNeeded is equal to:                      |
//|                      * 0, the eigenvectors are not returned;     |
//|                      * 1, the eigenvectors are returned.         |
//|     ProblemType -   if ProblemType is equal to:                  |
//|                      * 1, the following problem is solved:       |
//|                           A*x = lambda*B*x;                      |
//|                      * 2, the following problem is solved:       |
//|                           A*B*x = lambda*x;                      |
//|                      * 3, the following problem is solved:       |
//|                           B*A*x = lambda*x.                      |
//| Output parameters:                                               |
//|     D           -   eigenvalues in ascending order.              |
//|                     Array whose index ranges within [0..N-1].    |
//|     Z           -   if ZNeeded is equal to:                      |
//|                      * 0, Z hasn?t changed;                      |
//|                      * 1, Z contains eigenvectors.               |
//|                     Array whose indexes range within             |
//|                     [0..N-1, 0..N-1].                            |
//|                     The eigenvectors are stored in matrix        |
//|                     columns. It should be noted that the         |
//|                     eigenvectors in such problems do not form an |
//|                     orthogonal system.                           |
//| Result:                                                          |
//|     True, if the problem was solved successfully.                |
//|     False, if the error occurred during the Cholesky             |
//|     decomposition of matrix B (the matrix isn?t                  |
//|     positive-definite) or during the work of the iterative       |
//|     algorithm for solving the symmetric eigenproblem.            |
//| See also the GeneralizedSymmetricDefiniteEVDReduce subroutine.   |
//+------------------------------------------------------------------+
bool CAlglib::SMatrixGEVD(CMatrixDouble &a,const int n,const bool isuppera,
                          CMatrixDouble &b,const bool isupperb,
                          const int zneeded,const int problemtype,
                          double &d[],CMatrixDouble &z)
  {
   return(CSpdGEVD::SMatrixGEVD(a,n,isuppera,b,isupperb,zneeded,problemtype,d,z));
  }
//+------------------------------------------------------------------+
//| Algorithm for reduction of the following generalized symmetric   |
//| positive- definite eigenvalue problem:                           |
//|     A*x = lambda*B*x (1) or                                      |
//|     A*B*x = lambda*x (2) or                                      |
//|     B*A*x = lambda*x (3)                                         |
//| to the symmetric eigenvalues problem C*y = lambda*y (eigenvalues |
//| of this and the given problems are the same, and the eigenvectors|
//| of the given problem could be obtained by multiplying the        |
//| obtained eigenvectors by the transformation matrix x = R*y).     |
//| Here A is a symmetric matrix, B - symmetric positive-definite    |
//| matrix.                                                          |
//| Input parameters:                                                |
//|     A           -   symmetric matrix which is given by its upper |
//|                     or lower triangular part.                    |
//|                     Array whose indexes range within             |
//|                     [0..N-1, 0..N-1].                            |
//|     N           -   size of matrices A and B.                    |
//|     IsUpperA    -   storage format of matrix A.                  |
//|     B           -   symmetric positive-definite matrix which is  |
//|                     given by its upper or lower triangular part. |
//|                     Array whose indexes range within             |
//|                     [0..N-1, 0..N-1].                            |
//|     IsUpperB    -   storage format of matrix B.                  |
//|     ProblemType -   if ProblemType is equal to:                  |
//|                      * 1, the following problem is solved:       |
//|                           A*x = lambda*B*x;                      |
//|                      * 2, the following problem is solved:       |
//|                           A*B*x = lambda*x;                      |
//|                      * 3, the following problem is solved:       |
//|                           B*A*x = lambda*x.                      |
//| Output parameters:                                               |
//|     A           -   symmetric matrix which is given by its upper |
//|                     or lower triangle depending on IsUpperA.     |
//|                     Contains matrix C. Array whose indexes range |
//|                     within [0..N-1, 0..N-1].                     |
//|     R           -   upper triangular or low triangular           |
//|                     transformation matrix which is used to obtain|
//|                     the eigenvectors of a given problem as the   |
//|                     product of eigenvectors of C (from the right)|
//|                     and matrix R (from the left). If the matrix  |
//|                     is upper triangular, the elements below the  |
//|                     main diagonal are equal to 0 (and vice versa)|
//|                     Thus, we can perform the multiplication      |
//|                     without taking into account the internal     |
//|                     structure (which is an easier though less    |
//|                     effective way). Array whose indexes range    |
//|                     within [0..N-1, 0..N-1].                     |
//|     IsUpperR    -   type of matrix R (upper or lower triangular).|
//| Result:                                                          |
//|     True, if the problem was reduced successfully.               |
//|     False, if the error occurred during the Cholesky             |
//|         decomposition of matrix B (the matrix is not             |
//|         positive-definite).                                      |
//+------------------------------------------------------------------+
bool CAlglib::SMatrixGEVDReduce(CMatrixDouble &a,const int n,
                                const bool isuppera,CMatrixDouble &b,
                                const bool isupperb,const int problemtype,
                                CMatrixDouble &r,bool &isupperr)
  {
//--- initialization
   isupperr=false;
//--- return result
   return(CSpdGEVD::SMatrixGEVDReduce(a,n,isuppera,b,isupperb,problemtype,r,isupperr));
  }
//+------------------------------------------------------------------+
//| Inverse matrix update by the Sherman-Morrison formula            |
//| The algorithm updates matrix A^-1 when adding a number to an     |
//| element of matrix A.                                             |
//| Input parameters:                                                |
//|     InvA    -   inverse of matrix A.                             |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..N-1].                                |
//|     N       -   size of matrix A.                                |
//|     UpdRow  -   row where the element to be updated is stored.   |
//|     UpdColumn - column where the element to be updated is stored.|
//|     UpdVal  -   a number to be added to the element.             |
//| Output parameters:                                               |
//|     InvA    -   inverse of modified matrix A.                    |
//+------------------------------------------------------------------+
void CAlglib::RMatrixInvUpdateSimple(CMatrixDouble &inva,const int n,
                                     const int updrow,const int updcolumn,
                                     const double updval)
  {
   CInverseUpdate::RMatrixInvUpdateSimple(inva,n,updrow,updcolumn,updval);
  }
//+------------------------------------------------------------------+
//| Inverse matrix update by the Sherman-Morrison formula            |
//| The algorithm updates matrix A^-1 when adding a vector to a row  |
//| of matrix A.                                                     |
//| Input parameters:                                                |
//|     InvA    -   inverse of matrix A.                             |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..N-1].                                |
//|     N       -   size of matrix A.                                |
//|     UpdRow  -   the row of A whose vector V was added.           |
//|                 0 <= Row <= N-1                                  |
//|     V       -   the vector to be added to a row.                 |
//|                 Array whose index ranges within [0..N-1].        |
//| Output parameters:                                               |
//|     InvA    -   inverse of modified matrix A.                    |
//+------------------------------------------------------------------+
void CAlglib::RMatrixInvUpdateRow(CMatrixDouble &inva,const int n,
                                  const int updrow,double &v[])
  {
   CInverseUpdate::RMatrixInvUpdateRow(inva,n,updrow,v);
  }
//+------------------------------------------------------------------+
//| Inverse matrix update by the Sherman-Morrison formula            |
//| The algorithm updates matrix A^-1 when adding a vector to a      |
//| column of matrix A.                                              |
//| Input parameters:                                                |
//|     InvA        -   inverse of matrix A.                         |
//|                     Array whose indexes range within             |
//|                     [0..N-1, 0..N-1].                            |
//|     N           -   size of matrix A.                            |
//|     UpdColumn   -   the column of A whose vector U was added.    |
//|                     0 <= UpdColumn <= N-1                        |
//|     U           -   the vector to be added to a column.          |
//|                     Array whose index ranges within [0..N-1].    |
//| Output parameters:                                               |
//|     InvA        -   inverse of modified matrix A.                |
//+------------------------------------------------------------------+
void CAlglib::RMatrixInvUpdateColumn(CMatrixDouble &inva,const int n,
                                     const int updcolumn,double &u[])
  {
   CInverseUpdate::RMatrixInvUpdateColumn(inva,n,updcolumn,u);
  }
//+------------------------------------------------------------------+
//| Inverse matrix update by the Sherman-Morrison formula            |
//| The algorithm computes the inverse of matrix A+u*v? by using the |
//| given matrix A^-1 and the vectors u and v.                       |
//| Input parameters:                                                |
//|     InvA    -   inverse of matrix A.                             |
//|                 Array whose indexes range within                 |
//|                 [0..N-1, 0..N-1].                                |
//|     N       -   size of matrix A.                                |
//|     U       -   the vector modifying the matrix.                 |
//|                 Array whose index ranges within [0..N-1].        |
//|     V       -   the vector modifying the matrix.                 |
//|                 Array whose index ranges within [0..N-1].        |
//| Output parameters:                                               |
//|     InvA - inverse of matrix A + u*v'.                           |
//+------------------------------------------------------------------+
void CAlglib::RMatrixInvUpdateUV(CMatrixDouble &inva,const int n,
                                 double &u[],double &v[])
  {
   CInverseUpdate::RMatrixInvUpdateUV(inva,n,u,v);
  }
//+------------------------------------------------------------------+
//| Subroutine performing the Schur decomposition of a general matrix|
//| by using the QR algorithm with multiple shifts.                  |
//| The source matrix A is represented as S'*A*S = T, where S is an  |
//| orthogonal matrix (Schur vectors), T - upper quasi-triangular    |
//| matrix (with blocks of sizes 1x1 and 2x2 on the main diagonal).  |
//| Input parameters:                                                |
//|     A   -   matrix to be decomposed.                             |
//|             Array whose indexes range within [0..N-1, 0..N-1].   |
//|     N   -   size of A, N>=0.                                     |
//| Output parameters:                                               |
//|     A   -   contains matrix T.                                   |
//|             Array whose indexes range within [0..N-1, 0..N-1].   |
//|     S   -   contains Schur vectors.                              |
//|             Array whose indexes range within [0..N-1, 0..N-1].   |
//| Note 1:                                                          |
//|     The block structure of matrix T can be easily recognized:    |
//|     since all the elements below the blocks are zeros, the       |
//|     elements a[i+1,i] which are equal to 0 show the block border.|
//| Note 2:                                                          |
//|     The algorithm performance depends on the value of the        |
//|     internal parameter NS of the InternalSchurDecomposition      |
//|     subroutine which defines the number of shifts in the QR      |
//|     algorithm (similarly to the block width in block-matrix      |
//|     algorithms in linear algebra). If you require maximum        |
//|     performance on your machine, it is recommended to adjust     |
//|     this parameter manually.                                     |
//| Result:                                                          |
//|     True,                                                        |
//|         if the algorithm has converged and parameters A and S    |
//|         contain the result.                                      |
//|     False,                                                       |
//|         if the algorithm has not converged.                      |
//| Algorithm implemented on the basis of the DHSEQR subroutine      |
//| (LAPACK 3.0 library).                                            |
//+------------------------------------------------------------------+
bool CAlglib::RMatrixSchur(CMatrixDouble &a,const int n,CMatrixDouble &s)
  {
   return(CSchur::RMatrixSchur(a,n,s));
  }
//+------------------------------------------------------------------+
//|         NONLINEAR CONJUGATE GRADIENT METHOD                      |
//| DESCRIPTION:                                                     |
//| The subroutine minimizes function F(x) of N arguments by using   |
//| one of the nonlinear conjugate gradient methods.                 |
//| These CG methods are globally convergent (even on non-convex     |
//| functions) as long as grad(f) is Lipschitz continuous in a some  |
//| neighborhood of the L = { x : f(x)<=f(x0) }.                     |
//| REQUIREMENTS:                                                    |
//| Algorithm will request following information during its          |
//| operation:                                                       |
//| * function value F and its gradient G (simultaneously) at given  |
//|   point X                                                        |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with MinCGCreate() call      |
//| 2. User tunes solver parameters with MinCGSetCond(),             |
//|    MinCGSetStpMax() and other functions                          |
//| 3. User calls MinCGOptimize() function which takes algorithm     |
//|    state and pointer (delegate, etc.) to callback function which |
//|    calculates F/G.                                               |
//| 4. User calls MinCGResults() to get solution                     |
//| 5. Optionally, user may call MinCGRestartFrom() to solve another |
//|    problem with same N but another starting point and/or another |
//|    function. MinCGRestartFrom() allows to reuse already          |
//|    initialized structure.                                        |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>0:                          |
//|                 * if given, only leading N elements of X are used|
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     X       -   starting point, array[0..N-1].                   |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::MinCGCreate(const int n,double &x[],CMinCGStateShell &state)
  {
   CMinCG::MinCGCreate(n,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|         NONLINEAR CONJUGATE GRADIENT METHOD                      |
//| DESCRIPTION:                                                     |
//| The subroutine minimizes function F(x) of N arguments by using   |
//| one of the nonlinear conjugate gradient methods.                 |
//| These CG methods are globally convergent (even on non-convex     |
//| functions) as long as grad(f) is Lipschitz continuous in a some  |
//| neighborhood of the L = { x : f(x)<=f(x0) }.                     |
//| REQUIREMENTS:                                                    |
//| Algorithm will request following information during its          |
//| operation:                                                       |
//| * function value F and its gradient G (simultaneously) at given  |
//|   point X                                                        |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with MinCGCreate() call      |
//| 2. User tunes solver parameters with MinCGSetCond(),             |
//|    MinCGSetStpMax() and other functions                          |
//| 3. User calls MinCGOptimize() function which takes algorithm     |
//|    state and pointer (delegate, etc.) to callback function which |
//|    calculates F/G.                                               |
//| 4. User calls MinCGResults() to get solution                     |
//| 5. Optionally, user may call MinCGRestartFrom() to solve another |
//|    problem with same N but another starting point and/or another |
//|    function. MinCGRestartFrom() allows to reuse already          |
//|    initialized structure.                                        |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>0:                          |
//|                 * if given, only leading N elements of X are used|
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     X       -   starting point, array[0..N-1].                   |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::MinCGCreate(double &x[],CMinCGStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinCG::MinCGCreate(n,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| The subroutine is finite difference variant of MinCGCreate().    |
//| It uses finite differences in order to differentiate target      |
//| function.                                                        |
//| Description below contains information which is specific to this |
//| function only. We recommend to read comments on MinCGCreate() in |
//| order to get more information about creation of CG optimizer.    |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>0:                          |
//|                 * if given, only leading N elements of X are     |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     X       -   starting point, array[0..N-1].                   |
//|     DiffStep-   differentiation step, >0                         |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. algorithm uses 4-point central formula for differentiation.   |
//| 2. differentiation step along I-th axis is equal to              |
//|    DiffStep*S[I] where S[] is scaling vector which can be set by |
//|    MinCGSetScale() call.                                         |
//| 3. we recommend you to use moderate values of differentiation    |
//|    step. Too large step will result in too large truncation      |
//|    errors, while too small step will result in too large         |
//|    numerical errors. 1.0E-6 can be good value to start with.     |
//| 4. Numerical differentiation is very inefficient - one gradient  |
//|    calculation needs 4*N function evaluations. This function will|
//|    work for any N - either small (1...10), moderate (10...100) or|
//|    large  (100...). However, performance penalty will be too     |
//|    severe for any N's except for small ones.                     |
//|    We should also say that code which relies on numerical        |
//|    differentiation is less robust and precise. L-BFGS  needs     |
//|    exact gradient values. Imprecise gradient may slow down       |
//|    convergence, especially on highly nonlinear problems.         |
//|    Thus we recommend to use this function for fast prototyping   |
//|    on small- dimensional problems only, and to implement         |
//|    analytical gradient as soon as possible.                      |
//+------------------------------------------------------------------+
void CAlglib::MinCGCreateF(const int n,double &x[],double diffstep,
                           CMinCGStateShell &state)
  {
   CMinCG::MinCGCreateF(n,x,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| The subroutine is finite difference variant of MinCGCreate().    |
//| It uses finite differences in order to differentiate target      |
//| function.                                                        |
//| Description below contains information which is specific to this |
//| function only. We recommend to read comments on MinCGCreate() in |
//| order to get more information about creation of CG optimizer.    |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>0:                          |
//|                 * if given, only leading N elements of X are     |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     X       -   starting point, array[0..N-1].                   |
//|     DiffStep-   differentiation step, >0                         |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. algorithm uses 4-point central formula for differentiation.   |
//| 2. differentiation step along I-th axis is equal to              |
//|    DiffStep*S[I] where S[] is scaling vector which can be set by |
//|    MinCGSetScale() call.                                         |
//| 3. we recommend you to use moderate values of differentiation    |
//|    step. Too large step will result in too large truncation      |
//|    errors, while too small step will result in too large         |
//|    numerical errors. 1.0E-6 can be good value to start with.     |
//| 4. Numerical differentiation is very inefficient - one gradient  |
//|    calculation needs 4*N function evaluations. This function will|
//|    work for any N - either small (1...10), moderate (10...100) or|
//|    large  (100...). However, performance penalty will be too     |
//|    severe for any N's except for small ones.                     |
//|    We should also say that code which relies on numerical        |
//|    differentiation is less robust and precise. L-BFGS  needs     |
//|    exact gradient values. Imprecise gradient may slow down       |
//|    convergence, especially on highly nonlinear problems.         |
//|    Thus we recommend to use this function for fast prototyping   |
//|    on small- dimensional problems only, and to implement         |
//|    analytical gradient as soon as possible.                      |
//+------------------------------------------------------------------+
void CAlglib::MinCGCreateF(double &x[],double diffstep,
                           CMinCGStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinCG::MinCGCreateF(n,x,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function sets stopping conditions for CG optimization       |
//| algorithm.                                                       |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     EpsG    -   >=0                                              |
//|                 The subroutine finishes its work if the condition|
//|                 |v|<EpsG is satisfied, where:                    |
//|                 * |.| means Euclidian norm                       |
//|                 * v - scaled gradient vector, v[i]=g[i]*s[i]     |
//|                 * g - gradient                                   |
//|                 * s - scaling coefficients set by MinCGSetScale()|
//|     EpsF    -   >=0                                              |
//|                 The subroutine finishes its work if on k+1-th    |
//|                 iteration the condition |F(k+1)-F(k)| <=         |
//|                 <= EpsF*max{|F(k)|,|F(k+1)|,1} is satisfied.     |
//|     EpsX    -   >=0                                              |
//|                 The subroutine finishes its work if on k+1-th    |
//|                 iteration the condition |v|<=EpsX is fulfilled,  |
//|                 where:                                           |
//|                 * |.| means Euclidian norm                       |
//|                 * v - scaled step vector, v[i]=dx[i]/s[i]        |
//|                 * dx - ste pvector, dx=X(k+1)-X(k)               |
//|                 * s - scaling coefficients set by MinCGSetScale()|
//|     MaxIts  -   maximum number of iterations. If MaxIts=0, the   |
//|                 number of iterations is unlimited.               |
//| Passing EpsG=0, EpsF=0, EpsX=0 and MaxIts=0 (simultaneously) will|
//| lead to automatic stopping criterion selection (small EpsX).     |
//+------------------------------------------------------------------+
void CAlglib::MinCGSetCond(CMinCGStateShell &state,double epsg,
                           double epsf,double epsx,int maxits)
  {
   CMinCG::MinCGSetCond(state.GetInnerObj(),epsg,epsf,epsx,maxits);
  }
//+------------------------------------------------------------------+
//| This function sets scaling coefficients for CG optimizer.        |
//| ALGLIB optimizers use scaling matrices to test stopping          |
//| conditions (step size and gradient are scaled before comparison  |
//| with tolerances). Scale of the I-th variable is a translation    |
//| invariant measure of:                                            |
//| a) "how large" the variable is                                   |
//| b) how large the step should be to make significant changes in   |
//|    the function                                                  |
//| Scaling is also used by finite difference variant of CG          |
//| optimizer - step along I-th axis is equal to DiffStep*S[I].      |
//| In most optimizers (and in the CG too) scaling is NOT a form of  |
//| preconditioning. It just affects stopping conditions. You should |
//| set preconditioner by separate call to one of the                |
//| MinCGSetPrec...() functions.                                     |
//| There is special preconditioning mode, however, which uses       |
//| scaling coefficients to form diagonal preconditioning matrix.    |
//| You can turn this mode on, if you want. But you should understand|
//| that scaling is not the same thing as preconditioning - these are|
//| two different, although related forms of tuning solver.          |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure stores algorithm state                 |
//|     S       -   array[N], non-zero scaling coefficients          |
//|                 S[i] may be negative, sign doesn't matter.       |
//+------------------------------------------------------------------+
void CAlglib::MinCGSetScale(CMinCGStateShell &state,double &s[])
  {
   CMinCG::MinCGSetScale(state.GetInnerObj(),s);
  }
//+------------------------------------------------------------------+
//| This function turns on/off reporting.                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     NeedXRep-   whether iteration reports are needed or not      |
//| If NeedXRep is True, algorithm will call rep() callback function |
//| if it is provided to MinCGOptimize().                            |
//+------------------------------------------------------------------+
void CAlglib::MinCGSetXRep(CMinCGStateShell &state,bool needxrep)
  {
   CMinCG::MinCGSetXRep(state.GetInnerObj(),needxrep);
  }
//+------------------------------------------------------------------+
//| This function sets CG algorithm.                                 |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     CGType  -   algorithm type:                                  |
//|                 * -1    automatic selection of the best          |
//|                         algorithm                                |
//|                 * 0     DY (Dai and Yuan) algorithm              |
//|                 * 1     Hybrid DY-HS algorithm                   |
//+------------------------------------------------------------------+
void CAlglib::MinCGSetCGType(CMinCGStateShell &state,int cgtype)
  {
   CMinCG::MinCGSetCGType(state.GetInnerObj(),cgtype);
  }
//+------------------------------------------------------------------+
//| This function sets maximum step length                           |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     StpMax  -   maximum step length, >=0. Set StpMax to 0.0, if  |
//|                 you don't want to limit step length.             |
//| Use this subroutine when you optimize target function which      |
//| contains exp() or other fast growing functions, and optimization |
//| algorithm makes too large steps which leads to overflow. This    |
//| function allows us to reject steps that are too large (and       |
//| therefore expose us to the possible overflow) without actually   |
//| calculating function value at the x+stp*d.                       |
//+------------------------------------------------------------------+
void CAlglib::MinCGSetStpMax(CMinCGStateShell &state,double stpmax)
  {
   CMinCG::MinCGSetStpMax(state.GetInnerObj(),stpmax);
  }
//+------------------------------------------------------------------+
//| This function allows to suggest initial step length to the CG    |
//| algorithm.                                                       |
//| Suggested step length is used as starting point for the line     |
//| search. It can be useful when you have badly scaled problem, i.e.|
//| when ||grad|| (which is used as initial estimate for the first   |
//| step) is many orders of magnitude different from the desired     |
//| step.                                                            |
//| Line search may fail on such problems without good estimate of   |
//| initial step length. Imagine, for example, problem with          |
//| ||grad||=10^50 and desired step equal to 0.1 Line search         |
//| function will use 10^50 as initial step, then it will decrease   |
//| step length by 2 (up to 20 attempts) and will get 10^44, which is|
//| still too large.                                                 |
//| This function allows us to tell than line search should be       |
//| started from some moderate step length, like 1.0, so algorithm   |
//| will be able to detect desired step length in a several searches.|
//| Default behavior (when no step is suggested) is to use           |
//| preconditioner, if it is available, to generate initial estimate |
//| of step length.                                                  |
//| This function influences only first iteration of algorithm. It   |
//| should be called between MinCGCreate/MinCGRestartFrom() call and |
//| MinCGOptimize call. Suggested step is ignored if you have        |
//| preconditioner.                                                  |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure used to store algorithm state.         |
//|     Stp     -   initial estimate of the step length.             |
//|                 Can be zero (no estimate).                       |
//+------------------------------------------------------------------+
void CAlglib::MinCGSuggestStep(CMinCGStateShell &state,double stp)
  {
   CMinCG::MinCGSuggestStep(state.GetInnerObj(),stp);
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: preconditioning is turned    |
//| off.                                                             |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//| NOTE: you can change preconditioner "on the fly", during         |
//| algorithm iterations.                                            |
//+------------------------------------------------------------------+
void CAlglib::MinCGSetPrecDefault(CMinCGStateShell &state)
  {
   CMinCG::MinCGSetPrecDefault(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: diagonal of approximate      |
//| Hessian is used.                                                 |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     D       -   diagonal of the approximate Hessian,             |
//|                 array[0..N-1], (if larger, only leading N        |
//|                 elements are used).                              |
//| NOTE: you can change preconditioner "on the fly", during         |
//| algorithm iterations.                                            |
//| NOTE 2: D[i] should be positive. Exception will be thrown        |
//| otherwise.                                                       |
//| NOTE 3: you should pass diagonal of approximate Hessian - NOT    |
//| ITS INVERSE.                                                     |
//+------------------------------------------------------------------+
void CAlglib::MinCGSetPrecDiag(CMinCGStateShell &state,double &d[])
  {
   CMinCG::MinCGSetPrecDiag(state.GetInnerObj(),d);
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: scale-based diagonal         |
//| preconditioning.                                                 |
//| This preconditioning mode can be useful when you don't have      |
//| approximate diagonal of Hessian, but you know that your variables|
//| are badly scaled (for example, one variable is in [1,10], and    |
//| another in [1000,100000]), and most part of the ill-conditioning |
//| comes from different scales of vars.                             |
//| In this case simple scale-based  preconditioner,                 |
//| with H[i] = 1/(s[i]^2), can greatly improve convergence.         |
//| IMPRTANT: you should set scale of your variables with            |
//| MinCGSetScale() call (before or after MinCGSetPrecScale() call). |
//| Without knowledge of the scale of your variables scale-based     |
//| preconditioner will be just unit matrix.                         |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//| NOTE: you can change preconditioner "on the fly", during         |
//| algorithm iterations.                                            |
//+------------------------------------------------------------------+
void CAlglib::MinCGSetPrecScale(CMinCGStateShell &state)
  {
   CMinCG::MinCGSetPrecScale(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function provides reverse communication interface           |
//| Reverse communication interface is not documented or recommended |
//| to use.                                                          |
//| See below for functions which provide better documented API      |
//+------------------------------------------------------------------+
bool CAlglib::MinCGIteration(CMinCGStateShell &state)
  {
   return(CMinCG::MinCGIteration(state.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. This function has two different implementations: one which    |
//|    uses exact (analytical) user-supplied  gradient, and one which|
//|    uses function value only and numerically differentiates       |
//|    function in order to obtain gradient.                         |
//|    Depending on the specific function used to create optimizer   |
//|    object (either MinCGCreate() for analytical gradient or       |
//|    MinCGCreateF() for numerical differentiation) you should      |
//|    choose appropriate variant of MinCGOptimize() - one which     |
//|    accepts function AND gradient or one which accepts function   |
//|    ONLY.                                                         |
//|    Be careful to choose variant of MinCGOptimize() which         |
//|    corresponds to your optimization scheme! Table below lists    |
//|    different combinations of callback (function/gradient) passed |
//|    to MinCGOptimize() and specific function used to create       |
//|    optimizer.                                                    |
//|                   |         USER PASSED TO MinCGOptimize()       |
//|    CREATED WITH   |  function only   |  function and gradient    |
//|    ------------------------------------------------------------  |
//|    MinCGCreateF() |     work                FAIL                 |
//|    MinCGCreate()  |     FAIL                work                 |
//|    Here "FAIL" denotes inappropriate combinations of optimizer   |
//|    creation function and MinCGOptimize() version. Attemps to use |
//|    such combination (for example, to create optimizer with       |
//|    MinCGCreateF() and to pass gradient information to            |
//|    MinCGOptimize()) will lead to exception being thrown. Either  |
//|    you did not pass gradient when it WAS needed or you passed    |
//|    gradient when it was NOT needed.                              |
//+------------------------------------------------------------------+
void CAlglib::MinCGOptimize(CMinCGStateShell &state,CNDimensional_Func &func,
                            CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinCGIteration(state))
     {
      //--- check
      if(state.GetNeedF())
        {
         func.Func(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'mincgoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. This function has two different implementations: one which    |
//|    uses exact (analytical) user-supplied  gradient, and one which|
//|    uses function value only and numerically differentiates       |
//|    function in order to obtain gradient.                         |
//|    Depending on the specific function used to create optimizer   |
//|    object (either MinCGCreate() for analytical gradient or       |
//|    MinCGCreateF() for numerical differentiation) you should      |
//|    choose appropriate variant of MinCGOptimize() - one which     |
//|    accepts function AND gradient or one which accepts function   |
//|    ONLY.                                                         |
//|    Be careful to choose variant of MinCGOptimize() which         |
//|    corresponds to your optimization scheme! Table below lists    |
//|    different combinations of callback (function/gradient) passed |
//|    to MinCGOptimize() and specific function used to create       |
//|    optimizer.                                                    |
//|                   |         USER PASSED TO MinCGOptimize()       |
//|    CREATED WITH   |  function only   |  function and gradient    |
//|    ------------------------------------------------------------  |
//|    MinCGCreateF() |     work                FAIL                 |
//|    MinCGCreate()  |     FAIL                work                 |
//|    Here "FAIL" denotes inappropriate combinations of optimizer   |
//|    creation function and MinCGOptimize() version. Attemps to use |
//|    such combination (for example, to create optimizer with       |
//|    MinCGCreateF() and to pass gradient information to            |
//|    MinCGOptimize()) will lead to exception being thrown. Either  |
//|    you did not pass gradient when it WAS needed or you passed    |
//|    gradient when it was NOT needed.                              |
//+------------------------------------------------------------------+
void CAlglib::MinCGOptimize(CMinCGStateShell &state,CNDimensional_Grad &grad,
                            CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinCGIteration(state))
     {
      //--- check
      if(state.GetNeedFG())
        {
         grad.Grad(state.GetInnerObj().m_x,state.GetInnerObj().m_f,state.GetInnerObj().m_g,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'mincgoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| Conjugate gradient results                                       |
//| INPUT PARAMETERS:                                                |
//|     State   -   algorithm state                                  |
//| OUTPUT PARAMETERS:                                               |
//|     X       -   array[0..N-1], solution                          |
//|     Rep     -   optimization report:                             |
//|                 * Rep.TerminationType completetion code:         |
//|                     *  1    relative function improvement is no  |
//|                             more than EpsF.                      |
//|                     *  2    relative step is no more than EpsX.  |
//|                     *  4    gradient norm is no more than EpsG   |
//|                     *  5    MaxIts steps was taken               |
//|                     *  7    stopping conditions are too          |
//|                             stringent, further improvement is    |
//|                             impossible, we return best X found   |
//|                             so far                               |
//|                     *  8    terminated by user                   |
//|                 * Rep.IterationsCount contains iterations count  |
//|                 * NFEV countains number of function calculations |
//+------------------------------------------------------------------+
void CAlglib::MinCGResults(CMinCGStateShell &state,double &x[],
                           CMinCGReportShell &rep)
  {
   CMinCG::MinCGResults(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Conjugate gradient results                                       |
//| Buffered implementation of MinCGResults(), which uses            |
//| pre-allocated buffer to store X[]. If buffer size is too small,  |
//| it resizes buffer.It is intended to be used in the inner cycles  |
//| of performance critical algorithms where array reallocation      |
//| penalty is too large to be ignored.                              |
//+------------------------------------------------------------------+
void CAlglib::MinCGResultsBuf(CMinCGStateShell &state,double &x[],
                              CMinCGReportShell &rep)
  {
   CMinCG::MinCGResultsBuf(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This  subroutine  restarts  CG  algorithm from new point. All    |
//| optimization parameters are left unchanged.                      |
//| This function allows to solve multiple optimization problems     |
//| (which must have same number of dimensions) without object       |
//| reallocation penalty.                                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure used to store algorithm state.         |
//|     X       -   new starting point.                              |
//+------------------------------------------------------------------+
void CAlglib::MinCGRestartFrom(CMinCGStateShell &state,double &x[])
  {
   CMinCG::MinCGRestartFrom(state.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| This subroutine submits request for termination of running       |
//| optimizer. It should be called from user-supplied callback when  |
//| user decides that it is time to "smoothly" terminate optimization|
//| process. As result, optimizer stops at point which was "current  |
//| accepted" when termination request was submitted and returns     |
//| error code 8 (successful termination).                           |
//| INPUT PARAMETERS:                                                |
//|   State    -  optimizer structure                                |
//| NOTE: after request for termination optimizer may perform several|
//|       additional calls to user-supplied callbacks. It does  NOT  |
//|       guarantee to stop immediately - it just guarantees that    |
//|       these additional calls will be discarded later.            |
//| NOTE: calling this function on optimizer which is NOT running    |
//|       will have no effect.                                       |
//| NOTE: multiple calls to this function are possible. First call is|
//|       counted, subsequent calls are silently ignored.            |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSRequestTermination(CMinLBFGSStateShell &state)
  {
   CMinLBFGS::MinLBFGSRequestTermination(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                      BOUND CONSTRAINED OPTIMIZATION              |
//|        WITH ADDITIONAL LINEAR EQUALITY AND INEQUALITY CONSTRAINTS|
//| DESCRIPTION:                                                     |
//| The subroutine minimizes function F(x) of N arguments subject to |
//| any combination of:                                              |
//| * bound constraints                                              |
//| * linear inequality constraints                                  |
//| * linear equality constraints                                    |
//| REQUIREMENTS:                                                    |
//| * user must provide function value and gradient                  |
//| * starting point X0 must be feasible or                          |
//|   not too far away from the feasible set                         |
//| * grad(f) must be Lipschitz continuous on a level set:           |
//|   L = { x : f(x)<=f(x0) }                                        |
//| * function must be defined everywhere on the feasible set F      |
//| USAGE:                                                           |
//| Constrained optimization if far more complex than the            |
//| unconstrained one. Here we give very brief outline of the BLEIC  |
//| optimizer. We strongly recommend you to read examples in the     |
//| ALGLIB Reference Manual and to read ALGLIB User Guide on         |
//| optimization, which is available at                              |
//| http://www.alglib.net/optimization/                              |
//| 1. User initializes algorithm state with MinBLEICCreate() call   |
//| 2. USer adds boundary and/or linear constraints by calling       |
//|    MinBLEICSetBC() and MinBLEICSetLC() functions.                |
//| 3. User sets stopping conditions for underlying unconstrained    |
//|    solver with MinBLEICSetInnerCond() call.                      |
//|    This function controls accuracy of underlying optimization    |
//|    algorithm.                                                    |
//| 4. User sets stopping conditions for outer iteration by calling  |
//|    MinBLEICSetOuterCond() function.                              |
//|    This function controls handling of boundary and inequality    |
//|    constraints.                                                  |
//| 5. Additionally, user may set limit on number of internal        |
//|    iterations by MinBLEICSetMaxIts() call.                       |
//|    This function allows to prevent algorithm from looping        |
//|    forever.                                                      |
//| 6. User calls MinBLEICOptimize() function which takes algorithm  |
//|    state and pointer (delegate, etc.) to callback function       |
//|    which calculates F/G.                                         |
//| 7. User calls MinBLEICResults() to get solution                  |
//| 8. Optionally user may call MinBLEICRestartFrom() to solve       |
//|    another problem with same N but another starting point.       |
//|    MinBLEICRestartFrom() allows to reuse already initialized     |
//|    structure.                                                    |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>0:                          |
//|                 * if given, only leading N elements of X are     |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   size ofX                                       |
//|     X       -   starting point, array[N]:                        |
//|                 * it is better to set X to a feasible point      |
//|                 * but X can be infeasible, in which case         |
//|                   algorithm will try to find feasible point      |
//|                   first, using X as initial approximation.       |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure stores algorithm state                 |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICCreate(const int n,double &x[],CMinBLEICStateShell &state)
  {
   CMinBLEIC::MinBLEICCreate(n,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                      BOUND CONSTRAINED OPTIMIZATION              |
//|        WITH ADDITIONAL LINEAR EQUALITY AND INEQUALITY CONSTRAINTS|
//| DESCRIPTION:                                                     |
//| The subroutine minimizes function F(x) of N arguments subject to |
//| any combination of:                                              |
//| * bound constraints                                              |
//| * linear inequality constraints                                  |
//| * linear equality constraints                                    |
//| REQUIREMENTS:                                                    |
//| * user must provide function value and gradient                  |
//| * starting point X0 must be feasible or                          |
//|   not too far away from the feasible set                         |
//| * grad(f) must be Lipschitz continuous on a level set:           |
//|   L = { x : f(x)<=f(x0) }                                        |
//| * function must be defined everywhere on the feasible set F      |
//| USAGE:                                                           |
//| Constrained optimization if far more complex than the            |
//| unconstrained one. Here we give very brief outline of the BLEIC  |
//| optimizer. We strongly recommend you to read examples in the     |
//| ALGLIB Reference Manual and to read ALGLIB User Guide on         |
//| optimization, which is available at                              |
//| http://www.alglib.net/optimization/                              |
//| 1. User initializes algorithm state with MinBLEICCreate() call   |
//| 2. USer adds boundary and/or linear constraints by calling       |
//|    MinBLEICSetBC() and MinBLEICSetLC() functions.                |
//| 3. User sets stopping conditions for underlying unconstrained    |
//|    solver with MinBLEICSetInnerCond() call.                      |
//|    This function controls accuracy of underlying optimization    |
//|    algorithm.                                                    |
//| 4. User sets stopping conditions for outer iteration by calling  |
//|    MinBLEICSetOuterCond() function.                              |
//|    This function controls handling of boundary and inequality    |
//|    constraints.                                                  |
//| 5. Additionally, user may set limit on number of internal        |
//|    iterations by MinBLEICSetMaxIts() call.                       |
//|    This function allows to prevent algorithm from looping        |
//|    forever.                                                      |
//| 6. User calls MinBLEICOptimize() function which takes algorithm  |
//|    state and pointer (delegate, etc.) to callback function       |
//|    which calculates F/G.                                         |
//| 7. User calls MinBLEICResults() to get solution                  |
//| 8. Optionally user may call MinBLEICRestartFrom() to solve       |
//|    another problem with same N but another starting point.       |
//|    MinBLEICRestartFrom() allows to reuse already initialized     |
//|    structure.                                                    |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>0:                          |
//|                 * if given, only leading N elements of X are     |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   size ofX                                       |
//|     X       -   starting point, array[N]:                        |
//|                 * it is better to set X to a feasible point      |
//|                 * but X can be infeasible, in which case         |
//|                   algorithm will try to find feasible point      |
//|                   first, using X as initial approximation.       |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure stores algorithm state                 |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICCreate(double &x[],CMinBLEICStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinBLEIC::MinBLEICCreate(n,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| The subroutine is finite difference variant of MinBLEICCreate(). |
//| It uses finite differences in order to differentiate target      |
//| function.                                                        |
//| Description below contains information which is specific to this |
//| function only. We recommend to read comments on MinBLEICCreate() |
//| in order to get more information about creation of BLEIC         |
//| optimizer.                                                       |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>0:                          |
//|                 * if given, only leading N elements of X are used|
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     X       -   starting point, array[0..N-1].                   |
//|     DiffStep-   differentiation step, >0                         |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. algorithm uses 4-point central formula for differentiation.   |
//| 2. differentiation step along I-th axis is equal to DiffStep*S[I]|
//|    where S[] is scaling vector which can be set by               |
//|    MinBLEICSetScale() call.                                      |
//| 3. we recommend you to use moderate values of differentiation    |
//|    step. Too large step will result in too large truncation      |
//|    errors, while too small step will result in too large         |
//|    numerical errors. 1.0E-6 can be good value to start with.     |
//| 4. Numerical differentiation is very inefficient - one  gradient |
//|    calculation needs 4*N function evaluations. This function will|
//|    work for any N - either small (1...10), moderate (10...100) or|
//|    large (100...). However, performance penalty will be too      |
//|    severe for any N's except for small ones.                     |
//|    We should also say that code which relies on numerical        |
//|    differentiation is less robust and precise. CG needs exact    |
//|    gradient values. Imprecise gradient may slow down convergence,|
//|    especially on highly nonlinear problems.                      |
//|    Thus we recommend to use this function for fast prototyping on|
//|    small - dimensional problems only, and to implement analytical|
//|    gradient as soon as possible.                                 |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICCreateF(const int n,double &x[],double diffstep,
                              CMinBLEICStateShell &state)
  {
   CMinBLEIC::MinBLEICCreateF(n,x,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| The subroutine is finite difference variant of MinBLEICCreate(). |
//| It uses finite differences in order to differentiate target      |
//| function.                                                        |
//| Description below contains information which is specific to this |
//| function only. We recommend to read comments on MinBLEICCreate() |
//| in order to get more information about creation of BLEIC         |
//| optimizer.                                                       |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>0:                          |
//|                 * if given, only leading N elements of X are used|
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     X       -   starting point, array[0..N-1].                   |
//|     DiffStep-   differentiation step, >0                         |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. algorithm uses 4-point central formula for differentiation.   |
//| 2. differentiation step along I-th axis is equal to DiffStep*S[I]|
//|    where S[] is scaling vector which can be set by               |
//|    MinBLEICSetScale() call.                                      |
//| 3. we recommend you to use moderate values of differentiation    |
//|    step. Too large step will result in too large truncation      |
//|    errors, while too small step will result in too large         |
//|    numerical errors. 1.0E-6 can be good value to start with.     |
//| 4. Numerical differentiation is very inefficient - one  gradient |
//|    calculation needs 4*N function evaluations. This function will|
//|    work for any N - either small (1...10), moderate (10...100) or|
//|    large (100...). However, performance penalty will be too      |
//|    severe for any N's except for small ones.                     |
//|    We should also say that code which relies on numerical        |
//|    differentiation is less robust and precise. CG needs exact    |
//|    gradient values. Imprecise gradient may slow down convergence,|
//|    especially on highly nonlinear problems.                      |
//|    Thus we recommend to use this function for fast prototyping on|
//|    small - dimensional problems only, and to implement analytical|
//|    gradient as soon as possible.                                 |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICCreateF(double &x[],double diffstep,
                              CMinBLEICStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinBLEIC::MinBLEICCreateF(n,x,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function sets boundary constraints for BLEIC optimizer.     |
//| Boundary constraints are inactive by default (after initial      |
//| creation). They are preserved after algorithm restart with       |
//| MinBLEICRestartFrom().                                           |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure stores algorithm state                 |
//|     BndL    -   lower bounds, array[N].                          |
//|                 If some (all) variables are unbounded, you may   |
//|                 specify very small number or -INF.               |
//|     BndU    -   upper bounds, array[N].                          |
//|                 If some (all) variables are unbounded, you may   |
//|                 specify very large number or +INF.               |
//| NOTE 1: it is possible to specify BndL[i]=BndU[i]. In this case  |
//| I-th variable will be "frozen" at X[i]=BndL[i]=BndU[i].          |
//| NOTE 2: this solver has following useful properties:             |
//| * bound constraints are always satisfied exactly                 |
//| * function is evaluated only INSIDE area specified by bound      |
//|   constraints, even when numerical differentiation is used       |
//|   (algorithm adjusts nodes according to boundary constraints)    |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetBC(CMinBLEICStateShell &state,double &bndl[],
                            double &bndu[])
  {
   CMinBLEIC::MinBLEICSetBC(state.GetInnerObj(),bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function sets linear constraints for BLEIC optimizer.       |
//| Linear constraints are inactive by default (after initial        |
//| creation). They are preserved after algorithm restart with       |
//| MinBLEICRestartFrom().                                           |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure previously allocated with              |
//|                MinBLEICCreate call.                              |
//|     C       -   linear constraints, array[K,N+1].                |
//|                 Each row of C represents one constraint, either  |
//|                 equality or inequality (see below):              |
//|                 * first N elements correspond to coefficients,   |
//|                 * last element corresponds to the right part.    |
//|                 All elements of C (including right part) must be |
//|                 finite.                                          |
//|     CT      -   type of constraints, array[K]:                   |
//|                 * if CT[i]>0, then I-th constraint is            |
//|                   C[i,*]*x >= C[i,n+1]                           |
//|                 * if CT[i]=0, then I-th constraint is            |
//|                   C[i,*]*x  = C[i,n+1]                           |
//|                 * if CT[i]<0, then I-th constraint is            |
//|                   C[i,*]*x <= C[i,n+1]                           |
//|     K       -   number of equality/inequality constraints, K>=0: |
//|                 * if given, only leading K elements of C/CT are  |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   sizes of C/CT                                  |
//| NOTE 1: linear (non-bound) constraints are satisfied only        |
//| approximately:                                                   |
//| * there always exists some minor violation (about Epsilon in     |
//|   magnitude) due to rounding errors                              |
//| * numerical differentiation, if used, may lead to function       |
//|   evaluations outside of the feasible area, because algorithm    |
//|   does NOT change numerical differentiation formula according to |
//|   linear constraints.                                            |
//| If you want constraints to be satisfied exactly, try to          |
//| reformulate your problem in such manner that all constraints will|
//| become boundary ones (this kind of constraints is always         |
//| satisfied exactly, both in the final solution and in all         |
//| intermediate points).                                            |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetLC(CMinBLEICStateShell &state,CMatrixDouble &c,
                            int &ct[],const int k)
  {
   CMinBLEIC::MinBLEICSetLC(state.GetInnerObj(),c,ct,k);
  }
//+------------------------------------------------------------------+
//| This function sets linear constraints for BLEIC optimizer.       |
//| Linear constraints are inactive by default (after initial        |
//| creation). They are preserved after algorithm restart with       |
//| MinBLEICRestartFrom().                                           |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure previously allocated with              |
//|                MinBLEICCreate call.                              |
//|     C       -   linear constraints, array[K,N+1].                |
//|                 Each row of C represents one constraint, either  |
//|                 equality or inequality (see below):              |
//|                 * first N elements correspond to coefficients,   |
//|                 * last element corresponds to the right part.    |
//|                 All elements of C (including right part) must be |
//|                 finite.                                          |
//|     CT      -   type of constraints, array[K]:                   |
//|                 * if CT[i]>0, then I-th constraint is            |
//|                   C[i,*]*x >= C[i,n+1]                           |
//|                 * if CT[i]=0, then I-th constraint is            |
//|                   C[i,*]*x  = C[i,n+1]                           |
//|                 * if CT[i]<0, then I-th constraint is            |
//|                   C[i,*]*x <= C[i,n+1]                           |
//|     K       -   number of equality/inequality constraints, K>=0: |
//|                 * if given, only leading K elements of C/CT are  |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   sizes of C/CT                                  |
//| NOTE 1: linear (non-bound) constraints are satisfied only        |
//| approximately:                                                   |
//| * there always exists some minor violation (about Epsilon in     |
//|   magnitude) due to rounding errors                              |
//| * numerical differentiation, if used, may lead to function       |
//|   evaluations outside of the feasible area, because algorithm    |
//|   does NOT change numerical differentiation formula according to |
//|   linear constraints.                                            |
//| If you want constraints to be satisfied exactly, try to          |
//| reformulate your problem in such manner that all constraints will|
//| become boundary ones (this kind of constraints is always         |
//| satisfied exactly, both in the final solution and in all         |
//| intermediate points).                                            |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetLC(CMinBLEICStateShell &state,CMatrixDouble &c,
                            int &ct[])
  {
//--- check
   if(CAp::Rows(c)!=CAp::Len(ct))
     {
      Print(__FUNCTION__+": looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int k=(int)CAp::Rows(c);
//--- function call
   CMinBLEIC::MinBLEICSetLC(state.GetInnerObj(),c,ct,k);
  }
//+------------------------------------------------------------------+
//| This function sets stopping conditions for the underlying        |
//| nonlinear CG optimizer. It controls overall accuracy of solution.|
//| These conditions should be strict enough in order for algorithm  |
//| to converge.                                                     |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     EpsG    -   >=0                                              |
//|                 The subroutine finishes its work if the condition|
//|                 |v|<EpsG is satisfied, where:                    |
//|                 * |.| means Euclidian norm                       |
//|                 * v - scaled gradient vector, v[i]=g[i]*s[i]     |
//|                 * g - gradient                                   |
//|                 * s - scaling coefficients set by                |
//|                       MinBLEICSetScale()                         |
//|     EpsF    -   >=0                                              |
//|                 The subroutine finishes its work if on k+1-th    |
//|                 iteration the condition |F(k+1)-F(k)| <=         |
//|                 <= EpsF*max{|F(k)|,|F(k+1)|,1} is satisfied.     |
//|     EpsX    -   >=0                                              |
//|                 The subroutine finishes its work if on k+1-th    |
//|                 iteration the condition |v|<=EpsX is fulfilled,  |
//|                 where:                                           |
//|                 * |.| means Euclidian norm                       |
//|                 * v - scaled step vector, v[i]=dx[i]/s[i]        |
//|                 * dx - ste pvector, dx=X(k+1)-X(k)               |
//|                 * s - scaling coefficients set by                |
//|                       MinBLEICSetScale()                         |
//| Passing EpsG=0, EpsF=0 and EpsX=0 (simultaneously) will lead to  |
//| automatic stopping criterion selection.                          |
//| These conditions are used to terminate inner iterations. However,|
//| you need to tune termination conditions for outer iterations too.|
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetInnerCond(CMinBLEICStateShell &state,
                                   const double epsg,
                                   const double epsf,
                                   const double epsx)
  {
   CMinBLEIC::MinBLEICSetInnerCond(state.GetInnerObj(),epsg,epsf,epsx);
  }
//+------------------------------------------------------------------+
//| This function sets stopping conditions for outer iteration of    |
//| BLEIC algo.                                                      |
//| These conditions control accuracy of constraint handling and     |
//| amount of infeasibility allowed in the solution.                 |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     EpsX    -   >0, stopping condition on outer iteration step   |
//|                     length                                       |
//|     EpsI    -   >0, stopping condition on infeasibility          |
//| Both EpsX and EpsI must be non-zero.                             |
//| MEANING OF EpsX                                                  |
//| EpsX is a stopping condition for outer iterations. Algorithm will|
//| stop when solution of the current modified subproblem will be    |
//| within EpsX (using 2-norm) of the previous solution.             |
//| MEANING OF EpsI                                                  |
//| EpsI controls feasibility properties - algorithm won't stop until|
//| all inequality constraints will be satisfied with error (distance|
//| from current point to the feasible area) at most EpsI.           |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetOuterCond(CMinBLEICStateShell &state,
                                   const double epsx,const double epsi)
  {
   CMinBLEIC::MinBLEICSetOuterCond(state.GetInnerObj(),epsx,epsi);
  }
//+------------------------------------------------------------------+
//| This function sets scaling coefficients for BLEIC optimizer.     |
//| ALGLIB optimizers use scaling matrices to test stopping          |
//| conditions (step size and gradient are scaled before comparison  |
//| with tolerances). Scale of the I-th variable is a translation    |
//| invariant measure of:                                            |
//| a) "how large" the variable is                                   |
//| b) how large the step should be to make significant changes in   |
//| the function                                                     |
//| Scaling is also used by finite difference variant of the         |
//| optimizer - step along I-th axis is equal to DiffStep*S[I].      |
//| In most optimizers (and in the BLEIC too) scaling is NOT a form  |
//| of preconditioning. It just affects stopping conditions. You     |
//| should set preconditioner by separate call to one of the         |
//| MinBLEICSetPrec...() functions.                                  |
//| There is a special preconditioning mode, however, which uses     |
//| scaling coefficients to form diagonal preconditioning matrix.    |
//| You can turn this mode on, if you want. But you should understand|
//| that scaling is not the same thing as preconditioning - these are|
//| two different, although related forms of tuning solver.          |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure stores algorithm state                 |
//|     S       -   array[N], non-zero scaling coefficients          |
//|                 S[i] may be negative, sign doesn't matter.       |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetScale(CMinBLEICStateShell &state,double &s[])
  {
   CMinBLEIC::MinBLEICSetScale(state.GetInnerObj(),s);
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: preconditioning is turned    |
//| off.                                                             |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetPrecDefault(CMinBLEICStateShell &state)
  {
   CMinBLEIC::MinBLEICSetPrecDefault(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: diagonal of approximate      |
//| Hessian is used.                                                 |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     D       -   diagonal of the approximate Hessian,             |
//|                 array[0..N-1], (if larger, only leading N        |
//|                 elements are used).                              |
//| NOTE 1: D[i] should be positive. Exception will be thrown        |
//|         otherwise.                                               |
//| NOTE 2: you should pass diagonal of approximate Hessian - NOT    |
//|         ITS INVERSE.                                             |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetPrecDiag(CMinBLEICStateShell &state,
                                  double &d[])
  {
   CMinBLEIC::MinBLEICSetPrecDiag(state.GetInnerObj(),d);
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: scale-based diagonal         |
//| preconditioning.                                                 |
//| This preconditioning mode can be useful when you don't have      |
//| approximate diagonal of Hessian, but you know that your variables|
//| are badly scaled (for example, one variable is in [1,10], and    |
//| another in [1000,100000]), and most part of the ill-conditioning |
//| comes from different scales of vars.                             |
//| In this case simple scale-based preconditioner, with H[i] =      |
//| = 1/(s[i]^2), can greatly improve convergence.                   |
//| IMPRTANT: you should set scale of your variables with            |
//| MinBLEICSetScale() call (before or after MinBLEICSetPrecScale()  |
//| call). Without knowledge of the scale of your variables          |
//| scale-based preconditioner will be just unit matrix.             |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetPrecScale(CMinBLEICStateShell &state)
  {
   CMinBLEIC::MinBLEICSetPrecScale(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function allows to stop algorithm after specified number of |
//| inner iterations.                                                |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     MaxIts  -   maximum number of inner iterations.              |
//|                 If MaxIts=0, the number of iterations is         |
//|                 unlimited.                                       |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetMaxIts(CMinBLEICStateShell &state,
                                const int maxits)
  {
   CMinBLEIC::MinBLEICSetMaxIts(state.GetInnerObj(),maxits);
  }
//+------------------------------------------------------------------+
//| This function turns on/off reporting.                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     NeedXRep-   whether iteration reports are needed or not      |
//| If NeedXRep is True, algorithm will call rep() callback function |
//| if it is provided to MinBLEICOptimize().                         |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetXRep(CMinBLEICStateShell &state,bool needxrep)
  {
   CMinBLEIC::MinBLEICSetXRep(state.GetInnerObj(),needxrep);
  }
//+------------------------------------------------------------------+
//| This function sets maximum step length                           |
//| IMPORTANT: this feature is hard to combine with preconditioning. |
//| You can't set upper limit on step length, when you solve         |
//| optimization problem with linear (non-boundary) constraints AND  |
//| preconditioner turned on.                                        |
//| When non-boundary constraints are present, you have to either a) |
//| use preconditioner, or b) use upper limit on step length. YOU    |
//| CAN'T USE BOTH! In this case algorithm will terminate with       |
//| appropriate error code.                                          |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     StpMax  -   maximum step length, >=0. Set StpMax to 0.0, if  |
//|                 you don't want to limit step length.             |
//| Use this subroutine when you optimize target function which      |
//| contains exp() or other fast growing functions, and optimization |
//| algorithm makes too large steps which lead to overflow. This     |
//| function allows us to reject steps that are too large (and       |
//| therefore expose us to the possible overflow) without actually   |
//| calculating function value at the x+stp*d.                       |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetStpMax(CMinBLEICStateShell &state,double stpmax)
  {
   CMinBLEIC::MinBLEICSetStpMax(state.GetInnerObj(),stpmax);
  }
//+------------------------------------------------------------------+
//| This function provides reverse communication interface           |
//| Reverse communication interface is not documented or recommended |
//| to use.                                                          |
//| See below for functions which provide better documented API      |
//+------------------------------------------------------------------+
bool CAlglib::MinBLEICIteration(CMinBLEICStateShell &state)
  {
   return(CMinBLEIC::MinBLEICIteration(state.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. This function has two different implementations: one which    |
//|    uses exact (analytical) user-supplied gradient, and one which |
//|    uses function value only and numerically differentiates       |
//|    function in order to obtain gradient.                         |
//|    Depending on the specific function used to create optimizer   |
//|    object (either MinBLEICCreate() for analytical gradient or    |
//|    MinBLEICCreateF() for numerical differentiation) you should   |
//|    choose appropriate variant of MinBLEICOptimize() - one which  |
//|    accepts function AND gradient or one which accepts function   |
//|    ONLY.                                                         |
//|    Be careful to choose variant of MinBLEICOptimize() which      |
//|    corresponds to your optimization scheme! Table below lists    |
//|    different combinations of callback (function/gradient) passed |
//|    to MinBLEICOptimize() and specific function used to create    |
//|    optimizer.                                                    |
//|                      |         USER PASSED TO MinBLEICOptimize() |
//|    CREATED WITH      |  function only   |  function and gradient |
//|    ------------------------------------------------------------  |
//|    MinBLEICCreateF() |     work                FAIL              |
//|    MinBLEICCreate()  |     FAIL                work              |
//|    Here "FAIL" denotes inappropriate combinations of optimizer   |
//|    creation function and MinBLEICOptimize() version. Attemps to  |
//|    use such combination (for example, to create optimizer with   |
//|    MinBLEICCreateF() and to pass gradient information to         |
//|    MinCGOptimize()) will lead to exception being thrown. Either  |
//|    you did not pass gradient when it WAS needed or you passed    |
//|    gradient when it was NOT needed.                              |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICOptimize(CMinBLEICStateShell &state,CNDimensional_Func &func,
                               CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinBLEICIteration(state))
     {
      //--- check
      if(state.GetNeedF())
        {
         func.Func(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'minbleicoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. This function has two different implementations: one which    |
//|    uses exact (analytical) user-supplied gradient, and one which |
//|    uses function value only and numerically differentiates       |
//|    function in order to obtain gradient.                         |
//|    Depending on the specific function used to create optimizer   |
//|    object (either MinBLEICCreate() for analytical gradient or    |
//|    MinBLEICCreateF() for numerical differentiation) you should   |
//|    choose appropriate variant of MinBLEICOptimize() - one which  |
//|    accepts function AND gradient or one which accepts function   |
//|    ONLY.                                                         |
//|    Be careful to choose variant of MinBLEICOptimize() which      |
//|    corresponds to your optimization scheme! Table below lists    |
//|    different combinations of callback (function/gradient) passed |
//|    to MinBLEICOptimize() and specific function used to create    |
//|    optimizer.                                                    |
//|                      |         USER PASSED TO MinBLEICOptimize() |
//|    CREATED WITH      |  function only   |  function and gradient |
//|    ------------------------------------------------------------  |
//|    MinBLEICCreateF() |     work                FAIL              |
//|    MinBLEICCreate()  |     FAIL                work              |
//|    Here "FAIL" denotes inappropriate combinations of optimizer   |
//|    creation function and MinBLEICOptimize() version. Attemps to  |
//|    use such combination (for example, to create optimizer with   |
//|    MinBLEICCreateF() and to pass gradient information to         |
//|    MinCGOptimize()) will lead to exception being thrown. Either  |
//|    you did not pass gradient when it WAS needed or you passed    |
//|    gradient when it was NOT needed.                              |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICOptimize(CMinBLEICStateShell &state,CNDimensional_Grad &grad,
                               CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinBLEICIteration(state))
     {
      //--- check
      if(state.GetNeedFG())
        {
         grad.Grad(state.GetInnerObj().m_x,state.GetInnerObj().m_f,state.GetInnerObj().m_g,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'minbleicoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| This function activates/deactivates verification of the user-    |
//| supplied analytic gradient.                                      |
//| Upon activation of this option OptGuard integrity checker        |
//| performs numerical differentiation of your target function at the|
//| initial point (note: future versions may also perform check at   |
//| the final point) and compares numerical gradient with analytic   |
//| one provided by you.                                             |
//| If difference is too large, an error flag is set and optimization|
//| session continues. After optimization session is over, you can   |
//| retrieve the report which stores both gradients and specific     |
//| components highlighted as suspicious by the OptGuard.            |
//| The primary OptGuard report can be retrieved with                |
//| MinBLEICOptGuardResults().                                       |
//| IMPORTANT: gradient check is a high-overhead option which will   |
//|            cost you about 3*N additional function evaluations.   |
//|            In many cases it may cost as much as the rest of the  |
//|            optimization session.                                 |
//| YOU SHOULD NOT USE IT IN THE PRODUCTION CODE UNLESS YOU WANT TO  |
//|         CHECK DERIVATIVES PROVIDED BY SOME THIRD PARTY.          |
//| NOTE: unlike previous incarnation of the gradient checking code, |
//|       OptGuard does NOT interrupt optimization even if it        |
//|       discovers bad gradient.                                    |
//| INPUT PARAMETERS:                                                |
//|      State    -  structure used to store algorithm State         |
//|      TestStep -  verification step used for numerical            |
//|                  differentiation:                                |
//|                     * TestStep=0 turns verification off          |
//|                     * TestStep>0 activates verification          |
//|                  You should carefully choose TestStep. Value     |
//|                  which is too large (so large that function      |
//|                  behavior is non-cubic at this scale) will lead  |
//|                  to false alarms. Too short step will result in  |
//|                  rounding errors dominating numerical derivative.|
//| You may use different step for different parameters by means of  |
//| setting scale with MinBLEICSetScale().                           |
//| === EXPLANATION ================================================ |
//| In order to verify gradient algorithm performs following steps:  |
//|   * two trial steps are made to X[i]-TestStep*S[i] and           |
//|     X[i]+TestStep*S[i], where X[i] is i-th component of the      |
//|     initial point and S[i] is a scale of i-th parameter          |
//|   * F(X) is evaluated at these trial points                      |
//|   * we perform one more evaluation in the middle point of the    |
//|     interval                                                     |
//|   * we build cubic model using function values and derivatives at|
//|     trial points and we compare its prediction with actual value |
//|     in the middle point                                          |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICOptGuardGradient(CMinBLEICStateShell &state,double teststep)
  {
   CMinBLEIC::MinBLEICOptGuardGradient(state.GetInnerObj(),teststep);
  }
//+------------------------------------------------------------------+
//| This function activates/deactivates nonsmoothness monitoring     |
//| option of the OptGuard integrity checker. Smoothness monitor     |
//| silently observes solution process and tries to detect ill-posed |
//| problems, i.e. ones with:                                        |
//|   a) discontinuous target function (non-C0)                      |
//|   b) nonsmooth  target function (non-C1)                         |
//| Smoothness monitoring does NOT interrupt optimization even if it |
//| suspects that your problem is nonsmooth. It just sets            |
//| corresponding flags in the OptGuard report which can be retrieved|
//| after optimization is over.                                      |
//| Smoothness monitoring is a moderate overhead option which often  |
//| adds less than 1% to the optimizer running time. Thus, you can   |
//| use it even for large scale problems.                            |
//| NOTE: OptGuard does NOT guarantee that it will always detect     |
//|       C0/C1 continuity violations.                               |
//| First, minor errors are hard to catch - say, a 0.0001 difference |
//| in the model values at two sides of the gap may be due           |
//| to discontinuity of the model - or simply because the model has  |
//| changed.                                                         |
//| Second, C1-violations are especially difficult to detect in a    |
//| noninvasive way. The optimizer usually performs very short steps |
//| near the nonsmoothness, and differentiation usually introduces a |
//| lot of numerical noise. It is hard to tell whether some tiny     |
//| discontinuity in the slope is due to real nonsmoothness or just  |
//| due to numerical noise alone.                                    |
//| Our top priority was to avoid false positives, so in some rare   |
//| cases minor errors may went unnoticed (however, in most cases    |
//| they can be spotted with restart from different initial point).  |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm State                                    |
//|   Level    -  monitoring level:                                  |
//|               * 0 - monitoring is disabled                       |
//|               * 1 - noninvasive low-overhead monitoring; function|
//|                     values and/or gradients are recorded, but    |
//|                     OptGuard does not try to perform additional  |
//|                     evaluations in order to get more information |
//|                     about suspicious locations.                  |
//| === EXPLANATION ================================================ |
//| One major source of headache during optimization is the          |
//| possibility of the coding errors in the target function /        |
//| constraints (or their gradients). Such errors most often manifest|
//| themselves as discontinuity or nonsmoothness of the target /     |
//| constraints.                                                     |
//| Another frequent situation is when you try to optimize something |
//| involving lots of min() and max() operations, i.e. nonsmooth     |
//| target. Although not a coding error, it is nonsmoothness anyway -|
//| and smooth optimizers usually stop right after encountering      |
//| nonsmoothness, well before reaching solution.                    |
//| OptGuard integrity checker helps you to catch such situations: it|
//| monitors function values/gradients being passed to the optimizer |
//| and tries to errors. Upon discovering suspicious pair of points  |
//| it raises appropriate flag (and allows you to continue           |
//| optimization). When optimization is done, you can study OptGuard |
//| result.                                                          |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICOptGuardSmoothness(CMinBLEICStateShell &state,
                                         int level)
  {
   CMinBLEIC::MinBLEICOptGuardSmoothness(state.GetInnerObj(),level);
  }
//+------------------------------------------------------------------+
//| Results of OptGuard integrity check, should be called after      |
//| optimization session is over.                                    |
//| === PRIMARY REPORT ============================================= |
//| OptGuard performs several checks which are intended to catch     |
//| common errors in the implementation of nonlinear function /      |
//| gradient:                                                        |
//|   * incorrect analytic gradient                                  |
//|   * discontinuous (non-C0) target functions (constraints)        |
//|   * nonsmooth  (non-C1) target functions (constraints)           |
//| Each of these checks is activated with appropriate function:     |
//|   * MinBLEICOptGuardGradient() for gradient verification         |
//|   * MinBLEICOptGuardSmoothness() for C0/C1 checks                |
//| Following flags are set when these errors are suspected:         |
//|   * rep.badgradsuspected, and additionally:                      |
//|      * rep.badgradvidx for specific variable (gradient element)  |
//|        suspected                                                 |
//|      * rep.badgradxbase, a point where gradient is tested        |
//|      * rep.badgraduser, user-provided gradient (stored as 2D     |
//|        matrix with single row in order to make report structure  |
//|        compatible with more complex optimizers like MinNLC or    |
//|        MinLM)                                                    |
//|      * rep.badgradnum, reference gradient obtained via numerical |
//|        differentiation (stored as 2D matrix with single row in   |
//|        order to make report structure compatible with more       |
//|        complex optimizers like MinNLC or MinLM)                  |
//|   * rep.nonc0suspected                                           |
//|   * rep.nonc1suspected                                           |
//| === ADDITIONAL REPORTS/LOGS ==================================== |
//| Several different tests are performed to catch C0/C1 errors, you |
//| can find out specific test signaled error by looking to:         |
//|   * rep.nonc0test0positive, for non-C0 test #0                   |
//|   * rep.nonc1test0positive, for non-C1 test #0                   |
//|   * rep.nonc1test1positive, for non-C1 test #1                   |
//| Additional information (including line search logs) can be       |
//| obtained by means of:                                            |
//|   * MinBLEICOptGuardNonC1Test0Results()                          |
//|   * MinBLEICOptGuardNonC1Test1Results()                          |
//| which return detailed error reports, specific points where       |
//| discontinuities were found, and so on.                           |
//| ================================================================ |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm State                                    |
//| OUTPUT PARAMETERS:                                               |
//|   Rep      -  generic OptGuard report; more detailed reports     |
//|               can be retrieved with other functions.             |
//| NOTE: false negatives (nonsmooth problems are not identified as  |
//|       nonsmooth ones) are possible although unlikely.            |
//| The reason is that you need to make several evaluations around   |
//| nonsmoothness in order to accumulate enough information about    |
//| function curvature. Say, if you start right from the nonsmooth   |
//| point, optimizer simply won't get enough data to understand what |
//| is going wrong before it terminates due to abrupt changes in the |
//| derivative. It is also possible that "unlucky" step will move us |
//| to the termination too quickly.                                  |
//| Our current approach is to have less than 0.1% false negatives in|
//| our test examples (measured with multiple restarts from random   |
//| points), and to have exactly 0% false positives.                 |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICOptGuardResults(CMinBLEICStateShell &state,
                                      COptGuardReport &rep)
  {
   CMinBLEIC::MinBLEICOptGuardResults(state.GetInnerObj(),rep);
  }
//+------------------------------------------------------------------+
//| Detailed results of the OptGuard integrity check for             |
//| nonsmoothness test #0                                            |
//| Nonsmoothness (non-C1) test #0 studies function values (not      |
//| gradient!) obtained during line searches and monitors behavior   |
//| of the directional derivative estimate.                          |
//| This test is less powerful than test #1, but it does not depend  |
//| on the gradient values and thus it is more robust against        |
//| artifacts introduced by numerical differentiation.               |
//| Two reports are returned:                                        |
//|  *a "strongest" one, corresponding to line search which had    |
//|       highest value of the nonsmoothness indicator               |
//|  *a "longest" one, corresponding to line search which had more |
//|       function evaluations, and thus is more detailed            |
//| In both cases following fields are returned:                     |
//|   * positive  - is TRUE when test flagged suspicious point;      |
//|                    FALSE if test did not notice anything         |
//|                    (in the latter cases fields below are empty). |
//|   * x0[], d[] - arrays of length N which store initial point and |
//|                 direction for line search (d[] can be normalized,|
//|                 but does not have to)                            |
//|   * stp[], f[]- arrays of length CNT which store step lengths and|
//|                 function values at these points; f[i] is         |
//|                 evaluated in x0+stp[i]*d.                        |
//|   * stpidxa, stpidxb - we suspect that function violates C1      |
//|                 continuity between steps #stpidxa and #stpidxb   |
//|                 (usually we have stpidxb=stpidxa+3, with most    |
//|                 likely position of the violation between         |
//|                 stpidxa+1 and stpidxa+2.                         |
//| ================================================================ |
//| = SHORTLY SPEAKING: build a 2D plot of (stp,f) and look at it -  |
//| =                   you will see where C1 continuity is violated.|
//| ================================================================ |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm State                                    |
//| OUTPUT PARAMETERS:                                               |
//|   StrRep  - C1 test #0 "strong" report                         |
//|   LngRep  - C1 test #0 "long" report                           |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICOptGuardNonC1Test0Results(CMinBLEICStateShell &state,
                                                COptGuardNonC1Test0Report &strrep,
                                                COptGuardNonC1Test0Report &lngrep)
  {
   CMinBLEIC::MinBLEICOptGuardNonC1Test0Results(state.GetInnerObj(),strrep,lngrep);
  }
//+------------------------------------------------------------------+
//| Detailed results of the OptGuard integrity check for             |
//| nonsmoothness test #1                                            |
//| Nonsmoothness (non-C1) test #1 studies individual components of  |
//| the gradient computed during line search.                        |
//| When precise analytic gradient is provided this test is more     |
//| powerful than test #0 which works with function values and       |
//| ignores user-provided gradient. However, test #0 becomes more    |
//| powerful when numerical differentiation is employed (in such     |
//| cases test #1 detects higher levels of numerical noise and       |
//| becomes too conservative).                                       |
//| This test also tells specific components of the gradient which   |
//| violate C1 continuity, which makes it more informative than #0,  |
//| which just tells that continuity is violated.                    |
//| Two reports are returned:                                        |
//|  *a "strongest" one, corresponding to line search which had    |
//|     highest value of the nonsmoothness indicator                 |
//|  *a "longest" one, corresponding to line search which had more |
//|     function evaluations, and thus is more detailed              |
//| In both cases following fields are returned:                     |
//|   * positive  -  is TRUE when test flagged suspicious point;     |
//|                     FALSE if test did not notice anything        |
//|                     (in the latter cases fields below are empty).|
//|   * vidx      -  is an index of the variable in [0,N) with       |
//|                  nonsmooth derivative                            |
//|   * x0[], d[] -  arrays of length N which store initial point and|
//|                  direction for line search (d[] can be normalized|
//|                  but does not have to)                           |
//|   * stp[], g[]-  arrays of length CNT which store step lengths   |
//|                  and gradient values at these points; g[i] is    |
//|                  evaluated in x0+stp[i]*d and contains vidx-th   |
//|                  component of the gradient.                      |
//|   * stpidxa, stpidxb - we suspect that function violates C1      |
//|                  continuity between steps #stpidxa and #stpidxb  |
//|                  (usually we have stpidxb=stpidxa+3, with most   |
//|                  likely position of the violation between        |
//|                  stpidxa+1 and stpidxa+2.                        |
//| ================================================================ |
//| = SHORTLY SPEAKING: build a 2D plot of (stp,f) and look at it -  |
//| =                   you will see where C1 continuity is violated.|
//| ================================================================ |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm State                                    |
//| OUTPUT PARAMETERS:                                               |
//|   StrRep  - C1 test #1 "strong" report                         |
//|   LngRep  - C1 test #1 "long" report                           |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICOptGuardNonC1Test1Results(CMinBLEICStateShell &state,
                                                COptGuardNonC1Test1Report &strrep,
                                                COptGuardNonC1Test1Report &lngrep)
  {
   CMinBLEIC::MinBLEICOptGuardNonC1Test1Results(state.GetInnerObj(),strrep,lngrep);
  }
//+------------------------------------------------------------------+
//| BLEIC results                                                    |
//| INPUT PARAMETERS:                                                |
//|     State   -   algorithm state                                  |
//| OUTPUT PARAMETERS:                                               |
//|     X       -   array[0..N-1], solution                          |
//|     Rep     -   optimization report. You should check Rep.       |
//|                 TerminationType in order to distinguish          |
//|                 successful termination from unsuccessful one.    |
//|                 More information about fields of this structure  |
//|                 can be found in the comments on MinBLEICReport   |
//|                 datatype.                                        |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICResults(CMinBLEICStateShell &state,double &x[],
                              CMinBLEICReportShell &rep)
  {
   CMinBLEIC::MinBLEICResults(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| BLEIC results                                                    |
//| Buffered implementation of MinBLEICResults() which uses          |
//| pre-allocated buffer to store X[]. If buffer size is too small,  |
//| it resizes buffer. It is intended to be used in the inner cycles |
//| of performance critical algorithms where array reallocation      |
//| penalty is too large to be ignored.                              |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICResultsBuf(CMinBLEICStateShell &state,double &x[],
                                 CMinBLEICReportShell &rep)
  {
   CMinBLEIC::MinBLEICResultsBuf(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine restarts algorithm from new point.               |
//| All optimization parameters (including constraints) are left     |
//| unchanged.                                                       |
//| This function allows to solve multiple optimization problems     |
//| (which must have same number of dimensions) without object       |
//| reallocation penalty.                                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure previously allocated with              |
//|                 MinBLEICCreate call.                             |
//|     X       -   new starting point.                              |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICRestartFrom(CMinBLEICStateShell &state,
                                  double &x[])
  {
   CMinBLEIC::MinBLEICRestartFrom(state.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| This subroutine submits request for termination of running       |
//| optimizer. It should be called from user-supplied callback when  |
//| user decides that it is time to "smoothly" terminate optimization|
//| process. As result, optimizer stops at point which was "current  |
//| accepted" when termination  request  was submitted and returns   |
//| error code 8 (successful termination).                           |
//| INPUT PARAMETERS:                                                |
//|   State    -  optimizer structure                                |
//| NOTE: after  request  for  termination  optimizer  may   perform |
//|       several additional calls to user-supplied callbacks. It    |
//|       does NOT guarantee to stop immediately - it just guarantees|
//|       that these additional calls will be discarded later.       |
//| NOTE: calling this function on optimizer which is NOT running    |
//|       will have no effect.                                       |
//| NOTE: multiple calls to this function are possible. First call is|
//|       counted, subsequent calls are silently ignored.            |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICRequestTermination(CMinBLEICStateShell &state)
  {
   CMinBLEIC::MinBLEICRequestTermination(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|         LIMITED MEMORY BFGS METHOD FOR LARGE SCALE OPTIMIZATION  |
//| DESCRIPTION:                                                     |
//| The subroutine minimizes function F(x) of N arguments by using a |
//| quasi - Newton method (LBFGS scheme) which is optimized to use a |
//| minimum  amount of memory.                                       |
//| The subroutine generates the approximation of an inverse Hessian |
//| matrix by using information about the last M steps of the        |
//| algorithm (instead of N). It lessens a required amount of memory |
//| from a value of order N^2 to a value of order 2*N*M.             |
//| REQUIREMENTS:                                                    |
//| Algorithm will request following information during its          |
//| operation:                                                       |
//| * function value F and its gradient G (simultaneously) at given  |
//| point X                                                          |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with MinLBFGSCreate() call   |
//| 2. User tunes solver parameters with MinLBFGSSetCond()           |
//|    MinLBFGSSetStpMax() and other functions                       |
//| 3. User calls MinLBFGSOptimize() function which takes algorithm  |
//|    state and pointer (delegate, etc.) to callback function which |
//|    calculates F/G.                                               |
//| 4. User calls MinLBFGSResults() to get solution                  |
//| 5. Optionally user may call MinLBFGSRestartFrom() to solve       |
//|    another problem with same N/M but another starting point      |
//|    and/or another function. MinLBFGSRestartFrom() allows to reuse|
//|    already initialized structure.                                |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension. N>0                           |
//|     M       -   number of corrections in the BFGS scheme of      |
//|                 Hessian approximation update. Recommended value: |
//|                 3<=M<=7. The smaller value causes worse          |
//|                 convergence, the bigger will not cause a         |
//|                 considerably better convergence, but will cause  |
//|                 a fall in  the performance. M<=N.                |
//|     X       -   initial solution approximation, array[0..N-1].   |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. you may tune stopping conditions with MinLBFGSSetCond()       |
//|    function                                                      |
//| 2. if target function contains exp() or other fast growing       |
//|    functions, and optimization algorithm makes too large steps   |
//|    which leads to overflow, use MinLBFGSSetStpMax() function to  |
//|    bound algorithm's steps. However, L-BFGS rarely needs such a  |
//|    tuning.                                                       |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSCreate(const int n,const int m,double &x[],
                             CMinLBFGSStateShell &state)
  {
   CMinLBFGS::MinLBFGSCreate(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|         LIMITED MEMORY BFGS METHOD FOR LARGE SCALE OPTIMIZATION  |
//| DESCRIPTION:                                                     |
//| The subroutine minimizes function F(x) of N arguments by using a |
//| quasi - Newton method (LBFGS scheme) which is optimized to use a |
//| minimum  amount of memory.                                       |
//| The subroutine generates the approximation of an inverse Hessian |
//| matrix by using information about the last M steps of the        |
//| algorithm (instead of N). It lessens a required amount of memory |
//| from a value of order N^2 to a value of order 2*N*M.             |
//| REQUIREMENTS:                                                    |
//| Algorithm will request following information during its          |
//| operation:                                                       |
//| * function value F and its gradient G (simultaneously) at given  |
//| point X                                                          |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with MinLBFGSCreate() call   |
//| 2. User tunes solver parameters with MinLBFGSSetCond()           |
//|    MinLBFGSSetStpMax() and other functions                       |
//| 3. User calls MinLBFGSOptimize() function which takes algorithm  |
//|    state and pointer (delegate, etc.) to callback function which |
//|    calculates F/G.                                               |
//| 4. User calls MinLBFGSResults() to get solution                  |
//| 5. Optionally user may call MinLBFGSRestartFrom() to solve       |
//|    another problem with same N/M but another starting point      |
//|    and/or another function. MinLBFGSRestartFrom() allows to reuse|
//|    already initialized structure.                                |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension. N>0                           |
//|     M       -   number of corrections in the BFGS scheme of      |
//|                 Hessian approximation update. Recommended value: |
//|                 3<=M<=7. The smaller value causes worse          |
//|                 convergence, the bigger will not cause a         |
//|                 considerably better convergence, but will cause  |
//|                 a fall in  the performance. M<=N.                |
//|     X       -   initial solution approximation, array[0..N-1].   |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. you may tune stopping conditions with MinLBFGSSetCond()       |
//|    function                                                      |
//| 2. if target function contains exp() or other fast growing       |
//|    functions, and optimization algorithm makes too large steps   |
//|    which leads to overflow, use MinLBFGSSetStpMax() function to  |
//|    bound algorithm's steps. However, L-BFGS rarely needs such a  |
//|    tuning.                                                       |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSCreate(const int m,double &x[],CMinLBFGSStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinLBFGS::MinLBFGSCreate(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| The subroutine is finite difference variant of MinLBFGSCreate(). |
//| It uses finite differences in order to differentiate target      |
//| function.                                                        |
//| Description below contains information which is specific to this |
//| function only. We recommend to read comments on MinLBFGSCreate() |
//| in order to get more information about creation of LBFGS         |
//| optimizer.                                                       |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>0:                          |
//|                 * if given, only leading N elements of X are used|
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     M       -   number of corrections in the BFGS scheme of      |
//|                 Hessian approximation update. Recommended value: |
//|                 3<=M<=7. The smaller value causes worse          |
//|                 convergence, the bigger will not cause a         |
//|                 considerably better convergence, but will cause a|
//|                 fall in  the performance. M<=N.                  |
//|     X       -   starting point, array[0..N-1].                   |
//|     DiffStep-   differentiation step, >0                         |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. algorithm uses 4-point central formula for differentiation.   |
//| 2. differentiation step along I-th axis is equal to DiffStep*S[I]|
//|    where S[] is scaling vector which can be set by               |
//|    MinLBFGSSetScale() call.                                      |
//| 3. we recommend you to use moderate values of differentiation    |
//|    step. Too large step will result in too large truncation      |
//|    errors, while too small step will result in too large         |
//|    numerical errors. 1.0E-6 can be good value to start with.     |
//| 4. Numerical differentiation is very inefficient - one gradient  |
//|    calculation needs 4*N function evaluations. This function will|
//|    work for any N - either small (1...10), moderate (10...100) or|
//|    large (100...). However, performance penalty will be too      |
//|    severe for any N's except for small ones.                     |
//|    We should also say that code which relies on numerical        |
//|    differentiation is less robust and precise. LBFGS needs exact |
//|    gradient values. Imprecise gradient may slow down convergence,|
//|    especially on highly nonlinear problems.                      |
//|    Thus we recommend to use this function for fast prototyping on|
//|    small- dimensional problems only, and to implement analytical |
//|    gradient as soon as possible.                                 |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSCreateF(const int n,const int m,double &x[],
                              const double diffstep,CMinLBFGSStateShell &state)
  {
   CMinLBFGS::MinLBFGSCreateF(n,m,x,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| The subroutine is finite difference variant of MinLBFGSCreate(). |
//| It uses finite differences in order to differentiate target      |
//| function.                                                        |
//| Description below contains information which is specific to this |
//| function only. We recommend to read comments on MinLBFGSCreate() |
//| in order to get more information about creation of LBFGS         |
//| optimizer.                                                       |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem dimension, N>0:                          |
//|                 * if given, only leading N elements of X are used|
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     M       -   number of corrections in the BFGS scheme of      |
//|                 Hessian approximation update. Recommended value: |
//|                 3<=M<=7. The smaller value causes worse          |
//|                 convergence, the bigger will not cause a         |
//|                 considerably better convergence, but will cause a|
//|                 fall in  the performance. M<=N.                  |
//|     X       -   starting point, array[0..N-1].                   |
//|     DiffStep-   differentiation step, >0                         |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. algorithm uses 4-point central formula for differentiation.   |
//| 2. differentiation step along I-th axis is equal to DiffStep*S[I]|
//|    where S[] is scaling vector which can be set by               |
//|    MinLBFGSSetScale() call.                                      |
//| 3. we recommend you to use moderate values of differentiation    |
//|    step. Too large step will result in too large truncation      |
//|    errors, while too small step will result in too large         |
//|    numerical errors. 1.0E-6 can be good value to start with.     |
//| 4. Numerical differentiation is very inefficient - one gradient  |
//|    calculation needs 4*N function evaluations. This function will|
//|    work for any N - either small (1...10), moderate (10...100) or|
//|    large (100...). However, performance penalty will be too      |
//|    severe for any N's except for small ones.                     |
//|    We should also say that code which relies on numerical        |
//|    differentiation is less robust and precise. LBFGS needs exact |
//|    gradient values. Imprecise gradient may slow down convergence,|
//|    especially on highly nonlinear problems.                      |
//|    Thus we recommend to use this function for fast prototyping on|
//|    small- dimensional problems only, and to implement analytical |
//|    gradient as soon as possible.                                 |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSCreateF(const int m,double &x[],const double diffstep,
                              CMinLBFGSStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinLBFGS::MinLBFGSCreateF(n,m,x,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function sets stopping conditions for L-BFGS optimization   |
//| algorithm.                                                       |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     EpsG    -   >=0                                              |
//|                 The subroutine finishes its work if the condition|
//|                 |v|<EpsG is satisfied, where:                    |
//|                 * |.| means Euclidian norm                       |
//|                 * v - scaled gradient vector, v[i]=g[i]*s[i]     |
//|                 * g - gradient                                   |
//|                 * s - scaling coefficients set by                |
//|                       MinLBFGSSetScale()                         |
//|     EpsF    -   >=0                                              |
//|                 The subroutine finishes its work if on k+1-th    |
//|                 iteration the condition |F(k+1)-F(k)| <=         |
//|                 <= EpsF*max{|F(k)|,|F(k+1)|,1} is satisfied.     |
//|     EpsX    -   >=0                                              |
//|                 The subroutine finishes its work if on k+1-th    |
//|                 iteration the condition |v|<=EpsX is fulfilled,  |
//|                 where:                                           |
//|                 * |.| means Euclidian norm                       |
//|                 * v - scaled step vector, v[i]=dx[i]/s[i]        |
//|                 * dx - ste pvector, dx=X(k+1)-X(k)               |
//|                 * s - scaling coefficients set by                |
//|                   MinLBFGSSetScale()                             |
//|     MaxIts  -   maximum number of iterations. If MaxIts=0, the   |
//|                 number of iterations is unlimited.               |
//| Passing EpsG=0, EpsF=0, EpsX=0 and MaxIts=0 (simultaneously) will|
//| lead to automatic stopping criterion selection (small EpsX).     |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSSetCond(CMinLBFGSStateShell &state,const double epsg,
                              const double epsf,const double epsx,
                              const int maxits)
  {
   CMinLBFGS::MinLBFGSSetCond(state.GetInnerObj(),epsg,epsf,epsx,maxits);
  }
//+------------------------------------------------------------------+
//| This function turns on/off reporting.                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     NeedXRep-   whether iteration reports are needed or not      |
//| If NeedXRep is True, algorithm will call rep() callback function |
//| if it is provided to MinLBFGSOptimize().                         |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSSetXRep(CMinLBFGSStateShell &state,const bool needxrep)
  {
   CMinLBFGS::MinLBFGSSetXRep(state.GetInnerObj(),needxrep);
  }
//+------------------------------------------------------------------+
//| This function sets maximum step length                           |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     StpMax  -   maximum step length, >=0. Set StpMax to 0.0      |
//|                 (default), if you don't want to limit step       |
//|                 length.                                          |
//| Use this subroutine when you optimize target function which      |
//| contains exp() or other fast growing functions, and optimization |
//| algorithm makes too large steps which leads to overflow. This    |
//| function allows us to reject steps that are too large (and       |
//| therefore expose us to the possible overflow) without actually   |
//| calculating function value at the x+stp*d.                       |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSSetStpMax(CMinLBFGSStateShell &state,const double stpmax)
  {
   CMinLBFGS::MinLBFGSSetStpMax(state.GetInnerObj(),stpmax);
  }
//+------------------------------------------------------------------+
//| This function sets scaling coefficients for LBFGS optimizer.     |
//| ALGLIB optimizers use scaling matrices to test stopping          |
//| conditions (step size and gradient are scaled before comparison  |
//| with tolerances). Scale of the I-th variable is a translation    |
//| invariant measure of:                                            |
//| a) "how large" the variable is                                   |
//| b) how large the step should be to make significant changes in   |
//|    the function                                                  |
//| Scaling is also used by finite difference variant of the         |
//| optimizer - step along I-th axis is equal to DiffStep*S[I].      |
//| In most optimizers (and in the LBFGS too) scaling is NOT a form  |
//| of preconditioning. It just affects stopping conditions. You     |
//| should set preconditioner by separate call to one of the         |
//| MinLBFGSSetPrec...() functions.                                  |
//| There is special preconditioning mode, however, which uses       |
//| scaling coefficients to form diagonal preconditioning matrix.    |
//| You can turn this mode on, if you want. But  you should          |
//| understand that scaling is not the same thing as                 |
//| preconditioning - these are two different, although related      |
//| forms of tuning solver.                                          |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure stores algorithm state                 |
//|     S       -   array[N], non-zero scaling coefficients          |
//|                 S[i] may be negative, sign doesn't matter.       |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSSetScale(CMinLBFGSStateShell &state,double &s[])
  {
   CMinLBFGS::MinLBFGSSetScale(state.GetInnerObj(),s);
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: default preconditioner       |
//| (simple scaling, same for all elements of X) is used.            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//| NOTE: you can change preconditioner "on the fly", during         |
//| algorithm iterations.                                            |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSSetPrecDefault(CMinLBFGSStateShell &state)
  {
   CMinLBFGS::MinLBFGSSetPrecDefault(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: Cholesky factorization of    |
//| approximate Hessian is used.                                     |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     P       -   triangular preconditioner, Cholesky factorization|
//|                 of the approximate Hessian. array[0..N-1,0..N-1],|
//|                 (if larger, only leading N elements are used).   |
//|     IsUpper -   whether upper or lower triangle of P is given    |
//|                 (other triangle is not referenced)               |
//| After call to this function preconditioner is changed to P (P is |
//| copied into the internal buffer).                                |
//| NOTE: you can change preconditioner "on the fly", during         |
//| algorithm iterations.                                            |
//| NOTE 2: P should be nonsingular. Exception will be thrown        |
//| otherwise.                                                       |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSSetPrecCholesky(CMinLBFGSStateShell &state,
                                      CMatrixDouble &p,const bool IsUpper)
  {
   CMinLBFGS::MinLBFGSSetPrecCholesky(state.GetInnerObj(),p,IsUpper);
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: diagonal of approximate      |
//| Hessian is used.                                                 |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     D       -   diagonal of the approximate Hessian,             |
//|                 array[0..N-1], (if larger, only leading N        |
//|                 elements are used).                              |
//| NOTE: you can change preconditioner "on the fly", during         |
//| algorithm iterations.                                            |
//| NOTE 2: D[i] should be positive. Exception will be thrown        |
//| otherwise.                                                       |
//| NOTE 3: you should pass diagonal of approximate Hessian - NOT    |
//| ITS INVERSE.                                                     |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSSetPrecDiag(CMinLBFGSStateShell &state,double &d[])
  {
   CMinLBFGS::MinLBFGSSetPrecDiag(state.GetInnerObj(),d);
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: scale-based diagonal         |
//| preconditioning.                                                 |
//| This preconditioning mode can be useful when you don't have      |
//| approximate diagonal of Hessian, but you know that your variables|
//| are badly scaled (for example, one variable is in [1,10], and    |
//| another in [1000,100000]), and most part of the ill-conditioning |
//| comes from different scales of vars.                             |
//| In this case simple scale-based preconditioner, with H[i] =      |
//| = 1/(s[i]^2), can greatly improve convergence.                   |
//| IMPRTANT: you should set scale of your variables with            |
//| MinLBFGSSetScale() call (before or after MinLBFGSSetPrecScale()  |
//| call). Without knowledge of the scale of your variables          |
//| scale-based preconditioner will be just unit matrix.             |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSSetPrecScale(CMinLBFGSStateShell &state)
  {
   CMinLBFGS::MinLBFGSSetPrecScale(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function provides reverse communication interface           |
//| Reverse communication interface is not documented or recommended |
//| to use.                                                          |
//| See below for functions which provide better documented API      |
//+------------------------------------------------------------------+
bool CAlglib::MinLBFGSIteration(CMinLBFGSStateShell &state)
  {
   return(CMinLBFGS::MinLBFGSIteration(state.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. This function has two different implementations: one which    |
//|    uses exact (analytical) user-supplied gradient, and one which |
//|    uses function value only and numerically differentiates       |
//|    function in order to obtain gradient.                         |
//|    Depending on the specific function used to create optimizer   |
//|    object (either MinLBFGSCreate() for analytical gradient or    |
//|    MinLBFGSCreateF() for numerical differentiation) you should   |
//|    choose appropriate variant of MinLBFGSOptimize() - one which  |
//|    accepts function AND gradient or one which accepts function   |
//|    ONLY.                                                         |
//|    Be careful to choose variant of MinLBFGSOptimize() which      |
//|    corresponds to your optimization scheme! Table below lists    |
//|    different combinations of callback (function/gradient) passed |
//|    to MinLBFGSOptimize()  and specific function used to create   |
//|    optimizer.                                                    |
//|                      |         USER PASSED TO MinLBFGSOptimize() |
//|    CREATED WITH      |  function only   |  function and gradient |
//|    ------------------------------------------------------------  |
//|    MinLBFGSCreateF() |     work                FAIL              |
//|    MinLBFGSCreate()  |     FAIL                work              |
//|    Here "FAIL" denotes inappropriate combinations of optimizer   |
//|    creation function and MinLBFGSOptimize() version. Attemps to  |
//|    use such combination (for example, to create optimizer with   |
//|    MinLBFGSCreateF() and to pass gradient information to         |
//|    MinCGOptimize()) will lead to exception being thrown. Either  |
//|    you  did  not pass gradient when it WAS needed or you passed  |
//|    gradient when it was NOT needed.                              |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSOptimize(CMinLBFGSStateShell &state,CNDimensional_Func &func,
                               CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinLBFGSIteration(state))
     {
      //--- check
      if(state.GetNeedF())
        {
         func.Func(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'minlbfgsoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. This function has two different implementations: one which    |
//|    uses exact (analytical) user-supplied gradient, and one which |
//|    uses function value only and numerically differentiates       |
//|    function in order to obtain gradient.                         |
//|    Depending on the specific function used to create optimizer   |
//|    object (either MinLBFGSCreate() for analytical gradient or    |
//|    MinLBFGSCreateF() for numerical differentiation) you should   |
//|    choose appropriate variant of MinLBFGSOptimize() - one which  |
//|    accepts function AND gradient or one which accepts function   |
//|    ONLY.                                                         |
//|    Be careful to choose variant of MinLBFGSOptimize() which      |
//|    corresponds to your optimization scheme! Table below lists    |
//|    different combinations of callback (function/gradient) passed |
//|    to MinLBFGSOptimize()  and specific function used to create   |
//|    optimizer.                                                    |
//|                      |         USER PASSED TO MinLBFGSOptimize() |
//|    CREATED WITH      |  function only   |  function and gradient |
//|    ------------------------------------------------------------  |
//|    MinLBFGSCreateF() |     work                FAIL              |
//|    MinLBFGSCreate()  |     FAIL                work              |
//|    Here "FAIL" denotes inappropriate combinations of optimizer   |
//|    creation function and MinLBFGSOptimize() version. Attemps to  |
//|    use such combination (for example, to create optimizer with   |
//|    MinLBFGSCreateF() and to pass gradient information to         |
//|    MinCGOptimize()) will lead to exception being thrown. Either  |
//|    you  did  not pass gradient when it WAS needed or you passed  |
//|    gradient when it was NOT needed.                              |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSOptimize(CMinLBFGSStateShell &state,CNDimensional_Grad &grad,
                               CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinLBFGSIteration(state))
     {
      //--- check
      if(state.GetNeedFG())
        {
         grad.Grad(state.GetInnerObj().m_x,state.GetInnerObj().m_f,state.GetInnerObj().m_g,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'minlbfgsoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| L-BFGS algorithm results                                         |
//| INPUT PARAMETERS:                                                |
//|     State   -   algorithm state                                  |
//| OUTPUT PARAMETERS:                                               |
//|     X       -   array[0..N-1], solution                          |
//|     Rep     -   optimization report:                             |
//|                 * Rep.TerminationType completetion code:         |
//|                     * -2    rounding errors prevent further      |
//|                             improvement. X contains best point   |
//|                             found.                               |
//|                     * -1    incorrect parameters were specified  |
//|                     *  1    relative function improvement is no  |
//|                             more than EpsF.                      |
//|                     *  2    relative step is no more than EpsX.  |
//|                     *  4    gradient norm is no more than EpsG   |
//|                     *  5    MaxIts steps was taken               |
//|                     *  7    stopping conditions are too          |
//|                             stringent, further improvement is    |
//|                             impossible                           |
//|                 * Rep.IterationsCount contains iterations count  |
//|                 * NFEV countains number of function calculations |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSResults(CMinLBFGSStateShell &state,double &x[],
                              CMinLBFGSReportShell &rep)
  {
   CMinLBFGS::MinLBFGSResults(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| L-BFGS algorithm results                                         |
//| Buffered implementation of MinLBFGSResults which uses            |
//| pre-allocated buffer to store X[]. If buffer size is too small,  |
//| it resizes buffer. It is intended to be used in the inner cycles |
//| of performance critical algorithms where array reallocation      |
//| penalty is too large to be ignored.                              |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSresultsbuf(CMinLBFGSStateShell &state,double &x[],
                                 CMinLBFGSReportShell &rep)
  {
   CMinLBFGS::MinLBFGSResultsBuf(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This  subroutine restarts LBFGS algorithm from new point. All    |
//| optimization parameters are left unchanged.                      |
//| This function allows to solve multiple optimization problems     |
//| (which must have same number of dimensions) without object       |
//| reallocation penalty.                                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure used to store algorithm state          |
//|     X       -   new starting point.                              |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSRestartFrom(CMinLBFGSStateShell &state,double &x[])
  {
   CMinLBFGS::MinLBFGSRestartFrom(state.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//|                     CONSTRAINED QUADRATIC PROGRAMMING            |
//| The subroutine creates QP optimizer. After initial creation, it  |
//| contains default optimization problem with zero quadratic and    |
//| linear terms and no constraints. You should set quadratic/linear |
//| terms with calls to functions provided by MinQP subpackage.      |
//| INPUT PARAMETERS:                                                |
//|     N       -   problem size                                     |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   optimizer with zero quadratic/linear terms       |
//|                 and no constraints                               |
//+------------------------------------------------------------------+
void CAlglib::MinQPCreate(const int n,CMinQPStateShell &state)
  {
   CMinQP::MinQPCreate(n,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function sets linear term for QP solver.                    |
//| By default, linear term is zero.                                 |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     B       -   linear term, array[N].                           |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetLinearTerm(CMinQPStateShell &state,double &b[])
  {
   CMinQP::MinQPSetLinearTerm(state.GetInnerObj(),b);
  }
//+------------------------------------------------------------------+
//| This function sets quadratic term for QP solver.                 |
//| By default quadratic term is zero.                               |
//| 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                                                         |
//|     f(x) = x^2 + x                                               |
//| you should rewrite your problem as follows:                      |
//|     f(x) = 0.5*(2*x^2) + x                                       |
//| and your matrix A will be equal to [[2.0]], not to [[1.0]]       |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     A       -   matrix, array[N,N]                               |
//|     IsUpper -   (optional) storage type:                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used                                           |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used                                           |
//|                 * if not given, both lower and upper triangles   |
//|                   must be filled.                                |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetQuadraticTerm(CMinQPStateShell &state,CMatrixDouble &a,
                                    const bool IsUpper)
  {
   CMinQP::MinQPSetQuadraticTerm(state.GetInnerObj(),a,IsUpper);
  }
//+------------------------------------------------------------------+
//| This function sets quadratic term for QP solver.                 |
//| By default quadratic term is zero.                               |
//| 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                                                         |
//|     f(x) = x^2 + x                                               |
//| you should rewrite your problem as follows:                      |
//|     f(x) = 0.5*(2*x^2) + x                                       |
//| and your matrix A will be equal to [[2.0]], not to [[1.0]]       |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     A       -   matrix, array[N,N]                               |
//|     IsUpper -   (optional) storage type:                         |
//|                 * if True, symmetric matrix A is given by its    |
//|                   upper triangle, and the lower triangle isn?t   |
//|                   used                                           |
//|                 * if False, symmetric matrix A is given by its   |
//|                   lower triangle, and the upper triangle isn?t   |
//|                   used                                           |
//|                 * if not given, both lower and upper triangles   |
//|                   must be filled.                                |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetQuadraticTerm(CMinQPStateShell &state,CMatrixDouble &a)
  {
//--- check
   if(!CAp::IsSymmetric(a))
     {
      Print(__FUNCTION__+": 'a' parameter is not symmetric matrix");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   bool IsUpper=false;
//--- function call
   CMinQP::MinQPSetQuadraticTerm(state.GetInnerObj(),a,IsUpper);
  }
//+------------------------------------------------------------------+
//| This function sets sparse quadratic term for QP solver. By       |
//| default, quadratic term is zero. This function overrides previous|
//| calls to MinQPSetQuadraticTerm() or MinQPSetQuadraticTermSparse()|
//| NOTE: dense solvers like DENSE-AUL-QP or DENSE-IPM-QP will       |
//|       convert this matrix to dense storage anyway.               |
//| 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                                      |
//|                          f(x) = x^2 + x                          |
//|            you should rewrite your problem as follows:           |
//|                      f(x) = 0.5*(2*x^2) + x                      |
//|            and your matrix A will be equal to [[2.0]], not to    |
//|            [[1.0]]                                               |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//|   A        -  matrix, array[N,N]                                 |
//|   IsUpper  -  (optional) storage type:                           |
//|               * if True, symmetric matrix A is given by its upper|
//|                 triangle, and the lower triangle isn't used      |
//|               * if False, symmetric matrix A is given by its     |
//|                 lower triangle, and the upper triangle isn't used|
//|               * if not given, both lower and upper triangles must|
//|                 be filled.                                       |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetQuadraticTermSparse(CMinQPStateShell &state,
                                          CSparseMatrix &a,bool IsUpper)
  {
   CMinQP::MinQPSetQuadraticTermSparse(state.GetInnerObj(),a,IsUpper);
  }
//+------------------------------------------------------------------+
//| This function sets starting point for QP solver. It is useful to |
//| have good initial approximation to the solution, because it will |
//| increase speed of convergence and identification of active       |
//| constraints.                                                     |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     X       -   starting point, array[N].                        |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetStartingPoint(CMinQPStateShell &state,double &x[])
  {
   CMinQP::MinQPSetStartingPoint(state.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| This  function sets origin for QP solver. By default, following  |
//| QP program is solved:                                            |
//|     min(0.5*x'*A*x+b'*x)                                         |
//| This function allows to solve different problem:                 |
//|     min(0.5*(x-x_origin)'*A*(x-x_origin)+b'*(x-x_origin))        |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     XOrigin -   origin, array[N].                                |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetOrigin(CMinQPStateShell &state,double &xorigin[])
  {
   CMinQP::MinQPSetOrigin(state.GetInnerObj(),xorigin);
  }
//+------------------------------------------------------------------+
//| This function sets scaling coefficients.                         |
//| ALGLIB optimizers use scaling matrices to test stopping          |
//| conditions (step size and gradient are scaled before comparison  |
//| with  tolerances)  and  as preconditioner.                       |
//| Scale of the I-th variable is a translation invariant measure of:|
//|   a) "how large" the variable is                                 |
//|   b) how large the step should be to make significant changes in |
//|      the function                                                |
//| If you do not know how to choose scales of your variables, you   |
//| can:                                                             |
//|   * read www.alglib.net/optimization/scaling.php article         |
//|   * use minqpsetscaleautodiag(), which calculates scale  using   |
//|     diagonal ofthe quadratic term: S is set to 1/sqrt(diag(A)),  |
//|     which works well sometimes.                                  |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//|   S        -  array[N], non-zero scaling coefficients S[i] may   |
//|               be negative, sign doesn't matter.                  |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetScale(CMinQPStateShell &state,CRowDouble &s)
  {
   CMinQP::MinQPSetScale(state.GetInnerObj(),s);
  }
//+------------------------------------------------------------------+
//| This function sets automatic evaluation of variable scaling.     |
//| IMPORTANT: this function works only for  matrices  with positive |
//|            diagonal elements! Zero or negative elements will     |
//|            result in -9 error code being returned. Specify scale |
//|            vector manually with MinQPSetScale() in such cases.   |
//|            ALGLIB optimizers use scaling matrices to test        |
//|            stopping conditions (step size and gradient are scaled|
//|            before comparison  with  tolerances)  and  as         |
//|            preconditioner.                                       |
//| The best way to set scaling is to manually specify variable      |
//| scales. However, sometimes you just need quick-and-dirty         |
//| solution - either when you perform fast prototyping, or when you |
//| know your problem well  and  you are 100 % sure that this quick  |
//| solution is robust enough in your case.                          |
//| One such solution is to evaluate scale of I-th variable          |
//| as 1 / Sqrt(A[i, i]), where A[i, i] is an I-th diagonal          |
//| element of the quadratic term.                                   |
//| Such approach works well sometimes, but you have to be careful   |
//| here.                                                            |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetScaleAutoDiag(CMinQPStateShell &state)
  {
   CMinQP::MinQPSetScaleAutoDiag(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function tells solver to use BLEIC-based algorithm and sets |
//| stopping criteria for the algorithm.                             |
//| This algorithm is intended for large-scale problems, possibly    |
//| nonconvex, with small number of general linear constraints.      |
//| Feasible initial point is essential for good performance.        |
//| IMPORTANT: when DENSE-IPM (or DENSE-AUL for nonconvex problems)  |
//|            solvers are applicable, their performance is much     |
//|            better than that of BLEIC-QP.                         |
//|            We recommend you to use BLEIC only when other solvers |
//|            can not be used.                                      |
//| ALGORITHM FEATURES:                                              |
//|   * supports dense and sparse QP problems                        |
//|   * supports box and general linear equality / inequality        |
//|     constraints                                                  |
//|   * can solve all types of problems (convex, semidefinite,       |
//|     nonconvex) as long as they are bounded from below under      |
//|     constraints.                                                 |
//| Say, it is possible to solve "min{-x^2} subject to -1<=x<=+1".   |
//| Of course, global minimum is found only for positive definite and|
//| semidefinite problems. As for indefinite ones-only local minimum |
//| is found.                                                        |
//| ALGORITHM OUTLINE :                                              |
//|   * BLEIC-QP solver is just a driver function for MinBLEIC       |
//|     solver; it solves quadratic programming problem as general   |
//|     linearly constrained optimization problem, which is solved   |
//|     by means of BLEIC solver(part of ALGLIB, active set method). |
//| ALGORITHM LIMITATIONS:                                           |
//|   * This algorithm is inefficient on problems with hundreds and  |
//|     thousands of general inequality constraints and infeasible   |
//|     initial point. Initial feasibility detection stage may take  |
//|     too long on such constraint sets. Consider using DENSE-IPM   |
//|     or DENSE-AUL instead.                                        |
//|   * unlike QuickQP solver, this algorithm does not perform Newton|
//|     steps and does not use Level 3 BLAS. Being general-purpose   |
//|     active set method, it can activate constraints only          |
//|     one-by-one. Thus, its performance is lower than that of      |
//|     QuickQP.                                                     |
//|   * its precision is also a bit inferior to that of QuickQP.     |
//|     BLEIC-QP performs only LBFGS steps(no Newton steps), which   |
//|     are good at detecting neighborhood of the solution, buy needs|
//|     many iterations to find solution with more than 6 digits of  |
//|     precision.                                                   |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//|   EpsG     -  >= 0, The subroutine finishes its work if the      |
//|               condition | v | < EpsG is satisfied, where:        |
//|                  * | . | means Euclidian norm                    |
//|                  * v - scaled constrained gradient vector,       |
//|                        v[i] = g[i] * s[i]                        |
//|                  * g - gradient                                  |
//|                  * s - scaling coefficients set by               |
//|                        MinQPSetScale()                           |
//|   EpsF     -  >= 0, The subroutine finishes its work if          |
//|                     exploratory steepest descent step on k+1-th  |
//|                     iteration satisfies following condition:     |
//|               |F(k+1) - F(k)| <= EpsF * max{ |F(k)|, |F(k+1)|, 1}|
//|   EpsX     -  >= 0, The subroutine finishes its work if          |
//|                     exploratory steepest descent step on k+1-th  |
//|                     iteration satisfies following condition:     |
//|                  * | . | means Euclidian norm                    |
//|                  * v - scaled step vector, v[i] = dx[i] / s[i]   |
//|                  * dx - step vector, dx = X(k + 1) - X(k)        |
//|                  * s - scaling coefficients set by               |
//|                        MinQPSetScale()                           |
//|   MaxIts   -  maximum number of iterations. If MaxIts = 0, the   |
//|               number of iterations is unlimited.                 |
//| NOTE: this algorithm uses LBFGS iterations, which are relatively |
//|       cheap, but improve function value only a bit. So you will  |
//|       need many iterations to converge - from 0.1 * N to 10 * N, |
//|       depending on problem's condition number.                   |
//| IT IS VERY IMPORTANT TO CALL MinQPSetScale() WHEN YOU USE THIS   |
//| ALGORITHM BECAUSE ITS STOPPING CRITERIA ARE SCALE - DEPENDENT!   |
//| Passing EpsG = 0, EpsF = 0 and EpsX = 0 and MaxIts = 0           |
//| (simultaneously) will lead to automatic stopping criterion       |
//| selection (presently it is small step length, but it may change  |
//| in the future versions of ALGLIB).                               |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetAlgoBLEIC(CMinQPStateShell &state,double epsg,
                                double epsf,double epsx,int maxits)
  {
   CMinQP::MinQPSetAlgoBLEIC(state.GetInnerObj(),epsg,epsf,epsx,maxits);
  }
//+------------------------------------------------------------------+
//| This function tells QP solver to use DENSE-AUL algorithm and sets|
//| stopping criteria for the algorithm.                             |
//| This algorithm is intended for non-convex problems with moderate |
//| (up to several thousands) variable count and arbitrary number of |
//| constraints which are either(a) effectively convexified under    |
//| constraints or (b) have unique solution even with nonconvex      |
//| target.                                                          |
//| IMPORTANT: when DENSE-IPM solver is applicable, its performance  |
//|            is usually much better than that of DENSE-AUL. We     |
//|            recommend you to use DENSE-AUL only when other solvers|
//|            can not be used.                                      |
//| ALGORITHM FEATURES:                                              |
//|   * supports box and dense / sparse general linear equality /    |
//|     inequality constraints                                       |
//|   * convergence is theoretically proved for positive - definite  |
//|     (convex) QP problems. Semidefinite and non-convex problems   |
//|     can be solved as long as they are bounded from below under   |
//|     constraints, although without theoretical guarantees.        |
//| ALGORITHM OUTLINE:                                               |
//|   * this algorithm is an augmented Lagrangian method with dense  |
//|     preconditioner(hence its name).                              |
//|   * it performs several outer iterations in order to refine      |
//|     values of the Lagrange multipliers. Single outer iteration is|
//|     a solution of some optimization problem: first it performs   |
//|     dense Cholesky factorization of the Hessian in order to build|
//|     preconditioner (adaptive regularization is applied to enforce|
//|     positive definiteness), and then it uses L-BFGS optimizer to |
//|     solve optimization problem.                                  |
//|   * typically you need about 5-10 outer iterations to converge   |
//|     to solution                                                  |
//| ALGORITHM LIMITATIONS:                                           |
//|   * because dense Cholesky driver is used, this algorithm has    |
//|     O(N^2) memory requirements and O(OuterIterations*N^3) minimum|
//|     running time. From the practical point of view, it limits its|
//|     applicability by several thousands of variables.             |
//| From the other side, variables count is the most limiting factor,|
//| and dependence on constraint count is much more lower. Assuming  |
//| that constraint matrix is sparse, it may handle tens of thousands|
//| of general linear constraints.                                   |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//|   EpsX     -  >= 0, stopping criteria for inner optimizer. Inner |
//|                     iterations are stopped when step length (with|
//|                     variable scaling being applied) is less than |
//|                     EpsX. See MinQPSetScale() for more           |
//|                     information on variable scaling.             |
//|   Rho      -  penalty coefficient, Rho > 0:                      |
//|                  * large enough that algorithm converges with    |
//|                    desired precision.                            |
//|                  * not TOO large to prevent ill-conditioning     |
//|                  * recommended values are 100, 1000 or 10000     |
//|   ItsCnt   -  number of outer iterations:                        |
//|               * recommended values: 10 - 15 (although in most    |
//|                 cases it converges within 5 iterations, you may  |
//|                 need a few more to be sure).                     |
//|               * ItsCnt = 0 means that small number of outer      |
//|                 iterations is automatically chosen (10 iterations|
//|                 in current version).                             |
//|               * ItsCnt = 1 means that AUL algorithm performs just|
//|                 as usual penalty method.                         |
//|               * ItsCnt > 1 means that AUL algorithm performs     |
//|                 specified number of outer iterations             |
//| IT IS VERY IMPORTANT TO CALL MinQPSetScale() WHEN YOU USE THIS   |
//| ALGORITHM BECAUSE ITS CONVERGENCE PROPERTIES AND STOPPING        |
//| CRITERIA ARE SCALE - DEPENDENT!                                  |
//| NOTE: Passing EpsX = 0 will lead to automatic step length        |
//|       selection (specific step length chosen may change in the   |
//|       future versions of ALGLIB, so it is better to specify step |
//|       length explicitly).                                        |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetAlgoDenseAUL(CMinQPStateShell &state,double epsx,
                                   double rho,int itscnt)
  {
   CMinQP::MinQPSetAlgoDenseAUL(state.GetInnerObj(),epsx,rho,itscnt);
  }
//+------------------------------------------------------------------+
//| This function tells QP solver to use DENSE-IPM QP algorithm and  |
//| sets stopping criteria for the algorithm.                        |
//| This algorithm is intended for convex and semidefinite problems  |
//| with moderate (up to several thousands) variable count and       |
//| arbitrary number of constraints.                                 |
//| IMPORTANT: this algorithm won't work for nonconvex problems, use |
//|            DENSE-AUL or BLEIC-QP instead. If you try to run      |
//|            DENSE-IPM on problem with indefinite matrix (matrix   |
//|            having at least one negative eigenvalue) then         |
//|            depending on circumstances it may either(a) stall at  |
//|            some arbitrary point, or (b) throw exception on       |
//|            failure of Cholesky decomposition.                    |
//| ALGORITHM FEATURES:                                              |
//|   * supports box and dense / sparse general linear equality /    |
//|     inequality constraints                                       |
//| ALGORITHM OUTLINE:                                               |
//|   * this algorithm is our implementation of interior point method|
//|     as formulated by R.J.Vanderbei, with minor modifications to  |
//|     the algorithm (damped Newton directions are extensively used)|
//|   * like all interior point methods, this algorithm tends to     |
//|     converge in roughly same number of iterations (between 15 and|
//|     50) independently from the problem dimensionality            |
//| ALGORITHM LIMITATIONS:                                           |
//|   * because dense Cholesky driver is used, for N-dimensional     |
//|     problem with M dense constaints this algorithm has           |
//|     O(N^2 + N*M) memory requirements and  O(N^3 + N*M^2) running |
//|     time. Having sparse constraints with Z nonzeros per row      |
//|     relaxes storage and running time down to O(N^2 + M*Z) and    |
//|     O(N^3 + N*Z^2) From the practical point of view, it limits   |
//|     its applicability by several thousands of variables. From the|
//|     other side, variables count is the most limiting factor, and |
//|     dependence on constraint count is much more lower. Assuming  |
//|     that constraint matrix is sparse, it may handle tens of      |
//|     thousands of general linear constraints.                     |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//|   Eps      -  >= 0, stopping criteria. The algorithm stops when  |
//|               primal and dual infeasiblities as well as          |
//|               complementarity gap are less than Eps.             |
//| IT IS VERY IMPORTANT TO CALL minqpsetscale() WHEN YOU USE THIS   |
//| ALGORITHM BECAUSE ITS CONVERGENCE PROPERTIES AND STOPPING        |
//| CRITERIA ARE SCALE - DEPENDENT!                                  |
//| NOTE: Passing EpsX = 0 will lead to automatic selection of small |
//| epsilon.                                                         |
//| ===== TRACING IPM SOLVER ======================================= |
//| IPM solver supports advanced tracing capabilities. You can trace |
//| algorithm output by specifying following trace symbols (case-    |
//| insensitive) by means of trace_file() call:                      |
//|   * 'IPM'     -  for basic trace of algorithm steps and decisions|
//|                  Only short scalars(function values and deltas)  |
//|                  are printed. N-dimensional quantities like      |
//|                  search directions are NOT printed.              |
//|   * 'IPM.DETAILED' - for output of points being visited and      |
//|                  search directions. This symbol also implicitly  |
//|                  defines 'IPM'. You can control output format by |
//|                  additionally specifying:                        |
//|               * nothing      to output in  6-digit exponential   |
//|                              format                              |
//|               * 'PREC.E15'   to output in 15-digit exponential   |
//|                              format                              |
//|               * 'PREC.F6'    to output in  6-digit fixed-point   |
//|                              format                              |
//| By default trace is disabled and adds no overhead to the         |
//| optimization process. However, specifying any of the symbols adds|
//| some formatting and output - related overhead.                   |
//| You may specify multiple symbols by separating them with commas: |
//|   >                                                              |
//|  >CAlglib::Trace_File("IPM,PREC.F6","path/to/trace.log")       |
//|   >                                                              |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetAlgoDenseIPM(CMinQPStateShell &state,double eps)
  {
   CMinQP::MinQPSetAlgoDenseIPM(state.GetInnerObj(),eps);
  }
//+------------------------------------------------------------------+
//| This function tells QP solver to  use  SPARSE-IPM  QP algorithm  |
//| and  sets stopping criteria for the algorithm.                   |
//| This  algorithm  is  intended  for convex and semidefinite       |
//| problems  with large  variable and constraint count  and  sparse |
//| quadratic  term  and constraints. It is possible to have  some   |
//| limited set of  dense  linear constraints - they will be handled |
//| separately by dense BLAS - but the more dense constraints you    |
//| have, the more time solver needs.                                |
//| IMPORTANT: internally this solver performs large and sparse(N+M) |
//|            x(N+M) triangular factorization. So it expects both   |
//|            quadratic term and constraints to be highly CSparse   |
//|            However, its  running  time is influenced by BOTH fill|
//|            factor and sparsity pattern.                          |
//| Generally we expect that no more than few nonzero  elements per  |
//| row are present. However different sparsity patterns may result  |
//| in completely different running  times  even  given  same  fill  |
//| factor.                                                          |
//| In many cases this algorithm outperforms DENSE-IPM by order  of  |
//| magnitude. However, in some cases you may  get  better  results  |
//| with DENSE-IPM even when solving sparse task.                    |
//| IMPORTANT: this algorithm won't work for nonconvex problems, use |
//|            DENSE-AUL or BLEIC - QP instead. If you try to  run   |
//|            DENSE-IPM  on  problem with indefinite matrix (matrix |
//|            having at least one negative eigenvalue) then         |
//|            depending on circumstances it may  either(a) stall at |
//|            some arbitrary point, or (b)  throw  exception  on    |
//|            failure of Cholesky decomposition.                    |
//| ALGORITHM FEATURES:                                              |
//|   * supports box and dense/sparse general linear equality/       |
//|      inequality constraints                                      |
//|   * specializes on large-scale sparse problems                   |
//| ALGORITHM OUTLINE:                                               |
//|   * this  algorithm  is  our implementation  of  interior  point |
//|     method as formulated by  R.J.Vanderbei, with minor           |
//|     modifications to the  algorithm (damped Newton directions are|
//|     extensively used)                                            |
//|   * like all interior point methods, this algorithm  tends  to   |
//|     converge in roughly same number of iterations(between 15 and |
//|     50) independently from the problem dimensionality            |
//| ALGORITHM LIMITATIONS:                                           |
//|   * this algorithm may handle moderate number  of dense          |
//|     constraints, usually no more than a thousand of dense ones   |
//|     without losing its efficiency.                               |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//|   Eps      -  >= 0, stopping criteria. The algorithm stops  when |
//|               primal and dual infeasiblities as well as          |
//|               complementarity gap are less than Eps.             |
//| IT IS VERY IMPORTANT TO CALL minqpsetscale() WHEN YOU USE THIS   |
//| ALGORITHM BECAUSE ITS CONVERGENCE PROPERTIES AND STOPPING        |
//| CRITERIA ARE SCALE - DEPENDENT!                                  |
//| NOTE: Passing EpsX = 0 will lead to automatic selection of small |
//|       epsilon.                                                   |
//| ===== TRACING IPM SOLVER ======================================= |
//| IPM solver supports advanced tracing capabilities. You can trace |
//| algorithm output by specifying following trace symbols           |
//| (case-insensitive)  by  means of trace_file() call:              |
//|   * 'IPM'  -  for basic trace of algorithm  steps and decisions. |
//|               Only short scalars(function values and deltas) are |
//|               printed. N-dimensional quantities like search      |
//|               directions are NOT printed.                        |
//|   * 'IPM.DETAILED' - for output of points being visited and      |
//|               search directions. This symbol also implicitly     |
//|               defines 'IPM'. You can control output format by    |
//|               additionally specifying:                           |
//|               * nothing      to output in  6-digit exponential   |
//|                              format                              |
//|               * 'PREC.E15'   to output in 15-digit exponential   |
//|                              format                              |
//|               * 'PREC.F6'    to output in  6-digit fixed-point   |
//|                              format                              |
//| By default trace is disabled and adds no overhead to the         |
//| optimization process. However, specifying any of the symbols adds|
//| some formatting and output - related overhead.                   |
//| You may specify multiple symbols by separating them with commas: |
//|   >                                                              |
//|  >CAlglib::Trace_File("IPM,PREC.F6","path/to/trace.log")       |
//|   >                                                              |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetAlgoSparseIPM(CMinQPStateShell &state,double eps)
  {
   CMinQP::MinQPSetAlgoSparseIPM(state.GetInnerObj(),eps);
  }
//+------------------------------------------------------------------+
//| This function tells solver to use QuickQP algorithm: special     |
//| extra-fast algorithm for problems with box-only constrants. It   |
//| may solve non-convex problems as long as they are bounded from   |
//| below under constraints.                                         |
//| ALGORITHM FEATURES:                                              |
//|   * several times faster than DENSE-IPM when running on box-only |
//|     problem                                                      |
//|   * utilizes accelerated methods for activation of constraints.  |
//|   * supports dense and sparse QP problems                        |
//|   * supports ONLY box constraints; general linear constraints are|
//|     NOT supported by this solver                                 |
//|   * can solve all types of problems (convex, semidefinite,       |
//|     nonconvex) as long as they are bounded from below under      |
//|     constraints. Say, it is possible to solve "min{-x^2} subject |
//|     to -1<=x<=+1". In convex/semidefinite case global minimum  is|
//|     returned, in nonconvex case-algorithm returns one of the     |
//|     local minimums.                                              |
//| ALGORITHM OUTLINE:                                               |
//|   * algorithm  performs  two kinds of iterations: constrained CG |
//|     iterations and constrained Newton iterations                 |
//|   * initially it performs small number of constrained CG         |
//|     iterations, which can efficiently activate/deactivate        |
//|     multiple constraints                                         |
//|   * after CG phase algorithm tries to calculate Cholesky         |
//|     decomposition and to perform several constrained Newton      |
//|     steps. If  Cholesky  decomposition failed(matrix is          |
//|     indefinite even under constraints), we perform more CG       |
//|     iterations until we converge to such set of constraints that |
//|     system matrix becomes positive definite. Constrained Newton  |
//|     steps greatly increase convergence speed and precision.      |
//|   * algorithm interleaves CG and Newton iterations which  allows |
//|     to handle indefinite matrices (CG phase) and quickly converge|
//|     after final set of constraints is found (Newton phase).      |
//|     Combination of CG and Newton phases is called "outer         |
//|     iteration".                                                  |
//|   * it is possible to turn off Newton phase (beneficial for      |
//|     semidefinite problems - Cholesky decomposition will fail too |
//|     often)                                                       |
//| ALGORITHM LIMITATIONS:                                           |
//|   * algorithm does not support general  linear  constraints; only|
//|     box ones are supported                                       |
//|   * Cholesky decomposition for sparse problems is performed with |
//|     Skyline Cholesky solver, which is intended for low-profile   |
//|     matrices. No profile-reducing reordering of variables is     |
//|     performed in this version of ALGLIB.                         |
//|   * problems with near-zero negative eigenvalues (or exacty zero |
//|     ones) may experience about 2-3x performance penalty. The     |
//|     reason is that Cholesky decomposition can not be performed   |
//|     until we identify directions of zero and negative curvature  |
//|     and activate corresponding boundary constraints- but we need |
//|     a lot of trial and errors because these directions  are hard |
//|     to notice in the matrix spectrum. In this case you may turn  |
//|     off Newton phase of algorithm. Large negative eigenvalues    |
//|     are  not  an  issue,  so  highly  non-convex problems can be |
//|     solved very efficiently.                                     |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//|   EpsG     -  >= 0. The subroutine finishes its work if the      |
//|               condition |v| < EpsG is satisfied, where:          |
//|               * | . | means Euclidian norm                       |
//|               * v - scaled constrained gradient vector,          |
//|                  v[i] = g[i] * s[i]                              |
//|               * g - gradient                                     |
//|               * s - scaling coefficients set by MinQPSetScale()  |
//|   EpsF     -  >= 0. The subroutine finishes its work if          |
//|               exploratory steepest descent step on k+1-th        |
//|               iteration satisfies following condition:           |
//|               |F(k+1) - F(k)| <= EpsF*max{|F(k)|, |F(k+1)|, 1}   |
//|   EpsX     -  >= 0. The subroutine finishes its work if          |
//|               exploratory steepest descent step on k+1-th        |
//|               iteration satisfies following condition:           |
//|               * | . | means Euclidian norm                       |
//|               * v - scaled step vector, v[i] = dx[i] / s[i]      |
//|               * dx - step vector, dx = X(k + 1) - X(k)           |
//|               * s - scaling coefficients set by MinQPSetScale()  |
//|   MaxOuterIts - maximum number of OUTER iterations.  One  outer  |
//|               iteration includes some amount of CG iterations    |
//|               (from 5 to ~N) and one or several (usually small   |
//|               amount) Newton steps. Thus, one outer iteration has|
//|               high cost, but can greatly reduce funcation value. |
//|               Use 0 if you do not want to limit number of outer  |
//|               iterations.                                        |
//|   UseNewton - use Newton phase or not:                           |
//|               * Newton phase improves performance of positive    |
//|                 definite dense problems (about 2 times           |
//|                 improvement can be observed)                     |
//|               * can result in some performance penalty on        |
//|                 semidefinite or slightly negative definite       |
//|                 problems - each Newton phase will bring no       |
//|                 improvement (Cholesky failure), but still will   |
//|                 require computational time.                      |
//|               * if you doubt, you can turn off this phase -      |
//|                 optimizer will retain its most of its high speed.|
//| IT IS VERY IMPORTANT TO CALL MinQPSetScale() WHEN YOU USE THIS   |
//| ALGORITHM BECAUSE ITS STOPPING CRITERIA ARE SCALE - DEPENDENT!   |
//| Passing EpsG = 0, EpsF = 0 and EpsX = 0 and MaxIts = 0           |
//| (simultaneously) will lead to automatic stopping criterion       |
//| selection (presently it is small step length, but it may change  |
//| in the future versions of ALGLIB).                               |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetAlgoQuickQP(CMinQPStateShell &state,double epsg,
                                  double epsf,double epsx,
                                  int maxouterits,bool usenewton)
  {
   CMinQP::MinQPSetAlgoQuickQP(state.GetInnerObj(),epsg,epsf,epsx,maxouterits,usenewton);
  }
//+------------------------------------------------------------------+
//| This function tells solver to use Cholesky-based algorithm.      |
//| Cholesky-based algorithm can be used when:                       |
//| * problem is convex                                              |
//| * there is no constraints or only boundary constraints are       |
//|   present                                                        |
//| This algorithm has O(N^3) complexity for unconstrained problem   |
//| and is up to several times slower on bound constrained problems  |
//| (these additional iterations are needed to identify active       |
//| constraints).                                                    |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetAlgoCholesky(CMinQPStateShell &state)
  {
   CMinQP::MinQPSetAlgoCholesky(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function sets boundary constraints for QP solver            |
//| Boundary constraints are inactive by default (after initial      |
//| creation). After being set, they are preserved until explicitly  |
//| turned off with another SetBC() call.                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure stores algorithm state                 |
//|     BndL    -   lower bounds, array[N].                          |
//|                 If some (all) variables are unbounded, you may   |
//|                 specify very small number or -INF (latter is     |
//|                 recommended because it will allow solver to use  |
//|                 better algorithm).                               |
//|     BndU    -   upper bounds, array[N].                          |
//|                 If some (all) variables are unbounded, you may   |
//|                 specify very large number or +INF (latter is     |
//|                 recommended because it will allow solver to use  |
//|                 better algorithm).                               |
//| NOTE: it is possible to specify BndL[i]=BndU[i]. In this case    |
//| I-th variable will be "frozen" at X[i]=BndL[i]=BndU[i].          |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetBC(CMinQPStateShell &state,double &bndl[],
                         double &bndu[])
  {
   CMinQP::MinQPSetBC(state.GetInnerObj(),bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function sets box constraints for QP solver (all variables  |
//| at once, same constraints for all variables)                     |
//| Box constraints are inactive by default (after initial  creation)|
//| After being set, they are preserved until explicitly overwritten |
//| with another MinQPSetBC() or MinQPSetBCAll() call, or partially  |
//| overwritten with MinQPSetBCI() call.                             |
//| Following types of constraints are supported:                    |
//|   DESCRIPTION         CONSTRAINT              HOW TO SPECIFY     |
//|   fixed variable      x[i]=Bnd                BndL=BndU          |
//|   lower bound         BndL<=x[i]              BndU=+INF          |
//|   upper bound         x[i]<=BndU              BndL=-INF          |
//|   range               BndL<=x[i]<=BndU        ...                |
//|   free variable       -                       BndL=-INF, BndU+INF|
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//|   BndL     -  lower bound, same for all variables                |
//|   BndU     -  upper bound, same for all variables                |
//| NOTE: infinite values can be specified by means of AL_NEGINF and |
//|       AL_POSINF.                                                 |
//| NOTE: you may replace infinities by very small/very large values,|
//|       but it is not recommended because large numbers may        |
//|       introduce large numerical errors in the algorithm.         |
//| NOTE: BndL>BndU will result in QP problem being recognized as    |
//|       infeasible.                                                |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetBCAll(CMinQPStateShell &state,double bndl,
                            double bndu)
  {
   CMinQP::MinQPSetBCAll(state.GetInnerObj(),bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function sets box constraints for I-th variable (other      |
//| variables are not modified).                                     |
//| Following types of constraints are supported:                    |
//|   DESCRIPTION         CONSTRAINT              HOW TO SPECIFY     |
//|   fixed variable      x[i] = Bnd                BndL = BndU      |
//|   lower bound         BndL <= x[i]              BndU = +INF      |
//|   upper bound         x[i] <= BndU              BndL = -INF      |
//|   range               BndL <= x[i] <= BndU        ...            |
//|   free variable       -                      BndL -INF, BndU +INF|
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//|   BndL     -  lower bound                                        |
//|   BndU     -  upper bound                                        |
//| NOTE: infinite values can be specified by means of AL_POSINF and |
//|       AL_POSINF.                                                 |
//| NOTE: you may replace infinities by very small/very large values,|
//|       but it is not recommended because large numbers may        |
//|       introduce large numerical errors in the algorithm.         |
//| NOTE: BndL>BndU will result in QP problem being recognized as    |
//|       infeasible.                                                |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetBCI(CMinQPStateShell &state,int i,
                          double bndl,double bndu)
  {
   CMinQP::MinQPSetBCI(state.GetInnerObj(),i,bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function sets dense linear constraints for QP optimizer.    |
//| This function overrides results of previous calls to MinQPSetLC()|
//| MinQPSetLCSparse() and MinQPSetLCMixed(). After call to this     |
//| function all non-box constraints are dropped, and you have only  |
//| those constraints which were specified in the present call.      |
//| If you want to specify mixed(with dense and sparse terms) linear |
//| constraints, you should call MinQPSetLCMixed().                  |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinQPCreate    |
//|               call.                                              |
//|   C        -  linear constraints, array[K, N + 1]. Each row of C |
//|               represents one constraint, either equality or      |
//|               inequality (see below):                            |
//|               * first N elements correspond to coefficients,     |
//|               * last element corresponds to the right part.      |
//|               All elements of C(including right part) must be    |
//|               finite.                                            |
//|   CT       -  type of constraints, array[K]:                     |
//|               * if CT[i] > 0, then I-th constraint is            |
//|                        C[i, *] * x >= C[i, n + 1]                |
//|               * if CT[i] = 0, then I-th constraint is            |
//|                        C[i, *] * x = C[i, n + 1]                 |
//|               * if CT[i] < 0, then I-th constraint is            |
//|                        C[i, *] * x <= C[i, n + 1]                |
//|   K        -  number of equality/inequality constraints, K >= 0: |
//|               * if given, only leading K elements of C/CT are    |
//|                 used                                             |
//|               * if not given, automatically determined from sizes|
//|                 of C/CT                                          |
//| NOTE 1: linear (non-bound) constraints are satisfied only        |
//|         approximately - there always exists some violation due   |
//|         to numerical errors and algorithmic limitations          |
//|         (BLEIC-QP solver is most precise, AUL-QP solver is less  |
//|         precise).                                                |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetLC(CMinQPStateShell &state,CMatrixDouble &c,
                         CRowInt &ct,int k)
  {
   CMinQP::MinQPSetLC(state.GetInnerObj(),c,ct,k);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetLC(CMinQPStateShell &state,CMatrixDouble &c,
                         CRowInt &ct)
  {
//--- check
   if(!CAp::Assert(CAp::Rows(c)==CAp::Len(ct),"Error while calling 'MinQPSetLC': looks like one of arguments has wrong size"))
      return;
//--- initialization
   int k=CAp::Rows(c);
//--- function call
   CMinQP::MinQPSetLC(state.GetInnerObj(),c,ct,k);
  }
//+------------------------------------------------------------------+
//| This function sets sparse linear constraints for QP optimizer.   |
//| This function overrides results of previous calls to MinQPSetLC()|
//| MinQPSetLCSparse() and MinQPSetLCMixed(). After call to this     |
//| function all non-box constraints are dropped, and you have only  |
//| those constraints which were specified in the present call.      |
//| If you want to specify mixed(with dense and sparse terms) linear |
//| constraints, you should call MinQPSetLCMixed().                  |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinQPCreate    |
//|               call.                                              |
//|   C        -  linear constraints, sparse matrix with dimensions  |
//|               at least [K, N + 1]. If matrix has larger size,    |
//|               only leading Kx(N + 1) rectangle is used. Each row |
//|               of C represents one constraint, either equality or |
//|               inequality(see below) :                            |
//|               * first N elements correspond to coefficients,     |
//|               * last element corresponds to the right part.      |
//|               All elements of C(including right part) must be    |
//|               finite.                                            |
//|   CT       -  type of constraints, array[K]:                     |
//|               * if CT[i] > 0, then I-th constraint is            |
//|                        C[i, *] * x >= C[i, n + 1]                |
//|               * if CT[i] = 0, then I-th constraint is            |
//|                        C[i, *] * x = C[i, n + 1]                 |
//|               * if CT[i] < 0, then I-th constraint is            |
//|                        C[i, *] * x <= C[i, n + 1]                |
//|   K        -  number of equality/inequality constraints, K >= 0: |
//|               * if given, only leading K elements of C/CT are    |
//|                 used                                             |
//|               * if not given, automatically determined from sizes|
//|                 of C/CT                                          |
//| NOTE 1: linear (non-bound) constraints are satisfied only        |
//|         approximately - there always exists some violation due   |
//|         to numerical errors and algorithmic limitations          |
//|         (BLEIC-QP solver is most precise, AUL-QP solver is less  |
//|         precise).                                                |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetLCSparse(CMinQPStateShell &state,CSparseMatrix &c,
                               CRowInt &ct,int k)
  {
   CMinQP::MinQPSetLCSparse(state.GetInnerObj(),c,ct,k);
  }
//+------------------------------------------------------------------+
//| This function sets mixed linear constraints, which include a set |
//| of dense rows, and a set of sparse rows.                         |
//| This function overrides results of previous calls to MinQPSetLC()|
//| MinQPSetLCSparse() and MinQPSetLCMixed(). After call to this     |
//| function all non-box constraints are dropped, and you have only  |
//| those constraints which were specified in the present call.      |
//| If you want to specify mixed(with dense and sparse terms) linear |
//| constraints, you should call MinQPSetLCMixed().                  |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinQPCreate    |
//|               call.                                              |
//|   SparseC  -  linear constraints, sparse matrix with dimensions  |
//|               EXACTLY EQUAL TO [SparseK, N + 1]. Each row of C   |
//|               represents one constraint, either equality or      |
//|               inequality (see below):                            |
//|               * first N elements correspond to coefficients,     |
//|               * last element corresponds to the right part.      |
//|               All elements of C(including right part) must be    |
//|               finite.                                            |
//|   SparseCT -  type of sparse constraints, array[K]:              |
//|               * if SparseCT[i] > 0, then I-th constraint is      |
//|                     SparseC[i, *] * x >= SparseC[i, n + 1]       |
//|               * if SparseCT[i] = 0, then I-th constraint is      |
//|                     SparseC[i, *] * x  = SparseC[i, n + 1]       |
//|               * if SparseCT[i] < 0, then I-th constraint is      |
//|                     SparseC[i, *] * x <= SparseC[i, n + 1]       |
//|   SparseK  -  number of sparse equality/inequality constraints,  |
//|               K >= 0                                             |
//|   DenseC   -  dense linear constraints, array[K, N + 1]. Each row|
//|               of DenseC represents one constraint, either        |
//|               equality or inequality(see below):                 |
//|               * first N elements correspond to coefficients,     |
//|               * last element corresponds to the right part.      |
//|               All elements of DenseC (including right part) must |
//|               be finite.                                         |
//|   DenseCT  -  type of constraints, array[K]:                     |
//|               * if DenseCT[i] > 0, then I-th constraint is       |
//|                        DenseC[i, *] * x >= DenseC[i, n + 1]      |
//|               * if DenseCT[i] = 0, then I-th constraint is       |
//|                        DenseC[i, *] * x  = DenseC[i, n + 1]      |
//|               * if DenseCT[i] < 0, then I-th constraint is       |
//|                        DenseC[i, *] * x <= DenseC[i, n + 1]      |
//|   DenseK   -  number of equality/inequality constraints,         |
//|               DenseK >= 0                                        |
//| NOTE 1: linear(non-box) constraints are satisfied only           |
//|         approximately - there always exists some violation due   |
//|         to numerical errors and algorithmic limitations          |
//|         (BLEIC-QP solver is most precise, AUL-QP solver is less  |
//|         precise).                                                |
//| NOTE 2: due to backward compatibility reasons SparseC can be     |
//|         larger than [SparseK, N + 1]. In this case only leading  |
//|         [SparseK, N+1] submatrix will be used. However, the rest |
//|         of ALGLIB has more strict requirements on the input size,|
//|         so we recommend you to pass sparse term whose size       |
//|         exactly matches algorithm expectations.                  |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetLCMixed(CMinQPStateShell &state,
                              CSparseMatrix &sparsec,CRowInt &sparsect,
                              int sparsek,CMatrixDouble &densec,
                              CRowInt &densect,int densek)
  {
   CMinQP::MinQPSetLCMixed(state.GetInnerObj(),sparsec,sparsect,sparsek,densec,densect,densek);
  }
//+------------------------------------------------------------------+
//| This function provides legacy API for specification of mixed     |
//| dense / sparse linear constraints.                               |
//| New conventions used by ALGLIB since release 3.16.0 State that   |
//| set of sparse constraints comes first,  followed  by  set  of    |
//| dense  ones.  This convention is essential when you talk about   |
//| things like order of  Lagrange multipliers.                      |
//| However, legacy API accepted mixed constraints in reverse order. |
//| This function is here to simplify situation with code relying on |
//| legacy API. It simply accepts constraints in one order (old) and |
//| passes them to new  API, now in correct order.                   |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetLCMixedLegacy(CMinQPStateShell &state,
                                    CMatrixDouble &densec,
                                    CRowInt &densect,int densek,
                                    CSparseMatrix &sparsec,
                                    CRowInt &sparsect,int sparsek)
  {
   CMinQP::MinQPSetLCMixedLegacy(state.GetInnerObj(),densec,densect,densek,sparsec,sparsect,sparsek);
  }
//+------------------------------------------------------------------+
//| This function sets two-sided linear constraints AL <= A*x <= AU  |
//| with dense constraint matrix A.                                  |
//| NOTE: knowing  that constraint matrix is dense helps some QP     |
//| solvers (especially modern IPM method) to utilize efficient dense|
//| Level 3 BLAS for dense parts of the problem. If your problem has |
//| both dense and sparse constraints, you can use MinQPSetLC2Mixed()|
//| function, which will result in dense algebra being applied to    |
//| dense terms, and sparse sparse linear algebra applied to sparse  |
//| terms.                                                           |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinQPCreate()  |
//|               call.                                              |
//|   A        -  linear constraints, array[K, N]. Each row of A     |
//|               represents one constraint. One-sided inequality    |
//|               constraints, two-sided inequality constraints,     |
//|               equality constraints are supported (see below)     |
//|   AL, AU   -  lower and upper bounds, array[K];                  |
//|               * AL[i] = AU[i] => equality constraint Ai * x      |
//|               * AL[i]<AU.Set(i,> two-sided constraint            |
//|                           AL[i] <= Ai*x <= AU[i]                 |
//|               * AL[i]  =  -INF  => one-sided constraint          |
//|                                 Ai*x <= AU[i]                    |
//|               * AU[i]  =  +INF  => one-sided constraint          |
//|                                 AL[i] <= Ai*x                    |
//|               * AL[i] = -INF, AU[i] = +INF => constraint is      |
//|                                               ignored            |
//|   K        -  number of equality/inequality constraints, K >= 0; |
//|               if not given, inferred from sizes of A, AL, AU.    |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetLC2Dense(CMinQPStateShell &state,
                               CMatrixDouble &a,CRowDouble &al,
                               CRowDouble &au,int k)
  {
   CMinQP::MinQPSetLC2Dense(state.GetInnerObj(),a,al,au,k);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetLC2Dense(CMinQPStateShell &state,
                               CMatrixDouble &a,CRowDouble &al,
                               CRowDouble &au)
  {
//--- check
   if(!CAp::Assert((CAp::Rows(a)==CAp::Len(al)) || (CAp::Rows(a)!=CAp::Len(au)),
                   "Error while calling 'minqpsetlc2dense': looks like one of arguments has wrong size"))
      return;
//--- initialization
   int k=CAp::Rows(a);
//--- function call
   CMinQP::MinQPSetLC2Dense(state.GetInnerObj(),a,al,au,k);
  }
//+------------------------------------------------------------------+
//| This function sets two-sided linear constraints AL <= A*x <= AU  |
//| with sparse constraining matrix A. Recommended for large-scale   |
//| problems.                                                        |
//| This function overwrites linear (non-box) constraints set by     |
//| previous calls(if such calls were made).                         |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinQPCreate()  |
//|               call.                                              |
//|   A        -  sparse matrix with size [K, N](exactly!). Each row |
//|               of A represents one general linear constraint. A   |
//|               can be stored in any sparse storage format.        |
//|   AL, AU   -  lower and upper bounds, array[K];                  |
//|               * AL[i] = AU[i] => equality constraint Ai*x        |
//|               * AL[i]<AU.Set(i,> two-sided constraint            |
//|                              AL[i] <= Ai*x <= AU[i]              |
//|               * AL[i]  =  -INF  => one-sided constraint          |
//|                                 Ai*x <= AU[i]                    |
//|               * AU[i]  =  +INF  => one-sided constraint          |
//|                                 AL[i] <= Ai*x                    |
//|               * AL[i] = -INF, AU[i] = +INF => constraint is      |
//|                                               ignored            |
//|   K        -  number of equality/inequality constraints, K >= 0. |
//|               If K = 0 is specified, A, AL, AU are ignored.      |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetLC2(CMinQPStateShell &state,CSparseMatrix &a,
                          CRowDouble &al,CRowDouble &au,int k)
  {
   CMinQP::MinQPSetLC2(state.GetInnerObj(),a,al,au,k);
  }
//+------------------------------------------------------------------+
//| This function sets two-sided linear constraints AL <= A*x <= AU  |
//| with mixed constraining matrix A including sparse part (first    |
//| SparseK rows) and dense part(last DenseK rows). Recommended for  |
//| large-scale problems.                                            |
//| This function overwrites linear (non-box) constraints set by     |
//| previous calls (if such calls were made).                        |
//| This function may be useful if constraint matrix includes large  |
//| number of both types of rows - dense and CSparse If you have just|
//| a few sparse rows, you may represent them in dense format without|
//| losing performance. Similarly, if you have just a few dense rows,|
//| you may store them in sparse format with almost same performance.|
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinQPCreate()  |
//|               call.                                              |
//|   SparseA  -  sparse matrix with size [K, N](exactly!). Each row |
//|               of A represents one general linear constraint. A   |
//|               can be stored in any sparse storage format.        |
//|   SparseK  -  number of sparse constraints, SparseK >= 0         |
//|   DenseA   -  linear constraints, array[K, N], set of dense      |
//|               constraints. Each row of A represents one general  |
//|               linear constraint.                                 |
//|   DenseK   -  number of dense constraints, DenseK >= 0           |
//|   AL, AU   -  lower and upper bounds, array[SparseK + DenseK],   |
//|               with former SparseK elements corresponding to      |
//|               sparse constraints,  and latter DenseK elements    |
//|               corresponding to dense constraints;                |
//|               * AL[i] = AU[i] => equality constraint Ai*x        |
//|               * AL[i]<AU.Set(i,> two-sided constraint            |
//|                              AL[i] <= Ai*x <= AU[i]              |
//|               * AL[i]  =  -INF  => one-sided constraint          |
//|                                 Ai*x <= AU[i]                    |
//|               * AU[i]  =  +INF  => one-sided constraint          |
//|                                 AL[i] <= Ai*x                    |
//|               * AL[i] = -INF, AU[i] = +INF => constraint is      |
//|                                               ignored            |
//|   K        -  number  of equality/inequality constraints, K >= 0.|
//|               If  K = 0 is specified, A, AL, AU are ignored.     |
//+------------------------------------------------------------------+
void CAlglib::MinQPSetLC2Mixed(CMinQPStateShell &state,
                               CSparseMatrix &sparsea,int ksparse,
                               CMatrixDouble &densea,int kdense,
                               CRowDouble &al,CRowDouble &au)
  {
   CMinQP::MinQPSetLC2Mixed(state.GetInnerObj(),sparsea,ksparse,densea,kdense,al,au);
  }
//+------------------------------------------------------------------+
//| This function appends two-sided linear constraint AL <= A*x <= AU|
//| to the matrix of currently present dense constraints.            |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinQPCreate()  |
//|               call.                                              |
//|   A        -  linear constraint coefficient, array[N], right side|
//|               is NOT included.                                   |
//|   AL, AU   -  lower and upper bounds;                            |
//|               * AL    =   AU    => equality constraint Ai*x      |
//|               * AL    <   AU    => two-sided constraint          |
//|                           AL    <= Ai*x <= AU                    |
//|               * AL    = -INF    => one-sided constraint          |
//|                                 Ai*x <= AU                       |
//|               * AU    = +INF    => one-sided constraint          |
//|                                 AL    <= Ai*x                    |
//|               * AL    = -INF, AU    = +INF => constraint is      |
//|                                               ignored            |
//+------------------------------------------------------------------+
void CAlglib::MinQPAddLC2Dense(CMinQPStateShell &state,CRowDouble &a,
                               double al,double au)
  {
   CMinQP::MinQPAddLC2Dense(state.GetInnerObj(),a,al,au);
  }
//+------------------------------------------------------------------+
//| This function appends two-sided linear constraint AL <= A*x <= AU|
//| to the list of currently present sparse constraints.             |
//| Constraint is passed in compressed format: as list of non-zero   |
//| entries of coefficient vector A. Such approach is more efficient |
//| than dense storage for highly sparse constraint vectors.         |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinQPCreate()  |
//|               call.                                              |
//|   IdxA     -  array[NNZ], indexes of non-zero elements of A:     |
//|               * can be unsorted                                  |
//|               * can include duplicate indexes (corresponding     |
//|                 entries  of ValA[] will be summed)               |
//|   ValA     -  array[NNZ], values of non-zero elements of A       |
//|   NNZ      -  number of non-zero coefficients in A               |
//|   AL, AU   -  lower and upper bounds;                            |
//|               * AL = AU    => equality constraint A*x            |
//|               * AL<AU    => two-sided constraint AL <= A*x <= AU |
//|               * AL = -INF  => one-sided constraint A*x <= AU     |
//|               * AU = +INF  => one-sided constraint AL <= A*x     |
//|               * AL = -INF, AU = +INF => constraint is ignored    |
//+------------------------------------------------------------------+
void CAlglib::MinQPAddLC2(CMinQPStateShell &state,CRowInt &idxa,
                          CRowDouble &vala,int nnz,
                          double al,double au)
  {
   CMinQP::MinQPAddLC2(state.GetInnerObj(),idxa,vala,nnz,al,au);
  }
//+------------------------------------------------------------------+
//| This function appends two-sided linear constraint AL <= A*x <= AU|
//| to the list of currently present sparse constraints.             |
//| Constraint vector A is  passed as a dense array which is         |
//| internally sparsified by this function.                          |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinQPCreate()  |
//|               call.                                              |
//|   DA       -  array[N], constraint vector                        |
//|   AL, AU   -  lower and upper bounds;                            |
//|               * AL = AU    => equality constraint A*x            |
//|               * AL < AU    => two-sided constraint AL<=A*x<=AU   |
//|               * AL = -INF  => one-sided constraint A*x <= AU     |
//|               * AU = +INF  => one-sided constraint AL <= A*x     |
//|               * AL = -INF, AU = +INF => constraint is ignored    |
//+------------------------------------------------------------------+
void CAlglib::MinQPAddLC2SparseFromDense(CMinQPStateShell &state,
                                         CRowDouble &da,
                                         double al,double au)
  {
   CMinQP::MinQPAddLC2SparseFromDense(state.GetInnerObj(),da,al,au);
  }
//+------------------------------------------------------------------+
//| This function solves quadratic programming problem.              |
//| You should call it after setting solver options with             |
//| MinQPSet...() calls.                                             |
//| INPUT PARAMETERS:                                                |
//|     State   -   algorithm state                                  |
//| You should use MinQPResults() function to access results after   |
//| calls to this function.                                          |
//+------------------------------------------------------------------+
void CAlglib::MinQPOptimize(CMinQPStateShell &state)
  {
   CMinQP::MinQPOptimize(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| QP solver results                                                |
//| INPUT PARAMETERS:                                                |
//|     State   -   algorithm state                                  |
//| OUTPUT PARAMETERS:                                               |
//|     X       -   array[0..N-1], solution                          |
//|     Rep     -   optimization report. You should check Rep.       |
//|                 TerminationType, which contains completion code, |
//|                 and you may check another fields which contain   |
//|                 another information about algorithm functioning. |
//+------------------------------------------------------------------+
void CAlglib::MinQPResults(CMinQPStateShell &state,double &x[],
                           CMinQPReportShell &rep)
  {
   CMinQP::MinQPResults(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| QP results                                                       |
//| Buffered implementation of MinQPResults() which uses             |
//| pre-allocated  buffer to store X[]. If buffer size is too small, |
//| it resizes buffer. It is intended to be used in the inner cycles |
//| of performance critical algorithms where array reallocation      |
//| penalty is too large to be ignored.                              |
//+------------------------------------------------------------------+
void CAlglib::MinQPResultsBuf(CMinQPStateShell &state,double &x[],
                              CMinQPReportShell &rep)
  {
   CMinQP::MinQPResultsBuf(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                 IMPROVED LEVENBERG-MARQUARDT METHOD FOR          |
//|                  NON-LINEAR LEAST SQUARES OPTIMIZATION           |
//| DESCRIPTION:                                                     |
//| This function is used to find minimum of function which is       |
//| represented as sum of squares:                                   |
//|     F(x) = f[0]^2(x[0],...,x[n-1]) + ... +                       |
//|     + f[m-1]^2(x[0],...,x[n-1])                                  |
//| using value of function vector f[] and Jacobian of f[].          |
//| REQUIREMENTS:                                                    |
//| This algorithm will request following information during its     |
//| operation:                                                       |
//| * function vector f[] at given point X                           |
//| * function vector f[] and Jacobian of f[] (simultaneously) at    |
//| given point                                                      |
//| There are several overloaded versions of MinLMOptimize()         |
//| function which correspond to different LM-like optimization      |
//| algorithms provided by this unit. You should choose version which|
//| accepts fvec() and jac() callbacks. First one is used to         |
//| calculate f[] at given point, second one calculates f[] and      |
//| Jacobian df[i]/dx[j].                                            |
//| You can try to initialize MinLMState structure with VJ function  |
//| and then use incorrect version  of  MinLMOptimize() (for example,|
//| version which works with general form function and does not      |
//| provide Jacobian), but it will lead to exception being thrown    |
//| after first attempt to calculate Jacobian.                       |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with MinLMCreateVJ() call    |
//| 2. User tunes solver parameters with MinLMSetCond(),             |
//|    MinLMSetStpMax() and other functions                          |
//| 3. User calls MinLMOptimize() function which takes algorithm     |
//|    state and callback functions.                                 |
//| 4. User calls MinLMResults() to get solution                     |
//| 5. Optionally, user may call MinLMRestartFrom() to solve another |
//|    problem with same N/M but another starting point and/or       |
//|    another function. MinLMRestartFrom() allows to reuse already  |
//|    initialized structure.                                        |
//| INPUT PARAMETERS:                                                |
//|     N       -   dimension, N>1                                   |
//|                 * if given, only leading N elements of X are     |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     M       -   number of functions f[i]                         |
//|     X       -   initial solution, array[0..N-1]                  |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. you may tune stopping conditions with MinLMSetCond() function |
//| 2. if target function contains exp() or other fast growing       |
//|    functions, and optimization algorithm makes too large steps   |
//|    which leads to overflow, use MinLMSetStpMax() function to     |
//|    bound algorithm's steps.                                      |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateVJ(const int n,const int m,double &x[],
                            CMinLMStateShell &state)
  {
   CMinLM::MinLMCreateVJ(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                 IMPROVED LEVENBERG-MARQUARDT METHOD FOR          |
//|                  NON-LINEAR LEAST SQUARES OPTIMIZATION           |
//| DESCRIPTION:                                                     |
//| This function is used to find minimum of function which is       |
//| represented as sum of squares:                                   |
//|     F(x) = f[0]^2(x[0],...,x[n-1]) + ... +                       |
//|     + f[m-1]^2(x[0],...,x[n-1])                                  |
//| using value of function vector f[] and Jacobian of f[].          |
//| REQUIREMENTS:                                                    |
//| This algorithm will request following information during its     |
//| operation:                                                       |
//| * function vector f[] at given point X                           |
//| * function vector f[] and Jacobian of f[] (simultaneously) at    |
//| given point                                                      |
//| There are several overloaded versions of MinLMOptimize()         |
//| function which correspond to different LM-like optimization      |
//| algorithms provided by this unit. You should choose version which|
//| accepts fvec() and jac() callbacks. First one is used to         |
//| calculate f[] at given point, second one calculates f[] and      |
//| Jacobian df[i]/dx[j].                                            |
//| You can try to initialize MinLMState structure with VJ function  |
//| and then use incorrect version  of  MinLMOptimize() (for example,|
//| version which works with general form function and does not      |
//| provide Jacobian), but it will lead to exception being thrown    |
//| after first attempt to calculate Jacobian.                       |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with MinLMCreateVJ() call    |
//| 2. User tunes solver parameters with MinLMSetCond(),             |
//|    MinLMSetStpMax() and other functions                          |
//| 3. User calls MinLMOptimize() function which takes algorithm     |
//|    state and callback functions.                                 |
//| 4. User calls MinLMResults() to get solution                     |
//| 5. Optionally, user may call MinLMRestartFrom() to solve another |
//|    problem with same N/M but another starting point and/or       |
//|    another function. MinLMRestartFrom() allows to reuse already  |
//|    initialized structure.                                        |
//| INPUT PARAMETERS:                                                |
//|     N       -   dimension, N>1                                   |
//|                 * if given, only leading N elements of X are     |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     M       -   number of functions f[i]                         |
//|     X       -   initial solution, array[0..N-1]                  |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. you may tune stopping conditions with MinLMSetCond() function |
//| 2. if target function contains exp() or other fast growing       |
//|    functions, and optimization algorithm makes too large steps   |
//|    which leads to overflow, use MinLMSetStpMax() function to     |
//|    bound algorithm's steps.                                      |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateVJ(const int m,double &x[],CMinLMStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinLM::MinLMCreateVJ(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                 IMPROVED LEVENBERG-MARQUARDT METHOD FOR          |
//|                  NON-LINEAR LEAST SQUARES OPTIMIZATION           |
//| DESCRIPTION:                                                     |
//| This function is used to find minimum of function which is       |
//| represented as sum of squares:                                   |
//|     F(x) = f[0]^2(x[0],...,x[n-1]) + ... +                       |
//|     + f[m-1]^2(x[0],...,x[n-1])                                  |
//| using value of function vector f[] only. Finite differences are  |
//| used to calculate Jacobian.                                      |
//| REQUIREMENTS:                                                    |
//| This algorithm will request following information during its     |
//| operation:                                                       |
//| * function vector f[] at given point X                           |
//| There are several overloaded versions of MinLMOptimize() function|
//| which correspond to different LM-like optimization algorithms    |
//| provided by this unit. You should choose version which accepts   |
//| fvec() callback.                                                 |
//| You can try to initialize MinLMState structure with VJ function  |
//| and then use incorrect version of MinLMOptimize() (for example,  |
//| version which works with general form function and does not      |
//| accept function vector), but it will lead to exception being     |
//| thrown after first attempt to calculate Jacobian.                |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with MinLMCreateV() call     |
//| 2. User tunes solver parameters with MinLMSetCond(),             |
//|    MinLMSetStpMax() and other functions                          |
//| 3. User calls MinLMOptimize() function which takes algorithm     |
//|    state and callback functions.                                 |
//| 4. User calls MinLMResults() to get solution                     |
//| 5. Optionally, user may call MinLMRestartFrom() to solve another |
//|    problem with same N/M but another starting point and/or       |
//|    another function. MinLMRestartFrom() allows to reuse already  |
//|    initialized structure.                                        |
//| INPUT PARAMETERS:                                                |
//|     N       -   dimension, N>1                                   |
//|                 * if given, only leading N elements of X are     |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     M       -   number of functions f[i]                         |
//|     X       -   initial solution, array[0..N-1]                  |
//|     DiffStep-   differentiation step, >0                         |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| See also MinLMIteration, MinLMResults.                           |
//| NOTES:                                                           |
//| 1. you may tune stopping conditions with MinLMSetCond() function |
//| 2. if target function contains exp() or other fast growing       |
//|    functions, and optimization algorithm makes too large steps   |
//|    which leads to overflow, use MinLMSetStpMax() function to     |
//|    bound algorithm's steps.                                      |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateV(const int n,const int m,double &x[],
                           double diffstep,CMinLMStateShell &state)
  {
   CMinLM::MinLMCreateV(n,m,x,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                 IMPROVED LEVENBERG-MARQUARDT METHOD FOR          |
//|                  NON-LINEAR LEAST SQUARES OPTIMIZATION           |
//| DESCRIPTION:                                                     |
//| This function is used to find minimum of function which is       |
//| represented as sum of squares:                                   |
//|     F(x) = f[0]^2(x[0],...,x[n-1]) + ... +                       |
//|     + f[m-1]^2(x[0],...,x[n-1])                                  |
//| using value of function vector f[] only. Finite differences are  |
//| used to calculate Jacobian.                                      |
//| REQUIREMENTS:                                                    |
//| This algorithm will request following information during its     |
//| operation:                                                       |
//| * function vector f[] at given point X                           |
//| There are several overloaded versions of MinLMOptimize() function|
//| which correspond to different LM-like optimization algorithms    |
//| provided by this unit. You should choose version which accepts   |
//| fvec() callback.                                                 |
//| You can try to initialize MinLMState structure with VJ function  |
//| and then use incorrect version of MinLMOptimize() (for example,  |
//| version which works with general form function and does not      |
//| accept function vector), but it will lead to exception being     |
//| thrown after first attempt to calculate Jacobian.                |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with MinLMCreateV() call     |
//| 2. User tunes solver parameters with MinLMSetCond(),             |
//|    MinLMSetStpMax() and other functions                          |
//| 3. User calls MinLMOptimize() function which takes algorithm     |
//|    state and callback functions.                                 |
//| 4. User calls MinLMResults() to get solution                     |
//| 5. Optionally, user may call MinLMRestartFrom() to solve another |
//|    problem with same N/M but another starting point and/or       |
//|    another function. MinLMRestartFrom() allows to reuse already  |
//|    initialized structure.                                        |
//| INPUT PARAMETERS:                                                |
//|     N       -   dimension, N>1                                   |
//|                 * if given, only leading N elements of X are     |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     M       -   number of functions f[i]                         |
//|     X       -   initial solution, array[0..N-1]                  |
//|     DiffStep-   differentiation step, >0                         |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| See also MinLMIteration, MinLMResults.                           |
//| NOTES:                                                           |
//| 1. you may tune stopping conditions with MinLMSetCond() function |
//| 2. if target function contains exp() or other fast growing       |
//|    functions, and optimization algorithm makes too large steps   |
//|    which leads to overflow, use MinLMSetStpMax() function to     |
//|    bound algorithm's steps.                                      |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateV(const int m,double &x[],const double diffstep,
                           CMinLMStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinLM::MinLMCreateV(n,m,x,diffstep,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|     LEVENBERG-MARQUARDT-LIKE METHOD FOR NON-LINEAR OPTIMIZATION  |
//| DESCRIPTION:                                                     |
//| This function is used to find minimum of general form (not       |
//| "sum-of-squares") function                                       |
//|     F = F(x[0], ..., x[n-1])                                     |
//| using its gradient and Hessian. Levenberg-Marquardt modification |
//| with L-BFGS pre-optimization and internal pre-conditioned L-BFGS |
//| optimization after each Levenberg-Marquardt step is used.        |
//| REQUIREMENTS:                                                    |
//| This algorithm will request following information during its     |
//| operation:                                                       |
//| * function value F at given point X                              |
//| * F and gradient G (simultaneously) at given point X             |
//| * F, G and Hessian H (simultaneously) at given point X           |
//| There are several overloaded versions of  MinLMOptimize()        |
//| function which correspond to different LM-like optimization      |
//| algorithms provided by this unit. You should choose version which|
//| accepts func(), grad() and hess() function pointers. First       |
//| pointer is used to calculate F at given point, second one        |
//| calculates F(x) and grad F(x), third one calculates F(x), grad   |
//| F(x), hess F(x).                                                 |
//| You can try to initialize MinLMState structure with FGH-function |
//| and then use incorrect version of MinLMOptimize() (for example,  |
//| version which does not provide Hessian matrix), but it will lead |
//| to exception being thrown after first attempt to calculate       |
//| Hessian.                                                         |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with MinLMCreateFGH() call   |
//| 2. User tunes solver parameters with MinLMSetCond(),             |
//|    MinLMSetStpMax() and other functions                          |
//| 3. User calls MinLMOptimize() function which takes algorithm     |
//|    state and pointers (delegates, etc.) to callback functions.   |
//| 4. User calls MinLMResults() to get solution                     |
//| 5. Optionally, user may call MinLMRestartFrom() to solve another |
//|    problem with same N but another starting point and/or another |
//|    function. MinLMRestartFrom() allows to reuse already          |
//|    initialized structure.                                        |
//| INPUT PARAMETERS:                                                |
//|     N       -   dimension, N>1                                   |
//|                 * if given, only leading N elements of X are     |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     X       -   initial solution, array[0..N-1]                  |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. you may tune stopping conditions with MinLMSetCond() function |
//| 2. if target function contains exp() or other fast growing       |
//|    functions, and optimization algorithm makes too large steps   |
//|    which leads to overflow, use MinLMSetStpMax() function to     |
//|    bound algorithm's steps.                                      |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateFGH(const int n,double &x[],CMinLMStateShell &state)
  {
   CMinLM::MinLMCreateFGH(n,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|     LEVENBERG-MARQUARDT-LIKE METHOD FOR NON-LINEAR OPTIMIZATION  |
//| DESCRIPTION:                                                     |
//| This function is used to find minimum of general form (not       |
//| "sum-of-squares") function                                       |
//|     F = F(x[0], ..., x[n-1])                                     |
//| using its gradient and Hessian. Levenberg-Marquardt modification |
//| with L-BFGS pre-optimization and internal pre-conditioned L-BFGS |
//| optimization after each Levenberg-Marquardt step is used.        |
//| REQUIREMENTS:                                                    |
//| This algorithm will request following information during its     |
//| operation:                                                       |
//| * function value F at given point X                              |
//| * F and gradient G (simultaneously) at given point X             |
//| * F, G and Hessian H (simultaneously) at given point X           |
//| There are several overloaded versions of  MinLMOptimize()        |
//| function which correspond to different LM-like optimization      |
//| algorithms provided by this unit. You should choose version which|
//| accepts func(), grad() and hess() function pointers. First       |
//| pointer is used to calculate F at given point, second one        |
//| calculates F(x) and grad F(x), third one calculates F(x), grad   |
//| F(x), hess F(x).                                                 |
//| You can try to initialize MinLMState structure with FGH-function |
//| and then use incorrect version of MinLMOptimize() (for example,  |
//| version which does not provide Hessian matrix), but it will lead |
//| to exception being thrown after first attempt to calculate       |
//| Hessian.                                                         |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with MinLMCreateFGH() call   |
//| 2. User tunes solver parameters with MinLMSetCond(),             |
//|    MinLMSetStpMax() and other functions                          |
//| 3. User calls MinLMOptimize() function which takes algorithm     |
//|    state and pointers (delegates, etc.) to callback functions.   |
//| 4. User calls MinLMResults() to get solution                     |
//| 5. Optionally, user may call MinLMRestartFrom() to solve another |
//|    problem with same N but another starting point and/or another |
//|    function. MinLMRestartFrom() allows to reuse already          |
//|    initialized structure.                                        |
//| INPUT PARAMETERS:                                                |
//|     N       -   dimension, N>1                                   |
//|                 * if given, only leading N elements of X are     |
//|                   used                                           |
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//|     X       -   initial solution, array[0..N-1]                  |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. you may tune stopping conditions with MinLMSetCond() function |
//| 2. if target function contains exp() or other fast growing       |
//|    functions, and optimization algorithm makes too large steps   |
//|    which leads to overflow, use MinLMSetStpMax() function to     |
//|    bound algorithm's steps.                                      |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateFGH(double &x[],CMinLMStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinLM::MinLMCreateFGH(n,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function sets stopping conditions for Levenberg-Marquardt   |
//| optimization algorithm.                                          |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     EpsX    -   >=0                                              |
//|                 The subroutine finishes its work if on k+1-th    |
//|                 iteration the condition |v|<=EpsX is fulfilled,  |
//|                 where:                                           |
//|                 * |.| means Euclidian norm                       |
//|                 * v - scaled step vector, v[i]=dx[i]/s[i]        |
//|                 * dx - ste pvector, dx=X(k+1)-X(k)               |
//|                 * s - scaling coefficients set by MinLMSetScale()|
//|     MaxIts  -   maximum number of iterations. If MaxIts=0, the   |
//|                 number of iterations is unlimited. Only          |
//|                 Levenberg-Marquardt iterations are counted       |
//|                 (L-BFGS/CG iterations are NOT counted because    |
//|                 their cost is very low compared to that of LM).  |
//| Passing EpsG=0, EpsF=0, EpsX=0 and MaxIts=0 (simultaneously) will|
//| lead to automatic stopping criterion selection (small EpsX).     |
//+------------------------------------------------------------------+
void CAlglib::MinLMSetCond(CMinLMStateShell &state,const double epsx,
                           const int maxits)
  {
   CMinLM::MinLMSetCond(state.GetInnerObj(),epsx,maxits);
  }
//+------------------------------------------------------------------+
//| This function turns on/off reporting.                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     NeedXRep-   whether iteration reports are needed or not      |
//| If NeedXRep is True, algorithm will call rep() callback function |
//| if it is provided to MinLMOptimize(). Both Levenberg-Marquardt   |
//| and internal L-BFGS iterations are reported.                     |
//+------------------------------------------------------------------+
void CAlglib::MinLMSetXRep(CMinLMStateShell &state,const bool needxrep)
  {
   CMinLM::MinLMSetXRep(state.GetInnerObj(),needxrep);
  }
//+------------------------------------------------------------------+
//| This function sets maximum step length                           |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     StpMax  -   maximum step length, >=0. Set StpMax to 0.0, if  |
//|                 you don't want to limit step length.             |
//| Use this subroutine when you optimize target function which      |
//| contains exp() or other fast growing functions, and optimization |
//| algorithm makes too large steps which leads to overflow. This    |
//| function allows us to reject steps that are too large (and       |
//| therefore expose us to the possible overflow) without actually   |
//| calculating function value at the x+stp*d.                       |
//| NOTE: non-zero StpMax leads to moderate performance degradation  |
//| because intermediate step of preconditioned L-BFGS optimization  |
//| is incompatible with limits on step size.                        |
//+------------------------------------------------------------------+
void CAlglib::MinLMSetStpMax(CMinLMStateShell &state,const double stpmax)
  {
   CMinLM::MinLMSetStpMax(state.GetInnerObj(),stpmax);
  }
//+------------------------------------------------------------------+
//| This function sets scaling coefficients for LM optimizer.        |
//| ALGLIB optimizers use scaling matrices to test stopping          |
//| conditions (step size and gradient are scaled before comparison  |
//| with tolerances). Scale of the I-th variable is a translation    |
//| invariant measure of:                                            |
//| a) "how large" the variable is                                   |
//| b) how large the step should be to make significant changes in   |
//| the function                                                     |
//| Generally, scale is NOT considered to be a form of               |
//| preconditioner. But LM optimizer is unique in that it uses       |
//| scaling matrix both in the stopping condition tests and as       |
//| Marquardt damping factor.                                        |
//| Proper scaling is very important for the algorithm performance.  |
//| It is less important for the quality of results, but still has   |
//| some influence (it is easier to converge when variables are      |
//| properly scaled, so premature stopping is possible when very     |
//| badly scalled variables are combined with relaxed stopping       |
//| conditions).                                                     |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure stores algorithm state                 |
//|     S       -   array[N], non-zero scaling coefficients          |
//|                 S[i] may be negative, sign doesn't matter.       |
//+------------------------------------------------------------------+
void CAlglib::MinLMSetScale(CMinLMStateShell &state,double &s[])
  {
   CMinLM::MinLMSetScale(state.GetInnerObj(),s);
  }
//+------------------------------------------------------------------+
//| This function sets boundary constraints for LM optimizer         |
//| Boundary constraints are inactive by default (after initial      |
//| creation). They are preserved until explicitly turned off with   |
//| another SetBC() call.                                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure stores algorithm state                 |
//|     BndL    -   lower bounds, array[N].                          |
//|                 If some (all) variables are unbounded, you may   |
//|                 specify very small number or -INF (latter is     |
//|                 recommended because it will allow solver to use  |
//|                 better algorithm).                               |
//|     BndU    -   upper bounds, array[N].                          |
//|                 If some (all) variables are unbounded, you may   |
//|                 specify very large number or +INF (latter is     |
//|                 recommended because it will allow solver to use  |
//|                 better algorithm).                               |
//| NOTE 1: it is possible to specify BndL[i]=BndU[i]. In this case  |
//| I-th variable will be "frozen" at X[i]=BndL[i]=BndU[i].          |
//| NOTE 2: this solver has following useful properties:             |
//| * bound constraints are always satisfied exactly                 |
//| * function is evaluated only INSIDE area specified by bound      |
//|   constraints or at its boundary                                 |
//+------------------------------------------------------------------+
void CAlglib::MinLMSetBC(CMinLMStateShell &state,double &bndl[],
                         double &bndu[])
  {
   CMinLM::MinLMSetBC(state.GetInnerObj(),bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function is used to change acceleration settings            |
//| You can choose between three acceleration strategies:            |
//| * AccType=0, no acceleration.                                    |
//| * AccType=1, secant updates are used to update quadratic model   |
//|   after each iteration. After fixed number of iterations (or     |
//|   after model breakdown) we recalculate quadratic model using    |
//|   analytic Jacobian or finite differences. Number of secant-based|
//|   iterations depends on optimization settings: about 3           |
//|   iterations - when we have analytic Jacobian, up to 2*N         |
//|   iterations - when we use finite differences to calculate       |
//|   Jacobian.                                                      |
//| AccType=1 is recommended when Jacobian calculation cost is       |
//| prohibitive high (several Mx1 function vector calculations       |
//| followed by several NxN Cholesky factorizations are faster than  |
//| calculation of one M*N  Jacobian). It should also be used when we|
//| have no Jacobian, because finite difference approximation takes  |
//| too much time to compute.                                        |
//| Table below list optimization protocols (XYZ protocol corresponds|
//| to MinLMCreateXYZ) and acceleration types they support (and use  |
//| by default).                                                     |
//| ACCELERATION TYPES SUPPORTED BY OPTIMIZATION PROTOCOLS:          |
//| protocol    0   1   comment                                      |
//| V           +   +                                                |
//| VJ          +   +                                                |
//| FGH         +                                                    |
//| DAFAULT VALUES:                                                  |
//| protocol    0   1   comment                                      |
//| V               x   without acceleration it is so slooooooooow   |
//| VJ          x                                                    |
//| FGH         x                                                    |
//| NOTE: this  function should be called before optimization.       |
//| Attempt to call it during algorithm iterations may result in     |
//| unexpected behavior.                                             |
//| NOTE: attempt to call this function with unsupported             |
//| protocol/acceleration combination will result in exception being |
//| thrown.                                                          |
//+------------------------------------------------------------------+
void CAlglib::MinLMSetAccType(CMinLMStateShell &state,const int acctype)
  {
   CMinLM::MinLMSetAccType(state.GetInnerObj(),acctype);
  }
//+------------------------------------------------------------------+
//| This function provides reverse communication interface           |
//| Reverse communication interface is not documented or recommended |
//| to use.                                                          |
//| See below for functions which provide better documented API      |
//+------------------------------------------------------------------+
bool CAlglib::MinLMIteration(CMinLMStateShell &state)
  {
   return(CMinLM::MinLMIteration(state.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     hess    -   callback which calculates function (or merit     |
//|                 function) value func, gradient grad and Hessian  |
//|                 hess at given point x                            |
//|     fvec    -   callback which calculates function vector fi[]   |
//|                 at given point x                                 |
//|     jac     -   callback which calculates function vector fi[]   |
//|                 and Jacobian jac at given point x                |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. Depending on function used to create state  structure, this   |
//|    algorithm may accept Jacobian and/or Hessian and/or gradient. |
//|    According to the said above, there ase several versions of    |
//|    this function, which accept different sets of callbacks.      |
//|    This flexibility opens way to subtle errors - you may create  |
//|    state with MinLMCreateFGH() (optimization using Hessian), but |
//|    call function which does not accept Hessian. So when          |
//|    algorithm will request Hessian, there will be no callback to  |
//|    call. In this case exception will be thrown.                  |
//|    Be careful to avoid such errors because there is no way to    |
//|    find them at compile time - you can see them at runtime only. |
//+------------------------------------------------------------------+
void CAlglib::MinLMOptimize(CMinLMStateShell &state,CNDimensional_FVec &fvec,
                            CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinLMIteration(state))
     {
      if(state.GetNeedFI())
        {
         fvec.FVec(state.GetInnerObj().m_x,state.GetInnerObj().m_fi,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'minlmoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     hess    -   callback which calculates function (or merit     |
//|                 function) value func, gradient grad and Hessian  |
//|                 hess at given point x                            |
//|     fvec    -   callback which calculates function vector fi[]   |
//|                 at given point x                                 |
//|     jac     -   callback which calculates function vector fi[]   |
//|                 and Jacobian jac at given point x                |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. Depending on function used to create state  structure, this   |
//|    algorithm may accept Jacobian and/or Hessian and/or gradient. |
//|    According to the said above, there ase several versions of    |
//|    this function, which accept different sets of callbacks.      |
//|    This flexibility opens way to subtle errors - you may create  |
//|    state with MinLMCreateFGH() (optimization using Hessian), but |
//|    call function which does not accept Hessian. So when          |
//|    algorithm will request Hessian, there will be no callback to  |
//|    call. In this case exception will be thrown.                  |
//|    Be careful to avoid such errors because there is no way to    |
//|    find them at compile time - you can see them at runtime only. |
//+------------------------------------------------------------------+
void CAlglib::MinLMOptimize(CMinLMStateShell &state,CNDimensional_FVec &fvec,
                            CNDimensional_Jac &jac,CNDimensional_Rep &rep,
                            bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinLMIteration(state))
     {
      //--- check
      if(state.GetNeedFI())
        {
         fvec.FVec(state.GetInnerObj().m_x,state.GetInnerObj().m_fi,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetNeedFIJ())
        {
         jac.Jac(state.GetInnerObj().m_x,state.GetInnerObj().m_fi,state.GetInnerObj().m_j,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'minlmoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     hess    -   callback which calculates function (or merit     |
//|                 function) value func, gradient grad and Hessian  |
//|                 hess at given point x                            |
//|     fvec    -   callback which calculates function vector fi[]   |
//|                 at given point x                                 |
//|     jac     -   callback which calculates function vector fi[]   |
//|                 and Jacobian jac at given point x                |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. Depending on function used to create state  structure, this   |
//|    algorithm may accept Jacobian and/or Hessian and/or gradient. |
//|    According to the said above, there ase several versions of    |
//|    this function, which accept different sets of callbacks.      |
//|    This flexibility opens way to subtle errors - you may create  |
//|    state with MinLMCreateFGH() (optimization using Hessian), but |
//|    call function which does not accept Hessian. So when          |
//|    algorithm will request Hessian, there will be no callback to  |
//|    call. In this case exception will be thrown.                  |
//|    Be careful to avoid such errors because there is no way to    |
//|    find them at compile time - you can see them at runtime only. |
//+------------------------------------------------------------------+
void CAlglib::MinLMOptimize(CMinLMStateShell &state,CNDimensional_Func &func,
                            CNDimensional_Grad &grad,CNDimensional_Hess &hess,
                            CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinLMIteration(state))
     {
      //--- check
      if(state.GetNeedF())
        {
         func.Func(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetNeedFG())
        {
         grad.Grad(state.GetInnerObj().m_x,state.GetInnerObj().m_f,state.GetInnerObj().m_g,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetNeedFGH())
        {
         hess.Hess(state.GetInnerObj().m_x,state.GetInnerObj().m_f,state.GetInnerObj().m_g,state.GetInnerObj().m_h,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'minlmoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     hess    -   callback which calculates function (or merit     |
//|                 function) value func, gradient grad and Hessian  |
//|                 hess at given point x                            |
//|     fvec    -   callback which calculates function vector fi[]   |
//|                 at given point x                                 |
//|     jac     -   callback which calculates function vector fi[]   |
//|                 and Jacobian jac at given point x                |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. Depending on function used to create state  structure, this   |
//|    algorithm may accept Jacobian and/or Hessian and/or gradient. |
//|    According to the said above, there ase several versions of    |
//|    this function, which accept different sets of callbacks.      |
//|    This flexibility opens way to subtle errors - you may create  |
//|    state with MinLMCreateFGH() (optimization using Hessian), but |
//|    call function which does not accept Hessian. So when          |
//|    algorithm will request Hessian, there will be no callback to  |
//|    call. In this case exception will be thrown.                  |
//|    Be careful to avoid such errors because there is no way to    |
//|    find them at compile time - you can see them at runtime only. |
//+------------------------------------------------------------------+
void CAlglib::MinLMOptimize(CMinLMStateShell &state,CNDimensional_Func &func,
                            CNDimensional_Jac &jac,CNDimensional_Rep &rep,
                            bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinLMIteration(state))
     {
      //--- check
      if(state.GetNeedF())
        {
         func.Func(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetNeedFIJ())
        {
         jac.Jac(state.GetInnerObj().m_x,state.GetInnerObj().m_fi,state.GetInnerObj().m_j,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'minlmoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     hess    -   callback which calculates function (or merit     |
//|                 function) value func, gradient grad and Hessian  |
//|                 hess at given point x                            |
//|     fvec    -   callback which calculates function vector fi[]   |
//|                 at given point x                                 |
//|     jac     -   callback which calculates function vector fi[]   |
//|                 and Jacobian jac at given point x                |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//| NOTES:                                                           |
//| 1. Depending on function used to create state  structure, this   |
//|    algorithm may accept Jacobian and/or Hessian and/or gradient. |
//|    According to the said above, there ase several versions of    |
//|    this function, which accept different sets of callbacks.      |
//|    This flexibility opens way to subtle errors - you may create  |
//|    state with MinLMCreateFGH() (optimization using Hessian), but |
//|    call function which does not accept Hessian. So when          |
//|    algorithm will request Hessian, there will be no callback to  |
//|    call. In this case exception will be thrown.                  |
//|    Be careful to avoid such errors because there is no way to    |
//|    find them at compile time - you can see them at runtime only. |
//+------------------------------------------------------------------+
void CAlglib::MinLMOptimize(CMinLMStateShell &state,CNDimensional_Func &func,
                            CNDimensional_Grad &grad,CNDimensional_Jac &jac,
                            CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinLMIteration(state))
     {
      //--- check
      if(state.GetNeedF())
        {
         func.Func(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetNeedFG())
        {
         grad.Grad(state.GetInnerObj().m_x,state.GetInnerObj().m_f,state.GetInnerObj().m_g,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetNeedFIJ())
        {
         jac.Jac(state.GetInnerObj().m_x,state.GetInnerObj().m_fi,state.GetInnerObj().m_j,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'minlmoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| Levenberg-Marquardt algorithm results                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   algorithm state                                  |
//| OUTPUT PARAMETERS:                                               |
//|     X       -   array[0..N-1], solution                          |
//|     Rep     -   optimization report;                             |
//|                 see comments for this structure for more info.   |
//+------------------------------------------------------------------+
void CAlglib::MinLMResults(CMinLMStateShell &state,double &x[],
                           CMinLMReportShell &rep)
  {
   CMinLM::MinLMResults(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Levenberg-Marquardt algorithm results                            |
//| Buffered implementation of MinLMResults(), which uses            |
//| pre-allocated buffer to store X[]. If buffer size is too small,  |
//| it resizes buffer. It is intended to be used in the inner cycles |
//| of performance critical algorithms where array reallocation      |
//| penalty is too large to be ignored.                              |
//+------------------------------------------------------------------+
void CAlglib::MinLMResultsBuf(CMinLMStateShell &state,double &x[],
                              CMinLMReportShell &rep)
  {
   CMinLM::MinLMResultsBuf(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine restarts LM algorithm from new point. All        |
//| optimization parameters are left unchanged.                      |
//| This function allows to solve multiple optimization problems     |
//| (which must have same number of dimensions) without object       |
//| reallocation penalty.                                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure used for reverse communication         |
//|                 previously allocated with MinLMCreateXXX call.   |
//|     X       -   new starting point.                              |
//+------------------------------------------------------------------+
void CAlglib::MinLMRestartFrom(CMinLMStateShell &state,double &x[])
  {
   CMinLM::MinLMRestartFrom(state.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| This is obsolete function.                                       |
//| Since ALGLIB 3.3 it is equivalent to MinLMCreateVJ().            |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateVGJ(const int n,const int m,double &x[],
                             CMinLMStateShell &state)
  {
   CMinLM::MinLMCreateVGJ(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This is obsolete function.                                       |
//| Since ALGLIB 3.3 it is equivalent to MinLMCreateVJ().            |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateVGJ(const int m,double &x[],CMinLMStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinLM::MinLMCreateVGJ(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This is obsolete function.                                       |
//| Since ALGLIB 3.3 it is equivalent to MinLMCreateFJ().            |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateFGJ(const int n,const int m,double &x[],
                             CMinLMStateShell &state)
  {
   CMinLM::MinLMCreateFGJ(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This is obsolete function.                                       |
//| Since ALGLIB 3.3 it is equivalent to MinLMCreateFJ().            |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateFGJ(const int m,double &x[],CMinLMStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinLM::MinLMCreateFGJ(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function is considered obsolete since ALGLIB 3.1.0 and is   |
//| present for backward compatibility only. We recommend to use     |
//| MinLMCreateVJ, which provides similar, but more consistent and   |
//| feature-rich interface.                                          |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateFJ(const int n,const int m,double &x[],
                            CMinLMStateShell &state)
  {
   CMinLM::MinLMCreateFJ(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function is considered obsolete since ALGLIB 3.1.0 and is   |
//| present for backward compatibility only. We recommend to use     |
//| MinLMCreateVJ, which provides similar, but more consistent and   |
//| feature-rich interface.                                          |
//+------------------------------------------------------------------+
void CAlglib::MinLMCreateFJ(const int m,double &x[],CMinLMStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinLM::MinLMCreateFJ(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| LINEAR PROGRAMMING                                               |
//| The subroutine creates LP solver. After initial creation it      |
//| contains default optimization problem with zero cost vector and  |
//| all variables being fixed to zero values and no constraints.     |
//| In order to actually solve something you should:                 |
//|   * set cost vector with MinLPSetCost()                          |
//|   * set variable bounds with MinLPSetBC() or MinLPSetBCAll()     |
//|   * specify constraint matrix with one of the following          |
//|     functions:                                                   |
//|      [*] MinLPSetLC()        for dense one-sided constraints     |
//|      [*] MinLPSetLC2Dense()  for dense two-sided constraints     |
//|      [*] MinLPSetLC2()       for sparse two-sided constraints    |
//|      [*] MinLPAddLC2Dense()  to add one dense row to constraint  |
//|                              matrix                              |
//|      [*] MinLPAddLC2()       to add one row to constraint matrix |
//|                              (compressed format)                 |
//|   * call MinLPOptimize() to run the solver and MinLPResults() to |
//|     get the solution vector and additional information.          |
//| By default, LP solver uses best algorithm available. As of ALGLIB|
//| 3.17, sparse interior point (barrier) solver is used. Future     |
//| releases of ALGLIB may introduce other solvers.                  |
//| User may choose specific LP algorithm by calling:                |
//|   * MinLPSetAlgoDSS() for revised dual simplex method with DSE   |
//|     pricing and bounds flipping ratio test (aka long dual step). |
//|     Large - scale sparse LU solverwith Forest - Tomlin update is |
//|     used internally as linear algebra driver.                    |
//|   * MinLPSetAlgoIPM() for sparse interior point method           |
//| INPUT PARAMETERS:                                                |
//|   N        -  problem size                                       |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  optimizer in the default State                     |
//+------------------------------------------------------------------+
void CAlglib::MinLPCreate(int n,CMinLPState &state)
  {
   CMinLP::MinLPCreate(n,state);
  }
//+------------------------------------------------------------------+
//| This function sets LP algorithm to revised dual simplex method.  |
//| ALGLIB implementation of dual simplex method supports advanced   |
//| performance and stability improvements like DSE pricing, bounds  |
//| flipping ratio test (aka long dual step), Forest - Tomlin update,|
//| Shifting.                                                        |
//| INPUT PARAMETERS:                                                |
//|   State       -  optimizer                                       |
//|   Eps         -  stopping condition, Eps >= 0:                   |
//|                  * should be small number about 1E-6 or 1E-7.    |
//|                  * zero value means that solver automatically    |
//|                    selects good value (can be different in       |
//|                    different ALGLIB versions)                    |
//|                  * default value is zero                         |
//| Algorithm stops when relative error is less than Eps.            |
//| ===== TRACING DSS SOLVER ======================================= |
//| DSS solver supports advanced tracing capabilities. You can trace |
//| algorithm output by specifying following trace symbols           |
//| (case-insensitive) by means of trace_file() call:                |
//|   * 'DSS'     -  for basic trace of algorithm steps and decisions|
//|                  Only short scalars (function values and deltas) |
//|                  are  printed. N-dimensional quantities like     |
//|                  search directions are NOT printed.              |
//|   * 'DSS.DETAILED' - for output of points being visited and      |
//|                  search directions.                              |
//| This symbol also implicitly defines 'DSS'. You can control output|
//| format by additionally specifying:                               |
//|   * nothing     to output in  6-digit exponential format         |
//|   * 'PREC.E15'  to output in  15-digit exponential format        |
//|   * 'PREC.F6'   to output in  6-digit fixed - point format       |
//| By default trace is disabled and adds no overhead to  the        |
//| optimization process. However, specifying any of the symbols     |
//| adds some formatting and output - related overhead.              |
//| You may specify multiple symbols by separating them with commas: |
//|   >                                                              |
//|  >CAlglib::Trace_File("DSS,PREC.F6","path/to/trace.log")       |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetAlgoDSS(CMinLPState &state,double eps)
  {
   CMinLP::MinLPSetAlgoDSS(state,eps);
  }
//+------------------------------------------------------------------+
//| This function sets LP algorithm to sparse interior point method. |
//| ALGORITHM INFORMATION:                                           |
//|   * this  algorithm  is  our implementation  of  interior  point |
//|     method as formulated by R.J.Vanderbei, with minor            |
//|     modifications to the algorithm (damped Newton directions are |
//|     extensively used)                                            |
//|   * like all interior point methods, this algorithm  tends  to   |
//|     converge in roughly same number of iterations (between 15    |
//|     and 50) independently from the problem dimensionality        |
//| INPUT PARAMETERS:                                                |
//|   State    -  optimizer                                          |
//|   Eps      -  stopping condition, Eps >= 0:                      |
//|               * should be small number about 1E-7 or 1E-8.       |
//|               * zero value means that solver automatically       |
//|                 selects good value (can be different in different|
//|                 ALGLIB versions)                                 |
//|               * default value is zero                            |
//| Algorithm  stops  when  primal  error  AND  dual error AND       |
//| duality gap are less than Eps.                                   |
//| ===== TRACING IPM SOLVER ======================================= |
//| IPM solver supports advanced tracing capabilities. You can trace |
//| algorithm output by specifying following trace symbols           |
//| (case-insensitive) by means of trace_file() call:                |
//|   * 'IPM'        -  for basic trace of algorithm steps and       |
//|                     decisions. Only short scalars (function      |
//|                     values and deltas) are printed. N-dimensional|
//|                     quantities like search directions are  NOT   |
//|                     printed.                                     |
//|   * 'IPM.DETAILED' - for output of points being visited and      |
//|                     search directions                            |
//| This symbol also implicitly defines 'IPM'. You can output format |
//| by additionally specifying:                                      |
//|   * nothing     to output in  6-digit exponential format         |
//|   * 'PREC.E15'  to output in  15 - digit exponential format      |
//|   * 'PREC.F6'   to output in  6-digit fixed-point format         |
//| By default trace is disabled and adds no overhead to the         |
//| optimization process. However, specifying any of the symbols     |
//| adds some formatting and output - related overhead.              |
//| You may specify multiple symbols by separating them with commas: |
//|   >                                                              |
//|  >CAlglib::Trace_File("IPM,PREC.F6","path/to/trace.log")       |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetAlgoIPM(CMinLPState &state,double eps=0)
  {
   CMinLP::MinLPSetAlgoIPM(state,eps);
  }
//+------------------------------------------------------------------+
//| This function sets cost term for LP solver.                      |
//| By default, cost term is zero.                                   |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//|   C        -  cost term, array[N].                               |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetCost(CMinLPState &state,CRowDouble &c)
  {
   CMinLP::MinLPSetCost(state,c);
  }
//+------------------------------------------------------------------+
//| This function sets scaling coefficients.                         |
//| ALGLIB optimizers use scaling matrices to test stopping          |
//| conditions and as preconditioner.                                |
//| Scale of the I-th variable is a translation invariant measure of:|
//|   a) "how large" the variable is                                 |
//|   b) how large the step should be to make significant changes in |
//|      the function                                                |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//|   S        -  array[N], non-zero scaling coefficients S[i] may   |
//|               be negative, sign doesn't matter.                  |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetScale(CMinLPState &state,CRowDouble &s)
  {
   CMinLP::MinLPSetScale(state,s);
  }
//+------------------------------------------------------------------+
//| This function sets box constraints for LP solver (all variables  |
//| at  once, different constraints for different variables).        |
//| The default State of constraints is to have all variables fixed  |
//| at zero. You have to overwrite it by your own constraint vector. |
//| Constraint status is preserved until constraints are  explicitly |
//| overwritten with another MinLPSetBC() call, overwritten with     |
//| MinLPSetBCAll(), or partially overwritten with minlmsetbci() call|
//| Following types of constraints are supported:                    |
//|   DESCRIPTION         CONSTRAINT              HOW TO SPECIFY     |
//|   fixed variable      x[i] = Bnd[i]             BndL[i] = BndU[i]|
//|   lower bound         BndL[i] <= x[i]           BndU[i] = +INF   |
//|   upper bound         x[i] <= BndU[i]           BndL[i] = -INF   |
//|   range               BndL[i] <= x[i] <= BndU[i]  ...            |
//|   free variable       -             BndL[I] = -INF, BndU[I] + INF|
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//|   BndL     -  lower bounds, array[N].                            |
//|   BndU     -  upper bounds, array[N].                            |
//| NOTE: infinite values can be specified by means of AL_POSINF and |
//|       AL_NEGINF                                                  |
//| NOTE: you may replace infinities by very small/very large values,|
//|       but it is not recommended because large numbers may        |
//|       introduce large numerical errors in the algorithm.         |
//| NOTE: if constraints for all variables are same you may use      |
//|       MinLPSetBCAll() which allows to specify constraints without|
//|       using arrays.                                              |
//| NOTE: BndL > BndU will result in LP problem being recognized as  |
//|       infeasible.                                                |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetBC(CMinLPState &state,CRowDouble &bndl,
                         CRowDouble &bndu)
  {
   CMinLP::MinLPSetBC(state,bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function sets box constraints for LP solver(all variables at|
//| once, same constraints for all variables)                        |
//| The default State of constraints is to have all variables fixed  |
//| at zero. You have to overwrite it by your own constraint vector. |
//| Constraint status is preserved until constraints are explicitly  |
//| overwritten with another MinLPSetBC() call or partially          |
//| overwritten with MinLPSetBCAll().                                |
//| Following types of constraints are supported:                    |
//|   DESCRIPTION         CONSTRAINT              HOW TO SPECIFY     |
//|   fixed variable      x[i] = Bnd[i]             BndL[i] = BndU[i]|
//|   lower bound         BndL[i] <= x[i]           BndU[i] = +INF   |
//|   upper bound         x[i] <= BndU[i]           BndL[i] = -INF   |
//|   range               BndL[i] <= x[i] <= BndU[i]  ...            |
//|   free variable       -             BndL[I] = -INF, BndU[I] + INF|
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//|   BndL     -  lower bound, same for all variables                |
//|   BndU     -  upper bound, same for all variables                |
//| NOTE: infinite values can be specified by means of AL_POSINF and |
//|       AL_NEGINF                                                  |
//| NOTE: you may replace infinities by very small/very large values,|
//|       but it is not recommended because large numbers may        |
//|       introduce large numerical errors in the algorithm.         |
//| NOTE: MinLPSetBC() can be used to specify different constraints  |
//|       for different variables.                                   |
//| NOTE: BndL > BndU will result in LP problem being recognized as  |
//|       infeasible.                                                |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetBCAll(CMinLPState &state,double bndl,double bndu)
  {
   CMinLP::MinLPSetBCAll(state,bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function sets box constraints for I-th variable (other      |
//| variables are not modified).                                     |
//| The default State of constraints is to have all variables fixed  |
//| at zero. You have to overwrite it by your own constraint vector. |
//| Following types of constraints are supported:                    |
//|   DESCRIPTION         CONSTRAINT              HOW TO SPECIFY     |
//|   fixed variable      x[i] = Bnd[i]             BndL[i] = BndU[i]|
//|   lower bound         BndL[i] <= x[i]           BndU[i] = +INF   |
//|   upper bound         x[i] <= BndU[i]           BndL[i] = -INF   |
//|   range               BndL[i] <= x[i] <= BndU[i]  ...            |
//|   free variable       -             BndL[I] = -INF, BndU[I] + INF|
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//|   I        -  variable index, in [0, N)                          |
//|   BndL     -  lower bound for I-th variable                      |
//|   BndU     -  upper bound for I-th variable                      |
//| NOTE: infinite values can be specified by means of AL_POSINF and |
//|       AL_NEGINF                                                  |
//| NOTE: you may replace infinities by very small/very large values,|
//|       but it is not recommended because large numbers may        |
//|       introduce large numerical errors in the algorithm.         |
//| NOTE: MinLPSetBC() can be used to specify different constraints  |
//|       for different variables.                                   |
//| NOTE: BndL > BndU will result in LP problem being recognized as  |
//|       infeasible.                                                |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetBCi(CMinLPState &state,int i,double bndl,double bndu)
  {
   CMinLP::MinLPSetBCi(state,i,bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function sets one-sided linear constraints A*x ~ AU, where  |
//| "~" can be a mix of "<=", "=" and ">=".                          |
//| IMPORTANT: this function is provided here for compatibility with |
//|            the rest of ALGLIB optimizers which accept constraints|
//|            in format like this one. Many real-life problems      |
//|            feature two-sided constraints like a0 <= a*x <= a1. It|
//|            is really inefficient to add them as a pair of        |
//|            one-sided constraints.                                |
//| Use MinLPSetLC2Dense(), MinLPSetLC2(), MinLPAddLC2() (or its     |
//| sparse version) wherever possible.                               |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinLPCreate()  |
//|               call.                                              |
//|   A        -  linear constraints, array[K, N + 1]. Each row of A |
//|               represents one constraint, with first N elements   |
//|               being linear coefficients, and last element being  |
//|               right side.                                        |
//|   CT       -  constraint types, array[K]:                        |
//|               * if CT[i] > 0, then I-th constraint is            |
//|                              A[i, *]*x >= A[i, n]                |
//|               * if CT[i] = 0, then I-th constraint is            |
//|                              A[i, *] * x  = A[i, n]              |
//|               * if CT[i] < 0, then I-th constraint is            |
//|                              A[i, *] * x <= A[i, n]              |
//|   K        -  number of equality/inequality constraints, K >= 0; |
//|               if not given, inferred from sizes of A and CT.     |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetLC(CMinLPState &state,CMatrixDouble &a,
                         CRowInt &ct,int k)
  {
   CMinLP::MinLPSetLC(state,a,ct,k);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetLC(CMinLPState &state,CMatrixDouble &a,CRowInt &ct)
  {
//--- check
   if(!CAp::Assert(CAp::Rows(a)==CAp::Len(ct),"Error while calling 'MinLPSetLC': looks like one of arguments has wrong size"))
      return;
//--- initialization
   int k=CAp::Rows(a);
//--- function call
   CMinLP::MinLPSetLC(state,a,ct,k);
  }
//+------------------------------------------------------------------+
//| This function sets two-sided linear constraints AL <= A*x <= AU. |
//| This version accepts dense matrix as  input; internally LP solver|
//| uses sparse storage anyway (most LP problems are sparse), but for|
//| your convenience it may accept dense inputs. This  function      |
//| overwrites linear constraints set by previous calls (if such     |
//| calls were made).                                                |
//| We recommend you to use sparse version of this function unless   |
//| you solve small-scale LP problem (less than few hundreds of      |
//| variables).                                                      |
//| NOTE: there also exist several versions of this function:        |
//|   * one-sided dense version which accepts constraints in the same|
//|     format as one used by QP and  NLP solvers                    |
//|   * two-sided sparse version which accepts sparse matrix         |
//|   * two-sided dense  version which allows you to add constraints |
//|     row by row                                                   |
//|   * two-sided sparse version which allows you to add constraints |
//|     row by row                                                   |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinLPCreate()  |
//|               call.                                              |
//|   A        -  linear constraints, array[K, N]. Each row of A     |
//|               represents one  constraint. One-sided inequality   |
//|               constraints, two-sided inequality constraints,     |
//|               equality constraints are supported (see below)     |
//|   AL, AU   -  lower and upper bounds, array[K];                  |
//|               * AL[i] = AU[i] => equality constraint Ai * x      |
//|               * AL[i]<AU[i] => two-sided constraint              |
//|                              AL[i] <= Ai*x <= AU[i]              |
//|               * AL[i] = -INF  => one-sided constraint            |
//|                              Ai*x <= AU[i]                       |
//|               * AU[i] = +INF  => one-sided constraint            |
//|                              AL[i] <= Ai*x                       |
//|               * AL[i] = -INF, AU[i] = +INF => constraint is      |
//|                                               ignored            |
//|   K        -  number of equality/inequality constraints, K >= 0; |
//|               if not given, inferred from sizes of A, AL, AU.    |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetLC2Dense(CMinLPState &state,CMatrixDouble &a,
                               CRowDouble &al,CRowDouble &au,int k)
  {
   CMinLP::MinLPSetLC2Dense(state,a,al,au,k);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetLC2Dense(CMinLPState &state,CMatrixDouble &a,
                               CRowDouble &al,CRowDouble &au)
  {
//--- check
   if(!CAp::Assert(CAp::Rows(a)==CAp::Len(al) && CAp::Rows(a)==CAp::Len(au),
                   "Error while calling 'minlpsetlc2dense': looks like one of arguments has wrong size"))
      return;
//--- initialization
   int k=CAp::Rows(a);
//--- function call
   CMinLP::MinLPSetLC2Dense(state,a,al,au,k);
  }
//+------------------------------------------------------------------+
//| This function sets two-sided linear constraints AL <= A*x <= AU  |
//| with sparse constraining matrix A. Recommended for large-scale   |
//| problems.                                                        |
//| This function overwrites linear (non-box) constraints set by     |
//| previous calls (if such calls were made).                        |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinLPCreate()  |
//|               call.                                              |
//|   A        -  sparse matrix with size [K, N] (exactly!). Each row|
//|               of A represents one general linear constraint. A   |
//|               can be stored in any sparse storage format.        |
//|   AL, AU   -  lower and upper bounds, array[K];                  |
//|               * AL.Set(i,AU.Set(i, > equality constraint Ai*x    |
//|               * AL[i]<AU.Set(i,> two-sided constraint            |
//|                              AL[i] <= Ai*x <= AU[i]              |
//|               * AL[i] = -INF  => one-sided constraint            |
//|                                    Ai*x <= AU[i]                 |
//|               * AU[i] = +INF  => one-sided constraint            |
//|                                    AL[i] <= Ai*x                 |
//|               * AL.Set(i, -INF, AU.Set(i, +INF => constraint is  |
//|                                                   ignored        |
//|   K        -  number of equality/inequality constraints, K >= 0. |
//|               If  K = 0 is specified, A, AL, AU are ignored.     |
//+------------------------------------------------------------------+
void CAlglib::MinLPSetLC2(CMinLPState &state,CSparseMatrix &a,
                          CRowDouble &al,CRowDouble &au,int k)
  {
   CMinLP::MinLPSetLC2(state,a,al,au,k);
  }
//+------------------------------------------------------------------+
//| This function appends two-sided linear constraint AL <= A*x <= AU|
//| to the list of currently present constraints.                    |
//| This version accepts dense constraint vector as input, but       |
//| sparsifies it for internal storage and processing. Thus, time to |
//| add one constraint in is O(N) - we have to scan entire array of  |
//| length N. Sparse version of this function is order of magnitude  |
//| faster for constraints with just a few nonzeros per row.         |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinLPCreate()  |
//|               call.                                              |
//|   A        -  linear constraint coefficient, array[N], right side|
//|               is NOT included.                                   |
//|   AL, AU   -  lower and upper bounds;                            |
//|                  * AL = AU    => equality constraint Ai*x        |
//|                  * AL<AU    => two-sided constraint              |
//|                              AL <= A*x <= AU                     |
//|                  * AL = -INF  => one-sided constraint Ai*x <= AU |
//|                  * AU = +INF  => one-sided constraint AL <= Ai*x |
//|                  * AL = -INF, AU = +INF => constraint is ignored |
//+------------------------------------------------------------------+
void CAlglib::MinLPAddLC2Dense(CMinLPState &state,CRowDouble &a,
                               double al,double au)
  {
   CMinLP::MinLPAddLC2Dense(state,a,al,au);
  }
//+------------------------------------------------------------------+
//| This function appends two-sided linear constraint AL <= A*x <= AU|
//| to the list of currently present constraints.                    |
//| Constraint is passed in compressed format: as list of non-zero   |
//| entries of coefficient vector A. Such approach is more efficient |
//| than dense storage for highly sparse constraint vectors.         |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinLPCreate()  |
//|               call.                                              |
//|   IdxA     -  array[NNZ], indexes of non-zero elements of A:     |
//|               * can be unsorted                                  |
//|               * can include duplicate indexes (corresponding     |
//|                 entries of ValA[] will be summed)                |
//|   ValA     -  array[NNZ], values of non-zero elements of A       |
//|   NNZ      -  number of non-zero coefficients in A               |
//|   AL, AU   -  lower and upper bounds;                            |
//|               * AL = AU    => equality constraint A*x            |
//|               * AL<AU    => two-sided constraint AL <= A*x <= AU |
//|               * AL = -INF  => one-sided constraint A*x <= AU     |
//|               * AU = +INF  => one-sided constraint AL <= A*x     |
//|               * AL = -INF, AU = +INF => constraint is ignored    |
//+------------------------------------------------------------------+
void CAlglib::MinLPAddLC2(CMinLPState &state,CRowInt &idxa,
                          CRowDouble &vala,int nnz,double al,
                          double au)
  {
   CMinLP::MinLPAddLC2(state,idxa,vala,nnz,al,au);
  }
//+------------------------------------------------------------------+
//| This function solves LP problem.                                 |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm State                                    |
//| You should use MinLPResults() function to access results after   |
//| calls to this function.                                          |
//+------------------------------------------------------------------+
void CAlglib::MinLPOptimize(CMinLPState &state)
  {
   CMinLP::MinLPOptimize(state);
  }
//+------------------------------------------------------------------+
//| LP solver results                                                |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm State                                    |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], solution (on failure: last trial point)  |
//|   Rep      -  optimization report. You should check              |
//|               Rep.TerminationType, which contains completion     |
//|               code, and you may check another fields which       |
//|               contain another information about algorithm        |
//|               functioning.                                       |
//| Failure codes returned by algorithm are:                         |
//|   * -4    LP problem is primal unbounded(dual infeasible)        |
//|   * -3    LP problem is primal infeasible(dual unbounded)        |
//|   * -2    IPM solver detected that problem is either infeasible  |
//|            or unbounded                                          |
//| Success codes:                                                   |
//|   *  1..4 successful completion                                  |
//|   *  5    MaxIts steps was taken                                 |
//+------------------------------------------------------------------+
void CAlglib::MinLPResults(CMinLPState &state,CRowDouble &x,
                           CMinLPReport &rep)
  {
   CMinLP::MinLPResults(state,x,rep);
  }
//+------------------------------------------------------------------+
//| LP results                                                       |
//| Buffered implementation of MinLPResults() which uses             |
//| pre-allocated buffer to store X[]. If buffer size is too small,  |
//| it resizes buffer. It is intended to be used in the inner cycles |
//| of performance critical algorithms where array reallocation      |
//| penalty is too large to be ignored.                              |
//+------------------------------------------------------------------+
void CAlglib::MinLPResultsBuf(CMinLPState &state,CRowDouble &x,
                              CMinLPReport &rep)
  {
   CMinLP::MinLPResultsBuf(state,x,rep);
  }
//+------------------------------------------------------------------+
//| NONLINEARLY  CONSTRAINED  OPTIMIZATION WITH PRECONDITIONED       |
//| AUGMENTED LAGRANGIAN ALGORITHM                                   |
//| DESCRIPTION:                                                     |
//| The subroutine minimizes function F(x) of N arguments subject to |
//| any combination of:                                              |
//|   * bound constraints                                            |
//|   * linear inequality constraints                                |
//|   * linear equality constraints                                  |
//|   * nonlinear equality constraints Gi(x) = 0                     |
//|   * nonlinear inequality constraints Hi(x) <= 0                  |
//| REQUIREMENTS:                                                    |
//|   *  user must provide function value and gradient for F(), H(), |
//|      G()                                                         |
//|   *  starting point X0 must be feasible or not too far away from |
//|      the feasible set                                            |
//|   *  F(), G(), H() are continuously differentiable on the        |
//|      feasible set and its neighborhood                           |
//|   *  nonlinear constraints G() and H() must have non-zero        |
//|      gradient at G(x) = 0 and at H(x) = 0. Say, constraint like  |
//|      x^2 >= 1 is supported, but x^2 >= 0 is NOT supported.       |
//| USAGE:                                                           |
//| Constrained optimization if far more complex than the            |
//| unconstrained one. Nonlinearly constrained optimization is one   |
//| of the most esoteric numerical procedures.                       |
//| Here we give very brief outline of the MinNLC optimizer. We      |
//| strongly recommend you to study examples in the ALGLIB Reference |
//| Manual and to read ALGLIB User Guide on optimization, which is   |
//| available at http://www.alglib.net/optimization/                 |
//|   1. User initializes algorithm State with MinNLCCreate() call   |
//|      and chooses what NLC solver to use. There is some solver    |
//|      which is used by default, with default Settings, but you    |
//|      should NOT rely on default choice. It may change in future  |
//|      releases of ALGLIB without notice, and no one can guarantee |
//|      that new solver will be able to solve your problem with     |
//|      default Settings.                                           |
//| From the other side, if you choose solver explicitly, you can be |
//| pretty sure that it will work with new ALGLIB releases.          |
//| In the current release following solvers can be used:            |
//|   *  SQP solver, recommended for medium-scale problems (less than|
//|      thousand of variables) with hard-to-evaluate target         |
//|      functions. Requires less function evaluations than other    |
//|      solvers but each step involves solution of QP subproblem,   |
//|      so running time may be higher than that of AUL (another     |
//|      recommended option). Activated with MinNLCSetAlgoSQP()      |
//|      function.                                                   |
//|   *  AUL solver with dense preconditioner, recommended for       |
//|      large-scale problems or for problems  with  cheap  target   |
//|      function.  Needs  more function evaluations that SQP (about |
//|      5x - 10x  times  more),  but  its iterations  are  much     |
//|      cheaper that that of SQP. Activated with MinNLCSetAlgoAUL() |
//|      function.                                                   |
//|   *  SLP solver, successive linear programming. The slowest one, |
//|      requires more target function evaluations that SQP and AUL. |
//|      However,  it  is somewhat more robust in tricky cases, so   |
//|      it can be used  as  a backup plan. Activated with           |
//|      MinNLCSetAlgoSLP() function.                                |
//|   2. [optional] user activates OptGuard  integrity checker which |
//|      tries to detect possible errors in the user - supplied      |
//|      callbacks:                                                  |
//|   *  discontinuity/nonsmoothness of the target/nonlinear         |
//|      constraints                                                 |
//|   *  errors in the analytic gradient provided by user.           |
//| This feature is essential for early prototyping stages because it|
//| helps to catch common coding and problem statement errors.       |
//| OptGuard can be activated with following functions (one per each |
//| check performed):                                                |
//|   * MinNLCOptGuardSmoothness()                                   |
//|   * MinNLCOptGuardGradient()                                     |
//|   3. User adds boundary and/or linear and/or nonlinear           |
//|      constraints by means of calling one of the following        |
//|      functions:                                                  |
//|      a) MinNLCSetBC() for boundary constraints                   |
//|      b) MinNLCSetLC() for linear constraints                     |
//|      c) MinNLCSetNLC() for nonlinear constraints                 |
//| You may combine(a), (b) and (c) in one optimization problem.     |
//|   4. User sets scale of the variables with MinNLCSetScale()      |
//|      function. It  is VERY important to set  scale  of  the      |
//|      variables,  because  nonlinearly constrained problems are   |
//|      hard to solve when variables are badly scaled.              |
//|   5. User sets  stopping  conditions  with  MinNLCSetCond(). If  |
//|      NLC solver uses  inner/outer  iteration  layout,  this      |
//|      function   sets   stopping conditions for INNER iterations. |
//|   6. Finally, user calls MinNLCOptimize() function  which  takes |
//|      algorithm State and pointer (delegate, etc.) to callback    |
//|      function which calculates F / G / H.                        |
//|   7. User calls MinNLCResults() to get solution; additionally you|
//|      can retrieve OptGuard report with MinNLCOptGuardResults(),  |
//|      and get detailed report about purported errors in the target|
//|      function with:                                              |
//|      *  MinNLCOptGuardNonC1Test0Results()                        |
//|      *  MinNLCOptGuardNonC1Test1Results()                        |
//|   8. Optionally user may call MinNLCRestartFrom() to solve       |
//|      another  problem with same N but another starting point.    |
//|      MinNLCRestartFrom() allows to reuse already initialized     |
//|      structure.                                                  |
//| INPUT PARAMETERS:                                                |
//|   N           -  problem dimension, N > 0 :                      |
//|               * if given, only leading N elements of X are used  |
//|               * if not given, automatically determined from size |
//|                 of X                                             |
//|   X           -  starting point, array[N]:                       |
//|               * it is better to set X to a feasible point        |
//|               * but X can be infeasible, in which case algorithm |
//|                 will try to find feasible point first, using X as|
//|                 initial approximation.                           |
//| OUTPUT PARAMETERS:                                               |
//|   State       -  structure stores algorithm State                |
//+------------------------------------------------------------------+
void CAlglib::MinNLCCreate(int n,CRowDouble &x,CMinNLCState &state)
  {
   CMinNLC::MinNLCCreate(n,x,state);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinNLCCreate(CRowDouble &x,CMinNLCState &state)
  {
   int n=CAp::Len(x);
//--- function call
   CMinNLC::MinNLCCreate(n,x,state);
  }
//+------------------------------------------------------------------+
//| This subroutine is a finite difference variant of MinNLCCreate().|
//| It uses finite differences in order to differentiate target      |
//| function.                                                        |
//| Description below contains information which is specific to this |
//| function only. We recommend to read comments on MinNLCCreate()   |
//| in order to get more information about creation of NLC optimizer.|
//| INPUT PARAMETERS:                                                |
//|   N        -  problem dimension, N > 0:                          |
//|               * if given, only leading N elements of X are used  |
//|               * if not given, automatically determined from size |
//|                 of X                                             |
//|   X        -  starting point, array[N]:                          |
//|               * it is better to set X to a feasible point        |
//|               * but X can be infeasible, in which case algorithm |
//|                 will try to find feasible point first, using X as|
//|                 initial approximation.                           |
//|   DiffStep -  differentiation step, > 0                          |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure stores algorithm State                   |
//| NOTES:                                                           |
//|   1. algorithm uses 4-point central formula for differentiation. |
//|   2. differentiation step along I-th axis is equal to            |
//|      DiffStep*S[I] where S[] is scaling vector which can be set  |
//|      by MinNLCSetScale() call.                                   |
//|   3. we recommend you to use moderate values of  differentiation |
//|      step. Too large step will result in too large TRUNCATION    |
//|      errors, while too small step will result in too large       |
//|      NUMERICAL errors. 1.0E-4 can be good value to start from.   |
//|   4. Numerical differentiation is very inefficient - one gradient|
//|      calculation needs 4 * N function evaluations. This function |
//|      will work for any N - either small(1...10), moderate        |
//|      (10...100) or large(100...). However, performance penalty   |
//|      will be too severe for any N's except for small ones. We    |
//|      should also say that code which relies on numerical         |
//|      differentiation is less robust and precise. Imprecise       |
//|      gradient may slow down convergence, especially on highly    |
//|      nonlinear problems. Thus we recommend to use this function  |
//|      for fast prototyping on small-dimensional problems only,    |
//|      and to implement analytical gradient as soon as possible.   |
//+------------------------------------------------------------------+
void CAlglib::MinNLCCreateF(int n,CRowDouble &x,double diffstep,
                            CMinNLCState &state)
  {
   CMinNLC::MinNLCCreateF(n,x,diffstep,state);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinNLCCreateF(CRowDouble &x,double diffstep,CMinNLCState &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinNLC::MinNLCCreateF(n,x,diffstep,state);
  }
//+------------------------------------------------------------------+
//| This function sets boundary constraints for NLC optimizer.       |
//| Boundary constraints are inactive by  default (after  initial    |
//| creation). They are preserved after algorithm restart with       |
//| MinNLCRestartFrom().                                             |
//| You may combine boundary constraints with  general  linear ones -|
//| and with nonlinear ones! Boundary constraints are  handled  more |
//| efficiently than other types. Thus, if your  problem  has  mixed |
//| constraints, you may explicitly specify some of them as boundary |
//| and save some time / space.                                      |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure stores algorithm State                |
//|   BndL        -  lower bounds, array[N]. If some (all) variables |
//|                  are unbounded, you may specify very small number|
//|                  or -INF.                                        |
//|   BndU        -  upper bounds, array[N]. If some (all) variables |
//|                  are unbounded, you may specify very large number|
//|                  or +INF.                                        |
//| NOTE 1: it is possible to specify BndL.Set(i, BndU[i].  In  this |
//|         case  I-th variable will be "frozen" at                  |
//|         X.Set(i, BndL.Set(i, BndU[i].                            |
//| NOTE 2: when you solve your problem  with augmented Lagrangian   |
//|         solver, boundary constraints are satisfied only          |
//|         approximately! It is possible that algorithm will        |
//|         evaluate  function  outside  of feasible area!           |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetBC(CMinNLCState &state,CRowDouble &bndl,
                          CRowDouble &bndu)
  {
   CMinNLC::MinNLCSetBC(state,bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function sets linear constraints for MinNLC optimizer.      |
//| Linear constraints are inactive by default (after initial        |
//| creation).  They are preserved after algorithm restart with      |
//| MinNLCRestartFrom().                                             |
//| You may combine linear constraints with boundary ones - and with |
//| nonlinear ones! If your problem has mixed constraints, you  may  |
//| explicitly specify some of them as linear. It may help optimizer |
//| to   handle  them  more efficiently.                             |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinNLCCreate   |
//|               call.                                              |
//|   C        -  linear constraints, array[K, N + 1]. Each row of C |
//|               represents one constraint, either equality or      |
//|               inequality (see below):                            |
//|               * first N elements correspond to coefficients,     |
//|               * last element corresponds to the right part.      |
//|               All elements of C (including right part) must be   |
//|               finite.                                            |
//|   CT       -  type of constraints, array[K]:                     |
//|               * if CT[i] > 0, then I-th constraint is            |
//|                           C[i, *] * x >= C[i, n + 1]             |
//|               * if CT[i] = 0, then I-th constraint is            |
//|                           C[i, *] * x  = C[i, n + 1]             |
//|               * if CT[i] < 0, then I-th constraint is            |
//|                           C[i, *] * x <= C[i, n + 1]             |
//|   K        -  number of equality/inequality constraints, K >= 0: |
//|               * if given, only leading K elements of C/CT are    |
//|                 used                                             |
//|               * if not given, automatically determined from sizes|
//|                 of C/CT                                          |
//| NOTE 1: when you solve your problem with augmented Lagrangian    |
//|         solver, linear constraints are  satisfied  only          |
//|         approximately! It is possible that algorithm will        |
//|         evaluate  function  outside  of feasible area!           |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetLC(CMinNLCState &state,CMatrixDouble &c,
                          CRowInt &ct,int k)
  {
   CMinNLC::MinNLCSetLC(state,c,ct,k);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetLC(CMinNLCState &state,CMatrixDouble &c,CRowInt &ct)
  {
//--- check
   if(!CAp::Assert(CAp::Rows(c)==CAp::Len(ct),
                   "Error while calling 'MinNLCSetLC': looks like one of arguments has wrong size"))
      return;
//--- initialization
   int k=CAp::Rows(c);
//--- function call
   CMinNLC::MinNLCSetLC(state,c,ct,k);
  }
//+------------------------------------------------------------------+
//| This function sets nonlinear constraints for MinNLC optimizer.   |
//| In fact, this function sets NUMBER of nonlinear  constraints.    |
//| Constraints itself (constraint functions) are passed to          |
//| MinNLCOptimize() method. This method requires user-defined vector|
//| function F[] and its Jacobian J[], where:                        |
//|   *  first component of F[] and first row of Jacobian J[]        |
//|      corresponds  to function being minimized                    |
//|   *  next NLEC components of F[] (and rows  of  J) correspond to |
//|      nonlinear equality constraints G_i(x) = 0                   |
//|   *  next NLIC components of F[] (and rows  of  J) correspond to |
//|      nonlinear inequality constraints H_i(x) <= 0                |
//| NOTE: you may combine nonlinear constraints with linear/boundary |
//|       ones. If your problem has mixed constraints, you  may      |
//|       explicitly specify some of them as linear ones. It may help|
//|       optimizer to handle them more efficiently.                 |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure previously allocated with MinNLCCreate|
//|                  call.                                           |
//|   NLEC        -  number of Non-Linear Equality Constraints(NLEC),|
//|                  >= 0                                            |
//|   NLIC        -  number of Non-Linear Inquality Constraints(NLIC)|
//|                  >= 0                                            |
//| NOTE 1: when you solve your problem with augmented Lagrangian    |
//|         solver, nonlinear constraints are satisfied only         |
//|         approximately! It is possible   that  algorithm  will    |
//|         evaluate  function  outside   of feasible area!          |
//| NOTE 2: algorithm scales variables according to scale specified  |
//|         by MinNLCSetScale() function, so it can handle problems  |
//|         with badly scaled variables (as long as we KNOW their    |
//|         scales).                                                 |
//| However, there is no way to automatically scale nonlinear        |
//| constraints Gi(x) and Hi(x). Inappropriate scaling of Gi/Hi may  |
//| ruin convergence. Solving problem with constraint "1000*G0(x)=0" |
//| is NOT same as solving it with constraint "0.001*G0(x)=0".       |
//| It means that YOU  are  the  one who is responsible for correct  |
//| scaling of nonlinear constraints Gi(x) and Hi(x). We recommend   |
//| you to scale nonlinear constraints in such way that I-th         |
//| component of dG/dX (or dH/dx) has approximately unit  magnitude  |
//| (for problems with unit scale) or has  magnitude approximately   |
//| equal to 1/S[i] (where S is a scale set by MinNLCSetScale()      |
//| function).                                                       |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetNLC(CMinNLCState &state,int nlec,int nlic)
  {
   CMinNLC::MinNLCSetNLC(state,nlec,nlic);
  }
//+------------------------------------------------------------------+
//| This function sets stopping conditions for inner iterations of   |
//| optimizer.                                                       |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//|   EpsX     -  >= 0, The subroutine finishes its work if on k+1-th|
//|               iteration the condition |v| <= EpsX is fulfilled,  |
//|               where:                                             |
//|               * | . | means Euclidian norm                       |
//|               * v - scaled step vector, v[i] = dx[i] / s[i]      |
//|               * dx - step vector, dx = X(k + 1) - X(k)           |
//|               * s - scaling coefficients set by MinNLCSetScale() |
//|   MaxIts   -  maximum number of iterations. If MaxIts = 0, the   |
//|               number of iterations is unlimited.                 |
//| Passing EpsX = 0 and MaxIts = 0(simultaneously) will lead to     |
//| automatic selection of the stopping condition.                   |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetCond(CMinNLCState &state,double epsx,int maxits)
  {
   CMinNLC::MinNLCSetCond(state,epsx,maxits);
  }
//+------------------------------------------------------------------+
//| This function sets scaling coefficients for NLC optimizer.       |
//| ALGLIB optimizers use scaling matrices to test stopping          |
//| conditions (step size and gradient are scaled before comparison  |
//| with tolerances). Scale of the I-th variable is a translation    |
//| invariant measure of:                                            |
//|   a) "how large" the variable is                                 |
//|   b) how large the step should be to make significant changes in |
//|      the function                                                |
//| Scaling is also used by finite difference variant of the         |
//| optimizer - step along I-th axis is equal to DiffStep*S[I].      |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//|   S        -  array[N], non-zero scaling coefficients S[i] may   |
//|               be negative, sign doesn't matter.                  |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetScale(CMinNLCState &state,CRowDouble &s)
  {
   CMinNLC::MinNLCSetScale(state,s);
  }
//+------------------------------------------------------------------+
//| This function sets preconditioner to "inexact LBFGS-based" mode. |
//| Preconditioning is very important for convergence of  Augmented  |
//| Lagrangian algorithm because presence of penalty term makes      |
//| problem ill-conditioned. Difference between performance  of      |
//| preconditioned and unpreconditioned methods can be as large      |
//| as 100x!                                                         |
//| MinNLC optimizer may use following preconditioners, each with its|
//| own benefits and drawbacks:                                      |
//|   a) inexact LBFGS-based, with O(N * K) evaluation time          |
//|   b) exact low rank one,  with O(N * K ^ 2) evaluation time      |
//|   c) exact robust one,    with O(N ^ 3 + K * N ^ 2) evaluation   |
//|      time where K is a total number of general linear and        |
//|      nonlinear constraints (box ones are not counted).           |
//| Inexact LBFGS-based preconditioner uses L-BFGS formula combined  |
//| with orthogonality assumption to perform very fast updates. For a|
//| N-dimensional problem with K general linear or nonlinear         |
//| constraints (boundary ones  are not counted) it has O(N * K) cost|
//| per iteration.  This   preconditioner  has best  quality (less   |
//| iterations)  when   general   linear  and  nonlinear constraints |
//| are orthogonal to each other (orthogonality  with  respect  to   |
//| boundary constraints is not required). Number of iterations      |
//| increases when constraints  are  non - orthogonal, because       |
//| algorithm assumes orthogonality, but still it is better than no  |
//| preconditioner at all.                                           |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetPrecInexact(CMinNLCState &state)
  {
   CMinNLC::MinNLCSetPrecInexact(state);
  }
//+------------------------------------------------------------------+
//| This function sets preconditioner to "exact low rank" mode.      |
//| Preconditioning is very important for convergence of  Augmented  |
//| Lagrangian algorithm because presence of penalty term makes      |
//| problem ill-conditioned. Difference between performance of       |
//| preconditioned and unpreconditioned methods can be as large      |
//| as 100x!                                                         |
//| MinNLC optimizer may use following preconditioners, each with its|
//| own benefits and drawbacks:                                      |
//|   a) inexact LBFGS-based, with O(N * K) evaluation time          |
//|   b) exact low rank one,  with O(N * K ^ 2) evaluation time      |
//|   c) exact robust one,    with O(N ^ 3 + K * N ^ 2) evaluation   |
//|      time where K is a total number of general linear and        |
//|      nonlinear constraints (box ones are not counted).           |
//| It also provides special unpreconditioned mode of operation which|
//| can be used for test purposes. Comments below discuss low rank   |
//| preconditioner.                                                  |
//| Exact low-rank preconditioner uses Woodbury matrix  identity  to |
//| build quadratic model of the penalized function. It has following|
//| features:                                                        |
//|   * no special assumptions about orthogonality of constraints    |
//|   * preconditioner evaluation is optimized for K << N. Its cost  |
//|     is O(N * K ^ 2), so it may become prohibitively slow for     |
//|     K >= N.                                                      |
//|   * finally, stability of the process is guaranteed only for     |
//|     K << N. Woodbury update often fail for K >= N due to         |
//|     degeneracy of  intermediate  matrices.                       |
//| That's why we recommend to use "exact robust" preconditioner for |
//| such cases.                                                      |
//| RECOMMENDATIONS:                                                 |
//| We recommend to choose between "exact low rank" and "exact       |
//| robust" preconditioners, with "low rank" version being chosen    |
//| when you know in advance that total count of non-box constraints |
//| won't exceed N, and "robust" version being chosen when you need  |
//| bulletproof solution.                                            |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure stores algorithm State                |
//|   UpdateFreq  -  update frequency. Preconditioner is  rebuilt    |
//|                  after  every UpdateFreq iterations. Recommended |
//|                  value : 10 or higher. Zero value means that good|
//|                  default value will be used.                     |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetPrecExactLowRank(CMinNLCState &state,int updatefreq)
  {
   CMinNLC::MinNLCSetPrecExactLowRank(state,updatefreq);
  }
//+------------------------------------------------------------------+
//| This function sets preconditioner to "exact robust" mode.        |
//| Preconditioning is very important for convergence of  Augmented  |
//| Lagrangian algorithm because presence of penalty term makes      |
//| problem ill-conditioned. Difference between performance  of      |
//| preconditioned  and  unpreconditioned methods can be as large    |
//| as 100x!                                                         |
//| MinNLC optimizer may use following preconditioners, each with its|
//| own benefits and drawbacks:                                      |
//|   a) inexact LBFGS-based, with O(N * K) evaluation time          |
//|   b) exact low rank one,  with O(N * K ^ 2) evaluation time      |
//|   c) exact robust one,    with O(N ^ 3 + K * N ^ 2) evaluation   |
//|      time where K is a total number of general linear and        |
//|      nonlinear constraints (box ones are not counted).           |
//| It also provides special unpreconditioned mode of operation which|
//| can be used for test purposes. Comments below discuss robust     |
//| preconditioner.                                                  |
//| Exact robust preconditioner uses Cholesky decomposition to invert|
//| approximate Hessian matrix H = D + W'*C*W (where D stands for    |
//| diagonal terms of Hessian, combined result of initial scaling    |
//| matrix and penalty from box constraints; W stands for general    |
//| linear constraints and linearization of nonlinear ones; C stands |
//| for diagonal matrix of penalty coefficients).                    |
//| This preconditioner has following features:                      |
//|   * no special assumptions about constraint structure            |
//|  *preconditioner is optimized  for  stability; unlike  "exact  |
//|     low rank" version which fails for K >= N, this one works well|
//|     for any value of K.                                          |
//|   * the only drawback is that is takes O(N ^ 3 + K * N ^ 2) time |
//|     to build it. No economical Woodbury update is applied even   |
//|     when it makes sense, thus there are exist situations (K << N)|
//|     when "exact low rank" preconditioner outperforms this one.   |
//| RECOMMENDATIONS:                                                 |
//| We recommend to choose between "exact low rank" and "exact       |
//| robust" preconditioners, with "low rank" version being chosen    |
//| when you know in advance that total count of non-box constraints |
//| won't exceed N, and "robust" version being chosen when you need  |
//| bulletproof solution.                                            |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure stores algorithm State                |
//|   UpdateFreq  -  update frequency. Preconditioner is  rebuilt    |
//|                  after every UpdateFreq iterations. Recommended  |
//|                  value: 10 or higher. Zero value means that good |
//|                  default value will be used.                     |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetPrecExactRobust(CMinNLCState &state,int updatefreq)
  {
   CMinNLC::MinNLCSetPrecExactRobust(state,updatefreq);
  }
//+------------------------------------------------------------------+
//| This function sets preconditioner to "turned off" mode.          |
//| Preconditioning is very important for convergence of  Augmented  |
//| Lagrangian algorithm because presence of penalty term makes      |
//| problem  ill-conditioned. Difference between performance of      |
//| preconditioned  and  unpreconditioned methods can be as large    |
//| as 100x!                                                         |
//| MinNLC optimizer may utilize two preconditioners, each with its  |
//| own benefits and drawbacks:                                      |
//|   a) inexact LBFGS-based, and b) exact low rank one.             |
//| It also provides special unpreconditioned mode of operation which|
//| can be used for test purposes.                                   |
//| This function activates this test mode. Do not use it in         |
//| production code to solve real-life problems.                     |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetPrecNone(CMinNLCState &state)
  {
   CMinNLC::MinNLCSetPrecNone(state);
  }
//+------------------------------------------------------------------+
//| This function sets maximum step length (after scaling of step    |
//| vector with respect to variable scales specified by              |
//| MinNLCSetScale() call).                                          |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure which stores algorithm State          |
//|   StpMax      -  maximum step length, >= 0. Set StpMax to 0.0    |
//|                  (default), if you don't want to limit step      |
//|                  length.                                         |
//| Use this subroutine when you optimize target function which      |
//| contains exp() or other fast growing functions, and optimization |
//| algorithm makes too large steps which leads to overflow. This    |
//| function allows us to reject steps that are too large (and       |
//| therefore expose us to the possible overflow) without actually   |
//| calculating function value at the x + stp*d.                     |
//| NOTE: different solvers employed by MinNLC optimizer use         |
//|       different norms for step; AUL solver uses 2-norm, whilst   |
//|       SLP solver uses INF-norm.                                  |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetSTPMax(CMinNLCState &state,double stpmax)
  {
   CMinNLC::MinNLCSetSTPMax(state,stpmax);
  }
//+------------------------------------------------------------------+
//| This function tells MinNLC unit to use Augmented Lagrangian      |
//| algorithm for nonlinearly constrained  optimization.  This       |
//| algorithm is a slight modification of one described in           |
//| "A Modified Barrier-Augmented Lagrangian Method for Constrained  |
//| Minimization(1999)" by D.GOLDFARB, R.POLYAK, K. SCHEINBERG,      |
//| I.YUZEFOVICH.                                                    |
//| AUL solver can be significantly faster than SQP on easy problems |
//| due to cheaper iterations, although it needs more function       |
//| evaluations.                                                     |
//| Augmented Lagrangian algorithm works by converting problem of    |
//| minimizing F(x) subject to equality/inequality constraints  to   |
//| unconstrained problem of the form                                |
//|   min[ f(x) +                                                    |
//|             + Rho * PENALTY_EQ(x)   + SHIFT_EQ(x, Nu1) +         |
//|             + Rho * PENALTY_INEQ(x) + SHIFT_INEQ(x, Nu2) ]       |
//|   where:                                                         |
//|   * Rho is a fixed penalization coefficient                      |
//|   * PENALTY_EQ(x) is a penalty term, which is used to            |
//|     APPROXIMATELY  enforce equality constraints                  |
//|  *SHIFT_EQ(x) is a special "shift"  term  which  is  used  to  |
//|     "fine-tune" equality constraints, greatly increasing         |
//|     precision                                                    |
//|   * PENALTY_INEQ(x) is a penalty term which is used to           |
//|     approximately enforce inequality constraints                 |
//|  *SHIFT_INEQ(x) is a special "shift"  term  which  is  used to |
//|     "fine-tune" inequality constraints, greatly increasing       |
//|     precision                                                    |
//|   * Nu1/Nu2 are vectors of Lagrange coefficients which are fine- |
//|     tuned during outer iterations of algorithm                   |
//| This  version  of  AUL  algorithm  uses   preconditioner,  which |
//| greatly accelerates convergence. Because this  algorithm  is     |
//| similar to penalty methods, it may perform steps into infeasible |
//| area. All kinds of constraints (boundary, linear and nonlinear   |
//| ones) may be violated in intermediate points - and in the        |
//| solution. However, properly configured AUL method is             |
//| significantly better at handling constraints than barrier and/or |
//| penalty methods.                                                 |
//| The very basic outline of algorithm is given below:              |
//|   1) first outer iteration is performed with "default" values of |
//|      Lagrange multipliers Nu1/Nu2. Solution quality is low       |
//|      (candidate point can be too far away from true solution;    |
//|      large violation of constraints is possible) and is          |
//|      comparable with that of penalty methods.                    |
//|   2) subsequent outer iterations refine Lagrange multipliers and |
//|      improve quality of the solution.                            |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//|   Rho      -  penalty coefficient, Rho > 0:                      |
//|               * large enough  that  algorithm  converges  with   |
//|                 desired precision. Minimum value is              |
//|                 10 * max(S'*diag(H)*S), where S is a scale matrix|
//|                 (set by MinNLCSetScale) and H is a Hessian of the|
//|                 function being minimized. If you can not easily  |
//|                 estimate Hessian norm, see our recommendations   |
//|                 below.                                           |
//|               * not TOO large to prevent ill - conditioning      |
//|               * for unit - scale problems(variables and Hessian  |
//|                 have unit magnitude), Rho = 100 or Rho = 1000 can|
//|                 be used.                                         |
//|               * it is important to note that Rho is internally   |
//|                 multiplied by scaling matrix, i.e. optimum value |
//|                 of Rho depends on scale of variables specified   |
//|                 by  MinNLCSetScale().                            |
//|   ItsCnt   -  number of outer iterations:                        |
//|               * ItsCnt = 0 means that small number of outer      |
//|                 iterations is automatically chosen (10 iterations|
//|                 in current version).                             |
//|               * ItsCnt = 1 means that AUL algorithm performs just|
//|                 as usual barrier method.                         |
//|               * ItsCnt > 1 means that  AUL  algorithm  performs  |
//|                 specified number of outer iterations             |
//| HOW TO CHOOSE PARAMETERS                                         |
//| Nonlinear optimization is a tricky area and Augmented Lagrangian |
//| algorithm is sometimes hard to tune. Good values of Rho and      |
//| ItsCnt are problem - specific. In order to help you we prepared  |
//| following set of recommendations:                                |
//|   * for  unit-scale problems (variables and Hessian have unit    |
//|     magnitude), Rho = 100 or Rho = 1000 can be used.             |
//|   * start from some small value of Rho and solve problem with    |
//|     just one outer iteration (ItcCnt = 1). In this case algorithm|
//|     behaves like penalty method. Increase Rho in 2x or 10x steps |
//|     until you see that one outer iteration returns point which is|
//|     "rough approximation to solution".                           |
//| It is very important to have Rho so large that penalty term      |
//| becomes constraining i.e. modified function becomes highly convex|
//| in constrained directions.                                       |
//| From the other side, too large Rho may prevent you from          |
//| converging to the solution. You can diagnose it by studying      |
//| number of inner iterations performed by algorithm: too few (5-10 |
//| on 1000-dimensional problem) or too many (orders of magnitude    |
//| more than dimensionality) usually means that Rho is too large.   |
//|   * with just one outer iteration you usually have low-quality   |
//|     solution. Some constraints can be violated with very large   |
//|     margin, while other ones (which are NOT violated in the true |
//|     solution) can push final  point too far in the inner area of |
//|     the feasible set.                                            |
//| For example, if you have constraint x0 >= 0 and true solution    |
//| x0=1, then merely a presence of "x0>=0" will introduce a bias  |
//| towards larger values of x0. Say, algorithm may stop at x0 = 1.5 |
//| instead of 1.0.                                                  |
//|   * after you found good Rho, you may increase number of outer   |
//|     iterations. ItsCnt = 10 is a good value. Subsequent outer    |
//|     iteration will refine values of  Lagrange  multipliers.      |
//|     Constraints which were violated will be enforced, inactive   |
//|     constraints will be dropped(corresponding multipliers will be|
//|     decreased). Ideally, you should see 10-1000x improvement in  |
//|     constraint handling(constraint violation is reduced).        |
//|   * if you see that algorithm converges to vicinity of solution, |
//|     but additional outer iterations do not refine solution, it   |
//|     may mean that algorithm is unstable - it wanders around true |
//|     solution, but can not approach it. Sometimes algorithm may be|
//|     stabilized by increasing Rho one more time, making it 5x or  |
//|     10x larger.                                                  |
//| SCALING OF CONSTRAINTS [IMPORTANT]                               |
//| AUL optimizer scales variables according to scale specified  by  |
//| MinNLCSetScale() function, so it can handle problems with badly  |
//| scaled variables (as long as we KNOW their scales). However,     |
//| because function being optimized is a mix of original function   |
//| and constraint - dependent penalty functions, it is important to |
//| rescale both variables AND constraints.                          |
//| Say, if you minimize f(x) = x^2 subject to 1000000*x >= 0,  then |
//| you have constraint whose scale is different from that of target |
//| function (another example is 0.000001*x >= 0). It is also        |
//| possible to have constraints whose scales are misaligned:        |
//| 1000000*x0 >= 0, 0.000001*x1 <= 0. Inappropriate scaling may ruin|
//| convergence because minimizing x^2 subject to x >= 0 is NOT same |
//| as minimizing it subject to 1000000*x >= 0.                      |
//| Because we know coefficients of boundary/linear constraints, we  |
//| can automatically rescale and normalize them. However, there is  |
//| no way to automatically rescale nonlinear constraints Gi(x) and  |
//| Hi(x) - they are black boxes.                                    |
//| It means that YOU are the one who is responsible for correct     |
//| scaling of nonlinear constraints Gi(x) and Hi(x). We recommend   |
//| you to rescale nonlinear constraints in such way that I-th       |
//| component of dG/dX (or dH/dx) has magnitude approximately equal  |
//| to 1/S[i] (where S is a scale set by MinNLCSetScale() function). |
//| WHAT IF IT DOES NOT CONVERGE?                                    |
//| It is possible that AUL algorithm fails to converge to precise   |
//| values of Lagrange multipliers. It stops somewhere around true   |
//| solution, but candidate point is still too far from solution,    |
//| and some constraints are violated. Such kind of failure is       |
//| specific for Lagrangian algorithms - technically, they stop at   |
//| some point, but this point is not constrained solution.          |
//| There are exist several reasons why algorithm may fail to        |
//| converge:                                                        |
//|   a) too loose stopping criteria for inner iteration             |
//|   b) degenerate, redundant constraints                           |
//|   c) target function has unconstrained extremum exactly at the   |
//|      boundary of some constraint                                 |
//|   d) numerical noise in the target function                      |
//| In all these cases algorithm is unstable - each outer iteration  |
//| results in large and almost random step which improves handling  |
//| of some constraints, but violates other ones (ideally outer      |
//| iterations should form a sequence of progressively decreasing    |
//| steps towards solution).                                         |
//| First reason possible is that too loose stopping criteria for    |
//| inner iteration were specified. Augmented Lagrangian algorithm   |
//| solves a sequence of intermediate problems, and requries each of |
//| them to be solved with high precision. Insufficient precision    |
//| results in incorrect update of  Lagrange multipliers.            |
//| Another reason is that you may have specified degenerate         |
//| constraints: say, some constraint was repeated twice. In most    |
//| cases AUL algorithm gracefully handles such situations, but      |
//| sometimes it may spend too much time figuring out subtle         |
//| degeneracies in constraint matrix.                               |
//| Third reason is tricky and hard to diagnose. Consider situation  |
//| when you minimize  f = x^2  subject to constraint x >= 0.        |
//| Unconstrained extremum is located exactly at the boundary of     |
//| constrained area. In this case algorithm will tend to oscillate  |
//| between negative and positive x. Each time it stops at x<0 it    |
//| "reinforces" constraint x >= 0, and each time it  is bounced to  |
//| x>0 it "relaxes" constraint( and is  attracted  to  x < 0).    |
//| Such situation sometimes happens in problems with hidden         |
//| symetries. Algorithm is got caught in a loop with Lagrange       |
//| multipliers  being continuously increased / decreased. Luckily,  |
//| such loop forms after at  least three iterations, so this problem|
//| can be solved by  DECREASING  number  of outer iterations down   |
//| to 1-2 and increasing penalty coefficient Rho as much as possible|
//| Final reason is numerical noise. AUL algorithm is robust against |
//| moderate noise (more robust than, say, active set methods),  but |
//| large  noise  may destabilize algorithm.                         |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetAlgoAUL(CMinNLCState &state,double rho,int itscnt)
  {
   CMinNLC::MinNLCSetAlgoAUL(state,rho,itscnt);
  }
//+------------------------------------------------------------------+
//| This  function tells MinNLC optimizer to use SLP (Successive     |
//| Linear Programming) algorithm for nonlinearly constrained        |
//| optimization. This algorithm is a slight modification of one     |
//| described in "A Linear programming - based optimization algorithm|
//| for solving nonlinear programming problems" (2010) by Claus Still|
//| and Tapio Westerlund.                                            |
//| This solver is the slowest one in ALGLIB, it requires more target|
//| function evaluations that SQP and AUL. However it is somewhat    |
//| more robust in tricky cases, so it can be used as a backup plan. |
//| We recommend to use this algo when SQP/AUL do not work (does not |
//| return the solution you expect). If trying different approach    |
//| gives same results, then MAYBE something is wrong with your      |
//| optimization problem.                                            |
//| Despite its name ("linear" = "first order method") this algorithm|
//| performs steps similar to that of conjugate gradients method;    |
//| internally it uses orthogonality/conjugacy requirement for       |
//| subsequent steps which makes it closer to second order methods in|
//| terms of convergence speed.                                      |
//| Convergence is proved for the following case:                    |
//|   *  function and constraints are continuously differentiable (C1|
//|      class)                                                      |
//|   *  extended Mangasarian-Fromovitz constraint qualification     |
//|      (EMFCQ) holds; in the context of this algorithm EMFCQ means |
//|      that one can, for any infeasible point, find a search       |
//|      direction such that the constraint infeasibilities are      |
//|      reduced.                                                    |
//| This algorithm has following nice properties:                    |
//|   *  no parameters to tune                                       |
//|   *  no convexity requirements for target function or constraints|
//|   *  initial point can be infeasible                             |
//|   *  algorithm respects box constraints in all intermediate      |
//|      points (it does not even evaluate function outside of box   |
//|      constrained area)                                           |
//|   *  once linear constraints are enforced, algorithm will not    |
//|      violate them                                                |
//|   *  no such guarantees can be provided for nonlinear            |
//|      constraints, but once nonlinear constraints are enforced,   |
//|      algorithm will try to respect them as much as possible      |
//|   *  numerical differentiation does not violate box constraints  |
//|      (although general linear and nonlinear ones can be violated |
//|      during differentiation)                                     |
//|   *  from our experience, this algorithm is somewhat more robust |
//|      in really difficult cases                                   |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//| ===== TRACING SLP SOLVER ======================================= |
//| SLP solver supports advanced tracing capabilities. You can trace |
//| algorithm output by specifying following trace symbols  (case-   |
//| insensitive) by means of trace_file() call:                      |
//|   * 'SLP'  -  for basic trace of algorithm steps and decisions.  |
//|               Only short scalars(function values and deltas) are |
//|               printed.                                           |
//|               N-dimensional quantities like search directions are|
//|               NOT printed.                                       |
//|               It also prints OptGuard integrity checker report   |
//|               when nonsmoothness of target / constraints is      |
//|               suspected.                                         |
//|   * 'SLP.DETAILED' - for output of points being visited and      |
//|               search directions.                                 |
//|               This symbol also implicitly defines 'SLP'. You can |
//|               control output format by additionally specifying:  |
//|               * nothing to output in 6-digit exponential format  |
//|               * 'PREC.E15' to output in 15-digit exponential     |
//|                  format                                          |
//|               * 'PREC.F6' to output in 6-digit fixed-point format|
//|   * 'SLP.PROBING' - to let algorithm insert additional function  |
//|               evaluations before line search in order to build   |
//|               human-readable chart of the raw Lagrangian         |
//|               (~40 additional function evaluations is performed  |
//|               for each line search). This symbol also implicitly |
//|               defines 'SLP'. Definition of this symbol also      |
//|               automatically activates OptGuard smoothness monitor|
//|   * 'OPTGUARD'  - for report of smoothness/continuity violations |
//|               in target and/or constraints. This kind of         |
//|               reporting is included in 'SLP', but it comes with  |
//|               lots of additional Info. If you need just          |
//|               smoothness monitoring, specify this setting.       |
//| NOTE: this tag merely directs OptGuard output to log file. Even  |
//|       if you specify it, you still have to configure OptGuard by |
//|       calling MinNLCOptGuard...() family of functions.           |
//| By default trace is disabled and adds no overhead to the         |
//| optimization process. However, specifying any of the symbols adds|
//| some formatting and output - related overhead. Specifying        |
//| 'SLP.PROBING' adds  even larger overhead due to additional       |
//| function evaluations being performed.                            |
//| You may specify multiple symbols by separating them with commas: |
//|   >                                                              |
//|  >CAlglib::Trace_File("SLP,SLP.PROBING,PREC.F6",               |
//|                        "path/to/trace.log")                      |
//|   >                                                              |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetAlgoSLP(CMinNLCState &state)
  {
   CMinNLC::MinNLCSetAlgoSLP(state);
  }
//+------------------------------------------------------------------+
//| This  function tells MinNLC optimizer to use SQP (Successive     |
//| Quadratic Programming) algorithm for nonlinearly constrained     |
//| optimization.                                                    |
//| This algorithm needs order of magnitude (5x-10x) less function   |
//| evaluations than AUL solver, but has higher overhead because each|
//| iteration involves solution of quadratic programming problem.    |
//| Convergence is proved for the following case:                    |
//|   *  function and constraints are continuously differentiable    |
//|      (C1 class)                                                  |
//| This algorithm has following nice properties:                    |
//|   *  no parameters to tune                                       |
//|   *  no convexity requirements for target function or constraints|
//|   *  initial point can be infeasible                             |
//|   *  algorithm respects box constraints in all intermediate      |
//|      points (it does not even evaluate function outside of box   |
//|      constrained area)                                           |
//|   *  once linear constraints are enforced, algorithm will not    |
//|      violate them                                                |
//|   *  no such guarantees can be provided for nonlinear            |
//|      constraints, but once nonlinear constraints are enforced,   |
//|      algorithm will try to respect them as much as possible      |
//|   *  numerical differentiation does not violate box constraints  |
//|      (although general linear and nonlinear ones can be violated |
//|      during differentiation)                                     |
//| We recommend this algorithm as a default option for medium scale |
//| problems (less than thousand of variables) or problems with      |
//| target function being hard to evaluate.                          |
//| For  large-scale problems or ones with very cheap target function|
//| AUL solver can be better option.                                 |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//| ===== INTERACTION WITH OPTGUARD ================================ |
//| OptGuard integrity checker allows us to catch problems like      |
//| errors in gradients  and discontinuity/nonsmoothness of the      |
//| target/constraints. The latter kind of problems can be detected  |
//| by looking upon line searches performed during optimization and  |
//| searching for signs of nonsmoothness.                            |
//| The problem with SQP is that it is too good for OptGuard to work-|
//| it does not perform line searches. It typically needs 1-2        |
//| function evaluations per step, and it is not enough for OptGuard |
//| to detect nonsmoothness.                                         |
//| So, if you suspect that your problem is nonsmooth and if you want|
//| to confirm or deny it, we recommend you to either:               |
//|   *  use AUL or SLP solvers, which can detect nonsmoothness of   |
//|      the problem                                                 |
//|   *  or, alternatively, activate 'SQP.PROBING' trace tag that    |
//|      will insert additional function evaluations (~40 per line   |
//|      step) that will help OptGuard integrity checker to study    |
//|      properties of your problem                                  |
//| ===== TRACING SQP SOLVER ======================================= |
//| SQP solver supports advanced tracing capabilities. You can trace |
//| algorithm output by specifying following trace symbols (case-    |
//| insensitive) by means of trace_file() call:                      |
//|   * 'SQP'     -  for basic trace of algorithm steps and          |
//|                  decisions. Only short scalars (function values  |
//|                  and deltas) are printed.                        |
//|                  N-dimensional quantities like search directions |
//|                  are NOT printed.                                |
//|                  It also prints OptGuard integrity checker report|
//|                  when nonsmoothness of target/constraints is     |
//|                  suspected.                                      |
//|   * 'SQP.DETAILED' - for output of points being visited and      |
//|                  search directions. This symbol also implicitly  |
//|                  defines 'SQP'. You can control output format by |
//|                  additionally specifying:                        |
//|                  *  nothing to output in 6-digit exponential     |
//|                     format                                       |
//|                  * 'PREC.E15' to output in 15-digit exponential  |
//|                     format                                       |
//|                  * 'PREC.F6'  to output in 6-digit fixed-point   |
//|                     format                                       |
//|   * 'SQP.PROBING' - to let algorithm insert additional function  |
//|                  evaluations before line search in order to build|
//|                  human-readable chart of the raw Lagrangian (~40 |
//|                  additional function evaluations is performed for|
//|                  each line search). This symbol also implicitly  |
//|                  defines 'SQP' and activates OptGuard integrity  |
//|                  checker which detects continuity and smoothness |
//|                  violations. An OptGuard log is printed at the   |
//|                  end of the file.                                |
//| By default trace is disabled and adds no overhead to the         |
//| optimization process. However, specifying any of the symbols adds|
//| some formatting and output-related overhead. Specifying          |
//| 'SQP.PROBING' adds even larger overhead due to additional        |
//| function evaluations being performed.                            |
//| You may specify multiple symbols by separating them with commas: |
//|   >                                                              |
//|  >CAlglib::Trace_File("SQP, SQP.PROBING, PREC.F6",             |
//|                                 "path/to/trace.log")             |
//|   >                                                              |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetAlgoSQP(CMinNLCState &state)
  {
   CMinNLC::MinNLCSetAlgoSQP(state);
  }
//+------------------------------------------------------------------+
//| This function turns on / off reporting.                          |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm State             |
//|   NeedXRep -  whether iteration reports are needed or not        |
//| If NeedXRep is True, algorithm will call rep() callback function |
//| if it is provided to MinNLCOptimize().                           |
//| NOTE:   algorithm passes two parameters to rep() callback  -     |
//|         current point and penalized function value at current    |
//|         point. Important - function value which is returned is   |
//|         NOT function being minimized. It is sum of the value of  |
//|         the function being minimized - and penalty term.         |
//+------------------------------------------------------------------+
void CAlglib::MinNLCSetXRep(CMinNLCState &state,bool needxrep)
  {
   CMinNLC::MinNLCSetXRep(state,needxrep);
  }
//+------------------------------------------------------------------+
//| NOTES:                                                           |
//|   1. This function has two different implementations: one which  |
//|      uses exact (analytical) user-supplied Jacobian, and one     |
//|      which uses only function vector and numerically             |
//|      differentiates  function  in  order  to  obtain gradient.   |
//| Depending  on  the  specific  function  used to create optimizer |
//| object you should choose appropriate variant of MinNLCOptimize()-|
//| one which accepts function AND Jacobian or one which accepts ONLY|
//| function.                                                        |
//| Be careful to choose variant of MinNLCOptimize() which           |
//| corresponds to your optimization scheme! Table below lists       |
//| different combinations of callback (function/gradient) passed to |
//| MinNLCOptimize() and specific function used to create optimizer. |
//|   |         USER PASSED TO MinNLCOptimize()                      |
//|   CREATED WITH      |  function only   |  function and gradient  |
//|   ------------------------------------------------------------   |
//|   MinNLCCreateF()   |     works               FAILS              |
//|   MinNLCCreate()    |     FAILS               works              |
//| Here "FAILS" denotes inappropriate combinations  of  optimizer   |
//| creation function  and MinNLCOptimize() version. Attemps to use  |
//| such combination will lead to exception. Either you did not pass |
//| gradient when it WAS needed or you passed gradient when it was   |
//| NOT needed.                                                      |
//+------------------------------------------------------------------+
bool CAlglib::MinNLCIteration(CMinNLCState &state)
  {
   return(CMinNLC::MinNLCIteration(state));
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|   fvec     -  callback which calculates function vector fi[] at  |
//|               given point x                                      |
//|   jac      -  callback which calculates function vector fi[] and |
//|               Jacobian jac at given point x                      |
//|   rep      -  optional callback which is called after each       |
//|               iteration can be null                              |
//|   obj      -  optional object which is passed to func/grad/hess/ |
//|               jac/rep can be null                                |
//| NOTES:                                                           |
//| 1. This function has two different implementations: one which    |
//|    uses  exact (analytical) user-supplied Jacobian, and one which|
//|    uses  only  function vector and numerically  differentiates   |
//|    function  in  order  to  obtain gradient.                     |
//|    Depending  on  the  specific  function  used to create        |
//|    optimizer object you should choose appropriate variant of     |
//|    MinNLCOptimize() -  one  which accepts function AND Jacobian  |
//|    or one which accepts ONLY function.                           |
//|    Be careful to choose variant of MinNLCOptimize()  which       |
//|    corresponds to your optimization scheme! Table below lists    |
//|    different  combinations  of callback (function/gradient)      |
//|    passed to MinNLCOptimize()   and  specific function used to   |
//|    create optimizer.                                             |
//|                     |         USER PASSED TO MinNLCOptimize()    |
//|   CREATED WITH      |  function only   |  function and gradient  |
//|   ------------------------------------------------------------   |
//|   MinNLCCreateF()   |     works               FAILS              |
//|   MinNLCCreate()    |     FAILS               works              |
//| Here "FAILS" denotes inappropriate combinations  of  optimizer   |
//| creation function  and  MinNLCOptimize()  version.  Attemps  to  |
//| use  such combination will lead to exception. Either  you  did   |
//| not pass gradient when it WAS needed or you passed gradient when |
//| it was NOT needed.                                               |
//+------------------------------------------------------------------+
void CAlglib::MinNLCOptimize(CMinNLCState &state,
                             CNDimensional_FVec &fvec,
                             CNDimensional_Rep &rep,CObject &obj)
  {
//--- check
   if(!CAp::Assert(GetPointer(fvec)!=NULL,"ALGLIB: error in 'minnlcoptimize()' (fvec is null)"))
      return;

//--- cycle
   while(MinNLCIteration(state))
     {
      if(state.m_needfi)
        {
         fvec.FVec(state.m_x,state.m_fi,obj);
         continue;
        }
      if(state.m_xupdated)
        {
         if(GetPointer(rep)!=NULL)
            rep.Rep(state.m_x,state.m_f,obj);
         continue;
        }
      CAp::Assert(false,"ALGLIB: error in 'minnlcoptimize' (some derivatives were not provided?)");
      break;
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinNLCOptimize(CMinNLCState &state,CNDimensional_Jac &jac,CNDimensional_Rep &rep,CObject &obj)
  {
//--- check
   if(!CAp::Assert(GetPointer(jac)!=NULL,"ALGLIB: error in 'minnlcoptimize()' (jac is null)"))
      return;

//--- cycle
   while(MinNLCIteration(state))
     {
      if(state.m_needfij)
        {
         jac.Jac(state.m_x,state.m_fi,state.m_j,obj);
         continue;
        }
      if(state.m_xupdated)
        {
         if(GetPointer(rep)!=NULL)
            rep.Rep(state.m_x,state.m_f,obj);
         continue;
        }
      CAp::Assert(false,"ALGLIB: error in 'minnlcoptimize' (some derivatives were not provided?)");
      break;
     }
  }
//+------------------------------------------------------------------+
//| This function activates/deactivates verification of the user-    |
//| supplied analytic gradient/Jacobian.                             |
//| Upon activation of this option OptGuard integrity checker        |
//| performs numerical differentiation of your target function       |
//| (constraints) at the initial point (note: future versions may    |
//| also perform check at the final point) and compares numerical    |
//| gradient/Jacobian with analytic one provided by you.             |
//| If difference is too large, an error flag is set and optimization|
//| session continues. After optimization session is over, you can   |
//| retrieve the report which stores both gradients/Jacobians, and   |
//| specific components highlighted as suspicious by the OptGuard.   |
//| The primary OptGuard report can be retrieved with                |
//| MinNLCOptGuardResults().                                         |
//| IMPORTANT: gradient check is a high-overhead option which will   |
//|            cost you about 3*N additional function evaluations.   |
//|            In many cases it may cost as much as the rest of the  |
//|            optimization session.                                 |
//| YOU SHOULD NOT USE IT IN THE PRODUCTION CODE UNLESS YOU WANT TO  |
//| CHECK DERIVATIVES PROVIDED BY SOME THIRD PARTY.                  |
//| NOTE: unlike previous incarnation of the gradient checking code, |
//|       OptGuard does NOT interrupt optimization even if it        |
//|       discovers bad gradient.                                    |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure used to store algorithm State         |
//|   TestStep    -  verification step used for numerical            |
//|                  differentiation:                                |
//|                  * TestStep = 0 turns verification off           |
//|                  * TestStep > 0 activates verification           |
//|                  You should carefully choose TestStep. Value     |
//|                  which is too large (so large that function      |
//|                  behavior is non- cubic at this scale) will      |
//|                  lead to false alarms. Too short step will       |
//|                  result in rounding errors dominating numerical  |
//|                  derivative.                                     |
//|                  You may use different step for different        |
//|                  parameters by means of setting scale with       |
//|                  MinNLCSetScale().                               |
//| === EXPLANATION ================================================ |
//| In order to verify gradient algorithm performs following steps:  |
//|   *  two trial steps are made to                                 |
//|            X[i] - TestStep * S[i] and X[i] + TestStep * S[i],    |
//|      where X[i] is i-th component of the initial point and S[i]  |
//|      is a scale of i-th parameter                                |
//|   *  F(X) is evaluated at these trial points                     |
//|   *  we perform one more evaluation in the middle point of the   |
//|      interval                                                    |
//|   *  we build cubic model using function values and derivatives  |
//|      at trial points and we compare its prediction with actual   |
//|      value in the middle point                                   |
//+------------------------------------------------------------------+
void CAlglib::MinNLCOptGuardGradient(CMinNLCState &state,double teststep)
  {
   CMinNLC::MinNLCOptGuardGradient(state,teststep);
  }
//+------------------------------------------------------------------+
//| This function activates/deactivates nonsmoothness monitoring     |
//| option of the OptGuard integrity checker. Smoothness monitor     |
//| silently observes solution process and tries to detect ill-posed |
//| problems, i.e. ones with:                                        |
//|   a) discontinuous target function(non-C0) and/or constraints    |
//|   b) nonsmooth   target function(non-C1) and/or constraints      |
//| Smoothness monitoring does NOT interrupt optimization even if it |
//| suspects that your problem is nonsmooth. It just sets            |
//| corresponding flags in the OptGuard report which can be retrieved|
//| after optimization is over.                                      |
//| Smoothness monitoring is a moderate overhead option which often  |
//| adds less than 1% to the optimizer running time. Thus, you can   |
//| use it even for large scale problems.                            |
//| NOTE:   OptGuard does NOT guarantee that it will always detect   |
//|         C0/C1 continuity violations.                             |
//| First, minor errors are hard to catch-say, a 0.0001 difference   |
//| in the model values at two sides of the gap may be due to        |
//| discontinuity of the model - or simply because the model has     |
//| changed.                                                         |
//| Second, C1-violations are especially difficult to detect in a    |
//| noninvasive way. The optimizer usually performs very short steps |
//| near the nonsmoothness, and differentiation usually  introduces  |
//| a lot of numerical noise. It is hard to tell whether some tiny   |
//| discontinuity in the slope is due to real nonsmoothness or just  |
//| due to numerical noise alone.                                    |
//| Our top priority was to avoid false positives, so in some rare   |
//| cases minor errors may went unnoticed (however, in most cases    |
//| they can be spotted with restart from different initial point).  |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm State                                    |
//|   level    -  monitoring level:                                  |
//|               * 0 - monitoring is disabled                       |
//|               * 1 - noninvasive low - overhead monitoring;       |
//|                     function values and/or gradients are         |
//|                     recorded, but OptGuard does not try to       |
//|                     perform additional evaluations in order      |
//|                     to get more information about suspicious     |
//|                     locations.                                   |
//| This kind of monitoring does not work well with SQP because SQP  |
//| solver needs just 1-2 function evaluations per step, which is not|
//| enough for OptGuard to make any conclusions.                     |
//| === EXPLANATION ================================================ |
//| One major source of headache during optimization is the          |
//| possibility of the coding errors in the target function/         |
//| constraints (or their gradients). Such errors  most  often       |
//| manifest  themselves as discontinuity or nonsmoothness of the    |
//| target/constraints.                                              |
//| Another frequent situation is when you try to optimize something |
//| involving lots of min() and max() operations, i.e. nonsmooth     |
//| target. Although not a coding error, it is nonsmoothness anyway -|
//| and smooth optimizers usually stop right after encountering      |
//| nonsmoothness, well before reaching solution.                    |
//| OptGuard integrity checker helps you to catch such situations:   |
//| it monitors function values/gradients being passed to the        |
//| optimizer and tries to errors. Upon discovering suspicious pair  |
//| of points it raises appropriate flag (and allows you to continue |
//| optimization). When optimization is done, you can study OptGuard |
//| result.                                                          |
//+------------------------------------------------------------------+
void CAlglib::MinNLCOptGuardSmoothness(CMinNLCState &state,int level)
  {
   CMinNLC::MinNLCOptGuardSmoothness(state,level);
  }
//+------------------------------------------------------------------+
//| Results of OptGuard integrity check, should be called  after     |
//| optimization session is over.                                    |
//| === PRIMARY REPORT ============================================= |
//| OptGuard performs several checks which are intended to catch     |
//| common errors in the implementation of nonlinear function/       |
//| gradient:                                                        |
//|   * incorrect analytic gradient                                  |
//|   * discontinuous (non-C0) target functions (constraints)        |
//|   * nonsmooth (non-C1) target functions (constraints)            |
//| Each of these checks is activated with appropriate function:     |
//|   * MinNLCOptGuardGradient() for gradient verification           |
//|   * MinNLCOptGuardSmoothness() for C0/C1 checks                  |
//| Following flags are set when these errors are suspected:         |
//|   * rep.badgradsuspected, and additionally:                      |
//|         * rep.badgradfidx for specific function (Jacobian row)   |
//|                           suspected                              |
//|         * rep.badgradvidx for specific variable (Jacobian column)|
//|                           suspected                              |
//|         * rep.badgradxbase, a point where gradient/Jacobian is   |
//|                           tested                                 |
//|         * rep.badgraduser, user-provided gradient/Jacobian       |
//|         * rep.badgradnum, reference gradient/Jacobian obtained   |
//|                           via numerical differentiation          |
//|   * rep.nonc0suspected, and additionally:                        |
//|         * rep.nonc0fidx - an index of specific function violating|
//|                           C0 continuity                          |
//|         * rep.nonc1suspected, and additionally                   |
//|         * rep.nonc1fidx - an index of specific function violating|
//|                           C1 continuity                          |
//| Here function index 0 means target function, index 1 or higher   |
//| denotes nonlinear constraints.                                   |
//| === ADDITIONAL REPORTS / LOGS ================================== |
//| Several different tests are performed to catch C0/C1 errors, you |
//| can find out specific test signaled error by looking to:         |
//|   * rep.nonc0test0positive, for non-C0 test #0                   |
//|   * rep.nonc1test0positive, for non-C1 test #0                   |
//|   * rep.nonc1test1positive, for non-C1 test #1                   |
//| Additional information (including line search logs) can be       |
//| obtained  by means of:                                           |
//|   * MinNLCOptGuardNonC1Test0Results()                            |
//|   * MinNLCOptGuardNonC1Test1Results()                            |
//| which return detailed error reports, specific points where       |
//| discontinuities were found, and so on.                           |
//| ================================================================ |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm State                                    |
//| OUTPUT PARAMETERS:                                               |
//|   rep      -  generic OptGuard report; more  detailed reports can|
//|               be retrieved with other functions.                 |
//| NOTE:   false negatives (nonsmooth problems are not identified   |
//|         as nonsmooth ones) are possible although unlikely.       |
//| The reason is that you need to make several evaluations around   |
//| nonsmoothness in order to accumulate enough information about    |
//| function curvature. Say, if you start right from the nonsmooth   |
//| point, optimizer simply won't get enough data to understand what |
//| is going wrong before it terminates due to abrupt changes in the |
//| derivative. It is also possible that "unlucky" step will move us |
//| to the termination too quickly.                                  |
//| Our current approach is to have less than 0.1 % false negatives  |
//| in our test examples (measured with multiple restarts from random|
//| points), and to have exactly 0 % false positives.                |
//+------------------------------------------------------------------+
void CAlglib::MinNLCOptGuardResults(CMinNLCState &state,
                                    COptGuardReport &rep)
  {
   CMinNLC::MinNLCOptGuardResults(state,rep);
  }
//+------------------------------------------------------------------+
//| Detailed results of the OptGuard integrity check for             |
//| nonsmoothness test #0                                            |
//| Nonsmoothness(non-C1) test #0 studies function values (not       |
//| gradient!) obtained during line searches and monitors behavior   |
//| of the directional derivative estimate.                          |
//| This test is less powerful than test #1, but it does not depend  |
//| on the gradient values and thus it is more robust against        |
//| artifacts introduced by numerical differentiation.               |
//| Two reports are returned:                                        |
//|  *a "strongest" one, corresponding to line  search which had   |
//|     highest value of the nonsmoothness indicator                 |
//|  *a "longest" one, corresponding to line search which had more |
//|     function evaluations, and thus is more detailed              |
//| In both cases following fields are returned:                     |
//|   * positive - is TRUE when test flagged suspicious point;       |
//|                FALSE if test did not notice anything (in the     |
//|                      latter cases fields below are empty).       |
//|   * fidx-is an index of the function (0 for target function, 1 or|
//|                higher for nonlinear constraints) which is        |
//|                suspected of being "non-C1"                       |
//|   * x0[], d[] - arrays of length N which store initial point and |
//|                direction for line search (d[] can be normalized, |
//|                but does not have to)                             |
//|   * stp[], f[] - arrays of length CNT which store step lengths   |
//|                and function values at these points; f[i] is      |
//|                evaluated in x0 + stp[i]*d.                       |
//|   * stpidxa, stpidxb - we suspect that function violates C1      |
//|                continuity between steps #stpidxa and #stpidxb    |
//|                (usually we have stpidxb = stpidxa + 3, with most |
//|                likely position of the violation between          |
//|                stpidxa + 1 and stpidxa + 2.                      |
//| ================================================================ |
//| = SHORTLY SPEAKING: build a 2D plot of(stp, f) and look at it -  |
//| =                   you will see where C1 continuity is violated.|
//| ================================================================ |
//| INPUT PARAMETERS:                                                |
//|   State       -  algorithm State                                 |
//| OUTPUT PARAMETERS:                                               |
//|   strrep     - C1 test #0 "strong" report                      |
//|   lngrep     - C1 test #0 "long" report                        |
//+------------------------------------------------------------------+
void CAlglib::MinNLCOptGuardNonC1Test0Results(CMinNLCState &state,
                                              COptGuardNonC1Test0Report &strrep,
                                              COptGuardNonC1Test0Report &lngrep)
  {
   CMinNLC::MinNLCOptGuardNonC1Test0Results(state,strrep,lngrep);
  }
//+------------------------------------------------------------------+
//| Detailed results of the OptGuard integrity check for             |
//| nonsmoothness test #1                                            |
//| Nonsmoothness(non-C1) test #1 studies individual components of   |
//| the gradient computed during line search.                        |
//| When precise analytic gradient is provided this test is more     |
//| powerful than test #0 which works with function values and       |
//| ignores user-provided gradient. However, test #0 becomes more    |
//| powerful  when  numerical differentiation is employed (in such   |
//| cases test #1 detects higher levels of numerical noise and       |
//| becomes too conservative).                                       |
//| This test also tells specific components of the gradient which   |
//| violate C1 continuity, which makes it more informative than #0,  |
//| which just tells that continuity is violated.                    |
//| Two reports are returned:                                        |
//|  *a "strongest" one, corresponding to line  search which had   |
//|     highest value of the nonsmoothness indicator                 |
//|  *a "longest" one, corresponding to line search which had more |
//|     function evaluations, and thus is more detailed              |
//| In both cases following fields are returned:                     |
//|   * positive - is TRUE when test flagged suspicious point; FALSE |
//|     if test did not notice anything(in the latter cases fields   |
//|     below are empty).                                            |
//|   * fidx-is an index of the function(0 for target function, 1 or |
//|     higher for nonlinear constraints) which is suspected of      |
//|     being "non-C1"                                               |
//|   * vidx - is an index of the variable in [0, N) with nonsmooth  |
//|     derivative                                                   |
//|   * x0[], d[] - arrays of length N which store initial point and |
//|     direction for line search(d[] can be normalized, but does not|
//|     have to)                                                     |
//|   * stp[], g[]-arrays of length CNT which store step lengths and |
//|     gradient values at these points; g[i] is evaluated in        |
//|     x0 + stp[i]*d and contains vidx-th component of the gradient.|
//|   * stpidxa, stpidxb - we suspect that function violates C1      |
//|     continuity between steps #stpidxa and #stpidxb (usually we   |
//|     have stpidxb = stpidxa + 3, with most likely position of the |
//|     violation between stpidxa + 1 and stpidxa + 2.               |
//| ================================================================ |
//| = SHORTLY SPEAKING: build a 2D plot of (stp, f) and look at it - |
//| =                   you will see where C1 continuity is violated.|
//| ================================================================ |
//| INPUT PARAMETERS:                                                |
//|   State       -  algorithm State                                 |
//| OUTPUT PARAMETERS:                                               |
//|   strrep     - C1 test #1 "strong" report                      |
//|   lngrep     - C1 test #1 "long" report                        |
//+------------------------------------------------------------------+
void CAlglib::MinNLCOptGuardNonC1Test1Results(CMinNLCState &state,
                                              COptGuardNonC1Test1Report &strrep,
                                              COptGuardNonC1Test1Report &lngrep)
  {
   CMinNLC::MinNLCOptGuardNonC1Test1Results(state,strrep,lngrep);
  }
//+------------------------------------------------------------------+
//| MinNLC results: the solution found, completion codes and         |
//| additional information.                                          |
//| If you activated OptGuard integrity checking functionality and   |
//| want to get OptGuard report, it can be retrieved with:           |
//|   * MinNLCOptGuardResults()  -  for a primary report about(a)    |
//|                                 suspected C0/C1 continuity       |
//|                                 violations and (b) errors in the |
//|                                 analytic gradient.               |
//|   * MinNLCOptGuardNonC1Test0Results() - for C1 continuity        |
//|                                 violation test #0, detailed line |
//|                                 search log                       |
//|   * MinNLCOptGuardNonC1Test1Results() - for C1 continuity        |
//|                                 violation test #1, detailed line |
//|                                 search log                       |
//| INPUT PARAMETERS:                                                |
//|   State       -  algorithm State                                 |
//| OUTPUT PARAMETERS:                                               |
//|   X           -  array[0..N - 1], solution                       |
//|   Rep         -  optimization report, contains information about |
//|                  completion code, constraint violation at the    |
//|                  solution and so on.                             |
//| You  should  check  rep.m_terminationtype in order to distinguish|
//| successful termination from unsuccessful one:                    |
//| === FAILURE CODES ===                                            |
//| * -8    internal integrity control detected infinite or NAN      |
//|         values  in  function/gradient. Abnormal termination      |
//|         signalled.                                               |
//| * -3    box constraints are infeasible.                          |
//| Note:   infeasibility of non-box constraints does NOT trigger    |
//|         emergency completion; you have to examine rep.m_bcerr/   |
//|         rep.m_lcerr/rep.m_nlcerr to detect possibly inconsistent |
//|         constraints.                                             |
//| === SUCCESS CODES ===                                            |
//| * 2     scaled step is no more than EpsX.                        |
//| * 5     MaxIts steps were taken.                                 |
//| * 8     user  requested  algorithm  termination  via             |
//|         MinNLCRequestTermination(), last accepted point is       |
//|         returned.                                                |
//| More information about fields of this structure can be found in  |
//| the comments on CMinNLCReport datatype.                          |
//+------------------------------------------------------------------+
void CAlglib::MinNLCResults(CMinNLCState &state,CRowDouble &x,
                            CMinNLCReport &rep)
  {
   CMinNLC::MinNLCResults(state,x,rep);
  }
//+------------------------------------------------------------------+
//| NLC results                                                      |
//| Buffered implementation of MinNLCResults() which uses pre-       |
//| allocated buffer to store X[]. If buffer size is too small, it   |
//| resizes buffer. It is intended to be used in the inner cycles of |
//| performance critical algorithms where array reallocation penalty |
//| is too large to be ignored.                                      |
//+------------------------------------------------------------------+
void CAlglib::MinNLCResultsBuf(CMinNLCState &state,
                               CRowDouble &x,
                               CMinNLCReport &rep)
  {
   CMinNLC::MinNLCResultsBuf(state,x,rep);
  }
//+------------------------------------------------------------------+
//| This subroutine submits request for termination of running       |
//| optimizer. It should be called from user - supplied callback     |
//| when user decides that it is time to "smoothly" terminate        |
//| optimization process. As result, optimizer stops at point which  |
//| was "current accepted" when termination request was submitted    |
//| and returns error code 8(successful termination).                |
//| INPUT PARAMETERS:                                                |
//|   State    -  optimizer structure                                |
//| NOTE:   after request for termination optimizer may  perform     |
//|         several additional calls to user-supplied callbacks.     |
//|         It does  NOT  guarantee to stop immediately - it just    |
//|         guarantees that these additional calls will be discarded |
//|         later.                                                   |
//| NOTE:   calling this function on optimizer which is NOT running  |
//|         will have no effect.                                     |
//| NOTE:   multiple calls to this function are possible. First call |
//|         is counted, subsequent calls are silently ignored.       |
//+------------------------------------------------------------------+
void CAlglib::MinNLCRequestTermination(CMinNLCState &state)
  {
   CMinNLC::MinNLCRequestTermination(state);
  }
//+------------------------------------------------------------------+
//| This subroutine restarts algorithm from new point.               |
//| All optimization parameters (including constraints) are left     |
//| unchanged.                                                       |
//| This  function  allows  to  solve multiple optimization problems |
//| (which must have  same number of dimensions) without object      |
//| reallocation penalty.                                            |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinNLCCreate   |
//|               call.                                              |
//|   X        -  new starting point.                                |
//+------------------------------------------------------------------+
void CAlglib::MinNLCRestartFrom(CMinNLCState &state,CRowDouble &x)
  {
   CMinNLC::MinNLCRestartFrom(state,x);
  }
//+------------------------------------------------------------------+
//| NONSMOOTH NONCONVEX OPTIMIZATION                                 |
//| SUBJECT TO BOX / LINEAR / NONLINEAR - NONSMOOTH CONSTRAINTS      |
//| DESCRIPTION:                                                     |
//| The subroutine minimizes function  F(x) of N arguments subject to|
//| any combination of:                                              |
//|   * bound constraints                                            |
//|   * linear inequality constraints                                |
//|   * linear equality constraints                                  |
//|   * nonlinear equality constraints Gi(x) = 0                     |
//|   * nonlinear inequality constraints Hi(x) <= 0                  |
//| IMPORTANT: see MinNSSetAlgoAGS for important information on      |
//|            performance restrictions of AGS solver.               |
//| REQUIREMENTS:                                                    |
//|   * starting point X0 must be feasible or not too far away from  |
//|     the feasible set                                             |
//|   * F(), G(), H() are continuous, locally Lipschitz and          |
//|     continuously (but not necessarily twice) differentiable in an|
//|     open dense subset of R^N.                                    |
//| Functions F(), G() and H() may be nonsmooth and non-convex.      |
//| Informally speaking, it means that functions are composed of     |
//| large differentiable "patches" with nonsmoothness having place   |
//| only at the boundaries between these "patches". Most real-life   |
//| nonsmooth functions satisfy these requirements. Say, anything    |
//| which involves finite number of abs(), min() and max() is very   |
//| likely to pass the test. Say, it is possible to optimize anything|
//| of the following:                                                |
//|   * f = abs(x0) + 2 * abs(x1)                                    |
//|   * f = max(x0, x1)                                              |
//|   * f = sin(max(x0, x1) + abs(x2))                               |
//|   * for nonlinearly constrained problems: F() must be bounded    |
//|     from below without nonlinear constraints (this requirement   |
//|     is due to the fact that, contrary to box and linear          |
//|     constraints, nonlinear ones require special handling).       |
//|   * user must provide function value and gradient for F(), H(),  |
//|     G() at all points where function / gradient can be calculated|
//|     If optimizer requires value exactly at the boundary between  |
//|     "patches"(say, at x = 0 for f = abs(x)), where gradient is   |
//|     not defined, user may resolve tie arbitrarily (in our case - |
//|     return +1 or -1 at its discretion).                          |
//|   * NS solver supports numerical differentiation, i.e. it may    |
//|     differentiate your function for you, but it results in 2N    |
//|     increase of function evaluations. Not recommended unless you |
//|     solve really small problems. See MinNSCreateF() for more     |
//|     information on this functionality.                           |
//| USAGE:                                                           |
//| 1. User initializes algorithm State with MinNSCreate() call and  |
//|    chooses what NLC solver to use. There is some solver which is |
//|    used by default, with default Settings, but you should NOT    |
//|    rely on default choice. It may change in future releases of   |
//|    ALGLIB without notice, and no one can guarantee that new      |
//|    solver will be able to solve your problem with default        |
//|    Settings.                                                     |
//| From the other side, if you choose solver explicitly, you can be |
//| pretty sure that it will work with new ALGLIB releases.          |
//| In the current release following solvers can be used:            |
//|   * AGS solver (activated with MinNSSetAlgoAGS() function)       |
//| 2. User adds boundary and/or linear and/or nonlinear constraints |
//|    by means of calling one of the following functions:           |
//|      a) MinNSSetBC() for boundary constraints                    |
//|      b) MinNSSetLC() for linear constraints                      |
//|      c) MinNSSetNLC() for nonlinear constraints                  |
//|   You may combine(a), (b) and (c) in one optimization problem.   |
//| 3. User sets scale of the variables with MinNSSetScale() function|
//|    It is VERY important to set scale of the variables, because   |
//|    nonlinearly constrained problems are hard to solve when       |
//|    variables are badly scaled.                                   |
//| 4. User sets stopping conditions with MinNSSetCond().            |
//| 5. Finally, user calls MinNSOptimize() function which takes      |
//|    algorithm State and pointer (delegate, etc) to callback       |
//|    function which calculates F / G / H.                          |
//| 6. User calls MinNSResults() to get solution                     |
//| 7. Optionally user may call MinNSRestartFrom() to solve another  |
//|    problem with same N but another starting point.               |
//|    MinNSRestartFrom() allows  to reuse already initialized       |
//|    structure.                                                    |
//| INPUT PARAMETERS:                                                |
//|   N        -  problem dimension, N > 0:                          |
//|               * if given, only leading N elements of X are used  |
//|               * if not given, automatically determined from size |
//|                 of X                                             |
//|   X        -  starting point, array[N]:                          |
//|               * it is better to set X to a feasible point        |
//|               * but X can be infeasible, in which case algorithm |
//|                 will try to find feasible point first, using X as|
//|                 initial approximation.                           |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure stores algorithm State                   |
//| NOTE:   MinNSCreateF() function may be used if you do not have   |
//|         analytic gradient. This function creates solver which    |
//|         uses numerical differentiation with user-specified step. |
//+------------------------------------------------------------------+
void CAlglib::MinNSCreate(int n,CRowDouble &x,CMinNSState &state)
  {
   CMinNS::MinNSCreate(n,x,state);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinNSCreate(CRowDouble &x,CMinNSState &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinNS::MinNSCreate(n,x,state);
  }
//+------------------------------------------------------------------+
//| Version of MinNSCreateF() which uses numerical differentiation.  |
//| I.e., you do not have to calculate derivatives yourself. However,|
//| this version needs 2N times more function evaluations.           |
//| 2-point differentiation formula is used, because  more  precise  |
//| 4-point formula is unstable when used on non - smooth functions. |
//| INPUT PARAMETERS:                                                |
//|   N        -  problem dimension, N > 0:                          |
//|               * if given, only leading N elements of X are used  |
//|               * if not given, automatically determined from size |
//|                 of X                                             |
//|   X        -  starting point, array[N]:                          |
//|               * it is better to set X to a feasible point        |
//|               * but X can be infeasible, in which case algorithm |
//|                 will try to find feasible point first, using X as|
//|                 initial approximation.                           |
//|   DiffStep -  differentiation  step,  DiffStep > 0.   Algorithm  |
//|               performs numerical differentiation  with  step  for|
//|               I-th variable being equal to DiffStep*S[I] (here   |
//|               S[] is a  scale vector, set by MinNSSetScale()     |
//|               function). Do not use  too  small  steps,  because |
//|               it may lead to catastrophic cancellation during    |
//|               intermediate calculations.                         |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure stores algorithm State                   |
//+------------------------------------------------------------------+
void CAlglib::MinNSCreateF(int n,CRowDouble &x,double diffstep,
                           CMinNSState &state)
  {
   CMinNS::MinNSCreateF(n,x,diffstep,state);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinNSCreateF(CRowDouble &x,double diffstep,CMinNSState &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinNS::MinNSCreateF(n,x,diffstep,state);
  }
//+------------------------------------------------------------------+
//| This function sets boundary constraints.                         |
//| Boundary constraints are inactive by default (after initial      |
//| creation). They are preserved after algorithm restart with       |
//| MinNSRestartFrom().                                              |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure stores algorithm State                   |
//|   BndL     -  lower bounds, array[N]. If some (all) variables    |
//|               are unbounded, you may specify very small number   |
//|               or -INF.                                           |
//|   BndU     -  upper bounds, array[N]. If some (all) variables are|
//|               unbounded, you may specify very large number       |
//|               or +INF.                                           |
//| NOTE 1: it is possible to specify BndL[i]=BndU[i]. In this case  |
//|         I-th variable will be "frozen" at X[i]=BndL[i]=BndU[i].  |
//| NOTE 2: AGS solver has following useful properties:              |
//|            * bound constraints are always satisfied exactly      |
//|            * function is evaluated only INSIDE area specified by |
//|              bound constraints, even when numerical              |
//|              differentiation is used(algorithm adjusts  nodes    |
//|              according to boundary constraints)                  |
//+------------------------------------------------------------------+
void CAlglib::MinNSSetBC(CMinNSState &state,CRowDouble &bndl,CRowDouble &bndu)
  {
   CMinNS::MinNSSetBC(state,bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function sets linear constraints.                           |
//| Linear constraints are inactive by default (after initial        |
//| creation). They are preserved after algorithm restart with       |
//| MinNSRestartFrom().                                              |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinNSCreate()  |
//|               call.                                              |
//|   C        -  linear constraints, array[K, N + 1]. Each row of C |
//|               represents one constraint, either equality or      |
//|               inequality(see below):                             |
//|               * first N elements correspond to coefficients,     |
//|               * last element corresponds to the right part.      |
//|               All elements of C (including right part) must be   |
//|               finite.                                            |
//|   CT       -  type of constraints, array[K]:                     |
//|               * if CT[i] > 0, then I-th constraint is            |
//|                           C[i, *] * x >= C[i, n + 1]             |
//|               * if CT[i] = 0, then I-th constraint is            |
//|                           C[i, *] * x  = C[i, n + 1]             |
//|               * if CT[i] < 0, then I-th constraint is            |
//|                            C[i, *] * x <= C[i, n + 1]            |
//|   K        -  number of equality / inequality constraints, K>=0: |
//|               * if given, only leading K elements of C/CT are    |
//|                 used                                             |
//|               * if not given, automatically determined from sizes|
//|                 of C/CT                                          |
//| NOTE:   linear (non-bound) constraints are satisfied only        |
//|         approximately:                                           |
//|         * there always exists some minor violation(about current |
//|           sampling radius in magnitude during optimization, about|
//|           EpsX in the solution) due to use of penalty method to  |
//|           handle constraints.                                    |
//|         * numerical differentiation, if used, may lead to        |
//|           function evaluations outside of the feasible area,     |
//|           because algorithm does NOT change numerical            |
//|           differentiation formula according to linear constraints|
//| If you want constraints to be satisfied exactly, try to          |
//| reformulate your problem in such manner that all constraints will|
//| become boundary ones (this kind of constraints is always         |
//| satisfied exactly, both in the final solution and in all         |
//| intermediate points).                                            |
//+------------------------------------------------------------------+
void CAlglib::MinNSSetLC(CMinNSState &state,CMatrixDouble &c,CRowInt &ct,int k)
  {
   CMinNS::MinNSSetLC(state,c,ct,k);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinNSSetLC(CMinNSState &state,CMatrixDouble &c,CRowInt &ct)
  {
//--- check
   if(!CAp::Assert(CAp::Rows(c)==CAp::Len(ct),
                   "Error while calling 'MinNSSetLC': looks like one of arguments has wrong size"))
      return;
//--- initialization
   int k=CAp::Rows(c);
//--- function call
   CMinNS::MinNSSetLC(state,c,ct,k);
  }
//+------------------------------------------------------------------+
//| This function sets nonlinear constraints.                        |
//| In fact, this function sets NUMBER of nonlinear  constraints.    |
//| Constraints itself (constraint functions) are passed to          |
//| MinNSOptimize() method. This method requires user-defined vector |
//| function F[] and its Jacobian J[], where:                        |
//|   * first component of F[] and first row of Jacobian J[]         |
//|     correspond to function being minimized                       |
//|   * next NLEC components of F[] (and rows of J) correspond to    |
//|     nonlinear equality constraints G_i(x) = 0                    |
//|   * next NLIC components of F[] (and rows of J) correspond to    |
//|     nonlinear inequality constraints H_i(x) <= 0                 |
//| NOTE: you may combine nonlinear constraints with linear/boundary |
//|       ones. If your problem has mixed constraints, you may       |
//|       explicitly specify some of them as linear ones. It may help|
//|       optimizer to handle them more efficiently.                 |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure previously allocated with             |
//|                  MinNSCreate() call.                             |
//|   NLEC        -  number of Non-Linear Equality Constraints(NLEC),|
//|                  >= 0                                            |
//|   NLIC        -  number of Non-Linear Inquality Constraints(NLIC)|
//|                  >= 0                                            |
//| NOTE 1: nonlinear constraints are satisfied only approximately!  |
//|         It is possible that algorithm will evaluate function     |
//|         outside of the feasible area!                            |
//| NOTE 2: algorithm scales variables according to scale specified  |
//|         by MinNSSetScale() function, so it can handle problems   |
//|         with badly scaled variables (as long as we KNOW their    |
//|         scales).                                                 |
//| However, there is no way to automatically scale nonlinear        |
//| constraints Gi(x) and Hi(x). Inappropriate scaling of Gi/Hi may  |
//| ruin convergence. Solving problem with constraint "1000*G0(x)=0" |
//| is NOT same as solving it with constraint "0.001*G0(x)=0".       |
//| It means that YOU are the one who is responsible for correct     |
//| scaling of nonlinear constraints Gi(x) and Hi(x). We recommend   |
//| you to scale nonlinear constraints in such way that I-th         |
//| component of dG/dX (or dH/dx) has approximately unit magnitude   |
//| (for problems with unit scale) or has magnitude approximately    |
//| equal to 1/S[i] (where S is a scale set by MinNSSetScale()       |
//| function).                                                       |
//| NOTE 3: nonlinear constraints are always hard to handle, no      |
//|         matter what algorithm you try to use. Even basic box/    |
//|         linear constraints modify function curvature by adding   |
//|         valleys and ridges. However, nonlinear constraints add   |
//|         valleys which are very hard to follow due to their       |
//|         "curved" nature.                                         |
//| It means that optimization with single nonlinear constraint may  |
//| be significantly slower than optimization with multiple linear   |
//| ones. It is normal situation, and we recommend you to carefully  |
//| choose Rho parameter of MinNSSetAlgoAGS(), because too large     |
//| value may slow down convergence.                                 |
//+------------------------------------------------------------------+
void CAlglib::MinNSSetNLC(CMinNSState &state,int nlec,int nlic)
  {
   CMinNS::MinNSSetNLC(state,nlec,nlic);
  }
//+------------------------------------------------------------------+
//| This function sets stopping conditions for iterations of         |
//| optimizer.                                                       |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure which stores algorithm State          |
//|   EpsX        -  >= 0, The AGS solver finishes its work if on    |
//|                  k+1-th iteration sampling radius decreases      |
//|                  below EpsX.                                     |
//|   MaxIts      -  maximum number of iterations. If MaxIts = 0,    |
//|                  the number of iterations is unlimited.          |
//| Passing EpsX = 0  and  MaxIts = 0 (simultaneously) will lead to  |
//| automatic stopping criterion selection. We do not recommend you  |
//| to rely on default choice in production code.                    |
//+------------------------------------------------------------------+
void CAlglib::MinNSSetCond(CMinNSState &state,double epsx,int maxits)
  {
   CMinNS::MinNSSetCond(state,epsx,maxits);
  }
//+------------------------------------------------------------------+
//| This function sets scaling coefficients for NLC optimizer.       |
//| ALGLIB optimizers use scaling matrices to test stopping          |
//| conditions (step size and gradient are scaled before comparison  |
//| with tolerances). Scale of the I-th variable is a translation    |
//| invariant measure of:                                            |
//|   a) "how large" the variable is                                 |
//|   b) how large the step should be to make significant changes in |
//|      the function                                                |
//| Scaling is also used by finite difference variant of the         |
//| optimizer - step along I-th axis is equal to DiffStep*S[I].      |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure stores algorithm State                |
//|   S           -  array[N], non-zero scaling coefficients S[i]    |
//|                  may be negative, sign doesn't matter.           |
//+------------------------------------------------------------------+
void CAlglib::MinNSSetScale(CMinNSState &state,CRowDouble &s)
  {
   CMinNS::MinNSSetScale(state,s);
  }
//+------------------------------------------------------------------+
//| This function tells MinNS unit to use  AGS (adaptive gradient    |
//| sampling) algorithm for nonsmooth constrained optimization. This |
//| algorithm is a slight modification of one described in "An       |
//| Adaptive Gradient Sampling Algorithm for Nonsmooth Optimization" |
//| by Frank E. Curtisy and Xiaocun Quez.                            |
//| This optimizer has following benefits and drawbacks:             |
//|   + robustness; it can be used with nonsmooth and nonconvex      |
//|                 functions.                                       |
//|   + relatively easy tuning; most of the metaparameters are easy  |
//|                 to select.                                       |
//|   - it has convergence of steepest descent, slower than CG/LBFGS.|
//|   - each iteration involves evaluation of ~2N gradient values and|
//|     solution of 2Nx2N quadratic programming problem, which limits|
//|     applicability of algorithm by small-scale problems (up       |
//|     to 50 - 100).                                                |
//| IMPORTANT: this algorithm has convergence guarantees, i.e. it    |
//|            will steadily move towards some stationary point of   |
//|            the function.                                         |
//| However, "stationary point" does not  always  mean  "solution".  |
//| Nonsmooth problems often have "flat spots", i.e. areas where     |
//| function do not change at all. Such "flat spots" are stationary  |
//| points by definition, and algorithm may be caught here.          |
//| Nonsmooth CONVEX tasks are not prone to this problem. Say, if    |
//| your function has form f() = MAX(f0, f1, ...), and f_i are convex|
//| then f() is convex too and you have guaranteed  convergence  to  |
//| solution.                                                        |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure which stores algorithm State          |
//|   Radius      -  initial sampling radius, >= 0. Internally       |
//|                  multiplied  by  vector of  per-variable  scales |
//|                  specified by MinNSSetScale().                   |
//|                  You should select relatively large sampling     |
//|                  radius, roughly proportional to scaled length   |
//|                  of the first steps of the algorithm. Something  |
//|                  close to 0.1 in magnitude should be good for    |
//|                  most problems.                                  |
//|                  AGS solver can automatically decrease radius,   |
//|                  so too large radius is not a problem (assuming  |
//|                  that you won't choose so large radius that      |
//|                  algorithm will sample function in too far away  |
//|                  points, where gradient value is irrelevant).    |
//|                  Too small radius won't cause algorithm to fail, |
//|                  but it may slow down algorithm (it may have to  |
//|                  perform too short steps).                       |
//|   Penalty     -  penalty coefficient for nonlinear constraints:  |
//|                  * for problem with nonlinear constraints should |
//|                    be some problem - specific positive value,    |
//|                    large enough that penalty term changes shape  |
//|                    of the function. Starting from some problem - |
//|                    specific value penalty coefficient becomes    |
//|                    large enough to exactly enforce nonlinear     |
//|                    constraints; larger values do not improve     |
//|                    precision. Increasing it too much may slow    |
//|                    down convergence, so you should choose it     |
//|                    carefully.                                    |
//|                  * can be zero for problems WITHOUT nonlinear    |
//|                    constraints (i.e. for unconstrained ones or   |
//|                    ones with just box or linear constraints)     |
//|                  * if you specify zero value for problem with at |
//|                    least one nonlinear constraint, algorithm will|
//|                    terminate with error code - 1.                |
//| ALGORITHM OUTLINE                                                |
//| The very basic outline of unconstrained AGS algorithm is given   |
//| below:                                                           |
//| 0. If sampling radius is below EpsX or we performed more then    |
//|    MaxIts iterations - STOP.                                     |
//| 1. sample O(N) gradient values at random locations around current|
//|    point; informally speaking, this sample is an implicit        |
//|    piecewise linear model of the function, although algorithm    |
//|    formulation does not mention that explicitly                  |
//| 2. solve quadratic programming problem in order to find descent  |
//|    direction                                                     |
//| 3. if QP solver tells us that we are near solution, decrease     |
//|    sampling radius and move to(0)                                |
//| 4. perform backtracking line search                              |
//| 5. after moving to new point, goto(0)                            |
//| Constraint handling details:                                     |
//|   * box constraints are handled exactly by algorithm             |
//|   * linear/nonlinear constraints are handled by adding L1        |
//|     penalty. Because our solver can handle nonsmoothness, we can |
//|     use L1 penalty function, which is an exact one (i.e. exact   |
//|     solution is returned under such penalty).                    |
//|   * penalty coefficient for linear constraints is chosen         |
//|     automatically; however, penalty coefficient for nonlinear    |
//|     constraints must be specified by user.                       |
//| ===== TRACING AGS SOLVER ======================================= |
//| AGS solver supports advanced tracing capabilities. You can trace |
//| algorithm output by specifying following trace symbols (case-    |
//| insensitive) by means of trace_file() call:                      |
//|   * 'AGS'        -  for basic trace of algorithm steps and       |
//|                     decisions. Only short scalars (function      |
//|                     values and deltas) are printed. N-dimensional|
//|                     quantities like search directions are NOT    |
//|                     printed.                                     |
//|   * 'AGS.DETAILED' - for output of points being visited and      |
//|                     search directions. This symbol also          |
//|                     implicitly defines 'AGS'. You can control    |
//|                     output format by additionally specifying:    |
//|                     * nothing to output in 6-digit exponential   |
//|                       format                                     |
//|                     * 'PREC.E15' to output in 15-digit           |
//|                       exponential format                         |
//|                     * 'PREC.F6' to output in 6-digit fixed-point |
//|                       format                                     |
//|   * 'AGS.DETAILED.SAMPLE' - for output of points being visited,  |
//|                     search directions and gradient sample. May   |
//|                     take a LOT of space, do not use it on        |
//|                     problems with more that several tens of vars.|
//|                     This symbol also implicitly defines 'AGS' and|
//|                     'AGS.DETAILED'.                              |
//| By default trace is disabled and adds no overhead to the         |
//| optimization process. However, specifying any of the symbols adds|
//| some formatting and output-related overhead.                     |
//| You may specify multiple symbols by separating them with commas: |
//|   >                                                              |
//|  >CAlglib::Trace_File("AGS,PREC.F6","path/to/trace.log")       |
//|   >                                                              |
//+------------------------------------------------------------------+
void CAlglib::MinNSSetAlgoAGS(CMinNSState &state,double radius,double penalty)
  {
   CMinNS::MinNSSetAlgoAGS(state,radius,penalty);
  }
//+------------------------------------------------------------------+
//| This function turns on / off reporting.                          |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure which stores algorithm State          |
//|   NeedXRep    -  whether iteration reports are needed or not     |
//| If NeedXRep is True, algorithm will call rep() callback function |
//| if it is provided to MinNSOptimize().                            |
//+------------------------------------------------------------------+
void CAlglib::MinNSSetXRep(CMinNSState &state,bool needxrep)
  {
   CMinNS::MinNSSetXRep(state,needxrep);
  }
//+------------------------------------------------------------------+
//| This subroutine submits request for termination of running       |
//| optimizer. It should be called from user-supplied callback when  |
//| user decides that it is time to "smoothly" terminate optimization|
//| process. As result, optimizer stops at point which was "current  |
//| accepted" when termination request was submitted and returns     |
//| error code 8 (successful termination).                           |
//| INPUT PARAMETERS:                                                |
//|   State       -  optimizer structure                             |
//| NOTE: after request for termination optimizer may perform several|
//|       additional calls to user-supplied callbacks. It does NOT   |
//|       guarantee to stop immediately - it just guarantees that    |
//|       these additional calls will be discarded later.            |
//| NOTE: calling this function on optimizer which is NOT running    |
//|       will have no effect.                                       |
//| NOTE: multiple calls to this function are possible. First call is|
//|       counted, subsequent calls are silently ignored.            |
//+------------------------------------------------------------------+
void CAlglib::MinNSRequestTermination(CMinNSState &state)
  {
   CMinNS::MinNSRequestTermination(state);
  }
//+------------------------------------------------------------------+
//| This function provides reverse communication interface           |
//| Reverse communication interface is not documented or recommended |
//| to use. See below for functions which provide better documented  |
//| API                                                              |
//+------------------------------------------------------------------+
bool CAlglib::MinNSIteration(CMinNSState &state)
  {
   return(CMinNS::MinNSIteration(state));
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|   fvec        -  callback which calculates function vector fi[]  |
//|                  at given point x                                |
//|   jac         -  callback which calculates function vector fi[]  |
//|                  and Jacobian jac at given point x               |
//|   rep         -  optional callback which is called after each    |
//|                  iteration can be null                           |
//|   obj         -  optional object which is passed to func/grad/   |
//|                  hess/jac/rep can be null                        |
//| NOTES:                                                           |
//| 1. This function has two different implementations: one which    |
//|    uses  exact (analytical) user-supplied Jacobian, and one which|
//|    uses  only  function vector and numerically  differentiates   |
//|    function  in  order  to  obtain gradient.                     |
//|    Depending  on  the  specific  function  used to create        |
//|    optimizer object you should choose appropriate variant of     |
//|    MinNSOptimize() -  one  which accepts function AND Jacobian or|
//|    one which accepts ONLY function.                              |
//|    Be careful to choose variant of MinNSOptimize()  which        |
//|    corresponds  to your optimization scheme! Table below lists   |
//|    different combinations of callback (function/gradient) passed |
//|    to MinNSOptimize() and specific function used to create       |
//|    optimizer.                                                    |
//|                     |         USER PASSED TO MinNLCOptimize()    |
//|   CREATED WITH      |  function only   |  function and gradient  |
//|   ------------------------------------------------------------   |
//|   MinNLCCreateF()   |     works               FAILS              |
//|   MinNLCCreate()    |     FAILS               works              |
//| Here "FAILS" denotes inappropriate combinations  of  optimizer   |
//| creation function  and  MinNLCOptimize()  version.  Attemps  to  |
//| use  such combination will lead to exception. Either  you  did   |
//| not pass gradient when it WAS needed or you passed gradient when |
//| it was NOT needed.                                               |
//+------------------------------------------------------------------+
void CAlglib::MinNSOptimize(CMinNSState &state,
                            CNDimensional_FVec &fvec,
                            CNDimensional_Rep &rep,CObject &obj)
  {
//--- check
   if(!CAp::Assert(GetPointer(fvec)!=NULL,"ALGLIB: error in 'MinNSOptimize()' (fvec is null)"))
      return;

//--- cycle
   while(MinNSIteration(state))
     {
      if(state.m_needfi)
        {
         fvec.FVec(state.m_x,state.m_fi,obj);
         continue;
        }
      if(state.m_xupdated)
        {
         if(GetPointer(rep)!=NULL)
            rep.Rep(state.m_x,state.m_f,obj);
         continue;
        }
      CAp::Assert(false,"ALGLIB: error in 'MinNSOptimize' (some derivatives were not provided?)");
      break;
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinNSOptimize(CMinNSState &state,
                            CNDimensional_Jac &jac,
                            CNDimensional_Rep &rep,
                            CObject &obj)
  {
//--- check
   if(!CAp::Assert(GetPointer(jac)!=NULL,"ALGLIB: error in 'MinNSOptimize()' (jac is null)"))
      return;

//--- cycle
   while(MinNSIteration(state))
     {
      if(state.m_needfij)
        {
         jac.Jac(state.m_x,state.m_fi,state.m_j,obj);
         continue;
        }
      if(state.m_xupdated)
        {
         if(GetPointer(rep)!=NULL)
            rep.Rep(state.m_x,state.m_f,obj);
         continue;
        }
      CAp::Assert(false,"ALGLIB: error in 'MinNSOptimize' (some derivatives were not provided?)");
      break;
     }
  }
//+------------------------------------------------------------------+
//| MinNS results                                                    |
//| INPUT PARAMETERS:                                                |
//|   State       -  algorithm State                                 |
//| OUTPUT PARAMETERS:                                               |
//|   X           -  array[0..N - 1], solution                       |
//|   Rep         -  optimization report. You should check           |
//|                  Rep.TerminationType in order to distinguish     |
//|                  successful termination from unsuccessful one:   |
//|   * -8     internal integrity control detected infinite or NAN   |
//|            values in function/gradient. Abnormal termination     |
//|            signalled.                                            |
//|   * -3     box constraints are inconsistent                      |
//|   * -1     inconsistent parameters were passed:                  |
//|            * penalty parameter for MinNSSetAlgoAGS() is zero, but|
//|              we have nonlinear constraints set by MinNSSetNLC()  |
//|   *  2     sampling radius decreased below epsx                  |
//|   *  7     stopping conditions are too stringent, further        |
//|            improvement is impossible, X contains best point found|
//|            so far.                                               |
//|   *  8     User requested termination via                        |
//|            MinNSRequestTermination()                             |
//+------------------------------------------------------------------+
void CAlglib::MinNSResults(CMinNSState &state,
                           CRowDouble &x,CMinNSReport &rep)
  {
   CMinNS::MinNSResults(state,x,rep);
  }
//+------------------------------------------------------------------+
//| Buffered implementation of MinNSResults() which uses pre-        |
//| allocated  buffer to store X[]. If buffer size is too small, it  |
//| resizes buffer. It is intended to be used in the inner cycles of |
//| performance critical algorithms where array reallocation penalty |
//| is too large to be ignored.                                      |
//+------------------------------------------------------------------+
void CAlglib::MinNSResultsBuf(CMinNSState &state,
                              CRowDouble &x,
                              CMinNSReport &rep)
  {
   CMinNS::MinNSResultsBuf(state,x,rep);
  }
//+------------------------------------------------------------------+
//| This subroutine restarts algorithm from new point.               |
//| All optimization parameters (including constraints) are left     |
//| unchanged.                                                       |
//| This function allows to solve multiple optimization problems     |
//| (which must have  same number of dimensions) without object      |
//| reallocation penalty.                                            |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure previously allocated with             |
//|                  MinNSCreate() call.                             |
//|   X           -  new starting point.                             |
//+------------------------------------------------------------------+
void CAlglib::MinNSRestartFrom(CMinNSState &state,CRowDouble &x)
  {
   CMinNS::MinNSRestartFrom(state,x);
  }
//+------------------------------------------------------------------+
//| BOX CONSTRAINED OPTIMIZATION WITH FAST ACTIVATION OF MULTIPLE BOX|
//| CONSTRAINTS                                                      |
//| DESCRIPTION:                                                     |
//| The subroutine minimizes function F(x) of N arguments subject to |
//| box constraints (with some of box constraints actually being     |
//| equality ones).                                                  |
//| This optimizer uses algorithm similar to that of MinBLEIC        |
//| (optimizer with general linear constraints), but presence of     |
//| box-only constraints allows us to use faster constraint          |
//| activation strategies. On large-scale problems, with multiple    |
//| constraints active at the solution, this optimizer can be several|
//| times faster than BLEIC.                                         |
//| REQUIREMENTS:                                                    |
//|   * user must provide function value and gradient                |
//|   * starting point X0 must be feasible or not too far away from  |
//|     the feasible set                                             |
//|   * grad(f) must be Lipschitz continuous on a level set:         |
//|               L = { x : f(x) <= f(x0) }                          |
//|   * function must be defined everywhere on the feasible set F    |
//| USAGE:                                                           |
//| Constrained optimization if far more complex than the            |
//| unconstrained one. Here we give very brief outline of the BC     |
//| optimizer. We strongly recommend you to read examples in the     |
//| ALGLIB Reference Manual and to read ALGLIB User Guide on         |
//| optimization, which is available at                              |
//|         http://www.alglib.net/optimization/                      |
//| 1. User initializes algorithm state with MinBCCreate() call      |
//| 2. USer adds box constraints by calling MinBCSetBC() function.   |
//| 3. User sets stopping conditions with MinBCSetCond().            |
//| 4. User calls MinBCOptimize() function which takes algorithm     |
//|    state and pointer (delegate, etc.) to callback function which |
//|    calculates F / G.                                             |
//| 5. User calls MinBCResults() to get solution                     |
//| 6. Optionally user may call MinBCRestartFrom() to solve another  |
//|    problem with same N but another starting point.               |
//|    MinBCRestartFrom() allows to reuse already initialized        |
//|    structure.                                                    |
//| INPUT PARAMETERS:                                                |
//|   N        -  problem dimension, N > 0:                          |
//|               * if given, only leading N elements of X are used  |
//|               * if not given, automatically determined from size |
//|                 ofX                                              |
//|   X        -  starting point, array[N]:                          |
//|               * it is better to set X to a feasible point        |
//|               * but X can be infeasible, in which case algorithm |
//|                 will try to find feasible point first, using X as|
//|                 initial approximation.                           |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure stores algorithm state                   |
//+------------------------------------------------------------------+
void CAlglib::MinBCCreate(int n,CRowDouble &x,CMinBCState &state)
  {
   CMinBC::MinBCCreate(n,x,state);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinBCCreate(CRowDouble &x,CMinBCState &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinBC::MinBCCreate(n,x,state);
  }
//+------------------------------------------------------------------+
//| The subroutine is finite difference variant of MinBCCreate(). It |
//| uses finite differences in order to differentiate target function|
//| Description below contains information which is specific to  this|
//| function only. We recommend to read comments on MinBCCreate() in |
//| order to get more information about creation of BC optimizer.    |
//| INPUT PARAMETERS:                                                |
//|   N        -  problem dimension, N > 0:                          |
//|               * if given, only leading N elements of X are used  |
//|               * if not given, automatically determined from size |
//|                 of X                                             |
//|   X        -  starting point, array[0..N - 1].                   |
//|   DiffStep -  differentiation step, > 0                          |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure which stores algorithm state             |
//| NOTES:                                                           |
//|   1. algorithm uses 4-point central formula for differentiation. |
//|   2. differentiation step along I-th axis is equal to            |
//|      DiffStep*S[I] where S[] is scaling vector which can be set  |
//|      by MinBCSetScale() call.                                    |
//| 3. we recommend you to use moderate values of  differentiation   |
//|    step. Too large step will result in too large truncation      |
//|    errors, while too small step will result in too large         |
//|    numerical errors. 1.0E-6 can be good value to start with.     |
//| 4. Numerical differentiation is very inefficient - one gradient  |
//|    calculation needs 4*N function evaluations. This function will|
//|    work for any N - either small(1...10), moderate(10...100) or  |
//|    large(100...). However, performance penalty will be too severe|
//|    for any N's except for small ones.                            |
//|    We should also say that code which relies on numerical        |
//|    differentiation is less robust and precise. CG needs exact    |
//|    gradient values. Imprecise gradient may slow down convergence,|
//|    especially on highly nonlinear problems.                      |
//|    Thus we recommend to use this function for fast prototyping on|
//|    small-dimensional problems only, and to implement analytical  |
//|    gradient as soon as possible.                                 |
//+------------------------------------------------------------------+
void CAlglib::MinBCCreateF(int n,CRowDouble &x,
                           double diffstep,
                           CMinBCState &state)
  {
   CMinBC::MinBCCreateF(n,x,diffstep,state);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinBCCreateF(CRowDouble &x,
                           double diffstep,
                           CMinBCState &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinBC::MinBCCreateF(n,x,diffstep,state);
  }
//+------------------------------------------------------------------+
//| This function sets boundary constraints for BC optimizer.        |
//| Boundary constraints are inactive by default (after initial      |
//| creation). They are preserved after algorithm restart with       |
//| MinBCRestartFrom().                                              |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure stores algorithm state                |
//|   BndL        -  lower bounds, array[N]. If some (all) variables |
//|                  are unbounded, you may specify very small number|
//|                  or -INF.                                        |
//|   BndU        -  upper bounds, array[N]. If some (all) variables |
//|                  are unbounded, you may specify very large number|
//|                  or +INF.                                        |
//| NOTE 1: it is possible to specify BndL[i] = BndU[i]. In this case|
//|         I-th variable will be "frozen" at X[i] = BndL[i]=BndU[i].|
//| NOTE 2: this solver has following useful properties:             |
//|         * bound constraints are always satisfied exactly         |
//|         * function is evaluated only INSIDE area specified by    |
//|           bound constraints, even when numerical differentiation |
//|           is used (algorithm adjusts nodes according to boundary |
//|           constraints)                                           |
//+------------------------------------------------------------------+
void CAlglib::MinBCSetBC(CMinBCState &state,CRowDouble &bndl,
                         CRowDouble &bndu)
  {
   CMinBC::MinBCSetBC(state,bndl,bndu);
  }
//+------------------------------------------------------------------+
//| This function sets stopping conditions for the optimizer.        |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure which stores algorithm state          |
//|   EpsG        -  >= 0. The subroutine finishes its work if the   |
//|                  condition | v | < EpsG is satisfied, where:     |
//|                  * | . | means Euclidian norm                    |
//|                  * v - scaled gradient vector, v[i] = g[i] * s[i]|
//|                  * g - gradient                                  |
//|                  * s - scaling coefficients set by MinBCSetScale |
//|   EpsF        -  >= 0. The subroutine finishes its work if on    |
//|                  k+1-th iteration the condition                  |
//|   | F(k + 1) - F(k) | <= EpsF * max{ | F(k) |, | F(k + 1) |, 1}  |
//|                  is satisfied.                                   |
//|   EpsX        -  >= 0. The subroutine finishes its work if on    |
//|                  k+1-th iteration the condition | v | <= EpsX is |
//|                  fulfilled, where:                               |
//|                  * | . | means Euclidian norm                    |
//|                  * v - scaled step vector, v[i] = dx[i] / s[i]   |
//|                  * dx - step vector, dx = X(k + 1) - X(k)        |
//|                  * s - scaling coefficients set by MinBCSetScale |
//|   MaxIts      -  maximum number of iterations. If MaxIts = 0, the|
//|                  number of iterations is unlimited.              |
//| Passing EpsG = 0, EpsF = 0 and EpsX = 0 and MaxIts = 0           |
//| (simultaneously) will lead to automatic stopping criterion       |
//| selection.                                                       |
//| NOTE: when SetCond() called with non-zero MaxIts, BC solver may  |
//|       perform slightly more than MaxIts iterations. I.e., MaxIts |
//|       sets non-strict limit on iterations count.                 |
//+------------------------------------------------------------------+
void CAlglib::MinBCSetCond(CMinBCState &state,double epsg,
                           double epsf,double epsx,int maxits)
  {
   CMinBC::MinBCSetCond(state,epsg,epsf,epsx,maxits);
  }
//+------------------------------------------------------------------+
//| This function sets scaling coefficients for BC optimizer.        |
//| ALGLIB optimizers use scaling matrices to test stopping          |
//| conditions (step size and gradient are scaled before comparison  |
//| with tolerances). Scale of the I-th variable is a translation    |
//| invariant measure of:                                            |
//|   a) "how large" the variable is                                 |
//|   b) how large the step should be to make significant changes in |
//|      the function                                                |
//| Scaling is also used by finite difference variant of the         |
//| optimizer - step along I-th axis is equal to DiffStep*S[I].      |
//| In most optimizers (and in the BC too) scaling is NOT a form of  |
//| preconditioning. It just affects stopping conditions. You should |
//| set preconditioner by separate call to one of the MinBCSetPrec...|
//| functions.                                                       |
//| There is a special preconditioning mode, however, which uses     |
//| scaling coefficients to form diagonal preconditioning matrix. You|
//| can turn this mode on, if you want. But you should understand    |
//| that scaling is not the same thing as preconditioning - these are|
//| two different, although related forms of tuning solver.          |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure stores algorithm state                |
//|   S           -  array[N], non-zero scaling coefficients S[i] may|
//|                  be negative, sign doesn't matter.               |
//+------------------------------------------------------------------+
void CAlglib::MinBCSetScale(CMinBCState &state,CRowDouble &s)
  {
   CMinBC::MinBCSetScale(state,s);
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: preconditioning is turned off|
//| INPUT PARAMETERS:                                                |
//|   State       -  structure which stores algorithm state          |
//+------------------------------------------------------------------+
void CAlglib::MinBCSetPrecDefault(CMinBCState &state)
  {
   CMinBC::MinBCSetPrecDefault(state);
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: diagonal of approximate      |
//| Hessian is used.                                                 |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure which stores algorithm state          |
//|   D           -  diagonal of the approximate Hessian,            |
//|                  array[0..N - 1], (if larger, only leading N     |
//|                  elements are used).                             |
//| NOTE 1: D[i] should be positive. Exception will be thrown        |
//|         otherwise.                                               |
//| NOTE 2: you should pass diagonal of approximate Hessian - NOT ITS|
//|         INVERSE.                                                 |
//+------------------------------------------------------------------+
void CAlglib::MinBCSetPrecDiag(CMinBCState &state,CRowDouble &d)
  {
   CMinBC::MinBCSetPrecDiag(state,d);
  }
//+------------------------------------------------------------------+
//| Modification of the preconditioner: scale - based diagonal       |
//| preconditioning.                                                 |
//| This preconditioning mode can be useful when you don't have      |
//| approximate diagonal of Hessian, but you know that your variables|
//| are badly scaled (for example, one variable is in [1, 10], and   |
//| another in [1000, 100000]), and most part of the ill-conditioning|
//| comes from different scales of vars.                             |
//| In this case simple scale-based preconditioner, with             |
//|      H[i] = 1/(s[i]^2), can greatly improve convergence.         |
//| IMPRTANT:  you should set scale of your variables  with          |
//|            MinBCSetScale() call (before or after                 |
//|            MinBCSetPrecScale() call). Without knowledge of the   |
//|            scale of your variables scale-based preconditioner    |
//|            will be just unit matrix.                             |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm state             |
//+------------------------------------------------------------------+
void CAlglib::MinBCSetPrecScale(CMinBCState &state)
  {
   CMinBC::MinBCSetPrecScale(state);
  }
//+------------------------------------------------------------------+
//| This function turns on / off reporting.                          |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure which stores algorithm state          |
//|   NeedXRep    -  whether iteration reports are needed or not     |
//| If NeedXRep is True, algorithm will call rep() callback function |
//| if it is provided to MinBCOptimize().                            |
//+------------------------------------------------------------------+
void CAlglib::MinBCSetXRep(CMinBCState &state,bool needxrep)
  {
   CMinBC::MinBCSetXRep(state,needxrep);
  }
//+------------------------------------------------------------------+
//| This function sets maximum step length                           |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure which stores algorithm state          |
//|   StpMax      -  maximum step length, >= 0. Set StpMax to 0.0,   |
//|                  if you don't want to limit step length.         |
//| Use this subroutine when you optimize target function which      |
//| contains exp() or other fast growing functions, and optimization |
//| algorithm makes too large steps which lead to overflow. This     |
//| function allows us to reject steps that are too large (and       |
//| therefore expose us to the possible overflow) without actually   |
//| calculating function value at the x + stp*d.                     |
//+------------------------------------------------------------------+
void CAlglib::MinBCSetStpMax(CMinBCState &state,double stpmax)
  {
   CMinBC::MinBCSetStpMax(state,stpmax);
  }
//+------------------------------------------------------------------+
//| This function provides reverse communication interface           |
//| Reverse communication interface is not documented or recommended |
//| to use. See below for functions which provide better documented  |
//| API                                                              |
//+------------------------------------------------------------------+
bool CAlglib::MinBCIteration(CMinBCState &state)
  {
   return(CMinBC::MinBCIteration(state));
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|   fvec        -  callback which calculates function vector fi[]  |
//|                  at given point x                                |
//|   jac         -  callback which calculates function vector fi[]  |
//|                  and Jacobian jac at given point x               |
//|   rep         -  optional callback which is called after each    |
//|                  iteration can be null                           |
//|   obj         -  optional object which is passed to func/grad/   |
//|                  hess/jac/rep can be null                        |
//| NOTES:                                                           |
//| 1. This function has two different implementations: one which    |
//|    uses  exact (analytical) user-supplied Jacobian, and one which|
//|    uses  only  function vector and numerically  differentiates   |
//|    function  in  order  to  obtain gradient.                     |
//|    Depending  on  the  specific  function  used to create        |
//|    optimizer object you should choose appropriate variant of     |
//|    MinBCOptimize() -  one  which accepts function AND Jacobian or|
//|    one which accepts ONLY function.                              |
//|    Be careful to choose variant of MinBCOptimize()  which        |
//|    corresponds  to your optimization scheme! Table below lists   |
//|    different combinations of callback (function/gradient) passed |
//|    to MinBCOptimize() and specific function used to create       |
//|    optimizer.                                                    |
//|                     |         USER PASSED TO MinBCOptimize()     |
//|   CREATED WITH      |  function only   |  function and gradient  |
//|   ------------------------------------------------------------   |
//|   MinBCCreateF()   |     works               FAILS               |
//|   MinBCCreate()    |     FAILS               works               |
//| Here "FAILS" denotes inappropriate combinations  of  optimizer   |
//| creation function  and  MinBCOptimize()  version.  Attemps  to   |
//| use  such combination will lead to exception. Either  you  did   |
//| not pass gradient when it WAS needed or you passed gradient when |
//| it was NOT needed.                                               |
//+------------------------------------------------------------------+
void CAlglib::MinBCOptimize(CMinBCState &state,CNDimensional_Func &func,
                            CNDimensional_Rep &rep,CObject &obj)
  {
//--- check
   if(!CAp::Assert(GetPointer(func)!=NULL,"ALGLIB: error in 'MinBCOptimize()' (func is null)"))
      return;

//--- cycle
   while(MinBCIteration(state))
     {
      if(state.m_needf)
        {
         func.Func(state.m_x,state.m_f,obj);
         continue;
        }
      if(state.m_xupdated)
        {
         if(GetPointer(rep)!=NULL)
            rep.Rep(state.m_x,state.m_f,obj);
         continue;
        }
      CAp::Assert(false,"ALGLIB: error in 'MinBCOptimize' (some derivatives were not provided?)");
      break;
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::MinBCOptimize(CMinBCState &state,CNDimensional_Grad &grad,
                            CNDimensional_Rep &rep,CObject &obj)
  {
//--- check
   if(!CAp::Assert(GetPointer(grad)!=NULL,"ALGLIB: error in 'MinBCOptimize()' (grad is null)"))
      return;

//--- cycle
   while(MinBCIteration(state))
     {
      if(state.m_needfg)
        {
         grad.Grad(state.m_x,state.m_f,state.m_g,obj);
         continue;
        }
      if(state.m_xupdated)
        {
         if(GetPointer(rep)!=NULL)
            rep.Rep(state.m_x,state.m_f,obj);
         continue;
        }
      CAp::Assert(false,"ALGLIB: error in 'MinBCOptimize' (some derivatives were not provided?)");
      break;
     }
  }
//+------------------------------------------------------------------+
//| This function activates / deactivates verification of the user - |
//| supplied analytic gradient.                                      |
//| Upon activation of this option OptGuard integrity checker        |
//| performs numerical differentiation of your target function at    |
//| the initial point (note: future versions may also perform check  |
//| at the final point) and compares numerical gradient with analytic|
//| one provided by you.                                             |
//| If difference is too large, an error flag is set and optimization|
//| session continues. After optimization session is over, you can   |
//| retrieve the report which stores both gradients and specific     |
//| components highlighted as suspicious by the OptGuard.            |
//| The primary OptGuard report can be retrieved with                |
//| MinBCOptGuardResults().                                          |
//| IMPORTANT: gradient check is a high - overhead option which will |
//| cost you about 3*N additional function evaluations. In many cases|
//| it may cost as much as the rest of the optimization session.     |
//| YOU SHOULD NOT USE IT IN THE PRODUCTION CODE UNLESS YOU WANT TO  |
//| CHECK DERIVATIVES PROVIDED BY SOME THIRD PARTY.                  |
//| NOTE: unlike previous incarnation of the gradient checking code, |
//|       OptGuard does NOT interrupt optimization even if it        |
//|       discovers bad gradient.                                    |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure used to store algorithm state         |
//|   TestStep    -  verification step used for numerical            |
//|                  differentiation:                                |
//|                  * TestStep = 0 turns verification off           |
//|                  * TestStep > 0 activates verification           |
//|                  You should carefully choose TestStep. Value     |
//|                  which is too large (so large that function      |
//|                  behavior is non-cubic at this scale) will lead  |
//|                  to false alarms. Too short step will result in  |
//|                  rounding errors dominating numerical derivative.|
//| You may use different step for different parameters by means of  |
//| setting scale with MinBCSetScale().                              |
//| === EXPLANATION ================================================ |
//| In order to verify gradient algorithm performs following steps:  |
//|   * two trial steps are made to X[i] - TestStep * S[i] and       |
//|     X[i] + TestStep * S[i], where X[i] is i-th component of the  |
//|     initial point and S[i] is a scale of i-th parameter          |
//|   * F(X) is evaluated at these trial points                      |
//|   * we perform one more evaluation in the middle point of the    |
//|     interval                                                     |
//|   * we build cubic model using function values and derivatives   |
//|     at trial points and we compare its prediction with actual    |
//|     value in the middle point                                    |
//+------------------------------------------------------------------+
void CAlglib::MinBCOptGuardGradient(CMinBCState &state,double teststep)
  {
   CMinBC::MinBCOptGuardGradient(state,teststep);
  }
//+------------------------------------------------------------------+
//| This  function  activates / deactivates nonsmoothness monitoring |
//| option of the  OptGuard  integrity  checker. Smoothness  monitor |
//| silently observes solution process and tries to detect ill-posed |
//| problems, i.e. ones with:                                        |
//|   a) discontinuous target function(non - C0)                     |
//|   b) nonsmooth     target function(non - C1)                     |
//| Smoothness monitoring does NOT interrupt optimization  even if it|
//| suspects that your problem is nonsmooth. It just sets            |
//| corresponding flags in the OptGuard report which can be retrieved|
//| after optimization is over.                                      |
//| Smoothness monitoring is a moderate overhead option which often  |
//| adds less than 1 % to the optimizer running time. Thus, you can  |
//| use it even for large scale problems.                            |
//| NOTE: OptGuard does  NOT guarantee that it will  always  detect  |
//|       C0 / C1 continuity violations.                             |
//| First, minor errors are hard to  catch - say, a 0.0001 difference|
//| in the model values at two sides of the gap may be due to        |
//| discontinuity of the model - or simply because the model has     |
//| changed.                                                         |
//| Second, C1 - violations  are  especially  difficult  to  detect  |
//| in  a noninvasive way. The optimizer usually  performs  very     |
//| short  steps near the nonsmoothness, and differentiation  usually|
//| introduces  a lot of numerical noise.  It  is  hard  to  tell    |
//| whether  some  tiny discontinuity in the slope is due to real    |
//| nonsmoothness or just  due to numerical noise alone.             |
//| Our top priority was to avoid false positives, so in some rare   |
//| cases minor errors may went unnoticed(however, in most cases they|
//| can be spotted with restart from different initial point).       |
//| INPUT PARAMETERS:                                                |
//|   State       -  algorithm state                                 |
//|   Level       -  monitoring level:                               |
//|                  * 0 - monitoring is disabled                    |
//|                  * 1 - noninvasive low - overhead monitoring;    |
//|                  function values and / or gradients are recorded,|
//|                  but OptGuard does not try to perform additional |
//|                  evaluations  in  order  to get more information |
//|                  about suspicious locations.                     |
//| === EXPLANATION ================================================ |
//| One  major  source  of  headache  during  optimization  is  the  |
//| possibility of the coding errors in the target function /        |
//| constraints (or their gradients). Such  errors   most   often    |
//| manifest   themselves  as  discontinuity  or nonsmoothness of the|
//| target / constraints.                                            |
//| Another frequent situation is when you try to optimize something |
//| involving lots of min() and max() operations, i.e. nonsmooth     |
//| target. Although not  a coding error, it is nonsmoothness anyway-|
//| and smooth  optimizers  usually stop right after encountering    |
//| nonsmoothness, well before reaching solution.                    |
//| OptGuard integrity checker helps you to catch such situations:   |
//| it monitors function values / gradients being passed  to  the    |
//| optimizer and tries  to errors. Upon discovering suspicious pair |
//| of points it  raises appropriate flag (and allows you to continue|
//| optimization). When optimization is done, you can study OptGuard |
//| result.                                                          |
//+------------------------------------------------------------------+
void CAlglib::MinBCOptGuardSmoothness(CMinBCState &state,int level=1)
  {
   CMinBC::MinBCOptGuardSmoothness(state,level);
  }
//+------------------------------------------------------------------+
//| Results of OptGuard integrity check, should be called  after     |
//| optimization session is over.                                    |
//| === PRIMARY REPORT ============================================= |
//| OptGuard performs several checks which are intended to catch     |
//| common errors in the implementation of nonlinear function /      |
//| gradient:                                                        |
//|   * incorrect analytic gradient                                  |
//|   * discontinuous(non - C0) target functions(constraints)        |
//|   * nonsmooth(non - C1) target functions(constraints)            |
//| Each of these checks is activated with appropriate function:     |
//|   * MinBCOptGuardGradient() for gradient verification            |
//|   * MinBCOptGuardSmoothness() for C0 / C1 checks                 |
//| Following flags are set when these errors are suspected:         |
//|   * rep.badgradsuspected, and additionally:                      |
//|      * rep.badgradvidx for specific variable (gradient element)  |
//|        suspected                                                 |
//|      * rep.badgradxbase, a point where gradient is tested        |
//|      * rep.badgraduser, user - provided gradient(stored  as  2D  |
//|        matrix with single row in order to make report structure  |
//|        compatible  with  more complex optimizers like MinNLC or  |
//|        MinLM)                                                    |
//|      * rep.badgradnum,  reference   gradient   obtained   via    |
//|        numerical differentiation (stored as 2D matrix with single|
//|        row in order to make report structure compatible with more|
//|        complex optimizers like MinNLC or MinLM)                  |
//|   * rep.nonc0suspected                                           |
//|   * rep.nonc1suspected                                           |
//| === ADDITIONAL REPORTS / LOGS ================================== |
//| Several different tests are performed to catch C0 / C1 errors,   |
//| you can find out specific test signaled error by looking to:     |
//|   * rep.nonc0test0positive, for non - C0 test #0                 |
//|   * rep.nonc1test0positive, for non - C1 test #0                 |
//|   * rep.nonc1test1positive, for non - C1 test #1                 |
//| Additional information (including line search logs) can  be      |
//| obtained by means of:                                            |
//|   * MinBCOptGuardNonC1Test0Results()                             |
//|   * MinBCOptGuardNonC1Test1Results()                             |
//| which return detailed error reports, specific points where       |
//| discontinuities were found, and so on.                           |
//| ================================================================ |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm state                                    |
//| OUTPUT PARAMETERS:                                               |
//|   Rep      -  generic OptGuard report; more  detailed  reports   |
//|               can  be retrieved with other functions.            |
//| NOTE: false negatives (nonsmooth problems are not identified as  |
//|       nonsmooth ones) are possible although unlikely.            |
//| The reason  is  that  you  need  to  make several evaluations    |
//| around nonsmoothness in order to accumulate  enough  information |
//| about function curvature. Say, if you start right from the       |
//| nonsmooth point, optimizer simply won't get enough data to       |
//| understand what is going wrong before it terminates due to abrupt|
//| changes in the  derivative. It is also  possible  that  "unlucky"|
//| step  will  move  us  to  the termination too quickly.           |
//| Our current approach is to have less than 0.1 %  false  negatives|
//| in our test examples(measured  with  multiple  restarts  from    |
//| random points), and to have exactly 0 % false positives.         |
//+------------------------------------------------------------------+
void CAlglib::MinBCOptGuardResults(CMinBCState &state,COptGuardReport &rep)
  {
   CMinBC::MinBCOptGuardResults(state,rep);
  }
//+------------------------------------------------------------------+
//|Detailed results of the OptGuard integrity check for nonsmoothness|
//| test #0                                                          |
//| Nonsmoothness (non - C1) test #0 studies  function  values (not  |
//| gradient!) obtained during line searches and monitors  behavior  |
//| of  the  directional derivative estimate.                        |
//| This test is less powerful than test #1, but it does  not  depend|
//| on  the gradient values and thus it is more robust against       |
//| artifacts introduced by numerical differentiation.               |
//| Two reports are returned:                                        |
//|  *a "strongest" one, corresponding  to  line   search  which   |
//|     had  highest value of the nonsmoothness indicator            |
//|  *a "longest" one, corresponding to line search which had more |
//|     function evaluations, and thus is more detailed              |
//| In both cases following fields are returned:                     |
//|   * positive - is TRUE  when test flagged suspicious point;      |
//|                   FALSE  if  test did not notice anything (in the|
//|                   latter cases fields below are empty).          |
//|   * x0[], d[] - arrays of length N which store initial point and |
//|                 direction for line search (d[] can be normalized,|
//|                 but does not have to)                            |
//|   * stp[], f[] - arrays of length CNT which store step lengths   |
//|                 and  function values at these points; f[i] is    |
//|                 evaluated in x0 + stp[i]*d.                      |
//|   * stpidxa, stpidxb - we  suspect  that  function  violates  C1 |
//|                 continuity between steps #stpidxa and #stpidxb   |
//|                 (usually we have  stpidxb = stpidxa + 3, with    |
//|                 most  likely  position of the violation  between |
//|                 stpidxa + 1 and stpidxa + 2.                     |
//| ================================================================ |
//| = SHORTLY SPEAKING: build a 2D plot of (stp, f) and look at it - |
//| =                   you will see where C1 continuity is violated.|
//| ================================================================ |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm state                                    |
//| OUTPUT PARAMETERS:                                               |
//|   strrep  - C1 test #0 "strong" report                         |
//|   lngrep  - C1 test #0 "long" report                           |
//+------------------------------------------------------------------+
void CAlglib::MinBCOptGuardNonC1Test0Results(CMinBCState &state,
                                             COptGuardNonC1Test0Report &strrep,
                                             COptGuardNonC1Test0Report &lngrep)
  {
   CMinBC::MinBCOptGuardNonC1Test0Results(state,strrep,lngrep);
  }
//+------------------------------------------------------------------+
//| Detailed results of the OptGuard integrity check for             |
//| nonsmoothness test #1                                            |
//| Nonsmoothness (non-C1) test #1 studies individual components of  |
//| the gradient computed during line search.                        |
//| When precise analytic gradient is provided this test is more     |
//| powerful than test #0  which  works  with  function  values  and |
//| ignores user-provided gradient. However, test #0 becomes more    |
//| powerful when numerical differentiation is employed (in such     |
//| cases test #1 detects higher levels of numerical noise and       |
//| becomes too conservative).                                       |
//| This test also tells specific components of the gradient which   |
//| violate C1 continuity, which makes it more informative than #0,  |
//| which just tells that continuity is violated.                    |
//| Two reports are returned:                                        |
//|  *a "strongest" one, corresponding to line search which had    |
//|     highest value of the nonsmoothness indicator                 |
//|  *a "longest" one, corresponding to line search which had more |
//|     function evaluations, and thus is more detailed              |
//| In both cases following fields are returned:                     |
//|   * positive - is TRUE  when test flagged suspicious point;      |
//|                   FALSE if test did not notice anything (in the  |
//|                   latter cases fields below are empty).          |
//|   * vidx - is an index of the variable in [0, N) with nonsmooth  |
//|                  derivative                                      |
//|   * x0[], d[] - arrays of length N which store initial point  and|
//|                  direction for line search(d[] can be normalized,|
//|                  but does not have to)                           |
//|   * stp[], g[] - arrays of length CNT which store step lengths   |
//|                  and  gradient values at these points; g[i] is   |
//|                  evaluated in x0 + stp[i]*d and contains vidx-th |
//|                  component of the gradient.                      |
//|   * stpidxa, stpidxb - we  suspect  that  function  violates  C1 |
//|                  continuity between steps #stpidxa and #stpidxb  |
//|                  (usually we have  stpidxb = stpidxa + 3, with   |
//|                  most likely position of the violation  between  |
//|                  stpidxa + 1 and stpidxa + 2.                    |
//| ================================================================ |
//| = SHORTLY SPEAKING: build a 2D plot of (stp, f) and look at it - |
//| =                   you will see where C1 continuity is violated.|
//| ================================================================ |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm state                                    |
//| OUTPUT PARAMETERS:                                               |
//|   strrep  - C1 test #1 "strong" report                         |
//|   lngrep  - C1 test #1 "long" report                           |
//+------------------------------------------------------------------+
void CAlglib::MinBCOptGuardNonC1Test1Results(CMinBCState &state,
                                             COptGuardNonC1Test1Report &strrep,
                                             COptGuardNonC1Test1Report &lngrep)
  {
   CMinBC::MinBCOptGuardNonC1Test1Results(state,strrep,lngrep);
  }
//+------------------------------------------------------------------+
//| BC results                                                       |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm state                                    |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[0..N - 1], solution                          |
//|   Rep      -  optimization report. You should check              |
//|               Rep.TerminationType in order to distinguish        |
//|               successful  termination  from unsuccessful one:    |
//|      * -8     internal integrity control  detected  infinite or  |
//|               NAN  values   in   function / gradient.   Abnormal |
//|               termination signalled.                             |
//|      * -3     inconsistent constraints.                          |
//|      *  1     relative function improvement is no more than EpsF.|
//|      *  2     scaled step is no more than EpsX.                  |
//|      *  4     scaled gradient norm is no more than EpsG.         |
//|      *  5     MaxIts steps was taken                             |
//|      *  8     terminated by user who called                      |
//|               MinBCRequestTermination().                         |
//| X contains point which was "current accepted" when termination   |
//| request was submitted. More information about fields of this     |
//| structure can be found in the comments on MinBCReport datatype.  |
//+------------------------------------------------------------------+
void CAlglib::MinBCResults(CMinBCState &state,CRowDouble &x,
                           CMinBCReport &rep)
  {
   CMinBC::MinBCResults(state,x,rep);
  }
//+------------------------------------------------------------------+
//| BC results                                                       |
//| Buffered implementation of MinBCResults() which uses pre -       |
//| allocated buffer to store X[]. If buffer size is too small, it   |
//| resizes buffer. It is intended to be used in the inner cycles of |
//| performance critical algorithms where array reallocation penalty |
//| is too large to be ignored.                                      |
//+------------------------------------------------------------------+
void CAlglib::MinBCResultsBuf(CMinBCState &state,CRowDouble &x,
                              CMinBCReport &rep)
  {
   CMinBC::MinBCResultsBuf(state,x,rep);
  }
//+------------------------------------------------------------------+
//| This subroutine restarts algorithm from new point.               |
//| All optimization parameters (including constraints) are left     |
//| unchanged.                                                       |
//| This function allows to solve multiple optimization problems     |
//| (which must have  same number of dimensions) without object      |
//| reallocation penalty.                                            |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure previously allocated with MinBCCreate    |
//|               call.                                              |
//|   X        -  new starting point.                                |
//+------------------------------------------------------------------+
void CAlglib::MinBCRestartFrom(CMinBCState &state,CRowDouble &x)
  {
   CMinBC::MinBCRestartFrom(state,x);
  }
//+------------------------------------------------------------------+
//| This subroutine submits request for termination of running       |
//| optimizer. It should be called from user-supplied callback when  |
//| user decides that it is time to "smoothly" terminate optimization|
//| process. As result, optimizer stops at point which was "current  |
//| accepted" when termination request was submitted and returns     |
//| error code 8 (successful termination).                           |
//| INPUT PARAMETERS:                                                |
//|   State    -  optimizer structure                                |
//| NOTE: after request for termination optimizer may perform several|
//|       additional calls to user-supplied callbacks. It does NOT   |
//|       guarantee to stop immediately - it just guarantees that    |
//|       these additional calls will be discarded later.            |
//| NOTE: calling this function on optimizer which is NOT running    |
//|       will have no effect.                                       |
//| NOTE: multiple calls to this function are possible. First call is|
//|       counted, subsequent calls are silently ignored.            |
//+------------------------------------------------------------------+
void CAlglib::MinBCRequestTermination(CMinBCState &state)
  {
   CMinBC::MinBCRequestTermination(state);
  }
//+------------------------------------------------------------------+
//| Obsolete function, use MinLBFGSSetPrecDefault() instead.         |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSSetDefaultPreconditioner(CMinLBFGSStateShell &state)
  {
   CMinComp::MinLBFGSSetDefaultPreconditioner(state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Obsolete function, use MinLBFGSSetCholeskyPreconditioner()       |
//| instead.                                                         |
//+------------------------------------------------------------------+
void CAlglib::MinLBFGSSetCholeskyPreconditioner(CMinLBFGSStateShell &state,
                                                CMatrixDouble &p,bool IsUpper)
  {
   CMinComp::MinLBFGSSetCholeskyPreconditioner(state.GetInnerObj(),p,IsUpper);
  }
//+------------------------------------------------------------------+
//| This is obsolete function which was used by previous version of  |
//| the  BLEIC optimizer. It does nothing in the current version of  |
//| BLEIC.                                                           |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetBarrierWidth(CMinBLEICStateShell &state,
                                      const double mu)
  {
   CMinComp::MinBLEICSetBarrierWidth(state.GetInnerObj(),mu);
  }
//+------------------------------------------------------------------+
//| This is obsolete function which was used by previous version of  |
//| the  BLEIC optimizer. It does nothing in the current version of  |
//| BLEIC.                                                           |
//+------------------------------------------------------------------+
void CAlglib::MinBLEICSetBarrierDecay(CMinBLEICStateShell &state,
                                      const double mudecay)
  {
   CMinComp::MinBLEICSetBarrierDecay(state.GetInnerObj(),mudecay);
  }
//+------------------------------------------------------------------+
//| Obsolete optimization algorithm.                                 |
//| Was replaced by MinBLEIC subpackage.                             |
//+------------------------------------------------------------------+
void CAlglib::MinASACreate(const int n,double &x[],double &bndl[],
                           double &bndu[],CMinASAStateShell &state)
  {
   CMinComp::MinASACreate(n,x,bndl,bndu,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Obsolete optimization algorithm.                                 |
//| Was replaced by MinBLEIC subpackage.                             |
//+------------------------------------------------------------------+
void CAlglib::MinASACreate(double &x[],double &bndl[],double &bndu[],
                           CMinASAStateShell &state)
  {
//--- check
   if((CAp::Len(x)!=CAp::Len(bndl)) || (CAp::Len(x)!=CAp::Len(bndu)))
     {
      Print("Error while calling 'minasacreate': looks like one of arguments has wrong size");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CMinComp::MinASACreate(n,x,bndl,bndu,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Obsolete optimization algorithm.                                 |
//| Was replaced by MinBLEIC subpackage.                             |
//+------------------------------------------------------------------+
void CAlglib::MinASASetCond(CMinASAStateShell &state,const double epsg,
                            const double epsf,const double epsx,const int maxits)
  {
   CMinComp::MinASASetCond(state.GetInnerObj(),epsg,epsf,epsx,maxits);
  }
//+------------------------------------------------------------------+
//| Obsolete optimization algorithm.                                 |
//| Was replaced by MinBLEIC subpackage.                             |
//+------------------------------------------------------------------+
void CAlglib::MinASASetXRep(CMinASAStateShell &state,const bool needxrep)
  {
   CMinComp::MinASASetXRep(state.GetInnerObj(),needxrep);
  }
//+------------------------------------------------------------------+
//| Obsolete optimization algorithm.                                 |
//| Was replaced by MinBLEIC subpackage.                             |
//+------------------------------------------------------------------+
void CAlglib::MinASASetAlgorithm(CMinASAStateShell &state,const int algotype)
  {
   CMinComp::MinASASetAlgorithm(state.GetInnerObj(),algotype);
  }
//+------------------------------------------------------------------+
//| Obsolete optimization algorithm.                                 |
//| Was replaced by MinBLEIC subpackage.                             |
//+------------------------------------------------------------------+
void CAlglib::MinASASetStpMax(CMinASAStateShell &state,const double stpmax)
  {
   CMinComp::MinASASetStpMax(state.GetInnerObj(),stpmax);
  }
//+------------------------------------------------------------------+
//| This function provides reverse communication interface           |
//| Reverse communication interface is not documented or recommended |
//| to use.                                                          |
//| See below for functions which provide better documented API      |
//+------------------------------------------------------------------+
bool CAlglib::MinASAIteration(CMinASAStateShell &state)
  {
   return(CMinComp::MinASAIteration(state.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear optimizer                                              |
//| These functions accept following parameters:                     |
//|     grad    -   callback which calculates function (or merit     |
//|                 function) value func and gradient grad at given  |
//|                 point x                                          |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//+------------------------------------------------------------------+
void CAlglib::MinASAOptimize(CMinASAStateShell &state,CNDimensional_Grad &grad,
                             CNDimensional_Rep &rep,bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::MinASAIteration(state))
     {
      //--- check
      if(state.GetNeedFG())
        {
         grad.Grad(state.GetInnerObj().m_x,state.GetInnerObj().m_f,state.GetInnerObj().m_g,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'minasaoptimize' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| Obsolete optimization algorithm.                                 |
//| Was replaced by MinBLEIC subpackage.                             |
//+------------------------------------------------------------------+
void CAlglib::MinASAResults(CMinASAStateShell &state,double &x[],
                            CMinASAReportShell &rep)
  {
   CMinComp::MinASAResults(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Obsolete optimization algorithm.                                 |
//| Was replaced by MinBLEIC subpackage.                             |
//+------------------------------------------------------------------+
void CAlglib::MinASAResultsBuf(CMinASAStateShell &state,double &x[],
                               CMinASAReportShell &rep)
  {
   CMinComp::MinASAResultsBuf(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| Obsolete optimization algorithm.                                 |
//| Was replaced by MinBLEIC subpackage.                             |
//+------------------------------------------------------------------+
void CAlglib::MinASARestartFrom(CMinASAStateShell &state,double &x[],
                                double &bndl[],double &bndu[])
  {
   CMinComp::MinASARestartFrom(state.GetInnerObj(),x,bndl,bndu);
  }
//+------------------------------------------------------------------+
//| Polynomial root finding.                                         |
//| This function returns all roots of the polynomial                |
//|      P(x) = a0 + a1*x + a2*x^2 + ... + an*x^n                    |
//| Both real and complex roots are returned (see below).            |
//| INPUT PARAMETERS:                                                |
//|   A        -  array[N+1], polynomial coefficients:               |
//|               * A[0] is constant term                            |
//|               * A[N] is a coefficient of X^N                     |
//|   N        -  polynomial degree                                  |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array of complex roots:                            |
//|               * for isolated real root, X[I] is strictly real:   |
//|                 IMAGE(X[I])=0                                    |
//|               * complex roots are always returned in pairs-roots |
//|                 occupy positions I and I+1, with:                |
//|                  * X[I+1]=Conj(X[I])                             |
//|                  * IMAGE(X[I]) > 0                               |
//|                  * IMAGE(X[I+1]) = -IMAGE(X[I]) < 0              |
//|               * multiple real roots may have non-zero imaginary  |
//|                 part due to roundoff errors. There is no reliable|
//|                 way to distinguish real root of multiplicity 2   |
//|                 from two complex roots in the presence of        |
//|                 roundoff errors.                                 |
//|   Rep      -  report, additional information, following fields   |
//|               are set:                                           |
//|               * Rep.MaxErr - max( |P(xi)| )  for  i=0..N-1. This |
//|                 field allows to quickly estimate "quality" of the|
//|                 roots being returned.                            |
//| NOTE: this function uses companion matrix method to find roots.  |
//|       In case internal EVD solver fails do find eigenvalues,     |
//|       exception is generated.                                    |
//| NOTE: roots are not "polished" and no matrix balancing is        |
//|       performed for them.                                        |
//+------------------------------------------------------------------+
void CAlglib::PolynomialSolve(CRowDouble &a,int n,CRowComplex &x,
                              CPolynomialSolverReport &rep)
  {
   CPolynomialSolver::PolynomialSolve(a,n,x,rep);
  }
//+------------------------------------------------------------------+
//| Dense solver.                                                    |
//| This subroutine solves a system A*x=b, where A is NxN            |
//| non-denegerate real matrix, x and b are vectors.                 |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * iterative refinement                                           |
//| * O(N^3) complexity                                              |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1], right part                        |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   return code:                                     |
//|                 * -3    A is singular, or VERY close to singular.|
//|                         X is filled by zeros in such cases.      |
//|                 * -1    N<=0 was passed                          |
//|                 *  1    task is solved (but matrix A may be      |
//|                         ill-conditioned, check R1/RInf parameters|
//|                         for condition numbers).                  |
//|     Rep     -   solver report, see below for more info           |
//|     X       -   array[0..N-1], it contains:                      |
//|                 * solution of A*x=b if A is non-singular         |
//|                   (well-conditioned or ill-conditioned, but not  |
//|                   very close to singular)                        |
//|                 * zeros, if A is singular or VERY close to       |
//|                   singular (in this case Info=-3).               |
//| SOLVER REPORT                                                    |
//| Subroutine sets following fields of the Rep structure:           |
//| * R1        reciprocal of condition number: 1/cond(A), 1-norm.   |
//| * RInf      reciprocal of condition number: 1/cond(A), inf-norm. |
//+------------------------------------------------------------------+
void CAlglib::RMatrixSolve(CMatrixDouble &a,const int n,double &b[],
                           int &info,CDenseSolverReportShell &rep,
                           double &x[])
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::RMatrixSolve(a,n,b,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver.                                                    |
//| Similar to RMatrixSolve() but solves task with multiple right    |
//| parts (where b and x are NxM matrices).                          |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * optional iterative refinement                                  |
//| * O(N^3+M*N^2) complexity                                        |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1,0..M-1], right part                 |
//|     M       -   right part size                                  |
//|     RFS     -   iterative refinement switch:                     |
//|                 * True - refinement is used.                     |
//|                   Less performance, more precision.              |
//|                 * False - refinement is not used.                |
//|                   More performance, less precision.              |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::RMatrixSolveM(CMatrixDouble &a,const int n,CMatrixDouble &b,
                            const int m,const bool rfs,int &info,
                            CDenseSolverReportShell &rep,CMatrixDouble &x)
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::RMatrixSolveM(a,n,b,m,rfs,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver.                                                    |
//| This subroutine solves a system A*X=B, where A is NxN            |
//| non-denegerate real matrix given by its LU decomposition, X and  |
//| B are NxM real matrices.                                         |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * O(N^2) complexity                                              |
//| * condition number estimation                                    |
//| No iterative refinement is provided because exact form of        |
//| original matrix is not known to subroutine. Use RMatrixSolve or  |
//| RMatrixMixedSolve if you need iterative refinement.              |
//| INPUT PARAMETERS                                                 |
//|     LUA     -   array[0..N-1, ..N-1], LU decomposition, RMatrixLU|
//|                 result                                           |
//|     P       -   array[0..N-1], pivots array, RMatrixLU result    |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1], right part                        |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::RMatrixLUSolve(CMatrixDouble &lua,int &p[],const int n,
                             double &b[],int &info,
                             CDenseSolverReportShell &rep,double &x[])
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::RMatrixLUSolve(lua,p,n,b,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver.                                                    |
//| Similar to RMatrixLUSolve() but solves task with multiple right  |
//| parts (where b and x are NxM matrices).                          |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * O(M*N^2) complexity                                            |
//| * condition number estimation                                    |
//| No iterative refinement is provided because exact form of        |
//| original matrix is not known to subroutine. Use RMatrixSolve or  |
//| RMatrixMixedSolve if you need iterative refinement.              |
//| INPUT PARAMETERS                                                 |
//|     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU|
//|                 result                                           |
//|     P       -   array[0..N-1], pivots array, RMatrixLU result    |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1,0..M-1], right part                 |
//|     M       -   right part size                                  |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::RMatrixLUSolveM(CMatrixDouble &lua,int &p[],const int n,
                              CMatrixDouble &b,const int m,int &info,
                              CDenseSolverReportShell &rep,CMatrixDouble &x)
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::RMatrixLUSolveM(lua,p,n,b,m,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver.                                                    |
//| This subroutine solves a system A*x=b, where BOTH ORIGINAL A AND |
//| ITS LU DECOMPOSITION ARE KNOWN. You can use it if for some       |
//| reasons you have both A and its LU decomposition.                |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * iterative refinement                                           |
//| * O(N^2) complexity                                              |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU|
//|                 result                                           |
//|     P       -   array[0..N-1], pivots array, RMatrixLU result    |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1], right part                        |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolveM                         |
//|     Rep     -   same as in RMatrixSolveM                         |
//|     X       -   same as in RMatrixSolveM                         |
//+------------------------------------------------------------------+
void CAlglib::RMatrixMixedSolve(CMatrixDouble &a,CMatrixDouble &lua,
                                int &p[],const int n,double &b[],
                                int &info,CDenseSolverReportShell &rep,
                                double &x[])
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::RMatrixMixedSolve(a,lua,p,n,b,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver.                                                    |
//| Similar to RMatrixMixedSolve() but solves task with multiple     |
//| right parts (where b and x are NxM matrices).                    |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * iterative refinement                                           |
//| * O(M*N^2) complexity                                            |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU|
//|                 result                                           |
//|     P       -   array[0..N-1], pivots array, RMatrixLU result    |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1,0..M-1], right part                 |
//|     M       -   right part size                                  |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolveM                         |
//|     Rep     -   same as in RMatrixSolveM                         |
//|     X       -   same as in RMatrixSolveM                         |
//+------------------------------------------------------------------+
void CAlglib::RMatrixMixedSolveM(CMatrixDouble &a,CMatrixDouble &lua,
                                 int &p[],const int n,CMatrixDouble &b,
                                 const int m,int &info,
                                 CDenseSolverReportShell &rep,
                                 CMatrixDouble &x)
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::RMatrixMixedSolveM(a,lua,p,n,b,m,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixSolveM(), but for complex matrices. |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * iterative refinement                                           |
//| * O(N^3+M*N^2) complexity                                        |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1,0..M-1], right part                 |
//|     M       -   right part size                                  |
//|     RFS     -   iterative refinement switch:                     |
//|                 * True - refinement is used.                     |
//|                   Less performance, more precision.              |
//|                 * False - refinement is not used.                |
//|                   More performance, less precision.              |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::CMatrixSolveM(CMatrixComplex &a,const int n,CMatrixComplex &b,
                            const int m,const bool rfs,int &info,
                            CDenseSolverReportShell &rep,
                            CMatrixComplex &x)
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::CMatrixSolveM(a,n,b,m,rfs,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixSolve(), but for complex matrices.  |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * iterative refinement                                           |
//| * O(N^3) complexity                                              |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1], right part                        |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::CMatrixSolve(CMatrixComplex &a,const int n,complex &b[],
                           int &info,CDenseSolverReportShell &rep,
                           complex &x[])
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::CMatrixSolve(a,n,b,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixLUSolveM(), but for complex         |
//| matrices.                                                        |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * O(M*N^2) complexity                                            |
//| * condition number estimation                                    |
//| No iterative refinement is provided because exact form of        |
//| original matrix is not known to subroutine. Use CMatrixSolve or  |
//| CMatrixMixedSolve if you need iterative refinement.              |
//| INPUT PARAMETERS                                                 |
//|     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU|
//|                 result                                           |
//|     P       -   array[0..N-1], pivots array, RMatrixLU result    |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1,0..M-1], right part                 |
//|     M       -   right part size                                  |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::CMatrixLUSolveM(CMatrixComplex &lua,int &p[],const int n,
                              CMatrixComplex &b,const int m,int &info,
                              CDenseSolverReportShell &rep,CMatrixComplex &x)
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::CMatrixLUSolveM(lua,p,n,b,m,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixLUSolve(), but for complex matrices.|
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * O(N^2) complexity                                              |
//| * condition number estimation                                    |
//| No iterative refinement is provided because exact form of        |
//| original matrix is not known to subroutine. Use CMatrixSolve or  |
//| CMatrixMixedSolve if you need iterative refinement.              |
//| INPUT PARAMETERS                                                 |
//|     LUA     -   array[0..N-1,0..N-1], LU decomposition, CMatrixLU|
//|                 result                                           |
//|     P       -   array[0..N-1], pivots array, CMatrixLU result    |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1], right part                        |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::CMatrixLUSolve(CMatrixComplex &lua,int &p[],const int n,
                             complex &b[],int &info,CDenseSolverReportShell &rep,
                             complex &x[])
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::CMatrixLUSolve(lua,p,n,b,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixMixedSolveM(), but for complex      |
//| matrices.                                                        |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * iterative refinement                                           |
//| * O(M*N^2) complexity                                            |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     LUA     -   array[0..N-1,0..N-1], LU decomposition, CMatrixLU|
//|                 result                                           |
//|     P       -   array[0..N-1], pivots array, CMatrixLU result    |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1,0..M-1], right part                 |
//|     M       -   right part size                                  |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolveM                         |
//|     Rep     -   same as in RMatrixSolveM                         |
//|     X       -   same as in RMatrixSolveM                         |
//+------------------------------------------------------------------+
void CAlglib::CMatrixMixedSolveM(CMatrixComplex &a,CMatrixComplex &lua,
                                 int &p[],const int n,CMatrixComplex &b,
                                 const int m,int &info,
                                 CDenseSolverReportShell &rep,
                                 CMatrixComplex &x)
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::CMatrixMixedSolveM(a,lua,p,n,b,m,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixMixedSolve(), but for complex       |
//| matrices.                                                        |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * iterative refinement                                           |
//| * O(N^2) complexity                                              |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     LUA     -   array[0..N-1,0..N-1], LU decomposition, CMatrixLU|
//|                 result                                           |
//|     P       -   array[0..N-1], pivots array, CMatrixLU result    |
//|     N       -   size of A                                        |
//|     B       -   array[0..N-1], right part                        |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolveM                         |
//|     Rep     -   same as in RMatrixSolveM                         |
//|     X       -   same as in RMatrixSolveM                         |
//+------------------------------------------------------------------+
void CAlglib::CMatrixMixedSolve(CMatrixComplex &a,CMatrixComplex &lua,
                                int &p[],const int n,complex &b[],
                                int &info,CDenseSolverReportShell &rep,
                                complex &x[])
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::CMatrixMixedSolve(a,lua,p,n,b,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixSolveM(), but for symmetric positive|
//| definite matrices.                                               |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * O(N^3+M*N^2) complexity                                        |
//| * matrix is represented by its upper or lower triangle           |
//| No iterative refinement is provided because such partial         |
//| representation of matrix does not allow efficient calculation of |
//| extra-precise matrix-vector products for large matrices. Use     |
//| RMatrixSolve or RMatrixMixedSolve if you need iterative          |
//| refinement.                                                      |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     N       -   size of A                                        |
//|     IsUpper -   what half of A is provided                       |
//|     B       -   array[0..N-1,0..M-1], right part                 |
//|     M       -   right part size                                  |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve.                         |
//|                 Returns -3 for non-SPD matrices.                 |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixSolveM(CMatrixDouble &a,const int n,const bool IsUpper,
                              CMatrixDouble &b,const int m,int &info,
                              CDenseSolverReportShell &rep,CMatrixDouble &x)
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::SPDMatrixSolveM(a,n,IsUpper,b,m,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixSolve(), but for SPD matrices.      |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * O(N^3) complexity                                              |
//| * matrix is represented by its upper or lower triangle           |
//| No iterative refinement is provided because such partial         |
//| representation of matrix does not allow efficient calculation of |
//| extra-precise  matrix-vector products for large matrices. Use    |
//| RMatrixSolve or RMatrixMixedSolve if you need iterative          |
//| refinement.                                                      |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     N       -   size of A                                        |
//|     IsUpper -   what half of A is provided                       |
//|     B       -   array[0..N-1], right part                        |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|                 Returns -3 for non-SPD matrices.                 |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixSolve(CMatrixDouble &a,const int n,const bool IsUpper,
                             double &b[],int &info,CDenseSolverReportShell &rep,
                             double &x[])
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::SPDMatrixSolve(a,n,IsUpper,b,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixLUSolveM(), but for SPD matrices    |
//| represented by their Cholesky decomposition.                     |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * O(M*N^2) complexity                                            |
//| * condition number estimation                                    |
//| * matrix is represented by its upper or lower triangle           |
//| No iterative refinement is provided because such partial         |
//| representation of matrix does not allow efficient calculation of |
//| extra-precise  matrix-vector products for large matrices. Use    |
//| RMatrixSolve or RMatrixMixedSolve  if  you need iterative        |
//| refinement.                                                      |
//| INPUT PARAMETERS                                                 |
//|     CHA     -   array[0..N-1,0..N-1], Cholesky decomposition,    |
//|                 SPDMatrixCholesky result                         |
//|     N       -   size of CHA                                      |
//|     IsUpper -   what half of CHA is provided                     |
//|     B       -   array[0..N-1,0..M-1], right part                 |
//|     M       -   right part size                                  |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixCholeskySolveM(CMatrixDouble &cha,const int n,
                                      const bool IsUpper,CMatrixDouble &b,
                                      const int m,int &info,
                                      CDenseSolverReportShell &rep,
                                      CMatrixDouble &x)
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::SPDMatrixCholeskySolveM(cha,n,IsUpper,b,m,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixLUSolve(), but for  SPD matrices    |
//| represented by their Cholesky decomposition.                     |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * O(N^2) complexity                                              |
//| * condition number estimation                                    |
//| * matrix is represented by its upper or lower triangle           |
//| No iterative refinement is provided because such partial         |
//| representation of matrix does not allow efficient calculation of |
//| extra-precise  matrix-vector products for large matrices. Use    |
//| RMatrixSolve or RMatrixMixedSolve  if  you need iterative        |
//| refinement.                                                      |
//| INPUT PARAMETERS                                                 |
//|     CHA     -   array[0..N-1,0..N-1], Cholesky decomposition,    |
//|                 SPDMatrixCholesky result                         |
//|     N       -   size of A                                        |
//|     IsUpper -   what half of CHA is provided                     |
//|     B       -   array[0..N-1], right part                        |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::SPDMatrixCholeskySolve(CMatrixDouble &cha,const int n,
                                     const bool IsUpper,double &b[],
                                     int &info,CDenseSolverReportShell &rep,
                                     double &x[])
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::SPDMatrixCholeskySolve(cha,n,IsUpper,b,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixSolveM(), but for Hermitian positive|
//| definite matrices.                                               |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * O(N^3+M*N^2) complexity                                        |
//| * matrix is represented by its upper or lower triangle           |
//| No iterative refinement is provided because such partial         |
//| representation of matrix does not allow efficient calculation of |
//| extra-precise  matrix-vector products for large matrices. Use    |
//| RMatrixSolve or RMatrixMixedSolve if you need iterative          |
//| refinement.                                                      |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     N       -   size of A                                        |
//|     IsUpper -   what half of A is provided                       |
//|     B       -   array[0..N-1,0..M-1], right part                 |
//|     M       -   right part size                                  |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve.                         |
//|                 Returns -3 for non-HPD matrices.                 |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::HPDMatrixSolveM(CMatrixComplex &a,const int n,const bool IsUpper,
                              CMatrixComplex &b,const int m,int &info,
                              CDenseSolverReportShell &rep,CMatrixComplex &x)
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::HPDMatrixSolveM(a,n,IsUpper,b,m,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixSolve(), but for Hermitian positive |
//| definite matrices.                                               |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * condition number estimation                                    |
//| * O(N^3) complexity                                              |
//| * matrix is represented by its upper or lower triangle           |
//| No iterative refinement is provided because such partial         |
//| representation of matrix does not allow efficient calculation of |
//| extra-precise matrix-vector products for large matrices. Use     |
//| RMatrixSolve or RMatrixMixedSolve if you need iterative          |
//| refinement.                                                      |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..N-1,0..N-1], system matrix              |
//|     N       -   size of A                                        |
//|     IsUpper -   what half of A is provided                       |
//|     B       -   array[0..N-1], right part                        |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|                 Returns -3 for non-HPD matrices.                 |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::HPDMatrixSolve(CMatrixComplex &a,const int n,
                             const bool IsUpper,complex &b[],
                             int &info,CDenseSolverReportShell &rep,
                             complex &x[])
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::HPDMatrixSolve(a,n,IsUpper,b,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixLUSolveM(), but for HPD matrices    |
//| represented by their Cholesky decomposition.                     |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * O(M*N^2) complexity                                            |
//| * condition number estimation                                    |
//| * matrix is represented by its upper or lower triangle           |
//| No iterative refinement is provided because such partial         |
//| representation of matrix does not allow efficient calculation of |
//| extra-precise matrix-vector products for large matrices. Use     |
//| RMatrixSolve or RMatrixMixedSolve if you need iterative          |
//| refinement.                                                      |
//| INPUT PARAMETERS                                                 |
//|     CHA     -   array[0..N-1,0..N-1], Cholesky decomposition,    |
//|                 HPDMatrixCholesky result                         |
//|     N       -   size of CHA                                      |
//|     IsUpper -   what half of CHA is provided                     |
//|     B       -   array[0..N-1,0..M-1], right part                 |
//|     M       -   right part size                                  |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::HPDMatrixCholeskySolveM(CMatrixComplex &cha,const int n,
                                      const bool IsUpper,CMatrixComplex &b,
                                      const int m,int &info,
                                      CDenseSolverReportShell &rep,
                                      CMatrixComplex &x)
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::HPDMatrixCholeskySolveM(cha,n,IsUpper,b,m,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver. Same as RMatrixLUSolve(), but for  HPD matrices    |
//| represented by their Cholesky decomposition.                     |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * O(N^2) complexity                                              |
//| * condition number estimation                                    |
//| * matrix is represented by its upper or lower triangle           |
//| No iterative refinement is provided because such partial         |
//| representation of matrix does not allow efficient calculation of |
//| extra-precise  matrix-vector products for large matrices. Use    |
//| RMatrixSolve or RMatrixMixedSolve if you need iterative          |
//| refinement.                                                      |
//| INPUT PARAMETERS                                                 |
//|     CHA     -   array[0..N-1,0..N-1], Cholesky decomposition,    |
//|                 SPDMatrixCholesky result                         |
//|     N       -   size of A                                        |
//|     IsUpper -   what half of CHA is provided                     |
//|     B       -   array[0..N-1], right part                        |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   same as in RMatrixSolve                          |
//|     Rep     -   same as in RMatrixSolve                          |
//|     X       -   same as in RMatrixSolve                          |
//+------------------------------------------------------------------+
void CAlglib::HPDMatrixCholeskySolve(CMatrixComplex &cha,const int n,
                                     const bool IsUpper,complex &b[],
                                     int &info,CDenseSolverReportShell &rep,
                                     complex &x[])
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::HPDMatrixCholeskySolve(cha,n,IsUpper,b,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Dense solver.                                                    |
//| This subroutine finds solution of the linear system A*X=B with   |
//| non-square, possibly degenerate A. System is solved in the least |
//| squares sense, and general least squares solution  X = X0 + CX*y |
//| which  minimizes |A*X-B| is returned. If A is non-degenerate,    |
//| solution in the usual sense is returned                          |
//| Algorithm features:                                              |
//| * automatic detection of degenerate cases                        |
//| * iterative refinement                                           |
//| * O(N^3) complexity                                              |
//| INPUT PARAMETERS                                                 |
//|     A       -   array[0..NRows-1,0..NCols-1], system matrix      |
//|     NRows   -   vertical size of A                               |
//|     NCols   -   horizontal size of A                             |
//|     B       -   array[0..NCols-1], right part                    |
//|     Threshold-  a number in [0,1]. Singular values beyond        |
//|                 Threshold are considered  zero.  Set it to 0.0,  |
//|                 if you don't understand what it means, so the    |
//|                 solver will choose good value on its own.        |
//| OUTPUT PARAMETERS                                                |
//|     Info    -   return code:                                     |
//|                 * -4    SVD subroutine failed                    |
//|                 * -1    if NRows<=0 or NCols<=0 or Threshold<0   |
//|                         was passed                               |
//|                 *  1    if task is solved                        |
//|     Rep     -   solver report, see below for more info           |
//|     X       -   array[0..N-1,0..M-1], it contains:               |
//|                 * solution of A*X=B if A is non-singular         |
//|                   (well-conditioned or ill-conditioned, but not  |
//|                   very close to singular)                        |
//|                 * zeros, if A is singular or VERY close to       |
//|                   singular (in this case Info=-3).               |
//| SOLVER REPORT                                                    |
//| Subroutine sets following fields of the Rep structure:           |
//| * R2        reciprocal of condition number: 1/cond(A), 2-norm.   |
//| * N         = NCols                                              |
//| * K         dim(Null(A))                                         |
//| * CX        array[0..N-1,0..K-1], kernel of A.                   |
//|             Columns of CX store such vectors that A*CX[i]=0.     |
//+------------------------------------------------------------------+
void CAlglib::RMatrixSolveLS(CMatrixDouble &a,const int nrows,
                             const int ncols,double &b[],
                             const double threshold,int &info,
                             CDenseSolverLSReportShell &rep,
                             double &x[])
  {
//--- initialization
   info=0;
//--- function call
   CDenseSolver::RMatrixSolveLS(a,nrows,ncols,b,threshold,info,rep.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Sparse linear solver for A*x = b with N*N sparse real symmetric  |
//| positive definite matrix A, N * 1 vectors x and b.               |
//| This solver converts input matrix to SKS format, performs        |
//| Cholesky factorization using SKS Cholesky subroutine (works well |
//| for limited bandwidth matrices) and uses sparse triangular       |
//| solvers to get solution of the original system.                  |
//| INPUT PARAMETERS:                                                |
//|   A        -  sparse matrix, must be NxN exactly                 |
//|   IsUpper  -  which half of A is provided (another half is       |
//|               ignored)                                           |
//|   B        -  array[0..N - 1], right part                        |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], it contains:                             |
//|               * rep.m_terminationtype > 0    =>  solution        |
//|               * rep.m_terminationtype = -3   =>  filled by zeros |
//|   Rep      -  solver report, following fields are set:           |
//|               * rep.m_terminationtype - solver status; > 0 for   |
//|                                       success, set to - 3 on     |
//|                                       failure (degenerate or     |
//|                                       non-SPD system).           |
//+------------------------------------------------------------------+
void CAlglib::SparseSPDSolveSKS(CSparseMatrix &a,bool IsUpper,
                                CRowDouble &b,CRowDouble &x,
                                CSparseSolverReport &rep)
  {
   CDirectSparseSolvers::SparseSPDSolveSKS(a,IsUpper,b,x,rep);
  }
//+------------------------------------------------------------------+
//| Sparse linear solver for A*x = b with N*N sparse real symmetric  |
//| positive definite matrix A, N * 1 vectors x and b.               |
//| This solver converts input matrix to CRS format, performs        |
//| Cholesky factorization using supernodal Cholesky decomposition   |
//| with permutation-reducing ordering and uses sparse triangular    |
//| solver to get solution of the original system.                   |
//| INPUT PARAMETERS:                                                |
//|   A        -  sparse matrix, must be NxN exactly                 |
//|   IsUpper  -  which half of A is provided (another half is       |
//|               ignored)                                           |
//|   B        -  array[N], right part                               |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], it contains:                             |
//|               * rep.m_terminationtype > 0  => solution           |
//|               * rep.m_terminationtype = -3  => filled by zeros   |
//|   Rep      -  solver report, following fields are set:           |
//|               * rep.m_terminationtype - solver status; > 0 for   |
//|                                         success, set to - 3 on   |
//|                                         failure (degenerate or   |
//|                                         non-SPD system).         |
//+------------------------------------------------------------------+
void CAlglib::SparseSPDSolve(CSparseMatrix &a,bool IsUpper,
                             CRowDouble &b,CRowDouble &x,
                             CSparseSolverReport &rep)
  {
   CDirectSparseSolvers::SparseSPDSolve(a,IsUpper,b,x,rep);
  }
//+------------------------------------------------------------------+
//| Sparse linear solver for A*x = b with N*N real symmetric positive|
//| definite matrix A given by its Cholesky decomposition, and N * 1 |
//| vectors x and b.                                                 |
//| IMPORTANT: this solver requires input matrix to be in the SKS    |
//|            (Skyline) or CRS (compressed row storage) format. An  |
//|            exception will be generated if you pass matrix in some|
//|            other format.                                         |
//| INPUT PARAMETERS:                                                |
//|   A        -  sparse NxN matrix stored in CRs or SKS format, must|
//|               be NxN exactly                                     |
//|   IsUpper  -  which half of A is provided (another half is       |
//|               ignored)                                           |
//|   B        -  array[N], right part                               |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], it contains:                             |
//|               * rep.m_terminationtype > 0  => solution           |
//|               * rep.m_terminationtype = -3  => filled by zeros   |
//|   Rep      -  solver report, following fields are set:           |
//|               * rep.m_terminationtype - solver status; > 0 for   |
//|                                         success, set to - 3 on   |
//|                                         failure (degenerate or   |
//|                                         non-SPD system).         |
//+------------------------------------------------------------------+
void CAlglib::SparseSPDCholeskySolve(CSparseMatrix &a,bool IsUpper,
                                     CRowDouble &b,CRowDouble &x,
                                     CSparseSolverReport &rep)
  {
   CDirectSparseSolvers::SparseSPDCholeskySolve(a,IsUpper,b,x,rep);
  }
//+------------------------------------------------------------------+
//| Sparse linear solver for A*x = b with general (nonsymmetric) N*N |
//| sparse real matrix A, N * 1 vectors x and b.                     |
//| This solver converts input matrix to CRS format, performs LU     |
//| factorization and uses sparse triangular solvers to get solution |
//| of the original system.                                          |
//| INPUT PARAMETERS:                                                |
//|   A        -  sparse matrix, must be NxN exactly, any storage    |
//|               format                                             |
//|   N        -  size of A, N > 0                                   |
//|   B        -  array[0..N - 1], right part                        |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], it contains:                             |
//|               * rep.m_terminationtype > 0  => solution           |
//|               * rep.m_terminationtype = -3  => filled by zeros   |
//|   Rep      -  solver report, following fields are set:           |
//|               * rep.m_terminationtype - solver status; > 0 for   |
//|                 success, set to - 3 on failure (degenerate       |
//|                 system).                                         |
//+------------------------------------------------------------------+
void CAlglib::SparseSolve(CSparseMatrix &a,CRowDouble &b,
                          CRowDouble &x,CSparseSolverReport &rep)
  {
   CDirectSparseSolvers::SparseSolve(a,b,x,rep);
  }
//+------------------------------------------------------------------+
//| Sparse linear solver for A*x = b with general (nonsymmetric) N*N |
//| sparse real matrix A given by its LU factorization, N*1 vectors x|
//| and b.                                                           |
//| IMPORTANT: this solver requires input matrix to be in the CRS    |
//|            sparse storage format. An exception will be generated |
//|            if you pass matrix in some other format (HASH or SKS).|
//| INPUT PARAMETERS:                                                |
//|   A        -  LU factorization of the sparse matrix, must be NxN |
//|               exactly in CRS storage format                      |
//|   P, Q     -  pivot indexes from LU factorization                |
//|   N        -  size of A, N > 0                                   |
//|   B        -  array[0..N - 1], right part                        |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], it contains:                             |
//|               * rep.m_terminationtype > 0  => solution           |
//|               * rep.m_terminationtype = -3  => filled by zeros   |
//|   Rep      -  solver report, following fields are set:           |
//|               * rep.m_terminationtype - solver status; > 0 for   |
//|                                         success, set to - 3 on   |
//|                                         failure (degenerate      |
//|                                         system).                 |
//+------------------------------------------------------------------+
void CAlglib::SparseLUSolve(CSparseMatrix &a,CRowInt &p,CRowInt &q,
                            CRowDouble &b,CRowDouble &x,
                            CSparseSolverReport &rep)
  {
   CDirectSparseSolvers::SparseLUSolve(a,p,q,b,x,rep);
  }
//+------------------------------------------------------------------+
//| Solving sparse symmetric linear system A*x = b using GMRES(k)    |
//| method. Sparse symmetric A is given by its lower or upper        |
//| triangle.                                                        |
//| NOTE: use SparseSolveGMRES() to solve system with nonsymmetric A.|
//| This function provides convenience API for an 'expert' interface |
//| provided by SparseSolverState class. Use SparseSolver API if you |
//| need advanced functions like providing initial point, using      |
//| out-of-core API and so on.                                       |
//| INPUT PARAMETERS:                                                |
//|   A        -  sparse symmetric NxN matrix in any sparse storage  |
//|               format. Using CRS format is recommended because it |
//|               avoids internal conversion. An exception will be   |
//|               generated if A is not NxN matrix (where N is a size|
//|               specified during solver object creation).          |
//|   IsUpper  -  whether upper or lower triangle of A is used:      |
//|               * IsUpper = True => only upper triangle is used and|
//|                 lower triangle is not referenced at all          |
//|               * IsUpper = False => only lower triangle is used   |
//|                 and upper triangle is not referenced at all      |
//|   B        -  right part, array[N]                               |
//|   K        -  k parameter for GMRES(k), k >= 0. Zero value means |
//|               that algorithm will choose it automatically.       |
//|   EpsF     -  stopping condition, EpsF >= 0. The algorithm will  |
//|               stop when residual will decrease below EpsF* | B |.|
//|               Having EpsF = 0 means that this stopping condition |
//|               is ignored.                                        |
//|   MaxIts   -  stopping condition, MaxIts >= 0. The algorithm will|
//|               stop after performing MaxIts iterations. Zero value|
//|               means no limit.                                    |
//| NOTE: having both EpsF = 0 and MaxIts = 0 means that stopping    |
//|       criteria will be chosen automatically.                     |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], the solution                             |
//|   Rep      -  solution report:                                   |
//|               * Rep.TerminationType completion code:             |
//|                  * -5  CG method was used for a matrix which is  |
//|                        not positive definite                     |
//|                  * -4  overflow / underflow during solution (ill |
//|                        conditioned problem)                      |
//|                  * 1   || residual || <= EpsF* || b ||           |
//|                  * 5   MaxIts steps was taken                    |
//|                  * 7   rounding errors prevent further progress, |
//|                        best point found is returned              |
//|                  * 8   the algorithm was terminated  early with  |
//|                        SparseSolverRequestTermination() being    |
//|                        called from other thread.                 |
//|               * Rep.IterationsCount contains iterations count    |
//|               * Rep.NMV contains number of matrix - vector       |
//|                         calculations                             |
//|               * Rep.R2 contains squared residual                 |
//+------------------------------------------------------------------+
void CAlglib::SparseSolveSymmetricGMRES(CSparseMatrix &a,bool IsUpper,
                                        CRowDouble &b,int k,double epsf,
                                        int maxits,CRowDouble &x,
                                        CSparseSolverReport &rep)
  {
   CIterativeSparse::SparseSolveSymmetricGMRES(a,IsUpper,b,k,epsf,maxits,x,rep);
  }
//+------------------------------------------------------------------+
//| Solving sparse linear system A*x = b using GMRES(k) method.      |
//| This function provides convenience API for an 'expert' interface |
//| provided by SparseSolverState class. Use SparseSolver API if you |
//| need advanced functions like providing initial point, using      |
//| out-of-core API and so on.                                       |
//| INPUT PARAMETERS:                                                |
//|   A        -  sparse NxN matrix in any sparse storage format.    |
//|               Using CRS format is recommended because it avoids  |
//|               internal conversion. An exception will be generated|
//|               if A is not NxN matrix (where N is a size specified|
//|               during solver object creation).                    |
//|   B        -  right part, array[N]                               |
//|   K        -  k parameter for GMRES(k), k >= 0. Zero value means |
//|               that algorithm will choose it automatically.       |
//|   EpsF     -  stopping condition, EpsF >= 0. The algorithm will  |
//|               stop when residual will decrease below EpsF*| B |. |
//|               Having EpsF = 0 means that this stopping condition |
//|               is ignored.                                        |
//|   MaxIts   -  stopping condition, MaxIts >= 0. The algorithm will|
//|               stop after performing MaxIts iterations. Zero value|
//|               means no limit.                                    |
//| NOTE: having both EpsF = 0 and MaxIts = 0 means that stopping    |
//|       criteria will be chosen automatically.                     |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], the solution                             |
//|   Rep      -  solution report:                                   |
//|               * Rep.TerminationType completion code:             |
//|                  * -5  CG method was used for a matrix which is  |
//|                        not positive definite                     |
//|                  * -4  overflow / underflow during solution (ill |
//|                        conditioned problem)                      |
//|                  * 1   || residual || <= EpsF* || b ||           |
//|                  * 5   MaxIts steps was taken                    |
//|                  * 7   rounding errors prevent further progress, |
//|                        best point found is returned              |
//|                  * 8   the algorithm was terminated  early with  |
//|                        SparseSolverRequestTermination() being    |
//|                        called from other thread.                 |
//|               * Rep.IterationsCount contains iterations count    |
//|               * Rep.NMV contains number of matrix - vector       |
//|                        calculations                              |
//|               * Rep.R2 contains squared residual                 |
//+------------------------------------------------------------------+
void CAlglib::SparseSolveGMRES(CSparseMatrix &a,CRowDouble &b,int k,
                               double epsf,int maxits,CRowDouble &x,
                               CSparseSolverReport &rep)
  {
   CIterativeSparse::SparseSolveGMRES(a,b,k,epsf,maxits,x,rep);
  }
//+------------------------------------------------------------------+
//| This function initializes sparse linear iterative solver object. |
//| This solver can be used to solve nonsymmetric and symmetric      |
//| positive definite NxN(square) linear systems.                    |
//| The solver provides 'expert' API which allows advanced control   |
//| over algorithms being used, including ability to get progress    |
//| report, terminate long-running solver from other thread,         |
//| out-of-core solution and so on.                                  |
//| NOTE: there are also convenience functions that allows quick one-|
//|       line to the solvers:                                       |
//|      *  SparseSolveCG() to solve SPD linear systems              |
//|      *  SparseSolveGMRES() to solve unsymmetric linear systems.  |
//| NOTE: if you want to solve MxN(rectangular) linear problem you   |
//|       may use LinLSQR solver provided by ALGLIB.                 |
//| USAGE (A is given by the SparseMatrix structure):                |
//|   1. User initializes algorithm state with SparseSolverCreate()  |
//|      call                                                        |
//|   2. User selects algorithm with one of the SparseSolverSetAlgo??|
//|      functions. By default, GMRES(k) is used with automatically  |
//|      chosen k                                                    |
//|   3. Optionally, user tunes solver parameters, sets starting     |
//|      point, etc.                                                 |
//|   4. Depending on whether system is symmetric or not, user calls:|
//|      * SparseSolverSolveSymmetric() for a symmetric system given |
//|        by its lower or upper triangle                            |
//|      * SparseSolverSolve() for a nonsymmetric system or a        |
//|        symmetric one given by the full matrix                    |
//|   5. User calls SparseSolverResults() to get the solution        |
//| It is possible to call SparseSolverSolve???() again to solve     |
//| another task with same dimensionality but different matrix and/or|
//| right part without reinitializing SparseSolverState structure.   |
//| USAGE(out-of-core mode):                                         |
//|   1. User initializes algorithm state with SparseSolverCreate()  |
//|      call                                                        |
//|   2. User selects algorithm with one of the SparseSolverSetAlgo??|
//|      functions. By default, GMRES(k) is used with automatically  |
//|      chosen k                                                    |
//|   3. Optionally, user tunes solver parameters, sets starting     |
//|      point, etc.                                                 |
//|   4. After that user should work with out-of-core interface in a |
//|      loop like one given below:                                  |
//|      > CAlgLib::SparseSolverOOCStart(state)                      |
//|      > while CAlgLib::SparseSolverOOCContinue(state) do          |
//|      >   CAlgLib::SparseSolver))CGetRequestInfo(state,           |
//|                                                 RequestType)     |
//|      >   CAlgLib::SparseSolverOOCGetRequeStdata(state,  X)       |
//|      >   if RequestType = 0 then                                 |
//|      >     [calculate Y = A * X, with X = R ^ N]                 |
//|      >   CAlgLib:SparseSolverOOCSendResult(state, Y)             |
//|      > CAlgLib::SparseSolverOOCStop(state, X, Report)            |
//| INPUT PARAMETERS:                                                |
//|   N        -  problem dimensionality (fixed at start-up)         |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure which stores algorithm state             |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverCreate(int n,CSparseSolverState &state)
  {
   CIterativeSparse::SparseSolverCreate(n,state);
  }
//+------------------------------------------------------------------+
//| This function sets the solver algorithm to GMRES(k).             |
//| NOTE: if you do not need advanced functionality of the           |
//|       SparseSolver API, you may use convenience functions        |
//|       SparseSolveGMRES() and SparseSolveSymmetricGMRES().        |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm state             |
//|   K        -  GMRES parameter, K >= 0:                           |
//|               * recommended values are in 10..100 range          |
//|               * larger values up to N are possible but have      |
//|                 little sense - the algorithm will be slower than |
//|                 any dense solver.                                |
//|               * values above N are truncated down to N           |
//|               * zero value means that default value is chosen.   |
//|                 This value is 50 in the current version, but it  |
//|                 may change in future ALGLIB releases.            |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverSetAlgoGMRES(CSparseSolverState &state,int k)
  {
   CIterativeSparse::SparseSolverSetAlgoGMRES(state,k);
  }
//+------------------------------------------------------------------+
//| This function sets starting point.                               |
//| By default, zero starting point is used.                         |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm state             |
//|   X        -  starting point, array[N]                           |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  new starting point was set                         |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverSetStartingPoint(CSparseSolverState &state,
                                           CRowDouble &x)
  {
   CIterativeSparse::SparseSolverSetStartingPoint(state,x);
  }
//+------------------------------------------------------------------+
//| This function sets stopping criteria.                            |
//| INPUT PARAMETERS:                                                |
//|   EpsF     -  algorithm will be stopped if norm of residual is   |
//|               less than EpsF* || b ||.                           |
//|   MaxIts   -  algorithm will be stopped if number of iterations  |
//|               is more than MaxIts.                               |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure which stores algorithm state             |
//| NOTES: If both EpsF and MaxIts are zero then small EpsF will be  |
//|        set to small value.                                       |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverSetCond(CSparseSolverState &state,
                                  double epsf,int maxits)
  {
   CIterativeSparse::SparseSolverSetCond(state,epsf,maxits);
  }
//+------------------------------------------------------------------+
//| Procedure for the solution of A*x = b with sparse symmetric A    |
//| given by its lower or upper triangle.                            |
//| This function will work with any solver algorithm being  used,   |
//| SPD one (like CG) or not(like GMRES). Using unsymmetric solvers  |
//| (like GMRES) on SPD problems is suboptimal, but still possible.  |
//| NOTE: the solver behavior is ill-defined for a situation when a  |
//|       SPD solver is used on indefinite matrix. It may solve the  |
//|       problem up to desired precision (sometimes, rarely) or     |
//|       return with error code signalling violation of underlying  |
//|       assumptions.                                               |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm state                                    |
//|   A        -  sparse symmetric NxN matrix in any sparse storage  |
//|               format. Using CRS format is recommended because it |
//|               avoids internal conversion. An exception will be   |
//|               generated if A is not NxN matrix (where N is a size|
//|               specified during solver object creation).          |
//|   IsUpper  -  whether upper or lower triangle of A is used:      |
//|               * IsUpper = True => only upper triangle is used and|
//|                 lower triangle is not referenced at all          |
//|               * IsUpper = False => only lower triangle is used   |
//|                 and upper triangle is not referenced at all      |
//|   B        -  right part, array[N]                               |
//| RESULT:                                                          |
//|   This function returns no result. You can get the solution by   |
//|   calling SparseSolverResults()                                  |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverSolveSymmetric(CSparseSolverState &state,
                                         CSparseMatrix &a,
                                         bool IsUpper,CRowDouble &b)
  {
   CIterativeSparse::SparseSolverSolveSymmetric(state,a,IsUpper,b);
  }
//+------------------------------------------------------------------+
//| Procedure for the solution of A*x = b with sparse nonsymmetric A |
//| IMPORTANT: this function will work with any solver algorithm     |
//|            being used, symmetric solver like CG, or not. However,|
//|            using symmetric solvers on nonsymmetric problems is   |
//|            dangerous. It may solve the problem up to desired     |
//|            precision (sometimes, rarely) or terminate with error |
//|            code signalling violation of underlying assumptions.  |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm state                                    |
//|   A        -  sparse NxN matrix in any sparse storage format.    |
//|               Using CRS format is recommended because it avoids  |
//|               internal conversion. An exception will be generated|
//|               if A is not NxN matrix (where N is a size specified|
//|               during solver object creation).                    |
//|   B        -  right part, array[N]                               |
//| RESULT:                                                          |
//|   This function returns no result.                               |
//|   You can get the solution by calling SparseSolverResults()      |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverSolve(CSparseSolverState &state,
                                CSparseMatrix &a,CRowDouble &b)
  {
   CIterativeSparse::SparseSolverSolve(state,a,b);
  }
//+------------------------------------------------------------------+
//| Sparse solver results.                                           |
//| This function must be called after calling one of the            |
//| SparseSolverSolve() functions.                                   |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm state                                    |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], solution                                 |
//|   Rep      -  solution report:                                   |
//|               * Rep.TerminationType completion code:             |
//|                  * -5  CG method was used for a matrix which is  |
//|                        not positive definite                     |
//|                  * -4  overflow/underflow during solution (ill   |
//|                        conditioned problem)                      |
//|                  * 1   || residual || <= EpsF* || b ||           |
//|                  * 5   MaxIts steps was taken                    |
//|                  * 7   rounding errors prevent further progress, |
//|                        best point found is returned              |
//|                  * 8   the algorithm was terminated  early with  |
//|                        SparseSolverRequestTermination() being    |
//|                        called from other thread.                 |
//|               * Rep.IterationsCount contains iterations count    |
//|               * Rep.NMV contains number of matrix - vector       |
//|                        calculations                              |
//|               * Rep.R2 contains squared residual                 |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverResults(CSparseSolverState &state,
                                  CRowDouble &x,
                                  CSparseSolverReport &rep)
  {
   CIterativeSparse::SparseSolverResults(state,x,rep);
  }
//+------------------------------------------------------------------+
//|This function turns on/off reporting during out-of-core processing|
//| When the solver works in the out-of-core mode, it can be         |
//| configured to report its progress by returning current location. |
//| These location reports implemented as a special kind of the      |
//| out-of-core request:                                             |
//|   *  SparseSolverOOCGetRequestInfo() returns - 1                 |
//|   *  SparseSolverOOCGetRequestData() returns current location    |
//|   *  SparseSolverOOCGetRequestData1() returns squared norm of    |
//|                                       the residual               |
//|   *  SparseSolverOOCSendResult() shall NOT be called             |
//| This function has no effect when SparseSolverSolve() is used     |
//| because this function has no method of reporting its progress.   |
//| NOTE: when used with GMRES(k), this function reports progress    |
//|       every k-th iteration.                                      |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm state             |
//|   NeedXRep -  whether iteration reports are needed or not        |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverSetXRep(CSparseSolverState &state,
                                  bool needxrep)
  {
   CIterativeSparse::SparseSolverSetXRep(state,needxrep);
  }
//+------------------------------------------------------------------+
//| This function initiates out-of-core mode of the sparse solver. It|
//| should be used in conjunction with other out-of-core - related   |
//| functions of this subspackage in a loop like one given below:    |
//|   >         CAlgLib::SparseSolverOOCStart(state)                 |
//|   > while   CAlgLib::SparseSolverOOCContinue(state) do           |
//|   >   CAlgLib::SparseSolverOOCGetRequestInfo(state, RequestType) |
//|   >   CAlgLib::SparseSolverOOCGetRequestData(state, out X)       |
//|   >   if RequestType = 0 then                                    |
//|   >     [calculate Y = A * X, with X = R ^ N]                    |
//|   >   CAlgLib::SparseSolverOOCSendResult(state, in Y)            |
//|   > CAlgLib::SparseSolverOOCStop(state, out X, out Report)       |
//| INPUT PARAMETERS:                                                |
//|   State       -  solver object                                   |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverOOCStart(CSparseSolverState &state,
                                   CRowDouble &b)
  {
   CIterativeSparse::SparseSolverOOCStart(state,b);
  }
//+------------------------------------------------------------------+
//| This function performs iterative solution of the linear system in|
//| the out-of-core mode. It should be used in conjunction with other|
//| out-of-core - related functions of this subspackage in a loop    |
//| like one given below:                                            |
//|   >         CAlgLib::SparseSolverOOCStart(state)                 |
//|   > while   CAlgLib::SparseSolverOOCContinue(state) do           |
//|   >   CAlgLib::SparseSolverOOCGetRequestInfo(state, RequestType) |
//|   >   CAlgLib::SparseSolverOOCGetRequestData(state, out X)       |
//|   >   if RequestType = 0 then                                    |
//|   >     [calculate Y = A * X, with X = R ^ N]                    |
//|   >   CAlgLib::SparseSolverOOCSendResult(state, in Y)            |
//|   > CAlgLib::SparseSolverOOCStop(state, out X, out Report)       |
//| INPUT PARAMETERS:                                                |
//|   State       -  solver object                                   |
//+------------------------------------------------------------------+
bool CAlglib::SparseSolverOOCContinue(CSparseSolverState &state)
  {
   return(CIterativeSparse::SparseSolverOOCContinue(state));
  }
//+------------------------------------------------------------------+
//| This function is used to retrieve information about out-of-core  |
//| request sent by the solver:                                      |
//|   * RequestType = 0 means that matrix - vector products A * x is |
//|                     requested                                    |
//|   * RequestType = -1 means that solver reports its progress; this|
//|                     request is returned only when reports are    |
//|                     activated wit SparseSolverSetXRep().         |
//| This function returns just request type; in order to get contents|
//| of the trial vector, use SparseSolverOOCGetRequestData().        |
//| It should be used in conjunction with other out-of-core - related|
//| functions of this subspackage in a loop like one given below:    |
//|   >         CAlgLib::SparseSolverOOCStart(state)                 |
//|   > while   CAlgLib::SparseSolverOOCContinue(state) do           |
//|   >   CAlgLib::SparseSolverOOCGetRequestInfo(state, RequestType) |
//|   >   CAlgLib::SparseSolverOOCGetRequestData(state, out X)       |
//|   >   if RequestType = 0 then                                    |
//|   >     [calculate Y = A * X, with X = R ^ N]                    |
//|   >   CAlgLib::SparseSolverOOCSendResult(state, in Y)            |
//|   > CAlgLib::SparseSolverOOCStop(state, out X, out Report)       |
//| INPUT PARAMETERS:                                                |
//|   State    -  solver running in out-of-core mode                 |
//| OUTPUT PARAMETERS:                                               |
//|   RequestType -  type of the request to process:                 |
//|                  * 0  for matrix - vector product A * x, with A  |
//|                       being NxN system matrix and X being        |
//|                       N-dimensional vector                       |
//|                  *-1  for location and residual report           |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverOOCGetRequestInfo(CSparseSolverState &state,
                                            int &requesttype)
  {
   CIterativeSparse::SparseSolverOOCGetRequestInfo(state,requesttype);
  }
//+------------------------------------------------------------------+
//| This function is used to retrieve vector associated with         |
//| out-of-core request sent by the solver to user code. Depending on|
//| the request type(returned by the SparseSolverOOCGetRequestInfo())|
//| this vector should be multiplied by A or subjected to another    |
//| processing.                                                      |
//| It should be used in conjunction with other out-of-core - related|
//| functions of this subspackage in a loop like one given below:    |
//|   >         CAlgLib::SparseSolverOOCStart(state)                 |
//|   > while   CAlgLib::SparseSolverOOCContinue(state) do           |
//|   >   CAlgLib::SparseSolverOOCGetRequestInfo(state, RequestType) |
//|   >   CAlgLib::SparseSolverOOCGetRequestData(state, out X)       |
//|   >   if RequestType = 0 then                                    |
//|   >     [calculate Y = A * X, with X = R ^ N]                    |
//|   >   CAlgLib::SparseSolverOOCSendResult(state, in Y)            |
//|   > CAlgLib::SparseSolverOOCStop(state, out X, out Report)       |
//| INPUT PARAMETERS:                                                |
//|   State       -  solver running in out-of-core mode              |
//|   X           -  possibly preallocated  storage; reallocated if  |
//|                  needed, left unchanged, if large enough to store|
//|                  request data.                                   |
//| OUTPUT PARAMETERS:                                               |
//|   X           -  array[N] or larger, leading N elements are      |
//|                  filled with vector X.                           |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverOOCGetRequestData(CSparseSolverState &state,CRowDouble &x)
  {
   CIterativeSparse::SparseSolverOOCGetRequestData(state,x);
  }
//+------------------------------------------------------------------+
//| This function is used to retrieve scalar value associated with   |
//| out-of-core request sent by the solver to user code. In the      |
//| current ALGLIB version this function is used to retrieve squared |
//| residual norm during progress reports.                           |
//| INPUT PARAMETERS:                                                |
//|   State       -  solver running in out-of-core mode              |
//| OUTPUT PARAMETERS:                                               |
//|   V           -  scalar value associated with the current request|
//+------------------------------------------------------------------+
void CAlglib::SparseSolverOOCGetRequestData1(CSparseSolverState &state,
                                             double &v)
  {
   CIterativeSparse::SparseSolverOOCGetRequestData1(state,v);
  }
//+------------------------------------------------------------------+
//| This function is used to send user reply to out-of-core request  |
//| sent by the solver. Usually it is product A*x for vector X       |
//| returned by the solver.                                          |
//| It should be used in conjunction with other out-of-core - related|
//| functions of this subspackage in a loop like one given below:    |
//|   >         CAlgLib::SparseSolverOOCStart(state)                 |
//|   > while   CAlgLib::SparseSolverOOCContinue(state) do           |
//|   >   CAlgLib::SparseSolverOOCGetRequestInfo(state, RequestType) |
//|   >   CAlgLib::SparseSolverOOCGetRequestData(state, out X)       |
//|   >   if RequestType = 0 then                                    |
//|   >     [calculate Y = A * X, with X = R ^ N]                    |
//|   >   CAlgLib::SparseSolverOOCSendResult(state, in Y)            |
//|   > CAlgLib::SparseSolverOOCStop(state, out X, out Report)       |
//| INPUT PARAMETERS:                                                |
//|   State    -  solver running in out-of-core mode                 |
//|   AX       -  array[N] or larger, leading N elements contain A*x |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverOOCSendResult(CSparseSolverState &state,
                                        CRowDouble &ax)
  {
   CIterativeSparse::SparseSolverOOCSendResult(state,ax);
  }
//+------------------------------------------------------------------+
//| This function finalizes out-of-core mode of the linear solver. It|
//| should be used in conjunction with other out-of-core - related   |
//| functions of this subspackage in a loop like one given below:    |
//|   >         CAlgLib::SparseSolverOOCStart(state)                 |
//|   > while   CAlgLib::SparseSolverOOCContinue(state) do           |
//|   >   CAlgLib::SparseSolverOOCGetRequestInfo(state, RequestType) |
//|   >   CAlgLib::SparseSolverOOCGetRequestData(state, out X)       |
//|   >   if RequestType = 0 then                                    |
//|   >     [calculate Y = A * X, with X = R ^ N]                    |
//|   >   CAlgLib::SparseSolverOOCSendResult(state, in Y)            |
//|   > CAlgLib::SparseSolverOOCStop(state, out X, out Report)       |
//| INPUT PARAMETERS:                                                |
//|   State    -  solver state                                       |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], the solution.                            |
//|   Zero     -  filled on the failure(Rep.TerminationType < 0).    |
//|   Rep      -  report with additional info:                       |
//|               * Rep.TerminationType completion code:             |
//|                  * -5  CG method was used for a matrix which is  |
//|                        not positive definite                     |
//|                  * -4  overflow/underflow during solution (ill   |
//|                        conditioned problem)                      |
//|                  * 1   || residual || <= EpsF* || b ||           |
//|                  * 5   MaxIts steps was taken                    |
//|                  * 7   rounding errors prevent further progress, |
//|                        best point found is returned              |
//|                  * 8   the algorithm was terminated  early with  |
//|                        SparseSolverRequestTermination() being    |
//|                        called from other thread.                 |
//|               * Rep.IterationsCount contains iterations count    |
//|               * Rep.NMV contains number of matrix - vector       |
//|                        calculations                              |
//|               * Rep.R2 contains squared residual                 |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverOOCStop(CSparseSolverState &state,
                                  CRowDouble &x,CSparseSolverReport &rep)
  {
   CIterativeSparse::SparseSolverOOCStop(state,x,rep);
  }
//+------------------------------------------------------------------+
//| This subroutine submits request for termination of the running   |
//| solver. It can be called from some other thread which wants the  |
//| solver to terminate or when processing an out-of-core request.   |
//| As result, solver stops at point which was "current accepted"    |
//| when the termination request was submitted and returns error code|
//| 8 (successful termination). Such termination is a smooth process |
//| which properly deallocates all temporaries.                      |
//| INPUT PARAMETERS:                                                |
//|   State    -  solver structure                                   |
//| NOTE: calling this function on solver which is NOT running will  |
//|       have no effect.                                            |
//| NOTE: multiple calls to this function are possible. First call is|
//|       counted, subsequent calls are silently ignored.            |
//| NOTE: solver clears termination flag on its start, it means that |
//|       if some other thread will request termination too soon, its|
//|       request will went unnoticed.                               |
//+------------------------------------------------------------------+
void CAlglib::SparseSolverRequestTermination(CSparseSolverState &state)
  {
   CIterativeSparse::SparseSolverRequestTermination(state);
  }
//+------------------------------------------------------------------+
//| This function initializes linear CG Solver. This solver is used  |
//| to solve symmetric positive definite problems. If you want to    |
//| solve nonsymmetric (or non-positive definite) problem you may use|
//| LinLSQR solver provided by ALGLIB.                               |
//| USAGE:                                                           |
//|   1. User initializes algorithm state with LinCGCreate() call    |
//|   2. User tunes solver parameters with LinCGSetCond() and other  |
//|      functions                                                   |
//|   3. Optionally, user sets starting point with                   |
//|      LinCGSetStartingPoint()                                     |
//|   4. User calls LinCGSolveSparse() function which takes algorithm|
//|      state and SparseMatrix object.                              |
//|   5. User calls LinCGResults() to get solution                   |
//|   6. Optionally, user may call LinCGSolveSparse() again to solve |
//|      another problem with different matrix and/or right part     |
//|      without reinitializing LinCGState structure.                |
//| INPUT PARAMETERS:                                                |
//|   N        -  problem dimension, N > 0                           |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure which stores algorithm state             |
//+------------------------------------------------------------------+
void CAlglib::LinCGCreate(int n,CLinCGState &state)
  {
   CLinCG::LinCGCreate(n,state);
  }
//+------------------------------------------------------------------+
//| This function sets starting point.                               |
//| By default, zero starting point is used.                         |
//| INPUT PARAMETERS:                                                |
//|   X        -  starting point, array[N]                           |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure which stores algorithm state             |
//+------------------------------------------------------------------+
void CAlglib::LinCGSetStartingPoint(CLinCGState &state,CRowDouble &x)
  {
   CLinCG::LinCGSetStartingPoint(state,x);
  }
//+------------------------------------------------------------------+
//| This function changes preconditioning settings of                |
//| LinCGSolveSparse() function. By default, SolveSparse() uses      |
//| diagonal preconditioner, but if you want to use solver without   |
//| preconditioning, you can call this function which forces solver  |
//| to use unit matrix for preconditioning.                          |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm state             |
//+------------------------------------------------------------------+
void CAlglib::LinCGSetPrecUnit(CLinCGState &state)
  {
   CLinCG::LinCGSetPrecUnit(state);
  }
//+------------------------------------------------------------------+
//| This function changes preconditioning settings of                |
//| LinCGSolveSparse() function. LinCGSolveSparse() will use diagonal|
//| of the system matrix as preconditioner. This preconditioning mode|
//| is active by default.                                            |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure which stores algorithm state          |
//+------------------------------------------------------------------+
void CAlglib::LinCGSetPrecDiag(CLinCGState &state)
  {
   CLinCG::LinCGSetPrecDiag(state);
  }
//+------------------------------------------------------------------+
//| This function sets stopping criteria.                            |
//| INPUT PARAMETERS:                                                |
//|   EpsF     -  algorithm will be stopped if norm of residual is   |
//|               less than EpsF* || b ||.                           |
//|   MaxIts   -  algorithm will be stopped if number of iterations  |
//|               is more than MaxIts.                               |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure which stores algorithm state             |
//| NOTES: If both EpsF and MaxIts are zero then small EpsF will be  |
//|        set to small value.                                       |
//+------------------------------------------------------------------+
void CAlglib::LinCGSetCond(CLinCGState &state,double epsf,int maxits)
  {
   CLinCG::LinCGSetCond(state,epsf,maxits);
  }
//+------------------------------------------------------------------+
//| Procedure for solution of A*x = b with sparse A.                 |
//| INPUT PARAMETERS:                                                |
//|   State       -  algorithm state                                 |
//|   A           -  sparse matrix in the CRS format (you MUST       |
//|                  contvert it to CRS format by calling            |
//|                  SparseConvertToCRS() function).                 |
//|   IsUpper     -  whether upper or lower triangle of A is used:   |
//|                  * IsUpper = True => only upper triangle is used |
//|                                      and lower triangle is not   |
//|                                      referenced at all           |
//|                  * IsUpper = False => only lower triangle is used|
//|                                      and upper triangle is not   |
//|                                      referenced at all           |
//|   B           -  right part, array[N]                            |
//| RESULT:                                                          |
//|   This function returns no result.                               |
//|   You can get solution by calling LinCGResults()                 |
//| NOTE: this function uses lightweight preconditioning -           |
//|       multiplication by inverse of diag(A). If you want, you can |
//|       turn preconditioning off by calling LinCGSetPrecUnit().    |
//|       However, preconditioning cost is low and preconditioner is |
//|       very important for solution of badly scaled problems.      |
//+------------------------------------------------------------------+
void CAlglib::LinCGSolveSparse(CLinCGState &state,CSparseMatrix &a,
                               bool IsUpper,CRowDouble &b)
  {
   CLinCG::LinCGSolveSparse(state,a,IsUpper,b);
  }
//+------------------------------------------------------------------+
//| CG - solver: results.                                            |
//| This function must be called after LinCGSolve                    |
//| INPUT PARAMETERS:                                                |
//|   State       -  algorithm state                                 |
//| OUTPUT PARAMETERS:                                               |
//|   X           -  array[N], solution                              |
//|   Rep         -  optimization report:                            |
//|                  * Rep.TerminationType completetion code:        |
//|                     * -5  input matrix is either not positive    |
//|                           definite, too large or too small       |
//|                     * -4  overflow / underflow during solution   |
//|                           (ill conditioned problem)              |
//|                     * 1   || residual || <= EpsF* || b ||        |
//|                     * 5   MaxIts steps was taken                 |
//|                     * 7   rounding errors prevent further        |
//|                           progress, best point found is returned |
//|                  * Rep.IterationsCount contains iterations count |
//|                  * NMV countains number of matrix - vector       |
//|                           calculations                           |
//+------------------------------------------------------------------+
void CAlglib::LinCGResult(CLinCGState &state,CRowDouble &x,
                          CLinCGReport &rep)
  {
   CLinCG::LinCGResult(state,x,rep);
  }
//+------------------------------------------------------------------+
//| This function sets restart frequency. By default, algorithm is   |
//| restarted after N subsequent iterations.                         |
//+------------------------------------------------------------------+
void CAlglib::LinCGSetRestartFreq(CLinCGState &state,int srf)
  {
   CLinCG::LinCGSetRestartFreq(state,srf);
  }
//+------------------------------------------------------------------+
//| This function sets frequency of residual recalculations.         |
//| Algorithm updates residual r_k using iterative formula, but      |
//| recalculates it from scratch after each 10 iterations. It is done|
//| to avoid accumulation of numerical errors and to stop algorithm  |
//| when r_k starts to grow.                                         |
//| Such low update  frequence(1 / 10) gives very little overhead,   |
//| but makes algorithm a bit more robust against numerical errors.  |
//| However, you may change it                                       |
//| INPUT PARAMETERS:                                                |
//|   Freq        -  desired update frequency, Freq >= 0.            |
//| Zero value means that no updates will be done.                   |
//+------------------------------------------------------------------+
void CAlglib::LinCGSetRUpdateFreq(CLinCGState &state,int freq)
  {
   CLinCG::LinCGSetRUpdateFreq(state,freq);
  }
//+------------------------------------------------------------------+
//| This function turns on / off reporting.                          |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm state             |
//|   NeedXRep -  whether iteration reports are needed or not        |
//| If NeedXRep is True, algorithm will call rep() callback function |
//| if it is provided to MinCGOptimize().                            |
//+------------------------------------------------------------------+
void CAlglib::LinCGSetXRep(CLinCGState &state,bool needxrep)
  {
   CLinCG::LinCGSetXRep(state,needxrep);
  }
//+------------------------------------------------------------------+
//| This function initializes linear LSQR Solver. This solver is used|
//| to solve non-symmetric (and, possibly, non-square) problems.     |
//| Least squares solution is returned for non - compatible systems. |
//| USAGE:                                                           |
//|   1. User initializes algorithm state with LinLSQRCreate() call  |
//|   2. User tunes solver parameters with LinLSQRSetCond() and other|
//|      functions                                                   |
//|   3. User calls LinLSQRSolveSparse() function which takes        |
//|      algorithm state and SparseMatrix object.                    |
//|   4. User calls LinLSQRResults() to get solution                 |
//|   5. Optionally, user may call LinLSQRSolveSparse() again to     |
//|      solve another problem with different matrix and/or right    |
//|      part without reinitializing LinLSQRState structure.         |
//| INPUT PARAMETERS:                                                |
//|   M        -  number of rows in A                                |
//|   N        -  number of variables, N > 0                         |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure which stores algorithm state             |
//| NOTE: see also LinLSQRCreateBuf() for version which reuses       |
//|       previously allocated place as much as possible.            |
//+------------------------------------------------------------------+
void CAlglib::LinLSQRCreate(int m,int n,CLinLSQRState &state)
  {
   CLinLSQR::LinLSQRCreate(m,n,state);
  }
//+------------------------------------------------------------------+
//| This function initializes linear LSQR Solver. It provides exactly|
//| same functionality as LinLSQRCreate(), but reuses previously     |
//| allocated space as much as possible.                             |
//| INPUT PARAMETERS:                                                |
//|   M        -  number of rows in A                                |
//|   N        -  number of variables, N > 0                         |
//| OUTPUT PARAMETERS:                                               |
//|   State    -  structure which stores algorithm state             |
//+------------------------------------------------------------------+
void CAlglib::LinLSQRCreateBuf(int m,int n,CLinLSQRState &state)
  {
   CLinLSQR::LinLSQRCreateBuf(m,n,state);
  }
//+------------------------------------------------------------------+
//| This function changes preconditioning settings of                |
//| LinLSQQSolveSparse() function. By default, SolveSparse() uses    |
//| diagonal preconditioner, but if you want to use solver without   |
//| preconditioning, you can call this function which forces solver  |
//| to use unit matrix for preconditioning.                          |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm state             |
//+------------------------------------------------------------------+
void CAlglib::LinLSQRSetPrecUnit(CLinLSQRState &state)
  {
   CLinLSQR::LinLSQRSetPrecUnit(state);
  }
//+------------------------------------------------------------------+
//| This function changes preconditioning settings of                |
//| LinCGSolveSparse() function. LinCGSolveSparse() will use diagonal|
//| of the system matrix as preconditioner. This preconditioning mode|
//| is active by default.                                            |
//| INPUT PARAMETERS:                                                |
//|   State       -  structure which stores algorithm state          |
//+------------------------------------------------------------------+
void CAlglib::LinLSQRSetPrecDiag(CLinLSQRState &state)
  {
   CLinLSQR::LinLSQRSetPrecDiag(state);
  }
//+------------------------------------------------------------------+
//| This function sets optional Tikhonov regularization coefficient. |
//| It is zero by default.                                           |
//| INPUT PARAMETERS:                                                |
//|   LambdaI     -  regularization factor, LambdaI >= 0             |
//| OUTPUT PARAMETERS:                                               |
//|   State       -  structure which stores algorithm state          |
//+------------------------------------------------------------------+
void CAlglib::LinLSQRSetLambdaI(CLinLSQRState &state,double lambdai)
  {
   CLinLSQR::LinLSQRSetLambdaI(state,lambdai);
  }
//+------------------------------------------------------------------+
//| Procedure for solution of A*x = b with sparse A.                 |
//| INPUT PARAMETERS:                                                |
//|   State       -  algorithm state                                 |
//|   A           -  sparse M*N matrix in the CRS format (you MUST   |
//|                  contvert it to CRS format by calling            |
//|                  SparseConvertToCRS() function BEFORE you pass it|
//|                  to this function).                              |
//|   B           -  right part, array[M]                            |
//| RESULT:                                                          |
//|   This function returns no result.                               |
//|   You can get solution by calling LinCGResults()                 |
//| NOTE: this function uses lightweight preconditioning -           |
//|       multiplication by inverse of diag(A). If you want, you can |
//|      turn preconditioning off by calling LinLSQRSetPrecUnit().   |
//|      However, preconditioning cost is low and preconditioner is  |
//|      very important for solution of badly scaled problems.       |
//+------------------------------------------------------------------+
void CAlglib::LinLSQRSolveSparse(CLinLSQRState &state,CSparseMatrix &a,
                                 CRowDouble &b)
  {
   CLinLSQR::LinLSQRSolveSparse(state,a,b);
  }
//+------------------------------------------------------------------+
//| This function sets stopping criteria.                            |
//| INPUT PARAMETERS:                                                |
//|   EpsA        -  algorithm will be stopped if                    |
//|                  || A^T * Rk || / ( || A || * || Rk ||) <= EpsA. |
//|   EpsB        -  algorithm will be stopped if                    |
//|                  || Rk || <= EpsB * || B ||                      |
//|   MaxIts      -  algorithm will be stopped if number of          |
//|                  iterations more than MaxIts.                    |
//| OUTPUT PARAMETERS:                                               |
//|   State       -  structure which stores algorithm state          |
//| NOTE: if EpsA, EpsB, EpsC and MaxIts are zero then these         |
//|       variables will be setted as default values.                |
//+------------------------------------------------------------------+
void CAlglib::LinLSQRSetCond(CLinLSQRState &state,double epsa,
                             double epsb,int maxits)
  {
   CLinLSQR::LinLSQRSetCond(state,epsa,epsb,maxits);
  }
//+------------------------------------------------------------------+
//| LSQR solver: results.                                            |
//| This function must be called after LinLSQRSolve                  |
//| INPUT PARAMETERS:                                                |
//|   State    -  algorithm state                                    |
//| OUTPUT PARAMETERS:                                               |
//|   X        -  array[N], solution                                 |
//|   Rep      -  optimization report:                               |
//|               * Rep.TerminationType completetion code:           |
//|                  * 1  || Rk || <= EpsB* || B ||                  |
//|                  * 4  ||A^T * Rk|| / (||A|| * ||Rk||) <= EpsA    |
//|                  * 5  MaxIts steps was taken                     |
//|                  * 7  rounding errors prevent further progress,  |
//|                       X contains best point found so far.        |
//|                       (sometimes returned on singular systems)   |
//|                  * 8  user requested termination via calling     |
//|                       LinLSQRRequestTermination()                |
//|               * Rep.IterationsCount contains iterations count    |
//|               * NMV countains number of matrix - vector          |
//|                     calculations                                 |
//+------------------------------------------------------------------+
void CAlglib::LinLSQRResults(CLinLSQRState &state,CRowDouble &x,
                             CLinLSQRReport &rep)
  {
   CLinLSQR::LinLSQRResults(state,x,rep);
  }
//+------------------------------------------------------------------+
//| This function turns on / off reporting.                          |
//| INPUT PARAMETERS:                                                |
//|   State    -  structure which stores algorithm state             |
//|   NeedXRep -  whether iteration reports are needed or not        |
//|               If NeedXRep is True, algorithm will call rep()     |
//|               callback function if it is provided to             |
//|               MinCGOptimize().                                   |
//+------------------------------------------------------------------+
void CAlglib::LinLSQRSetXRep(CLinLSQRState &state,bool needxrep)
  {
   CLinLSQR::LinLSQRSetXRep(state,needxrep);
  }
//+------------------------------------------------------------------+
//| This function is used to peek into LSQR solver and get current   |
//| iteration counter. You can safely "peek" into the solver from    |
//| another thread.                                                  |
//| INPUT PARAMETERS:                                                |
//|   S        -  solver object                                      |
//| RESULT:                                                          |
//|   iteration counter, in [0, INF)                                 |
//+------------------------------------------------------------------+
int CAlglib::LinLSQRPeekIterationsCount(CLinLSQRState &s)
  {
   return(CLinLSQR::LinLSQRPeekIterationsCount(s));
  }
//+------------------------------------------------------------------+
//| This subroutine submits request for termination of the running   |
//| solver. It can be called from some other thread which wants LSQR |
//| solver to terminate (obviously, the thread running LSQR solver   |
//| can not request termination because it is already busy working on|
//| LSQR).                                                           |
//| As result, solver stops at point which was "current accepted"    |
//| when termination request was submitted and returns error code 8  |
//| (successful termination). Such  termination  is a smooth process |
//| which properly deallocates all temporaries.                      |
//| INPUT PARAMETERS:                                                |
//|   State    -  solver structure                                   |
//| NOTE: calling this function on solver which is NOT running will  |
//|       have no effect.                                            |
//| NOTE: multiple calls to this function are possible. First call is|
//|       counted, subsequent calls are silently ignored.            |
//| NOTE: solver clears termination flag on its start, it means that |
//|       if some other thread will request termination too soon, its|
//|       request will went unnoticed.                               |
//+------------------------------------------------------------------+
void CAlglib::LinLSQRRequestTermination(CLinLSQRState &state)
  {
   CLinLSQR::LinLSQRRequestTermination(state);
  }
//+------------------------------------------------------------------+
//|                 LEVENBERG-MARQUARDT-LIKE NONLINEAR SOLVER        |
//| DESCRIPTION:                                                     |
//| This algorithm solves system of nonlinear equations              |
//|     F[0](x[0], ..., x[n-1])   = 0                                |
//|     F[1](x[0], ..., x[n-1])   = 0                                |
//|     ...                                                          |
//|     F[M-1](x[0], ..., x[n-1]) = 0                                |
//| with M/N do not necessarily coincide. Algorithm converges        |
//| quadratically under following conditions:                        |
//|     * the solution set XS is nonempty                            |
//|     * for some xs in XS there exist such neighbourhood N(xs)     |
//|       that:                                                      |
//|       * vector function F(x) and its Jacobian J(x) are           |
//|         continuously differentiable on N                         |
//|       * ||F(x)|| provides local error bound on N, i.e. there     |
//|         exists such c1, that ||F(x)||>c1*distance(x,XS)          |
//| Note that these conditions are much more weaker than usual       |
//| non-singularity conditions. For example, algorithm will converge |
//| for any affine function F (whether its Jacobian singular or not).|
//| REQUIREMENTS:                                                    |
//| Algorithm will request following information during its          |
//| operation:                                                       |
//| * function vector F[] and Jacobian matrix at given point X       |
//| * value of merit function f(x)=F[0]^2(x)+...+F[M-1]^2(x) at given|
//| point X                                                          |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with NLEQCreateLM() call     |
//| 2. User tunes solver parameters with NLEQSetCond(),              |
//|    NLEQSetStpMax() and other functions                           |
//| 3. User calls NLEQSolve() function which takes algorithm state   |
//|    and pointers (delegates, etc.) to callback functions which    |
//|    calculate merit function value and Jacobian.                  |
//| 4. User calls NLEQResults() to get solution                      |
//| 5. Optionally, user may call NLEQRestartFrom() to solve another  |
//|    problem with same parameters (N/M) but another starting point |
//|    and/or another function vector. NLEQRestartFrom() allows to   |
//|    reuse already initialized structure.                          |
//| INPUT PARAMETERS:                                                |
//|     N       -   space dimension, N>1:                            |
//|                 * if provided, only leading N elements of X are  |
//|                   used                                           |
//|                 * if not provided, determined automatically from |
//|                   size of X                                      |
//|     M       -   system size                                      |
//|     X       -   starting point                                   |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. you may tune stopping conditions with NLEQSetCond() function  |
//| 2. if target function contains exp() or other fast growing       |
//|    functions, and optimization algorithm makes too large steps   |
//|    which leads to overflow, use NLEQSetStpMax() function to bound|
//|    algorithm's steps.                                            |
//| 3. this algorithm is a slightly modified implementation of the   |
//|    method described in 'Levenberg-Marquardt method for           |
//|    constrained nonlinear equations with strong local convergence |
//|    properties' by Christian Kanzow Nobuo Yamashita and Masao     |
//|    Fukushima and further developed in  'On the convergence of a  |
//|    New Levenberg-Marquardt Method' by Jin-yan Fan and Ya-Xiang   |
//|    Yuan.                                                         |
//+------------------------------------------------------------------+
void CAlglib::NlEqCreateLM(const int n,const int m,double &x[],
                           CNlEqStateShell &state)
  {
   CNlEq::NlEqCreateLM(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//|                 LEVENBERG-MARQUARDT-LIKE NONLINEAR SOLVER        |
//| DESCRIPTION:                                                     |
//| This algorithm solves system of nonlinear equations              |
//|     F[0](x[0], ..., x[n-1])   = 0                                |
//|     F[1](x[0], ..., x[n-1])   = 0                                |
//|     ...                                                          |
//|     F[M-1](x[0], ..., x[n-1]) = 0                                |
//| with M/N do not necessarily coincide. Algorithm converges        |
//| quadratically under following conditions:                        |
//|     * the solution set XS is nonempty                            |
//|     * for some xs in XS there exist such neighbourhood N(xs)     |
//|       that:                                                      |
//|       * vector function F(x) and its Jacobian J(x) are           |
//|         continuously differentiable on N                         |
//|       * ||F(x)|| provides local error bound on N, i.e. there     |
//|         exists such c1, that ||F(x)||>c1*distance(x,XS)          |
//| Note that these conditions are much more weaker than usual       |
//| non-singularity conditions. For example, algorithm will converge |
//| for any affine function F (whether its Jacobian singular or not).|
//| REQUIREMENTS:                                                    |
//| Algorithm will request following information during its          |
//| operation:                                                       |
//| * function vector F[] and Jacobian matrix at given point X       |
//| * value of merit function f(x)=F[0]^2(x)+...+F[M-1]^2(x) at given|
//| point X                                                          |
//| USAGE:                                                           |
//| 1. User initializes algorithm state with NLEQCreateLM() call     |
//| 2. User tunes solver parameters with NLEQSetCond(),              |
//|    NLEQSetStpMax() and other functions                           |
//| 3. User calls NLEQSolve() function which takes algorithm state   |
//|    and pointers (delegates, etc.) to callback functions which    |
//|    calculate merit function value and Jacobian.                  |
//| 4. User calls NLEQResults() to get solution                      |
//| 5. Optionally, user may call NLEQRestartFrom() to solve another  |
//|    problem with same parameters (N/M) but another starting point |
//|    and/or another function vector. NLEQRestartFrom() allows to   |
//|    reuse already initialized structure.                          |
//| INPUT PARAMETERS:                                                |
//|     N       -   space dimension, N>1:                            |
//|                 * if provided, only leading N elements of X are  |
//|                   used                                           |
//|                 * if not provided, determined automatically from |
//|                   size of X                                      |
//|     M       -   system size                                      |
//|     X       -   starting point                                   |
//| OUTPUT PARAMETERS:                                               |
//|     State   -   structure which stores algorithm state           |
//| NOTES:                                                           |
//| 1. you may tune stopping conditions with NLEQSetCond() function  |
//| 2. if target function contains exp() or other fast growing       |
//|    functions, and optimization algorithm makes too large steps   |
//|    which leads to overflow, use NLEQSetStpMax() function to bound|
//|    algorithm's steps.                                            |
//| 3. this algorithm is a slightly modified implementation of the   |
//|    method described in 'Levenberg-Marquardt method for           |
//|    constrained nonlinear equations with strong local convergence |
//|    properties' by Christian Kanzow Nobuo Yamashita and Masao     |
//|    Fukushima and further developed in  'On the convergence of a  |
//|    New Levenberg-Marquardt Method' by Jin-yan Fan and Ya-Xiang   |
//|    Yuan.                                                         |
//+------------------------------------------------------------------+
void CAlglib::NlEqCreateLM(const int m,double &x[],CNlEqStateShell &state)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   CNlEq::NlEqCreateLM(n,m,x,state.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This function sets stopping conditions for the nonlinear solver  |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     EpsF    -   >=0                                              |
//|                 The subroutine finishes  its work if on k+1-th   |
//|                 iteration the condition ||F||<=EpsF is satisfied |
//|     MaxIts  -   maximum number of iterations. If MaxIts=0, the   |
//|                 number of iterations is unlimited.               |
//| Passing EpsF=0 and MaxIts=0 simultaneously will lead to          |
//| automatic stopping criterion selection (small EpsF).             |
//| NOTES:                                                           |
//+------------------------------------------------------------------+
void CAlglib::NlEqSetCond(CNlEqStateShell &state,const double epsf,
                          const int maxits)
  {
   CNlEq::NlEqSetCond(state.GetInnerObj(),epsf,maxits);
  }
//+------------------------------------------------------------------+
//| This function turns on/off reporting.                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     NeedXRep-   whether iteration reports are needed or not      |
//| If NeedXRep is True, algorithm will call rep() callback function |
//| if it is provided to NLEQSolve().                                |
//+------------------------------------------------------------------+
void CAlglib::NlEqSetXRep(CNlEqStateShell &state,const bool needxrep)
  {
   CNlEq::NlEqSetXRep(state.GetInnerObj(),needxrep);
  }
//+------------------------------------------------------------------+
//| This function sets maximum step length                           |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure which stores algorithm state           |
//|     StpMax  -   maximum step length, >=0. Set StpMax to 0.0, if  |
//|                 you don't want to limit step length.             |
//| Use this subroutine when target function contains exp() or other |
//| fast growing functions, and algorithm makes too large steps which|
//| lead to overflow. This function allows us to reject steps that   |
//| are too large (and therefore expose us to the possible overflow) |
//| without actually calculating function value at the x+stp*d.      |
//+------------------------------------------------------------------+
void CAlglib::NlEqSetStpMax(CNlEqStateShell &state,const double stpmax)
  {
   CNlEq::NlEqSetStpMax(state.GetInnerObj(),stpmax);
  }
//+------------------------------------------------------------------+
//| This function provides reverse communication interface           |
//| Reverse communication interface is not documented or recommended |
//| to use.                                                          |
//| See below for functions which provide better documented API      |
//+------------------------------------------------------------------+
bool CAlglib::NlEqIteration(CNlEqStateShell &state)
  {
   return(CNlEq::NlEqIteration(state.GetInnerObj()));
  }
//+------------------------------------------------------------------+
//| This family of functions is used to launcn iterations of         |
//| nonlinear solver                                                 |
//| These functions accept following parameters:                     |
//|     func    -   callback which calculates function (or merit     |
//|                 function) value func at given point x            |
//|     jac     -   callback which calculates function vector fi[]   |
//|                 and Jacobian jac at given point x                |
//|     rep     -   optional callback which is called after each     |
//|                 iteration can be null                            |
//|     obj     -   optional object which is passed to               |
//|                 func/grad/hess/jac/rep can be null               |
//+------------------------------------------------------------------+
void CAlglib::NlEqSolve(CNlEqStateShell &state,CNDimensional_Func &func,
                        CNDimensional_Jac &jac,CNDimensional_Rep &rep,
                        bool rep_status,CObject &obj)
  {
//--- cycle
   while(CAlglib::NlEqIteration(state))
     {
      //--- check
      if(state.GetNeedF())
        {
         func.Func(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetNeedFIJ())
        {
         jac.Jac(state.GetInnerObj().m_x,state.GetInnerObj().m_fi,state.GetInnerObj().m_j,obj);
         //--- next iteration
         continue;
        }
      //--- check
      if(state.GetInnerObj().m_xupdated)
        {
         //--- check
         if(rep_status)
            rep.Rep(state.GetInnerObj().m_x,state.GetInnerObj().m_f,obj);
         //--- next iteration
         continue;
        }
      Print("ALGLIB: error in 'nleqsolve' (some derivatives were not provided?)");
      CAp::exception_happened=true;
      break;
     }
  }
//+------------------------------------------------------------------+
//| NLEQ solver results                                              |
//| INPUT PARAMETERS:                                                |
//|     State   -   algorithm state.                                 |
//| OUTPUT PARAMETERS:                                               |
//|     X       -   array[0..N-1], solution                          |
//|     Rep     -   optimization report:                             |
//|                 * Rep.TerminationType completetion code:         |
//|                     * -4    ERROR: algorithm has converged to the|
//|                             stationary point Xf which is local   |
//|                             minimum of f=F[0]^2+...+F[m-1]^2,    |
//|                             but is not solution of nonlinear     |
//|                             system.                              |
//|                     *  1    sqrt(f)<=EpsF.                       |
//|                     *  5    MaxIts steps was taken               |
//|                     *  7    stopping conditions are too          |
//|                             stringent, further improvement is    |
//|                             impossible                           |
//|                 * Rep.IterationsCount contains iterations count  |
//|                 * NFEV countains number of function calculations |
//|                 * ActiveConstraints contains number of active    |
//|                   constraints                                    |
//+------------------------------------------------------------------+
void CAlglib::NlEqResults(CNlEqStateShell &state,double &x[],
                          CNlEqReportShell &rep)
  {
   CNlEq::NlEqResults(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| NLEQ solver results                                              |
//| Buffered implementation of NLEQResults(), which uses             |
//| pre-allocated buffer to store X[]. If buffer size is too small,  |
//| it resizes buffer. It is intended to be used in the inner cycles |
//| of performance critical algorithms where array reallocation      |
//| penalty is too large to be ignored.                              |
//+------------------------------------------------------------------+
void CAlglib::NlEqResultsBuf(CNlEqStateShell &state,double &x[],
                             CNlEqReportShell &rep)
  {
   CNlEq::NlEqResultsBuf(state.GetInnerObj(),x,rep.GetInnerObj());
  }
//+------------------------------------------------------------------+
//| This subroutine restarts CG algorithm from new point. All        |
//| optimization parameters are left unchanged.                      |
//| This function allows to solve multiple optimization problems     |
//| (which must have same number of dimensions) without object       |
//| reallocation penalty.                                            |
//| INPUT PARAMETERS:                                                |
//|     State   -   structure used for reverse communication         |
//|                 previously allocated with MinCGCreate call.      |
//|     X       -   new starting point.                              |
//|     BndL    -   new lower bounds                                 |
//|     BndU    -   new upper bounds                                 |
//+------------------------------------------------------------------+
void CAlglib::NlEqRestartFrom(CNlEqStateShell &state,double &x[])
  {
   CNlEq::NlEqRestartFrom(state.GetInnerObj(),x);
  }
//+------------------------------------------------------------------+
//| Gamma function                                                   |
//| Input parameters:                                                |
//|     X   -   argument                                             |
//| Domain:                                                          |
//|     0 < X < 171.6                                                |
//|     -170 < X < 0, X is not an integer.                           |
//| Relative error:                                                  |
//|  arithmetic   domain     # trials      peak         rms          |
//|     IEEE    -170,-33      20000       2.3e-15     3.3e-16        |
//|     IEEE     -33,  33     20000       9.4e-16     2.2e-16        |
//|     IEEE      33, 171.6   20000       2.3e-15     3.2e-16        |
//+------------------------------------------------------------------+
double CAlglib::GammaFunction(const double x)
  {
   return(CGammaFunc::GammaFunc(x));
  }
//+------------------------------------------------------------------+
//| Natural logarithm of gamma function                              |
//| Input parameters:                                                |
//|     X       -   argument                                         |
//| Result:                                                          |
//|     logarithm of the absolute value of the Gamma(X).             |
//| Output parameters:                                               |
//|     SgnGam  -   sign(Gamma(X))                                   |
//| Domain:                                                          |
//|     0 < X < 2.55e305                                             |
//|     -2.55e305 < X < 0, X is not an integer.                      |
//| ACCURACY:                                                        |
//| arithmetic      domain        # trials     peak         rms      |
//|    IEEE    0, 3                 28000     5.4e-16     1.1e-16    |
//|    IEEE    2.718, 2.556e305     40000     3.5e-16     8.3e-17    |
//| The error criterion was relative when the function magnitude     |
//| was greater than one but absolute when it was less than one.     |
//| The following test used the relative error criterion, though     |
//| at certain points the relative error could be much higher than   |
//| indicated.                                                       |
//|    IEEE    -200, -4             10000     4.8e-16     1.3e-16    |
//+------------------------------------------------------------------+
double CAlglib::LnGamma(const double x,double &sgngam)
  {
//--- initialization
   sgngam=0;
//--- return result
   return(CGammaFunc::LnGamma(x,sgngam));
  }
//+------------------------------------------------------------------+
//| Error function                                                   |
//| The integral is                                                  |
//|                           x                                      |
//|                            -                                     |
//|                 2         | |          2                         |
//|   erf(x)  =  --------     |    exp( - t  ) dt.                   |
//|              sqrt(pi)   | |                                      |
//|                          -                                       |
//|                           0                                      |
//| For 0 <= |x| < 1, erf(x) = x * P4(x**2)/Q5(x**2); otherwise      |
//| erf(x) = 1 - erfc(x).                                            |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0,1         30000       3.7e-16     1.0e-16         |
//+------------------------------------------------------------------+
double CAlglib::ErrorFunction(const double x)
  {
   return(CNormalDistr::ErrorFunction(x));
  }
//+------------------------------------------------------------------+
//| Complementary error function                                     |
//|  1 - erf(x) =                                                    |
//|                           inf.                                   |
//|                             -                                    |
//|                  2         | |          2                        |
//|   erfc(x)  =  --------     |    exp( - t  ) dt                   |
//|               sqrt(pi)   | |                                     |
//|                           -                                      |
//|                            x                                     |
//| For small x, erfc(x) = 1 - erf(x); otherwise rational            |
//| approximations are computed.                                     |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0,26.6417   30000       5.7e-14     1.5e-14         |
//+------------------------------------------------------------------+
double CAlglib::ErrorFunctionC(const double x)
  {
   return(CNormalDistr::ErrorFunctionC(x));
  }
//+------------------------------------------------------------------+
//| Normal distribution function                                     |
//| Returns the area under the Gaussian probability density          |
//| function, integrated from minus infinity to x:                   |
//|                            x                                     |
//|                             -                                    |
//|                   1        | |          2                        |
//|    ndtr(x)  = ---------    |    exp( - t /2 ) dt                 |
//|               sqrt(2pi)  | |                                     |
//|                           -                                      |
//|                          -inf.                                   |
//|             =  ( 1 + erf(z) ) / 2                                |
//|             =  erfc(z) / 2                                       |
//| where z = x/sqrt(2). Computation is via the functions            |
//| erf and erfc.                                                    |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE     -13,0        30000       3.4e-14     6.7e-15         |
//+------------------------------------------------------------------+
double CAlglib::NormalDistribution(const double x)
  {
   return(CNormalDistr::NormalDistribution(x));
  }
//+------------------------------------------------------------------+
//| Normal distribution PDF                                          |
//| Returns Gaussian probability density function:                   |
//|                        1                                         |
//|            f(x)  = --------- * exp(-x^2/2)                       |
//|                    sqrt(2pi)                                     |
//| Cephes Math Library Release 2.8:  June, 2000                     |
//| Copyright 1984, 1987, 1988, 1992, 2000 by Stephen L. Moshier     |
//+------------------------------------------------------------------+
double CAlglib::NormalPDF(const double x)
  {
   return(CNormalDistr::NormalPDF(x));
  }
//+------------------------------------------------------------------+
//| Normal distribution CDF                                          |
//| Returns the area under the Gaussian probability density          |
//| function, integrated from minus infinity to x:                   |
//|                                    x                             |
//|                                     -                            |
//|                           1        | |          2                |
//|            ndtr(x)  = ---------    |    exp( - t /2 ) dt         |
//|                       sqrt(2pi)  | |                             |
//|                                   -                              |
//|                                  -inf.                           |
//|                                                                  |
//|                     =  ( 1 + erf(z) ) / 2                        |
//|                     =  erfc(z) / 2                               |
//| where z = x/sqrt(2). Computation is via the functions erf and    |
//|                      erfc.                                       |
//| ACCURACY:                                                        |
//|                              Relative error:                     |
//|      arithmetic   domain     # trials      peak         rms      |
//|         IEEE     -13,0        30000       3.4e-14     6.7e-15    |
//| Cephes Math Library Release 2.8:  June, 2000                     |
//| Copyright 1984, 1987, 1988, 1992, 2000 by Stephen L. Moshier     |
//+------------------------------------------------------------------+
double CAlglib::NormalCDF(const double x)
  {
   return(CNormalDistr::NormalCDF(x));
  }
//+------------------------------------------------------------------+
//| Inverse of the error function                                    |
//+------------------------------------------------------------------+
double CAlglib::InvErF(double e)
  {
   return(CNormalDistr::InvErF(e));
  }
//+------------------------------------------------------------------+
//| Inverse of Normal distribution function                          |
//| Returns the argument, x, for which the area under the            |
//| Gaussian probability density function (integrated from           |
//| minus infinity to x) is equal to y.                              |
//| For small arguments 0 < y < exp(-2), the program computes        |
//| z = sqrt( -2.0 * log(y) );  then the approximation is            |
//| x = z - log(z)/z  - (1/z) P(1/z) / Q(1/z).                       |
//| There are two rational functions P/Q, one for 0 < y < exp(-32)   |
//| and the other for y up to exp(-2).  For larger arguments,        |
//| w = y - 0.5, and  x/sqrt(2pi) = w + w**3 R(w**2)/S(w**2)).       |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain        # trials      peak         rms        |
//|    IEEE     0.125, 1        20000       7.2e-16     1.3e-16      |
//|    IEEE     3e-308, 0.135   50000       4.6e-16     9.8e-17      |
//+------------------------------------------------------------------+
double CAlglib::InvNormalDistribution(const double y0)
  {
   return(CNormalDistr::InvNormalDistribution(y0));
  }
//+------------------------------------------------------------------+
//| Inverse of Normal CDF                                            |
//| Returns the argument, x, for which the area under the Gaussian   |
//| probability density function (integrated from minus infinity to  |
//| x) is equal to y.                                                |
//| For small arguments 0 < y < exp(-2), the program computes        |
//|   z = sqrt( -2.0 * log(y) );  then the approximation is          |
//|   x = z - log(z)/z  - (1/z) P(1/z) / Q(1/z).                     |
//| There are two rational functions P/Q, one for 0 < y < exp(-32)   |
//| and the other for y up to exp(-2).  For larger arguments,        |
//|   w = y - 0.5, and  x/sqrt(2pi) = w + w**3 R(w**2)/S(w**2)).     |
//| ACCURACY:                                                        |
//|                           Relative error:                        |
//|      arithmetic   domain        # trials      peak        rms    |
//|        IEEE     0.125, 1        20000       7.2e-16     1.3e-16  |
//|        IEEE     3e-308, 0.135   50000       4.6e-16     9.8e-17  |
//| Cephes Math Library Release 2.8:  June, 2000                     |
//| Copyright 1984, 1987, 1988, 1992, 2000 by Stephen L. Moshier     |
//+------------------------------------------------------------------+
double CAlglib::InvNormalCDF(const double y0)
  {
   return(CNormalDistr::InvNormalCDF(y0));
  }
//+------------------------------------------------------------------+
//| Bivariate normal PDF                                             |
//| Returns probability density function of the bivariate  Gaussian  |
//| with correlation parameter equal to Rho:                         |
//|                      1              (    x^2 - 2*rho*x*y + y^2  )|
//| f(x,y,rho) = ----------------- * exp( - ----------------------- )|
//|              2pi*sqrt(1-rho^2)      (        2*(1-rho^2)        )|
//| with -1<rho<+1 and arbitrary x, y.                               |
//| This function won't fail as long as Rho is in (-1,+1) range.     |
//+------------------------------------------------------------------+
double CAlglib::BivariateNormalPDF(const double x,const double y,const double rho)
  {
   return(CNormalDistr::BivariateNormalPDF(x,y,rho));
  }
//+------------------------------------------------------------------+
//| Bivariate normal CDF                                             |
//| Returns the area under the bivariate Gaussian  PDF  with         |
//| correlation parameter equal to Rho, integrated from minus        |
//| infinity to (x,y):                                               |
//|                                       x      y                   |
//|                                       -      -                   |
//|                         1            | |    | |                  |
//| bvn(x,y,rho) = -------------------   |      |   f(u,v,rho)*du*dv |
//|                 2pi*sqrt(1-rho^2)  | |    | |                    |
//|                                     -      -                     |
//|                                   -INF   -INF                    |
//| where                                                            |
//|                            (    u^2 - 2*rho*u*v + v^2  )         |
//|          f(u,v,rho)   = exp( - ----------------------- )         |
//|                            (        2*(1-rho^2)        )         |
//| with -1<rho<+1 and arbitrary x, y.                               |
//| This subroutine uses high-precision approximation scheme proposed|
//| by Alan Genz in "Numerical Computation of Rectangular Bivariate  |
//| and Trivariate Normal and t probabilities", which computes CDF   |
//| with absolute error roughly equal to 1e-14.                      |
//| This function won't fail as long as Rho is in (-1,+1) range.     |
//+------------------------------------------------------------------+
double CAlglib::BivariateNormalCDF(double x,double y,const double rho)
  {
   return(CNormalDistr::BivariateNormalCDF(x,y,rho));
  }
//+------------------------------------------------------------------+
//| Incomplete gamma integral                                        |
//| The function is defined by                                       |
//|                           x                                      |
//|                            -                                     |
//|                   1       | |  -t  a-1                           |
//|  igam(a,x)  =   -----     |   e   t   dt.                        |
//|                  -      | |                                      |
//|                 | (a)    -                                       |
//|                           0                                      |
//| In this implementation both arguments must be positive.          |
//| The integral is evaluated by either a power series or            |
//| continued fraction expansion, depending on the relative          |
//| values of a and x.                                               |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0,30       200000       3.6e-14     2.9e-15         |
//|    IEEE      0,100      300000       9.9e-14     1.5e-14         |
//+------------------------------------------------------------------+
double CAlglib::IncompleteGamma(const double a,const double x)
  {
   return(CIncGammaF::IncompleteGamma(a,x));
  }
//+------------------------------------------------------------------+
//| Complemented incomplete gamma integral                           |
//| The function is defined by                                       |
//|  igamc(a,x)   =   1 - igam(a,x)                                  |
//|                            inf.                                  |
//|                              -                                   |
//|                     1       | |  -t  a-1                         |
//|               =   -----     |   e   t   dt.                      |
//|                    -      | |                                    |
//|                   | (a)    -                                     |
//|                             x                                    |
//| In this implementation both arguments must be positive.          |
//| The integral is evaluated by either a power series or            |
//| continued fraction expansion, depending on the relative          |
//| values of a and x.                                               |
//| ACCURACY:                                                        |
//| Tested at random a, x.                                           |
//|                a         x                      Relative error:  |
//| arithmetic   domain   domain     # trials      peak         rms  |
//|    IEEE     0.5,100   0,100      200000       1.9e-14     1.7e-15|
//|    IEEE     0.01,0.5  0,100      200000       1.4e-13     1.6e-15|
//+------------------------------------------------------------------+
double CAlglib::IncompleteGammaC(const double a,const double x)
  {
   return(CIncGammaF::IncompleteGammaC(a,x));
  }
//+------------------------------------------------------------------+
//| Inverse of complemented imcomplete gamma integral                |
//| Given p, the function finds x such that                          |
//|  igamc( a, x ) = p.                                              |
//| Starting with the approximate value                              |
//|         3                                                        |
//|  x = a t                                                         |
//|  where                                                           |
//|  t = 1 - d - ndtri(p) sqrt(d)                                    |
//| and                                                              |
//|  d = 1/9a,                                                       |
//| the routine performs up to 10 Newton iterations to find the      |
//| root of igamc(a,x) - p = 0.                                      |
//| ACCURACY:                                                        |
//| Tested at random a, p in the intervals indicated.                |
//|                a        p                      Relative error:   |
//| arithmetic   domain   domain     # trials      peak        rms   |
//|    IEEE     0.5,100   0,0.5       100000       1.0e-14    1.7e-15|
//|    IEEE     0.01,0.5  0,0.5       100000       9.0e-14    3.4e-15|
//|    IEEE    0.5,10000  0,0.5        20000       2.3e-13    3.8e-14|
//+------------------------------------------------------------------+
double CAlglib::InvIncompleteGammaC(const double a,const double y0)
  {
   return(CIncGammaF::InvIncompleteGammaC(a,y0));
  }
//+------------------------------------------------------------------+
//| Airy function                                                    |
//| Solution of the differential equation                            |
//| y"(x) = xy.                                                      |
//| The function returns the two independent solutions Ai, Bi        |
//| and their first derivatives Ai'(x), Bi'(x).                      |
//| Evaluation is by power series summation for small x,             |
//| by rational minimax approximations for large x.                  |
//| ACCURACY:                                                        |
//| Error criterion is absolute when function <= 1, relative         |
//| when function > 1, except * denotes relative error criterion.    |
//| For large negative x, the absolute error increases as x^1.5.     |
//| For large positive x, the relative error increases as x^1.5.     |
//| Arithmetic  domain   function  # trials      peak         rms    |
//| IEEE        -10, 0     Ai        10000       1.6e-15     2.7e-16 |
//| IEEE          0, 10    Ai        10000       2.3e-14*    1.8e-15*|
//| IEEE        -10, 0     Ai'       10000       4.6e-15     7.6e-16 |
//| IEEE          0, 10    Ai'       10000       1.8e-14*    1.5e-15*|
//| IEEE        -10, 10    Bi        30000       4.2e-15     5.3e-16 |
//| IEEE        -10, 10    Bi'       30000       4.9e-15     7.3e-16 |
//+------------------------------------------------------------------+
void CAlglib::Airy(const double x,double &ai,double &aip,double &bi,
                   double &bip)
  {
//--- initialization
   ai=0;
   aip=0;
   bi=0;
   bip=0;
//--- function call
   CAiryF::Airy(x,ai,aip,bi,bip);
  }
//+------------------------------------------------------------------+
//| Bessel function of order zero                                    |
//| Returns Bessel function of order zero of the argument.           |
//| The domain is divided into the intervals [0, 5] and              |
//| (5, infinity). In the first interval the following rational      |
//| approximation is used:                                           |
//|        2         2                                               |
//| (w - r  ) (w - r  ) P (w) / Q (w)                                |
//|       1         2    3       8                                   |
//|            2                                                     |
//| where w = x  and the two r's are zeros of the function.          |
//| In the second interval, the Hankel asymptotic expansion          |
//| is employed with two rational functions of degree 6/6            |
//| and 7/7.                                                         |
//| ACCURACY:                                                        |
//|                      Absolute error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0, 30       60000       4.2e-16     1.1e-16         |
//+------------------------------------------------------------------+
double CAlglib::BesselJ0(const double x)
  {
   return(CBessel::BesselJ0(x));
  }
//+------------------------------------------------------------------+
//| Bessel function of order one                                     |
//| Returns Bessel function of order one of the argument.            |
//| The domain is divided into the intervals [0, 8] and              |
//| (8, infinity). In the first interval a 24 term Chebyshev         |
//| expansion is used. In the second, the asymptotic                 |
//| trigonometric representation is employed using two               |
//| rational functions of degree 5/5.                                |
//| ACCURACY:                                                        |
//|                      Absolute error:                             |
//| arithmetic   domain      # trials      peak         rms          |
//|    IEEE      0, 30       30000       2.6e-16     1.1e-16         |
//+------------------------------------------------------------------+
double CAlglib::BesselJ1(const double x)
  {
   return(CBessel::BesselJ1(x));
  }
//+------------------------------------------------------------------+
//| Bessel function of integer order                                 |
//| Returns Bessel function of order n, where n is a                 |
//| (possibly negative) integer.                                     |
//| The ratio of jn(x) to j0(x) is computed by backward              |
//| recurrence.  First the ratio jn/jn-1 is found by a               |
//| continued fraction expansion.  Then the recurrence               |
//| relating successive orders is applied until j0 or j1 is          |
//| reached.                                                         |
//| If n = 0 or 1 the routine for j0 or j1 is called                 |
//| directly.                                                        |
//| ACCURACY:                                                        |
//|                      Absolute error:                             |
//| arithmetic   range      # trials      peak         rms           |
//|    IEEE      0, 30        5000       4.4e-16     7.9e-17         |
//| Not suitable for large n or x. Use jv() (fractional order)       |
//| instead.                                                         |
//+------------------------------------------------------------------+
double CAlglib::BesselJN(const int n,const double x)
  {
   return(CBessel::BesselJN(n,x));
  }
//+------------------------------------------------------------------+
//| Bessel function of the second kind, order zero                   |
//| Returns Bessel function of the second kind, of order             |
//| zero, of the argument.                                           |
//| The domain is divided into the intervals [0, 5] and              |
//| (5, infinity). In the first interval a rational approximation    |
//| R(x) is employed to compute                                      |
//|   y0(x)  = R(x)  +   2 * log(x) * j0(x) / PI.                    |
//| Thus a call to j0() is required.                                 |
//| In the second interval, the Hankel asymptotic expansion          |
//| is employed with two rational functions of degree 6/6            |
//| and 7/7.                                                         |
//| ACCURACY:                                                        |
//|  Absolute error, when y0(x) < 1; else relative error:            |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0, 30       30000       1.3e-15     1.6e-16         |
//+------------------------------------------------------------------+
double CAlglib::BesselY0(const double x)
  {
   return(CBessel::BesselY0(x));
  }
//+------------------------------------------------------------------+
//| Bessel function of second kind of order one                      |
//| Returns Bessel function of the second kind of order one          |
//| of the argument.                                                 |
//| The domain is divided into the intervals [0, 8] and              |
//| (8, infinity). In the first interval a 25 term Chebyshev         |
//| expansion is used, and a call to j1() is required.               |
//| In the second, the asymptotic trigonometric representation       |
//| is employed using two rational functions of degree 5/5.          |
//| ACCURACY:                                                        |
//|                      Absolute error:                             |
//| arithmetic   domain      # trials      peak         rms          |
//|    IEEE      0, 30       30000       1.0e-15     1.3e-16         |
//+------------------------------------------------------------------+
double CAlglib::BesselY1(const double x)
  {
   return(CBessel::BesselY1(x));
  }
//+------------------------------------------------------------------+
//| Bessel function of second kind of integer order                  |
//| Returns Bessel function of order n, where n is a                 |
//| (possibly negative) integer.                                     |
//| The function is evaluated by forward recurrence on               |
//| n, starting with values computed by the routines                 |
//| y0() and y1().                                                   |
//| If n = 0 or 1 the routine for y0 or y1 is called                 |
//| directly.                                                        |
//| ACCURACY:                                                        |
//|                      Absolute error, except relative             |
//|                      when y > 1:                                 |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0, 30       30000       3.4e-15     4.3e-16         |
//+------------------------------------------------------------------+
double CAlglib::BesselYN(const int n,const double x)
  {
   return(CBessel::BesselYN(n,x));
  }
//+------------------------------------------------------------------+
//| Modified Bessel function of order zero                           |
//| Returns modified Bessel function of order zero of the            |
//| argument.                                                        |
//| The function is defined as i0(x) = j0( ix ).                     |
//| The range is partitioned into the two intervals [0,8] and        |
//| (8, infinity).  Chebyshev polynomial expansions are employed     |
//| in each interval.                                                |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0,30        30000       5.8e-16     1.4e-16         |
//+------------------------------------------------------------------+
double CAlglib::BesselI0(const double x)
  {
   return(CBessel::BesselI0(x));
  }
//+------------------------------------------------------------------+
//| Modified Bessel function of order one                            |
//| Returns modified Bessel function of order one of the             |
//| argument.                                                        |
//| The function is defined as i1(x) = -i j1( ix ).                  |
//| The range is partitioned into the two intervals [0,8] and        |
//| (8, infinity).  Chebyshev polynomial expansions are employed     |
//| in each interval.                                                |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0, 30       30000       1.9e-15     2.1e-16         |
//+------------------------------------------------------------------+
double CAlglib::BesselI1(const double x)
  {
   return(CBessel::BesselI1(x));
  }
//+------------------------------------------------------------------+
//| Modified Bessel function, second kind, order zero                |
//| Returns modified Bessel function of the second kind              |
//| of order zero of the argument.                                   |
//| The range is partitioned into the two intervals [0,8] and        |
//| (8, infinity).  Chebyshev polynomial expansions are employed     |
//| in each interval.                                                |
//| ACCURACY:                                                        |
//| Tested at 2000 random points between 0 and 8.  Peak absolute     |
//| error (relative when K0 > 1) was 1.46e-14; rms, 4.26e-15.        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0, 30       30000       1.2e-15     1.6e-16         |
//+------------------------------------------------------------------+
double CAlglib::BesselK0(const double x)
  {
   return(CBessel::BesselK0(x));
  }
//+------------------------------------------------------------------+
//| Modified Bessel function, second kind, order one                 |
//| Computes the modified Bessel function of the second kind         |
//| of order one of the argument.                                    |
//| The range is partitioned into the two intervals [0,2] and        |
//| (2, infinity).  Chebyshev polynomial expansions are employed     |
//| in each interval.                                                |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0, 30       30000       1.2e-15     1.6e-16         |
//+------------------------------------------------------------------+
double CAlglib::BesselK1(const double x)
  {
   return(CBessel::BesselK1(x));
  }
//+------------------------------------------------------------------+
//| Modified Bessel function, second kind, integer order             |
//| Returns modified Bessel function of the second kind              |
//| of order n of the argument.                                      |
//| The range is partitioned into the two intervals [0,9.55] and     |
//| (9.55, infinity).  An ascending power series is used in the      |
//| low range, and an asymptotic expansion in the high range.        |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0,30        90000       1.8e-8      3.0e-10         |
//| Error is high only near the crossover point x = 9.55             |
//| between the two expansions used.                                 |
//+------------------------------------------------------------------+
double CAlglib::BesselKN(const int nn,const double x)
  {
   return(CBessel::BesselKN(nn,x));
  }
//+------------------------------------------------------------------+
//| Beta function                                                    |
//|                   -     -                                        |
//|                  | (a) | (b)                                     |
//| beta( a, b )  =  -----------.                                    |
//|                     -                                            |
//|                    | (a+b)                                       |
//| For large arguments the logarithm of the function is             |
//| evaluated using lgam(), then exponentiated.                      |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE       0,30       30000       8.1e-14     1.1e-14         |
//+------------------------------------------------------------------+
double CAlglib::Beta(const double a,const double b)
  {
   return(CBetaF::Beta(a,b));
  }
//+------------------------------------------------------------------+
//| Incomplete beta integral                                         |
//| Returns incomplete beta integral of the arguments, evaluated     |
//| from zero to x.  The function is defined as                      |
//|                  x                                               |
//|     -            -                                               |
//|    | (a+b)      | |  a-1     b-1                                 |
//|  -----------    |   t   (1-t)   dt.                              |
//|   -     -     | |                                                |
//|  | (a) | (b)   -                                                 |
//|                 0                                                |
//| The domain of definition is 0 <= x <= 1.  In this                |
//| implementation a and b are restricted to positive values.        |
//| The integral from x to 1 may be obtained by the symmetry         |
//| relation                                                         |
//|    1 - incbet( a, b, x )  =  incbet( b, a, 1-x ).                |
//| The integral is evaluated by a continued fraction expansion      |
//| or, when b*x is small, by a power series.                        |
//| ACCURACY:                                                        |
//| Tested at uniformly distributed random points (a,b,x) with a and |
//| b in "domain" and x between 0 and 1.                             |
//|                                        Relative error            |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0,5         10000       6.9e-15     4.5e-16         |
//|    IEEE      0,85       250000       2.2e-13     1.7e-14         |
//|    IEEE      0,1000      30000       5.3e-12     6.3e-13         |
//|    IEEE      0,10000    250000       9.3e-11     7.1e-12         |
//|    IEEE      0,100000    10000       8.7e-10     4.8e-11         |
//| Outputs smaller than the IEEE gradual underflow threshold        |
//| were excluded from these statistics.                             |
//+------------------------------------------------------------------+
double CAlglib::IncompleteBeta(const double a,const double b,const double x)
  {
   return(CIncBetaF::IncompleteBeta(a,b,x));
  }
//+------------------------------------------------------------------+
//| Inverse of imcomplete beta integral                              |
//| Given y, the function finds x such that                          |
//|  incbet( a, b, x ) = y .                                         |
//| The routine performs interval halving or Newton iterations to    |
//| find the root of incbet(a,b,x) - y = 0.                          |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//|                x     a,b                                         |
//| arithmetic   domain  domain  # trials    peak       rms          |
//|    IEEE      0,1    .5,10000   50000    5.8e-12   1.3e-13        |
//|    IEEE      0,1   .25,100    100000    1.8e-13   3.9e-15        |
//|    IEEE      0,1     0,5       50000    1.1e-12   5.5e-15        |
//| With a and b constrained to half-integer or integer values:      |
//|    IEEE      0,1    .5,10000   50000    5.8e-12   1.1e-13        |
//|    IEEE      0,1    .5,100    100000    1.7e-14   7.9e-16        |
//| With a = .5, b constrained to half-integer or integer values:    |
//|    IEEE      0,1    .5,10000   10000    8.3e-11   1.0e-11        |
//+------------------------------------------------------------------+
double CAlglib::InvIncompleteBeta(const double a,const double b,double y)
  {
   return(CIncBetaF::InvIncompleteBeta(a,b,y));
  }
//+------------------------------------------------------------------+
//| Binomial distribution                                            |
//| Returns the sum of the terms 0 through k of the Binomial         |
//| probability density:                                             |
//|   k                                                              |
//|   --  ( n )   j      n-j                                         |
//|   >   (   )  p  (1-p)                                            |
//|   --  ( j )                                                      |
//|  j=0                                                             |
//| The terms are not summed directly; instead the incomplete        |
//| beta integral is employed, according to the formula              |
//| y = bdtr( k, n, p ) = incbet( n-k, k+1, 1-p ).                   |
//| The arguments must be positive, with p ranging from 0 to 1.      |
//| ACCURACY:                                                        |
//| Tested at random points (a,b,p), with p between 0 and 1.         |
//|               a,b                     Relative error:            |
//| arithmetic  domain     # trials      peak         rms            |
//|  For p between 0.001 and 1:                                      |
//|    IEEE     0,100       100000      4.3e-15     2.6e-16          |
//+------------------------------------------------------------------+
double CAlglib::BinomialDistribution(const int k,const int n,const double p)
  {
   return(CBinomialDistr::BinomialDistribution(k,n,p));
  }
//+------------------------------------------------------------------+
//| Complemented binomial distribution                               |
//| Returns the sum of the terms k+1 through n of the Binomial       |
//| probability density:                                             |
//|   n                                                              |
//|   --  ( n )   j      n-j                                         |
//|   >   (   )  p  (1-p)                                            |
//|   --  ( j )                                                      |
//|  j=k+1                                                           |
//| The terms are not summed directly; instead the incomplete        |
//| beta integral is employed, according to the formula              |
//| y = bdtrc( k, n, p ) = incbet( k+1, n-k, p ).                    |
//| The arguments must be positive, with p ranging from 0 to 1.      |
//| ACCURACY:                                                        |
//| Tested at random points (a,b,p).                                 |
//|               a,b                     Relative error:            |
//| arithmetic  domain     # trials      peak         rms            |
//|  For p between 0.001 and 1:                                      |
//|    IEEE     0,100       100000      6.7e-15     8.2e-16          |
//|  For p between 0 and .001:                                       |
//|    IEEE     0,100       100000      1.5e-13     2.7e-15          |
//+------------------------------------------------------------------+
double CAlglib::BinomialComplDistribution(const int k,const int n,const double p)
  {
   return(CBinomialDistr::BinomialComplDistribution(k,n,p));
  }
//+------------------------------------------------------------------+
//| Inverse binomial distribution                                    |
//| Finds the event probability p such that the sum of the           |
//| terms 0 through k of the Binomial probability density            |
//| is equal to the given cumulative probability y.                  |
//| This is accomplished using the inverse beta integral             |
//| function and the relation                                        |
//| 1 - p = incbi( n-k, k+1, y ).                                    |
//| ACCURACY:                                                        |
//| Tested at random points (a,b,p).                                 |
//|               a,b                     Relative error:            |
//| arithmetic  domain     # trials      peak         rms            |
//|  For p between 0.001 and 1:                                      |
//|    IEEE     0,100       100000      2.3e-14     6.4e-16          |
//|    IEEE     0,10000     100000      6.6e-12     1.2e-13          |
//|  For p between 10^-6 and 0.001:                                  |
//|    IEEE     0,100       100000      2.0e-12     1.3e-14          |
//|    IEEE     0,10000     100000      1.5e-12     3.2e-14          |
//+------------------------------------------------------------------+
double CAlglib::InvBinomialDistribution(const int k,const int n,const double y)
  {
   return(CBinomialDistr::InvBinomialDistribution(k,n,y));
  }
//+------------------------------------------------------------------+
//| Calculation of the value of the Chebyshev polynomials of the     |
//| first and second kinds.                                          |
//| Parameters:                                                      |
//|     r   -   polynomial kind, either 1 or 2.                      |
//|     n   -   degree, n>=0                                         |
//|     x   -   argument, -1 <= x <= 1                               |
//| Result:                                                          |
//|     the value of the Chebyshev polynomial at x                   |
//+------------------------------------------------------------------+
double CAlglib::ChebyshevCalculate(int r,const int n,const double x)
  {
   return(CChebyshev::ChebyshevCalculate(r,n,x));
  }
//+------------------------------------------------------------------+
//| Summation of Chebyshev polynomials using Clenshaw?s recurrence   |
//| formula.                                                         |
//| This routine calculates                                          |
//|     c[0]*T0(x) + c[1]*T1(x) + ... + c[N]*TN(x)                   |
//| or                                                               |
//|     c[0]*U0(x) + c[1]*U1(x) + ... + c[N]*UN(x)                   |
//| depending on the R.                                              |
//| Parameters:                                                      |
//|     r   -   polynomial kind, either 1 or 2.                      |
//|     n   -   degree, n>=0                                         |
//|     x   -   argument                                             |
//| Result:                                                          |
//|     the value of the Chebyshev polynomial at x                   |
//+------------------------------------------------------------------+
double CAlglib::ChebyshevSum(double &c[],const int r,const int n,const double x)
  {
   return(CChebyshev::ChebyshevSum(c,r,n,x));
  }
//+------------------------------------------------------------------+
//| Representation of Tn as C[0] + C[1]*X + ... + C[N]*X^N           |
//| Input parameters:                                                |
//|     N   -   polynomial degree, n>=0                              |
//| Output parameters:                                               |
//|     C   -   coefficients                                         |
//+------------------------------------------------------------------+
void CAlglib::ChebyshevCoefficients(const int n,double &c[])
  {
   CChebyshev::ChebyshevCoefficients(n,c);
  }
//+------------------------------------------------------------------+
//| Conversion of a series of Chebyshev polynomials to a power       |
//| series.                                                          |
//| Represents A[0]*T0(x) + A[1]*T1(x) + ... + A[N]*Tn(x) as         |
//| B[0] + B[1]*X + ... + B[N]*X^N.                                  |
//| Input parameters:                                                |
//|     A   -   Chebyshev series coefficients                        |
//|     N   -   degree, N>=0                                         |
//| Output parameters                                                |
//|     B   -   power series coefficients                            |
//+------------------------------------------------------------------+
void CAlglib::FromChebyshev(double &a[],const int n,double &b[])
  {
   CChebyshev::FromChebyshev(a,n,b);
  }
//+------------------------------------------------------------------+
//| Chi-square distribution                                          |
//| Returns the area under the left hand tail (from 0 to x)          |
//| of the Chi square probability density function with              |
//| v degrees of freedom.                                            |
//|                                   x                              |
//|                                    -                             |
//|                        1          | |  v/2-1  -t/2               |
//|  P( x | v )   =   -----------     |   t      e     dt            |
//|                    v/2  -       | |                              |
//|                   2    | (v/2)   -                               |
//|                                   0                              |
//| where x is the Chi-square variable.                              |
//| The incomplete gamma integral is used, according to the          |
//| formula                                                          |
//| y = chdtr( v, x ) = igam( v/2.0, x/2.0 ).                        |
//| The arguments must both be positive.                             |
//| ACCURACY:                                                        |
//| See incomplete gamma function                                    |
//+------------------------------------------------------------------+
double CAlglib::ChiSquareDistribution(const double v,const double x)
  {
   return(CChiSquareDistr::ChiSquareDistribution(v,x));
  }
//+------------------------------------------------------------------+
//| Complemented Chi-square distribution                             |
//| Returns the area under the right hand tail (from x to            |
//| infinity) of the Chi square probability density function         |
//| with v degrees of freedom:                                       |
//|                                  inf.                            |
//|                                    -                             |
//|                        1          | |  v/2-1  -t/2               |
//|  P( x | v )   =   -----------     |   t      e     dt            |
//|                    v/2  -       | |                              |
//|                   2    | (v/2)   -                               |
//|                                   x                              |
//| where x is the Chi-square variable.                              |
//| The incomplete gamma integral is used, according to the          |
//| formula                                                          |
//| y = chdtr( v, x ) = igamc( v/2.0, x/2.0 ).                       |
//| The arguments must both be positive.                             |
//| ACCURACY:                                                        |
//| See incomplete gamma function                                    |
//+------------------------------------------------------------------+
double CAlglib::ChiSquareComplDistribution(const double v,const double x)
  {
   return(CChiSquareDistr::ChiSquareComplDistribution(v,x));
  }
//+------------------------------------------------------------------+
//| Inverse of complemented Chi-square distribution                  |
//| Finds the Chi-square argument x such that the integral           |
//| from x to infinity of the Chi-square density is equal            |
//| to the given cumulative probability y.                           |
//| This is accomplished using the inverse gamma integral            |
//| function and the relation                                        |
//|    x/2 = igami( df/2, y );                                       |
//| ACCURACY:                                                        |
//| See inverse incomplete gamma function                            |
//+------------------------------------------------------------------+
double CAlglib::InvChiSquareDistribution(const double v,const double y)
  {
   return(CChiSquareDistr::InvChiSquareDistribution(v,y));
  }
//+------------------------------------------------------------------+
//| Dawson's Integral                                                |
//| Approximates the integral                                        |
//|                             x                                    |
//|                             -                                    |
//|                      2     | |        2                          |
//|  dawsn(x)  =  exp( -x  )   |    exp( t  ) dt                     |
//|                          | |                                     |
//|                           -                                      |
//|                           0                                      |
//| Three different rational approximations are employed, for        |
//| the intervals 0 to 3.25; 3.25 to 6.25; and 6.25 up.              |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0,10        10000       6.9e-16     1.0e-16         |
//+------------------------------------------------------------------+
double CAlglib::DawsonIntegral(const double x)
  {
   return(CDawson::DawsonIntegral(x));
  }
//+------------------------------------------------------------------+
//| Complete elliptic integral of the first kind                     |
//| Approximates the integral                                        |
//|            pi/2                                                  |
//|             -                                                    |
//|            | |                                                   |
//|            |           dt                                        |
//| K(m)  =    |    ------------------                               |
//|            |                   2                                 |
//|          | |    sqrt( 1 - m sin t )                              |
//|           -                                                      |
//|            0                                                     |
//| using the approximation                                          |
//|     P(x)  -  log x Q(x).                                         |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE       0,1        30000       2.5e-16     6.8e-17         |
//+------------------------------------------------------------------+
double CAlglib::EllipticIntegralK(const double m)
  {
   return(CElliptic::EllipticIntegralK(m));
  }
//+------------------------------------------------------------------+
//| Complete elliptic integral of the first kind                     |
//| Approximates the integral                                        |
//|            pi/2                                                  |
//|             -                                                    |
//|            | |                                                   |
//|            |           dt                                        |
//| K(m)  =    |    ------------------                               |
//|            |                   2                                 |
//|          | |    sqrt( 1 - m sin t )                              |
//|           -                                                      |
//|            0                                                     |
//| where m = 1 - m1, using the approximation                        |
//|     P(x)  -  log x Q(x).                                         |
//| The argument m1 is used rather than m so that the logarithmic    |
//| singularity at m = 1 will be shifted to the origin; this         |
//| preserves maximum accuracy.                                      |
//| K(0) = pi/2.                                                     |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE       0,1        30000       2.5e-16     6.8e-17         |
//+------------------------------------------------------------------+
double CAlglib::EllipticIntegralKhighPrecision(const double m1)
  {
   return(CElliptic::EllipticIntegralKhighPrecision(m1));
  }
//+------------------------------------------------------------------+
//| Incomplete elliptic integral of the first kind F(phi|m)          |
//| Approximates the integral                                        |
//|                phi                                               |
//|                 -                                                |
//|                | |                                               |
//|                |           dt                                    |
//| F(phi_\m)  =   |    ------------------                           |
//|                |                   2                             |
//|              | |    sqrt( 1 - m sin t )                          |
//|               -                                                  |
//|                0                                                 |
//| of amplitude phi and modulus m, using the arithmetic -           |
//| geometric mean algorithm.                                        |
//| ACCURACY:                                                        |
//| Tested at random points with m in [0, 1] and phi as indicated.   |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE     -10,10       200000      7.4e-16     1.0e-16         |
//+------------------------------------------------------------------+
double CAlglib::IncompleteEllipticIntegralK(const double phi,const double m)
  {
   return(CElliptic::IncompleteEllipticIntegralK(phi,m));
  }
//+------------------------------------------------------------------+
//| Complete elliptic integral of the second kind                    |
//| Approximates the integral                                        |
//|            pi/2                                                  |
//|             -                                                    |
//|            | |                 2                                 |
//| E(m)  =    |    sqrt( 1 - m sin t ) dt                           |
//|          | |                                                     |
//|           -                                                      |
//|            0                                                     |
//| using the approximation                                          |
//|      P(x)  -  x log x Q(x).                                      |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE       0, 1       10000       2.1e-16     7.3e-17         |
//+------------------------------------------------------------------+
double CAlglib::EllipticIntegralE(const double m)
  {
   return(CElliptic::EllipticIntegralE(m));
  }
//+------------------------------------------------------------------+
//| Incomplete elliptic integral of the second kind                  |
//| Approximates the integral                                        |
//|                phi                                               |
//|                 -                                                |
//|                | |                                               |
//|                |                   2                             |
//| E(phi_\m)  =   |    sqrt( 1 - m sin t ) dt                       |
//|                |                                                 |
//|              | |                                                 |
//|               -                                                  |
//|                0                                                 |
//| of amplitude phi and modulus m, using the arithmetic -           |
//| geometric mean algorithm.                                        |
//| ACCURACY:                                                        |
//| Tested at random arguments with phi in [-10, 10] and m in        |
//| [0, 1].                                                          |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE     -10,10      150000       3.3e-15     1.4e-16         |
//+------------------------------------------------------------------+
double CAlglib::IncompleteEllipticIntegralE(const double phi,const double m)
  {
   return(CElliptic::IncompleteEllipticIntegralE(phi,m));
  }
//+------------------------------------------------------------------+
//| Exponential integral Ei(x)                                       |
//|               x                                                  |
//|                -     t                                           |
//|               | |   e                                            |
//|    Ei(x) =   -|-   ---  dt .                                     |
//|             | |     t                                            |
//|              -                                                   |
//|             -inf                                                 |
//| Not defined for x <= 0.                                          |
//| See also expn.c.                                                 |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE       0,100       50000      8.6e-16     1.3e-16         |
//+------------------------------------------------------------------+
double CAlglib::ExponentialIntegralEi(const double x)
  {
   return(CExpIntegrals::ExponentialIntegralEi(x));
  }
//+------------------------------------------------------------------+
//| Exponential integral En(x)                                       |
//| Evaluates the exponential integral                               |
//|                 inf.                                             |
//|                   -                                              |
//|                  | |   -xt                                       |
//|                  |    e                                          |
//|      E (x)  =    |    ----  dt.                                  |
//|       n          |      n                                        |
//|                | |     t                                         |
//|                 -                                                |
//|                  1                                               |
//| Both n and x must be nonnegative.                                |
//| The routine employs either a power series, a continued           |
//| fraction, or an asymptotic formula depending on the              |
//| relative values of n and x.                                      |
//| ACCURACY:                                                        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0, 30       10000       1.7e-15     3.6e-16         |
//+------------------------------------------------------------------+
double CAlglib::ExponentialIntegralEn(const double x,const int n)
  {
   return(CExpIntegrals::ExponentialIntegralEn(x,n));
  }
//+------------------------------------------------------------------+
//| F distribution                                                   |
//| Returns the area from zero to x under the F density              |
//| function (also known as Snedcor's density or the                 |
//| variance ratio density).  This is the density                    |
//| of x = (u1/df1)/(u2/df2), where u1 and u2 are random             |
//| variables having Chi square distributions with df1               |
//| and df2 degrees of freedom, respectively.                        |
//| The incomplete beta integral is used, according to the           |
//| formula                                                          |
//| P(x) = incbet( df1/2, df2/2, (df1*x/(df2 + df1*x) ).             |
//| The arguments a and b are greater than zero, and x is            |
//| nonnegative.                                                     |
//| ACCURACY:                                                        |
//| Tested at random points (a,b,x).                                 |
//|                x     a,b                     Relative error:     |
//| arithmetic  domain  domain     # trials      peak         rms    |
//|    IEEE      0,1    0,100       100000      9.8e-15     1.7e-15  |
//|    IEEE      1,5    0,100       100000      6.5e-15     3.5e-16  |
//|    IEEE      0,1    1,10000     100000      2.2e-11     3.3e-12  |
//|    IEEE      1,5    1,10000     100000      1.1e-11     1.7e-13  |
//+------------------------------------------------------------------+
double CAlglib::FDistribution(const int a,const int b,const double x)
  {
   return(CFDistr::FDistribution(a,b,x));
  }
//+------------------------------------------------------------------+
//| Complemented F distribution                                      |
//| Returns the area from x to infinity under the F density          |
//| function (also known as Snedcor's density or the                 |
//| variance ratio density).                                         |
//|                      inf.                                        |
//|                       -                                          |
//|              1       | |  a-1      b-1                           |
//| 1-P(x)  =  ------    |   t    (1-t)    dt                        |
//|            B(a,b)  | |                                           |
//|                     -                                            |
//|                      x                                           |
//| The incomplete beta integral is used, according to the           |
//| formula                                                          |
//| P(x) = incbet( df2/2, df1/2, (df2/(df2 + df1*x) ).               |
//| ACCURACY:                                                        |
//| Tested at random points (a,b,x) in the indicated intervals.      |
//|                x     a,b                     Relative error:     |
//| arithmetic  domain  domain     # trials      peak         rms    |
//|    IEEE      0,1    1,100       100000      3.7e-14     5.9e-16  |
//|    IEEE      1,5    1,100       100000      8.0e-15     1.6e-15  |
//|    IEEE      0,1    1,10000     100000      1.8e-11     3.5e-13  |
//|    IEEE      1,5    1,10000     100000      2.0e-11     3.0e-12  |
//+------------------------------------------------------------------+
double CAlglib::FComplDistribution(const int a,const int b,const double x)
  {
   return(CFDistr::FComplDistribution(a,b,x));
  }
//+------------------------------------------------------------------+
//| Inverse of complemented F distribution                           |
//| Finds the F density argument x such that the integral            |
//| from x to infinity of the F density is equal to the              |
//| given probability p.                                             |
//| This is accomplished using the inverse beta integral             |
//| function and the relations                                       |
//|      z = incbi( df2/2, df1/2, p )                                |
//|      x = df2 (1-z) / (df1 z).                                    |
//| Note: the following relations hold for the inverse of            |
//| the uncomplemented F distribution:                               |
//|      z = incbi( df1/2, df2/2, p )                                |
//|      x = df2 z / (df1 (1-z)).                                    |
//| ACCURACY:                                                        |
//| Tested at random points (a,b,p).                                 |
//|              a,b                     Relative error:             |
//| arithmetic  domain     # trials      peak         rms            |
//|  For p between .001 and 1:                                       |
//|    IEEE     1,100       100000      8.3e-15     4.7e-16          |
//|    IEEE     1,10000     100000      2.1e-11     1.4e-13          |
//|  For p between 10^-6 and 10^-3:                                  |
//|    IEEE     1,100        50000      1.3e-12     8.4e-15          |
//|    IEEE     1,10000      50000      3.0e-12     4.8e-14          |
//+------------------------------------------------------------------+
double CAlglib::InvFDistribution(const int a,const int b,const double y)
  {
   return(CFDistr::InvFDistribution(a,b,y));
  }
//+------------------------------------------------------------------+
//| Fresnel integral                                                 |
//| Evaluates the Fresnel integrals                                  |
//|           x                                                      |
//|           -                                                      |
//|          | |                                                     |
//| C(x) =   |   cos(pi/2 t**2) dt,                                  |
//|        | |                                                       |
//|         -                                                        |
//|          0                                                       |
//|           x                                                      |
//|           -                                                      |
//|          | |                                                     |
//| S(x) =   |   sin(pi/2 t**2) dt.                                  |
//|        | |                                                       |
//|         -                                                        |
//|          0                                                       |
//| The integrals are evaluated by a power series for x < 1.         |
//| For x >= 1 auxiliary functions f(x) and g(x) are employed        |
//| such that                                                        |
//| C(x) = 0.5 + f(x) sin( pi/2 x**2 ) - g(x) cos( pi/2 x**2 )       |
//| S(x) = 0.5 - f(x) cos( pi/2 x**2 ) - g(x) sin( pi/2 x**2 )       |
//| ACCURACY:                                                        |
//|  Relative error.                                                 |
//| Arithmetic  function   domain     # trials      peak        rms  |
//|   IEEE       S(x)      0, 10       10000       2.0e-15    3.2e-16|
//|   IEEE       C(x)      0, 10       10000       1.8e-15    3.3e-16|
//+------------------------------------------------------------------+
void CAlglib::FresnelIntegral(const double x,double &c,double &s)
  {
   CFresnel::FresnelIntegral(x,c,s);
  }
//+------------------------------------------------------------------+
//| Calculation of the value of the Hermite polynomial.              |
//| Parameters:                                                      |
//|     n   -   degree, n>=0                                         |
//|     x   -   argument                                             |
//| Result:                                                          |
//|     the value of the Hermite polynomial Hn at x                  |
//+------------------------------------------------------------------+
double CAlglib::HermiteCalculate(const int n,const double x)
  {
   return(CHermite::HermiteCalculate(n,x));
  }
//+------------------------------------------------------------------+
//| Summation of Hermite polynomials using Clenshaw?s recurrence     |
//| formula.                                                         |
//| This routine calculates                                          |
//|     c[0]*H0(x) + c[1]*H1(x) + ... + c[N]*HN(x)                   |
//| Parameters:                                                      |
//|     n   -   degree, n>=0                                         |
//|     x   -   argument                                             |
//| Result:                                                          |
//|     the value of the Hermite polynomial at x                     |
//+------------------------------------------------------------------+
double CAlglib::HermiteSum(double &c[],const int n,const double x)
  {
   return(CHermite::HermiteSum(c,n,x));
  }
//+------------------------------------------------------------------+
//| Representation of Hn as C[0] + C[1]*X + ... + C[N]*X^N           |
//| Input parameters:                                                |
//|     N   -   polynomial degree, n>=0                              |
//| Output parameters:                                               |
//|     C   -   coefficients                                         |
//+------------------------------------------------------------------+
void CAlglib::HermiteCoefficients(const int n,double &c[])
  {
   CHermite::HermiteCoefficients(n,c);
  }
//+------------------------------------------------------------------+
//| Jacobian Elliptic Functions                                      |
//| Evaluates the Jacobian elliptic functions sn(u|m), cn(u|m),      |
//| and dn(u|m) of parameter m between 0 and 1, and real             |
//| argument u.                                                      |
//| These functions are periodic, with quarter-period on the         |
//| real axis equal to the complete elliptic integral                |
//| ellpk(1.0-m).                                                    |
//| Relation to incomplete elliptic integral:                        |
//| If u = ellik(phi,m), then sn(u|m) = sin(phi),                    |
//| and cn(u|m) = cos(phi).  Phi is called the amplitude of u.       |
//| Computation is by means of the arithmetic-geometric mean         |
//| algorithm, except when m is within 1e-9 of 0 or 1.  In the       |
//| latter case with m close to 1, the approximation applies         |
//| only for phi < pi/2.                                             |
//| ACCURACY:                                                        |
//| Tested at random points with u between 0 and 10, m between       |
//| 0 and 1.                                                         |
//|            Absolute error (* = relative error):                  |
//| arithmetic   function   # trials      peak         rms           |
//|    IEEE      phi         10000       9.2e-16*    1.4e-16*        |
//|    IEEE      sn          50000       4.1e-15     4.6e-16         |
//|    IEEE      cn          40000       3.6e-15     4.4e-16         |
//|    IEEE      dn          10000       1.3e-12     1.8e-14         |
//|  Peak error observed in consistency check using addition         |
//| theorem for sn(u+v) was 4e-16 (absolute).  Also tested by        |
//| the above relation to the incomplete elliptic integral.          |
//| Accuracy deteriorates when u is large.                           |
//+------------------------------------------------------------------+
void CAlglib::JacobianEllipticFunctions(const double u,const double m,
                                        double &sn,double &cn,
                                        double &dn,double &ph)
  {
//--- initialization
   sn=0;
   cn=0;
   dn=0;
   ph=0;
//--- function call
   CJacobianElliptic::JacobianEllipticFunctions(u,m,sn,cn,dn,ph);
  }
//+------------------------------------------------------------------+
//| Calculation of the value of the Laguerre polynomial.             |
//| Parameters:                                                      |
//|     n   -   degree, n>=0                                         |
//|     x   -   argument                                             |
//| Result:                                                          |
//|     the value of the Laguerre polynomial Ln at x                 |
//+------------------------------------------------------------------+
double CAlglib::LaguerreCalculate(const int n,const double x)
  {
   return(CLaguerre::LaguerreCalculate(n,x));
  }
//+------------------------------------------------------------------+
//| Summation of Laguerre polynomials using Clenshaw?s recurrence    |
//| formula.                                                         |
//| This routine calculates c[0]*L0(x) + c[1]*L1(x) + ... +          |
//| +  c[N]*LN(x)                                                    |
//| Parameters:                                                      |
//|     n   -   degree, n>=0                                         |
//|     x   -   argument                                             |
//| Result:                                                          |
//|     the value of the Laguerre polynomial at x                    |
//+------------------------------------------------------------------+
double CAlglib::LaguerreSum(double &c[],const int n,const double x)
  {
   return(CLaguerre::LaguerreSum(c,n,x));
  }
//+------------------------------------------------------------------+
//| Representation of Ln as C[0] + C[1]*X + ... + C[N]*X^N           |
//| Input parameters:                                                |
//|     N   -   polynomial degree, n>=0                              |
//| Output parameters:                                               |
//|     C   -   coefficients                                         |
//+------------------------------------------------------------------+
void CAlglib::LaguerreCoefficients(const int n,double &c[])
  {
   CLaguerre::LaguerreCoefficients(n,c);
  }
//+------------------------------------------------------------------+
//| Calculation of the value of the Legendre polynomial Pn.          |
//| Parameters:                                                      |
//|     n   -   degree, n>=0                                         |
//|     x   -   argument                                             |
//| Result:                                                          |
//|     the value of the Legendre polynomial Pn at x                 |
//+------------------------------------------------------------------+
double CAlglib::LegendreCalculate(const int n,const double x)
  {
   return(CLegendre::LegendreCalculate(n,x));
  }
//+------------------------------------------------------------------+
//| Summation of Legendre polynomials using Clenshaw?s recurrence    |
//| formula.                                                         |
//| This routine calculates                                          |
//|     c[0]*P0(x) + c[1]*P1(x) + ... + c[N]*PN(x)                   |
//| Parameters:                                                      |
//|     n   -   degree, n>=0                                         |
//|     x   -   argument                                             |
//| Result:                                                          |
//|     the value of the Legendre polynomial at x                    |
//+------------------------------------------------------------------+
double CAlglib::LegendreSum(double &c[],const int n,const double x)
  {
   return(CLegendre::LegendreSum(c,n,x));
  }
//+------------------------------------------------------------------+
//| Representation of Pn as C[0] + C[1]*X + ... + C[N]*X^N           |
//| Input parameters:                                                |
//|     N   -   polynomial degree, n>=0                              |
//| Output parameters:                                               |
//|     C   -   coefficients                                         |
//+------------------------------------------------------------------+
void CAlglib::LegendreCoefficients(const int n,double &c[])
  {
   CLegendre::LegendreCoefficients(n,c);
  }
//+------------------------------------------------------------------+
//| Poisson distribution                                             |
//| Returns the sum of the first k+1 terms of the Poisson            |
//| distribution:                                                    |
//|   k         j                                                    |
//|   --   -m  m                                                     |
//|   >   e    --                                                    |
//|   --       j!                                                    |
//|  j=0                                                             |
//| The terms are not summed directly; instead the incomplete        |
//| gamma integral is employed, according to the relation            |
//| y = pdtr( k, m ) = igamc( k+1, m ).                              |
//| The arguments must both be positive.                             |
//| ACCURACY:                                                        |
//| See incomplete gamma function                                    |
//+------------------------------------------------------------------+
double CAlglib::PoissonDistribution(const int k,const double m)
  {
   return(CPoissonDistr::PoissonDistribution(k,m));
  }
//+------------------------------------------------------------------+
//| Complemented Poisson distribution                                |
//| Returns the sum of the terms k+1 to infinity of the Poisson      |
//| distribution:                                                    |
//|  inf.       j                                                    |
//|   --   -m  m                                                     |
//|   >   e    --                                                    |
//|   --       j!                                                    |
//|  j=k+1                                                           |
//| The terms are not summed directly; instead the incomplete        |
//| gamma integral is employed, according to the formula             |
//| y = pdtrc( k, m ) = igam( k+1, m ).                              |
//| The arguments must both be positive.                             |
//| ACCURACY:                                                        |
//| See incomplete gamma function                                    |
//+------------------------------------------------------------------+
double CAlglib::PoissonComplDistribution(const int k,const double m)
  {
   return(CPoissonDistr::PoissonComplDistribution(k,m));
  }
//+------------------------------------------------------------------+
//| Inverse Poisson distribution                                     |
//| Finds the Poisson variable x such that the integral              |
//| from 0 to x of the Poisson density is equal to the               |
//| given probability y.                                             |
//| This is accomplished using the inverse gamma integral            |
//| function and the relation                                        |
//|    m = igami( k+1, y ).                                          |
//| ACCURACY:                                                        |
//| See inverse incomplete gamma function                            |
//+------------------------------------------------------------------+
double CAlglib::InvPoissonDistribution(const int k,const double y)
  {
   return(CPoissonDistr::InvPoissonDistribution(k,y));
  }
//+------------------------------------------------------------------+
//| Psi (digamma) function                                           |
//|              d      -                                            |
//|   psi(x)  =  -- ln | (x)                                         |
//|              dx                                                  |
//| is the logarithmic derivative of the gamma function.             |
//| For integer x,                                                   |
//|                   n-1                                            |
//|                    -                                             |
//| psi(n) = -EUL  +   >  1/k.                                       |
//|                    -                                             |
//|                   k=1                                            |
//| This formula is used for 0 < n <= 10.  If x is negative, it      |
//| is transformed to a positive argument by the reflection          |
//| formula  psi(1-x) = psi(x) + pi cot(pi x).                       |
//| For general positive x, the argument is made greater than 10     |
//| using the recurrence  psi(x+1) = psi(x) + 1/x.                   |
//| Then the following asymptotic expansion is applied:              |
//|                           inf.   B                               |
//|                            -      2k                             |
//| psi(x) = log(x) - 1/2x -   >   -------                           |
//|                            -        2k                           |
//|                           k=1   2k x                             |
//| where the B2k are Bernoulli numbers.                             |
//| ACCURACY:                                                        |
//|    Relative error (except absolute when |psi| < 1):              |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE      0,30        30000       1.3e-15     1.4e-16         |
//|    IEEE      -30,0       40000       1.5e-15     2.2e-16         |
//+------------------------------------------------------------------+
double CAlglib::Psi(const double x)
  {
   return(CPsiF::Psi(x));
  }
//+------------------------------------------------------------------+
//| Student's t distribution                                         |
//| Computes the integral from minus infinity to t of the Student    |
//| t distribution with integer k > 0 degrees of freedom:            |
//|                                      t                           |
//|                                      -                           |
//|                                     | |                          |
//|              -                      |         2   -(k+1)/2       |
//|             | ( (k+1)/2 )           |  (     x   )               |
//|       ----------------------        |  ( 1 + --- )        dx     |
//|                     -               |  (      k  )               |
//|       sqrt( k pi ) | ( k/2 )        |                            |
//|                                   | |                            |
//|                                    -                             |
//|                                   -inf.                          |
//| Relation to incomplete beta integral:                            |
//|        1 - stdtr(k,t) = 0.5 * incbet( k/2, 1/2, z )              |
//| where                                                            |
//|        z = k/(k + t**2).                                         |
//| For t < -2, this is the method of computation.  For higher t,    |
//| a direct method is derived from integration by parts.            |
//| Since the function is symmetric about t=0, the area under the    |
//| right tail of the density is found by calling the function       |
//| with -t instead of t.                                            |
//| ACCURACY:                                                        |
//| Tested at random 1<=k<=25.  The "domain" refers to t.        |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE     -100,-2      50000       5.9e-15     1.4e-15         |
//|    IEEE     -2,100      500000       2.7e-15     4.9e-17         |
//+------------------------------------------------------------------+
double CAlglib::StudenttDistribution(const int k,const double t)
  {
   return(CStudenttDistr::StudenttDistribution(k,t));
  }
//+------------------------------------------------------------------+
//| Functional inverse of Student's t distribution                   |
//| Given probability p, finds the argument t such that stdtr(k,t)   |
//| is equal to p.                                                   |
//| ACCURACY:                                                        |
//| Tested at random 1<=k<=100.  The "domain" refers to p:       |
//|                      Relative error:                             |
//| arithmetic   domain     # trials      peak         rms           |
//|    IEEE    .001,.999     25000       5.7e-15     8.0e-16         |
//|    IEEE    10^-6,.001    25000       2.0e-12     2.9e-14         |
//+------------------------------------------------------------------+
double CAlglib::InvStudenttDistribution(const int k,const double p)
  {
   return(CStudenttDistr::InvStudenttDistribution(k,p));
  }
//+------------------------------------------------------------------+
//| Sine and cosine integrals                                        |
//| Evaluates the integrals                                          |
//|                          x                                       |
//|                          -                                       |
//|                         |  cos t - 1                             |
//|   Ci(x) = eul + ln x +  |  --------- dt,                         |
//|                         |      t                                 |
//|                        -                                         |
//|                         0                                        |
//|             x                                                    |
//|             -                                                    |
//|            |  sin t                                              |
//|   Si(x) =  |  ----- dt                                           |
//|            |    t                                                |
//|           -                                                      |
//|            0                                                     |
//| where eul = 0.57721566490153286061 is Euler's constant.          |
//| The integrals are approximated by rational functions.            |
//| For x > 8 auxiliary functions f(x) and g(x) are employed         |
//| such that                                                        |
//| Ci(x) = f(x) sin(x) - g(x) cos(x)                                |
//| Si(x) = pi/2 - f(x) cos(x) - g(x) sin(x)                         |
//| ACCURACY:                                                        |
//|    Test interval = [0,50].                                       |
//| Absolute error, except relative when > 1:                        |
//| arithmetic   function   # trials      peak         rms           |
//|    IEEE        Si        30000       4.4e-16     7.3e-17         |
//|    IEEE        Ci        30000       6.9e-16     5.1e-17         |
//+------------------------------------------------------------------+
void CAlglib::SineCosineIntegrals(const double x,double &si,double &ci)
  {
//--- initialization
   si=0;
   ci=0;
//--- function call
   CTrigIntegrals::SineCosineIntegrals(x,si,ci);
  }
//+------------------------------------------------------------------+
//| Hyperbolic sine and cosine integrals                             |
//| Approximates the integrals                                       |
//|                            x                                     |
//|                            -                                     |
//|                           | |   cosh t - 1                       |
//|   Chi(x) = eul + ln x +   |    -----------  dt,                  |
//|                         | |          t                           |
//|                          -                                       |
//|                          0                                       |
//|               x                                                  |
//|               -                                                  |
//|              | |  sinh t                                         |
//|   Shi(x) =   |    ------  dt                                     |
//|            | |       t                                           |
//|             -                                                    |
//|             0                                                    |
//| where eul = 0.57721566490153286061 is Euler's constant.          |
//| The integrals are evaluated by power series for x < 8            |
//| and by Chebyshev expansions for x between 8 and 88.              |
//| For large x, both functions approach exp(x)/2x.                  |
//| Arguments greater than 88 in magnitude return MAXNUM.            |
//| ACCURACY:                                                        |
//| Test interval 0 to 88.                                           |
//|                      Relative error:                             |
//| arithmetic   function  # trials      peak         rms            |
//|    IEEE         Shi      30000       6.9e-16     1.6e-16         |
//|        Absolute error, except relative when |Chi| > 1:           |
//|    IEEE         Chi      30000       8.4e-16     1.4e-16         |
//+------------------------------------------------------------------+
void CAlglib::HyperbolicSineCosineIntegrals(const double x,double &shi,double &chi)
  {
//--- initialization
   shi=0;
   chi=0;
//--- function call
   CTrigIntegrals::HyperbolicSineCosineIntegrals(x,shi,chi);
  }
//+------------------------------------------------------------------+
//| Calculation of the distribution moments: mean, variance,         |
//| skewness, kurtosis.                                              |
//| INPUT PARAMETERS:                                                |
//|     X       -   sample                                           |
//|     N       -   N>=0, sample size:                               |
//|                 * if given, only leading N elements of X are     |
//|                   processed                                      |
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//| OUTPUT PARAMETERS                                                |
//|     Mean    -   mean.                                            |
//|     Variance-   variance.                                        |
//|     Skewness-   skewness (if variance<>0; zero otherwise).       |
//|     Kurtosis-   kurtosis (if variance<>0; zero otherwise).       |
//+------------------------------------------------------------------+
void CAlglib::SampleMoments(const double &x[],const int n,double &mean,
                            double &variance,double &skewness,
                            double &kurtosis)
  {
//--- initialization
   mean=0;
   variance=0;
   skewness=0;
   kurtosis=0;
//--- function call
   CBaseStat::SampleMoments(x,n,mean,variance,skewness,kurtosis);
  }
//+------------------------------------------------------------------+
//| Calculation of the distribution moments: mean, variance,         |
//| skewness, kurtosis.                                              |
//| INPUT PARAMETERS:                                                |
//|     X       -   sample                                           |
//|     N       -   N>=0, sample size:                               |
//|                 * if given, only leading N elements of X are     |
//|                   processed                                      |
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//| OUTPUT PARAMETERS                                                |
//|     Mean    -   mean.                                            |
//|     Variance-   variance.                                        |
//|     Skewness-   skewness (if variance<>0; zero otherwise).       |
//|     Kurtosis-   kurtosis (if variance<>0; zero otherwise).       |
//+------------------------------------------------------------------+
void CAlglib::SampleMoments(const double &x[],double &mean,
                            double &variance,double &skewness,
                            double &kurtosis)
  {
//--- initialization
   mean=0;
   variance=0;
   skewness=0;
   kurtosis=0;
//--- get lenght
   int n=CAp::Len(x);
//--- function call
   CBaseStat::SampleMoments(x,n,mean,variance,skewness,kurtosis);
  }
//+------------------------------------------------------------------+
//| Calculation of the mean.                                         |
//| INPUT PARAMETERS:                                                |
//|   X        -  sample                                             |
//|   N        -  N>=0, sample size:                                 |
//|         * if given, only leading N elements of X are processed   |
//|         * if not given, automatically determined from size of X  |
//| NOTE: This function return result which calculated by            |
//|       'SampleMoments' function and stored at 'Mean' variable.    |
//+------------------------------------------------------------------+
double CAlglib::SampleMean(CRowDouble &x,int n)
  {
   return(CBaseStat::SampleMean(x,n));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CAlglib::SampleMean(CRowDouble &x)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   return(CBaseStat::SampleMean(x,n));
  }
//+------------------------------------------------------------------+
//| Calculation of the variance.                                     |
//| INPUT PARAMETERS:                                                |
//|   X        -  sample                                             |
//|   N        -  N>=0, sample size:                                 |
//|         * if given, only leading N elements of X are processed   |
//|         * if not given, automatically determined from size of X  |
//| NOTE: This function return result which calculated by            |
//|       'SampleMoments' function and stored at 'Variance' variable.|
//+------------------------------------------------------------------+
double CAlglib::SampleVariance(CRowDouble &x,int n)
  {
   return(CBaseStat::SampleVariance(x,n));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CAlglib::SampleVariance(CRowDouble &x)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   return(CBaseStat::SampleVariance(x,n));
  }
//+------------------------------------------------------------------+
//| Calculation of the skewness.                                     |
//| INPUT PARAMETERS:                                                |
//|   X        -  sample                                             |
//|   N        -  N>=0, sample size:                                 |
//|         * if given, only leading N elements of X are processed   |
//|         * if not given, automatically determined from size of X  |
//| NOTE: This function return result which calculated by            |
//|       'SampleMoments' function and stored at 'Skewness' variable.|
//+------------------------------------------------------------------+
double CAlglib::SampleSkewness(CRowDouble &x,int n)
  {
   return(CBaseStat::SampleSkewness(x,n));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CAlglib::SampleSkewness(CRowDouble &x)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   return(CBaseStat::SampleSkewness(x,n));
  }
//+------------------------------------------------------------------+
//| Calculation of the kurtosis.                                     |
//| INPUT PARAMETERS:                                                |
//|   X        -  sample                                             |
//|   N        -  N>=0, sample size:                                 |
//|         * if given, only leading N elements of X are processed   |
//|         * if not given, automatically determined from size of X  |
//| NOTE: This function return result  which calculated by           |
//|       'SampleMoments' function and stored at 'Kurtosis' variable.|
//+------------------------------------------------------------------+
double CAlglib::SampleKurtosis(CRowDouble &x,int n)
  {
   return(CBaseStat::SampleKurtosis(x,n));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CAlglib::SampleKurtosis(CRowDouble &x)
  {
//--- initialization
   int n=CAp::Len(x);
//--- function call
   return(CBaseStat::SampleKurtosis(x,n));
  }
//+------------------------------------------------------------------+
//| ADev                                                             |
//| Input parameters:                                                |
//|     X   -   sample                                               |
//|     N   -   N>=0, sample size:                                   |
//|             * if given, only leading N elements of X are         |
//|               processed                                          |
//|             * if not given, automatically determined from size   |
//|               of X                                               |
//| Output parameters:                                               |
//|     ADev-   ADev                                                 |
//+------------------------------------------------------------------+
void CAlglib::SampleAdev(const double &x[],const int n,double &adev)
  {
//--- initialization
   adev=0;
//--- function call
   CBaseStat::SampleAdev(x,n,adev);
  }
//+------------------------------------------------------------------+
//| ADev                                                             |
//| Input parameters:                                                |
//|     X   -   sample                                               |
//|     N   -   N>=0, sample size:                                   |
//|             * if given, only leading N elements of X are         |
//|               processed                                          |
//|             * if not given, automatically determined from size   |
//|               of X                                               |
//| Output parameters:                                               |
//|     ADev-   ADev                                                 |
//+------------------------------------------------------------------+
void CAlglib::SampleAdev(const double &x[],double &adev)
  {
//--- create a variable
   int n=CAp::Len(x);
//--- initialization
   adev=0;
//--- function call
   CBaseStat::SampleAdev(x,n,adev);
  }
//+------------------------------------------------------------------+
//| Median calculation.                                              |
//| Input parameters:                                                |
//|     X   -   sample (array indexes: [0..N-1])                     |
//|     N   -   N>=0, sample size:                                   |
//|             * if given, only leading N elements of X are         |
//|               processed                                          |
//|             * if not given, automatically determined from size   |
//|               of X                                               |
//| Output parameters:                                               |
//|     Median                                                       |
//+------------------------------------------------------------------+
void CAlglib::SampleMedian(const double &x[],const int n,double &median)
  {
//--- initialization
   median=0;
//--- function call
   CBaseStat::SampleMedian(x,n,median);
  }
//+------------------------------------------------------------------+
//| Median calculation.                                              |
//| Input parameters:                                                |
//|     X   -   sample (array indexes: [0..N-1])                     |
//|     N   -   N>=0, sample size:                                   |
//|             * if given, only leading N elements of X are         |
//|               processed                                          |
//|             * if not given, automatically determined from size   |
//|               of X                                               |
//| Output parameters:                                               |
//|     Median                                                       |
//+------------------------------------------------------------------+
void CAlglib::SampleMedian(const double &x[],double &median)
  {
//--- create a variable
   int n=CAp::Len(x);
//--- initialization
   median=0;
//--- function call
   CBaseStat::SampleMedian(x,n,median);
  }
//+------------------------------------------------------------------+
//| Percentile calculation.                                          |
//| Input parameters:                                                |
//|     X   -   sample (array indexes: [0..N-1])                     |
//|     N   -   N>=0, sample size:                                   |
//|             * if given, only leading N elements of X are         |
//|               processed                                          |
//|             * if not given, automatically determined from size   |
//|               of X                                               |
//|     P   -   percentile (0<=P<=1)                                 |
//| Output parameters:                                               |
//|     V   -   percentile                                           |
//+------------------------------------------------------------------+
void CAlglib::SamplePercentile(const double &x[],const int n,
                               const double p,double &v)
  {
//--- initialization
   v=0;
//--- function call
   CBaseStat::SamplePercentile(x,n,p,v);
  }
//+------------------------------------------------------------------+
//| Percentile calculation.                                          |
//| Input parameters:                                                |
//|     X   -   sample (array indexes: [0..N-1])                     |
//|     N   -   N>=0, sample size:                                   |
//|             * if given, only leading N elements of X are         |
//|               processed                                          |
//|             * if not given, automatically determined from size   |
//|               of X                                               |
//|     P   -   percentile (0<=P<=1)                                 |
//| Output parameters:                                               |
//|     V   -   percentile                                           |
//+------------------------------------------------------------------+
void CAlglib::SamplePercentile(const double &x[],const double p,
                               double &v)
  {
//--- create a variable
   int n=CAp::Len(x);
//--- initialization
   v=0;
//--- function call
   CBaseStat::SamplePercentile(x,n,p,v);
  }
//+------------------------------------------------------------------+
//| 2-sample covariance                                              |
//| Input parameters:                                                |
//|     X       -   sample 1 (array indexes: [0..N-1])               |
//|     Y       -   sample 2 (array indexes: [0..N-1])               |
//|     N       -   N>=0, sample size:                               |
//|                 * if given, only N leading elements of X/Y are   |
//|                   processed                                      |
//|                 * if not given, automatically determined from    |
//|                   input sizes                                    |
//| Result:                                                          |
//|     covariance (zero for N=0 or N=1)                             |
//+------------------------------------------------------------------+
double CAlglib::Cov2(const double &x[],const double &y[],const int n)
  {
   return(CBaseStat::Cov2(x,y,n));
  }
//+------------------------------------------------------------------+
//| 2-sample covariance                                              |
//| Input parameters:                                                |
//|     X       -   sample 1 (array indexes: [0..N-1])               |
//|     Y       -   sample 2 (array indexes: [0..N-1])               |
//|     N       -   N>=0, sample size:                               |
//|                 * if given, only N leading elements of X/Y are   |
//|                   processed                                      |
//|                 * if not given, automatically determined from    |
//|                   input sizes                                    |
//| Result:                                                          |
//|     covariance (zero for N=0 or N=1)                             |
//+------------------------------------------------------------------+
double CAlglib::Cov2(const double &x[],const double &y[])
  {
//--- check
   if(CAp::Len(x)!=CAp::Len(y))
     {
      Print(__FUNCTION__+": arrays size are not equal");
      CAp::exception_happened=true;
      return(EMPTY_VALUE);
     }
//--- initialization
   int n=CAp::Len(x);
//--- return result
   return(CBaseStat::Cov2(x,y,n));
  }
//+------------------------------------------------------------------+
//| Pearson product-moment correlation coefficient                   |
//| Input parameters:                                                |
//|     X       -   sample 1 (array indexes: [0..N-1])               |
//|     Y       -   sample 2 (array indexes: [0..N-1])               |
//|     N       -   N>=0, sample size:                               |
//|                 * if given, only N leading elements of X/Y are   |
//|                   processed                                      |
//|                 * if not given, automatically determined from    |
//|                   input sizes                                    |
//| Result:                                                          |
//|     Pearson product-moment correlation coefficient               |
//|     (zero for N=0 or N=1)                                        |
//+------------------------------------------------------------------+
double CAlglib::PearsonCorr2(const double &x[],const double &y[],
                             const int n)
  {
   return(CBaseStat::PearsonCorr2(x,y,n));
  }
//+------------------------------------------------------------------+
//| Pearson product-moment correlation coefficient                   |
//| Input parameters:                                                |
//|     X       -   sample 1 (array indexes: [0..N-1])               |
//|     Y       -   sample 2 (array indexes: [0..N-1])               |
//|     N       -   N>=0, sample size:                               |
//|                 * if given, only N leading elements of X/Y are   |
//|                   processed                                      |
//|                 * if not given, automatically determined from    |
//|                   input sizes                                    |
//| Result:                                                          |
//|     Pearson product-moment correlation coefficient               |
//|     (zero for N=0 or N=1)                                        |
//+------------------------------------------------------------------+
double CAlglib::PearsonCorr2(const double &x[],const double &y[])
  {
//--- check
   if(CAp::Len(x)!=CAp::Len(y))
     {
      Print(__FUNCTION__+": arrays size are not equal");
      CAp::exception_happened=true;
      return(EMPTY_VALUE);
     }
//--- initialization
   int n=CAp::Len(x);
//--- return result
   return(CBaseStat::PearsonCorr2(x,y,n));
  }
//+------------------------------------------------------------------+
//| Spearman's rank correlation coefficient                          |
//| Input parameters:                                                |
//|     X       -   sample 1 (array indexes: [0..N-1])               |
//|     Y       -   sample 2 (array indexes: [0..N-1])               |
//|     N       -   N>=0, sample size:                               |
//|                 * if given, only N leading elements of X/Y are   |
//|                   processed                                      |
//|                 * if not given, automatically determined from    |
//|                   input sizes                                    |
//| Result:                                                          |
//|     Spearman's rank correlation coefficient                      |
//|     (zero for N=0 or N=1)                                        |
//+------------------------------------------------------------------+
double CAlglib::SpearmanCorr2(const double &x[],const double &y[],
                              const int n)
  {
   return(CBaseStat::SpearmanCorr2(x,y,n));
  }
//+------------------------------------------------------------------+
//| Spearman's rank correlation coefficient                          |
//| Input parameters:                                                |
//|     X       -   sample 1 (array indexes: [0..N-1])               |
//|     Y       -   sample 2 (array indexes: [0..N-1])               |
//|     N       -   N>=0, sample size:                               |
//|                 * if given, only N leading elements of X/Y are   |
//|                   processed                                      |
//|                 * if not given, automatically determined from    |
//|                   input sizes                                    |
//| Result:                                                          |
//|     Spearman's rank correlation coefficient                      |
//|     (zero for N=0 or N=1)                                        |
//+------------------------------------------------------------------+
double CAlglib::SpearmanCorr2(const double &x[],const double &y[])
  {
//--- check
   if(CAp::Len(x)!=CAp::Len(y))
     {
      Print(__FUNCTION__+": arrays size are not equal");
      CAp::exception_happened=true;
      return(EMPTY_VALUE);
     }
//--- initialization
   int n=CAp::Len(x);
//--- return result
   return(CBaseStat::SpearmanCorr2(x,y,n));
  }
//+------------------------------------------------------------------+
//| Covariance matrix                                                |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M], sample matrix:                           |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X are used        |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M   -   M>0, number of variables:                            |
//|             * if given, only leading M columns of X are used     |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M,M], covariance matrix (zero if N=0 or N=1)   |
//+------------------------------------------------------------------+
void CAlglib::CovM(const CMatrixDouble &x,const int n,const int m,
                   CMatrixDouble &c)
  {
   CBaseStat::CovM(x,n,m,c);
  }
//+------------------------------------------------------------------+
//| Covariance matrix                                                |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M], sample matrix:                           |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X are used        |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M   -   M>0, number of variables:                            |
//|             * if given, only leading M columns of X are used     |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M,M], covariance matrix (zero if N=0 or N=1)   |
//+------------------------------------------------------------------+
void CAlglib::CovM(const CMatrixDouble &x,CMatrixDouble &c)
  {
//--- initialization
   int n=(int)CAp::Rows(x);
   int m=(int)CAp::Cols(x);
//--- function call
   CBaseStat::CovM(x,n,m,c);
  }
//+------------------------------------------------------------------+
//| Pearson product-moment correlation matrix                        |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M], sample matrix:                           |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X are used        |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M   -   M>0, number of variables:                            |
//|             * if given, only leading M columns of X are used     |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M,M], correlation matrix (zero if N=0 or N=1)  |
//+------------------------------------------------------------------+
void CAlglib::PearsonCorrM(const CMatrixDouble &x,const int n,
                           const int m,CMatrixDouble &c)
  {
   CBaseStat::PearsonCorrM(x,n,m,c);
  }
//+------------------------------------------------------------------+
//| Pearson product-moment correlation matrix                        |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M], sample matrix:                           |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X are used        |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M   -   M>0, number of variables:                            |
//|             * if given, only leading M columns of X are used     |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M,M], correlation matrix (zero if N=0 or N=1)  |
//+------------------------------------------------------------------+
void CAlglib::PearsonCorrM(CMatrixDouble &x,CMatrixDouble &c)
  {
//--- initialization
   int n=(int)CAp::Rows(x);
   int m=(int)CAp::Cols(x);
//--- function call
   CBaseStat::PearsonCorrM(x,n,m,c);
  }
//+------------------------------------------------------------------+
//| Spearman's rank correlation matrix                               |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M], sample matrix:                           |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X are used        |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M   -   M>0, number of variables:                            |
//|             * if given, only leading M columns of X are used     |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M,M], correlation matrix (zero if N=0 or N=1)  |
//+------------------------------------------------------------------+
void CAlglib::SpearmanCorrM(const CMatrixDouble &x,const int n,
                            const int m,CMatrixDouble &c)
  {
   CBaseStat::SpearmanCorrM(x,n,m,c);
  }
//+------------------------------------------------------------------+
//| Spearman's rank correlation matrix                               |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M], sample matrix:                           |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X are used        |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M   -   M>0, number of variables:                            |
//|             * if given, only leading M columns of X are used     |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M,M], correlation matrix (zero if N=0 or N=1)  |
//+------------------------------------------------------------------+
void CAlglib::SpearmanCorrM(const CMatrixDouble &x,CMatrixDouble &c)
  {
//--- initialization
   int n=(int)CAp::Rows(x);
   int m=(int)CAp::Cols(x);
//--- function call
   CBaseStat::SpearmanCorrM(x,n,m,c);
  }
//+------------------------------------------------------------------+
//| Cross-covariance matrix                                          |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M1], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     Y   -   array[N,M2], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X/Y are used      |
//|             * if not given, automatically determined from input  |
//|               sizes                                              |
//|     M1  -   M1>0, number of variables in X:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M2  -   M2>0, number of variables in Y:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M1,M2], cross-covariance matrix (zero if N=0 or|
//|             N=1)                                                 |
//+------------------------------------------------------------------+
void CAlglib::CovM2(const CMatrixDouble &x,const CMatrixDouble &y,
                    const int n,const int m1,const int m2,
                    CMatrixDouble &c)
  {
   CBaseStat::CovM2(x,y,n,m1,m2,c);
  }
//+------------------------------------------------------------------+
//| Cross-covariance matrix                                          |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M1], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     Y   -   array[N,M2], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X/Y are used      |
//|             * if not given, automatically determined from input  |
//|               sizes                                              |
//|     M1  -   M1>0, number of variables in X:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M2  -   M2>0, number of variables in Y:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M1,M2], cross-covariance matrix (zero if N=0 or|
//|             N=1)                                                 |
//+------------------------------------------------------------------+
void CAlglib::CovM2(const CMatrixDouble &x,const CMatrixDouble &y,
                    CMatrixDouble &c)
  {
//--- check
   if(CAp::Rows(x)!=CAp::Rows(y))
     {
      Print(__FUNCTION__+": rows size are not equal");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n =(int)CAp::Rows(x);
   int m1=(int)CAp::Cols(x);
   int m2=(int)CAp::Cols(y);
//--- function call
   CBaseStat::CovM2(x,y,n,m1,m2,c);
  }
//+------------------------------------------------------------------+
//| Pearson product-moment cross-correlation matrix                  |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M1], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     Y   -   array[N,M2], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X/Y are used      |
//|             * if not given, automatically determined from input  |
//|               sizes                                              |
//|     M1  -   M1>0, number of variables in X:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M2  -   M2>0, number of variables in Y:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M1,M2], cross-correlation matrix (zero if N=0  |
//|             or N=1)                                              |
//+------------------------------------------------------------------+
void CAlglib::PearsonCorrM2(const CMatrixDouble &x,const CMatrixDouble &y,
                            const int n,const int m1,const int m2,
                            CMatrixDouble &c)
  {
   CBaseStat::PearsonCorrM2(x,y,n,m1,m2,c);
  }
//+------------------------------------------------------------------+
//| Pearson product-moment cross-correlation matrix                  |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M1], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     Y   -   array[N,M2], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X/Y are used      |
//|             * if not given, automatically determined from input  |
//|               sizes                                              |
//|     M1  -   M1>0, number of variables in X:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M2  -   M2>0, number of variables in Y:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M1,M2], cross-correlation matrix (zero if N=0  |
//|             or N=1)                                              |
//+------------------------------------------------------------------+
void CAlglib::PearsonCorrM2(const CMatrixDouble &x,const CMatrixDouble &y,
                            CMatrixDouble &c)
  {
//--- check
   if(CAp::Rows(x)!=CAp::Rows(y))
     {
      Print(__FUNCTION__+": rows size are not equal");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n =(int)CAp::Rows(x);
   int m1=(int)CAp::Cols(x);
   int m2=(int)CAp::Cols(y);
//--- function call
   CBaseStat::PearsonCorrM2(x,y,n,m1,m2,c);
  }
//+------------------------------------------------------------------+
//| Spearman's rank cross-correlation matrix                         |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M1], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     Y   -   array[N,M2], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X/Y are used      |
//|             * if not given, automatically determined from input  |
//|               sizes                                              |
//|     M1  -   M1>0, number of variables in X:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M2  -   M2>0, number of variables in Y:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M1,M2], cross-correlation matrix (zero if N=0  |
//|             or N=1)                                              |
//+------------------------------------------------------------------+
void CAlglib::SpearmanCorrM2(const CMatrixDouble &x,const CMatrixDouble &y,
                             const int n,const int m1,const int m2,
                             CMatrixDouble &c)
  {
   CBaseStat::SpearmanCorrM2(x,y,n,m1,m2,c);
  }
//+------------------------------------------------------------------+
//| Spearman's rank cross-correlation matrix                         |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M1], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     Y   -   array[N,M2], sample matrix:                          |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X/Y are used      |
//|             * if not given, automatically determined from input  |
//|               sizes                                              |
//|     M1  -   M1>0, number of variables in X:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M2  -   M2>0, number of variables in Y:                      |
//|             * if given, only leading M1 columns of X are used    |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M1,M2], cross-correlation matrix (zero if N=0  |
//|             or N=1)                                              |
//+------------------------------------------------------------------+
void CAlglib::SpearmanCorrM2(const CMatrixDouble &x,const CMatrixDouble &y,
                             CMatrixDouble &c)
  {
//--- check
   if(CAp::Rows(x)!=CAp::Rows(y))
     {
      Print(__FUNCTION__+": rows size are not equal");
      CAp::exception_happened=true;
      return;
     }
//--- initialization
   int n =(int)CAp::Rows(x);
   int m1=(int)CAp::Cols(x);
   int m2=(int)CAp::Cols(y);
//--- function call
   CBaseStat::SpearmanCorrM2(x,y,n,m1,m2,c);
  }
//+------------------------------------------------------------------+
//| This function replaces data in XY by their ranks:                |
//|      * XY is processed row-by-row                                |
//|      * rows are processed separately                             |
//|      * tied data are correctly handled (tied ranks               |
//|        are calculated)                                           |
//|      * ranking starts from 0, ends at NFeatures-1                |
//|      * sum of within-row values is equal                         |
//|        to (NFeatures-1)*NFeatures/2                              |
//| INPUT PARAMETERS:                                                |
//|   XY       -  array[NPoints,NFeatures], dataset                  |
//|   NPoints  -  number of points                                   |
//|   NFeatures-  number of features                                 |
//| OUTPUT PARAMETERS:                                               |
//|   XY       -  data are replaced by their within-row ranks;       |
//|               ranking starts from 0, ends at NFeatures-1         |
//+------------------------------------------------------------------+
void CAlglib::RankData(CMatrixDouble &xy,int npoints,int nfeatures)
  {
   CBaseStat::RankData(xy,npoints,nfeatures);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::RankData(CMatrixDouble &xy)
  {
//--- initialization
   int npoints=CAp::Rows(xy);
   int nfeatures=CAp::Cols(xy);
//--- function call
   CBaseStat::RankData(xy,npoints,nfeatures);
  }
//+------------------------------------------------------------------+
//| This function replaces data in XY by their CENTERED ranks:       |
//|   * XY is processed row-by-row                                   |
//|   * rows are processed separately                                |
//|   * tied data are correctly handled (tied ranks are calculated)  |
//|   * centered ranks are just usual ranks, but centered in such way|
//|     that sum of within-row values is equal to 0.0.               |
//|   * centering is performed by subtracting mean from each row,    |
//|     i.e it changes mean value, but does NOT change higher moments|
//| INPUT PARAMETERS:                                                |
//|   XY       -  array[NPoints,NFeatures], dataset                  |
//|   NPoints  -  number of points                                   |
//|   NFeatures-  number of features                                 |
//| OUTPUT PARAMETERS:                                               |
//|   XY       -  data are replaced by their within-row ranks;       |
//|               ranking starts from 0, ends at NFeatures-1         |
//+------------------------------------------------------------------+
void CAlglib::RankDataCentered(CMatrixDouble &xy,int npoints,int nfeatures)
  {
   CBaseStat::RankDataCentered(xy,npoints,nfeatures);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CAlglib::RankDataCentered(CMatrixDouble &xy)
  {
//--- initialization
   int npoints=CAp::Rows(xy);
   int nfeatures=CAp::Cols(xy);
//--- function call
   CBaseStat::RankDataCentered(xy,npoints,nfeatures);
  }
//+------------------------------------------------------------------+
//| Pearson's correlation coefficient significance test              |
//| This test checks hypotheses about whether X  and Y are samples of|
//| two continuous distributions having zero correlation or whether  |
//| their correlation is non-zero.                                   |
//| The following tests are performed:                               |
//|     * two-tailed test (null hypothesis - X and Y have zero       |
//|       correlation)                                               |
//|     * left-tailed test (null hypothesis - the correlation        |
//|       coefficient is greater than or equal to 0)                 |
//|     * right-tailed test (null hypothesis - the correlation       |
//|       coefficient is less than or equal to 0).                   |
//| Requirements:                                                    |
//|     * the number of elements in each sample is not less than 5   |
//|     * normality of distributions of X and Y.                     |
//| Input parameters:                                                |
//|     R   -   Pearson's correlation coefficient for X and Y        |
//|     N   -   number of elements in samples, N>=5.                 |
//| Output parameters:                                               |
//|     BothTails   -   p-value for two-tailed test.                 |
//|                     If BothTails is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//|     LeftTail    -   p-value for left-tailed test.                |
//|                     If LeftTail is less than the given           |
//|                     significance level, the null hypothesis is   |
//|                     rejected.                                    |
//|     RightTail   -   p-value for right-tailed test.               |
//|                     If RightTail is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//+------------------------------------------------------------------+
void CAlglib::PearsonCorrelationSignificance(const double r,const int n,
                                             double &bothTails,
                                             double &leftTail,
                                             double &rightTail)
  {
   CCorrTests::PearsonCorrSignific(r,n,bothTails,leftTail,rightTail);
  }
//+------------------------------------------------------------------+
//| Spearman's rank correlation coefficient significance test        |
//| This test checks hypotheses about whether X and Y are samples of |
//| two continuous distributions having zero correlation or whether  |
//| their correlation is non-zero.                                   |
//| The following tests are performed:                               |
//|     * two-tailed test (null hypothesis - X and Y have zero       |
//|       correlation)                                               |
//|     * left-tailed test (null hypothesis - the correlation        |
//|       coefficient is greater than or equal to 0)                 |
//|     * right-tailed test (null hypothesis - the correlation       |
//|       coefficient is less than or equal to 0).                   |
//| Requirements:                                                    |
//|     * the number of elements in each sample is not less than 5.  |
//| The test is non-parametric and doesn't require distributions X   |
//| and Y to be normal.                                              |
//| Input parameters:                                                |
//|     R   -   Spearman's rank correlation coefficient for X and Y  |
//|     N   -   number of elements in samples, N>=5.                 |
//| Output parameters:                                               |
//|     BothTails   -   p-value for two-tailed test.                 |
//|                     If BothTails is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//|     LeftTail    -   p-value for left-tailed test.                |
//|                     If LeftTail is less than the given           |
//|                     significance level, the null hypothesis is   |
//|                     rejected.                                    |
//|     RightTail   -   p-value for right-tailed test.               |
//|                     If RightTail is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//+------------------------------------------------------------------+
void CAlglib::SpearmanRankCorrelationSignificance(const double r,
                                                  const int n,
                                                  double &bothTails,
                                                  double &leftTail,
                                                  double &rightTail)
  {
   CCorrTests::SpearmanRankCorrSignific(r,n,bothTails,leftTail,rightTail);
  }
//+------------------------------------------------------------------+
//| Jarque-Bera test                                                 |
//| This test checks hypotheses about the fact that a given sample X |
//| is a sample of normal random variable.                           |
//| Requirements:                                                    |
//|     * the number of elements in the sample is not less than 5.   |
//| Input parameters:                                                |
//|     X   -   sample. Array whose index goes from 0 to N-1.        |
//|     N   -   size of the sample. N>=5                             |
//| Output parameters:                                               |
//|     BothTails   -   p-value for two-tailed test.                 |
//|                     If BothTails is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//|     LeftTail    -   p-value for left-tailed test.                |
//|                     If LeftTail is less than the given           |
//|                     significance level, the null hypothesis is   |
//|                     rejected.                                    |
//|     RightTail   -   p-value for right-tailed test.               |
//|                     If RightTail is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//| Accuracy of the approximation used (5<=N<=1951):                 |
//| p-value       relative error (5<=N<=1951)                        |
//| [1, 0.1]            < 1%                                         |
//| [0.1, 0.01]         < 2%                                         |
//| [0.01, 0.001]       < 6%                                         |
//| [0.001, 0]          wasn't measured                              |
//| For N>1951 accuracy wasn't measured but it shouldn't be sharply  |
//| different from table values.                                     |
//+------------------------------------------------------------------+
void CAlglib::JarqueBeraTest(const double &x[],const int n,double &p)
  {
//--- initialization
   p=0;
//--- function call
   CJarqueBera::JarqueBeraTest(x,n,p);
  }
//+------------------------------------------------------------------+
//| Mann-Whitney U-test                                              |
//| This test checks hypotheses about whether X and Y are samples of |
//| two continuous distributions of the same shape and same median or|
//| whether their medians are different.                             |
//| The following tests are performed:                               |
//|     * two-tailed test (null hypothesis - the medians are equal)  |
//|     * left-tailed test (null hypothesis - the median of the first|
//|       sample is greater than or equal to the median of the second|
//|       sample)                                                    |
//|     * right-tailed test (null hypothesis - the median of the     |
//|       first sample is less than or equal to the median of the    |
//|       second sample).                                            |
//| Requirements:                                                    |
//|     * the samples are independent                                |
//|     * X and Y are continuous distributions (or discrete          |
//|       distributions well- approximating continuous distributions)|
//|     * distributions of X and Y have the  same  shape.  The  only |
//|       possible difference is their position (i.e. the value of   |
//|       the median)                                                |
//|     * the number of elements in each sample is not less than 5   |
//|     * the scale of measurement should be ordinal, interval or    |
//|       ratio (i.e. the test could not be applied to nominal       |
//|       variables).                                                |
//| The test is non-parametric and doesn't require distributions to  |
//| be normal.                                                       |
//| Input parameters:                                                |
//|     X   -   sample 1. Array whose index goes from 0 to N-1.      |
//|     N   -   size of the sample. N>=5                             |
//|     Y   -   sample 2. Array whose index goes from 0 to M-1.      |
//|     M   -   size of the sample. M>=5                             |
//| Output parameters:                                               |
//|     BothTails   -   p-value for two-tailed test.                 |
//|                     If BothTails is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//|     LeftTail    -   p-value for left-tailed test.                |
//|                     If LeftTail is less than the given           |
//|                     significance level, the null hypothesis is   |
//|                     rejected.                                    |
//|     RightTail   -   p-value for right-tailed test.               |
//|                     If RightTail is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//| To calculate p-values, special approximation is used. This       |
//| method lets us calculate p-values with satisfactory accuracy in  |
//| interval [0.0001, 1]. There is no approximation outside the      |
//| [0.0001, 1] interval. Therefore, if the significance level       |
//| outlies this interval, the test returns 0.0001.                  |
//| Relative precision of approximation of p-value:                  |
//| N          M          Max.err.   Rms.err.                        |
//| 5..10      N..10      1.4e-02    6.0e-04                         |
//| 5..10      N..100     2.2e-02    5.3e-06                         |
//| 10..15     N..15      1.0e-02    3.2e-04                         |
//| 10..15     N..100     1.0e-02    2.2e-05                         |
//| 15..100    N..100     6.1e-03    2.7e-06                         |
//| For N,M>100 accuracy checks weren't put into practice, but taking|
//| into account characteristics of asymptotic approximation used,   |
//| precision should not be sharply different from the values for    |
//| interval [5, 100].                                               |
//+------------------------------------------------------------------+
void CAlglib::MannWhitneyUTest(const double &x[],const int n,
                               const double &y[],const int m,
                               double &bothTails,double &leftTail,
                               double &rightTail)
  {
   CMannWhitneyU::CMannWhitneyUTest(x,n,y,m,bothTails,leftTail,rightTail);
  }
//+------------------------------------------------------------------+
//| Sign test                                                        |
//| This test checks three hypotheses about the median of the given  |
//| sample.                                                          |
//| The following tests are performed:                               |
//|     * two-tailed test (null hypothesis - the median is equal to  |
//|       the given value)                                           |
//|     * left-tailed test (null hypothesis - the median is greater  |
//|       than or equal to the given value)                          |
//|     * right-tailed test (null hypothesis - the  median is less   |
//|       than or equal to the given value)                          |
//| Requirements:                                                    |
//|     * the scale of measurement should be ordinal, interval or    |
//|       ratio (i.e. the test could not be applied to nominal       |
//|       variables).                                                |
//| The test is non-parametric and doesn't require distribution X to |
//| be normal                                                        |
//| Input parameters:                                                |
//|     X       -   sample. Array whose index goes from 0 to N-1.    |
//|     N       -   size of the sample.                              |
//|     Median  -   assumed median value.                            |
//| Output parameters:                                               |
//|     BothTails   -   p-value for two-tailed test.                 |
//|                     If BothTails is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//|     LeftTail    -   p-value for left-tailed test.                |
//|                     If LeftTail is less than the given           |
//|                     significance level, the null hypothesis is   |
//|                     rejected.                                    |
//|     RightTail   -   p-value for right-tailed test.               |
//|                     If RightTail is less than the given          |
//|                     significance levelthe null hypothesis is     |
//|                     rejected.                                    |
//| While calculating p-values high-precision binomial distribution  |
//| approximation is used, so significance levels have about 15 exact|
//| digits.                                                          |
//+------------------------------------------------------------------+
void CAlglib::OneSampleSignTest(const double &x[],const int n,
                                const double median,double &bothTails,
                                double &leftTail,double &rightTail)
  {
   CSignTest::OneSampleSignTest(x,n,median,bothTails,leftTail,rightTail);
  }
//+------------------------------------------------------------------+
//| One-sample t-test                                                |
//| This test checks three hypotheses about the mean of the given    |
//| sample. The following tests are performed:                       |
//|     * two-tailed test (null hypothesis - the mean is equal to the|
//|       given value)                                               |
//|     * left-tailed test (null hypothesis - the mean is greater    |
//|       than or equal to the given value)                          |
//|     * right-tailed test (null hypothesis - the mean is less than |
//|       or equal to the given value).                              |
//| The test is based on the assumption that a given sample has a    |
//| normal distribution and an unknown dispersion. If the            |
//| distribution sharply differs from normal, the test will work     |
//| incorrectly.                                                     |
//| Input parameters:                                                |
//|     X       -   sample. Array whose index goes from 0 to N-1.    |
//|     N       -   size of sample.                                  |
//|     Mean    -   assumed value of the mean.                       |
//| Output parameters:                                               |
//|     BothTails   -   p-value for two-tailed test.                 |
//|                     If BothTails is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//|     LeftTail    -   p-value for left-tailed test.                |
//|                     If LeftTail is less than the given           |
//|                     significance level, the null hypothesis is   |
//|                     rejected.                                    |
//|     RightTail   -   p-value for right-tailed test.               |
//|                     If RightTail is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//+------------------------------------------------------------------+
void CAlglib::StudentTest1(const double &x[],const int n,const double mean,
                           double &bothTails,double &leftTail,
                           double &rightTail)
  {
   CStudentTests::StudentTest1(x,n,mean,bothTails,leftTail,rightTail);
  }
//+------------------------------------------------------------------+
//| Two-sample pooled test                                           |
//| This test checks three hypotheses about the mean of the given    |
//| samples. The following tests are performed:                      |
//|     * two-tailed test (null hypothesis - the means are equal)    |
//|     * left-tailed test (null hypothesis - the mean of the first  |
//|       sample is greater than or equal to the mean of the second  |
//|       sample)                                                    |
//|     * right-tailed test (null hypothesis - the mean of the first |
//|       sample is less than or equal to the mean of the second     |
//|       sample).                                                   |
//| Test is based on the following assumptions:                      |
//|     * given samples have normal distributions                    |
//|     * dispersions are equal                                      |
//|     * samples are independent.                                   |
//| Input parameters:                                                |
//|     X       -   sample 1. Array whose index goes from 0 to N-1.  |
//|     N       -   size of sample.                                  |
//|     Y       -   sample 2. Array whose index goes from 0 to M-1.  |
//|     M       -   size of sample.                                  |
//| Output parameters:                                               |
//|     BothTails   -   p-value for two-tailed test.                 |
//|                     If BothTails is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//|     LeftTail    -   p-value for left-tailed test.                |
//|                     If LeftTail is less than the given           |
//|                     significance level, the null hypothesis is   |
//|                     rejected.                                    |
//|     RightTail   -   p-value for right-tailed test.               |
//|                     If RightTail is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//+------------------------------------------------------------------+
void CAlglib::StudentTest2(const double &x[],const int n,const double &y[],
                           const int m,double &bothTails,
                           double &leftTail,double &rightTail)
  {
   CStudentTests::StudentTest2(x,n,y,m,bothTails,leftTail,rightTail);
  }
//+------------------------------------------------------------------+
//| Two-sample unpooled test                                         |
//| This test checks three hypotheses about the mean of the given    |
//| samples. The following tests are performed:                      |
//|     * two-tailed test (null hypothesis - the means are equal)    |
//|     * left-tailed test (null hypothesis - the mean of the first  |
//|       sample  is greater than or equal to the mean of the second |
//|       sample)                                                    |
//|     * right-tailed test (null hypothesis - the mean of the first |
//|       sample is less than or equal to the mean of the second     |
//|       sample).                                                   |
//| Test is based on the following assumptions:                      |
//|     * given samples have normal distributions                    |
//|     * samples are independent.                                   |
//| Dispersion equality is not required                              |
//| Input parameters:                                                |
//|     X - sample 1. Array whose index goes from 0 to N-1.          |
//|     N - size of the sample.                                      |
//|     Y - sample 2. Array whose index goes from 0 to M-1.          |
//|     M - size of the sample.                                      |
//| Output parameters:                                               |
//|     BothTails   -   p-value for two-tailed test.                 |
//|                     If BothTails is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//|     LeftTail    -   p-value for left-tailed test.                |
//|                     If LeftTail is less than the given           |
//|                     significance level, the null hypothesis is   |
//|                     rejected.                                    |
//|     RightTail   -   p-value for right-tailed test.               |
//|                     If RightTail is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//+------------------------------------------------------------------+
void CAlglib::UnequalVarianceTest(const double &x[],const int n,
                                  const double &y[],const int m,
                                  double &bothTails,double &leftTail,
                                  double &rightTail)
  {
   CStudentTests::UnequalVarianceTest(x,n,y,m,bothTails,leftTail,rightTail);
  }
//+------------------------------------------------------------------+
//| Two-sample F-test                                                |
//| This test checks three hypotheses about dispersions of the given |
//| samples. The following tests are performed:                      |
//|     * two-tailed test (null hypothesis - the dispersions are     |
//|       equal)                                                     |
//|     * left-tailed test (null hypothesis - the dispersion of the  |
//|       first sample is greater than or equal to the dispersion of |
//|       the second sample).                                        |
//|     * right-tailed test (null hypothesis - the dispersion of the |
//|       first sample is less than or equal to the dispersion of    |
//|       the second sample)                                         |
//| The test is based on the following assumptions:                  |
//|     * the given samples have normal distributions                |
//|     * the samples are independent.                               |
//| Input parameters:                                                |
//|     X   -   sample 1. Array whose index goes from 0 to N-1.      |
//|     N   -   sample size.                                         |
//|     Y   -   sample 2. Array whose index goes from 0 to M-1.      |
//|     M   -   sample size.                                         |
//| Output parameters:                                               |
//|     BothTails   -   p-value for two-tailed test.                 |
//|                     If BothTails is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//|     LeftTail    -   p-value for left-tailed test.                |
//|                     If LeftTail is less than the given           |
//|                     significance level, the null hypothesis is   |
//|                     rejected.                                    |
//|     RightTail   -   p-value for right-tailed test.               |
//|                     If RightTail is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//+------------------------------------------------------------------+
void CAlglib::FTest(const double &x[],const int n,const double &y[],
                    const int m,double &bothTails,double &leftTail,
                    double &rightTail)
  {
   CVarianceTests::FTest(x,n,y,m,bothTails,leftTail,rightTail);
  }
//+------------------------------------------------------------------+
//| One-sample chi-square test                                       |
//| This test checks three hypotheses about the dispersion of the    |
//| given sample The following tests are performed:                  |
//|     * two-tailed test (null hypothesis - the dispersion equals   |
//|       the given number)                                          |
//|     * left-tailed test (null hypothesis - the dispersion is      |
//|       greater  than or equal to the given number)                |
//|     * right-tailed test (null hypothesis - dispersion is less    |
//|       than or equal to the given number).                        |
//| Test is based on the following assumptions:                      |
//|     * the given sample has a normal distribution.                |
//| Input parameters:                                                |
//|     X           -   sample 1. Array whose index goes from 0 to   |
//|                     N-1.                                         |
//|     N           -   size of the sample.                          |
//|     Variance    -   dispersion value to compare with.            |
//| Output parameters:                                               |
//|     BothTails   -   p-value for two-tailed test.                 |
//|                     If BothTails is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//|     LeftTail    -   p-value for left-tailed test.                |
//|                     If LeftTail is less than the given           |
//|                     significance level, the null hypothesis is   |
//|                     rejected.                                    |
//|     RightTail   -   p-value for right-tailed test.               |
//|                     If RightTail is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//+------------------------------------------------------------------+
void CAlglib::OneSampleVarianceTest(double &x[],int n,double variance,
                                    double &bothTails,double &leftTail,
                                    double &rightTail)
  {
   CVarianceTests::OneSampleVarianceTest(x,n,variance,bothTails,leftTail,rightTail);
  }
//+------------------------------------------------------------------+
//| Wilcoxon signed-rank test                                        |
//| This test checks three hypotheses about the median of the given  |
//| sample. The following tests are performed:                       |
//|     * two-tailed test (null hypothesis - the median is equal to  |
//|       the given value)                                           |
//|     * left-tailed test (null hypothesis - the median is greater  |
//|       than or equal to the given value)                          |
//|     * right-tailed test (null hypothesis - the median is less    |
//|       than or equal to the given value)                          |
//| Requirements:                                                    |
//|     * the scale of measurement should be ordinal, interval or    |
//|       ratio (i.e. the test could not be applied to nominal       |
//|       variables).                                                |
//|     * the distribution should be continuous and symmetric        |
//|       relative to its median.                                    |
//|     * number of distinct values in the X array should be greater |
//|       than 4                                                     |
//| The test is non-parametric and doesn't require distribution X to |
//| be normal                                                        |
//| Input parameters:                                                |
//|     X       -   sample. Array whose index goes from 0 to N-1.    |
//|     N       -   size of the sample.                              |
//|     Median  -   assumed median value.                            |
//| Output parameters:                                               |
//|     BothTails   -   p-value for two-tailed test.                 |
//|                     If BothTails is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//|     LeftTail    -   p-value for left-tailed test.                |
//|                     If LeftTail is less than the given           |
//|                     significance level, the null hypothesis is   |
//|                     rejected.                                    |
//|     RightTail   -   p-value for right-tailed test.               |
//|                     If RightTail is less than the given          |
//|                     significance level the null hypothesis is    |
//|                     rejected.                                    |
//| To calculate p-values, special approximation is used. This method|
//| lets us calculate p-values with two decimal places in interval   |
//| [0.0001, 1].                                                     |
//| "Two decimal places" does not sound very impressive, but in      |
//| practice the relative error of less than 1% is enough to make a  |
//| decision.                                                        |
//| There is no approximation outside the [0.0001, 1] interval.      |
//| Therefore, if the significance level outlies this interval, the  |
//| test returns 0.0001.                                             |
//+------------------------------------------------------------------+
void CAlglib::WilcoxonSignedRankTest(const double &x[],const int n,
                                     const double e,double &bothTails,
                                     double &leftTail,double &rightTail)
  {
   CWilcoxonSignedRank::WilcoxonSignedRankTest(x,n,e,bothTails,leftTail,rightTail);
  }
//+------------------------------------------------------------------+