casadi 3.6.5__cp312-none-macosx_11_0_arm64.whl → 3.6.7__cp312-none-macosx_11_0_arm64.whl

casadi/include/fatrop/solver/NLPL1.hpp

@@ -0,0 +1,263 @@
+#pragma once
+#include "fatrop/templates/NLPAlg.hpp"
+#include "fatrop/solver/FatropOptions.hpp"
+#include <memory>
+namespace fatrop
+{
+    class NLPL1 : public FatropNLP
+    {
+    public:
+        NLPL1(const std::shared_ptr<FatropNLP> &orig, const std::shared_ptr<FatropOptions>& opts) : orig_(orig), orig_dims_(orig->get_nlp_dims()), lower_(orig_dims_.nineqs), upper_(orig_dims_.nineqs), upper_bounded_(orig_dims_.nineqs), lower_bounded_(orig_dims_.nineqs), slack_dummy_(orig_dims_.nineqs), sigma_dummy_(orig_dims_.nineqs), gradb_dummy_(orig_dims_.nineqs), zl_dummy_(orig_dims_.nineqs), zu_dummy_(orig_dims_.nineqs), sigma_cache_(orig_dims_.nineqs * 3), gradb_cache_(orig_dims_.nineqs * 3)
+        {
+            opts -> register_option(DoubleOption::lower_bounded("L1_rho", "L1 penalty parameter", &rho, 1e4, 0.0));
+            auto lower_v = lower_[0];
+            auto upper_v = upper_[0];
+            orig_->get_bounds(lower_v, upper_v);
+            n_p = orig_dims_.nineqs;
+            n_n = orig_dims_.nineqs;
+            for (fatrop_int i = 0; i < orig_dims_.nineqs; ++i)
+            {
+                bool lower_bounded = !std::isinf(lower_v.at(i));
+                bool upper_bounded = !std::isinf(upper_v.at(i));
+                upper_bounded_[i] = upper_bounded;
+                lower_bounded_[i] = lower_bounded;
+            }
+            this_dims_.nvars = orig_dims_.nvars;
+            this_dims_.nineqs = orig_dims_.nineqs + n_n + n_p;
+            this_dims_.neqs = orig_dims_.neqs;
+        }
+        virtual fatrop_int eval_lag_hess(
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            const FatropVecBF &lam) override
+        {
+            FatropVecBF slack_dummy_v = slack_dummy_[0];
+            update_slack_vars(slack_vars, slack_dummy_v);
+            orig_->eval_lag_hess(obj_scale, primal_vars, slack_dummy_v, lam);
+            return 0;
+        };
+
+        virtual fatrop_int eval_constr_jac(
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars) override
+        {
+            FatropVecBF slack_dummy_v = slack_dummy_[0];
+            update_slack_vars(slack_vars, slack_dummy_v);
+            orig_->eval_constr_jac(primal_vars, slack_dummy_v);
+            return 0;
+        };
+        void update_slack_vars(const FatropVecBF &slack_vars, FatropVecBF &slack_dummy)
+        {
+            fatrop_int offs_n = orig_dims_.nineqs;
+            fatrop_int offs_p = orig_dims_.nineqs + n_n;
+            for (fatrop_int i = 0; i < orig_dims_.nineqs; ++i)
+            {
+                slack_dummy.at(i) = slack_vars.at(i) - slack_vars.at(i + offs_n) + slack_vars.at(i + offs_p);
+            }
+        }
+        virtual fatrop_int eval_constraint_viol(
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            FatropVecBF &constraint_violation) override
+        {
+            FatropVecBF slack_dummy_v = slack_dummy_[0];
+            update_slack_vars(slack_vars, slack_dummy_v);
+            orig_->eval_constraint_viol(primal_vars, slack_dummy_v, constraint_violation);
+            return 0;
+        };
+        virtual fatrop_int eval_obj_grad(
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            FatropVecBF &gradient_x,
+            FatropVecBF &gradient_s) override
+        {
+            orig_->eval_obj_grad(obj_scale, primal_vars, slack_vars, gradient_x, gradient_s);
+            gradient_s.block(orig_dims_.nineqs, n_n + n_p) = rho;
+            return 0;
+        };
+        virtual fatrop_int eval_obj(
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            double &res) override
+        {
+            orig_->eval_obj(obj_scale, primal_vars, slack_vars, res);
+            res += rho * sum(slack_vars.block(orig_dims_.nineqs, n_n + n_p));
+            return 0;
+        };
+        void get_initialization(const FatropVecBF &primal_vars_orig, FatropVecBF &intialization)
+        {
+            intialization.block(0, orig_dims_.nvars).copy(primal_vars_orig.block(0, orig_dims_.nvars));
+        }
+        virtual 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_wo_z) override
+        {
+            auto du_inf_s_wo_z_or = du_inf_s_wo_z.block(0, orig_dims_.nineqs);
+            orig_->eval_dual_inf(obj_scale, lam, grad_x, grad_s, du_inf_x, du_inf_s_wo_z_or);
+            auto lam_I = lam.block(orig_dims_.neqs - orig_dims_.nineqs, orig_dims_.nineqs);
+            axpby(1.0, lam_I, 1.0, grad_s.block(orig_dims_.nineqs, n_n), du_inf_s_wo_z.block(orig_dims_.nineqs, n_n));
+            axpby(-1.0, lam_I, 1.0, grad_s.block(orig_dims_.nineqs + n_n, n_p), du_inf_s_wo_z.block(orig_dims_.nineqs + n_n, n_p));
+            return 0;
+        }
+        void update_sigma_gradb(double inertia, const FatropVecBF &sigma_s, const FatropVecBF &sigma_n, const FatropVecBF &sigma_p, const FatropVecBF &gradb_s, const FatropVecBF &gradb_n, const FatropVecBF &gradb_p, const FatropVecBF &sigma_update, const FatropVecBF &gradb_update)
+        {
+            for (int i = 0; i < orig_dims_.nineqs; ++i)
+            {
+                double sigma_updt = 1.0 / (1.0 / (sigma_s.at(i) + inertia) + 1.0 / (sigma_n.at(i) + inertia) + 1.0 / (sigma_p.at(i) + inertia));
+                sigma_update.at(i) = sigma_updt - inertia;
+                gradb_update.at(i) = ((gradb_s.at(i)) / (sigma_s.at(i) + inertia) - (gradb_n.at(i)) / (sigma_n.at(i) + inertia) + (gradb_p.at(i)) / (sigma_p.at(i) + inertia)) * sigma_updt;
+            }
+        }
+        void update_delta_snp(double inertia, const FatropVecBF &sigma_s, const FatropVecBF &sigma_n, const FatropVecBF &sigma_p, const FatropVecBF &gradb_s, const FatropVecBF &gradb_n, const FatropVecBF &gradb_p, const FatropVecBF &lam_I, const FatropVecBF &delta_s, const FatropVecBF &delta_n, const FatropVecBF &delta_p)
+        {
+            for (int i = 0; i < orig_dims_.nineqs; ++i)
+            {
+                double lam_I_i = lam_I.at(i);
+                delta_s.at(i) = (-gradb_s.at(i) + lam_I_i) / (sigma_s.at(i) + inertia);
+                delta_n.at(i) = (-gradb_n.at(i) - lam_I_i) / (sigma_n.at(i) + inertia);
+                delta_p.at(i) = (-gradb_p.at(i) + lam_I_i) / (sigma_p.at(i) + inertia);
+            }
+        }
+
+        virtual 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
+        {
+            inertia_correction_w_cache = inertia_correction_w;
+            sigma_cache_[0].copy(sigma_total);
+            gradb_cache_[0].copy(gradb_total);
+            auto lam_I = lam.block(orig_dims_.neqs - orig_dims_.nineqs, orig_dims_.nineqs);
+            auto sigma_s = sigma_total.block(0, orig_dims_.nineqs);
+            auto sigma_n = sigma_total.block(orig_dims_.nineqs, n_n);
+            auto sigma_p = sigma_total.block(orig_dims_.nineqs + n_n, n_p);
+            auto gradb_s = gradb_total.block(0, orig_dims_.nineqs);
+            auto gradb_n = gradb_total.block(orig_dims_.nineqs, n_n);
+            auto gradb_p = gradb_total.block(orig_dims_.nineqs + n_n, n_p);
+            auto delta_s_or = delta_s.block(0, orig_dims_.nineqs);
+            auto delta_n = delta_s.block(orig_dims_.nineqs, n_n);
+            auto delta_p = delta_s.block(orig_dims_.nineqs + n_n, n_p);
+            update_sigma_gradb(inertia_correction_w, sigma_s, sigma_n, sigma_p, gradb_s, gradb_n, gradb_p, sigma_dummy_[0], gradb_dummy_[0]);
+            int ret = orig_->solve_pd_sys(inertia_correction_w, inertia_correction_c, ux, lam, delta_s.block(0, orig_dims_.nineqs), sigma_dummy_[0], gradb_dummy_[0]);
+            update_delta_snp(inertia_correction_w, sigma_s, sigma_n, sigma_p, gradb_s, gradb_n, gradb_p, lam_I, delta_s_or, delta_n, delta_p);
+            return ret;
+        };
+        virtual fatrop_int solve_soc_rhs(
+            const FatropVecBF &ux,
+            const FatropVecBF &lam,
+            const FatropVecBF &delta_s,
+            const FatropVecBF &cosntraint_violation) override
+        {
+            auto lam_I = lam.block(orig_dims_.neqs - orig_dims_.nineqs, orig_dims_.nineqs);
+            auto sigma_s = sigma_cache_[0].block(0, orig_dims_.nineqs);
+            auto sigma_n = sigma_cache_[0].block(orig_dims_.nineqs, n_n);
+            auto sigma_p = sigma_cache_[0].block(orig_dims_.nineqs + n_n, n_p);
+            auto gradb_s = gradb_cache_[0].block(0, orig_dims_.nineqs);
+            auto gradb_n = gradb_cache_[0].block(orig_dims_.nineqs, n_n);
+            auto gradb_p = gradb_cache_[0].block(orig_dims_.nineqs + n_n, n_p);
+            auto delta_s_or = delta_s.block(0, orig_dims_.nineqs);
+            auto delta_n = delta_s.block(orig_dims_.nineqs, n_n);
+            auto delta_p = delta_s.block(orig_dims_.nineqs + n_n, n_p);
+            int ret = orig_->solve_soc_rhs(ux, lam, delta_s.block(0, orig_dims_.nineqs), cosntraint_violation);
+            update_delta_snp(inertia_correction_w_cache, sigma_s, sigma_n, sigma_p, gradb_s, gradb_n, gradb_p, lam_I, delta_s_or, delta_n, delta_p);
+            return ret;
+        }
+        virtual NLPDims get_nlp_dims() const override { return this_dims_; };
+        virtual fatrop_int compute_scalings(
+            double &obj_scale,
+            FatropVecBF &x_scales,
+            FatropVecBF &lam_scales,
+            const FatropVecBF &grad_curr_x, const FatropVecBF &grad_curr_s) override
+        {
+            return orig_->compute_scalings(obj_scale, x_scales, lam_scales, grad_curr_x, grad_curr_s);
+        };
+        virtual fatrop_int initialize_slacks(double mu0,
+                                             FatropVecBF &s_curr) override
+        {
+            auto s_curr_or = s_curr.block(0, orig_dims_.nineqs);
+            auto n_curr = s_curr.block(orig_dims_.nineqs, n_n);
+            auto p_curr = s_curr.block(orig_dims_.nineqs + n_n, n_p);
+            int ret = orig_->initialize_slacks(mu0, s_curr_or);
+            auto upper_v = upper_[0];
+            auto lower_v = lower_[0];
+            // set zero for now TODO use quadratic formula here
+            for (int i = 0; i < orig_dims_.nineqs; i++)
+            {
+                double dist_L = lower_bounded_[i] ? s_curr_or.at(i) - lower_v.at(i) : 0.0;
+                double dist_U = upper_bounded_[i] ? upper_v.at(i) - s_curr_or.at(i) : 0.0;
+                double viol = 0.0;
+                double s_proj = s_curr_or.at(i);
+                if (lower_bounded_[i] && dist_L < 0.0)
+                {
+                    // std::cout << "lower" << std::endl;
+                    s_proj = s_curr_or.at(i) - dist_L;
+                }
+                if (upper_bounded_[i] && dist_U < 0.0)
+                {
+                    // std::cout << "upper" << std::endl;
+                    s_proj = s_curr_or.at(i) + dist_U;
+                }
+                viol = (s_curr_or.at(i) - s_proj);
+                double n_init = (mu0 - rho * viol) / (2 * rho) + std::sqrt(std::pow((mu0 - rho * viol) / (2 * rho), 2) + mu0 * viol / (2 * rho));
+                // if viol >>>> 0 -> n_init = 0 if viol <<< 0 n_init = viol
+                n_curr.at(i) = n_init;
+                p_curr.at(i) = viol + n_init;
+            }
+            return ret;
+        }
+        virtual fatrop_int initialize_dual(
+            const FatropVecBF &grad_x,
+            const FatropVecBF &grad_s,
+            FatropVecBF &dlam,
+            const FatropVecBF &zL,
+            const FatropVecBF &zU) override
+        {
+            // todo check if this is correct
+            return orig_->initialize_dual(grad_x, grad_s, dlam, zL.block(0, orig_dims_.nineqs), zU.block(0, orig_dims_.nineqs));
+        };
+        virtual fatrop_int get_bounds(
+            FatropVecBF &lower,
+            FatropVecBF &upper) const override
+        {
+            orig_->get_bounds(lower, upper);
+            lower.block(orig_dims_.nineqs, n_n) = 0.0;
+            lower.block(orig_dims_.nineqs + n_n, n_p) = 0.0;
+            upper.block(orig_dims_.nineqs, n_n) = std::numeric_limits<double>::infinity();
+            upper.block(orig_dims_.nineqs + n_n, n_p) = std::numeric_limits<double>::infinity();
+            return 0;
+        };
+        virtual fatrop_int get_initial_sol_guess(
+            FatropVecBF &initial) const override
+        {
+            orig_->get_initial_sol_guess(initial);
+            return 0;
+        }
+        std::shared_ptr<FatropNLP> orig_;
+        NLPDims orig_dims_;
+        NLPDims this_dims_;
+        FatropMemoryVecBF lower_, upper_;
+        std::vector<bool> upper_bounded_;
+        std::vector<bool> lower_bounded_;
+        fatrop_int n_p = 0;
+        fatrop_int n_n = 0;
+        FatropMemoryVecBF slack_dummy_;
+        FatropMemoryVecBF sigma_dummy_;
+        FatropMemoryVecBF gradb_dummy_;
+        FatropMemoryVecBF zl_dummy_;
+        FatropMemoryVecBF zu_dummy_;
+        double inertia_correction_w_cache = 0.0;
+        FatropMemoryVecBF sigma_cache_;
+        FatropMemoryVecBF gradb_cache_;
+        double rho = 1e4;
+    };
+};

casadi/include/fatrop/templates/NLPAlg.hpp

@@ -0,0 +1,104 @@
+/*
+ * 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 NLPINCLUDED
+#define NLPINCLUDED
+#include "fatrop/blasfeo_wrapper/LinearAlgebraBlasfeo.hpp"
+#include "fatrop/auxiliary/Common.hpp"
+namespace fatrop
+{
+    struct NLPDims
+    {
+        fatrop_int nvars;
+        fatrop_int neqs;
+        fatrop_int nineqs;
+    };
+    class FatropNLP
+    {
+    public:
+        virtual fatrop_int eval_lag_hess(
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            const FatropVecBF &lam) = 0;
+        virtual fatrop_int eval_constr_jac(
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars) = 0;
+        virtual fatrop_int eval_constraint_viol(
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            FatropVecBF &constraint_violation) = 0;
+        virtual fatrop_int eval_obj_grad(
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            FatropVecBF &gradient_x,
+            FatropVecBF &gradient_s) = 0;
+        virtual fatrop_int eval_obj(
+            double obj_scale,
+            const FatropVecBF &primal_vars,
+            const FatropVecBF &slack_vars,
+            double &res) = 0;
+        virtual 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) = 0;
+        virtual 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) = 0;
+        virtual fatrop_int solve_soc_rhs(
+            const FatropVecBF &ux,
+            const FatropVecBF &lam,
+            const FatropVecBF &delta_s,
+            const FatropVecBF &cosntraint_violation) = 0;
+        virtual NLPDims get_nlp_dims() const = 0;
+        virtual fatrop_int compute_scalings(
+            double &obj_scale,
+            FatropVecBF &x_scales,
+            FatropVecBF &lam_scales,
+            const FatropVecBF &grad_curr_x, const FatropVecBF& grad_curr_s) = 0;
+        virtual fatrop_int initialize_slacks(double mu0,
+            FatropVecBF &s_curr) = 0;
+        virtual fatrop_int initialize_dual(
+            const FatropVecBF &grad_x,
+            const FatropVecBF &grad_s,
+            FatropVecBF &dlam,
+            const FatropVecBF &zL,
+            const FatropVecBF &zU) = 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 pre_solve(const FatropVecBF& x_init,const FatropVecBF& s_init){};
+        // virtual fatrop_int GetDefaultParams(
+        //     FatropOptions &params) const = 0;
+        virtual fatrop_int Callback(FatropVecBF& primal_vars){return 0;};
+        virtual void finalize(){};
+        virtual void reset(){};
+        virtual void update_mu(double mu){};
+    };
+} // namespace fatrop
+#endif // NLPINCLUDED

casadi/include/highs/HConfig.h

@@ -1,20 +1,21 @@
 #ifndef HCONFIG_H_
 #define HCONFIG_H_
 
-/* #undef FAST_BUILD */
+#define FAST_BUILD
 #define ZLIB_FOUND
+/* #undef CUPDLP_CPU */
 #define CMAKE_BUILD_TYPE "Release"
-#define CMAKE_INSTALL_PREFIX "/Users/ghrunner/actions-runner/_work/casadi/casadi/build/external_projects"
+#define CMAKE_INSTALL_PREFIX "/Users/runner/work/casadi/casadi/build/external_projects"
 /* #undef HIGHSINT64 */
+/* #undef HIGHS_NO_DEFAULT_THREADS */
 /* #undef HIGHS_HAVE_MM_PAUSE */
 #define HIGHS_HAVE_BUILTIN_CLZ
 /* #undef HIGHS_HAVE_BITSCAN_REVERSE */
 
-#define HIGHS_GITHASH "21da9b90e"
-#define HIGHS_COMPILATION_DATE "2024-02-29"
+#define HIGHS_GITHASH "5ce7a275"
 #define HIGHS_VERSION_MAJOR 1
-#define HIGHS_VERSION_MINOR 6
-#define HIGHS_VERSION_PATCH 0
-#define HIGHS_DIR "/Users/ghrunner/actions-runner/_work/casadi/casadi/build/external_projects/src/highs-external"
+#define HIGHS_VERSION_MINOR 7
+#define HIGHS_VERSION_PATCH 2
+#define HIGHS_DIR "/Users/runner/work/casadi/casadi/build/external_projects/src/highs-external"
 
 #endif /* HCONFIG_H_ */

casadi/include/highs/Highs.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -37,7 +37,6 @@ HighsInt highsVersionMajor();
 HighsInt highsVersionMinor();
 HighsInt highsVersionPatch();
 const char* highsGithash();
-const char* highsCompilationDate();
 
 /**
  * @brief Class to set parameters and run HiGHS
@@ -78,11 +77,6 @@ class Highs {
    */
   std::string githash() const { return highsGithash(); }
 
-  /**
-   * @brief Return compilation date
-   */
-  std::string compilationDate() const { return highsCompilationDate(); }
-
   /**
    * @brief Reset the options and then call clearModel()
    */
@@ -384,6 +378,13 @@ class Highs {
    */
   double getInfinity() { return kHighsInf; }
 
+  /**
+   * @brief Get the size of HighsInt
+   */
+  HighsInt getSizeofHighsInt() {
+    return sizeof(options_.num_user_settable_options_);
+  }
+
   /**
    * @brief Get the run time of HiGHS
    */
@@ -409,6 +410,22 @@ class Highs {
    */
   const HighsPresolveLog& getPresolveLog() const { return presolve_log_; }
 
+  /**
+   * @brief Return a const pointer to the original column indices for
+   * the presolved model
+   */
+  const HighsInt* getPresolveOrigColsIndex() const {
+    return presolve_.data_.postSolveStack.getOrigColsIndex();
+  }
+
+  /**
+   * @brief Return a const pointer to the original row indices for the
+   * presolved model
+   */
+  const HighsInt* getPresolveOrigRowsIndex() const {
+    return presolve_.data_.postSolveStack.getOrigRowsIndex();
+  }
+
   /**
    * @brief Return a const reference to the incumbent LP
    */
@@ -482,6 +499,14 @@ class Highs {
    */
   HighsStatus getRanging(HighsRanging& ranging);
 
+  /**
+   * @brief Get the ill-conditioning information for the current basis
+   */
+  HighsStatus getIllConditioning(HighsIllConditioning& ill_conditioning,
+                                 const bool constraint,
+                                 const HighsInt method = 0,
+                                 const double ill_conditioning_bound = 1e-4);
+
   /**
    * @brief Get the current model objective value
    */
@@ -617,7 +642,7 @@ class Highs {
    * @brief Get multiple columns from the model given by a set
    */
   HighsStatus getCols(
-      const HighsInt num_set_entries,  //!< The number of indides in the set
+      const HighsInt num_set_entries,  //!< The number of indices in the set
       const HighsInt* set,  //!< Array of size num_set_entries with indices of
                             //!< columns to get
       HighsInt& num_col,    //!< Number of columns got from the model
@@ -689,7 +714,7 @@ class Highs {
    * @brief Get multiple rows from the model given by a set
    */
   HighsStatus getRows(
-      const HighsInt num_set_entries,  //!< The number of indides in the set
+      const HighsInt num_set_entries,  //!< The number of indices in the set
       const HighsInt*
           set,  //!< Array of size num_set_entries with indices of rows to get
       HighsInt& num_row,  //!< Number of rows got from the model
@@ -739,6 +764,17 @@ class Highs {
    */
   HighsStatus writeModel(const std::string& filename = "");
 
+  /**
+   * @brief Write out the incumbent presolved model to a file
+   */
+  HighsStatus writePresolvedModel(const std::string& filename = "");
+
+  /**
+   * @brief Write out the given model to a file
+   */
+  HighsStatus writeLocalModel(HighsModel& model,
+                              const std::string& filename = "");
+
   /**
    * @brief Write out the internal HighsBasis instance to a file
    */
@@ -786,6 +822,14 @@ class Highs {
   HighsStatus changeColsIntegrality(const HighsInt* mask,
                                     const HighsVarType* integrality);
 
+  /**
+   * @brief Clear the integrality of all columns
+   */
+  HighsStatus clearIntegrality() {
+    this->model_.lp_.integrality_.clear();
+    return HighsStatus::kOk;
+  }
+
   /**
    * @brief Change the cost of a column
    */
@@ -900,7 +944,7 @@ class Highs {
    * @brief Adds a variable to the incumbent model, without the cost or matrix
    * coefficients
    */
-  HighsStatus addVar(const double lower, const double upper) {
+  HighsStatus addVar(const double lower = 0, const double upper = kHighsInf) {
     return this->addVars(1, &lower, &upper);
   }
 
@@ -943,8 +987,9 @@ class Highs {
 
   /**
    * @brief Delete multiple columns from the incumbent model given by
-   * a mask (full length array with 1 => change; 0 => not). New index
-   * of any column not deleted is returned in place of the value 0.
+   * a mask (full length array with 1 => delete; 0 => keep). New index
+   * of any column kept is returned in place of the value 0.  For
+   * deleted columns, a value of -1 is returned.
    */
   HighsStatus deleteCols(HighsInt* mask);
 
@@ -964,9 +1009,10 @@ class Highs {
   }
 
   /**
-   * @brief Delete multiple variables from the incumbent model given by
-   * a mask (full length array with 1 => change; 0 => not). New index
-   * of any variable not deleted is returned in place of the value 0.
+   * @brief Delete multiple variables from the incumbent model given
+   * by a mask (full length array with 1 => delete; 0 => keep). New
+   * index of any variable not deleted is returned in place of the
+   * value 0. For deleted variables, a value of -1 is returned.
    */
   HighsStatus deleteVars(HighsInt* mask) { return deleteCols(mask); }
 
@@ -983,8 +1029,9 @@ class Highs {
 
   /**
    * @brief Delete multiple rows from the incumbent model given by a
-   * mask (full length array with 1 => change; 0 => not). New index of
-   * any row not deleted is returned in place of the value 0.
+   * mask (full length array with 1 => delete; 0 => keep). New index
+   * of any row not deleted is returned in place of the value 0. For
+   * deleted rows, a value of -1 is returned.
    */
   HighsStatus deleteRows(HighsInt* mask);
 
@@ -1019,20 +1066,22 @@ class Highs {
   /**
    * @brief Set the callback method to use for HiGHS
    */
-  HighsStatus setCallback(void (*user_callback)(const int, const char*,
-                                                const HighsCallbackDataOut*,
-                                                HighsCallbackDataIn*, void*),
+  HighsStatus setCallback(HighsCallbackFunctionType user_callback,
+                          void* user_callback_data = nullptr);
+  HighsStatus setCallback(HighsCCallbackType c_callback,
                           void* user_callback_data = nullptr);
 
   /**
    * @brief Start callback of given type
    */
   HighsStatus startCallback(const int callback_type);
+  HighsStatus startCallback(const HighsCallbackType callback_type);
 
   /**
    * @brief Stop callback of given type
    */
   HighsStatus stopCallback(const int callback_type);
+  HighsStatus stopCallback(const HighsCallbackType callback_type);
 
   /**
    * @brief Use the HighsBasis passed to set the internal HighsBasis
@@ -1163,6 +1212,8 @@ class Highs {
 
   // Start of deprecated methods
 
+  std::string compilationDate() const { return "deprecated"; }
+
   HighsStatus setLogCallback(void (*user_log_callback)(HighsLogType,
                                                        const char*, void*),
                              void* user_log_callback_data = nullptr);
@@ -1301,7 +1352,7 @@ class Highs {
     this->model_.hessian_.exactResize();
   }
 
-  HighsStatus assignContinuousAtDiscreteSolution();
+  HighsStatus completeSolutionFromDiscreteAssignment();
 
   HighsStatus callSolveLp(HighsLp& lp, const string message);
   HighsStatus callSolveQp();
@@ -1336,7 +1387,7 @@ class Highs {
   //
   // Methods to clear solver data for users in Highs class members
   // before (possibly) updating them with data from trying to solve
-  // the inumcumbent model.
+  // the incumbent model.
   //
   // Invalidates all solver data in Highs class members by calling
   // invalidateModelStatus(), invalidateSolution(), invalidateBasis(),
@@ -1366,7 +1417,8 @@ class Highs {
 
   HighsStatus returnFromWriteSolution(FILE* file,
                                       const HighsStatus return_status);
-  HighsStatus returnFromRun(const HighsStatus return_status);
+  HighsStatus returnFromRun(const HighsStatus return_status,
+                            const bool undo_mods);
   HighsStatus returnFromHighs(const HighsStatus return_status);
   void reportSolvedLpQpStats();
 
@@ -1444,6 +1496,7 @@ class Highs {
   HighsStatus getPrimalRayInterface(bool& has_primal_ray,
                                     double* primal_ray_value);
   HighsStatus getRangingInterface();
+
   bool aFormatOk(const HighsInt num_nz, const HighsInt format);
   bool qFormatOk(const HighsInt num_nz, const HighsInt format);
   void clearZeroHessian();
@@ -1454,6 +1507,23 @@ class Highs {
 
   HighsStatus handleInfCost();
   void restoreInfCost(HighsStatus& return_status);
+  HighsStatus optionChangeAction();
+  HighsStatus computeIllConditioning(HighsIllConditioning& ill_conditioning,
+                                     const bool constraint,
+                                     const HighsInt method,
+                                     const double ill_conditioning_bound);
+  void formIllConditioningLp0(HighsLp& ill_conditioning_lp,
+                              std::vector<HighsInt>& basic_var,
+                              const bool constraint);
+  void formIllConditioningLp1(HighsLp& ill_conditioning_lp,
+                              std::vector<HighsInt>& basic_var,
+                              const bool constraint,
+                              const double ill_conditioning_bound);
+  bool infeasibleBoundsOk();
 };
 
+// Start of deprecated methods not in the Highs class
+
+const char* highsCompilationDate();
+
 #endif

casadi/include/highs/filereaderlp/def.hpp

@@ -0,0 +1,19 @@
+#ifndef __READERLP_DEF_HPP__
+#define __READERLP_DEF_HPP__
+
+#include <stdexcept>
+#include <string>
+
+void inline lpassert(bool condition) {
+  if (!condition) {
+    throw std::invalid_argument("File not existent or illegal file format.");
+  }
+}
+
+const std::string LP_KEYWORD_INF[] = {"infinity", "inf"};
+const std::string LP_KEYWORD_FREE[] = {"free"};
+
+const unsigned int LP_KEYWORD_INF_N = 2;
+const unsigned int LP_KEYWORD_FREE_N = 1;
+
+#endif