InterpolARIMA.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
/***********************************************************************************/
/*  Copyright 2013 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 INTERPOLARIMA_H
#define INTERPOLARIMA_H
 
#include <iostream>
#include <map>
#include <meteoio/thirdParty/ctsa.h>
#include <meteoio/meteoResampling/ARIMAutils.h>
#include <string>
#include <vector>
 
namespace mio {
 
    using namespace ARIMAutils;
    class InterpolARIMA {
    public:
        InterpolARIMA();
        InterpolARIMA(std::vector<double> data_in, size_t gap_loc, size_t N_gap, int s = 0);
        InterpolARIMA(std::vector<double> data_in, size_t gap_loc, size_t N_gap, std::vector<double> xreg_vec, int s = 0);
        InterpolARIMA(std::vector<double> data_in, size_t gap_loc, size_t n_predictions, std::string direction = "forward", int s = 0);
 
        // Setters
        void setAutoArimaMetaData(int max_p_param = 8, int max_d_param = 3, int max_q = 8, int start_p = 2, int start_q = 2, int max_P = 2,
                                  int max_D = 1, int max_Q = 2, int start_P = 1, int start_Q = 1, bool seasonal = true,
                                  bool stationary = false);
        void setOptMetaData(ObjectiveFunction method = CSS_MLE, OptimizationMethod opt_method = BFGS, bool stepwise = true,
                            bool approximation = false, int num_models = 94);
        void setVerbose(bool verbose = false);
        void setNormalizationMode(Normalization::Mode mode);
        void setManualARIMA(int p, int d, int q, int P, int D, int Q, bool fill_backward);
 
        // Interpolation methods
        std::vector<double> simulate(int n_steps, int seed = 0);
        void fillGap();
        void fillGapManual();
 
        void interpolate();
        std::vector<double> predict(size_t n_steps = 0);
        // only do denormalization ARIMA predict! otherwise it will denorm twice
        std::vector<double> ARIMApredict(size_t n_steps);
 
        // Getters
        std::vector<double> getData() { return norm.denormalize(data); }
        std::vector<double> getForwardData() { return norm.denormalize(data_forward); }
        std::vector<double> getBackwardData() { return  norm.denormalize(data_backward); }
        std::vector<double> getInterpolatedData();
 
        // Copy constructor
        InterpolARIMA(const InterpolARIMA &other)
            : norm(other.norm), data(other.data), gap_loc(other.gap_loc), N_gap(other.N_gap), time(other.time), pred_forward(other.pred_forward),
              pred_backward(other.pred_backward), xreg_vec_f(other.xreg_vec_f), xreg_vec_b(other.xreg_vec_b),
              data_forward(other.data_forward), data_backward(other.data_backward), new_xreg_vec_f(other.new_xreg_vec_f),
              new_xreg_vec_b(other.new_xreg_vec_b), xreg_f((xreg_vec_f.empty()) ? nullptr : &xreg_vec_f[0]),
              xreg_b((xreg_vec_b.empty()) ? nullptr : &xreg_vec_b[0]), new_xreg_f((new_xreg_vec_f.empty()) ? nullptr : &new_xreg_vec_f[0]),
              new_xreg_b((new_xreg_vec_b.empty()) ? nullptr : &new_xreg_vec_b[0]), amse_forward(other.amse_forward),
              amse_backward(other.amse_backward), N_data_forward(other.N_data_forward), N_data_backward(other.N_data_backward),
              max_p(other.max_p), max_d(other.max_d), max_q(other.max_q), start_p(other.start_p), start_q(other.start_q),
              max_P(other.max_P), max_D(other.max_D), max_Q(other.max_Q), start_P(other.start_P), start_Q(other.start_Q), r(other.r),
              s(other.s), method(other.method), opt_method(other.opt_method), stepwise(other.stepwise), approximation(other.approximation),
              num_models(other.num_models), seasonal(other.seasonal), stationary(other.stationary),
              auto_arima_forward(auto_arima_copy(other.auto_arima_forward)), auto_arima_backward(auto_arima_copy(other.auto_arima_backward)), sarima_forward(other.sarima_forward) {
    }
 
    // Copy assignment operator
    InterpolARIMA &
    operator=(const InterpolARIMA &other) {
        if (this != &other) // protect against invalid self-assignment
        {
            auto_arima_forward = auto_arima_copy(other.auto_arima_forward);
            auto_arima_backward = auto_arima_copy(other.auto_arima_backward);
 
            // 3: copy all the other fields from the other object
            gap_loc = other.gap_loc;
            N_gap = other.N_gap;
            time = other.time;
            pred_forward = other.pred_forward;
            pred_backward = other.pred_backward;
            norm = other.norm;
            data = other.data;
            xreg_vec_f = other.xreg_vec_f;
            xreg_vec_b = other.xreg_vec_b;
            data_forward = other.data_forward;
            data_backward = other.data_backward;
            new_xreg_vec_f = other.new_xreg_vec_f;
            new_xreg_vec_b = other.new_xreg_vec_b;
            N_data_forward = other.N_data_forward;
            N_data_backward = other.N_data_backward;
            max_p = other.max_p;
            max_d = other.max_d;
            max_q = other.max_q;
            start_p = other.start_p;
            start_q = other.start_q;
            max_P = other.max_P;
            max_D = other.max_D;
            max_Q = other.max_Q;
            start_P = other.start_P;
            start_Q = other.start_Q;
            r = other.r;
            s = other.s;
            method = other.method;
            opt_method = other.opt_method;
            stepwise = other.stepwise;
            approximation = other.approximation;
            num_models = other.num_models;
            seasonal = other.seasonal;
            stationary = other.stationary;
 
            // 4: handle the pointers to the vectors
            xreg_f = (xreg_vec_f.empty()) ? nullptr : &xreg_vec_f[0];
            xreg_b = (xreg_vec_b.empty()) ? nullptr : &xreg_vec_b[0];
            new_xreg_f = (new_xreg_vec_f.empty()) ? nullptr : &new_xreg_vec_f[0];
            new_xreg_b = (new_xreg_vec_b.empty()) ? nullptr : &new_xreg_vec_b[0];
        }
        // by convention, always return *this
        return *this;
    }
 
    ~InterpolARIMA() {
        auto_arima_free(auto_arima_forward);
        auto_arima_free(auto_arima_backward);
        delete xreg_f;
        delete xreg_b;
        delete new_xreg_f;
        delete new_xreg_b;
    }
 
    // info
    std::string toString();
    std::string autoArimaInfo(auto_arima_object obj);
 
 
private:
    // Interpolation variables
    Normalization norm;
    std::vector<double> data;
    size_t gap_loc;
    size_t N_gap;
    std::vector<double> time;
    std::vector<double> pred_forward, pred_backward;
 
    // Auto Arima variables
    // const doesnt work with c
    std::vector<double> xreg_vec_f, xreg_vec_b, data_forward, data_backward, new_xreg_vec_f, new_xreg_vec_b;
    double *xreg_f;
    double *xreg_b;
    double *new_xreg_f;
    double *new_xreg_b;
    std::vector<double> amse_forward, amse_backward;
    size_t N_data_forward, N_data_backward;
    int max_p = 8, max_d = 3, max_q = 8;
    int start_p = 2, start_q = 2;
    int max_P = 2, max_D = 1, max_Q = 2;
    int start_P = 1, start_Q = 1;
    int r = 0, s = 0;
    ObjectiveFunction method = CSS_MLE; OptimizationMethod opt_method = BFGS;
    bool stepwise = true, approximation = true;
    int num_models = 94;
    bool seasonal = true, stationary = false;
 
    bool consistencyCheck();
    auto_arima_object initAutoArima(size_t N_data);
 
    // last to be initialized
public:
    auto_arima_object auto_arima_forward;
    auto_arima_object auto_arima_backward;
 
private:
    // (S)ARIMA variables
    bool set_manual = false;
    bool fill_backward_manual = false;
 
public:
    sarima_object sarima_forward;
};
 
} // namespace mio
 
#endif // INTERPOLARIMA_H