casadi 3.6.4__cp312-none-manylinux2014_x86_64.whl → 3.6.5__cp312-none-manylinux2014_x86_64.whl

casadi/cmake/casadi-config-version.cmake

@@ -1,4 +1,4 @@
-set(PACKAGE_VERSION "3.6.4")
+set(PACKAGE_VERSION "3.6.5")
 
 # Check whether the requested PACKAGE_FIND_VERSION is compatible
 if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")

casadi/include/casadi/casadi.i

@@ -80,6 +80,19 @@
       return PyErr_CheckSignals();
     }
 
+    std::string python_string_to_std_string(PyObject *str_py) {
+#if SWIG_VERSION < 0x040200
+      const char *str_char = SWIG_Python_str_AsChar(str_py);
+      std::string str(str_char);
+      SWIG_Python_str_DelForPy3(str_char);
+#else
+      PyObject *bytes = NULL;
+      std::string str(SWIG_PyUnicode_AsUTF8AndSize(str_py, NULL, &bytes));
+      Py_XDECREF(bytes);
+#endif
+      return str;
+    }
+
     void handle_director_exception() {
 	    std::string msg = "Exception in SWIG director ";
       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
@@ -91,9 +104,7 @@
       PyObject *ptype, *pvalue, *ptraceback;
       PyErr_Fetch(&ptype, &pvalue, &ptraceback);
       PyObject* msg_py = PyObject_Str(pvalue);
-      char *msg_char = SWIG_Python_str_AsChar(msg_py);
-      msg = msg_char;
-      SWIG_Python_str_DelForPy3(msg_char);
+      msg = python_string_to_std_string(msg_py);
       Py_DECREF(msg_py);
       PyErr_Restore(ptype, pvalue, ptraceback);
       PyErr_Print();
@@ -1441,11 +1452,15 @@ namespace std {
           || to_generic<std::vector<double> >(p, m)
           || to_generic<std::vector<bool> >(p, m)
           || to_generic<std::vector<std::string> >(p, m)
+          || to_generic<std::vector<std::vector<std::string> > >(p, m)
           || to_generic<std::vector<std::vector<casadi_int> > >(p, m)
           || to_generic<std::vector<std::vector<double> > >(p, m)
           || to_generic<casadi::Function>(p, m)
           || to_generic<std::vector<casadi::Function> >(p, m)
-          || to_generic<casadi::GenericType::Dict>(p, m)) {
+          || to_generic<casadi::GenericType::Dict>(p, m)
+          || to_generic<std::vector<casadi::GenericType::Dict> >(p, m)
+          || to_generic<std::vector<std::vector<casadi::GenericType> > >(p, m)
+          || to_generic<std::vector<casadi::GenericType> >(p, m)) {
         return true;
       }
 
@@ -1468,7 +1483,11 @@ namespace std {
       case OT_DOUBLEVECTOR: return from_tmp(a->as_double_vector());
       case OT_DOUBLEVECTORVECTOR: return from_tmp(a->as_double_vector_vector());
       case OT_STRINGVECTOR: return from_tmp(a->as_string_vector());
+      case OT_STRINGVECTORVECTOR: return from_tmp(a->as_string_vector_vector());
       case OT_DICT: return from_tmp(a->as_dict());
+      case OT_DICTVECTOR: return from_tmp(a->as_dict_vector());
+      case OT_VECTORVECTOR: return from_tmp(a->as_vector_vector());
+      case OT_VECTOR: return from_tmp(a->as_vector());
       case OT_FUNCTION: return from_tmp(a->as_function());
       case OT_FUNCTIONVECTOR: return from_tmp(a->as_function_vector());
 #ifdef SWIGPYTHON
@@ -1500,10 +1519,10 @@ namespace std {
 
 #ifdef SWIGPYTHON
       if (PyString_Check(p) || PyUnicode_Check(p)) {
-        if (m) (*m)->clear();
-        char* my_char = SWIG_Python_str_AsChar(p);
-        if (m) (*m)->append(my_char);
-        SWIG_Python_str_DelForPy3(my_char);
+        if (m) {
+          (*m)->clear();
+          (*m)->append(python_string_to_std_string(p));
+        }
         return true;
       }
 #endif // SWIGPYTHON
@@ -1594,9 +1613,7 @@ namespace std {
         while (PyDict_Next(p, &pos, &key, &value)) {
           if (!(PyString_Check(key) || PyUnicode_Check(key))) return false;
           if (m) {
-            char* c_key = SWIG_Python_str_AsChar(key);
-            M *v=&(**m)[std::string(c_key)], *v2=v;
-            SWIG_Python_str_DelForPy3(c_key);
+            M *v=&(**m)[python_string_to_std_string(key)], *v2=v;
             if (!casadi::to_ptr(value, &v)) return false;
             if (v!=v2) *v2=*v; // if only pointer changed
           } else {
@@ -1857,11 +1874,8 @@ namespace std {
       PyObject * classo = PyObject_GetAttrString( p, "__class__");
       PyObject * classname = PyObject_GetAttrString( classo, "__name__");
 
-      char* c_classname = SWIG_Python_str_AsChar(classname);
-      bool ret = strcmp(c_classname, name)==0;
-
+      bool ret = python_string_to_std_string(classname) == name;
       Py_DECREF(classo);Py_DECREF(classname);
-      SWIG_Python_str_DelForPy3(c_classname);
       return ret;
     }
 #endif // SWIGPYTHON
@@ -4420,6 +4434,7 @@ namespace casadi {
 %include <casadi/core/casadi_meta.hpp>
 %include <casadi/core/integration_tools.hpp>
 %include <casadi/core/nlp_tools.hpp>
+%include <casadi/core/tools.hpp>
 %include <casadi/core/nlp_builder.hpp>
 %include <casadi/core/dae_builder.hpp>
 %include <casadi/core/xml_file.hpp>

casadi/include/casadi/config.h

@@ -26,16 +26,16 @@
 
 #define CASADI_MAJOR_VERSION 3
 #define CASADI_MINOR_VERSION 6
-#define CASADI_PATCH_VERSION 4
+#define CASADI_PATCH_VERSION 5
 #define CASADI_IS_RELEASE 1
-#define CASADI_VERSION_STRING "3.6.4"
-#define CASADI_GIT_REVISION "329e2282664f584b17fd6319f8ce765a111a6022"  // NOLINT(whitespace/line_length)
-#define CASADI_GIT_DESCRIBE "3.6.3-116.329e22826"  // NOLINT(whitespace/line_length)
+#define CASADI_VERSION_STRING "3.6.5"
+#define CASADI_GIT_REVISION "3d820e62cb588e76498c92bf6feff6876b4e7ca0"  // NOLINT(whitespace/line_length)
+#define CASADI_GIT_DESCRIBE "3.6.3-175.3d820e62c"  // NOLINT(whitespace/line_length)
 #define CASADI_FEATURE_LIST "\n * dynamic-loading, Support for import of FMI 2.0 binaries\n * sundials-interface, Interface to the ODE/DAE integrator suite SUNDIALS.\n * csparse-interface, Interface to the sparse direct linear solver CSparse.\n * superscs-interface, Interface to QP solver SUPERSCS.\n * osqp-interface, Interface to QP solver OSQP.\n * tinyxml-interface, Interface to the XML parser TinyXML.\n * qpoases-interface, Interface to the active-set QP solver qpOASES.\n * blocksqp-interface, Interface to the NLP solver blockSQP.\n * cplex-mockup-build, Use mockup CPLEX (BUILD_MOCKUPS_VERSION=v65) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).\n * snopt-mockup-build, Use mockup SNOPT (BUILD_MOCKUPS_VERSION=v65) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).\n * knitro-mockup-build, Use mockup KNITRO (BUILD_MOCKUPS_VERSION=v65) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).\n * gurobi-mockup-build, Use mockup GUROBI (BUILD_MOCKUPS_VERSION=v65) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).\n * worhp-mockup-build, Use mockup WORHP (BUILD_MOCKUPS_VERSION=v65) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).\n * hsl-mockup-build, Use mockup WORHP (BUILD_MOCKUPS_VERSION=v65) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).\n * alpaqa-sourcebuild, Build Alpaqa (BUILD_ALPAQA_VERSION=develop) from downloaded source (BUILD_ALPAQA_GIT_REPO=https://github.com/jgillis/alpaqa).\n * highs-sourcebuild, Build HiGHS (BUILD_HIGHS_VERSION=v1.6.0) from downloaded source (BUILD_HIGHS_GIT_REPO=https://github.com/ERGO-Code/HiGHS).\n * proxqp-sourcebuild, Build PROXQP (BUILD_PROXQP_VERSION=v0.3.2) from downloaded source (BUILD_PROXQP_GIT_REPO=https://github.com/Simple-Robotics/proxsuite.git).\n * osqp-sourcebuild, Build OSQP (BUILD_OSQP_VERSION=v0.6.2) from downloaded source (BUILD_OSQP_GIT_REPO=https://github.com/osqp/osqp.git).\n * superscs-sourcebuild, Build SuperSCS (BUILD_SUPERSCS_VERSION=4d2d1bd03ed4cf93e684a880b233760ce34ca69c) from downloaded source (BUILD_SUPERSCS_GIT_REPO=https://github.com/jgillis/scs.git).\n * sleqp-sourcebuild, Build SLEQP (BUILD_SLEQP_VERSION=patch-1) from downloaded source (BUILD_SLEQP_GIT_REPO=https://github.com/jgillis/sleqp.git).\n * bonmin-sourcebuild, Build BONMIN (BUILD_BONMIN_VERSION=releases/1.8.9) from downloaded source (BUILD_BONMIN_GIT_REPO=https://github.com/coin-or/Bonmin.git).\n * ipopt-sourcebuild, Build IPOPT (BUILD_IPOPT_VERSION=3.14.11.mod) from downloaded source (BUILD_IPOPT_GIT_REPO=https://github.com/jgillis/Ipopt-1.git).\n * cbc-sourcebuild, Build CBC (BUILD_CBC_VERSION=releases/2.10.11) from downloaded source.\n * clp-sourcebuild, Build CLP (BUILD_CLP_VERSION=releases/1.17.9) from downloaded source (BUILD_CLP_GIT_REPO=https://github.com/coin-or/Clp.git).\n * mumps-sourcebuild, Build MUMPS (BUILD_MUMPS_TP_VERSION=releases/3.0.2) from downloaded source (BUILD_MUMPS_TP_GIT_REPO=https://github.com/coin-or-tools/ThirdParty-Mumps.git).\n * spral-sourcebuild, Build SPRAL (BUILD_SPRAL_VERSION=d385d2c9e858366d257cafaaf05760ffa6543e26) from downloaded source (BUILD_SPRAL_GIT_REPO=https://github.com/ralna/spral.git).\n * metis-sourcebuild, Build METIS (BUILD_METIS_TP_VERSION=releases/2.0.0) from downloaded source.\n * hpipm-sourcebuild, Build HPIPM (BUILD_HPIPM_VERSION=0e0c9f4e0d4081dceafa9b37c396db50bce0e81a) from downloaded source (BUILD_HPIPM_GIT_REPO=https://github.com/jgillis/hpipm.git).\n * trlib-sourcebuild, Build TRLIB (BUILD_TRLIB_VERSION=c7632b8b14152e78bc21721a3bd1a2432586b824) from downloaded source (BUILD_TRLIB_GIT_REPO=https://github.com/jgillis/trlib.git).\n * blasfeo-sourcebuild, Build BLASFEO (BUILD_BLASFEO_VERSION=edf92b396adddd9e548b9786f87ad290a0971329) from downloaded source (BUILD_BLASFEO_GIT_REPO=https://github.com/giaf/blasfeo.git).\n * lapack-sourcebuild, Download and install OpenBLAS for LAPACK+BLAS\n * eigen3-sourcebuild, Build Eigen (BUILD_EIGEN3_VERSION=3.4.0) from downloaded source (BUILD_EIGEN3_GIT_REPO=https://gitlab.com/libeigen/eigen.git).\n * simde-sourcebuild, Build Simde (BUILD_SIMDE_VERSION=v0.7.2) from downloaded source (BUILD_SIMDE_GIT_REPO=https://github.com/simd-everywhere/simde.git).\n * cplex-interface, Interface to the QP solver CPLEX.\n * gurobi-interface, Interface to the (mixed-integer) QP solver GUROBI\n * knitro-interface, Interface to the NLP solver KNITRO.\n * snopt-interface, Interface to the NLP solver KNITRO.\n * worhp-interface, Interface to the NLP solver Worhp (requires gfortran, gomp).\n * lapack-interface, Interface to LAPACK.\n * mumps-interface, Interface to MUMPS.\n * spral-interface, Interface to SPRAL.\n * coinutils-sourcebuild, Build COINUTILS (BUILD_COINUTILS_VERSION=releases/2.11.10) from downloaded source.\n * osi-sourcebuild, Build OSI (BUILD_OSI_VERSION=releases/0.108.9) from downloaded source.\n * clp-interface, Interface to the LP solver CLP.\n * cgl-sourcebuild, Build CGL (BUILD_CGL_VERSION=releases/0.60.8) from downloaded source.\n * cbc-interface, Interface to the LP solver CBC.\n * ipopt-interface, Interface to the NLP solver Ipopt.\n * bonmin-interface, Interface to the MINLP framework Bonmin.\n * highs-interface, Interface to the MILP / QP solver HiGHS.\n * sleqp-interface, Interface to the NLP solver SLEQP.\n * alpaqa-interface, Interface to the NLP solver Alpaqa.\n * proxqp-interface, Interface to QP solver PROXQP.\n * ampl-interface, Interface to the AMPL solver library.\n"  // NOLINT(whitespace/line_length)
 #define CASADI_BUILD_TYPE "Release"  // NOLINT(whitespace/line_length)
 #define CASADI_COMPILER_ID "GNU"  // NOLINT(whitespace/line_length)
 #define CASADI_COMPILER "/opt/rh/devtoolset-10/root/usr/bin/g++"  // NOLINT(whitespace/line_length)
-#define CASADI_COMPILER_FLAGS " -pthread -fPIC    -DUSE_CXX11 -DHAVE_MKSTEMPS -DCASADI_WITH_THREAD -DWITH_DEEPBIND -DCASADI_MAJOR_VERSION=3 -DCASADI_MINOR_VERSION=6 -DCASADI_PATCH_VERSION=4 -DCASADI_IS_RELEASE=1 -DCASADI_VERSION=31 -D_USE_MATH_DEFINES -D_SCL_SECURE_NO_WARNINGS -DWITH_DL -DWITH_DEPRECATED_FEATURES -DCASADI_DEFAULT_COMPILER_PLUGIN=shell"  // NOLINT(whitespace/line_length)
+#define CASADI_COMPILER_FLAGS " -pthread -fPIC    -DUSE_CXX11 -DHAVE_MKSTEMPS -DCASADI_WITH_THREAD -DWITH_DEEPBIND -DCASADI_MAJOR_VERSION=3 -DCASADI_MINOR_VERSION=6 -DCASADI_PATCH_VERSION=5 -DCASADI_IS_RELEASE=1 -DCASADI_VERSION=31 -D_USE_MATH_DEFINES -D_SCL_SECURE_NO_WARNINGS -DWITH_DL -DWITH_DEPRECATED_FEATURES -DCASADI_DEFAULT_COMPILER_PLUGIN=shell"  // NOLINT(whitespace/line_length)
 #define CASADI_MODULES "casadi;casadi_linsol_lapacklu;casadi_linsol_lapackqr;casadi_sundials_common;casadi_integrator_cvodes;casadi_integrator_idas;casadi_rootfinder_kinsol;casadi_nlpsol_sleqp;casadi_nlpsol_ipopt;casadi_nlpsol_bonmin;casadi_conic_qpoases;casadi_nlpsol_knitro;casadi_conic_cplex;casadi_conic_clp;casadi_conic_cbc;casadi_linsol_csparse;casadi_linsol_csparsecholesky;casadi_conic_highs;casadi_linsol_ma27;casadi_linsol_mumps;casadi_conic_gurobi;casadi_nlpsol_worhp;casadi_nlpsol_snopt;casadi_xmlfile_tinyxml;casadi_nlpsol_blocksqp;casadi_conic_hpipm;casadi_conic_superscs;casadi_nlpsol_ampl;casadi_conic_proxqp;casadi_conic_osqp;casadi_nlpsol_alpaqa;casadi_conic_nlpsol;casadi_conic_qrqp;casadi_conic_ipqp;casadi_nlpsol_qrsqp;casadi_importer_shell;casadi_integrator_rk;casadi_integrator_collocation;casadi_interpolant_linear;casadi_interpolant_bspline;casadi_linsol_symbolicqr;casadi_linsol_qr;casadi_linsol_ldl;casadi_linsol_tridiag;casadi_linsol_lsqr;casadi_nlpsol_sqpmethod;casadi_nlpsol_feasiblesqpmethod;casadi_nlpsol_scpgen;casadi_rootfinder_newton;casadi_rootfinder_fast_newton;casadi_rootfinder_nlpsol"  // NOLINT(whitespace/line_length)
 #define CASADI_PLUGINS "Linsol::lapacklu;Linsol::lapackqr;Integrator::cvodes;Integrator::idas;Rootfinder::kinsol;Nlpsol::sleqp;Nlpsol::ipopt;Nlpsol::bonmin;Conic::qpoases;Nlpsol::knitro;Conic::cplex;Conic::clp;Conic::cbc;Linsol::csparse;Linsol::csparsecholesky;Conic::highs;Linsol::ma27;Linsol::mumps;Conic::gurobi;Nlpsol::worhp;Nlpsol::snopt;XmlFile::tinyxml;Nlpsol::blocksqp;Conic::hpipm;Conic::superscs;Nlpsol::ampl;Conic::proxqp;Conic::osqp;Nlpsol::alpaqa;Conic::nlpsol;Conic::qrqp;Conic::ipqp;Nlpsol::qrsqp;Importer::shell;Integrator::rk;Integrator::collocation;Interpolant::linear;Interpolant::bspline;Linsol::symbolicqr;Linsol::qr;Linsol::ldl;Linsol::tridiag;Linsol::lsqr;Nlpsol::sqpmethod;Nlpsol::feasiblesqpmethod;Nlpsol::scpgen;Rootfinder::newton;Rootfinder::fast_newton;Rootfinder::nlpsol"  // NOLINT(whitespace/line_length)
 #define CASADI_INSTALL_PREFIX "/usr/local"  // NOLINT(whitespace/line_length)

casadi/include/casadi/core/code_generator.hpp

@@ -103,6 +103,11 @@ namespace casadi {
         \identifier{ry} */
     casadi_int get_constant(const std::vector<casadi_int>& v, bool allow_adding=false);
 
+    /** \brief Get or add a char constant
+
+        \identifier{27l} */
+    casadi_int get_constant(const std::vector<char>& v, bool allow_adding=false);
+
     /** \brief Represent an array constant; adding it when new
 
         \identifier{rz} */
@@ -128,6 +133,11 @@ namespace casadi {
         \identifier{s1} */
     std::string constant(const std::vector<double>& v);
 
+    /** \brief Represent an array constant; adding it when new
+
+        \identifier{27m} */
+    std::string constant(const std::vector<char>& v);
+
     /** \brief Allocate file scope double read-only memory
 
         \identifier{s2} */
@@ -153,7 +163,7 @@ namespace casadi {
         \identifier{s6} */
     std::string operator()(const Function& f, const std::string& arg,
                            const std::string& res, const std::string& iw,
-                           const std::string& w);
+                           const std::string& w, const std::string& failure_ret="1");
 
     /** \brief Print a string to buffer
 
@@ -232,6 +242,7 @@ namespace casadi {
         \identifier{sk} */
     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);
 
     /** \brief Sanitize source files for codegen
 
@@ -634,6 +645,12 @@ namespace casadi {
     void print_vector(std::ostream &s, const std::string& name,
                              const std::vector<casadi_int>& v);
 
+    /** \brief  Print char vector to a c file
+
+        \identifier{27n} */
+    void print_vector(std::ostream &s, const std::string& name,
+                             const std::vector<char>& v);
+
     /** \brief  Print real vector to a c file
 
         \identifier{ts} */
@@ -810,6 +827,9 @@ namespace casadi {
     bool with_sfunction;
     std::vector<std::string> added_sfunctions;
 
+    // Unroll arguments?
+    bool unroll_args;
+
     // Verbose codegen?
     bool verbose;
 
@@ -874,6 +894,7 @@ namespace casadi {
     std::multimap<Auxiliary, std::vector<std::string>> added_auxiliaries_;
     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::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_;
@@ -888,9 +909,13 @@ namespace casadi {
     };
     std::vector<FunctionMeta> added_functions_;
 
+    // Counters for creating unique identifiers
+    std::map<std::string, std::map<FunctionInternal*, casadi_int> > added_wrappers_;
+
     // Constants
     std::vector<std::vector<double> > double_constants_;
     std::vector<std::vector<casadi_int> > integer_constants_;
+    std::vector<std::vector<char> > char_constants_;
 
     // Does any function need thread-local memory?
     bool needs_mem_;
@@ -898,6 +923,9 @@ namespace casadi {
     // Hash a vector
     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);
+
+    std::string wrapper(const Function& base, const std::string& name);
 
     // Compare two vectors
     template<typename T>

casadi/include/casadi/core/core.hpp

@@ -65,5 +65,6 @@
 #include "xml_file.hpp"
 #include "optistack.hpp"
 #include "serializer.hpp"
+#include "tools.hpp"
 
 #endif // CASADI_CORE_HPP

casadi/include/casadi/core/generic_expression.hpp

@@ -170,7 +170,7 @@ class GenericExpression : public GenericExpressionCommon {
   ///@}
 
   ///@{
-  /** \brief Logical greater or equal to: (x,y) -> x <= y
+  /** \brief Logical greater or equal to: (x,y) -> x >= y
 
       \identifier{ou} */
   static ExType ge(const ExType &x, const ExType &y) {

casadi/include/casadi/core/generic_type.hpp

@@ -56,7 +56,11 @@ namespace casadi {
     OT_FUNCTION,
     OT_FUNCTIONVECTOR,
     OT_VOIDPTR,
-    OT_UNKNOWN};
+    OT_UNKNOWN,
+    OT_STRINGVECTORVECTOR,
+    OT_DICTVECTOR,
+    OT_VECTORVECTOR,
+    OT_VECTOR};
 #endif // SWIG
 
   /** \brief Generic data type, can hold different types such as bool, casadi_int, std::string etc.
@@ -93,10 +97,14 @@ namespace casadi {
     GenericType(const std::vector<double>& dv);
     GenericType(const std::vector< std::vector<double> >& dv);
     GenericType(const std::vector<std::string>& sv);
+    GenericType(const std::vector<std::vector<std::string> >& sv);
     GenericType(const char s[]);
     GenericType(const Function& f);
     GenericType(const std::vector<Function>& f);
     GenericType(const Dict& dict);
+    GenericType(const std::vector<Dict>& dictv);
+    GenericType(const std::vector<std::vector<GenericType> >& gvv);
+    GenericType(const std::vector<GenericType>& gv);
     GenericType(void* ptr);
 
     /// Public class name
@@ -140,9 +148,13 @@ namespace casadi {
       return to_double_vector_vector();
     }
     operator std::vector<std::string>() const { return to_string_vector();}
+    operator std::vector<std::vector<std::string> >() const { return to_string_vector_vector();}
     operator const Function&() const { return as_function();}
     operator const std::vector<Function>&() const { return as_function_vector();}
     operator const Dict&() const { return as_dict();}
+    operator const std::vector<Dict>&() const { return as_dict_vector();}
+    operator const std::vector<std::vector<GenericType> >&() const { return as_vector_vector();}
+    operator const std::vector<GenericType>&() const { return as_vector();}
     ///@}
 
     bool can_cast_to(TypeID other) const;
@@ -169,7 +181,11 @@ namespace casadi {
     bool is_double_vector_vector() const;
     bool is_bool_vector() const;
     bool is_string_vector() const;
+    bool is_string_vector_vector() const;
     bool is_dict() const;
+    bool is_dict_vector() const;
+    bool is_vector_vector() const;
+    bool is_vector() const;
     bool is_function() const;
     bool is_function_vector() const;
     bool is_void_pointer() const;
@@ -189,7 +205,11 @@ namespace casadi {
     const std::vector<double>& as_double_vector() const;
     const std::vector< std::vector<double> >& as_double_vector_vector() const;
     const std::vector<std::string>& as_string_vector() const;
+    const std::vector<std::vector<std::string> >& as_string_vector_vector() const;
     const Dict& as_dict() const;
+    const std::vector<Dict>& as_dict_vector() const;
+    const std::vector<std::vector< GenericType> >& as_vector_vector() const;
+    const std::vector<GenericType>& as_vector() const;
     const Function& as_function() const;
     const std::vector<Function>& as_function_vector() const;
     void* const & as_void_pointer() const;
@@ -207,7 +227,11 @@ namespace casadi {
     std::vector<double> to_double_vector() const;
     std::vector< std::vector<double> > to_double_vector_vector() const;
     std::vector<std::string> to_string_vector() const;
+    std::vector<std::vector<std::string> > to_string_vector_vector() const;
     Dict to_dict() const;
+    std::vector<Dict> to_dict_vector() const;
+    std::vector<GenericType> to_vector() const;
+    std::vector< std::vector< GenericType> > to_vector_vector() const;
     Function to_function() const;
     std::vector<Function> to_function_vector() const;
     void* to_void_pointer() const;

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/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]
@@ -147,3 +150,125 @@ 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) {
+  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])/fabs(d_bounds->a[k]);
+      T1 ub = (d_nlp->ubg[i]-d_bounds->b[k])/fabs(d_bounds->a[k]);
+      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];
+    }
+  }
+  return 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/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