casadi 3.6.4__cp312-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/casadi/core/generic_type.hpp

@@ -0,0 +1,287 @@
+/*
+ *    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_TYPE_HPP
+#define CASADI_GENERIC_TYPE_HPP
+
+#include "shared_object.hpp"
+#include "printable.hpp"
+#include "casadi_common.hpp"
+#include <string>
+#include <vector>
+
+namespace casadi {
+  class SerializingStream;
+  class DeserializingStream;
+#if !(defined(SWIG) && !defined(SWIGXML))
+
+  /** \brief  Types of options
+
+      \identifier{17m} */
+  enum TypeID {
+    OT_NULL,
+    OT_BOOL,
+    OT_INT,
+    OT_DOUBLE,
+    OT_STRING,
+    OT_INTVECTOR,
+    OT_INTVECTORVECTOR,
+    OT_BOOLVECTOR,
+    OT_DOUBLEVECTOR,
+    OT_DOUBLEVECTORVECTOR,
+    OT_STRINGVECTOR,
+    OT_DICT,
+    OT_FUNCTION,
+    OT_FUNCTIONVECTOR,
+    OT_VOIDPTR,
+    OT_UNKNOWN};
+#endif // SWIG
+
+  /** \brief Generic data type, can hold different types such as bool, casadi_int, std::string etc.
+
+      \author Joel Andersson
+      \date 2010
+
+      \identifier{17n} */
+  class CASADI_EXPORT GenericType
+    : public SWIG_IF_ELSE(PrintableCommon, Printable<GenericType>)
+#if !(defined(SWIG) && !defined(SWIGXML))
+    , public SharedObject
+#endif // SWIG
+  {
+  public:
+    /// C++ equivalent of Python's dict or MATLAB's struct
+    typedef std::map<std::string, GenericType> Dict;
+
+#if !(defined(SWIG) && !defined(SWIGXML))
+
+    /// Default constructor
+    GenericType();
+
+    /// Constructors (implicit type conversion)
+    GenericType(bool b);
+    GenericType(casadi_int i);
+    GenericType(int i) : GenericType(static_cast<casadi_int>(i)) {}
+    GenericType(double d);
+    GenericType(const std::string& s);
+    GenericType(const std::vector<bool>& iv);
+    GenericType(const std::vector<casadi_int>& iv);
+    GenericType(const std::vector<int>& iv);
+    GenericType(const std::vector< std::vector<casadi_int> >& ivv);
+    GenericType(const std::vector<double>& dv);
+    GenericType(const std::vector< std::vector<double> >& dv);
+    GenericType(const std::vector<std::string>& sv);
+    GenericType(const char s[]);
+    GenericType(const Function& f);
+    GenericType(const std::vector<Function>& f);
+    GenericType(const Dict& dict);
+    GenericType(void* ptr);
+
+    /// Public class name
+    static std::string type_name() {return "GenericType";}
+
+#ifndef SWIG
+    /// Get a description of a type
+    static std::string get_type_description(TypeID type);
+#endif
+
+    /// \cond INTERNAL
+#ifndef SWIG
+    /** \brief  Create from node
+
+        \identifier{17o} */
+    static GenericType create(SharedObjectInternal* node);
+#endif // SWIG
+    /// \endcond
+
+    /// Get a description of the object's type
+    std::string get_description() const { return get_type_description(getType()); }
+
+    /// Construct a GenericType given an TypeID
+#ifndef SWIG
+    static GenericType from_type(TypeID type);
+
+    ///@{
+    /// Implicit typecasting
+    operator bool() const { return to_bool();}
+    operator casadi_int() const { return to_int();}
+    operator int() const { return to_int();}
+    operator double() const { return to_double();}
+    operator std::string() const { return to_string();}
+    operator std::vector<bool>() const { return to_bool_vector();}
+    operator std::vector<casadi_int>() const { return to_int_vector();}
+    operator std::vector<int>() const;
+    operator std::vector<std::vector<casadi_int> >() const { return to_int_vector_vector();}
+    operator std::vector<std::vector<int> >() const;
+    operator std::vector<double>() const { return to_double_vector();}
+    operator std::vector< std::vector<double> >() const {
+      return to_double_vector_vector();
+    }
+    operator std::vector<std::string>() const { return to_string_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();}
+    ///@}
+
+    bool can_cast_to(TypeID other) const;
+    bool can_cast_to(const GenericType& other) const { return can_cast_to(other.getType()) ;}
+#endif
+
+#if !(defined(SWIG) && !defined(SWIGXML))
+    // Get type of object
+    TypeID getType() const;
+#endif
+
+    ///@{
+    /** \brief Check if a particular type
+
+        \identifier{17p} */
+    bool is_bool() const;
+    bool is_int() const;
+    bool is_double() const;
+    bool is_string() const;
+    bool is_empty_vector() const;
+    bool is_int_vector() const;
+    bool is_int_vector_vector() const;
+    bool is_double_vector() const;
+    bool is_double_vector_vector() const;
+    bool is_bool_vector() const;
+    bool is_string_vector() const;
+    bool is_dict() const;
+    bool is_function() const;
+    bool is_function_vector() const;
+    bool is_void_pointer() const;
+    ///@}
+
+    ///@{
+    /** \brief Cast to the internal type
+
+        \identifier{17q} */
+    const bool& as_bool() const;
+    const casadi_int& as_int() const;
+    const double& as_double() const;
+    const std::string& as_string() const;
+    const std::vector<casadi_int>& as_int_vector() const;
+    const std::vector<casadi_int>& as_bool_vector() const;
+    const std::vector<std::vector<casadi_int> >& as_int_vector_vector() const;
+    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 Dict& as_dict() const;
+    const Function& as_function() const;
+    const std::vector<Function>& as_function_vector() const;
+    void* const & as_void_pointer() const;
+    ///@}
+
+    ///@{
+    //! \brief Convert to a type
+    bool to_bool() const;
+    casadi_int to_int() const;
+    double to_double() const;
+    std::string to_string() const;
+    std::vector<casadi_int> to_int_vector() const;
+    std::vector<bool> to_bool_vector() const;
+    std::vector< std::vector<casadi_int> > to_int_vector_vector() const;
+    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;
+    Dict to_dict() const;
+    Function to_function() const;
+    std::vector<Function> to_function_vector() const;
+    void* to_void_pointer() const;
+    std::vector<int> to_int_type_vector() const;
+    ///@}
+
+    //! \brief Equality
+    bool operator==(const GenericType& op2) const;
+    bool operator!=(const GenericType& op2) const;
+#endif // SWIG
+
+    /** \brief Serialize an object
+
+        \identifier{17r} */
+    void serialize(SerializingStream& s) const;
+
+    /** \brief Deserialize with type disambiguation
+
+        \identifier{17s} */
+    static GenericType deserialize(DeserializingStream& s);
+  };
+
+  /// C++ equivalent of Python's dict or MATLAB's struct
+  typedef GenericType::Dict Dict;
+
+#ifndef SWIG
+  template<class T>
+  T get_from_dict(const std::map<std::string, T>& d,
+      const std::string& key, const T& default_value) {
+    auto it = d.find(key);
+    if (it==d.end()) return default_value;
+    return it->second;
+  }
+
+  template<class T>
+  T get_from_dict(const Dict& d, const std::string& key, const T& default_value) {
+    auto it = d.find(key);
+    if (it==d.end()) return default_value;
+    return it->second;
+  }
+
+  template<class T>
+  Dict extract_from_dict(const Dict& d, const std::string& key, T& value) {
+    Dict ret = d;
+    auto it = ret.find(key);
+    if (it!=ret.end()) {
+        value = it->second;
+        ret.erase(it);
+    }
+    return ret;
+  }
+
+  template<class T>
+  void extract_from_dict_inplace(Dict& d, const std::string& key, T& value) {
+    auto it = d.find(key);
+    if (it!=d.end()) {
+        value = it->second;
+        d.erase(it);
+    }
+  }
+
+  /** \brief Combine two dicts. First has priority 
+   * 
+   *
+      \identifier{17t} */
+  CASADI_EXPORT Dict combine(const Dict& first, const Dict& second, bool recurse=false);
+
+  /** \brief Update the target dictionary in place with source elements
+
+      \identifier{17u} */
+  CASADI_EXPORT void update_dict(Dict& target, const Dict& source, bool recurse=false);
+#endif
+
+} // namespace casadi
+
+
+#endif // CASADI_GENERIC_TYPE_HPP

casadi/include/casadi/core/global_options.hpp

@@ -0,0 +1,95 @@
+/*
+ *    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_GLOBAL_OPTIONS_HPP
+#define CASADI_GLOBAL_OPTIONS_HPP
+
+#include <fstream>
+#include <iostream>
+
+#include "casadi/core/casadi_common.hpp"
+#include <casadi/core/casadi_export.h>
+
+namespace casadi {
+
+  /** \brief Collects global CasADi options
+  *
+  *
+  * Note to developers:  \n
+  *  - use sparingly. Global options are - in general - a rather bad idea \n
+  *  - this class must never be instantiated. Access its static members directly \n
+  *
+  *  \author Joris Gillis
+  *  \date 2012
+
+      \identifier{23m} */
+  class CASADI_EXPORT GlobalOptions {
+    private:
+      /// No instances are allowed
+      GlobalOptions();
+    public:
+
+#ifndef SWIG
+      /** \brief Indicates whether simplifications should be made on the fly.
+
+      * e.g.   cos(-x) -> cos(x)
+      * Default: true
+
+          \identifier{17v} */
+      static bool simplification_on_the_fly;
+
+      static std::string casadipath;
+
+      static std::string casadi_include_path;
+
+      static bool hierarchical_sparsity;
+
+      static casadi_int max_num_dir;
+
+      static casadi_int start_index;
+
+#endif //SWIG
+      // Setter and getter for simplification_on_the_fly
+      static void setSimplificationOnTheFly(bool flag) { simplification_on_the_fly = flag; }
+      static bool getSimplificationOnTheFly() { return simplification_on_the_fly; }
+
+      // Setter and getter for hierarchical_sparsity
+      static void setHierarchicalSparsity(bool flag) { hierarchical_sparsity = flag; }
+      static bool getHierarchicalSparsity() { return hierarchical_sparsity; }
+
+      static void setCasadiPath(const std::string & path) { casadipath = path; }
+      static std::string getCasadiPath() { return casadipath; }
+
+      static void setCasadiIncludePath(const std::string & path) { casadi_include_path = path; }
+      static std::string getCasadiIncludePath() { return casadi_include_path; }
+
+      static void setMaxNumDir(casadi_int ndir) { max_num_dir=ndir; }
+      static casadi_int getMaxNumDir() { return max_num_dir; }
+
+  };
+
+} // namespace casadi
+
+#endif // CASADI_GLOBAL_OPTIONS_HPP

casadi/include/casadi/core/im.hpp

@@ -0,0 +1,52 @@
+/*
+ *    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_IM_HPP
+#define CASADI_IM_HPP
+
+#include "im_fwd.hpp"
+#include "matrix_decl.hpp"
+
+namespace casadi {
+
+  /// Is the IM a Slice
+  bool CASADI_EXPORT is_slice(const IM& x, bool ind1=false);
+
+  ///  Convert IM to Slice
+  Slice CASADI_EXPORT to_slice(const IM& x, bool ind1=false);
+
+  template<>
+  Dict CASADI_EXPORT IM::info() const;
+  template<>
+  void CASADI_EXPORT IM::to_file(const std::string& filename,
+    const Sparsity& sp, const casadi_int* nonzeros,
+    const std::string& format_hint);
+
+#ifndef CASADI_IM_INSTANTIATOR_CPP
+  extern template class Matrix<casadi_int>;
+#endif // CASADI_IM_INSTANTIATOR_CPP
+
+} // namespace casadi
+
+#endif // CASADI_IM_HPP

casadi/include/casadi/core/im_fwd.hpp

@@ -0,0 +1,35 @@
+/*
+ *    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_IM_FWD_HPP
+#define CASADI_IM_FWD_HPP
+#include "matrix_fwd.hpp"
+
+namespace casadi {
+
+  typedef Matrix<casadi_int> IM;
+
+} // namespace casadi
+
+#endif // CASADI_IM_FWD_HPP

casadi/include/casadi/core/importer.hpp

@@ -0,0 +1,221 @@
+/*
+ *    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_IMPORTER_HPP
+#define CASADI_IMPORTER_HPP
+
+#include "function.hpp"
+#include "printable.hpp"
+
+namespace casadi {
+
+#ifndef SWIG
+    /** \brief Convert to a type
+
+        \identifier{15y} */
+    template<typename T>
+    T text2type(const std::string& text) {
+      std::istringstream ss(text);
+      T ret;
+      ss >> ret;
+      return ret;
+    }
+
+    /** \brief Get entry as a vector
+
+        \identifier{15z} */
+    template<typename T>
+    std::vector<T> text2vector(const std::string& text) {
+      std::istringstream ss(text);
+      T tmp;
+      std::vector<T> ret;
+      while (ss >> tmp) ret.push_back(tmp);
+      return ret;
+    }
+
+    /** \brief Get entry as a set
+
+        \identifier{160} */
+    template<typename T>
+    std::set<T> text2set(const std::string& text) {
+      std::vector<T> v = text2vector<T>(text);
+      std::set<T> ret;
+      for (auto&& i : v) ret.insert(i);
+      return ret;
+    }
+#endif // SWIG
+
+  // Forward declaration of internal class
+  class ImporterInternal;
+
+  /** \brief Importer
+
+      Just-in-time compilation of code
+
+      \generalsection{Importer}
+      \pluginssection{Importer}
+
+      \author Joris Gillis
+      \date 2015
+
+      \identifier{161} */
+  class CASADI_EXPORT Importer
+    : public SharedObject,
+      public SWIG_IF_ELSE(PrintableCommon, Printable<Importer>) {
+  public:
+    /** \brief Get type name
+
+        \identifier{162} */
+    static std::string type_name() {return "Importer";}
+
+    /// Default constructor
+    Importer();
+
+    /// Importer factory
+    explicit Importer(const std::string& name,
+                      const std::string& compiler,
+                      const Dict& opts=Dict());
+
+    /// Access functions of the node
+    ImporterInternal* operator->();
+    const ImporterInternal* operator->() const;
+
+    /// Check if a particular cast is allowed
+    static bool test_cast(const SharedObjectInternal* ptr);
+
+    /// Check if a plugin is available
+    static bool has_plugin(const std::string& name);
+
+    /// Explicitly load a plugin dynamically
+    static void load_plugin(const std::string& name);
+
+    /// Get solver specific documentation
+    static std::string doc(const std::string& name);
+
+    /// Query plugin name
+    std::string plugin_name() const;
+
+    // Check if symbol exists
+    bool has_function(const std::string& symname) const;
+
+#ifndef SWIG
+    /// Get a function pointer for numerical evaluation
+    signal_t get_function(const std::string& symname);
+#endif // SWIG
+
+    /// \cond INTERNAL
+#ifndef SWIG
+    /** \brief  Create from node
+
+        \identifier{163} */
+    static Importer create(ImporterInternal* node);
+
+    /** \brief  Create from node and initialize
+
+        \identifier{164} */
+    static Importer create(ImporterInternal* node, const Dict& opts);
+#endif // SWIG
+    /// \endcond
+
+    /** \brief Does a meta entry exist?
+
+        \identifier{165} */
+    bool has_meta(const std::string& cmd, casadi_int ind=-1) const;
+
+    /** \brief Get entry as a text
+
+        \identifier{166} */
+    std::string get_meta(const std::string& cmd, casadi_int ind=-1) const;
+
+    /// Check if a function is inlined
+    bool inlined(const std::string& symname) const;
+
+    /// Get the function body, if inlined
+    std::string body(const std::string& symname) const;
+
+    /// Get library name
+    std::string library() const;
+
+#ifndef SWIG
+    /** Convert indexed command */
+    static inline std::string indexed(const std::string& cmd, casadi_int ind) {
+      std::stringstream ss;
+      ss << cmd << "[" << ind << "]";
+      return ss.str();
+    }
+
+    /** \brief Convert to a type
+
+        \identifier{167} */
+    template<typename T>
+    T to(const std::string& cmd, casadi_int ind=-1) const {
+      return text2type<T>(get_meta(cmd, ind));
+    }
+
+    /** \brief Get entry as a string
+
+        \identifier{168} */
+    std::string meta_string(const std::string& cmd, casadi_int ind=-1) const {
+      return to<std::string>(cmd, ind);
+    }
+
+    /** \brief Get entry as a vector
+
+        \identifier{169} */
+    template<typename T>
+    std::vector<T> meta_vector(const std::string& cmd, casadi_int ind=-1) const {
+      return text2vector<T>(get_meta(cmd, ind));
+    }
+
+    /** \brief Get entry as a set
+
+        \identifier{16a} */
+    template<typename T>
+    std::set<T> meta_set(const std::string& cmd, casadi_int ind=-1) const {
+      return text2set<T>(get_meta(cmd, ind));
+    }
+
+    /** \brief Get entry as an integer
+
+        \identifier{16b} */
+    casadi_int meta_int(const std::string& cmd, casadi_int ind=-1) const {
+      return to<casadi_int>(cmd, ind);
+    }
+#endif // SWIG
+
+    /** \brief Serialize an object
+
+        \identifier{16c} */
+    void serialize(SerializingStream &s) const;
+
+    /** \brief Deserialize with type disambiguation
+
+        \identifier{16d} */
+    static Importer deserialize(DeserializingStream& s);
+  };
+
+} // namespace casadi
+
+#endif // CASADI_IMPORTER_HPP