casadi 3.6.5__cp310-none-win_amd64.whl → 3.6.7__cp310-none-win_amd64.whl

casadi/include/fatrop/ocp/UStageOCPImpl.hpp

@@ -0,0 +1,152 @@
+#pragma once
+#include <string>
+#include "fatrop/ocp/OCPAbstract.hpp"
+#include "fatrop/ocp/UStageEvalAbstract.hpp"
+#include <memory>
+namespace fatrop
+{
+        template<typename TUStageEval>
+        class UStageOCPImpl : public OCPAbstract
+        {
+        public:
+            UStageOCPImpl(std::vector<std::shared_ptr<TUStageEval>> && ustages, int n_global_parameters): ustages_(std::move(ustages)), n_global_parameters_(n_global_parameters)
+            {
+                horizon_length_ = ustages_.size();
+            }
+            fatrop_int get_nx(const fatrop_int k) const override { return ustages_[k]->get_nx(); };
+            fatrop_int get_nu(const fatrop_int k) const override { return ustages_[k]->get_nu(); };
+            fatrop_int get_ng(const fatrop_int k) const override { return ustages_[k]->get_ng(); };
+            fatrop_int get_n_stage_params(const fatrop_int k) const override { return ustages_[k]->get_n_stage_params(); };
+            fatrop_int get_n_global_params() const override { return n_global_parameters_; };
+            fatrop_int get_default_stage_params(double *stage_params, const fatrop_int k) const override { return 0; };
+            fatrop_int get_default_global_params(double *global_params) const override { return 0; };
+            fatrop_int get_ng_ineq(const fatrop_int k) const override { return ustages_[k]->get_ng_ineq(); };
+            fatrop_int get_horizon_length() const override { return horizon_length_; };
+            fatrop_int eval_BAbt(
+                const double *states_kp1,
+                const double *inputs_k,
+                const double *states_k,
+                const double *stage_params_k,
+                const double *global_params,
+                MAT *res,
+                const fatrop_int k) override
+            {
+                return ustages_[k]->eval_BAbt(states_kp1, inputs_k, states_k, stage_params_k, global_params, res);
+            };
+            fatrop_int eval_RSQrqt(
+                const double *objective_scale,
+                const double *inputs_k,
+                const double *states_k,
+                const double *lam_dyn_k,
+                const double *lam_eq_k,
+                const double *lam_eq_ineq_k,
+                const double *stage_params_k,
+                const double *global_params,
+                MAT *res,
+                const fatrop_int k) override
+            {
+                return ustages_[k]->eval_RSQrqt(objective_scale, inputs_k, states_k, lam_dyn_k, lam_eq_k, lam_eq_ineq_k, stage_params_k, global_params, res);
+            };
+            fatrop_int eval_Ggt(
+                const double *inputs_k,
+                const double *states_k,
+                const double *stage_params_k,
+                const double *global_params,
+                MAT *res,
+                const fatrop_int k) override
+            {
+                return ustages_[k]->eval_Ggt(inputs_k, states_k, stage_params_k, global_params, res);
+            };
+            fatrop_int eval_Ggt_ineq(
+                const double *inputs_k,
+                const double *states_k,
+                const double *stage_params_k,
+                const double *global_params,
+                MAT *res,
+                const fatrop_int k) override
+            {
+                return ustages_[k]->eval_Ggt_ineq(inputs_k, states_k, stage_params_k, global_params, res);
+            };
+            fatrop_int eval_b(
+                const double *states_kp1,
+                const double *inputs_k,
+                const double *states_k,
+                const double *stage_params_k,
+                const double *global_params,
+                double *res,
+                const fatrop_int k) override
+            {
+                return ustages_[k]->eval_b(states_kp1, inputs_k, states_k, stage_params_k, global_params, res);
+            };
+            fatrop_int eval_g(
+                const double *inputs_k,
+                const double *states_k,
+                const double *stage_params_k,
+                const double *global_params,
+                double *res,
+                const fatrop_int k) override
+            {
+                return ustages_[k]->eval_g(inputs_k, states_k, stage_params_k, global_params, res);
+            };
+            fatrop_int eval_gineq(
+                const double *inputs_k,
+                const double *states_k,
+                const double *stage_params_k,
+                const double *global_params,
+                double *res,
+                const fatrop_int k) override
+            {
+                return ustages_[k]->eval_gineq(inputs_k, states_k, stage_params_k, global_params, res);
+            };
+            fatrop_int eval_rq(
+                const double *objective_scale,
+                const double *inputs_k,
+                const double *states_k,
+                const double *stage_params_k,
+                const double *global_params,
+                double *res,
+                const fatrop_int k) override
+            {
+                return ustages_[k]->eval_rq(objective_scale, inputs_k, states_k, stage_params_k, global_params, res);
+            };
+            fatrop_int eval_L(
+                const double *objective_scale,
+                const double *inputs_k,
+                const double *states_k,
+                const double *stage_params_k,
+                const double *global_params,
+                double *res,
+                const fatrop_int k) override
+            {
+                return ustages_[k]->eval_L(objective_scale, inputs_k, states_k, stage_params_k, global_params, res);
+            };
+            fatrop_int get_bounds(double *lower, double *upper, const fatrop_int k) const override
+            {
+                return ustages_[k]->get_bounds(lower, upper);
+            };
+            fatrop_int get_initial_xk(double *xk, const fatrop_int k) const override
+            {
+                // initialization is done higher up
+                for (int i = 0; i < get_nx(k); i++)
+                {
+                    xk[i] = 0;
+                }
+                return 0;
+            };
+            fatrop_int get_initial_uk(double *uk, const fatrop_int k) const override
+            {
+                // initialization is done higher up
+                for (int i = 0; i < get_nu(k); i++)
+                {
+                    uk[i] = 0;
+                }
+                return 0;
+            };
+
+        private:
+            std::vector<std::shared_ptr<TUStageEval>> ustages_;
+            int horizon_length_;
+            int n_global_parameters_;
+        };
+        // implementation of OCPAbstract, given an OCP
+} // namespace fatrop

casadi/include/fatrop/quasi_newton/bfgs.hpp

@@ -0,0 +1,159 @@
+
+    class BFGSUpdater
+    {
+    public:
+        BFGSUpdater(const int m) : m(m), Bk_prev(m, m), tmp1(m, 2), tmp2(m, 2), vk(m), yk_tilde(m) {}
+        int update(MAT *Bip1, VEC *si, VEC *yi)
+        {
+            MAT *Bk_prev_p = Bk_prev;
+            VEC *vk_p = vk;
+            VEC *yk_tilde_p = yk_tilde;
+
+            // powell update formula
+            // compute update
+            double sts = DOT(m, si, 0, si, 0);
+            double sty = DOT(m, si, 0, yi, 0);
+            double yty = DOT(m, yi, 0, yi, 0);
+            if (sts == 0.0 || first_time)
+            {
+                skips = 0;
+                reset();
+                GECP(m, m, Bk_prev_p, 0, 0, Bip1, 0, 0);
+                return 0;
+            }
+            GEMV_N(m, m, 1.0, Bk_prev_p, 0, 0, si, 0, 0.0, vk_p, 0, vk_p, 0);
+            double stv = DOT(m, si, 0, vk_p, 0);
+            double beta = -1.0 / stv;
+#define SKIPPING
+#define ALT_RANK1
+#ifdef SKIPPING
+            double alpha_tilde = 1.0 / sty;
+            AXPBY(m, 1.0, yi, 0, 0.0, vk_p, 0, yk_tilde_p, 0);
+            if (sty <= 1e-8 * std::sqrt(yty) * std::sqrt(sts))
+            {
+                int ret = 0;
+                if (skips >= 1)
+                {
+                    reset(1.0);
+                    ret = 1;
+                    // std::cout << "resetting Bk" << std::endl;
+                }
+                GECP(m, m, Bk_prev_p, 0, 0, Bip1, 0, 0);
+                skips++;
+                return ret;
+            }
+#else
+            double theta = sty > 0.2 * stv ? 1.0 : (0.8 * stv) / (stv - sty);
+            AXPBY(m, theta, yi, 0, 1.0 - theta, vk_p, 0, yk_tilde_p, 0);
+            double sty_tilde = DOT(m, si, 0, yk_tilde_p, 0);
+            double alpha_tilde = 1.0 / sty_tilde;
+#endif
+#ifdef ALT_RANK1
+
+            COLIN(m, yk_tilde_p, 0, tmp1, 0, 0);
+            VECSC(m, alpha_tilde, yk_tilde_p, 0);
+            COLIN(m, yk_tilde_p, 0, tmp2, 0, 0);
+
+            COLIN(m, vk_p, 0, tmp1, 0, 1);
+            VECSC(m, beta, vk_p, 0);
+            COLIN(m, vk_p, 0, tmp2, 0, 1);
+
+            SYRK_LN(m, 2, 1.0, tmp1, 0, 0, tmp2, 0, 0, 1.0, Bk_prev_p, 0, 0, Bip1, 0, 0);
+            TRTR_L(m, Bip1, 0, 0, Bip1, 0, 0);
+#else
+            GER(m, m, alpha_tilde, yk_tilde_p, 0, yk_tilde_p, 0, Bk_prev_p, 0, 0, Bip1, 0, 0);
+            GER(m, m, beta, vk_p, 0, vk_p, 0, Bip1, 0, 0, Bip1, 0, 0);
+#endif
+            // save the previous Bk
+            GECP(m, m, Bip1, 0, 0, Bk_prev_p, 0, 0);
+            skips = 0;
+            return 0;
+        }
+        void reset(double alpha = 1.0, bool reset_skips = true)
+        {
+            // std:: cout << "resetting Bk" << std::endl;
+            MAT *Bk_prev_p = Bk_prev;
+            // identity matrix for B0
+            GESE(m, m, 0.0, Bk_prev_p, 0, 0);
+            DIARE(m, alpha, Bk_prev_p, 0, 0);
+        }
+        const int m;
+        MATBF Bk_prev;
+        MATBF tmp1;
+        MATBF tmp2;
+        VECBF vk;
+        VECBF yk_tilde;
+        int skips = 0;
+        bool first_time = true;
+    };
+    class OCPBFGSUpdater : public BFGSUpdater
+    {
+    public:
+        OCPBFGSUpdater(int nu, int nx, int nxp1, int ng, int ng_ineq, bool first, bool last) : BFGSUpdater(nu + nx), nu(nu), nx(nx), nxp1(nxp1), ng(ng), ng_ineq(ng_ineq), first(first), last(last), BAt_prev(nu + nx, nxp1), Gt_prev(nu + nx, ng), Gt_ineq_prev(nu + nx, ng_ineq), ux_prev(nu + nx), grad_obj_prev(nu + nx), s(nu + nx), y(nu + nx) {reset();}
+        int update(MAT *Bkp1, VEC *ux, int a_ux, VEC *grad_obj, int a_grad_obj, MAT *BAbt, VEC *lam_dyn, int a_lam_dyn, MAT *Ggt, VEC *lam_eq, int a_lam_eq, MAT *Ggt_ineq, VEC *lam_ineq, int a_lam_ineq)
+        {
+            VEC *ux_prev_p = ux_prev;
+            VEC *grad_obj_prev_p = grad_obj_prev;
+            VEC *s_p = s;
+            VEC *y_p = y;
+            MAT *BAt_prev_p = BAt_prev;
+            MAT *Gt_prev_p = Gt_prev;
+            MAT *Gt_ineq_prev_p = Gt_ineq_prev;
+
+            // compute s
+            AXPBY(nu + nx, 1.0, ux, a_ux, -1.0, ux_prev_p, 0, s_p, 0);
+
+            // compute y
+            AXPBY(nu + nx, 1.0, grad_obj, a_grad_obj, 0.0, y_p, 0, y_p, 0);
+            if (!last)
+            {
+                // contribution from dynamics
+                GEMV_N(nu + nx, nxp1, 1.0, BAbt, 0, 0, lam_dyn, a_lam_dyn, 1.0, y_p, 0, y_p, 0);
+            }
+            // contribution from equality constraints
+            GEMV_N(nu + nx, ng, 1.0, Ggt, 0, 0, lam_eq, a_lam_eq, 1.0, y_p, 0, y_p, 0);
+            // contribution from inequality constraints
+            GEMV_N(nu + nx, ng_ineq, 1.0, Ggt_ineq, 0, 0, lam_ineq, a_lam_ineq, 1.0, y_p, 0, y_p, 0);
+            // save in last row
+            ROWIN(nu + nx, 1.0, y_p, 0, Bkp1, nu + nx, 0);
+            if (!first_time)
+            {
+                AXPBY(nu + nx, -1.0, grad_obj_prev_p, 0, 1.0, y_p, 0, y_p, 0);
+                if (!last)
+                {
+                    // contribution from dynamics
+                    GEMV_N(nu + nx, nxp1, -1.0, BAt_prev_p, 0, 0, lam_dyn, a_lam_dyn, 1.0, y_p, 0, y_p, 0);
+                }
+                // contribution from equality constraints
+                GEMV_N(nu + nx, ng, -1.0, Gt_prev_p, 0, 0, lam_eq, a_lam_eq, 1.0, y_p, 0, y_p, 0);
+                // contribution from inequality constraints
+                GEMV_N(nu + nx, ng_ineq, -1.0, Gt_ineq_prev_p, 0, 0, lam_ineq, a_lam_ineq, 1.0, y_p, 0, y_p, 0);
+            }
+            // call BFGS update
+            int ret = BFGSUpdater::update(Bkp1, s_p, y_p);
+            // save ux and grad_obj
+            VECCP(nu + nx, ux, a_ux, ux_prev_p, 0);
+            VECCP(nu + nx, grad_obj, a_grad_obj, grad_obj_prev_p, 0);
+            // save BAt, Gt, Gt_ineq
+            GECP(nu + nx, nxp1, BAbt, 0, 0, BAt_prev_p, 0, 0);
+            GECP(nu + nx, ng, Ggt, 0, 0, Gt_prev_p, 0, 0);
+            GECP(nu + nx, ng_ineq, Ggt_ineq, 0, 0, Gt_ineq_prev_p, 0, 0);
+            first_time = false;
+            // blasfeo_print_dmat(nu+nx+1, nu+nx, Bkp1, 0, 0);
+            return ret;
+        }
+        void reset()
+        {
+            first_time = true;
+            BFGSUpdater::reset();
+        }
+        const int nu, nx, nxp1, ng, ng_ineq;
+        const bool first, last;
+        MATBF BAt_prev;
+        MATBF Gt_prev;
+        MATBF Gt_ineq_prev;
+        VECBF ux_prev;
+        VECBF grad_obj_prev;
+        VECBF s;
+        VECBF y;
+    };

casadi/include/fatrop/solver/AlgBuilder.hpp

@@ -0,0 +1,76 @@
+/*
+ * Fatrop - A fast trajectory optimization solver
+ *  Copyright (C) 2022 - 2024 Lander Vanroye, KU Leuven. All rights reserved.
+ *
+ * This file is part of Fatrop.
+ *
+ * Fatrop 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.
+ *
+ * Fatrop 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 Fatrop.  If not, see <http://www.gnu.org/licenses/>. */
+#ifndef ALBBUILDERINCLUDED
+#define ALBBUILDERINCLUDED
+// #include "NLPAlg.hpp"
+#include "FatropAlg.hpp"
+#include "fatrop/auxiliary/Common.hpp"
+namespace fatrop
+{
+    class AlgBuilder
+    {
+    public:
+        void build_fatrop_algorithm_objects(const std::shared_ptr<FatropNLP> &nlp,const std::shared_ptr<FatropNLP> &nlp_resto,
+                                            const std::shared_ptr<FatropOptions> &fatropparams,
+                                            std::shared_ptr<FatropData> &fatropdata, std::shared_ptr<FatropData> &fatropdata_resto,
+                                            std::shared_ptr<Journaller> &journaller)
+        {
+            if (fatropprinter_ == nullptr)
+            {
+                fatropprinter_ = std::make_shared<FatropPrinter>();
+            }
+            fatropdata = std::make_shared<FatropData>(nlp->get_nlp_dims(), fatropparams, fatropprinter_);
+            fatropdata_resto = std::make_shared<FatropData>(nlp_resto->get_nlp_dims(), fatropparams, fatropprinter_);
+            journaller = std::make_shared<Journaller>(fatropparams->maxiter + 1, fatropprinter_);
+            fatropdata_ = fatropdata; // keep this around for building the algorithm
+            fatropdata_resto_ = fatropdata_resto;
+            journaller_ = journaller;
+            nlp_ = nlp;
+            nlp_resto_ = nlp_resto;
+            fatropoptions_ = fatropparams;
+        }
+        void set_printer(const std::shared_ptr<FatropPrinter> &printer)
+        {
+            fatropprinter_ = printer;
+        }
+        std::shared_ptr<FatropAlg> build_algorithm()
+        {
+            // TODO unsafe if maxiter is changed during application
+            std::shared_ptr<Filter> filter = std::make_shared<Filter>(fatropoptions_->maxiter + 1);
+            std::shared_ptr<LineSearch> linesearch = std::make_shared<BackTrackingLineSearch>(fatropoptions_, nlp_, fatropdata_, filter, journaller_, fatropprinter_);
+            std::shared_ptr<Filter> filter_resto = std::make_shared<Filter>(fatropoptions_->maxiter + 1);
+            std::shared_ptr<LineSearch> linesearch_resto = std::make_shared<BackTrackingLineSearch>(fatropoptions_, nlp_resto_, fatropdata_resto_, filter_resto, journaller_, fatropprinter_);
+            std::shared_ptr<FatropAlg> orig_alg = std::make_shared<FatropAlg>(nlp_, fatropdata_, fatropoptions_, filter, linesearch, journaller_, fatropprinter_, nullptr, nullptr, false);
+            std::shared_ptr<FatropAlg> resto_alg = std::make_shared<FatropAlg>(nlp_resto_, fatropdata_resto_, fatropoptions_, filter_resto, linesearch_resto, journaller_, fatropprinter_, orig_alg, nullptr, true);
+            orig_alg-> set_resto_alg(resto_alg);
+            return orig_alg;
+        }
+
+    private:
+        std::shared_ptr<FatropNLP> nlp_;
+        std::shared_ptr<FatropNLP> nlp_resto_;
+        std::shared_ptr<FatropOptions> fatropoptions_;
+        std::shared_ptr<FatropData> fatropdata_;
+        std::shared_ptr<FatropData> fatropdata_resto_;
+        std::shared_ptr<Journaller> journaller_;
+        std::shared_ptr<FatropPrinter> fatropprinter_;
+    };
+};
+
+#endif // ALBBUILDERINCLUDED

casadi/include/fatrop/solver/AlgStrategy.hpp

@@ -0,0 +1,33 @@
+/*
+ * Fatrop - A fast trajectory optimization solver
+ *  Copyright (C) 2022 - 2024 Lander Vanroye, KU Leuven. All rights reserved.
+ *
+ * This file is part of Fatrop.
+ *
+ * Fatrop 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.
+ *
+ * Fatrop 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 Fatrop.  If not, see <http://www.gnu.org/licenses/>. */
+#ifndef ALGSTRATEGYINCLUDED
+#define ALGSTRATEGYINCLUDED
+#include "FatropOptions.hpp"
+#include <memory>
+namespace fatrop
+{
+    class AlgStrategy
+    {
+    public:
+        AlgStrategy(const std::shared_ptr<FatropOptions> &fatrop_params) : fatrop_params_(fatrop_params){};
+        std::shared_ptr<FatropOptions> fatrop_params_;
+        void initialize() {};
+    };
+};
+#endif // !ALGSTRATEGYINCLUDED

casadi/include/fatrop/solver/FatropAlg.hpp

@@ -0,0 +1,121 @@
+/*
+ * Fatrop - A fast trajectory optimization solver
+ *  Copyright (C) 2022 - 2024 Lander Vanroye, KU Leuven. All rights reserved.
+ *
+ * This file is part of Fatrop.
+ *
+ * Fatrop 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.
+ *
+ * Fatrop 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 Fatrop.  If not, see <http://www.gnu.org/licenses/>. */
+#ifndef FATROPALGINCLUDED
+#define FATROPALGINCLUDED
+#include "fatrop/templates/NLPAlg.hpp"
+#include "FatropData.hpp"
+#include "Filter.hpp"
+#include "LineSearch.hpp"
+#include <cmath>
+#include "IterationData.hpp"
+#include <memory>
+#include "FatropStats.hpp"
+#include <limits>
+#include <fatrop/solver/FatropPrinter.hpp>
+#include "fatrop/auxiliary/Common.hpp"
+// #include "AlgorithmQuantities.hpp"
+// #ifdef ENABLE_MULTITHREADING
+// #include "fatrop/auxiliary/Worker.hpp"
+// #endif
+
+namespace fatrop
+{
+    // TODO: get rid of FatropApplication
+    class FatropAlg 
+    {
+    public:
+        FatropAlg(
+            const std::shared_ptr<FatropNLP> &fatropnlp,
+            const std::shared_ptr<FatropData> &fatropdata,
+            const std::shared_ptr<FatropOptions> &fatropparams,
+            const std::shared_ptr<Filter> &filter,
+            const std::shared_ptr<LineSearch> &linesearch,
+            const std::shared_ptr<Journaller> &journaller, 
+            const std::shared_ptr<FatropPrinter> &printer, 
+            const std::shared_ptr<FatropAlg>&orig_, const std::shared_ptr<FatropAlg>&resto_alg_, bool resto_problem);
+        void initialize() ;
+        void reset() ;
+        void set_bounds(const std::vector<double> &lower, const std::vector<double> &upper) ;
+        void set_initial(const std::vector<double> &initial) ;
+        void get_solution(std::vector<double> &sol) ;
+        fatrop_int optimize() ;
+        fatrop_int eval_lag_hess();
+        fatrop_int eval_constr_jac();
+        fatrop_int eval_constr_viol_curr();
+        fatrop_int eval_constr_viol_trial();
+        fatrop_int eval_obj_grad_curr();
+        double eval_objective_curr();
+        double eval_objective_trial();
+        fatrop_int eval_dual_infeasiblity();
+        fatrop_int perform_initializiation_dual();
+        fatrop_int solve_pd_sys(double inertia_correction_w, double inertia_correction_c, double mu);
+        fatrop_int start_resto_alg(double mu, int iter);
+        fatrop_int return_from_resto_alg(double mu);
+        bool resto_stop_crit();
+        std::shared_ptr<FatropNLP> fatropnlp_;
+        std::shared_ptr<FatropData> fatropdata_;
+        std::shared_ptr<FatropOptions> fatropoptions_;
+        std::shared_ptr<Filter> filter_;
+        std::shared_ptr<LineSearch> linesearch_;
+        std::shared_ptr<Journaller> journaller_;
+        std::shared_ptr<FatropPrinter> printer_;
+        FatropStats get_stats() 
+        {
+            return stats;
+        };
+
+    public:
+        double tol;
+        double acceptable_tol;
+        fatrop_int acceptable_iter;
+        fatrop_int maxiter;
+        void set_resto_alg(const std::shared_ptr<FatropAlg> &resto_alg)
+        {
+            resto_alg_ = resto_alg;
+        };
+
+    private:
+        double lammax;
+        double mu0;
+        double kappa_eta;
+        double kappa_mu;
+        double theta_mu;
+        double delta_w0;
+        double delta_wmin;
+        double kappa_wmin;
+        double kappa_wplus;
+        double kappa_wplusem;
+        double delta_c_stripe;
+        double kappa_c;
+        double kappa_d;
+        double theta_min;
+        fatrop_int max_watchdog_steps;
+        bool warm_start_init_point;
+        bool recalc_y;
+        double recalc_y_feas_tol;
+        // bool first_try_watchdog;
+        FatropStats stats;
+        std::weak_ptr<FatropAlg> orig_;
+        std::shared_ptr<FatropAlg> resto_alg_;
+        bool resto_problem_ = false;
+        fatrop_int start_iter_ = 0;
+        fatrop_int iter_count_ = 0;
+    };
+} // namespace fatrop
+#endif // FATROPALGINCLUDED