casadi 3.6.4__cp36-none-win_amd64.whl → 3.6.6__cp36-none-win_amd64.whl

casadi/include/fatrop/solver/FatropData.hpp

@@ -0,0 +1,188 @@
+/*
+ * 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/>. */
+
+// solver data
+#ifndef FATROPDATAINCLUDED
+#define FATROPDATAINCLUDED
+#include "fatrop/blasfeo_wrapper/LinearAlgebraBlasfeo.hpp"
+#include "fatrop/templates/NLPAlg.hpp"
+#include "fatrop/auxiliary/Common.hpp"
+#include "FatropOptions.hpp"
+#include "fatrop/solver/FatropPrinter.hpp"
+#include <cmath>
+#include <memory>
+namespace fatrop
+{
+#define CACHEMACRO(instance, val) instance.evaluated ? instance.value : instance.SetValue(val)
+    struct FatropData
+    {
+        FatropData(const NLPDims &nlpdims, const std::shared_ptr<FatropOptions> &params, const std::shared_ptr<FatropPrinter> &printer);
+        void initialize();
+        fatrop_int reset();
+        fatrop_int reset_caches();
+        double e_mu_curr(double mu);
+        fatrop_int eval_dual_inf_slack_eqs();
+        double eval_compl_slack(double mu);
+        double eval_barrier_func(double mu, VEC *s_p);
+        double eval_barrier_func_curr(double mu);
+        double eval_barrier_func_trial(double mu);
+        double eval_barrier_func_backup(double mu);
+        double eval_barrier_fo_decr(double mu, VEC *s_p, VEC *delta_s_p);
+        double eval_barrier_fo_decr_curr(double mu);
+        double eval_barrier_fo_decr_backup(double mu);
+        fatrop_int bound_slacks();
+        fatrop_int bound_z();
+        fatrop_int warmstart_dual();
+        fatrop_int modify_dual_bounds(double mu);
+        fatrop_int accept_dual_initializiaton();
+        fatrop_int update_trial_step(double alpha_primal, double alpha_dual);
+        fatrop_int accept_trial_step();
+        fatrop_int backup_curr();
+        fatrop_int backup_delta();
+        fatrop_int restore_backup();
+        double constr_viol_max_curr();
+        double constr_viol_max_next();
+        double constr_viol_sum_curr();
+        double constr_viol_sum_backup();
+        double constr_viol_sum_next();
+        double dual_sum_curr();
+        double dual_max_curr();
+        double dual_mean_curr();
+        double z_sum_curr();
+        fatrop_int number_of_bounds();
+        double delta_dual_max();
+        double dual_inf_max_curr();
+        double fo_decr_obj_curr();
+        double fo_decr_obj_backup();
+        void maximum_step_size(double &alpha_max_pr, double &alpha_max_du, double tau);
+        void set_bounds(const std::vector<double> &lowerin, const std::vector<double> &upperin);
+        void relax_bounds();
+        void relax_bounds_var(double mu);
+        void evaluate_barrier_quantities(double mu);
+        void compute_delta_z();
+        void compute_primal_dual_residu();
+        void init_bounds();
+        bool small_step_size();
+
+
+        const NLPDims nlpdims;
+        double obj_scale = 1.0;
+        fatrop_int n_eqs;
+        fatrop_int n_ineqs;
+        fatrop_int n_ineqs_r = 0;
+        FatropMemoryVecBF memvars;
+        FatropMemoryVecBF memeqs;
+        FatropMemoryVecBF memineqs;
+        FatropVecBF x_curr;
+        FatropVecBF x_next;
+        FatropVecBF x_backup;
+        FatropVecBF x_initial;
+        FatropVecBF delta_x;
+        FatropVecBF delta_x_backup;
+        FatropVecBF delta_x_backup_ls;
+        FatropVecBF x_scales;
+        FatropVecBF lam_curr;
+        FatropVecBF lam_next;
+        FatropVecBF lam_backup;
+        FatropVecBF lam_calc;
+        FatropVecBF lam_calc_backup;
+        FatropVecBF lam_calc_backup_ls;
+        FatropVecBF lam_scales;
+        FatropVecBF lam_init;
+        FatropVecBF g_curr;
+        FatropVecBF g_next;
+        FatropVecBF g_backup;
+        FatropVecBF g_soc;
+        FatropVecBF grad_curr_x;
+        FatropVecBF grad_next_x;
+        FatropVecBF grad_backup_x;
+        FatropVecBF du_inf_curr;
+        FatropVecBF du_inf_curr_s;
+        // vectors neccessary for inequality constraints
+        FatropVecBF s_curr;
+        FatropVecBF s_next;
+        FatropVecBF s_backup;
+        FatropVecBF delta_s;
+        FatropVecBF delta_s_backup;
+        FatropVecBF delta_s_backup_ls;
+        FatropVecBF zL_curr;
+        FatropVecBF zL_next;
+        FatropVecBF zL_backup;
+        FatropVecBF zL_init;
+        FatropVecBF zU_curr;
+        FatropVecBF zU_next;
+        FatropVecBF zU_backup;
+        FatropVecBF zU_init;
+        FatropVecBF delta_zL;
+        FatropVecBF delta_zU;
+        FatropVecBF s_lower_orig;
+        FatropVecBF s_upper_orig;
+        FatropVecBF s_lower;
+        FatropVecBF s_upper;
+        FatropVecBF sigma_L;
+        FatropVecBF sigma_U;
+        FatropVecBF sigma_total;
+        FatropVecBF gradb_L;
+        FatropVecBF gradb_U;
+        FatropVecBF gradb_plus;
+        FatropVecBF gradb_total;
+        FatropVecBF grad_curr_s;
+        FatropVecBF grad_next_s;
+        FatropVecBF grad_backup_s;
+        FatropVecBF du_inf_curr_s_wo_z;
+        // vector<bool> lower_bounded_v;
+        // vector<bool> upper_bounded_v;
+        struct EvalCache
+        {
+            struct Instance
+            {
+                bool evaluated = false;
+                double value = 0.0;
+                double SetValue(const double value_)
+                {
+                    value = value_;
+                    evaluated = true;
+                    return value;
+                }
+            };
+            Instance cv_linf;
+            Instance cv_l1;
+            Instance lam_linf;
+            Instance lam_l1;
+            Instance du_inf_linf;
+        };
+        EvalCache cache_curr;
+        EvalCache cache_next;
+        double obj_curr = 0.0;
+        double obj_backup = 0.0;
+        double theta_min = 1e-4;
+        const std::shared_ptr<FatropOptions> params;
+        const std::shared_ptr<FatropPrinter> printer_;
+        // algorithm parameters
+        double smax;
+        double kappa1;
+        double kappa2;
+        double kappa_d;
+        double kappa_sigma;
+        double bound_relax_factor;
+        double constr_viol_tol;
+        double warm_start_mult_bound_push;
+    };
+}
+#endif // FATROPDATAINCLUDED

casadi/include/fatrop/solver/FatropOptions.hpp

@@ -0,0 +1,94 @@
+/*
+ * 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 FATROPPARAMSINCLUDED
+#define FATROPPARAMSINCLUDED
+#include <string>
+#include <map>
+#include <type_traits>
+#include <iostream>
+#include "fatrop/auxiliary/Common.hpp"
+namespace fatrop
+{
+    template <typename T>
+    struct Option
+    {
+    public:
+        Option(){};
+        Option(const std::string &name, const std::string &description, T *value, T default_value);
+        void set(const T &new_value) const;
+        void set_default() const;
+        std::string name_;
+        std::string description_;
+        T *value = NULL;
+        T default_value_;
+    };
+
+
+    template <typename T>
+    struct NumberOption: public Option<T>
+    {
+    public:
+        // DoubleOption operator=(const DoubleOption &other) = default;
+        NumberOption(){};
+        NumberOption(const std::string &name, const std::string &description, T *value, T default_value, bool lower_bound_inclusive, T lower_bound, bool upper_bound_inclusive, T upper_bound); 
+        static NumberOption<T> lower_bounded(const std::string &name, const std::string &description, T *value, T default_value, T lower_bound);
+        static NumberOption<T> upper_bounded(const std::string &name, const std::string &description, T *value, T default_value, T upper_bound);
+        static NumberOption<T> un_bounded(const std::string &name, const std::string &description, T *value, T default_value);
+        static NumberOption<T> box_bounded(const std::string &name, const std::string &description, T *value, T default_value, T lower_bound, T upper_bound);
+        void set(const T &new_value) const;
+        bool lower_bound_inclusive_;
+        T lower_bound_;
+        bool upper_bound_inclusive_;
+        T upper_bound_;
+    };
+   // define Numeric option as Option<double>
+    typedef NumberOption<double> DoubleOption;
+    typedef NumberOption<fatrop_int> IntegerOption;
+    typedef Option<std::string> StringOption;
+    typedef Option<bool> BooleanOption;
+
+    class FatropOptions
+    {
+    public:
+        FatropOptions();
+        // the following options are shared between different algorithm components:
+        int maxiter = 1000; // TODO this value cannot be changed to a value larger than the one used for building the solver
+        double kappa_d = 1e-5;
+        template <typename T>
+        void set(const std::string &option_name, T value) const;
+        template <typename T>
+        void prebuilt_set(const std::string &option_name, T value);
+
+    public:
+        bool has_option(const std::string &option_name) const;
+        void register_option(const DoubleOption &option);
+        void register_option(const IntegerOption &option);
+        void register_option(const BooleanOption &option);
+        void register_option(const StringOption &option);
+        friend auto operator<<(std::ostream &os, const FatropOptions &m) -> std::ostream &;
+        std::map<std::string, DoubleOption> numeric_options;
+        std::map<std::string, IntegerOption> integer_options;
+        std::map<std::string, BooleanOption> boolean_options;
+        std::map<std::string, StringOption> string_options;
+        std::map<std::string, std::string> prebuilt_string;
+        std::map<std::string, double> prebuilt_double;
+    };
+
+} // namespace fatrop
+#endif // FatropOptions

casadi/include/fatrop/solver/FatropPrinter.hpp

@@ -0,0 +1,65 @@
+/*
+ * 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/>. */
+#define PRIORITY1 PrintPriority<1>()
+#ifndef FATROPPRINTERINCLUDED
+#define FATROPPRINTERINCLUDED
+#include <iostream>
+#include <string>
+#include <vector>
+namespace fatrop
+{
+    static std::ostream nullstream(nullptr);
+    template <int Priority>
+    struct PrintPriority
+    {
+        PrintPriority(){};
+        const int priority = Priority;
+    };
+    template <int priority>
+    std::ostream &operator<<(std::ostream &os, const PrintPriority<priority> &p)
+    {
+        if (p.priority >= -1)
+            return os;
+        return nullstream;
+    }
+    class FatropPrinter
+    {
+    public:
+        FatropPrinter(const int priority = 0, std::ostream &stream = std::cout) : priority_(priority), stream_(stream),
+            printf_buffer_(256) {};
+        std::ostream &
+        level(const int p)
+        {
+            if (p <= priority_)
+                return stream_;
+            return nullstream;
+        }
+        int &print_level() { return priority_; }
+
+
+        int printf(const char *fmt, ...);
+
+    private:
+        int priority_;
+        std::ostream& stream_;
+        std::vector<char> printf_buffer_;
+    };
+
+} // namespace fatrop
+#endif //  FATROPITERATIONDATAINCLUDED

casadi/include/fatrop/solver/FatropStats.hpp

@@ -0,0 +1,63 @@
+/*
+ * 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 FATROPSTATSINCLUDED
+#define FATROPSTATSINCLUDED
+#include <iostream>
+namespace fatrop
+{
+    struct FatropStats
+    {
+        double compute_sd_time = 0.0;
+        double duinf_time = 0.0;
+        double eval_hess_time = 0.0;
+        double eval_jac_time = 0.0;
+        double eval_cv_time = 0.0;
+        double eval_grad_time = 0.0;
+        double eval_obj_time = 0.0;
+        double initialization_time = 0.0;
+        double time_total = 0.0;
+        int eval_hess_count = 0;
+        int eval_jac_count = 0;
+        int eval_cv_count = 0;
+        int eval_grad_count = 0;
+        int eval_obj_count = 0;
+        int iterations_count = 0;
+        int return_flag = 0;
+        void print(std::ostream& stream)
+        {
+            stream << "---- stats ----" << std::endl;
+            stream << "compute_sd:     " << compute_sd_time << " s"<< std::endl;
+            stream << "duinf:          " << duinf_time << " s"<< std::endl;
+            stream << "initialization: " << initialization_time << " s  count: "<< iterations_count <<std::endl;
+            double time_FE = eval_hess_time + eval_jac_time + eval_cv_time + eval_grad_time + eval_obj_time ;
+            stream << "time_FE :       " << time_FE << " s"<< std::endl;
+            stream << "    eval hess:  " << eval_hess_time << " s  count: "<< eval_hess_count <<std::endl;
+            stream << "    eval jac:   " << eval_jac_time << " s  count: "<< eval_jac_count <<std::endl;
+            stream << "    eval cv:    " << eval_cv_time << " s  count: "<< eval_cv_count <<std::endl;
+            stream << "    eval grad:  " << eval_grad_time << " s  count: "<< eval_grad_count <<std::endl;
+            stream << "    eval obj:   " << eval_obj_time << " s  count: "<< eval_obj_count <<std::endl;
+            stream << "rest  :       " <<time_total -  time_FE - initialization_time - duinf_time - compute_sd_time<< " s"<< std::endl;
+            stream << "----- "<< std::endl;
+            stream << "time_w/o_FE : " << time_total - time_FE << " s" << std::endl;
+            stream << "time_FE :       " << time_FE << " s"<< std::endl;
+            stream << "time_total : " << time_total << " s  iterations: " << iterations_count << std::endl;
+        }
+    };
+} // namespace fatrop
+#endif // FATROPSTATSINCLUDED

casadi/include/fatrop/solver/Filter.hpp

@@ -0,0 +1,54 @@
+/*
+ * 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 FILTERINCLUDED
+#define FILTERINCLUDED
+#include "vector"
+#include "fatrop/auxiliary/Common.hpp"
+namespace fatrop
+{
+    struct FilterData
+    {
+        FilterData(){};
+        FilterData(const fatrop_int iteration, const double phi, const double theta):iteration(iteration),phi(phi),theta(theta){};
+        const fatrop_int iteration = 0;
+        /** \brief barrier function value */
+        const double phi = 0.0;
+        /** \brief constraint violation value */
+        const double theta = 0.0;
+    };
+    class Filter
+    {
+    public:
+        Filter(const fatrop_int size);
+        void augment(const FilterData &filterdata);
+        /** \brief check if fdin0 is dominated by fdin1 */
+        inline bool a_dominmates_b(const FilterData &fdin0, const FilterData &fdin1) const;
+        bool is_acceptable(const FilterData &fdin) const;
+        void reset();
+        fatrop_int size() const
+        {
+            return filterdata_.size();
+        }
+
+    private:
+        std::vector<FilterData> filterdata_;
+    };
+} // namespace fatrop
+
+#endif // FILTERINCLUDED

casadi/include/fatrop/solver/IterationData.hpp

@@ -0,0 +1,55 @@
+/*
+ * 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 FATROPITERATIONDATAINCLUDED
+#define FATROPITERATIONDATAINCLUDED
+#include <cmath>
+#include <vector>
+#include <iostream>
+#include <fatrop/solver/FatropPrinter.hpp>
+#include "fatrop/auxiliary/Common.hpp"
+#include <memory>
+namespace fatrop
+{
+    struct IterationData
+    {
+        fatrop_int iter = 0;
+        double mu = 0.0;
+        double objective = 0.0;
+        double constraint_violation = 0.0;
+        double du_inf = 0.0;
+        fatrop_int ls = 0;
+        double reg = 0.0;
+        double alpha_pr = 0.0;
+        double alpha_du = 0.0;
+        char type = 'x';
+    };
+    class Journaller
+    {
+    public:
+        Journaller(const fatrop_int maxiter, const std::shared_ptr<FatropPrinter> &printer);
+        void print_iterations();
+        void push();
+        void reset();
+        fatrop_int print_count = 0;
+        std::vector<IterationData> iterationdata;
+        IterationData it_curr;
+        std::shared_ptr<FatropPrinter> printer_;
+    };
+} // namespace fatrop
+#endif //  FATROPITERATIONDATAINCLUDED

casadi/include/fatrop/solver/LineSearch.hpp

@@ -0,0 +1,86 @@
+/*
+ * 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 LINESEARCHINCLUDED
+#define LINESEARCHINCLUDED
+#include "AlgStrategy.hpp"
+#include "IterationData.hpp"
+#include "fatrop/templates/NLPAlg.hpp"
+#include "fatrop/solver/FatropData.hpp"
+#include "fatrop/solver/Filter.hpp"
+#include "fatrop/solver/FatropPrinter.hpp"
+#include "fatrop/auxiliary/Common.hpp"
+#include <cmath>
+#include <memory>
+namespace fatrop
+{
+    struct LineSearchInfo
+    {
+        fatrop_int ls = 0;
+        bool first_rejected_by_filter = false;
+        bool last_rejected_by_filter = false;
+    };
+    class LineSearch : public AlgStrategy
+    {
+    public:
+        LineSearch(
+            const std::shared_ptr<FatropOptions> &fatropparams,
+            const std::shared_ptr<FatropNLP> &nlp,
+            const std::shared_ptr<FatropData> &fatropdata, const std::shared_ptr<FatropPrinter> &printer);
+        virtual LineSearchInfo find_acceptable_trial_point(double mu, bool small_sd, bool from_backup) = 0;
+        inline fatrop_int eval_constr_viol_trial();
+        double eval_obj_trial();
+        void reset();
+        virtual fatrop_int update_trial_step(double alpha_pr, double alpha_du) const;
+        virtual fatrop_int initialize_second_order_correction() const;
+        virtual fatrop_int exit_second_order_correction() const;
+        virtual fatrop_int compute_second_order_correction(double alpha) const;
+        std::shared_ptr<FatropNLP> fatropnlp_;
+        std::shared_ptr<FatropData> fatropdata_;
+        std::shared_ptr<FatropPrinter> printer_;
+        fatrop_int eval_cv_count;
+        fatrop_int eval_obj_count;
+        double eval_cv_time;
+        double eval_obj_time;
+    };
+
+    class BackTrackingLineSearch : public LineSearch
+    {
+    public:
+        BackTrackingLineSearch(
+            const std::shared_ptr<FatropOptions> &fatropparams,
+            const std::shared_ptr<FatropNLP> &nlp,
+            const std::shared_ptr<FatropData> &fatropdata,
+            const std::shared_ptr<Filter> &filter,
+            const std::shared_ptr<Journaller> &journaller, const std::shared_ptr<FatropPrinter> &printer);
+        void initialize();
+        LineSearchInfo find_acceptable_trial_point(double mu, bool small_sd, bool from_backup);
+        std::shared_ptr<Filter> filter_;
+        std::shared_ptr<Journaller> journaller_;
+        double s_phi;
+        double delta;
+        double s_theta;
+        double gamma_theta;
+        double gamma_phi;
+        double eta_phi;
+        double gamma_alpha;
+        bool accept_every_trial_step = false;
+        fatrop_int max_soc;
+    };
+} // namespace fatrop
+#endif // LINESEARCHINCLUDED