casadi 3.6.4__cp312-none-manylinux2014_x86_64.whl → 3.6.6__cp312-none-manylinux2014_x86_64.whl

casadi/include/fatrop/ocp/CasadiCApiUserdataWrap.hpp

@@ -0,0 +1,87 @@
+#pragma once
+#include <vector>
+#include <memory>
+#ifndef casadi_real_capi
+#define casadi_real_capi double
+#endif
+
+#ifndef casadi_int_capi
+#define casadi_int_capi long long int
+#endif
+// c++ stuff here
+// TODO: this can become part of the default fatrop API as well. It has no dependency on casadi.
+// forward declaration of OCPApplication
+namespace fatrop
+{
+  class OCPAbstractApplication;
+  namespace spectool
+  {
+
+    struct C_api_userdata
+    {
+      // constructor
+      C_api_userdata(const std::shared_ptr<fatrop::OCPAbstractApplication> &app);
+      const std::shared_ptr<fatrop::OCPAbstractApplication> app_;
+      std::vector<std::vector<casadi_int_capi>> sparsity_in;
+      std::vector<std::vector<casadi_int_capi>> sparsity_out;
+      std::vector<double> arg_initial_vars;
+      std::vector<double> arg_stage_parameters;
+      std::vector<double> arg_global_parameters;
+      int n_vars;
+      int n_stage_params;
+      int n_global_params;
+      int ref_count = 0;
+    };
+  }
+}
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* How to prefix internal symbols */
+#ifdef CASADI_CODEGEN_PREFIX
+#define CASADI_NAMESPACE_CONCAT(NS, ID) _CASADI_NAMESPACE_CONCAT(NS, ID)
+#define _CASADI_NAMESPACE_CONCAT(NS, ID) NS##ID
+#define CASADI_PREFIX(ID) CASADI_NAMESPACE_CONCAT(CODEGEN_PREFIX, ID)
+#else
+#undef CASADI_PREFIX
+#define CASADI_PREFIX(ID) f_##ID
+#endif
+
+/* Symbol visibility in DLLs */
+#ifndef CASADI_SYMBOL_EXPORT
+#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#if defined(STATIC_LINKED)
+#define CASADI_SYMBOL_EXPORT
+#else
+#define CASADI_SYMBOL_EXPORT __declspec(dllexport)
+#endif
+#elif defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#define CASADI_SYMBOL_EXPORT __attribute__((visibility("default")))
+#else
+#define CASADI_SYMBOL_EXPORT
+#endif
+#endif
+
+  CASADI_SYMBOL_EXPORT int fatrop_func(const casadi_real_capi **arg, casadi_real_capi **res, casadi_int_capi *iw, casadi_real_capi *w, int mem, void *user_data);
+  CASADI_SYMBOL_EXPORT int fatrop_func_alloc_mem(void *user_data);
+  CASADI_SYMBOL_EXPORT int fatrop_func_init_mem(int mem, void *user_data);
+  CASADI_SYMBOL_EXPORT void fatrop_func_free_mem(int mem, void *user_data);
+  CASADI_SYMBOL_EXPORT int fatrop_func_checkout(void *user_data);
+  CASADI_SYMBOL_EXPORT void fatrop_func_release(int mem, void *user_data);
+  CASADI_SYMBOL_EXPORT void fatrop_func_incref(void *user_data);
+  CASADI_SYMBOL_EXPORT void fatrop_func_decref(void *user_data);
+  CASADI_SYMBOL_EXPORT casadi_int_capi fatrop_func_n_in(void *user_data);
+  CASADI_SYMBOL_EXPORT casadi_int_capi fatrop_func_n_out(void *user_data);
+  CASADI_SYMBOL_EXPORT casadi_real_capi fatrop_func_default_in(casadi_int_capi i, void *user_data);
+  CASADI_SYMBOL_EXPORT const char *fatrop_func_name_in(casadi_int_capi i, void *user_data);
+  CASADI_SYMBOL_EXPORT const char *fatrop_func_name_out(casadi_int_capi i, void *user_data);
+  CASADI_SYMBOL_EXPORT const casadi_int_capi *fatrop_func_sparsity_in(casadi_int_capi i, void *user_data);
+  CASADI_SYMBOL_EXPORT const casadi_int_capi *fatrop_func_sparsity_out(casadi_int_capi i, void *user_data);
+  CASADI_SYMBOL_EXPORT int fatrop_func_work(casadi_int_capi *sz_arg, casadi_int_capi *sz_res, casadi_int_capi *sz_iw, casadi_int_capi *sz_w, void *user_data);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif

casadi/include/fatrop/ocp/DuInfEvaluator.hpp

@@ -0,0 +1,38 @@
+/*
+ * 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 DUINFEVALINCLUDED
+#define DUINFEVALINCLUDED
+#include "fatrop/blasfeo_wrapper/LinearAlgebraBlasfeo.hpp"
+#include "OCPKKT.hpp"
+#include "fatrop/auxiliary/Common.hpp"
+namespace fatrop
+{
+#define OCPMACRO(type, name, suffix) type name##suffix = ((type)OCP->name)
+    class DuInfEvaluator
+    {
+    public:
+        fatrop_int evaluate(
+            OCPKKTMemory *OCP,
+            double obj_scale,
+            const FatropVecBF &lam,
+            const FatropVecBF &grad,
+            FatropVecBF &du_inf);
+    };
+}
+#endif //  DUINFEVALINCLUDED

casadi/include/fatrop/ocp/FatropOCP.hpp

@@ -0,0 +1,161 @@
+/*
+ * 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 OCPALGINCLUDED
+#define OCPALGINCLUDED
+#include "fatrop/blasfeo_wrapper/LinearAlgebraBlasfeo.hpp"
+#include "fatrop/templates/NLPAlg.hpp"
+#include "OCPKKT.hpp"
+#include "OCPLinearSolver.hpp"
+#include "OCPScalingMethod.hpp"
+#include "DuInfEvaluator.hpp"
+#include "OCPInitializer.hpp"
+#include "fatrop/solver/FatropPrinter.hpp"
+// #include "fatrop/ocp/LineSearchDDP.hpp"
+// #include "sparse/SparseOCP.hpp"
+#include "OCP.hpp"
+#include <memory>
+#include "fatrop/auxiliary/Common.hpp"
+#include "OCPLSScaler.hpp"
+// #include <unistd.h>
+namespace fatrop
+{
+    class FatropOCP : public FatropNLP
+    {
+    public:
+        // FatropOCP();
+        FatropOCP(
+            const std::shared_ptr<OCP> &ocp,
+            const std::shared_ptr<OCPLinearSolver> &ls,
+            const std::shared_ptr<OCPScalingMethod> &scaler, const std::shared_ptr<FatropOptions> &options, const std::shared_ptr<FatropPrinter> &printer);
+        fatrop_int eval_lag_hess(
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            const FatropVecBF &lam) override;
+        fatrop_int eval_constr_jac(
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars) override;
+        fatrop_int solve_pd_sys(
+            const double inertia_correction_w,
+            const double inertia_correction_c,
+            const FatropVecBF &ux,
+            const FatropVecBF &lam,
+            const FatropVecBF &delta_s,
+            const FatropVecBF &sigma_total,
+            const FatropVecBF &gradb_total) override;
+        fatrop_int solve_soc_rhs(
+            const FatropVecBF &ux,
+            const FatropVecBF &lam,
+            const FatropVecBF &delta_s,
+            const FatropVecBF &constraint_violation) override;
+        fatrop_int compute_scalings(
+            double &obj_scale,
+            FatropVecBF &x_scales,
+            FatropVecBF &lam_scales,
+            const FatropVecBF &grad_curr_x, const FatropVecBF& grad_curr_s) override;
+        fatrop_int eval_constraint_viol(
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            FatropVecBF &constraint_violation) override;
+        fatrop_int eval_obj_grad(
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            FatropVecBF &gradient_x,FatropVecBF &gradient_s) override;
+        fatrop_int eval_obj(
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            double &res) override;
+        fatrop_int eval_dual_inf(
+            double obj_scale,
+            const FatropVecBF &lam,
+            const FatropVecBF &grad_x,
+            const FatropVecBF &grad_s,
+            FatropVecBF &du_inf_x, FatropVecBF& du_inf_s) override;
+        fatrop_int initialize_slacks(double mu0,
+            FatropVecBF &s_curr) override;
+        fatrop_int initialize_dual(
+            const FatropVecBF &grad_x,
+            const FatropVecBF &grad_s,
+            FatropVecBF &dlam,
+            const FatropVecBF &zL,
+            const FatropVecBF &zU) override;
+
+        fatrop_int get_bounds(
+            FatropVecBF &lower,
+            FatropVecBF &upper) const override
+        {
+            return ocp_->get_bounds(lower, upper);
+        };
+        fatrop_int get_initial_sol_guess(
+            FatropVecBF &initial) const override
+        {
+            return ocp_->get_initial_sol_guess(initial);
+        };
+        // int GetDefaultParams(
+        //     FatropOptions &params) const override
+        //     {
+        //        return ocp_->GetDefaultParams(params);
+        //     };
+        NLPDims get_nlp_dims() const override;
+        void finalize() override;
+        void reset() override;
+
+    public:
+        std::shared_ptr<OCP> ocp_;
+        OCPDims dims_;
+        NLPDims nlpdims_;
+        std::shared_ptr<OCPLinearSolver> ls_;
+        std::shared_ptr<OCPScalingMethod> scaler_;
+        std::shared_ptr<FatropOptions> options_;
+        std::shared_ptr<FatropPrinter> printer_;
+        DuInfEvaluator duinfevaluator_;
+        OCPKKTMemory ocpkktmemory_;
+        OCPInitializer OCPInitializer_;
+        FatropMemoryVecBF s_memvec;
+        FatropMemoryVecBF ux_memvec;
+        FatropVecBF sigma;
+        FatropVecBF gradb;
+        FatropVecBF s_dummy;
+        FatropVecBF s_zero;
+        FatropVecBF ux_dummy;
+        FatropMemoryVecBF rhs_rq;
+        FatropMemoryVecBF rhs_b;
+        FatropMemoryVecBF rhs_g;
+        FatropMemoryVecBF rhs_g_ineq;
+        FatropMemoryVecBF rhs_gradb;
+        FatropMemoryVecBF rhs_rq2;
+        FatropMemoryVecBF rhs_b2;
+        FatropMemoryVecBF rhs_g2;
+        FatropMemoryVecBF rhs_g_ineq2;
+        FatropMemoryVecBF rhs_gradb2;
+        FatropMemoryVecBF gradb_total_cache;
+        FatropMemoryVecBF sigma_total_cache;
+        FatropMemoryVecBF ux_test;
+        FatropMemoryVecBF lam_test;
+        FatropMemoryVecBF delta_s_test;
+        double inertia_correction_w_cache;
+        double inertia_correction_c_cache;
+        bool it_ref;
+        bool ls_scaling;
+        OCPLSScaler lsscaler_;
+    };
+} // namespace fatrop
+#endif //  OCPALGINCLUDED

casadi/include/fatrop/ocp/FatropOCPBuilder.hpp

@@ -0,0 +1,52 @@
+/*
+ * 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 FATROPOCPBUILDERINCLUDED
+#define FATROPOCPBUILDERINCLUDED
+#include "fatrop/ocp/OCP.hpp"
+#include "fatrop/ocp/FatropOCP.hpp"
+#include "fatrop/ocp/OCPAbstract.hpp"
+#include "fatrop/ocp/OCPAdapter.hpp"
+#include "fatrop/ocp/OCPLSRiccati.hpp"
+#include "fatrop/ocp/OCPNoScaling.hpp"
+namespace fatrop
+{
+    class FatropOCPBuilder
+    {
+    public:
+        FatropOCPBuilder(const std::shared_ptr<OCP> &ocp, const std::shared_ptr<FatropOptions> &fatropparams, const std::shared_ptr<FatropPrinter> &printer) : ocp_(ocp), fatropoptions_(fatropparams), fatropprinter_(printer)
+        {
+        }
+        std::shared_ptr<FatropOCP> build()
+        {
+            return build(ocp_);
+        }
+
+        std::shared_ptr<FatropOCP> build(const std::shared_ptr<OCP> &ocp)
+        {
+            return std::make_shared<FatropOCP>(ocp, std::make_shared<OCPLSRiccati>(ocp->get_ocp_dims(), fatropoptions_, fatropprinter_), std::make_shared<OCPNoScaling>(fatropoptions_), fatropoptions_, fatropprinter_);
+        }
+
+    private:
+        const std::shared_ptr<OCP> ocp_;
+        const std::shared_ptr<FatropOptions> fatropoptions_;
+        const std::shared_ptr<FatropPrinter> fatropprinter_;
+    };
+}
+
+#endif // !OCPALGBUILDERINCLUDED

casadi/include/fatrop/ocp/OCP.hpp

@@ -0,0 +1,82 @@
+/*
+ * 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 OCPINCLUDED
+#define OCPINCLUDED
+#include "fatrop/blasfeo_wrapper/LinearAlgebraBlasfeo.hpp"
+#include "OCPDims.hpp"
+#include "fatrop/ocp/OCPKKT.hpp"
+#include "fatrop/solver/FatropData.hpp"
+#include <memory>
+#include "fatrop/auxiliary/Common.hpp"
+namespace fatrop
+{
+    /** \brief interface class for OCP operations*/
+    class OCP
+    {
+    public:
+        virtual fatrop_int eval_lag_hess(
+            OCPKKTMemory *OCP,
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &lam) = 0;
+        virtual fatrop_int eval_constr_jac(
+            OCPKKTMemory *OCP,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars) = 0;
+        virtual fatrop_int eval_contr_viol(
+            OCPKKTMemory *OCP,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            FatropVecBF &constraint_violation) = 0;
+        virtual fatrop_int eval_ineqs(
+            OCPKKTMemory *OCP,
+            const FatropVecBF &primal_vars,
+            FatropVecBF &constraint_violation) = 0;
+        virtual fatrop_int eval_obj_grad(
+            OCPKKTMemory *OCP,
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            FatropVecBF &gradient_x 
+            ) = 0;
+        virtual fatrop_int eval_obj(
+            OCPKKTMemory *OCP,
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            double &res) = 0;
+        virtual fatrop_int integrate_dynamics(
+            OCPKKTMemory *OCP,
+            const fatrop_int k,
+            const FatropVecBF &uk,
+            const FatropVecBF &xk,
+            FatropVecBF &xkp1) = 0;
+        virtual OCPDims get_ocp_dims() const = 0;
+        virtual fatrop_int get_bounds(
+            FatropVecBF &lower,
+            FatropVecBF &upper) const = 0;
+        virtual fatrop_int get_initial_sol_guess(
+            FatropVecBF &initial) const = 0;
+        virtual void reset() = 0;
+        // virtual fatrop_int GetDefaultParams(
+        //     FatropOptions &params) const = 0;
+        virtual void set_parameters(const std::vector<double> &stage_params_in, const std::vector<double> &global_params_in) = 0;
+        virtual void set_initial_sol_guess(const std::shared_ptr<FatropData> &fatropdata, std::vector<double> &initial_u, std::vector<double> &initial_x) = 0;
+        virtual void get_solution(const std::shared_ptr<FatropData> &fatropdata, std::vector<double> &u, std::vector<double> &x) = 0;
+    };
+} // namespace fatrop
+#endif // OCPINCLUDED

casadi/include/fatrop/ocp/OCPAbstract.hpp

@@ -0,0 +1,254 @@
+/*
+ * 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 OCPTEMPLATEINCLUDED
+#define OCPTEMPLATEINCLUDED
+#include "fatrop/ocp/OCPKKT.hpp"
+#include "fatrop/blasfeo_wrapper/LinearAlgebraBlasfeo.hpp"
+#include "fatrop/auxiliary/FatropVector.hpp"
+#include "OCPDims.hpp"
+#include "fatrop/auxiliary/Common.hpp"
+namespace fatrop
+{
+    /// @brief  Abstract class for OCP template
+    /// @details  This class is used to define the interface for the OCP template.
+    /// an implemtation contains all information that is needed by the fatrop algorithm to solve the OCP.
+    /// the information includes the problem dimensions, the default parameters, default initial solution guess and evaluation code for stagewise function quantities.
+    class OCPAbstract
+    {
+    public:
+        /// @brief number of states for time step k
+        /// @param k: time step
+        virtual fatrop_int get_nx(const fatrop_int k) const = 0;
+        /// @brief number of inputs for time step k
+        /// @param k: time step
+        virtual fatrop_int get_nu(const fatrop_int k) const = 0;
+        /// @brief number of equality constraints for time step k
+        /// @param k: time step
+        virtual fatrop_int get_ng(const fatrop_int k) const = 0;
+        /// @brief  number of stage parameters for time step k
+        /// @param k: time step
+        virtual fatrop_int get_n_stage_params(const fatrop_int k) const = 0;
+        /// @brief  number of global parameters
+        virtual fatrop_int get_n_global_params() const = 0;
+        /// @brief default stage parameters for time step k
+        /// @param stage_params: pointer to array of size n_stage_params_k
+        /// @param k: time step
+        virtual fatrop_int get_default_stage_params(double *stage_params, const fatrop_int k) const = 0;
+        /// @brief default global parameters
+        /// @param global_params: pointer to array of size n_global_params
+        virtual fatrop_int get_default_global_params(double *global_params) const = 0;
+        /// @brief number of inequality constraints for time step k
+        /// @param k: time step
+        virtual fatrop_int get_ng_ineq(const fatrop_int k) const = 0;
+        /// @brief horizon length
+        virtual fatrop_int get_horizon_length() const = 0;
+        /// @brief  discretized dynamics
+        /// it evaluates the vertical concatenation of A_k^T, B_k^T, and b_k^T from the linearized dynamics x_{k+1} = A_k x_k + B_k u_k + b_k. 
+        /// The matrix is in column major format.
+        /// @param states_kp1: pointer to nx_{k+1}-array states of time step k+1
+        /// @param inputs_k: pointer to array inputs of time step k
+        /// @param states_k: pointer to array states of time step k
+        /// @param stage_params_k: pointer to array stage parameters of time step k
+        /// @param global_params: pointer to array global parameters
+        /// @param res: pointer to (nu+nx+1 x nu+nx)-matrix 
+        /// @param k: time step
+        virtual 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) = 0;
+        /// @brief  stagewise Lagrangian Hessian
+        /// It evaluates is the vertical concatenation of (1) the Hessian of the Lagrangian to the concatenation of (u_k, x_k) (2) the first order derivative of the Lagrangian Hessian to the concatenation of (u_k, x_k). 
+        /// The matrix is in column major format.
+        /// @param objective_scale: scale factor for objective function (usually 1.0)
+        /// @param inputs_k: pointer to array inputs of time step k
+        /// @param states_k: pointer to array states of time step k
+        /// @param lam_dyn_k: pointer to array dual variables for dynamics of time step k
+        /// @param lam_eq_k: pointer to array dual variables for equality constraints of time step k
+        /// @param lam_eq_ineq_k: pointer to array dual variables for inequality constraints of time step k
+        /// @param stage_params_k: pointer to array stage parameters of time step k
+        /// @param global_params: pointer to array global parameters
+        /// @param res: pointer to (nu+nx+1 x nu+nx)-matrix. 
+        /// @param k
+        /// @return
+        virtual 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) = 0;
+        /// @brief stagewise equality constraints Jacobian. 
+        /// It evaluates the vertical concatenation of (1) the Jacobian of the equality constraints to the concatenation of (u_k, x_k) (2) the equality constraints evaluated at u_k, x_k.
+        /// The matrix is in column major format.
+        /// @param inputs_k: pointer to array inputs of time step k
+        /// @param states_k: pointer to array states of time step k
+        /// @param stage_params_k: pointer to array stage parameters of time step k
+        /// @param global_params: pointer to array global parameters
+        /// @param res: pointer to (nu+nx+1 x ng)-matrix.
+        /// @param k: time step
+        /// @return
+        virtual 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) = 0;
+        /// @brief stagewise inequality constraints Jacobian. 
+        /// It evaluates the vertical concatenation of (1) the Jacobian of the inequality constraints to the concatenation of (u_k, x_k) (2) the inequality constraints evaluated at u_k, x_k. 
+        /// The matrix is in column major format.
+        /// @param inputs_k: pointer to array inputs of time step k
+        /// @param states_k: pointer to array states of time step k
+        /// @param stage_params_k: pointer to array stage parameters of time step k
+        /// @param global_params_ko: pointer to array global parameters
+        /// @param res: pointer to (nu+nx+1 x ng_ineq)-matrix, column major format
+        /// @param k : time step
+        /// @return
+        virtual 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) = 0;
+        /// @brief the dynamics constraint violation (b_k = -x_{k+1} + f_k(u_k, x_k, p_k, p))
+        /// @param states_kp1: pointer to array states of time step k+1
+        /// @param inputs_k: pointer to array inputs of time step k
+        /// @param states_k: pointer to array states of time step k
+        /// @param stage_params_k: pointer to array stage parameters of time step k
+        /// @param global_params: pointer to array global parameters
+        /// @param res: pointer to array nx_{k+1}-vector
+        /// @param k: time step
+        /// @return
+        virtual 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) = 0;
+        /// @brief the equality constraint violation (g_k = g_k(u_k, x_k, p_k, p))
+        /// @param inputs_k: pointer to array inputs of time step k
+        /// @param states_k: pointer to array states of time step k
+        /// @param stage_params_k: pointer to array stage parameters of time step k
+        /// @param global_params: pointer to array global parameters
+        /// @param res: pointer to array ng-vector
+        /// @param k: time step
+        virtual 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) = 0;
+        /// @brief the inequality constraint violation (g_ineq_k = g_ineq_k(u_k, x_k, p_k, p))
+        /// @param inputs_k: pointer to array inputs of time step k
+        /// @param states_k: pointer to array states of time step k
+        /// @param stage_params_k: pointer to array stage parameters of time step k
+        /// @param global_params: pointer to array global parameters
+        /// @param res: pointer to array ng_ineq-vector
+        /// @param k: time step
+        virtual 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) = 0;
+        /// @brief gradient of the objective function (not the Lagrangian!) to the concatenation of (u_k, x_k)
+        /// @param objective_scale: pointer to objective scale
+        /// @param inputs_k: pointer to array inputs of time step k
+        /// @param states_k: pointer to array states of time step k
+        /// @param stage_params_k: pointer to array stage parameters of time step k
+        /// @param global_params: pointer to array global parameters
+        /// @param res: pointer to (nu+nx)-array
+        /// @param k: time step
+        virtual 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) = 0;
+        /// @brief objective function value 
+        /// @param objective_scale: pointer to array objective scale
+        /// @param inputs_k: pointer to array inputs of time step k
+        /// @param states_k: pointer to array states of time step k
+        /// @param stage_params_k: pointer to array stage parameters of time step k
+        /// @param global_params: pointer to array global parameters
+        /// @param res: pointer to double
+        /// @param k: time step
+        virtual 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) = 0;
+        /// @brief the bounds of the inequalites at stage k
+        /// @param lower: pointer to ng_ineq-vector
+        /// @param upper: pointer to ng_ineq-vector
+        /// @param k: time step
+        virtual fatrop_int get_bounds(double *lower, double *upper, const fatrop_int k) const = 0;
+        /// @brief default initial guess for the states of stage k
+        /// @param xk: pointer to states of time step k 
+        /// @param k: time step
+        virtual fatrop_int get_initial_xk(double *xk, const fatrop_int k) const = 0;
+        /// @brief default initial guess for the inputs of stage k
+        /// @param uk: pointer to inputs of time step k
+        /// @param k: time step
+        virtual fatrop_int get_initial_uk(double *uk, const fatrop_int k) const = 0;
+
+        virtual fatrop_int full_eval_lag_hess(double objective_scale,
+                                        const double* primal_data,
+                                        const double* lam_data,
+                                        const double* stageparams_p,
+                                        const double* globalparams_p, MAT * RSQrqt_p) {
+            return 0;
+        }
+        virtual fatrop_int full_eval_constr_jac(const double* primal_data, const double* stageparams_p, const double* globalparams_p,
+            MAT* BAbt_p, MAT* Ggt_p, MAT* Ggt_ineq_p) {
+            return 0;
+        }
+        virtual fatrop_int full_eval_contr_viol(const double* primal_data, const double* stageparams_p, const double* globalparams_p,
+            double* cv_p) {
+            return 0;
+        }
+        virtual fatrop_int full_eval_obj_grad(double objective_scale, const double* primal_data, const double* stageparams_p, const double* globalparams_p,
+            double* grad_p) {
+            return 0;
+        }
+        virtual fatrop_int full_eval_obj(double objective_scale, const double* primal_data, const double* stageparams_p, const double* globalparams_p,
+            double* res) {
+            return 0;
+        }
+    };
+};     // namespace fatrop
+#endif // OCPTEMPLATEINCLUDED