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

casadi/include/casadi/core/blazing_spline.hpp

@@ -0,0 +1,47 @@
+/*
+ *    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_BLAZING_SPLINE_FUNCTION_HPP
+#define CASADI_BLAZING_SPLINE_FUNCTION_HPP
+
+#include "function.hpp"
+
+namespace casadi {
+  /** \brief Construct a specialized parametric BSpline
+   * 
+   * Specialized in these ways:
+   *  - order 3 is assumed
+   *  - up to dimension 3 supported
+   *  - a single scalar output (m=1)
+   *
+
+      \identifier{2b9} */
+  CASADI_EXPORT Function blazing_spline(const std::string& name,
+    const std::vector< std::vector<double> >& knots,
+    const Dict& opts=Dict());
+
+} // namespace casadi
+
+#endif // CASADI_BLAZING_SPLINE_FUNCTION_HPP

casadi/include/casadi/core/calculus.hpp

@@ -483,8 +483,6 @@ namespace casadi {
   template<>      struct F0XChecker<OP_MUL>{ static const bool check=true;};
   template<>      struct F0XChecker<OP_DIV>{ static const bool check=true;};
   template<>      struct F0XChecker<OP_NEG>{ static const bool check=true;};
-  template<>      struct F0XChecker<OP_POW>{ static const bool check=true;};
-  template<>      struct F0XChecker<OP_CONSTPOW>{ static const bool check=true;};
   template<>      struct F0XChecker<OP_SQRT>{ static const bool check=true;};
   template<>      struct F0XChecker<OP_SQ>{ static const bool check=true;};
   template<>      struct F0XChecker<OP_TWICE>{ static const bool check=true;};
@@ -1156,6 +1154,11 @@ namespace casadi {
         \identifier{1gb} */
     static inline void derF(unsigned char op, const T& x, const T& y, T& f, T* d);
 
+    /** \brief Evaluate function on a const/linear/nonlinear partition
+
+        \identifier{28f} */
+    static inline void fun_linear(unsigned char op, const T*x, const T* y, T* f);
+
     /** \brief Is binary operation?
 
         \identifier{1gc} */
@@ -1545,6 +1548,56 @@ case OP_HYPOT:     DerBinaryOperation<OP_HYPOT>::derf(X, Y, F, D);      break;
     case OP_LOG1P:                               \
     case OP_EXPM1:
 
+  template<typename T>
+  inline void casadi_math<T>::fun_linear(unsigned char op, const T* x, const T* y, T* f) {
+    if (op==OP_ADD || op==OP_SUB) {
+      for (int i=0;i<3;++i) {
+        f[i] = T::binary(op, x[i], y[i]);
+      }
+    } else if (op==OP_TWICE || op==OP_NEG) {
+      for (int i=0;i<3;++i) {
+        f[i] = T::unary(op, x[i]);
+      }
+    } else if (op==OP_MUL) {
+      f[0] += x[0]*y[0];
+      f[1] += x[0]*y[1];
+      f[2] += x[0]*y[2];
+      f[1] += x[1]*y[0];
+      f[2] += x[1]*y[1];
+      f[2] += x[1]*y[2];
+      f[2] += x[2]*y[0];
+      f[2] += x[2]*y[1];
+      f[2] += x[2]*y[2];
+    } else if (op==OP_DIV) {
+      bool const_argy = y[1].is_zero() && y[2].is_zero();
+      if (const_argy) {
+        f[0] = x[0]/y[0];
+        f[1] = x[1]/y[0];
+        f[2] = x[2]/y[0];
+      } else {
+        f[2] = (x[0]+x[1]+x[2])/(y[0]+y[1]+y[2]);
+      }
+    } else if (casadi_math<T>::is_unary(op)) {
+      bool const_arg = x[1].is_zero() && x[2].is_zero();
+      if (const_arg) {
+        f[0] = T::unary(op, x[0]);
+      } else {
+        f[2] = T::unary(op, x[0]+x[1]+x[2]);
+      }
+
+    } else if (casadi_math<T>::is_binary(op)) {
+      bool const_argx = x[1].is_zero() && x[2].is_zero();
+      bool const_argy = y[1].is_zero() && y[2].is_zero();
+      if (const_argx && const_argy) {
+        f[0] = T::binary(op, x[0], y[0]);
+      } else {
+        f[2] = T::binary(op, x[0]+x[1]+x[2], y[0]+y[1]+y[2]);
+      }
+    } else {
+      casadi_error("Not implemented");
+    }
+  }
+
   template<typename T>
   bool casadi_math<T>::is_binary(unsigned char op) {
     switch (op) {
@@ -1576,6 +1629,8 @@ case OP_HYPOT:     DerBinaryOperation<OP_HYPOT>::derf(X, Y, F, D);      break;
       CASADI_MATH_BINARY_BUILTIN
       case OP_IF_ELSE_ZERO:
         return 2;
+      case OP_CALL:
+        return -1;
       default:
         return 1;
     }

casadi/include/casadi/core/callback.hpp

@@ -168,6 +168,15 @@ namespace casadi {
         \identifier{og} */
     virtual bool uses_output() const;
 
+    /** \brief Customize calls to the function factory
+
+        \identifier{2de} */
+    virtual Function get_factory(const std::string& name,
+        const std::vector<std::string>& s_in,
+        const std::vector<std::string>& s_out,
+        const Function::AuxOut& aux,
+        const Dict& opts) const;
+
     ///@{
     /** \brief Return Jacobian of all input elements with respect to all output elements
 

casadi/include/casadi/core/casadi_common.hpp

@@ -183,6 +183,9 @@ namespace casadi {
   template<typename T2>
   std::string str(const std::map<std::string, T2> &p, bool more=false);
 
+  /// String representation of an array
+  template<typename T, size_t N>
+  std::string str(const std::array<T, N> &p, bool more=false);
 
   //! \brief Create a list of strings from __VA_ARGS__, no argument
   inline std::vector<std::string> strvec() {
@@ -309,8 +312,42 @@ namespace casadi {
     ss << "}";
     return ss.str();
   }
+
+  template<typename T, size_t N>
+  std::string str(const std::array<T, N> &v, bool more) {
+    std::stringstream ss;
+    ss << "[";
+    for (casadi_int i=0; i<N; ++i) {
+      if (i!=0) ss << ", ";
+      ss << v[i];
+    }
+    ss << "]";
+    return ss.str();
+  }
+
 #endif // SWIG
 
+  template<typename _Mutex>
+  class conditional_lock_guard {
+  public:
+    typedef _Mutex mutex_type;
+
+    conditional_lock_guard(mutex_type& m, bool condition) : mtx_(m), condition_(condition) {
+      if (condition_) mtx_.lock();
+    }
+
+    ~conditional_lock_guard() {
+      if (condition_) mtx_.unlock();
+    }
+
+    conditional_lock_guard(const conditional_lock_guard&) = delete;
+    conditional_lock_guard& operator=(const conditional_lock_guard&) = delete;
+
+  private:
+    mutex_type&  mtx_;
+    bool condition_;
+  };
+
 } // namespace casadi
 
 #include "casadi_logger.hpp"

casadi/include/casadi/core/casadi_meta.hpp

@@ -100,6 +100,21 @@ namespace casadi {
 
         \identifier{j9} */
     static const char* install_prefix();
+
+    /** \brief Obtain shared library prefix
+
+        \identifier{2be} */
+    static const char* shared_library_prefix();
+
+    /** \brief Obtain shared library suffix
+
+        \identifier{2bf} */
+    static const char* shared_library_suffix();
+
+    /** \brief Obtain object file suffix
+
+        \identifier{2bg} */
+    static const char* object_file_suffix();
   };
 
 }  // namespace casadi

casadi/include/casadi/core/casadi_misc.hpp

@@ -426,6 +426,20 @@ private:
   CASADI_EXPORT void normalized_setup(std::istream& stream);
   CASADI_EXPORT void normalized_setup(std::ostream& stream);
 
+
+  class CASADI_EXPORT StreamStateGuard {
+  public:
+      explicit StreamStateGuard(std::ostream& os);
+      ~StreamStateGuard();
+
+  private:
+      std::ostream& stream_;
+      std::ios::fmtflags flags_;
+      std::streamsize precision_;
+      std::streamsize width_;
+      std::locale locale_;
+  };
+
   inline void normalized_out(std::ostream& stream, double val) {
     if (val==std::numeric_limits<double>::infinity()) {
       stream << "inf";
@@ -487,6 +501,13 @@ namespace std {
     return stream;
   }
 
+  /// Enables flushing an std::vector to a stream (prints representation)
+  template<typename T, size_t N>
+  ostream& operator<<(ostream& stream, const array<T, N>& v) {
+    stream << casadi::str(v);
+    return stream;
+  }
+
   /// Enables flushing an std::set to a stream (prints representation)
   template<typename T>
   ostream& operator<<(ostream& stream, const set<T>& v) {

casadi/include/casadi/core/code_generator.hpp

@@ -82,11 +82,19 @@ namespace casadi {
     /// Add/get a shorthand
     std::string shorthand(const std::string& name, bool allow_adding=true);
 
-    // Add a sparsity pattern
-    std::string sparsity(const Sparsity& sp);
-
-    // Add a sparsity pattern, get index
-    casadi_int add_sparsity(const Sparsity& sp);
+    /* Add a sparsity pattern
+    *
+    * \param canonical If true, request canonical form,
+    * as opposed to potential dense abbreviation
+    */
+    std::string sparsity(const Sparsity& sp, bool canonical=true);
+
+    /* Add a sparsity pattern, get index
+    *
+    * \param canonical If true, request canonical form,
+    * as opposed to potential dense abbreviation
+    */
+    casadi_int add_sparsity(const Sparsity& sp, bool canonical=true);
 
     /** \brief Get the index of an existing sparsity pattern
 
@@ -163,15 +171,26 @@ namespace casadi {
         \identifier{s4} */
     void define_rom_integer(const void* id, casadi_int size);
 
-    /** \brief Setup a callback
-
-        \identifier{27s} */
-    void setup_callback(const std::string& s, const Function& f);
     /** \brief Access file scope integer read-only memory
 
         \identifier{s5} */
     std::string rom_integer(const void* id) const;
 
+    /** \brief Allocate file scope double writeable memory
+
+        \identifier{2aw} */
+    void define_pool_double(const std::string& name, const std::vector<double>& def);
+
+    /** \brief Access file scope double writeable memory
+
+        \identifier{2ax} */
+    std::string pool_double(const std::string& name) const;
+
+    /** \brief Setup a callback
+
+        \identifier{27s} */
+    void setup_callback(const std::string& s, const Function& f);
+
     /** \brief Generate a call to a function (generic signature)
 
         \identifier{s6} */
@@ -242,7 +261,7 @@ namespace casadi {
     /** \brief Avoid stack?
 
         \identifier{si} */
-    bool avoid_stack() { return avoid_stack_;}
+    bool avoid_stack() const { return avoid_stack_;}
 
     /** \brief Print a constant in a lossless but compact manner
 
@@ -250,14 +269,38 @@ namespace casadi {
     std::string constant(double v);
     std::string constant(casadi_int v);
     std::string constant(const std::string& v);
+    std::string constant(char v);
+
+    std::string format_padded(casadi_int i) const;
 
-    /** \brief Print an intializer
+    std::string zeros(casadi_int sz);
+    std::string ones(casadi_int sz);
+
+    /** \brief Print an initializer
 
         \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);
-    std::string initializer(const std::vector<std::string>& v);
+    template <typename T>
+    std::string initializer(const std::vector<T>& v) {
+        std::stringstream s;
+        if (v.size() > max_initializer_elements_per_line) {
+            s << "\n  ";
+        }
+
+        s << "{";
+        for (casadi_int i = 0; i < v.size(); ++i) {
+            if (i != 0) {
+                if (max_initializer_elements_per_line > 1 &&
+                    i % max_initializer_elements_per_line == 0) {
+                    s << ",\n  ";
+                } else {
+                    s << ", ";
+                }
+            }
+            s << constant(v[i]);
+        }
+        s << "}";
+        return s.str();
+    }
 
     /** \brief Sanitize source files for codegen
 
@@ -487,6 +530,11 @@ namespace casadi {
         \identifier{te} */
     std::string norm_inf(casadi_int n, const std::string& x);
 
+    /** \brief norm_1
+
+        \identifier{2br} */
+    std::string norm_1(casadi_int n, const std::string& x);
+
     /** 
 
      * \brief norm_2
@@ -634,7 +682,15 @@ namespace casadi {
       AUX_ORACLE_CALLBACK,
       AUX_OCP_BLOCK,
       AUX_ORACLE,
-      AUX_SCALED_COPY
+      AUX_SCALED_COPY,
+      AUX_BLAZING_DE_BOOR,
+      AUX_BLAZING_1D_BOOR_EVAL,
+      AUX_BLAZING_2D_BOOR_EVAL,
+      AUX_BLAZING_3D_BOOR_EVAL,
+      AUX_PRINTME,
+      AUX_PRINT_SCALAR,
+      AUX_PRINT_VECTOR,
+      AUX_PRINT_CANONICAL
     };
 
     /** \brief Add a built-in auxiliary function
@@ -650,11 +706,16 @@ namespace casadi {
                            const std::vector<Sparsity>& sp_out);
 
     /** Get work vector name from index */
-    std::string work(casadi_int n, casadi_int sz) const;
+    std::string work(casadi_int n, casadi_int sz, bool is_ref) const;
 
     /** Get work vector element from index */
     std::string workel(casadi_int n) const;
 
+    /** \brief Reserve a maximum size of work elements, used for padding of index
+
+        \identifier{2ay} */
+    void reserve_work(casadi_int n);
+
     /** Declare an array */
     static std::string array(const std::string& type, const std::string& name, casadi_int len,
                              const std::string& def=std::string());
@@ -683,6 +744,21 @@ namespace casadi {
     void print_vector(std::ostream &s, const std::string& name,
                              const std::vector<std::string>& v);
 
+    /** \brief Print canonical representaion of a matrix
+
+        \identifier{2dk} */
+    std::string print_canonical(const Sparsity& sp, const std::string& arg);
+
+    /** \brief Print canonical representaion of a vector
+
+        \identifier{2dl} */
+    std::string print_vector(casadi_int sz, const std::string& arg);
+
+    /** \brief Print canonical representaion of a scalar
+
+        \identifier{2dm} */
+    std::string print_scalar(const std::string& arg);
+
     /** \brief Create a copy operation
 
         \identifier{tt} */
@@ -692,6 +768,9 @@ namespace casadi {
     void copy_default(const std::string& arg, std::size_t n, const std::string& res,
       const std::string& def,  bool check_rhs=true);
 
+    // Should we elide a copy?
+    bool elide_copy(casadi_int sz);
+
     /** \brief Create a fill operation
 
         \identifier{tu} */
@@ -791,10 +870,10 @@ namespace casadi {
     static std::string casadi_version();
 
     /// Print file header
-    static void file_open(std::ofstream& f, const std::string& name, bool cpp);
+    static void stream_open(std::ostream& f, bool cpp);
 
     /// Print file header
-    static void file_close(std::ofstream& f, bool cpp);
+    static void stream_close(std::ostream& f, bool cpp);
 
     /** \brief Get number of temporary variables needed for all functions
 
@@ -887,6 +966,15 @@ namespace casadi {
     // Have a flag for exporting/importing symbols
     bool with_export, with_import;
 
+    // Maximum number of declarations per line
+    casadi_int max_declarations_per_line;
+
+    // Maximum number of initializer elements per line
+    casadi_int max_initializer_elements_per_line;
+
+    // Force the external API to use canonical sparsity
+    bool force_canonical;
+
     // Prefix symbols in DLLs?
     std::string dll_export, dll_import;
 
@@ -907,6 +995,12 @@ namespace casadi {
     casadi_int indent_;
     casadi_int current_indent_;
 
+    // Number of zeros/ones
+    casadi_int sz_zeros_;
+    casadi_int sz_ones_;
+
+    casadi_int padding_length_;
+
     // Names of exposed functions
     std::vector<std::string> exposed_fname;
 
@@ -926,6 +1020,8 @@ namespace casadi {
     std::map<std::string, std::string> local_default_;
     std::map<const void *, casadi_int> file_scope_double_;
     std::map<const void *, casadi_int> file_scope_integer_;
+    std::vector< std::vector<double> > pool_double_defaults_;
+    std::map<std::string, casadi_int> pool_double_;
 
     // Added functions
     struct FunctionMeta {

casadi/include/casadi/core/core.hpp

@@ -56,6 +56,7 @@
 #include "expm.hpp"
 #include "interpolant.hpp"
 #include "external.hpp"
+#include "blazing_spline.hpp"
 
 // Misc
 #include "integration_tools.hpp"
@@ -66,5 +67,9 @@
 #include "optistack.hpp"
 #include "serializer.hpp"
 #include "tools.hpp"
+#include "resource.hpp"
+#include "archiver.hpp"
+#include "filesystem.hpp"
+#include "options.hpp"
 
 #endif // CASADI_CORE_HPP