casadi 3.6.3__cp35-none-manylinux1_i686.whl → 3.6.5__cp35-none-manylinux1_i686.whl

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

@@ -29,6 +29,8 @@
 #include <set>
 #include <sstream>
 #include <unordered_map>
+#include <cstdint>
+#include <climits>
 
 namespace casadi {
   class Slice;
@@ -39,6 +41,7 @@ namespace casadi {
   class SXElem;
   class GenericType;
   class Importer;
+  class Fmu;
   class SharedObject;
   class SharedObjectInternal;
   class SXNode;
@@ -90,10 +93,15 @@ namespace casadi {
     }
     void unpack(Function& e);
     void unpack(Importer& e);
+    void unpack(Fmu& e);
     void unpack(GenericType& e);
     void unpack(std::ostream& s);
     void unpack(Slice& e);
     void unpack(int& e);
+
+#if SIZE_MAX != UINT_MAX
+    void unpack(unsigned int& e);
+#endif
     void unpack(bool& e);
     void unpack(casadi_int& e);
     void unpack(size_t& e);
@@ -223,10 +231,14 @@ namespace casadi {
     }
     void pack(const Function& e);
     void pack(const Importer& e);
+    void pack(const Fmu& e);
     void pack(const Slice& e);
     void pack(const GenericType& e);
     void pack(std::istream& s);
     void pack(int e);
+#if SIZE_MAX != UINT_MAX
+    void pack(unsigned int e);
+#endif
     void pack(bool e);
     void pack(casadi_int e);
     void pack(size_t 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,14 +1199,16 @@ 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());
   }
 

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