lreg.h

Go to the documentation of this file.

/* =====================================================================================
 
                      The UQ Toolkit (UQTk) version 3.1.1
                          Copyright (2021) NTESS
                        https://www.sandia.gov/UQToolkit/
                        https://github.com/sandialabs/UQTk
 
     Copyright 2021 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
     Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government
     retains certain rights in this software.
 
     This file is part of The UQ Toolkit (UQTk)
 
     UQTk is open source software: you can redistribute it and/or modify
     it under the terms of BSD 3-Clause License
 
     UQTk 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
     BSD 3 Clause License for more details.
 
     You should have received a copy of the BSD 3 Clause License
     along with UQTk. If not, see https://choosealicense.com/licenses/bsd-3-clause/.
 
     Questions? Contact the UQTk Developers at <uqtk-developers@software.sandia.gov>
     Sandia National Laboratories, Livermore, CA, USA
===================================================================================== */
 
#ifndef LREG_H_SEEN
#define LREG_H_SEEN
 
#include "Array1D.h"
#include "Array2D.h"
 
class Lreg {
public:
 
    Lreg() {residFlag_=false; diagPFlag_=false; return;};
    ~Lreg() {};
    //void testing();
 
    virtual void SetMindex(Array2D<int>& mindex){};
    virtual void GetMindex(Array2D<int>& mindex){};
    virtual void SetCenters(Array2D<double>& centers){};
    virtual void SetWidths(Array1D<double>& widths){};
    virtual void SetParamsRBF(){};
    virtual void EvalBases(Array2D<double>& xx,Array2D<double>& bb){};// dummy
    virtual void StripBases(Array1D<int>& used){};
 
    void InitRegr();
    void SetupData(Array2D<double>& xdata, Array1D<double>& ydata);
    void SetupData(Array2D<double>& xdata, Array2D<double>& ydata);
    void SetRegMode(string regmode){regMode_=regmode; return;}
    void SetRegWeights(Array1D<double>& weights);
    void BCS_BuildRegr(Array1D<int>& selected, double eta);
    void LSQ_BuildRegr();
    void EvalRegr(Array2D<double>& xcheck, Array1D<double>& ycheck,Array1D<double>& yvar,Array2D<double>& ycov);
 
    int GetNpt() const {return npt_;}
    int GetNdim() const {return ndim_;}
    int GetNbas() const {return nbas_;}
    double GetSigma2() const {return sigma2_;}
    void GetCoefCov(Array2D<double>& coef_cov)  {coef_cov=coef_cov_; return;}
    void GetCoef(Array1D<double>& coef)  {coef=coef_; return;}
    void Proj(Array1D<double>& array,Array1D<double>& proj_array);
    Array1D<double> LSQ_computeBestLambdas();
    double LSQ_computeBestLambda();
    void getResid();
    void getDiagP();
    Array1D<double> computeErrorMetrics(string method);
    double computeRVE(Array2D<double>& xval,Array1D<double>& yval,Array1D<double>& yval_regr);
 
 
 protected:
 
    Array2D<double> xdata_;
    Array1D<double> ydata_;
 
    int npt_;
    int nbas_;
    int ndim_;
    double sigma2_;
    Array1D<double> weights_;
    Array1D<double> resid_;
    bool residFlag_;
    Array1D<double> diagP_;
    bool diagPFlag_;
 
    Array2D<double> bdata_,A_,A_inv_,coef_cov_;
    Array1D<double> Hty_,coef_,coef_erb_;
 
private:
 
    double LSQ_computeLOO();
    double LSQ_computeGCV();
    bool dataSetFlag_;
    string regMode_;
 
};
 
class RBFreg: public Lreg {
public:
    RBFreg(Array2D<double>& centers, Array1D<double>& widths);
    ~RBFreg() {};
 
    void SetCenters(Array2D<double>& centers);
    void SetWidths(Array1D<double>& widths);
 
    void EvalBases(Array2D<double>& xx,Array2D<double>& bb);
    void StripBases(Array1D<int>& used);
 
private:
    Array2D<double> centers_;
    Array1D<double> widths_;
 
};
 
class PCreg: public Lreg {
public:
    PCreg(string strpar,int order,int dim);
    PCreg(string strpar,Array2D<int>& mindex);
    ~PCreg() {};
 
    void EvalBases(Array2D<double>& xx,Array2D<double>& bb);
    void StripBases(Array1D<int>& used);
    void SetMindex(Array2D<int>& mindex){mindex_=mindex;}
    void GetMindex(Array2D<int>& mindex){mindex=mindex_;return;}
 
private:
    Array2D<int> mindex_;
    string pctype_;
 
};
 
class PLreg: public Lreg {
public:
    PLreg(int order, int dim);
    PLreg(Array2D<int>& mindex);
    ~PLreg() {};
 
    void EvalBases(Array2D<double>& xx,Array2D<double>& bb);
    void StripBases(Array1D<int>& used);
    void SetMindex(Array2D<int>& mindex){mindex_=mindex;}
    void GetMindex(Array2D<int>& mindex){mindex=mindex_;return;}
 
 
private:
    Array2D<int> mindex_;
 
};
 
#endif /* LREG_H_SEEN */