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

casadi/include/casadi/core/casadi_misc.hpp

@@ -144,6 +144,28 @@ private:
   template<typename T>
   std::vector<T> vector_slice(const std::vector<T> &v, const std::vector<casadi_int> &i);
 
+  /**  \brief Select subset of vector
+
+  *  \param v Vector to slice
+  *  \param s Select?
+
+       \identifier{286} */
+  template<typename T>
+  std::vector<T> vector_select(const std::vector<T> &v, const std::vector<bool> &s,
+    bool invert=false);
+
+  /**  \brief Return all but the first element of a vector
+
+       \identifier{27y} */
+  template<typename T>
+  std::vector<T> vector_tail(const std::vector<T> &v);
+
+  /**  \brief Return all but the last element of a vector
+
+       \identifier{285} */
+  template<typename T>
+  std::vector<T> vector_init(const std::vector<T> &v);
+
   /** \brief Reverse a list
 
       \identifier{1la} */
@@ -526,6 +548,36 @@ namespace casadi {
     return ret;
   }
 
+  template<typename T>
+  std::vector<T> vector_select(const std::vector<T> &v, const std::vector<bool> &s, bool invert) {
+    std::vector<T> ret;
+    casadi_assert(v.size()==s.size(), "Dimension mismatch.");
+    if (invert) {
+      for (casadi_int k=0;k<s.size();++k) {
+        if (!s[k]) ret.push_back(v[k]);
+      }
+    } else {
+      for (casadi_int k=0;k<s.size();++k) {
+        if (s[k]) ret.push_back(v[k]);
+      }
+    }
+    return ret;
+  }
+
+  template<typename T>
+  std::vector<T> vector_tail(const std::vector<T> &v) {
+    std::vector<T> ret;
+    ret.insert(ret.begin(), v.begin()+1, v.end());
+    return ret;
+  }
+
+  template<typename T>
+  std::vector<T> vector_init(const std::vector<T> &v) {
+    std::vector<T> ret;
+    ret.insert(ret.begin(), v.begin(), v.begin()+v.size()-1);
+    return ret;
+  }
+
   template<typename T>
   std::vector<T> reverse(const std::vector<T> &v) {
     std::vector<T> ret(v.size());

casadi/include/casadi/core/casadi_types.hpp

@@ -57,9 +57,10 @@ namespace casadi {
         SOLVER_RET_UNKNOWN,
         SOLVER_RET_LIMITED, // Out of time
         SOLVER_RET_NAN,
-        SOLVER_RET_INFEASIBLE
+        SOLVER_RET_INFEASIBLE,
+        SOLVER_RET_EXCEPTION
     };
-}
+} // namespace casadi
 
 
 #endif // CASADI_TYPES_HPP

casadi/include/casadi/core/code_generator.hpp

@@ -108,6 +108,11 @@ namespace casadi {
         \identifier{27l} */
     casadi_int get_constant(const std::vector<char>& v, bool allow_adding=false);
 
+    /** \brief Get or add a vector<string> constant
+
+        \identifier{27z} */
+    casadi_int get_constant(const std::vector<std::string>& v, bool allow_adding=false);
+
     /** \brief Represent an array constant; adding it when new
 
         \identifier{rz} */
@@ -138,6 +143,11 @@ namespace casadi {
         \identifier{27m} */
     std::string constant(const std::vector<char>& v);
 
+    /** \brief Represent an array constant; adding it when new
+
+        \identifier{280} */
+    std::string constant(const std::vector<std::string>& v);
+
     /** \brief Allocate file scope double read-only memory
 
         \identifier{s2} */
@@ -153,6 +163,10 @@ namespace casadi {
         \identifier{s4} */
     void define_rom_integer(const void* id, casadi_int size);
 
+    /** \brief Setup a callback
+
+        \identifier{27s} */
+    void setup_callback(const std::string& s, const Function& f);
     /** \brief Access file scope integer read-only memory
 
         \identifier{s5} */
@@ -243,6 +257,7 @@ namespace casadi {
     std::string initializer(const std::vector<double>& v);
     std::string initializer(const std::vector<casadi_int>& v);
     std::string initializer(const std::vector<char>& v);
+    std::string initializer(const std::vector<std::string>& v);
 
     /** \brief Sanitize source files for codegen
 
@@ -614,7 +629,12 @@ namespace casadi {
       AUX_MMIN,
       AUX_MMAX,
       AUX_LOGSUMEXP,
-      AUX_SPARSITY
+      AUX_SPARSITY,
+      AUX_BFGS,
+      AUX_ORACLE_CALLBACK,
+      AUX_OCP_BLOCK,
+      AUX_ORACLE,
+      AUX_SCALED_COPY
     };
 
     /** \brief Add a built-in auxiliary function
@@ -657,6 +677,12 @@ namespace casadi {
     void print_vector(std::ostream &s, const std::string& name,
                              const std::vector<double>& v);
 
+    /** \brief  Print string vector to a c file
+
+        \identifier{281} */
+    void print_vector(std::ostream &s, const std::string& name,
+                             const std::vector<std::string>& v);
+
     /** \brief Create a copy operation
 
         \identifier{tt} */
@@ -895,6 +921,7 @@ namespace casadi {
     std::multimap<size_t, size_t> added_double_constants_;
     std::multimap<size_t, size_t> added_integer_constants_;
     std::multimap<size_t, size_t> added_char_constants_;
+    std::multimap<size_t, size_t> added_string_constants_;
     std::map<std::string, std::pair<std::string, std::string> > local_variables_;
     std::map<std::string, std::string> local_default_;
     std::map<const void *, casadi_int> file_scope_double_;
@@ -916,6 +943,7 @@ namespace casadi {
     std::vector<std::vector<double> > double_constants_;
     std::vector<std::vector<casadi_int> > integer_constants_;
     std::vector<std::vector<char> > char_constants_;
+    std::vector<std::vector<std::string> > string_constants_;
 
     // Does any function need thread-local memory?
     bool needs_mem_;
@@ -924,6 +952,7 @@ namespace casadi {
     static size_t hash(const std::vector<double>& v);
     static size_t hash(const std::vector<casadi_int>& v);
     static size_t hash(const std::vector<char>& v);
+    static size_t hash(const std::vector<std::string>& v);
 
     std::string wrapper(const Function& base, const std::string& name);
 

casadi/include/casadi/core/global_options.hpp

@@ -70,6 +70,8 @@ namespace casadi {
 
       static casadi_int start_index;
 
+      static bool julia_initialized;
+
 #endif //SWIG
       // Setter and getter for simplification_on_the_fly
       static void setSimplificationOnTheFly(bool flag) { simplification_on_the_fly = flag; }

casadi/include/casadi/core/mx.hpp

@@ -274,6 +274,11 @@ namespace casadi {
     /// Check if evaluation output
     bool is_output() const;
 
+    /** \brief  Check if a multiple output node
+
+        \identifier{284} */
+    bool has_output() const;
+
     /// Get the index of evaluation output - only valid when is_output() is true
     casadi_int which_output() const;
 
@@ -306,15 +311,23 @@ namespace casadi {
         \identifier{qp} */
     std::vector<MX> primitives() const;
 
+    /// @{
     /** \brief Split up an expression along symbolic primitives
 
         \identifier{qq} */
     std::vector<MX> split_primitives(const MX& x) const;
+    std::vector<SX> split_primitives(const SX& x) const;
+    std::vector<DM> split_primitives(const DM& x) const;
+    /// @}
 
+    /// @{
     /** \brief Join an expression along symbolic primitives
 
         \identifier{qr} */
     MX join_primitives(const std::vector<MX>& v) const;
+    SX join_primitives(const std::vector<SX>& v) const;
+    DM join_primitives(const std::vector<DM>& v) const;
+    /// @}
 
     /// \cond INTERNAL
     /** \brief Detect duplicate symbolic expressions
@@ -655,6 +668,7 @@ namespace casadi {
     static MX convexify(const MX& H, const Dict& opts = Dict());
     static MX stop_diff(const MX& expr, casadi_int order);
     static MX stop_diff(const MX& expr, const MX& var, casadi_int order);
+    static std::vector<MX> difference(const std::vector<MX>& a, const std::vector<MX>& b);
     ///@}
     /// \endcond
 
@@ -836,13 +850,14 @@ namespace casadi {
       return MX::stop_diff(expr, var, order);
     }
 
+    /** \bried Return all elements of a that do not occur in b, preserving order */
+    inline friend std::vector<MX> difference(const std::vector<MX>& a, const std::vector<MX>& b) {
+      return MX::difference(a, b);
+    }
 
 /** @} */
 #endif // SWIG
 
-    /** \bried Return all elements of a that do not occur in b, preserving order */
-    friend std::vector<MX> difference(const std::vector<MX>& a, const std::vector<MX>& b);
-
     /** \brief returns itself, but with an assertion attached
     *
     *  If y does not evaluate to 1, a runtime error is raised

casadi/include/casadi/core/optistack.hpp

@@ -200,6 +200,23 @@ public:
   void set_value(const std::vector<MX>& assignments);
   /// @}
 
+  /// @{
+  /** \brief Set domain of a decision variable
+  *
+  * \param[in] x decision variable
+  * \param[in] type 'real', 'integer' (default: real)
+  *
+  * \verbatim
+  * opti.set_domain(x, "real")
+  * opti.set_domain(x, "integer")
+  * \endverbatim
+
+      \identifier{27t} */
+  void set_domain(const MX& x, const std::string& domain);
+
+  /// @}
+
+
   /// Crunch the numbers; solve the problem
   OptiSol solve();
 
@@ -451,6 +468,11 @@ public:
     OPTI_PAR,  // parameter
     OPTI_DUAL_G // dual
   };
+  enum DomainType {
+    OPTI_DOMAIN_REAL,
+    OPTI_DOMAIN_INTEGER
+  };
+
 
   struct IndexAbstraction {
     IndexAbstraction() : start(0), stop(0) {}
@@ -475,6 +497,7 @@ public:
     casadi_int n;
     casadi_int m;
     VariableType type;
+    DomainType domain;
     casadi_int count;
     casadi_int i;
     casadi_int active_i;

casadi/include/casadi/core/runtime/casadi_nlp.hpp

@@ -66,12 +66,14 @@ struct casadi_nlpsol_detect_bounds_data {
   T1* lam_xu;
 };
 // C-REPLACE "casadi_nlpsol_detect_bounds_data<T1>" "struct casadi_nlpsol_detect_bounds_data"
+// C-REPLACE "casadi_oracle_data<T1>" "struct casadi_oracle_data"
 
 // SYMBOL "nlpsol_data"
 template<typename T1>
 struct casadi_nlpsol_data {
   // Problem structure
   const casadi_nlpsol_prob<T1>* prob;
+  casadi_oracle_data<T1>* oracle;
   // Variable bounds
   T1 *lbz, *ubz;
   // Current primal solution
@@ -151,8 +153,6 @@ void casadi_nlpsol_init(casadi_nlpsol_data<T1>* d, const T1*** arg, T1*** res,
 
 }
 
-// C-REPLACE "fabs" "casadi_fabs"
-
 // SYMBOL "nlpsol_detect_bounds_before"
 template<typename T1>
 int casadi_detect_bounds_before(casadi_nlpsol_data<T1>* d_nlp) {
@@ -194,8 +194,14 @@ int casadi_detect_bounds_before(casadi_nlpsol_data<T1>* d_nlp) {
   for (casadi_int i=0;i<p_bounds->ng;++i) {
     if (p_bounds->is_simple[i]) {
       // Update lbz/ubz
-      T1 lb = (d_nlp->lbg[i]-d_bounds->b[k])/fabs(d_bounds->a[k]);
-      T1 ub = (d_nlp->ubg[i]-d_bounds->b[k])/fabs(d_bounds->a[k]);
+
+      T1 lb = (d_nlp->lbg[i]-d_bounds->b[k])/d_bounds->a[k];
+      T1 ub = (d_nlp->ubg[i]-d_bounds->b[k])/d_bounds->a[k];
+      if (d_bounds->a[k]<0) {
+        T1 tmp = lb;
+        lb = ub;
+        ub = tmp;
+      }
       casadi_int j = p_bounds->target_x[k];
 
       if (lb==d_nlp->lbz[j]) {
@@ -270,5 +276,14 @@ int casadi_detect_bounds_after(casadi_nlpsol_data<T1>* d_nlp) {
         d_nlp->lam_g[d_bounds->target_u[i]-nx] += (d_nlp->lam[i]>0)*d_nlp->lam[i];
     }
   }
+
+  k = 0;
+  for (casadi_int i=0;i<p_bounds->ng;++i) {
+    if (p_bounds->is_simple[i]) {
+      if (d_nlp->lam_g) d_nlp->lam_g[i] /= d_bounds->a[k];
+      k++;
+    }
+  }
+
   return 0;
 }

casadi/include/casadi/core/runtime/casadi_ocp_block.hpp

@@ -0,0 +1,55 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+
+// SYMBOL "ocp_block"
+struct casadi_ocp_block {
+    casadi_int offset_r;
+    casadi_int offset_c;
+    casadi_int rows;
+    casadi_int cols;
+};
+// C-REPLACE "casadi_ocp_block" "struct casadi_ocp_block"
+
+// SYMBOL "unpack_ocp_blocks"
+template<typename T1>
+void casadi_unpack_ocp_blocks(casadi_ocp_block* blocks, const casadi_int* packed) {
+    casadi_int i;
+    casadi_int N = *packed++;
+    for (i=0;i<N;++i) {
+        blocks[i].offset_r = *packed++;
+        blocks[i].offset_c = *packed++;
+        blocks[i].rows = *packed++;
+        blocks[i].cols = *packed++;
+    }
+}
+
+// SYMBOL "ptr_ocp_block"
+template<typename T1>
+void casadi_ptr_ocp_block(casadi_int N, T1** vs, T1* v, const casadi_ocp_block* blocks, int eye) {
+    casadi_int k, offset = 0;
+    for (k=0;k<N;++k) {
+        vs[k] = v+offset;
+        if (eye) {
+        offset += blocks[k].rows;
+        } else {
+        offset += blocks[k].rows*blocks[k].cols;
+        }
+    }
+}

casadi/include/casadi/core/runtime/casadi_oracle.hpp

@@ -0,0 +1,44 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// C-REPLACE "OracleMemory* m;" ""
+
+
+// SYMBOL "oracle_data"
+template<typename T1>
+struct casadi_oracle_data {
+  const T1** arg;
+  T1** res;
+  casadi_int* iw;
+  T1* w;
+
+  void* m;
+};
+
+// C-REPLACE "casadi_oracle_data<T1>" "struct casadi_oracle_data"
+
+// SYMBOL "oracle_init"
+template<typename T1>
+void casadi_oracle_init(casadi_oracle_data<T1>* d, const T1*** arg, T1*** res,
+    casadi_int** iw, T1** w) {
+  d->arg = *arg;
+  d->res = *res;
+  d->iw = *iw;
+  d->w = *w;
+}

casadi/include/casadi/core/runtime/casadi_oracle_callback.hpp

@@ -0,0 +1,39 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// SYMBOL "oracle_callback"
+template<typename T1>
+struct casadi_oracle_callback {
+  int (*eval)(const T1** arg, T1** res, casadi_int* iw, T1* w, int mem);
+  int (*checkout)(void);
+  void (*release)(int);
+};
+// C-REPLACE "casadi_oracle_callback<T1>" "struct casadi_oracle_callback"
+// C-REPLACE "casadi_oracle_data<T1>" "struct casadi_oracle_data"
+
+// SYMBOL "call"
+template<typename T1>
+int casadi_oracle_call(const casadi_oracle_callback<T1>* cb, casadi_oracle_data<T1>* d) {
+  int flag;
+  int mem = 0;
+  if (cb->checkout) mem = cb->checkout();
+  flag = cb->eval(d->arg, d->res, d->iw, d->w, mem);
+  if (cb->release) cb->release(mem);
+  return flag;
+}

casadi/include/casadi/core/runtime/casadi_runtime.hpp

@@ -292,6 +292,7 @@ namespace casadi {
   #include "casadi_qrqp.hpp"
   #include "casadi_kkt.hpp"
   #include "casadi_ipqp.hpp"
+  #include "casadi_oracle.hpp"
   #include "casadi_nlp.hpp"
   #include "casadi_sqpmethod.hpp"
   #include "casadi_feasiblesqpmethod.hpp"
@@ -307,7 +308,9 @@ namespace casadi {
   #include "casadi_sum.hpp"
   #include "casadi_sparsity.hpp"
   #include "casadi_jac.hpp"
-
+  #include "casadi_oracle_callback.hpp"
+  #include "casadi_ocp_block.hpp"
+  #include "casadi_scaled_copy.hpp"
 } // namespace casadi
 
 /// \endcond

casadi/include/casadi/core/runtime/casadi_scaled_copy.hpp

@@ -0,0 +1,31 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// SYMBOL "scaled_copy"
+template<typename T1>
+void casadi_scaled_copy(T1 s, const T1* x, casadi_int n, T1* y) {
+  casadi_int i;
+  if (y) {
+    if (x) {
+      for (i=0; i<n; ++i) *y++ = s*(*x++);
+    } else {
+      for (i=0; i<n; ++i) *y++ = 0.;
+    }
+  }
+}

casadi/include/casadi/core/serializing_stream.hpp

@@ -99,7 +99,7 @@ namespace casadi {
     void unpack(Slice& e);
     void unpack(int& e);
 
-#if SIZE_MAX != UINT_MAX
+#if SIZE_MAX != UINT_MAX || defined(__EMSCRIPTEN__)
     void unpack(unsigned int& e);
 #endif
     void unpack(bool& e);
@@ -236,7 +236,7 @@ namespace casadi {
     void pack(const GenericType& e);
     void pack(std::istream& s);
     void pack(int e);
-#if SIZE_MAX != UINT_MAX
+#if SIZE_MAX != UINT_MAX || defined(__EMSCRIPTEN__)
     void pack(unsigned int e);
 #endif
     void pack(bool e);

casadi/include/casadi/core/sparsity.hpp

@@ -1212,6 +1212,13 @@ namespace casadi {
     hash_combine(seed, get_ptr(v), v.size());
   }
 
+  template<>
+  inline size_t hash_value(std::string v) {
+    size_t seed = 0;
+    hash_combine(seed, v.c_str(), v.size());
+    return seed;
+  }
+
   /** \brief Hash a sparsity pattern
 
       \identifier{ds} */