casadi 3.6.2__cp311-none-manylinux2014_i686.whl → 3.6.4__cp311-none-manylinux2014_i686.whl

casadi/include/casadi/core/runtime/casadi_finite_diff.hpp

@@ -17,6 +17,201 @@
 //    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
+// C-REPLACE "std::numeric_limits<T1>::quiet_NaN()" "NAN"
+// C-REPLACE "fmax" "casadi_fmax"
+
+// SYMBOL "forward_diff"
+template<typename T1>
+void casadi_forward_diff(const T1** yk, T1* J, T1 h, casadi_int n_y) {
+  // Local variables
+  casadi_int i;
+  const double *yf, *yc;
+  T1 hinv;
+  // Inverse of step size
+  hinv = 1. / h;
+  // Get stencil
+  yc = yk[0];
+  yf = yk[1];
+  // Calculate FD approximation
+  for (i = 0; i < n_y; ++i) J[i] = hinv * (yf[i] - yc[i]);
+}
+
+// SYMBOL "central_diff"
+template<typename T1>
+void casadi_central_diff(const T1** yk, T1* J, T1 h, casadi_int n_y) {
+  // Local variables
+  casadi_int i;
+  const T1 *yf, *yc, *yb;
+  T1 hinv;
+  // Inverse of step size
+  hinv = 1. / h;
+  // Get stencil
+  yb = yk[0];
+  yc = yk[1];
+  yf = yk[2];
+  // Set u and stencils to zero (also supresses warnings)
+  for (i = 0; i < n_y; ++i) {
+    if (isfinite(yb[i])) {
+      if (isfinite(yf[i])) {
+        // Both forward and backward allowed
+        J[i] = 0.5 * hinv * (yf[i] - yb[i]);
+      } else {
+        // Backward but not forward allowed
+        J[i] = hinv * (yc[i] - yb[i]);
+      }
+    } else {
+      if (isfinite(yf[i])) {
+        // Forward but not backward allowed
+        J[i] = hinv * (yf[i] - yc[i]);
+      } else {
+        // Neither forward nor backward possible
+        J[i] = std::numeric_limits<T1>::quiet_NaN();
+      }
+    }
+  }
+}
+
+// SYMBOL "central_diff_err"
+template<typename T1>
+T1 casadi_central_diff_err(const T1** yk, T1 h, casadi_int n_y, casadi_int i,
+    T1 abstol, T1 reltol) {
+  // Local variables
+  const T1 *yf, *yc, *yb;
+  T1 err_trunc, err_round;
+  // Get stencil
+  yb = yk[0];
+  yc = yk[1];
+  yf = yk[2];
+  // Only consider points where both forward and backward allowed
+  if (isfinite(yb[i]) && isfinite(yf[i])) {
+    // Truncation error
+    err_trunc = yf[i] - 2*yc[i] + yb[i];
+    // Roundoff error
+    err_round = reltol / h * fmax(fabs(yf[i] - yc[i]), fabs(yc[i] - yb[i])) + abstol;
+    // Error quotient estimate
+    return err_trunc / err_round;
+  } else {
+    // Cannot be calculated
+    return std::numeric_limits<T1>::quiet_NaN();;
+  }
+}
+
+// SYMBOL "smoothing_diff_weights"
+template<typename T1>
+T1 casadi_smoothing_diff_weights(casadi_int k, T1 yb, T1 yc, T1 yf, T1 *J) {
+  // Calculate shifted finite difference approximation, weights
+  if (k == 0) {
+    // Backward shifted
+    // 7.10 in Conte & Carl de Boor: Elementary Numerical Analysis (1972)
+    // and 25.3.4 in Abramowitz and Stegun, Handbook of Mathematical Functions (1964)
+    if (J) *J = 3 * yf - 4 * yc + yb;
+    // Relative weight is 1
+    return 1;
+  } else if (k == 1) {
+    // Central
+    // We give this the relative weight 4 since if all weights are equal,
+    // this would amount to a five point formula for the derivative
+    // (yb2 - 8*yb + 8*yf - y_f2)/(12*h)
+    // cf. 25.3.6 in Abramowitz and Stegun, Handbook of Mathematical Functions (1964)
+    if (J) *J = yf - yb;
+    // Relative weight is 4
+    return 4;
+  } else {
+    // Forward shifted, cf. backward shifted above
+    if (J) *J = -3 * yb + 4 * yc - yf;
+    // Relative weight is 1
+    return 1;
+  }
+}
+
+// SYMBOL "smoothing_diff"
+template<typename T1>
+void casadi_smoothing_diff(const T1** yk, T1* J, T1 h, casadi_int n_y, T1 smoothing) {
+  // Stencil
+  T1 yb, yc, yf;
+  // Local variables
+  T1 Jk, wk, sw, ui, sm;
+  casadi_int i, k;
+  // Set stencils to zero (also supresses warnings)
+  yf = yc = yb = 0;
+  for (i = 0; i < n_y; ++i) {
+    // Reset derivative estimate, sum of weights, error estimate
+    J[i] = sw = ui = 0;
+    // For backward shifted, central and forward shifted
+    for (k = 0; k < 3; ++k) {
+      // Get stencil
+      yb = yk[k][i];
+      yc = yk[k + 1][i];
+      yf = yk[k + 2][i];
+      // No contribuation if any value is infinite
+      if (!isfinite(yb) || !isfinite(yc) || !isfinite(yf)) continue;
+      // Calculate weights
+      wk = casadi_smoothing_diff_weights(k, yb, yc, yf, &Jk);
+      // Smoothness measure (second order derivative)
+      sm = yf - 2*yc + yb;
+      sm /= h*h;
+      // Modify the weight according to smoothness
+      wk /= sm*sm + smoothing;
+      sw += wk;
+      // Added weighted contribution to weight and error
+      J[i] += wk * Jk;
+    }
+    // If sw is 0, no stencil worked
+    if (sw == 0) {
+      // Set component to 0, return -1
+      J[i] = std::numeric_limits<T1>::quiet_NaN();
+    } else {
+      // Finalize estimate using the sum of weights and the step length
+      J[i] /= 2*h*sw;
+    }
+  }
+}
+
+// SYMBOL "smoothing_diff_err"
+template<typename T1>
+T1 casadi_smoothing_diff_err(const T1** yk, T1 h, casadi_int n_y, casadi_int i,
+    T1 abstol, T1 reltol, T1 smoothing) {
+  // Stencil
+  T1 yb, yc, yf;
+  // Local variables
+  T1 wk, sw, ui, err_trunc, err_round, sm;
+  casadi_int k;
+  // Set stencils to zero (also supresses warnings)
+  yf = yc = yb = 0;
+  // Reset derivative estimate, sum of weights, error estimate
+  sw = ui = 0;
+  // For backward shifted, central and forward shifted
+  for (k = 0; k < 3; ++k) {
+    // Get stencil
+    yb = yk[k][i];
+    yc = yk[k + 1][i];
+    yf = yk[k + 2][i];
+    // No contribuation if any value is infinite
+    if (!isfinite(yb) || !isfinite(yc) || !isfinite(yf)) continue;
+    // Calculate weights
+    wk = casadi_smoothing_diff_weights(k, yb, yc, yf, static_cast<T1*>(0));
+    // Truncation error
+    err_trunc = yf - 2*yc + yb;
+    // Roundoff error
+    err_round = reltol/h*fmax(fabs(yf - yc), fabs(yc - yb)) + abstol;
+    // We use the second order derivative as a smoothness measure
+    sm = err_trunc/(h*h);
+    // Modify the weight according to smoothness
+    wk /= sm*sm + smoothing;
+    sw += wk;
+    // Added weighted contribution to weight and error
+    ui += wk * fabs(err_trunc / err_round);
+  }
+  // If sw is 0, no stencil worked
+  if (sw == 0) {
+    // Cannot be calculated
+    return std::numeric_limits<T1>::quiet_NaN();;
+  } else {
+    // Finalize estimate using the sum of weights and the step length
+    return ui / sw;
+  }
+}
+
 // SYMBOL "finite_diff_mem"
 template<typename T1>
 struct casadi_finite_diff_mem {
@@ -31,13 +226,11 @@ struct casadi_finite_diff_mem {
 };
 
 // C-REPLACE "casadi_finite_diff_mem<T1>" "struct casadi_finite_diff_mem"
-// C-REPLACE "std::numeric_limits<T1>::quiet_NaN()" "NAN"
-// C-REPLACE "fmax" "casadi_fmax"
 
-// SYMBOL "forward_diff"
+// SYMBOL "forward_diff_old"
 template<typename T1>
-T1 casadi_forward_diff(T1** yk, T1* y0, T1* J,
-                       T1 h, casadi_int n_y, const casadi_finite_diff_mem<T1>* m) {
+T1 casadi_forward_diff_old(T1** yk, T1* y0, T1* J,
+    T1 h, casadi_int n_y, const casadi_finite_diff_mem<T1>* m) {
   casadi_int i;
   for (i=0; i<n_y; ++i) {
     J[i] = (yk[0][i]-y0[i])/h;
@@ -45,10 +238,10 @@ T1 casadi_forward_diff(T1** yk, T1* y0, T1* J,
   return -1;
 }
 
-// SYMBOL "central_diff"
+// SYMBOL "central_diff_old"
 template<typename T1>
-T1 casadi_central_diff(T1** yk, T1* y0, T1* J,
-                       T1 h, casadi_int n_y, const casadi_finite_diff_mem<T1>* m) {
+T1 casadi_central_diff_old(T1** yk, T1* y0, T1* J,
+    T1 h, casadi_int n_y, const casadi_finite_diff_mem<T1>* m) {
   // Return value
   T1 u;
   // Stencil
@@ -77,10 +270,10 @@ T1 casadi_central_diff(T1** yk, T1* y0, T1* J,
   return u;
 }
 
-// SYMBOL "smoothing_diff"
+// SYMBOL "smoothing_diff_old"
 template<typename T1>
-T1 casadi_smoothing_diff(T1** yk, T1* y0, T1* J,
-                         T1 h, casadi_int n_y, const casadi_finite_diff_mem<T1>* m) {
+T1 casadi_smoothing_diff_old(T1** yk, T1* y0, T1* J,
+    T1 h, casadi_int n_y, const casadi_finite_diff_mem<T1>* m) {
   // Return value
   T1 u;
   // Stencil

casadi/include/casadi/core/serializing_stream.hpp

@@ -29,6 +29,8 @@
 #include <set>
 #include <sstream>
 #include <unordered_map>
+#include <cstdint>
+#include <climits>
 
 namespace casadi {
   class Slice;
@@ -39,6 +41,7 @@ namespace casadi {
   class SXElem;
   class GenericType;
   class Importer;
+  class Fmu;
   class SharedObject;
   class SharedObjectInternal;
   class SXNode;
@@ -90,10 +93,15 @@ namespace casadi {
     }
     void unpack(Function& e);
     void unpack(Importer& e);
+    void unpack(Fmu& e);
     void unpack(GenericType& e);
     void unpack(std::ostream& s);
     void unpack(Slice& e);
     void unpack(int& e);
+
+#if SIZE_MAX != UINT_MAX
+    void unpack(unsigned int& e);
+#endif
     void unpack(bool& e);
     void unpack(casadi_int& e);
     void unpack(size_t& e);
@@ -223,10 +231,14 @@ namespace casadi {
     }
     void pack(const Function& e);
     void pack(const Importer& e);
+    void pack(const Fmu& e);
     void pack(const Slice& e);
     void pack(const GenericType& e);
     void pack(std::istream& s);
     void pack(int e);
+#if SIZE_MAX != UINT_MAX
+    void pack(unsigned int e);
+#endif
     void pack(bool e);
     void pack(casadi_int e);
     void pack(size_t e);

casadi/include/casadi/core/sparsity_interface.hpp

@@ -72,6 +72,8 @@ namespace casadi {
     static MatType mtimes(const std::vector<MatType> &args);
     static std::vector<MatType > horzsplit(const MatType& x, casadi_int incr);
     static std::vector<MatType > vertsplit(const MatType& x, casadi_int incr);
+    static std::vector<MatType > horzsplit_n(const MatType& x, casadi_int n);
+    static std::vector<MatType > vertsplit_n(const MatType& x, casadi_int n);
     static MatType repmat(const MatType &A, const std::pair<casadi_int, casadi_int>& rc) {
       return MatType::repmat(A, rc.first, rc.second);
     }
@@ -122,15 +124,32 @@ namespace casadi {
 
     /** \brief  split horizontally, retaining fixed-sized groups of columns
 
-     * \param incr Size of each group of columns
+     * \param incr Size (width) of each group of columns
      *
      *   horzcat(horzsplit(x, ...)) = x
+     *
+     * \seealso horzsplit_n
 
         \identifier{3h} */
     inline friend std::vector<MatType > horzsplit(const MatType& x, casadi_int incr=1) {
       return MatType::horzsplit(x, incr);
     }
 
+    /** \brief  split horizontally, retaining fixed-sized groups of columns
+
+     * \param n Number of groups of columns
+     *
+     * Will error when the number of columns is not a multiple of n
+     *
+     *   horzcat(horzsplit(x, ...)) = x
+     *
+     * \seealso horzsplit
+
+        \identifier{277} */
+    inline friend std::vector<MatType > horzsplit_n(const MatType& x, casadi_int n) {
+      return MatType::horzsplit_n(x, n);
+    }
+
     /** \brief  split vertically, retaining groups of rows
 
      * \param output_offset List of all start rows for each group
@@ -178,11 +197,29 @@ namespace casadi {
      [DM([0, 1]), DM([2, 3]), DM(4)]
      \enddoctest
      *
+
+     * \seealso vertsplit_n
+     
         \identifier{3k} */
     inline friend std::vector<MatType > vertsplit(const MatType &x, casadi_int incr=1) {
       return MatType::vertsplit(x, incr);
     }
 
+    /** \brief  split vertically, retaining fixed-sized groups of rows
+
+     * \param n Number of groups of rows
+     *
+     * Will error when the number of rows is not a multiple of n
+     *
+     *   vertcat(vertsplit(x, ...)) = x
+     *
+     * \seealso vertsplit
+
+        \identifier{278} */
+    inline friend std::vector<MatType > vertsplit_n(const MatType& x, casadi_int n) {
+      return MatType::vertsplit_n(x, n);
+    }
+
     /** \brief Construct a matrix from a list of list of blocks.
 
         \identifier{3l} */
@@ -684,6 +721,23 @@ namespace casadi {
     offset1.push_back(sz1);
     return MatType::vertsplit(x, offset1);
   }
+  template<typename MatType>
+  std::vector<MatType > SparsityInterface<MatType>::horzsplit_n(const MatType& x, casadi_int n) {
+    casadi_assert(n>=0, "horzsplit_n(x,n): n (" + str(n) + ") must be non-negative");
+    if (x.size2()==0) return std::vector<MatType>(n, x);
+    casadi_assert(x.size2() % n==0, "horzsplit_n(x,n): x.size2() (" + str(x.size2()) +
+                     ") must be a multiple of n (" + str(n) + ")");
+    return horzsplit(x, x.size2()/n);
+  }
+  template<typename MatType>
+  std::vector<MatType > SparsityInterface<MatType>::vertsplit_n(const MatType& x, casadi_int n) {
+    casadi_assert(n>=0, "vertsplit_n(x,n): n (" + str(n) + ") must be non-negative");
+    if (x.size1()==0) return std::vector<MatType>(n, x);
+    casadi_assert(x.size1() % n==0, "vertsplit(x,n): x.size1() (" + str(x.size1()) +
+                     ") must be a multiple of n (" + str(n) + ")");
+    return vertsplit(x, x.size1()/n);
+  }
+
 #endif // SWIG
 
 } // namespace casadi