casadi 3.6.4__cp312-none-win_amd64.whl → 3.6.7__cp312-none-win_amd64.whl

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/matrix_decl.hpp

@@ -1050,15 +1050,30 @@ namespace casadi {
 
     /** \brief Check if symbolic (Dense)
 
+        Check if an expression is a pure symbol.
+        Pure means that no operations should happen on the symbol
+        (not even vec, transpose, index, concatenation, ...)
+        By consequence, a slice of a vector-shaped MX symbol is not a symbol.
+        However, the SX type is really a container format with scalar entries.
+        Therefore, a slice of a vector-shaped SX symbol is still a symbol.
+
         Sparse matrices invariable return false
 
+        \seealso is_valid_input
+
         \identifier{19r} */
     bool is_symbolic() const;
 
     /** \brief Check if matrix can be used to define function inputs.
 
+
+        is_valid_input is more forgiving than is_symbolic.
+        Some compositions are allowed: vec, vertcat.
+
         Sparse matrices can return true if all non-zero elements are symbolic
 
+        \seealso is_symbolic
+
         \identifier{19s} */
     bool is_valid_input() const;
 

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

@@ -29,9 +29,12 @@ struct casadi_nlpsol_detect_bounds_prob {
   casadi_int ng;
   // Number of bounds
   casadi_int nb;
-  casadi_int *target_x;
-  casadi_int *target_g;
-  char *is_simple;
+  const casadi_int *target_x;
+  const casadi_int *target_g;
+  const char *is_simple;
+
+  int (*callback)(const T1** arg, T1** res, casadi_int* iw, T1* w, void* callback_data);
+  void* callback_data;
 };
 // C-REPLACE "casadi_nlpsol_detect_bounds_prob<T1>" "struct casadi_nlpsol_detect_bounds_prob"
 
@@ -48,10 +51,10 @@ struct casadi_nlpsol_prob {
 template<typename T1>
 struct casadi_nlpsol_detect_bounds_data {
   // Work vectors
-  const double** arg;
-  double** res;
+  const T1** arg;
+  T1** res;
   casadi_int* iw;
-  double* w;
+  T1* w;
 
   // Simple bounds g(x)=A(b)x+b(p);
   // a[i]*x[target_x[i]]+b[i]
@@ -63,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
@@ -147,3 +152,138 @@ void casadi_nlpsol_init(casadi_nlpsol_data<T1>* d, const T1*** arg, T1*** res,
   }
 
 }
+
+// SYMBOL "nlpsol_detect_bounds_before"
+template<typename T1>
+int casadi_detect_bounds_before(casadi_nlpsol_data<T1>* d_nlp) {
+  const casadi_nlpsol_prob<T1>* p_nlp = d_nlp->prob;
+  casadi_nlpsol_detect_bounds_data<T1>* d_bounds = &d_nlp->detect_bounds;
+  const casadi_nlpsol_detect_bounds_prob<T1>* p_bounds = &p_nlp->detect_bounds;
+
+  casadi_int nx = p_nlp->nx;
+  d_bounds->arg[0] = d_nlp->p;
+  d_bounds->res[0] = d_bounds->a;
+  d_bounds->res[1] = d_bounds->b;
+  p_bounds->callback(d_bounds->arg, d_bounds->res,
+    d_bounds->iw, d_bounds->w, p_bounds->callback_data);
+
+  for (casadi_int i=0;i<p_bounds->nb;++i) {
+    if (d_bounds->a[i]==0) {
+      casadi_int k = p_bounds->target_g[i];
+      if (d_nlp->lbg[k]>d_bounds->b[i]) return 1;
+      if (d_nlp->ubg[k]<d_bounds->b[i]) return 1;
+    }
+  }
+
+  T1* lbz = d_nlp->lbz+nx;
+  T1* ubz = d_nlp->ubz+nx;
+  T1* lam = d_nlp->lam+nx;
+
+  for (casadi_int i=0;i<nx;++i) {
+    d_bounds->lam_xl[i] = d_nlp->lam_x0 ? (d_nlp->lam_x0[i]<0)*d_nlp->lam_x0[i] : 0.;
+    d_bounds->lam_xu[i] = d_nlp->lam_x0 ? (d_nlp->lam_x0[i]>0)*d_nlp->lam_x0[i] : 0.;
+  }
+
+  for (casadi_int i=0;i<nx;++i) {
+    d_bounds->target_l[i] = i;
+    d_bounds->target_u[i] = i;
+  }
+
+  // Update lbz/ubz
+  casadi_int k=0;
+  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])/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]) {
+        if (d_nlp->lam_g0) d_bounds->lam_xl[j] += (d_nlp->lam_g0[i]<0)*d_nlp->lam_g0[i];
+      } else if (lb>d_nlp->lbz[j]) {
+        d_nlp->lbz[j] = lb;
+        d_bounds->target_l[j] = nx+i;
+        if (d_nlp->lam_g0) d_bounds->lam_xl[j] = (d_nlp->lam_g0[i]<0)*d_nlp->lam_g0[i];
+      }
+
+      if (ub==d_nlp->ubz[j]) {
+        if (d_nlp->lam_g0) d_bounds->lam_xu[j] += (d_nlp->lam_g0[i]>0)*d_nlp->lam_g0[i];
+      } else if (ub<d_nlp->ubz[j]) {
+        d_nlp->ubz[j] = ub;
+        d_bounds->target_u[j] = nx+i;
+        if (d_nlp->lam_g0) d_bounds->lam_xu[j] = (d_nlp->lam_g0[i]>0)*d_nlp->lam_g0[i];
+      }
+
+      k++;
+    } else {
+
+      // Update lbz/ubz
+      *lbz++ = d_nlp->lbg[i];
+      *ubz++ = d_nlp->ubg[i];
+
+      if (d_nlp->lam_g0) *lam++ = d_nlp->lam_g0[i];
+    }
+  }
+
+  for (casadi_int i=0;i<nx;++i) {
+    d_nlp->lam[i] = d_bounds->lam_xl[i]+d_bounds->lam_xu[i];
+  }
+  return 0;
+}
+
+// SYMBOL "nlpsol_detect_bounds_after"
+template<typename T1>
+int casadi_detect_bounds_after(casadi_nlpsol_data<T1>* d_nlp) {
+  const casadi_nlpsol_prob<T1>* p_nlp = d_nlp->prob;
+  casadi_nlpsol_detect_bounds_data<T1>* d_bounds = &d_nlp->detect_bounds;
+  const casadi_nlpsol_detect_bounds_prob<T1>* p_bounds = &p_nlp->detect_bounds;
+  casadi_int nx = p_nlp->nx;
+
+  casadi_fill(d_nlp->lam_x, nx, 0.);
+  casadi_fill(d_nlp->lam_g, p_bounds->ng, 0.);
+
+  casadi_int k = 0;
+  casadi_int k_normal = 0;
+  for (casadi_int i=0;i<p_bounds->ng;++i) {
+    if (p_bounds->is_simple[i]) {
+      casadi_int j = p_bounds->target_x[k];
+      if (d_nlp->g) d_nlp->g[i] = d_bounds->a[k]*d_nlp->z[j]+d_bounds->b[k];
+      k++;
+    } else {
+      if (d_nlp->g) d_nlp->g[i] = d_nlp->z[nx+k_normal];
+      if (d_nlp->lam_g) d_nlp->lam_g[i] = d_nlp->lam[nx+k_normal];
+      k_normal++;
+    }
+  }
+
+  for (casadi_int i=0;i<nx;++i) {
+    if (d_bounds->target_l[i]<nx) {
+      if (d_nlp->lam_x) d_nlp->lam_x[i] += (d_nlp->lam[i]<0)*d_nlp->lam[i];
+    } else {
+      if (d_nlp->lam_g)
+        d_nlp->lam_g[d_bounds->target_l[i]-nx] += (d_nlp->lam[i]<0)*d_nlp->lam[i];
+    }
+    if (d_bounds->target_u[i]<nx) {
+      if (d_nlp->lam_x) d_nlp->lam_x[i] += (d_nlp->lam[i]>0)*d_nlp->lam[i];
+    } else {
+      if (d_nlp->lam_g)
+        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/runtime/casadi_sqpmethod.hpp

@@ -57,6 +57,11 @@ struct casadi_sqpmethod_data {
   T1* temp_mem;
   // temp_sol
   T1* temp_sol;
+
+  const T1** arg;
+  T1** res;
+  casadi_int* iw;
+  T1* w;
 };
 // C-REPLACE "casadi_sqpmethod_data<T1>" "struct casadi_sqpmethod_data"
 
@@ -113,7 +118,8 @@ void casadi_sqpmethod_work(const casadi_sqpmethod_prob<T1>* p,
 
 // SYMBOL "sqpmethod_init"
 template<typename T1>
-void casadi_sqpmethod_init(casadi_sqpmethod_data<T1>* d, casadi_int** iw, T1** w,
+void casadi_sqpmethod_init(casadi_sqpmethod_data<T1>* d,
+    const T1*** arg, T1*** res, casadi_int** iw, T1** w,
     int elastic_mode, int so_corr) {
   // Local variables
   casadi_int nnz_h, nnz_a, nx, ng;
@@ -165,4 +171,8 @@ void casadi_sqpmethod_init(casadi_sqpmethod_data<T1>* d, casadi_int** iw, T1** w
     // Jacobian
     d->Jk = *w; *w += nnz_a;
   }
+  d->arg = *arg;
+  d->res = *res;
+  d->iw = *iw;
+  d->w = *w;
 }

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

@@ -1006,7 +1006,7 @@ namespace casadi {
     /** \brief Propagate sparsity through a linear solve
 
         \identifier{d9} */
-    void spsolve(bvec_t* X, const bvec_t* B, bool tr) const;
+    void spsolve(bvec_t* X, bvec_t* B, bool tr) const;
 #endif // SWIG
 
     /** \brief Get the location of all non-zero elements as they would appear in a Dense matrix
@@ -1199,17 +1199,26 @@ namespace casadi {
   /** \brief Generate a hash value incrementally, array
 
       \identifier{dq} */
-  inline void hash_combine(std::size_t& seed, const casadi_int* v, std::size_t sz) {
+  template<typename T>
+  inline void hash_combine(std::size_t& seed, const T* v, std::size_t sz) {
     for (casadi_int i=0; i<sz; ++i) hash_combine(seed, v[i]);
   }
 
   /** \brief Generate a hash value incrementally (function taken from boost)
 
       \identifier{dr} */
-  inline void hash_combine(std::size_t& seed, const std::vector<casadi_int>& v) {
+  template<typename T>
+  inline void hash_combine(std::size_t& seed, const std::vector<T>& v) {
     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} */

casadi/include/casadi/core/tools.hpp

@@ -0,0 +1,67 @@
+/*
+ *    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_TOOLS_HPP
+#define CASADI_TOOLS_HPP
+
+#include "casadi/core/function.hpp"
+
+namespace casadi {
+
+/** \brief Apply a transformation defined externally
+
+\param name Name of the shared library
+\param op Name of the operation
+\param f Function to transform
+\param opts Options
+
+    \identifier{27i} */
+CASADI_EXPORT Function external_transform(const std::string& name,
+                    const std::string& op,
+                    const Function& f,
+                    const Dict& opts=Dict());
+
+
+typedef void (*external_print_callback_t)(const char* s);
+typedef const char* (*external_transform_t)(char api_version, const char* casadi_version,
+    const char* in,
+    external_print_callback_t cb_stdout, external_print_callback_t cb_stderr);
+
+} // namespace casadi
+
+#ifndef SWIG
+extern "C" {
+  CASADI_EXPORT const char* external_transform_test_success__f(char api_version,
+    const char* casadi_version,
+    const char* in,
+    casadi::external_print_callback_t cb_stdout, casadi::external_print_callback_t cb_stderr);
+  CASADI_EXPORT const char* external_transform_test_fail__f(char api_version,
+    const char* casadi_version,
+    const char* in,
+    casadi::external_print_callback_t cb_stdout, casadi::external_print_callback_t cb_stderr);
+}
+#endif // SWIG
+
+#endif // CASADI_TOOLS_HPP