casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/casadi/core/dm.hpp

@@ -0,0 +1,87 @@
+/*
+ *    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_DM_HPP
+#define CASADI_DM_HPP
+
+#include "dm_fwd.hpp"
+#include "matrix_decl.hpp"
+
+namespace casadi {
+
+
+  template<>
+  DM DM::
+  solve(const DM& A, const DM& b,
+        const std::string& lsolver, const Dict& dict);
+
+  template<>
+  DM DM::
+  inv(const DM& A,
+        const std::string& lsolver, const Dict& dict);
+  template<>
+  DM DM::
+  pinv(const DM& A, const std::string& lsolver,
+       const Dict& dict);
+
+  template<>
+  DM DM::
+  rand(const Sparsity& sp); // NOLINT(runtime/threadsafe_fn)
+
+  template<>
+  DM DM::
+  expm(const DM& A);
+
+  template<>
+  DM DM::
+  expm_const(const DM& A, const DM& t);
+
+  template<>
+  DM DM::
+  _logsumexp(const DM& A);
+
+  template<>
+  std::vector<DM> DM::
+  cse(const std::vector<DM>& e);
+
+  template<> void DM::export_code(const std::string& lang,
+       std::ostream &stream, const Dict& options) const;
+
+  template<>
+  Dict DM::info() const;
+
+  template<>
+  void DM::to_file(const std::string& filename, const Sparsity& sp,
+    const double* nonzeros, const std::string& format);
+
+  template<>
+  DM DM::from_file(const std::string& filename, const std::string& format_hint);
+
+#ifndef CASADI_DM_INSTANTIATOR_CPP
+  extern template class Matrix<double>;
+#endif // CASADI_DM_INSTANTIATOR_CPP
+
+} // namespace casadi
+
+#endif // CASADI_DM_HPP

casadi/include/casadi/core/dm_fwd.hpp

@@ -0,0 +1,39 @@
+/*
+ *    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_DM_FWD_HPP
+#define CASADI_DM_FWD_HPP
+#include "matrix_fwd.hpp"
+#include <vector>
+#include <map>
+
+namespace casadi {
+
+  typedef Matrix<double> DM;
+  typedef std::vector<DM> DMVector;
+  typedef std::vector<DMVector> DMVectorVector;
+  typedef std::map<std::string, DM> DMDict;
+} // namespace casadi
+
+#endif // CASADI_DM_FWD_HPP

casadi/include/casadi/core/dple.hpp

@@ -0,0 +1,138 @@
+/*
+ *    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_DPLE_HPP
+#define CASADI_DPLE_HPP
+
+#include "function.hpp"
+
+namespace casadi {
+
+  /** \defgroup main_dple Title
+      \par
+
+      Discrete periodic Lyapunov Equation solver
+      Given matrices \f$A_k\f$ and symmetric \f$V_k,  k = 0..K-1\f$
+      \verbatim
+      A_k in R^(n x n)
+      V_k in R^n
+      \endverbatim
+      provides all of \f$P_k\f$ that satisfy:
+      \verbatim
+      P_0 = A_(K-1)*P_(K-1)*A_(K-1)' + V_k
+      P_k+1 = A_k*P_k*A_k' + V_k  for k = 1..K-1
+      \endverbatim
+
+      \generalsection{Dple}
+      \pluginssection{Dple}
+
+      \author Joris Gillis
+      \date 2013-2016
+
+      \identifier{21o} */
+
+  /** \defgroup dple Title
+  * @copydoc main_dple
+  *  @{
+  */
+
+  /** \if EXPANDED
+  * @copydoc main_dple
+  * \endif
+  */
+  ///@{
+  CASADI_EXPORT Function dplesol(const std::string& name, const std::string& solver,
+                           const SpDict& st, const Dict& opts=Dict());
+  CASADI_EXPORT MX dplesol(const MX& A, const MX& V, const std::string& solver,
+    const Dict& opts=Dict());
+  CASADI_EXPORT MXVector dplesol(const MXVector& A, const MXVector& V, const std::string& solver,
+    const Dict& opts=Dict());
+  CASADI_EXPORT DMVector dplesol(const DMVector& A, const DMVector& V, const std::string& solver,
+    const Dict& opts=Dict());
+  ///@}
+
+  /** \brief Get input scheme of DPLE solvers
+
+      \identifier{1nc} */
+  CASADI_EXPORT std::vector<std::string> dple_in();
+
+  /** \brief Get output scheme of DPLE solvers
+
+      \identifier{1nd} */
+  CASADI_EXPORT std::vector<std::string> dple_out();
+
+  /** \brief Get DPLE input scheme name by index
+
+      \identifier{1ne} */
+  CASADI_EXPORT std::string dple_in(casadi_int ind);
+
+  /** \brief Get DPLE output scheme name by index
+
+      \identifier{1nf} */
+  CASADI_EXPORT std::string dple_out(casadi_int ind);
+
+  /** \brief Get the number of QP solver inputs
+
+      \identifier{1ng} */
+  CASADI_EXPORT casadi_int dple_n_in();
+
+  /** \brief Get the number of QP solver outputs
+
+      \identifier{1nh} */
+  CASADI_EXPORT casadi_int dple_n_out();
+
+  /// Check if a particular plugin is available
+  CASADI_EXPORT bool has_dple(const std::string& name);
+
+  /// Explicitly load a plugin dynamically
+  CASADI_EXPORT void load_dple(const std::string& name);
+
+  /// Get the documentation string for a plugin
+  CASADI_EXPORT std::string doc_dple(const std::string& name);
+
+  /** @} */
+
+#ifndef SWIG
+/// Input arguments of a \e dple solver [dpleIn]
+enum DpleInput {
+  /// A matrices (horzcat when const_dim, diagcat otherwise) [a]
+  DPLE_A,
+  /// V matrices (horzcat when const_dim, diagcat otherwise) [v]
+  DPLE_V,
+  DPLE_NUM_IN
+};
+
+/// Output arguments of a \e dple solver [dpleOut]
+enum DpleOutput {
+  /// Lyapunov matrix (horzcat when const_dim, diagcat otherwise) (Cholesky of P if pos_def) [p]
+  DPLE_P,
+  /// Number of arguments.
+  DPLE_NUM_OUT
+};
+#endif // SWIG
+
+} // namespace casadi
+
+#endif // CASADI_DPLE_HPP

casadi/include/casadi/core/exception.hpp

@@ -0,0 +1,167 @@
+/*
+ *    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_EXCEPTION_HPP
+#define CASADI_EXCEPTION_HPP
+
+#include <chrono>
+#include <ctime>
+#include <exception>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <casadi/core/casadi_export.h>
+
+// Disable some Visual studio warnings
+#ifdef _MSC_VER
+
+// 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 C4996: 'sprintf': This function or variable may be unsafe. Consider using sprintf_s
+// instead
+#pragma warning(disable:4996)
+
+#endif // _MSC_VER
+
+namespace casadi {
+
+/** \brief  Casadi exception class
+
+        \author Joel Andersson
+        \date 2010
+        Example for simple exception throwing:
+        \code
+                throw CasadiException("This is a nasty error");
+        \endcode
+        Example for exception chaining:
+        \code
+                try {
+                        throw CasadiException("This is a nasty error");
+                catch(CasadiException &e) {
+                        throw CasadiException("Serious error.") << e;
+                }
+        \endcode
+
+    \identifier{7u} */
+class CASADI_EXPORT CasadiException : public std::exception {
+  public:
+  //! \brief Default constructor
+  CasadiException() {
+  }
+
+  //! \brief Form message string
+  explicit CasadiException(const std::string& msg) : msg_(msg) {}
+
+  //! \brief Destructor
+  ~CasadiException() throw() {}
+
+  //! \brief Display error
+  const char* what() const throw() override {
+    return msg_.c_str();
+  }
+
+  protected:
+  std::string msg_;
+};
+
+class CASADI_EXPORT KeyboardInterruptException : public CasadiException {
+  public:
+  //! \brief Default constructor
+  KeyboardInterruptException() : CasadiException("KeyboardInterrupt") {}
+  //! \brief Destructor
+  ~KeyboardInterruptException() throw() {}
+};
+
+// Strip path prefix
+inline std::string trim_path(const std::string& full_path) {
+  size_t found = full_path.rfind("/casadi/");
+  if (found == std::string::npos) {
+    return full_path;
+  } else {
+    std::string ret = full_path;
+    ret.replace(0, found, "...");
+    return ret;
+  }
+}
+
+// Current time as a string
+inline std::ostream& message_prefix(std::ostream &stream) {
+  // CasADi prefix
+  stream << "CasADi - ";
+  // Get current time
+  auto now = std::chrono::system_clock::now();
+  std::time_t tt = std::chrono::system_clock::to_time_t(now);
+  auto local_tm = *std::localtime(&tt);  // NOLINT(runtime/threadsafe_fn)
+  // Convert to YYYY-MM-DD HH:MM:SS format
+  stream << local_tm.tm_year + 1900 << '-';  // YYYY-
+  stream << std::setfill('0') << std::setw(2) << local_tm.tm_mon + 1 << '-';  // MM-
+  stream << std::setfill('0') << std::setw(2) << local_tm.tm_mday << ' ';  // DD
+  stream << std::setfill('0') << std::setw(2) << local_tm.tm_hour << ':';  // hh:
+  stream << std::setfill('0') << std::setw(2) << local_tm.tm_min << ':';  // mm:
+  stream << std::setfill('0') << std::setw(2) << local_tm.tm_sec;  // ss
+  return stream;
+}
+
+// String denoting where the macro is situated
+#define CASADI_WHERE casadi::trim_path(__FILE__ ":" CASADI_STR(__LINE__))
+
+// Throw an exception with information about source code location
+#define casadi_error(msg, ...) \
+throw casadi::CasadiException(CASADI_WHERE + ": "\
+          + casadi::fmtstr(msg, casadi::strvec(__VA_ARGS__)))
+
+// This assertion checks for illegal user inputs
+#define casadi_assert(x, msg, ...) \
+if (!(x)) casadi_error("Assertion \"" CASADI_STR(x) "\" failed:\n"\
+          + std::string(msg), __VA_ARGS__)
+
+// This assertion if for internal errors caused by bugs in CasADi
+#define casadi_assert_dev(x) casadi_assert(x, "Notify the CasADi developers.")
+
+// This assertion if for internal errors caused by bugs in CasADi
+#define casadi_report() casadi_error("Notify the CasADi developers.")
+
+// Issue a warning, including location in the source code
+#define casadi_warning(msg) \
+  casadi::message_prefix(casadi::uerr()) \
+    << " WARNING(\"" << msg << "\") [" << CASADI_WHERE << "]\n" << std::flush;
+
+// Issue a message, including location in the source code
+#define casadi_message(msg) \
+  casadi::message_prefix(casadi::uout()) \
+    << " MESSAGE(\"" << msg << "\") [" << CASADI_WHERE << "]\n" << std::flush;
+
+} // namespace casadi
+
+#endif // CASADI_EXCEPTION_HPP

casadi/include/casadi/core/expm.hpp

@@ -0,0 +1,84 @@
+/*
+ *    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_EXPM_HPP
+#define CASADI_EXPM_HPP
+
+#include "function.hpp"
+
+namespace casadi {
+
+  /** \defgroup main_expm Title
+      \par
+
+      Performs a matrix exponentiation
+      expm(A)
+
+
+      \generalsection{Expm}
+      \pluginssection{Expm}
+
+      \author Joris Gillis
+      \date 2017
+
+      \identifier{21l} */
+
+  /** \defgroup expm Title
+  * @copydoc main_expm
+  *  @{
+  */
+
+  /** \if EXPANDED
+  * @copydoc main_expm
+  * \endif
+  */
+  ///@{
+  CASADI_EXPORT Function expmsol(const std::string& name, const std::string& solver,
+                           const Sparsity& A, const Dict& opts=Dict());
+  ///@}
+
+  /** \brief Get the number of expm solver inputs
+
+      \identifier{rs} */
+  CASADI_EXPORT casadi_int expm_n_in();
+
+  /** \brief Get the number of expm solver outputs
+
+      \identifier{rt} */
+  CASADI_EXPORT casadi_int expm_n_out();
+
+  /// Check if a particular plugin is available
+  CASADI_EXPORT bool has_expm(const std::string& name);
+
+  /// Explicitly load a plugin dynamically
+  CASADI_EXPORT void load_expm(const std::string& name);
+
+  /// Get the documentation string for a plugin
+  CASADI_EXPORT std::string doc_expm(const std::string& name);
+
+  /** @} */
+} // namespace casadi
+
+#endif // CASADI_EXPM_HPP

casadi/include/casadi/core/external.hpp

@@ -0,0 +1,70 @@
+/*
+ *    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_EXTERNAL_HPP
+#define CASADI_EXTERNAL_HPP
+
+#include "function.hpp"
+#include "importer.hpp"
+
+namespace casadi {
+
+/** \brief  Load an external function from a shared library
+
+ * \param name Name as in the label assigned to a CasADi Function object:
+ *             Function(name,...,...)
+ *             Will be used to look up symbols/functions named eg. <name>_eval
+ *             Use `nm` (linux/osx) or `depends.exe` (win) to check which symbols are present
+ *             in your shared library
+ *
+ * File name is assumed to be ./<name>.so
+
+    \identifier{i0} */
+CASADI_EXPORT Function external(const std::string& name, const Dict& opts=Dict());
+
+/** \brief  Load an external function from a shared library
+ *
+ * \param name Name as in the label assigned to a CasADi Function object:
+ *             Function(name,...,...)
+ *             Will be used to look up symbols/functions named eg. <name>_eval
+ *             Use `nm` (linux/osx) or `depends.exe` (win) to check which symbols are present
+ *             in your shared library
+ * \param bin_name File name of the shared library
+
+    \identifier{i1} */
+CASADI_EXPORT Function external(const std::string& name, const std::string& bin_name,
+                                const Dict& opts=Dict());
+
+/** \brief  Load a just-in-time compiled external function
+
+ * File name given
+
+    \identifier{i2} */
+CASADI_EXPORT Function external(const std::string& name, const Importer& li,
+                                const Dict& opts=Dict());
+
+} // namespace casadi
+
+#endif // CASADI_EXTERNAL_HPP