casadi 3.6.7__cp27-none-manylinux2010_x86_64.whl → 3.7.0__cp27-none-manylinux2010_x86_64.whl

casadi/include/casadi/core/generic_shared_internal.hpp

@@ -0,0 +1,215 @@
+/*
+ *    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_GENERIC_SHARED_INTERNAL_HPP
+#define CASADI_GENERIC_SHARED_INTERNAL_HPP
+
+#include "generic_shared.hpp"
+#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
+#include <memory>
+#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
+
+#ifdef CASADI_WITH_THREAD
+#include <atomic>
+#endif // CASADI_WITH_THREAD
+
+namespace casadi {
+
+  /// \cond INTERNAL
+  /// Internal class for the reference counting framework, see comments on the public class.
+  template<typename Shared, typename Internal>
+  class GenericSharedInternal {
+    friend class GenericShared<Shared, Internal>;
+  public:
+
+    /// Default constructor
+    GenericSharedInternal();
+
+    /// Copy constructor
+    GenericSharedInternal(const GenericSharedInternal& node);
+
+    /// Assignment operator
+    GenericSharedInternal& operator=(const GenericSharedInternal& node);
+
+    /// Destructor
+    virtual ~GenericSharedInternal() = 0;
+
+    /// Get the reference count
+    casadi_int getCount() const;
+
+    std::string debug_repr(const Internal*) const;
+
+    /** \brief Get a weak reference to the object
+
+        \identifier{1ai} */
+    GenericWeakRef<Shared, Internal>* weak();
+
+  protected:
+    /** Called in the constructor of singletons to avoid that the counter reaches zero */
+    void initSingleton() {
+      casadi_assert_dev(static_cast<Internal*>(this)->count==0);
+      static_cast<Internal*>(this)->count++;
+    }
+
+    /** Called in the destructor of singletons */
+    void destroySingleton() {
+      static_cast<Internal*>(this)->count--;
+    }
+
+    /// Get a shared object from the current internal object
+    template<class B>
+    B shared_from_this() {
+      casadi_assert_dev(B::test_cast(static_cast<Internal*>(this)));
+      B ret;
+      ret.own(static_cast<Internal*>(this));
+      return ret;
+    }
+
+    /// Get a shared object from the current internal object
+    template<class B>
+    const B shared_from_this() const {
+      casadi_assert_dev(B::test_cast(static_cast<const Internal*>(this)));
+      B ret;
+      ret.own(const_cast<Internal*>(static_cast<const Internal*>(this)));
+      return ret;
+    }
+
+  private:
+    /// Weak pointer (non-owning) object for the object
+    GenericWeakRef<Shared, Internal>* weak_ref_;
+  };
+
+  template<typename Shared, typename Internal>
+  class GenericWeakRefInternal : public Internal {
+  public:
+    // Constructor
+    GenericWeakRefInternal(Internal* raw);
+
+    // Destructor
+    ~GenericWeakRefInternal() override;
+
+    // Raw pointer to the cached object
+    Internal* raw_;
+
+#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
+    mutable std::shared_ptr<std::mutex> mutex_;
+#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
+  };
+
+
+  template<class A>
+  A getcopy(const A& a,
+             std::map<typename A::base_type*,
+             typename A::internal_base_type> & already_copied) {
+    A ret;
+    if (!a.is_null()) {
+      auto it =
+          already_copied.find(const_cast<typename A::base_type*>(a.get()));
+      if (it!=already_copied.end()) {
+        ret.own(it->second.get());
+      }
+    }
+    return ret;
+  }
+
+  /// \endcond
+
+
+  template<typename Shared, typename Internal>
+  GenericSharedInternal<Shared, Internal>::
+  GenericSharedInternal(const GenericSharedInternal& node) {
+    static_cast<Internal*>(this)->count = 0; // reference counter is _not_ copied
+    weak_ref_ = nullptr; // nor will they have the same weak references
+  }
+
+  template<typename Shared, typename Internal>
+  GenericSharedInternal<Shared, Internal>&
+  GenericSharedInternal<Shared, Internal>::
+  operator=(const GenericSharedInternal<Shared, Internal>& node) {
+    // do _not_ copy the reference counter
+    return *this;
+  }
+
+  template<typename Shared, typename Internal>
+  GenericSharedInternal<Shared, Internal>::GenericSharedInternal() {
+    static_cast<Internal*>(this)->count = 0;
+    weak_ref_ = nullptr;
+  }
+
+  template<typename Shared, typename Internal>
+  std::string GenericSharedInternal<Shared, Internal>::debug_repr(const Internal* i) const {
+    // Note: i != this because of something something multiple inheritance
+    return str( (casadi_int)(i)) + "/" + static_cast<const Internal*>(this)->class_name();
+  }
+
+  template<typename Shared, typename Internal>
+  GenericSharedInternal<Shared, Internal>::~GenericSharedInternal() {
+    #ifdef WITH_REFCOUNT_WARNINGS
+    if (static_cast<Internal*>(this)->count!=0) {
+      // Note that casadi_assert_warning cannot be used in destructors
+      std::cerr << "Reference counting failure." <<
+                   "Possible cause: Circular dependency in user code." << std::endl;
+    }
+    #endif // WITH_REFCOUNT_WARNINGS
+    if (weak_ref_!=nullptr) {
+      // Assumption: no other GenericSharedInternal instances
+      // point to the same WeakRefInternal through weak_ref_
+      weak_ref_->kill();
+      delete weak_ref_;
+      weak_ref_ = nullptr;
+    }
+  }
+
+  template<typename Shared, typename Internal>
+  casadi_int GenericSharedInternal<Shared, Internal>::getCount() const {
+    return static_cast<const Internal*>(this)->count;
+  }
+
+  template<typename Shared, typename Internal>
+  GenericWeakRef<Shared, Internal>* GenericSharedInternal<Shared, Internal>::weak() {
+    if (weak_ref_==nullptr) {
+      weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
+    }
+    return weak_ref_;
+  }
+
+  template<typename Shared, typename Internal>
+  GenericWeakRefInternal<Shared, Internal>::GenericWeakRefInternal(Internal* raw) :
+    raw_(raw)
+#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
+    , mutex_(std::make_shared<std::mutex>())
+#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
+    {
+  }
+
+  template<typename Shared, typename Internal>
+  GenericWeakRefInternal<Shared, Internal>::~GenericWeakRefInternal() {
+  }
+
+
+} // namespace casadi
+
+
+#endif // CASADI_GENERIC_SHARED_INTERNAL_HPP

casadi/include/casadi/core/generic_type.hpp

@@ -303,6 +303,9 @@ namespace casadi {
 
       \identifier{17u} */
   CASADI_EXPORT void update_dict(Dict& target, const Dict& source, bool recurse=false);
+
+  CASADI_EXPORT void update_dict(Dict& target, const std::string& key,
+    const GenericType& value, bool recurse=false);
 #endif
 
 } // namespace casadi

casadi/include/casadi/core/global_options.hpp

@@ -72,6 +72,8 @@ namespace casadi {
 
       static bool julia_initialized;
 
+      static casadi_int copy_elision_min_size;
+
 #endif //SWIG
       // Setter and getter for simplification_on_the_fly
       static void setSimplificationOnTheFly(bool flag) { simplification_on_the_fly = flag; }
@@ -90,6 +92,14 @@ namespace casadi {
       static void setMaxNumDir(casadi_int ndir) { max_num_dir=ndir; }
       static casadi_int getMaxNumDir() { return max_num_dir; }
 
+      static void setCopyElisionMinSize(casadi_int sz) {
+        copy_elision_min_size=sz;
+        if (copy_elision_min_size!=-1 && copy_elision_min_size<2) {
+          copy_elision_min_size = 2;
+        }
+      }
+      static casadi_int getCopyElisionMinSize() { return copy_elision_min_size; }
+
   };
 
 } // namespace casadi

casadi/include/casadi/core/integrator.hpp

@@ -144,36 +144,45 @@ namespace casadi {
       \identifier{7g} */
   CASADI_EXPORT casadi_int integrator_n_out();
 
-  /** \brief Get input scheme of simulators
+  /** \brief Get input scheme of a DAE function
 
       \identifier{25p} */
   CASADI_EXPORT std::vector<std::string> dyn_in();
 
-  /** \brief Get simulator output scheme of simulators
+  /** \brief Get output scheme of a DAE function
 
       \identifier{25q} */
   CASADI_EXPORT std::vector<std::string> dyn_out();
 
-  /** \brief Get simulator input scheme name by index
+  /** \brief Get input scheme of a DAE function by index
 
       \identifier{25r} */
   CASADI_EXPORT std::string dyn_in(casadi_int ind);
 
-  /** \brief Get output scheme name by index
+  /** \brief Get output scheme of a DAE function by index
 
       \identifier{25s} */
   CASADI_EXPORT std::string dyn_out(casadi_int ind);
 
-  /** \brief Get the number of simulator inputs
+  /** \brief Get the number of inputs for a DAE function
 
       \identifier{25t} */
   CASADI_EXPORT casadi_int dyn_n_in();
 
-  /** \brief Get the number of simulator outputs
+  /** \brief Get the number of outputs for a DAE function
 
       \identifier{25u} */
   CASADI_EXPORT casadi_int dyn_n_out();
 
+  /** \brief Get input scheme of an event transition function
+
+      \identifier{2b4} */
+  CASADI_EXPORT std::vector<std::string> event_in();
+
+  /** \brief Get output scheme of an event transition functions
+
+      \identifier{2b5} */
+  CASADI_EXPORT std::vector<std::string> event_out();
   /** @} */
 
 #ifndef SWIG
@@ -186,13 +195,30 @@ enum DynIn {
   DYN_U,
   DYN_NUM_IN};
 
-/// Inputs of the symbolic representation of the DAE
+/// Outputs of the symbolic representation of the DAE
 enum DynOut {
   DYN_ODE,
   DYN_ALG,
   DYN_QUAD,
+  DYN_ZERO,
   DYN_NUM_OUT};
 
+/// Inputs of an event transition function
+enum EventIn {
+  EVENT_INDEX,
+  EVENT_T,
+  EVENT_X,
+  EVENT_Z,
+  EVENT_P,
+  EVENT_U,
+  EVENT_NUM_IN};
+
+/// Outputs of an event transition function
+enum EventOut {
+  EVENT_POST_X,
+  EVENT_POST_Z,
+  EVENT_NUM_OUT};
+
 /// Input arguments of an integrator
 enum IntegratorInput {
   /// Differential state at the initial time
@@ -241,12 +267,20 @@ template<> struct enum_traits<DynIn> {
 template<> struct enum_traits<DynOut> {
   static const size_t n_enum = DYN_NUM_OUT;
 };
+template<> struct enum_traits<EventIn> {
+  static const size_t n_enum = EVENT_NUM_IN;
+};
+template<> struct enum_traits<EventOut> {
+  static const size_t n_enum = EVENT_NUM_OUT;
+};
 ///@}
 
 ///@{
 /// Convert to string
 CASADI_EXPORT std::string to_string(DynIn v);
 CASADI_EXPORT std::string to_string(DynOut v);
+CASADI_EXPORT std::string to_string(EventIn v);
+CASADI_EXPORT std::string to_string(EventOut v);
 ///@}
 
 #endif // SWIG

casadi/include/casadi/core/matrix_decl.hpp

@@ -38,6 +38,13 @@
 #include <typeinfo>
 #include <vector>
 #include <initializer_list>
+#ifdef CASADI_WITH_THREAD
+#ifdef CASADI_WITH_THREAD_MINGW
+#include <mingw.mutex.h>
+#else // CASADI_WITH_THREAD_MINGW
+#include <mutex>
+#endif // CASADI_WITH_THREAD_MINGW
+#endif //CASADI_WITH_THREAD
 
 namespace casadi {
 
@@ -284,6 +291,9 @@ namespace casadi {
                                           const Matrix<Scalar> &x, const Matrix<Scalar> &y);
     static Matrix<Scalar> matrix_matrix(casadi_int op,
                                           const Matrix<Scalar> &x, const Matrix<Scalar> &y);
+    static std::vector< Matrix<Scalar> > call(const Function& f,
+        const std::vector< Matrix<Scalar> > &x);
+    static std::vector< Scalar > call(const Function& f, const std::vector< Scalar > &x);
     ///@}
     /// \endcond
 
@@ -356,6 +366,12 @@ namespace casadi {
                                         const Matrix<Scalar> &x_default,
                                         bool short_circuit=false);
     static bool depends_on(const Matrix<Scalar> &x, const Matrix<Scalar> &arg);
+    static bool contains(const std::vector<Matrix<Scalar> >& v, const Matrix<Scalar> &n);
+    static bool contains_all(const std::vector<Matrix<Scalar> >& v,
+        const std::vector<Matrix<Scalar> > &n);
+    static bool contains_any(const std::vector<Matrix<Scalar> >& v,
+        const std::vector<Matrix<Scalar> > &n);
+
     static Matrix<Scalar> mrdivide(const Matrix<Scalar> &x, const Matrix<Scalar> &y);
     static Matrix<Scalar> mldivide(const Matrix<Scalar> &x, const Matrix<Scalar> &y);
     static std::vector<Matrix<Scalar> > symvar(const Matrix<Scalar> &x);
@@ -417,6 +433,15 @@ namespace casadi {
     static Matrix<Scalar> mac(const Matrix<Scalar> &x,
                                 const Matrix<Scalar> &y,
                                 const Matrix<Scalar> &z);
+    static void extract_parametric(const Matrix<Scalar> &expr,
+        const Matrix<Scalar>& par,
+        Matrix<Scalar>& expr_ret,
+        std::vector<Matrix<Scalar> >& symbols,
+        std::vector<Matrix<Scalar>>& parametric,
+        const Dict& opts);
+    static void separate_linear(const Matrix<Scalar> &expr,
+      const Matrix<Scalar> &sym_lin, const Matrix<Scalar> &sym_const,
+      Matrix<Scalar>& expr_const, Matrix<Scalar>& expr_lin, Matrix<Scalar>& expr_nonlin);
     ///@}
 
     ///@{
@@ -749,6 +774,12 @@ namespace casadi {
      * taylor(sin(x), x)
      * \endcode
      * \verbatim >>   x \endverbatim
+     *
+     * \code
+     * taylor(sin(x),x,x0) -> sin(x0)+cos(x0)*(x-x0)
+     * \endcode
+     *
+     * \sa linearize, mtaylor, linear_coeff
 
         \identifier{23q} */
     friend inline Matrix<Scalar> taylor(const Matrix<Scalar>& ex, const Matrix<Scalar>& x,
@@ -765,6 +796,7 @@ namespace casadi {
      * Do Taylor expansions until the aggregated order of a term is equal to 'order'.
      * The aggregated order of \f$x^n y^m\f$ equals \f$n+m\f$.
      *
+     * \sa taylor
 
         \identifier{23r} */
     friend inline Matrix<Scalar> mtaylor(const Matrix<Scalar>& ex, const Matrix<Scalar>& x,
@@ -796,6 +828,7 @@ namespace casadi {
      * \endcode
      * \f$  (-3 x^2 y-x^3)/6+y+x \f$
      *
+     * \sa taylor
 
         \identifier{23s} */
     friend inline Matrix<Scalar> mtaylor(const Matrix<Scalar>& ex, const Matrix<Scalar>& x,
@@ -978,6 +1011,11 @@ namespace casadi {
         \identifier{19j} */
     Sparsity get_sparsity() const;
 
+    /** \brief  Get an output
+
+        \identifier{28i} */
+    Matrix<Scalar> get_output(casadi_int oind) const;
+
     /** \brief Construct a sparse matrix from triplet form
 
      * Default matrix size is max(col) x max(row)
@@ -1099,6 +1137,31 @@ namespace casadi {
         \identifier{19v} */
     bool is_constant() const;
 
+    /** \brief Check if function call
+
+        \identifier{28j} */
+    bool is_call() const;
+
+    /** \brief  Check if evaluation output
+
+        \identifier{28k} */
+    bool is_output() const;
+
+    /** \brief  Check if a multiple output node
+
+        \identifier{28l} */
+    bool has_output() const;
+
+    /** \brief Get the index of evaluation output - only valid when is_output() is true
+
+        \identifier{28m} */
+    casadi_int which_output() const;
+
+    /** \brief Get function - only valid when is_call() is true
+
+        \identifier{28n} */
+    Function which_function() const;
+
     /** \brief Check if the matrix is integer-valued
 
      * (note that false negative answers are possible)
@@ -1301,6 +1364,10 @@ namespace casadi {
     static Matrix<Scalar> _sym(const std::string& name, const Sparsity& sp);
     /// \endcond
 
+#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
+    static std::mutex& get_mutex_temp();
+#endif //CASADI_WITH_THREADSAFE_SYMBOLICS
+
   private:
     /// Sparsity of the matrix in a compressed column storage (CCS) format
     Sparsity sparsity_;

casadi/include/casadi/core/mx.hpp

@@ -34,6 +34,14 @@
 #include "generic_type.hpp"
 #include "printable.hpp"
 #include <vector>
+#ifdef CASADI_WITH_THREAD
+#ifdef CASADI_WITH_THREAD_MINGW
+#include <mingw.mutex.h>
+#else // CASADI_WITH_THREAD_MINGW
+#include <mutex>
+#endif // CASADI_WITH_THREAD_MINGW
+#endif //CASADI_WITH_THREAD
+
 namespace casadi {
 
   /** \brief  Forward declaration
@@ -122,6 +130,14 @@ namespace casadi {
         \identifier{q5} */
     MX(const Sparsity& sp, const std::string& fname);
 
+
+    /** \brief Construct matrix with a given sparsity and nonzeros,
+
+     * configurable in codegen via a pool
+
+        \identifier{2aa} */
+    MX(const Matrix<double>& val, const std::string& name);
+
     /** \brief  Create scalar constant (also implicit type conversion)
 
         \identifier{q6} */
@@ -188,6 +204,21 @@ namespace casadi {
         \identifier{qd} */
     Sparsity get_sparsity() const { return sparsity();}
 
+    /** \brief Get nonzeros as list of scalar MXes
+    *
+    * Since MX is not a containter, the scalar MXes may be complex
+    * When the expression satisfies is_valid_input, the results may be simple
+    *
+    * For example: 
+    * vertcat(x,y).nonzeros()
+    * will return {x,y}
+    *
+    * \sa expr.nz[:]
+    *
+
+        \identifier{2bh} */
+    std::vector<MX> get_nonzeros() const;
+
     /** \brief Erase a submatrix (leaving structural zeros in its place)
 
         Erase rows and/or columns of a matrix
@@ -611,6 +642,8 @@ namespace casadi {
     static MX conditional(const MX& ind, const std::vector<MX> &x, const MX& x_default,
                           bool short_circuit=false);
     static bool depends_on(const MX& x, const MX& arg);
+    static bool contains_all(const std::vector<MX>& v, const std::vector<MX> &n);
+    static bool contains_any(const std::vector<MX>& v, const std::vector<MX> &n);
     static MX simplify(const MX& x);
     static MX dot(const MX& x, const MX& y);
     static MX mrdivide(const MX& a, const MX& b);
@@ -636,6 +669,11 @@ namespace casadi {
     static MX cumsum(const MX &x, casadi_int axis=-1);
     static MX _logsumexp(const MX& x);
     static std::vector<MX> cse(const std::vector<MX>& e);
+    static void extract_parametric(const MX &expr, const MX& par,
+            MX& expr_ret, std::vector<MX>& symbols, std::vector<MX>& parametric, const Dict& opts);
+    static void separate_linear(const MX &expr,
+      const MX &sym_lin, const MX &sym_const,
+      MX& expr_const, MX& expr_lin, MX& expr_nonlin);
     ///@}
 
     ///@{
@@ -644,9 +682,15 @@ namespace casadi {
     static MX low(const MX& v, const MX& p, const Dict& options = Dict());
     static MX graph_substitute(const MX& x, const std::vector<MX> &v,
                                const std::vector<MX> &vdef);
+    static MX graph_substitute(const MX& x, const std::vector<MX> &v,
+                               const std::vector<MX> &vdef, bool& updated);
+    static std::vector<MX> graph_substitute(const std::vector<MX> &ex,
+                                            const std::vector<MX> &v,
+                                            const std::vector<MX> &vdef);
     static std::vector<MX> graph_substitute(const std::vector<MX> &ex,
-                                            const std::vector<MX> &expr,
-                                            const std::vector<MX> &exprs);
+                                            const std::vector<MX> &v,
+                                            const std::vector<MX> &vdef,
+                                            bool& updated);
     static MX matrix_expand(const MX& e, const std::vector<MX> &boundary,
                             const Dict& options);
     static std::vector<MX> matrix_expand(const std::vector<MX>& e,
@@ -724,6 +768,11 @@ namespace casadi {
       return MX::graph_substitute(ex, v, vdef);
     }
 
+    inline friend MX graph_substitute(const MX& ex, const std::vector<MX> &v,
+                                      const std::vector<MX> &vdef, bool& updated) {
+      return MX::graph_substitute(ex, v, vdef, updated);
+    }
+
     /** \brief Substitute multiple expressions in graph
 
      * Substitute variable var with expression expr in
@@ -737,6 +786,14 @@ namespace casadi {
       return MX::graph_substitute(ex, v, vdef);
     }
 
+    inline friend std::vector<MX>
+      graph_substitute(const std::vector<MX> &ex,
+                       const std::vector<MX> &v,
+                       const std::vector<MX> &vdef,
+                       bool& updated) {
+      return MX::graph_substitute(ex, v, vdef, updated);
+    }
+
     /** \brief Expand MX graph to SXFunction call
      *
      *  Expand the given expression e, optionally
@@ -928,6 +985,10 @@ namespace casadi {
     // Create matrix symbolic primitive
     static MX _sym(const std::string& name, const Sparsity& sp);
 
+#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
+    static std::mutex& get_mutex_temp() { return mutex_temp; }
+    static std::mutex mutex_temp;
+#endif //CASADI_WITH_THREADSAFE_SYMBOLICS
   private:
 
     /// Create an expression from a node: extra dummy arguments to avoid ambiguity for 0/NULL

casadi/include/casadi/core/options.hpp

@@ -30,7 +30,6 @@
 
 namespace casadi {
 /// \cond INTERNAL
-#ifndef SWIG
 
   /** \brief Options metadata for a class
 
@@ -39,6 +38,7 @@ namespace casadi {
 
       \identifier{x9} */
   struct CASADI_EXPORT Options {
+#ifndef SWIG
     // Base classes, whose options are also valid for the derived class
     std::vector<const Options*> bases;
 
@@ -57,6 +57,8 @@ namespace casadi {
     // Locate an entry
     const Options::Entry* find(const std::string& name) const;
 
+#endif // SWIG
+
     // Get all entries
     std::vector<std::string> all() const;
 
@@ -66,8 +68,10 @@ namespace casadi {
     // Get description for an entry
     std::string info(const std::string& name) const;
 
+#ifndef SWIG
     // Print all entries
     void disp(std::ostream& stream) const;
+#endif // SWIG
 
     /** \brief A distance metric between two words
 
@@ -95,7 +99,7 @@ namespace casadi {
     static bool is_sane(const Dict& opts);
 
     /// Sanitize a options dictionary
-    static Dict sanitize(const Dict& opts);
+    static Dict sanitize(const Dict& opts, bool top_level=true);
 
     /// Check if options exist
     void check(const Dict& opts) const;
@@ -111,7 +115,6 @@ namespace casadi {
     void print_one(const std::string &name, std::ostream &stream) const;
   };
 
-#endif // SWIG
   /// \endcond
 } // namespace casadi