libfit1D.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
/***********************************************************************************/
/*  Copyright 2011 WSL Institute for Snow and Avalanche Research    SLF-DAVOS      */
/***********************************************************************************/
/* This file is part of MeteoIO.
    MeteoIO is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    MeteoIO 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 Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with MeteoIO.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef LIBFIT1D_H
#define LIBFIT1D_H
 
#include <meteoio/meteoStats/libfit1DCore.h>
#include <meteoio/IOUtils.h>
 
#include <vector>
 
namespace mio {
 
class Zero : public FitModel {
        public:
                Zero() : FitModel("Zero", 0, 0) {fit_ready=true;}
                void setData(const std::vector<double>& /*in_X*/, const std::vector<double>& /*in_Y*/) {}
                bool fit() { return true;}
                double f(const double& /*x*/) const {return 0.;}
};
 
class SimpleLinear : public FitModel {
        public:
                SimpleLinear() : FitModel("SimpleLinear", 2, 2), fixed_lapse_rate(IOUtils::nodata) {fit_ready=false;}
                SimpleLinear(const std::string& i_regname) : FitModel(i_regname, 2, 2), fixed_lapse_rate(IOUtils::nodata) {fit_ready=false;}
                void setData(const std::vector<double>& in_X, const std::vector<double>& in_Y);
                bool fit();
                double f(const double& x) const;
                void setLapseRate(const double& in_lapse_rate) {fixed_lapse_rate = in_lapse_rate; fit_ready = false; min_nb_pts--;}
        protected:
                double fixed_lapse_rate;
};
 
class NoisyLinear : public SimpleLinear {
        public:
                NoisyLinear() : SimpleLinear("NoisyLinear") {fit_ready=false;}
                bool fit();
};
 
class SphericVario : public FitLeastSquare {
        public:
                SphericVario() : FitLeastSquare("SphericVario", 3, 4) {fit_ready = false;}
                void setDefaultGuess();
                double f(const double& x) const;
};
 
class LinVario : public FitLeastSquare {
        public:
                LinVario() : FitLeastSquare("LinVario", 2, 3) {fit_ready = false;}
                void setDefaultGuess();
                double f(const double& x) const;
};
 
class ExpVario : public FitLeastSquare {
        public:
                ExpVario() : FitLeastSquare("ExpVario", 3, 4) {fit_ready = false;}
                void setDefaultGuess();
                double f(const double& x) const;
};
 
class RatQuadVario : public FitLeastSquare {
        public:
                RatQuadVario() : FitLeastSquare("RatQuadVario", 3, 4) {fit_ready = false;}
                void setDefaultGuess();
                double f(const double& x) const;
};
 
class LinearLS : public FitLeastSquare {
        public:
                LinearLS() : FitLeastSquare("LinearLS", 2, 3) {fit_ready = false;}
                void setDefaultGuess();
                double f(const double& x) const;
};
 
class Quadratic : public FitLeastSquare {
        public:
                Quadratic() : FitLeastSquare("Quadratic", 3, 4) {fit_ready = false;}
                void setDefaultGuess();
                double f(const double& x) const;
};
 
class PolynomialRegression : public FitModel {
        public:
            //the default-constructor sets the degree to 2 (= quadratic regression)
                PolynomialRegression() : FitModel("POLYNOMIAL", 3, 3), degree(2) {fit_ready=false;}
                PolynomialRegression(const std::string& i_regname, const size_t& degreeOfRegression) :
                            FitModel(i_regname, degreeOfRegression+1, degreeOfRegression+1),
                            degree(degreeOfRegression){fit_ready=false;}
                void setData(const std::vector<double>& in_X, const std::vector<double>& in_Y);
                bool fit();
                double f(const double& x) const;
                void setDegree(const size_t& in_degree) {degree = in_degree; fit_ready = false; min_nb_pts=in_degree+1; nParam=in_degree+1; }
        protected:
                size_t degree;
};
 
class Fit1D {
        public:
                typedef enum REGRESSION {
                        ZERO, 
                        SIMPLE_LINEAR, 
                        NOISY_LINEAR, 
                        LINVARIO, 
                        EXPVARIO, 
                        SPHERICVARIO, 
                        RATQUADVARIO, 
                        LINEARLS, 
                        QUADRATIC, 
                        POLYNOMIAL 
                } regression;
 
                Fit1D() : model(nullptr) {}
 
                Fit1D(const regression& regType, const std::vector<double>& in_X, const std::vector<double>& in_Y, const bool& updatefit=true);
 
                Fit1D(const std::string& regType, const std::vector<double>& in_X, const std::vector<double>& in_Y, const bool& updatefit=true);
 
                Fit1D(const Fit1D& i_fit);
 
                ~Fit1D() {delete model;}
 
                bool setModel(const regression& i_regType, const std::vector<double>& in_X, const std::vector<double>& in_Y, const bool& updatefit=true);
 
                bool setModel(const std::string& i_regType, const std::vector<double>& in_X, const std::vector<double>& in_Y, const bool& updatefit=true);
 
                void setGuess(const std::vector<double>& lambda_in) {model->setGuess(lambda_in);}
 
                void setLapseRate(const double& lapse_rate) {model->setLapseRate(lapse_rate);}
 
                void setDegree(const size_t& degree) {model->setDegree(degree);}
 
                bool fit() {return model->fit();}
 
                double f(const double& x) const {return model->f(x);}
 
                std::vector<double> getParams() const { return model->getParams();}
 
                std::string getName() const {return model->getName();}
 
                std::string getInfo() const {return model->getInfo();}
 
                void setInfo(const std::string& info) {model->setInfo(info);}
 
                Fit1D& operator =(const Fit1D& source);
 
                double operator ()(const double& x) const {return model->f(x);}
 
                std::string toString() const {return model->toString();}
 
        private:
                FitModel *model;
};
 
class FitLinClosedForm {
        public:
                FitLinClosedForm() : predictors(), observations(), Beta(), regname("MultiLinear"), infoString(), nPreds(0), fit_ready(false) {}
 
                void addData(const std::vector<double>& vecPreds, const double& obs);
                bool fit();
                double f(const std::vector<double>& x) const;
                double operator ()(const std::vector<double>& x) const { return f(x);}
                std::vector<double> getParams() const;
                std::string getName() const {return regname;}
                std::string getInfo() const {return infoString;}
                void setInfo(const std::string& info) {infoString=info;}
                FitLinClosedForm& operator =(const FitLinClosedForm& source);
                bool isReady() const {return fit_ready;}
                std::string toString() const;
        private:
                std::vector< std::vector<double> > predictors;
                std::vector<double> observations;
                Matrix Beta;
                const std::string regname; //model name
                std::string infoString;
                size_t nPreds; 
                bool fit_ready;
};
 
} //end namespace
 
#endif