casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/casadi/core/callback.hpp

@@ -0,0 +1,226 @@
+/*
+ *    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_CALLBACK_HPP
+#define CASADI_CALLBACK_HPP
+
+#include "function.hpp"
+
+namespace casadi {
+  /** Forward declaration of internal class */
+  class CallbackInternal;
+
+  /** \brief Callback function functionality
+
+   This class provides a public API to the FunctionInternal class that
+   can be subclassed by the user, who is then able to implement the different
+   virtual method.
+   Note that the Function class also provides a public API to FunctionInternal,
+   but only allows calling, not being called.
+
+   The user is responsible for not deleting this class for the lifetime
+   of the internal function object.
+
+   \author Joris Gillis, Joel Andersson
+   \date 2015
+
+      \identifier{o0} */
+  class CASADI_EXPORT Callback : public Function {
+  public:
+    /** \brief Get type name
+
+        \identifier{o1} */
+    static std::string type_name() {return "Callback";}
+
+    /** \brief Default constructor
+
+        \identifier{o2} */
+    Callback();
+
+    /** \brief Copy constructor (throws an error)
+
+        \identifier{o3} */
+    Callback(const Callback& obj);
+
+    /** \brief  Destructor
+
+        \identifier{o4} */
+    virtual ~Callback();
+
+    /** \brief Construct internal object
+
+     * This is the step that actually construct the internal object, as the
+     * class constructor only creates a null pointer.
+     * It should be called from the user constructor.
+
+        \identifier{o5} */
+    void construct(const std::string& name, const Dict& opts=Dict());
+
+    /** \brief Initialize the object
+
+     * This function is called after the object construction (for the whole class
+     * hierarchy) is complete, but before the finalization step.
+     * It is called recursively for the whole class hierarchy, starting with the
+     * lowest level.
+
+        \identifier{o6} */
+    virtual void init() {}
+
+    /** \brief Finalize the object
+
+     * This function is called after the construction and init steps are completed,
+     * but before user functions are called.
+     * It is called recursively for the whole class hierarchy, starting with the
+     * highest level.
+
+        \identifier{o7} */
+    virtual void finalize() {}
+
+    /** \brief Evaluate numerically, using temporary matrices and work vectors
+     *
+     * This signature is not thread-safe.
+     * For guaranteed thread-safety, use `eval_buffer`
+
+        \identifier{o8} */
+    virtual std::vector<DM> eval(const std::vector<DM>& arg) const;
+
+    /** \brief A copy-free low level interface
+     *
+     * In Python, you will be passed two tuples of memoryview objects
+     * Note that only the structural nonzeros are present in the memoryview objects/buffers.
+     *
+     * Make sure to override has_eval_buffer() to indicate support for this method.
+
+        \identifier{o9} */
+    virtual int eval_buffer(const double **arg, const std::vector<casadi_int>& sizes_arg,
+                              double **res, const std::vector<casadi_int>& sizes_res) const;
+    /** \brief Does the Callback class support a copy-free low level interface ?
+     *
+
+        \identifier{265} */
+    virtual bool has_eval_buffer() const;
+
+    /** \brief Get the number of inputs
+
+     * This function is called during construction.
+
+        \identifier{oa} */
+    virtual casadi_int get_n_in();
+
+    /** \brief Get the number of outputs
+
+     * This function is called during construction.
+
+        \identifier{ob} */
+    virtual casadi_int get_n_out();
+
+    /** \brief Get the sparsity of an input
+
+     * This function is called during construction.
+
+        \identifier{oc} */
+    virtual Sparsity get_sparsity_in(casadi_int i);
+
+    /** \brief Get the sparsity of an output
+
+     * This function is called during construction.
+
+        \identifier{od} */
+    virtual Sparsity get_sparsity_out(casadi_int i);
+
+    /** \brief Get the name of an input
+
+     * This function is called during construction.
+
+        \identifier{oe} */
+    virtual std::string get_name_in(casadi_int i);
+
+    /** \brief Get the name of an output
+
+     * This function is called during construction.
+
+        \identifier{of} */
+    virtual std::string get_name_out(casadi_int i);
+
+    /** \brief Do the derivative functions need nondifferentiated outputs?
+
+        \identifier{og} */
+    virtual bool uses_output() const;
+
+    ///@{
+    /** \brief Return Jacobian of all input elements with respect to all output elements
+
+        \identifier{oh} */
+    virtual bool has_jacobian() const;
+    virtual Function get_jacobian(const std::string& name,
+                                  const std::vector<std::string>& inames,
+                                  const std::vector<std::string>& onames,
+                                  const Dict& opts) const;
+    ///@}
+
+    ///@{
+    /** \brief Return function that calculates forward derivatives
+
+     *    forward(nfwd) returns a cached instance if available,
+     *    and calls <tt>Function get_forward(casadi_int nfwd)</tt>
+     *    if no cached version is available.
+
+        \identifier{oi} */
+    virtual bool has_forward(casadi_int nfwd) const;
+    virtual Function get_forward(casadi_int nfwd, const std::string& name,
+                                 const std::vector<std::string>& inames,
+                                 const std::vector<std::string>& onames,
+                                 const Dict& opts) const;
+    ///@}
+
+    ///@{
+    /** \brief Return function that calculates adjoint derivatives
+
+     *    reverse(nadj) returns a cached instance if available,
+     *    and calls <tt>Function get_reverse(casadi_int nadj)</tt>
+     *    if no cached version is available.
+
+        \identifier{oj} */
+    virtual bool has_reverse(casadi_int nadj) const;
+    virtual Function get_reverse(casadi_int nadj, const std::string& name,
+                                 const std::vector<std::string>& inames,
+                                 const std::vector<std::string>& onames,
+                                 const Dict& opts) const;
+    ///@}
+
+    ///@{
+    /** \brief Return sparsity of Jacobian of all input elements
+
+     * with respect to all output elements
+
+        \identifier{ok} */
+    virtual bool has_jac_sparsity(casadi_int oind, casadi_int iind) const { return false; }
+    virtual Sparsity get_jac_sparsity(casadi_int oind, casadi_int iind, bool symmetric) const {
+      return Sparsity(); }
+    ///@}
+  };
+
+} // namespace casadi
+
+#endif // CASADI_CALLBACK_HPP

casadi/include/casadi/core/casadi_common.hpp

@@ -0,0 +1,318 @@
+/*
+ *    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_COMMON_HPP
+#define CASADI_COMMON_HPP
+
+#include <algorithm>
+#include <climits>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#ifdef SWIG
+#define SWIG_IF_ELSE(is_swig, not_swig) is_swig
+#define SWIG_OUTPUT(arg) OUTPUT
+#define SWIG_INOUT(arg) INOUT
+#define SWIG_CONSTREF(arg) const arg
+#ifdef SWIGMATLAB
+#define SWIG_IND1 true
+#else // SWIGMATLAB
+#define SWIG_IND1 false
+#endif // SWIGMATLAB
+#else // SWIG
+#define SWIG_IF_ELSE(is_swig, not_swig) not_swig
+#define SWIG_OUTPUT(arg) arg
+#define SWIG_INOUT(arg) arg
+#define SWIG_CONSTREF(arg) const arg &
+#define SWIG_IND1 false
+#endif // SWIG
+
+#include "casadi_types.hpp"
+
+namespace casadi {
+
+  /// Forward declarations
+  class SXElem;
+  class MX;
+  template<class T> class Matrix;
+  class Function;
+  class Sparsity;
+  class CodeGenerator;
+  class NlpBuilder;
+  struct Variable;
+  class DaeBuilder;
+  class XmlFile;
+  class Importer;
+
+#ifndef SWIG
+// Get GCC version if GCC is used
+#ifdef __GNUC__
+#ifdef __GNUC_MINOR__
+#ifdef __GNUC_PATCHLEVEL__
+#define GCC_VERSION (__GNUC__ * 10000 +__GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#endif // __GNUC_PATCHLEVEL__
+#endif // __GNUC_MINOR__
+#endif // __GNUC__
+
+// Disable some Visual studio warnings
+#ifdef _MSC_VER
+
+// warning C4018: '<' : signed/unsigned mismatch
+#pragma warning(disable:4018)
+
+// warning C4244: Potential loss of data converting double to int
+#pragma warning(disable:4244)
+
+// warning C4251: Need a dll interface?
+#pragma warning(disable:4251)
+
+// warning C4275: non dll-interface class 'std::exception' used as base for dll-interface
+// class 'casadi::CasadiException'
+#pragma warning(disable:4275)
+
+// warning C4715: Not all control paths return a value
+#pragma warning(disable:4715)
+
+// warning C4800: 'int' : forcing value to bool 'true'or 'false'(performance warning)
+#pragma warning(disable:4800)
+
+// warning C4910: __declspec(dllexport) and extern incompatible on an explicit instantiation
+#pragma warning(disable:4910)
+
+// warning C4996: 'sprintf': This function or variable may be unsafe. Consider using sprintf_s
+// instead
+#pragma warning(disable:4996)
+
+#endif // _MSC_VER
+
+  // Macro "minor" is sometimes defined, cf.
+  // https://stackoverflow.com/questions/22240973/major-and-minor-macros-defined-in-sys-sysmacros-h-pulled-in-by-iterator
+#undef minor
+
+  // Type with a size corresponding to that of double (or smaller) that can be used to hold a set
+  // of booleans
+  typedef unsigned long long bvec_t;
+
+  // Number of directions we can deal with at a time
+  // the size of bvec_t in bits (CHAR_BIT is the number of bits per byte, usually 8)
+  const int bvec_size = CHAR_BIT*sizeof(bvec_t);
+
+  // Make sure that the integer datatype is indeed smaller or equal to the double
+  //assert(sizeof(bvec_t) <= sizeof(double)); // doesn't work - very strange
+
+  ///@{
+  /** \brief  Function pointer types for the C API
+
+      \identifier{7j} */
+  typedef int (*config_t)(int, const char**);
+  typedef void (*signal_t)(void);
+  typedef casadi_int (*getint_t)(void);
+  typedef double (*default_t)(casadi_int i);
+  typedef const char* (*name_t)(casadi_int i);
+  typedef const casadi_int* (*sparsity_t)(casadi_int i);
+  typedef int (*diff_t)(casadi_int i);
+  typedef int (*casadi_checkout_t)(void);
+  typedef void (*casadi_release_t)(int);
+  typedef int (*work_t)(casadi_int* sz_arg, casadi_int* sz_res,
+    casadi_int* sz_iw, casadi_int* sz_w);
+  typedef int (*eval_t)(const double** arg, double** res,
+                        casadi_int* iw, double* w, int);
+  ///@}
+
+  // Easier to maintain than an enum (serialization/codegen)
+  constexpr casadi_int LOOKUP_LINEAR = 0;
+  constexpr casadi_int LOOKUP_EXACT = 1;
+  constexpr casadi_int LOOKUP_BINARY = 2;
+
+  /// String representation, any type
+  template<typename T>
+  std::string str(const T& v);
+
+  /// String representation, CasADi type
+  template<typename T>
+  std::string str(const T& v, bool more);
+
+  /// String representation of vector
+  template<typename T>
+  std::string str(const std::vector<T>& v, bool more=false);
+
+  /// String representation of set
+  template<typename T>
+  std::string str(const std::set<T>& v, bool more=false);
+
+  /// String representation of pair
+  template<typename T1, typename T2>
+  std::string str(const std::pair<T1, T2>& p, bool more=false);
+
+  /// String representation of a map
+  template<typename T1, typename T2>
+  std::string str(const std::map<T1, T2> &p, bool more=false);
+
+  /// String representation of a dictionary
+  template<typename T2>
+  std::string str(const std::map<std::string, T2> &p, bool more=false);
+
+
+  //! \brief Create a list of strings from __VA_ARGS__, no argument
+  inline std::vector<std::string> strvec() {
+    return {};
+  }
+
+  //! \brief Create a list of strings from __VA_ARGS__, one argument
+  template<typename T1>
+  inline std::vector<std::string> strvec(const T1& t1) {
+    return {str(t1)};
+  }
+
+  //! \brief Create a list of strings from __VA_ARGS__, two arguments
+  template<typename T1, typename T2>
+  inline std::vector<std::string> strvec(const T1& t1, const T2& t2) {
+    return {str(t1), str(t2)};
+  }
+
+  //! \brief Create a list of strings from __VA_ARGS__, three arguments
+  template<typename T1, typename T2, typename T3>
+  inline std::vector<std::string> strvec(const T1& t1, const T2& t2, const T3& t3) {
+    return {str(t1), str(t2), str(t3)};
+  }
+
+  //! \brief Create a list of strings from __VA_ARGS__, four arguments
+  template<typename T1, typename T2, typename T3, typename T4>
+  inline std::vector<std::string> strvec(const T1& t1, const T2& t2, const T3& t3,
+                                         const T4& t4) {
+    return {str(t1), str(t2), str(t3), str(t4)};
+  }
+
+  //! \brief Create a list of strings from __VA_ARGS__, five arguments
+  template<typename T1, typename T2, typename T3, typename T4, typename T5>
+  inline std::vector<std::string> strvec(const T1& t1, const T2& t2, const T3& t3,
+                                         const T4& t4, const T5& t5) {
+    return {str(t1), str(t2), str(t3), str(t4), str(t5)};
+  }
+
+  //! \brief Create a list of strings from __VA_ARGS__, six arguments
+  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+  inline std::vector<std::string> strvec(const T1& t1, const T2& t2, const T3& t3,
+                                         const T4& t4, const T5& t5, const T6& t6) {
+    return {str(t1), str(t2), str(t3), str(t4), str(t5), str(t6)};
+  }
+
+  //! \brief Create a string from a formatted string
+  inline std::string fmtstr(const std::string& fmt, const std::vector<std::string>& args) {
+    std::string s = fmt;
+    for (auto&& e : args) {
+      std::string::size_type n = s.find("%s");
+      if (n==std::string::npos) return "** Ill-formatted string ** " + fmt;
+      s.replace(n, 2, e);
+    }
+    return s;
+  }
+
+  // Implementations
+  template<typename T>
+  std::string str(const T& v) {
+    std::stringstream ss;
+    ss << v;
+    return ss.str();
+  }
+
+  template<typename T>
+  std::string str(const T& v, bool more) {
+    return v.get_str(more);
+  }
+
+  template<typename T>
+  std::string str(const std::vector<T>& v, bool more) {
+    std::stringstream ss;
+    ss << "[";
+    for (casadi_int i=0; i<v.size(); ++i) {
+      if (i!=0) ss << ", ";
+      ss << v[i];
+    }
+    ss << "]";
+    return ss.str();
+  }
+
+  template<typename T>
+  std::string str(const std::set<T>& v, bool more) {
+    std::stringstream ss;
+    ss << "{";
+    casadi_int cnt = 0;
+    for (const auto& e : v) {
+      if (cnt++!=0) ss << ", ";
+      ss << e;
+    }
+    ss << "}";
+    return ss.str();
+  }
+
+  template<typename T1, typename T2>
+  std::string str(const std::pair<T1, T2>& p, bool more) {
+    std::stringstream ss;
+    ss << "[" << p.first << "," << p.second << "]";
+    return ss.str();
+  }
+
+  template<typename T1, typename T2>
+  std::string str(const std::map<T1, T2>& p, bool more) {
+    std::stringstream ss;
+    ss << "{";
+    casadi_int count = 0;
+    for (auto& e : p) {
+      ss << e.first << ": " << e.second;
+      if (++count < p.size()) ss << ", ";
+    }
+    ss << "}";
+    return ss.str();
+  }
+
+  template<typename T2>
+  std::string str(const std::map<std::string, T2>& p, bool more) {
+    std::stringstream ss;
+    ss << "{";
+    casadi_int count = 0;
+    for (auto& e : p) {
+      ss << "\"" << e.first << "\": " << e.second;
+      if (++count < p.size()) ss << ", ";
+    }
+    ss << "}";
+    return ss.str();
+  }
+#endif // SWIG
+
+} // namespace casadi
+
+#include "casadi_logger.hpp"
+
+#endif // CASADI_COMMON_HPP

casadi/include/casadi/core/casadi_enum.hpp

@@ -0,0 +1,90 @@
+/*
+ *    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_ENUM_HPP
+#define CASADI_ENUM_HPP
+
+#include <string>
+#include <sstream>
+
+#include "exception.hpp"
+
+#include <casadi/core/casadi_export.h>
+
+/// \cond INTERNAL
+namespace casadi {
+
+/// Helper class: Specify number of entries in an enum
+template<typename T>
+struct enum_traits {
+  static const size_t n_enum = static_cast<size_t>(T::NUMEL);
+};
+
+/// Helper function: Check if enum exists
+template<typename T>
+bool has_enum(const std::string& s) {
+  // Look for a match
+  for (size_t i = 0; i < enum_traits<T>::n_enum; ++i) {
+    if (s == to_string(static_cast<T>(i))) return true;
+  }
+  // Not found
+  return false;
+}
+
+/// Helper function: Convert string to enum
+template<typename T>
+T to_enum(const std::string& s, const std::string& s_def = "") {
+  // Default value, if empty string
+  if (s.empty() && !s_def.empty()) return to_enum<T>(s_def);
+  // Linear search over permitted values
+  for (size_t i = 0; i < enum_traits<T>::n_enum; ++i) {
+    if (s == to_string(static_cast<T>(i))) return static_cast<T>(i);
+  }
+  // Informative error message
+  std::stringstream ss;
+  ss << "No such enum: '" << s << "'. Permitted values: ";
+  for (size_t i = 0; i < enum_traits<T>::n_enum; ++i) {
+    // Separate strings
+    if (i > 0) ss << ", ";
+    // Print enum name
+    ss << "'" << to_string(static_cast<T>(i)) << "'";
+  }
+  casadi_error(ss.str());
+  return static_cast<T>(enum_traits<T>::n_enum);  // never reached
+}
+
+/// Helper function: Get all fields
+template<typename T>
+std::vector<std::string> enum_names() {
+  std::vector<std::string> r(enum_traits<T>::n_enum);
+  for (size_t i = 0; i < enum_traits<T>::n_enum; ++i)
+    r[i] = to_string(static_cast<T>(i));
+  return r;
+}
+
+} // namespace casadi
+/// \endcond
+
+#endif // CASADI_ENUM_HPP

casadi/include/casadi/core/casadi_export.h

@@ -0,0 +1,43 @@
+
+#ifndef CASADI_EXPORT_H
+#define CASADI_EXPORT_H
+
+#ifdef CASADI_STATIC_DEFINE
+#  define CASADI_EXPORT
+#  define CASADI_NO_EXPORT
+#else
+#  ifndef CASADI_EXPORT
+#    ifdef casadi_EXPORTS
+        /* We are building this library */
+#      define CASADI_EXPORT __attribute__((visibility("default")))
+#    else
+        /* We are using this library */
+#      define CASADI_EXPORT __attribute__((visibility("default")))
+#    endif
+#  endif
+
+#  ifndef CASADI_NO_EXPORT
+#    define CASADI_NO_EXPORT __attribute__((visibility("hidden")))
+#  endif
+#endif
+
+#ifndef CASADI_DEPRECATED
+#  define CASADI_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef CASADI_DEPRECATED_EXPORT
+#  define CASADI_DEPRECATED_EXPORT CASADI_EXPORT CASADI_DEPRECATED
+#endif
+
+#ifndef CASADI_DEPRECATED_NO_EXPORT
+#  define CASADI_DEPRECATED_NO_EXPORT CASADI_NO_EXPORT CASADI_DEPRECATED
+#endif
+
+/* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef CASADI_NO_DEPRECATED
+#    define CASADI_NO_DEPRECATED
+#  endif
+#endif
+
+#endif /* CASADI_EXPORT_H */