casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/casadi/core/nlp_builder.hpp

@@ -0,0 +1,162 @@
+/*
+ *    This file is part of CasADi.
+ *
+ *    CasADi -- A symbolic framework for dynamic optimization.
+ *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
+ *                            KU Leuven. All rights reserved.
+ *    Copyright (C) 2011-2014 Greg Horn
+ *
+ *    CasADi 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.
+ *
+ *    CasADi 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 CasADi; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+
+#ifndef CASADI_NLP_BUILDER_HPP
+#define CASADI_NLP_BUILDER_HPP
+
+#include "mx.hpp"
+
+namespace casadi {
+
+  /** \brief A symbolic NLP representation
+
+  \date 2012-2015
+  \author Joel Andersson
+
+      \identifier{1e2} */
+  class CASADI_EXPORT NlpBuilder
+    : public SWIG_IF_ELSE(PrintableCommon, Printable<NlpBuilder>) {
+  public:
+
+    /** @name Symbolic representation of the NLP
+    *  Data members
+    */
+    ///@{
+
+    /// Variables
+    std::vector<MX> x;
+
+    /// Objective
+    MX f;
+
+    /// Constraints
+    std::vector<MX> g;
+
+    /// Bounds on x
+    std::vector<double> x_lb, x_ub;
+
+    /// Bounds on g
+    std::vector<double> g_lb, g_ub;
+
+    /// Primal initial guess
+    std::vector<double> x_init;
+
+    /// Dual initial guess
+    std::vector<double> lambda_init;
+
+    /// Discrete variables
+    std::vector<bool> discrete;
+    ///@}
+
+    /// Import an .nl file
+    void import_nl(const std::string& filename, const Dict& opts = Dict());
+
+    /// Readable name of the class
+    std::string type_name() const {return "NlpBuilder";}
+
+    /// Print a description of the object
+    void disp(std::ostream& stream, bool more=false) const;
+
+    /// Get string representation
+    std::string get_str(bool more=false) const {
+      std::stringstream ss;
+      disp(ss, more);
+      return ss.str();
+    }
+  };
+
+#ifndef SWIG
+  /** \Helper class for .nl import
+  The .nl format is described in "Writing .nl Files" paper by David M. Gay (2005)
+  \date 2016
+  \author Joel Andersson
+  */
+  class CASADI_EXPORT NlImporter {
+  public:
+    // Constructor
+    NlImporter(NlpBuilder& nlp, const std::string& filename, const Dict& opts);
+    // Destructor
+    ~NlImporter();
+  private:
+    int read_int();
+    char read_char();
+    double read_double();
+    short read_short();
+    long read_long();
+    // Reference to the class
+    NlpBuilder& nlp_;
+    // Options
+    bool verbose_;
+    // Binary mode
+    bool binary_;
+    // File stream
+    std::ifstream s_;
+    // All variables, including dependent
+    std::vector<MX> v_;
+    // Number of objectives and constraints
+    casadi_int n_var_, n_con_, n_obj_, n_eq_, n_lcon_;
+    // nonlinear vars in constraints, objectives, both
+    // see JuliaOpt/AmplNLWriter.jl/src/nl_write.jl
+    casadi_int nlvc_, nlvo_, nlvb_;
+    // Number of discrete variables // see JuliaOpt/AmplNLWriter.jl/src/nl_write.jl
+    casadi_int nbv_, niv_, nlvbi_, nlvci_, nlvoi_;
+    // objective sign
+    MX sign_;
+    // Parse the file
+    void parse();
+    // Imported function description
+    void F_segment();
+    // Suffix values
+    void S_segment();
+    // Defined variable definition
+    void V_segment();
+    // Algebraic constraint body
+    void C_segment();
+    // Logical constraint expression
+    void L_segment();
+    // Objective function
+    void O_segment();
+    // Dual initial guess
+    void d_segment();
+    // Primal initial guess
+    void x_segment();
+    // Bounds on algebraic constraint bodies ("ranges")
+    void r_segment();
+    // Bounds on variable
+    void b_segment();
+    // Jacobian row counts
+    void k_segment();
+    // Linear terms in the constraint function
+    void J_segment();
+    // Linear terms in the objective function
+    void G_segment();
+    /// Read an expression from an NL-file (Polish infix format)
+    MX expr();
+  };
+#endif // SWIG
+
+} // namespace casadi
+
+#endif // CASADI_NLP_BUILDER_HPP

casadi/include/casadi/core/nlp_tools.hpp

@@ -0,0 +1,124 @@
+/*
+ *    This file is part of CasADi.
+ *
+ *    CasADi -- A symbolic framework for dynamic optimization.
+ *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
+ *                            KU Leuven. All rights reserved.
+ *    Copyright (C) 2011-2014 Greg Horn
+ *
+ *    CasADi 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.
+ *
+ *    CasADi 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 CasADi; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+
+#ifndef CASADI_NLP_TOOLS_HPP
+#define CASADI_NLP_TOOLS_HPP
+
+#include "casadi/core/function.hpp"
+
+namespace casadi {
+
+  //@{
+  /** \brief Detect simple bounds from general constraints
+   *
+   * Given parametric constraints:
+   * \verbatim
+   *   subject to lbg(p) <= g(x,p) <= ubg(p)
+   * \endverbatim
+   *
+   * Returns an equivalent set
+   * \verbatim
+   *   subject to  lbg(p)(gi) <= g(x,p)(gi) <= ubg(p)(gi)
+   *               lbx(p) <= x                 <= ubx(p)
+   * \endverbatim
+   *
+   * \param[out] lam_forward (lam_g,p)->(lam_sg,lam_x)
+   * \param[out] lam_backward (lam_sg,lam_x,p)->(lam_g)
+   *
+      \identifier{1sw} */
+  CASADI_EXPORT void detect_simple_bounds(const SX& xX, const SX& p,
+      const SX& g, const SX& lbg, const SX& ubg,
+      std::vector<casadi_int>& SWIG_OUTPUT(gi),
+      SX& SWIG_OUTPUT(lbx), SX& SWIG_OUTPUT(ubx),
+      Function& SWIG_OUTPUT(lam_forward),
+      Function& SWIG_OUTPUT(lam_backward));
+  CASADI_EXPORT void detect_simple_bounds(const MX& xX, const MX& p,
+      const MX& g, const MX& lbg, const MX& ubg,
+      std::vector<casadi_int>& SWIG_OUTPUT(gi),
+      MX& SWIG_OUTPUT(lbx), MX& SWIG_OUTPUT(ubx),
+      Function& SWIG_OUTPUT(lam_forward),
+      Function& SWIG_OUTPUT(lam_backward));
+  //@}
+
+/*
+  CASADI_EXPORT void detect_simple_bounds(const SX& xX,
+      const SX& g, const SX& lbg, const SX& ubg,
+      std::vector<casadi_int>& SWIG_OUTPUT(gi),
+      DM& SWIG_OUTPUT(lbx), DM& SWIG_OUTPUT(ubx),
+      Function& SWIG_OUTPUT(lam_forward),
+      Function& SWIG_OUTPUT(lam_backward));
+*/
+
+
+  /** \brief Check sos structure and generate defaults
+
+      \identifier{1sx} */
+  template <class T>
+  void check_sos(casadi_int nx, const std::vector< std::vector<T> >& groups,
+                  std::vector< std::vector<double> >& weights,
+                  std::vector< casadi_int >& types) {
+    // Checks on presence
+    if (groups.empty()) {
+      casadi_assert(weights.empty(), "Missing sos_groups.");
+      casadi_assert(types.empty(),   "Missing sos_groups.");
+    }
+
+    // Checks on dimensions
+    casadi_int sos_num = groups.size();
+
+    casadi_assert(weights.empty() || weights.size()==sos_num,
+      "sos_weights has incorrect size");
+
+    // Set default types
+    if (!groups.empty() && types.empty())
+      types.resize(sos_num, 1);
+
+    // Set default weights
+    if (weights.empty()) {
+      for (const auto& e : groups) {
+        std::vector<double> w(e.size());
+        for (casadi_int i=0;i<w.size();++i) w[i] = i;
+        weights.push_back(w);
+      }
+    }
+
+    casadi_assert(types.size()==sos_num,
+      "sos_types has incorrect size");
+
+    // Group-wise dimension check
+    for (casadi_int i=0;i<weights.size();++i) {
+      casadi_assert(weights[i].size()==groups[i].size(),
+        "Dimension mismatch in weights for group " + str(i) + ": "
+        "Expected " + str(groups[i].size()) + ", got " + str(weights[i].size()));
+    }
+
+    // Checks on contents
+    for (casadi_int t : types) casadi_assert(t==1 || t==2, "SOS type must be either 1 or 2.");
+    for (const auto& v : groups) casadi_assert(in_range(v, 0, nx), "Index out of bound");
+  }
+
+} // namespace casadi
+
+#endif // CASADI_NLP_TOOLS_HPP

casadi/include/casadi/core/nlpsol.hpp

@@ -0,0 +1,234 @@
+/*
+ *    This file is part of CasADi.
+ *
+ *    CasADi -- A symbolic framework for dynamic optimization.
+ *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
+ *                            KU Leuven. All rights reserved.
+ *    Copyright (C) 2011-2014 Greg Horn
+ *
+ *    CasADi 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.
+ *
+ *    CasADi 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 CasADi; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+
+#ifndef CASADI_NLPSOL_HPP
+#define CASADI_NLPSOL_HPP
+
+#include "function.hpp"
+
+namespace casadi {
+
+  /** \defgroup main_nlpsol Title
+      \par
+
+      Create an NLP solver
+      Creates a solver for the following parametric nonlinear program (NLP):
+      \verbatim
+
+      min          F(x, p)
+      x
+
+      subject to
+      LBX <=   x    <= UBX
+      LBG <= G(x, p) <= UBG
+      p  == P
+
+      nx: number of decision variables
+      ng: number of constraints
+      np: number of parameters
+
+      \endverbatim
+
+      \generalsection{Nlpsol}
+      \pluginssection{Nlpsol}
+
+      \author Joel Andersson
+      \date 2011-2015
+
+      \identifier{21q} */
+
+  /** \defgroup nlpsol Title
+  * @copydoc main_nlpsol
+  *  @{
+  */
+
+  /** \if EXPANDED
+  * @copydoc main_nlpsol
+  * \endif
+  */
+  ///@{
+  CASADI_EXPORT Function nlpsol(const std::string& name, const std::string& solver,
+                                const SXDict& nlp, const Dict& opts=Dict());
+  CASADI_EXPORT Function nlpsol(const std::string& name, const std::string& solver,
+                                const MXDict& nlp, const Dict& opts=Dict());
+  CASADI_EXPORT Function nlpsol(const std::string& name, const std::string& solver,
+                                const std::string& fname, const Dict& opts=Dict());
+  CASADI_EXPORT Function nlpsol(const std::string& name, const std::string& solver,
+                                const Importer& compiler, const Dict& opts=Dict());
+  CASADI_EXPORT Function nlpsol(const std::string& name, const std::string& solver,
+                                const NlpBuilder& nl, const Dict& opts=Dict());
+  CASADI_EXPORT Function nlpsol(const std::string& name, const std::string& solver,
+                                const Function& nlp, const Dict& opts=Dict());
+  ///@}
+
+  /** \brief Get input scheme of NLP solvers
+
+  * \if EXPANDED
+  * @copydoc scheme_NlpsolInput
+  * \endif
+
+      \identifier{1sy} */
+  CASADI_EXPORT std::vector<std::string> nlpsol_in();
+
+  /** \brief Get NLP solver output scheme of NLP solvers
+
+  * \if EXPANDED
+  * @copydoc scheme_NlpsolOutput
+  * \endif
+
+      \identifier{1sz} */
+  CASADI_EXPORT std::vector<std::string> nlpsol_out();
+
+  /** \brief Get NLP solver input scheme name by index
+
+  * \if EXPANDED
+  * @copydoc scheme_NlpsolInput
+  * \endif
+
+      \identifier{1t0} */
+  CASADI_EXPORT std::string nlpsol_in(casadi_int ind);
+
+  /** \brief Get output scheme name by index
+
+  * \if EXPANDED
+  * @copydoc scheme_NlpsolOutput
+  * \endif
+
+      \identifier{1t1} */
+  CASADI_EXPORT std::string nlpsol_out(casadi_int ind);
+
+  /** \brief Number of NLP solver inputs
+
+      \identifier{1t2} */
+  CASADI_EXPORT casadi_int nlpsol_n_in();
+
+  /** \brief Number of NLP solver outputs
+
+      \identifier{1t3} */
+  CASADI_EXPORT casadi_int nlpsol_n_out();
+
+  ///@{
+  /** \brief Default input for an NLP solver
+
+      \identifier{1t4} */
+  CASADI_EXPORT double nlpsol_default_in(casadi_int ind);
+  CASADI_EXPORT std::vector<double> nlpsol_default_in();
+  ///@}
+
+  /** \brief Get all options for a plugin
+
+      \identifier{1t5} */
+  CASADI_EXPORT std::vector<std::string> nlpsol_options(const std::string& name);
+
+  /** \brief Get type info for a particular option
+
+      \identifier{1t6} */
+  CASADI_EXPORT std::string nlpsol_option_type(const std::string& name, const std::string& op);
+
+  /** \brief Get documentation for a particular option
+
+      \identifier{1t7} */
+  CASADI_EXPORT std::string nlpsol_option_info(const std::string& name, const std::string& op);
+
+  /// Check if a particular plugin is available
+  CASADI_EXPORT bool has_nlpsol(const std::string& name);
+
+  /// Explicitly load a plugin dynamically
+  CASADI_EXPORT void load_nlpsol(const std::string& name);
+
+  /// Get the documentation string for a plugin
+  CASADI_EXPORT std::string doc_nlpsol(const std::string& name);
+
+  /** @} */
+
+#ifndef SWIG
+/// Input arguments of an NLP function
+enum NLPInput {
+  /// Decision variable
+  NL_X,
+  /// Fixed parameter
+  NL_P,
+  /// Number of NLP inputs
+  NL_NUM_IN
+};
+
+/// Shortname for onput arguments of an NLP function
+const std::vector<std::string> NL_INPUTS = {"x", "p"};
+
+/// Output arguments of an NLP function
+enum NLPOutput {
+  /// Objective function
+  NL_F,
+  /// Constraint function
+  NL_G,
+  /// Number of NLP outputs
+  NL_NUM_OUT
+};
+
+/// Shortname for output arguments of an NLP function
+const std::vector<std::string> NL_OUTPUTS = {"f", "g"};
+
+/// Input arguments of an NLP Solver
+enum NlpsolInput {
+  /// Decision variables, initial guess (nx x 1)
+  NLPSOL_X0,
+  /// Value of fixed parameters (np x 1)
+  NLPSOL_P,
+  /// Decision variables lower bound (nx x 1), default -inf
+  NLPSOL_LBX,
+  /// Decision variables upper bound (nx x 1), default +inf
+  NLPSOL_UBX,
+  /// Constraints lower bound (ng x 1), default -inf
+  NLPSOL_LBG,
+  /// Constraints upper bound (ng x 1), default +inf
+  NLPSOL_UBG,
+  /// Lagrange multipliers for bounds on X, initial guess (nx x 1)
+  NLPSOL_LAM_X0,
+  /// Lagrange multipliers for bounds on G, initial guess (ng x 1)
+  NLPSOL_LAM_G0,
+  NLPSOL_NUM_IN
+};
+
+/// Output arguments of an NLP Solver
+enum NlpsolOutput {
+  /// Decision variables at the optimal solution (nx x 1)
+  NLPSOL_X,
+  /// Cost function value at the optimal solution (1 x 1)
+  NLPSOL_F,
+  /// Constraints function at the optimal solution (ng x 1)
+  NLPSOL_G,
+  /// Lagrange multipliers for bounds on X at the solution (nx x 1)
+  NLPSOL_LAM_X,
+  /// Lagrange multipliers for bounds on G at the solution (ng x 1)
+  NLPSOL_LAM_G,
+  /// Lagrange multipliers for bounds on P at the solution (np x 1)
+  NLPSOL_LAM_P,
+  NLPSOL_NUM_OUT
+};
+#endif // SWIG
+
+} // namespace casadi
+
+#endif // CASADI_NLPSOL_HPP

casadi/include/casadi/core/nonzeros.hpp

@@ -0,0 +1,111 @@
+/*
+ *    This file is part of CasADi.
+ *
+ *    CasADi -- A symbolic framework for dynamic optimization.
+ *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
+ *                            KU Leuven. All rights reserved.
+ *    Copyright (C) 2011-2014 Greg Horn
+ *
+ *    CasADi 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.
+ *
+ *    CasADi 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 CasADi; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+
+#ifndef CASADI_NONZEROS_HPP
+#define CASADI_NONZEROS_HPP
+
+namespace casadi {
+
+
+/** NonZeros class for Matrix
+  NonZeros is the return type for operator[] of the Matrix class, it allows access to the value as well as changing the parent object
+  \author Joel Andersson
+  \date 2011
+*/
+
+/// Access to a set of nonzeros
+template<typename M, typename K>
+class NonZeros : public M {
+  public:
+    /// Constructor
+    NonZeros(M& mat, const K& k) : mat_(mat), k_(k) { mat.get_nz(*this, false, k); }
+
+    /// Default copy constructor
+    NonZeros(const NonZeros<M, K> &y) = default;
+
+    ///@{
+    /// Methods that modify a part of the parent object (A[k] = ?, A[k] += ?, etc.)
+    const M& operator=(const NonZeros<M, K> &y);
+    const M& operator=(const M &y);
+    M operator+=(const M &y);
+    M operator-=(const M &y);
+    M operator*=(const M &y);
+    M operator/=(const M &y);
+    ///@}
+
+  private:
+    /// A reference to the matrix that is allowed to be modified
+    M& mat_;
+
+    /// The element of the matrix that is allowed to be modified
+    K k_;
+};
+
+// Implementation
+template<typename M, typename K>
+const M& NonZeros<M, K>::operator=(const NonZeros<M, K> &y) {
+  mat_.set_nz(y, false, k_);
+  return y;
+}
+
+// Implementation
+template<typename M, typename K>
+const M& NonZeros<M, K>::operator=(const M &y) {
+  mat_.set_nz(y, false, k_);
+  return y;
+}
+
+template<typename M, typename K>
+M NonZeros<M, K>::operator+=(const M &y) {
+  M s = *this+y;
+  mat_.set_nz(s, false, k_);
+  return s;
+}
+
+template<typename M, typename K>
+M NonZeros<M, K>::operator-=(const M &y) {
+  M s = *this-y;
+  mat_.set_nz(s, false, k_);
+  return s;
+}
+
+template<typename M, typename K>
+M NonZeros<M, K>::operator*=(const M &y) {
+   M s = *this*y;
+   mat_.set_nz(s, false, k_);
+   return s;
+}
+
+template<typename M, typename K>
+M NonZeros<M, K>::operator/=(const M &y) {
+  M s = *this/y;
+  mat_.set_nz(s, false, k_);
+  return s;
+}
+
+} // namespace casadi
+
+
+#endif // CASADI_NONZEROS_HPP