casadi 3.6.7__cp37-none-manylinux2014_x86_64.whl → 3.7.1__cp37-none-manylinux2014_x86_64.whl

casadi/include/casadi/core/runtime/casadi_blazing_de_boor.hpp

@@ -0,0 +1,101 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// SYMBOL "blazing_printvec"
+template<typename T1>
+void casadi_blazing_printvec(const simde__m256d* e) {
+  double elements[4];
+  simde_mm256_storeu_pd(elements, *e);
+  printf("mm256d: <%.4f %.4f %.4f %.4f>\n", elements[0], elements[1], elements[2], elements[3]);
+}
+
+// SYMBOL "blazing_de_boor"
+template<typename T1>
+void casadi_blazing_de_boor(T1 x, const T1* knots, simde__m256d* boor_d0, simde__m256d* boor_d1, simde__m256d* boor_d2, const simde__m256d* boor_d3) { // NOLINT(whitespace/line_length)
+  simde__m256d x_ = simde_mm256_set1_pd(x);
+  simde__m256d zero = simde_mm256_set1_pd(0.0);
+  simde__m256d mask_end = simde_mm256_set_pd(0.0, -1.0, -1.0, -1.0);
+
+  // shift one up
+  simde__m256d boor_d3i_1 = simde_mm256_permute4x64_pd(*boor_d3, SIMDE_MM_SHUFFLE(3, 3, 2, 1));
+  boor_d3i_1 = simde_mm256_blendv_pd(zero, boor_d3i_1, mask_end);
+
+  simde__m256d knotsi = simde_mm256_loadu_pd(knots);
+  simde__m256d knotsi_1 = simde_mm256_loadu_pd(knots+1);
+  simde__m256d knotsi_2 = simde_mm256_loadu_pd(knots+2);
+  simde__m256d knotsi_3 = simde_mm256_loadu_pd(knots+3);
+  simde__m256d knotsi_4 = simde_mm256_loadu_pd(knots+4);
+
+  simde__m256d bottom = simde_mm256_sub_pd(knotsi_1, knotsi); // bottom = knots[i + 1] - knots[i];
+  simde__m256d bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ); // if (bottom)
+
+  // (x - knots[i]) / bottom;
+  simde__m256d r = simde_mm256_div_pd(simde_mm256_sub_pd(x_, knotsi), bottom);
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+  *boor_d2 = simde_mm256_mul_pd(r, *boor_d3);
+
+  *boor_d2 = simde_mm256_blendv_pd(*boor_d2, zero, bottom_mask);
+
+  bottom = simde_mm256_sub_pd(knotsi_2, knotsi_1); // bottom = knots[i + 2] - knots[i + 1];
+  bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ);
+  r = simde_mm256_div_pd(simde_mm256_sub_pd(knotsi_2, x_), bottom); // (knots[i + 2] - x) / bottom
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+
+  *boor_d2 = simde_mm256_fmadd_pd(r, boor_d3i_1, *boor_d2);
+
+  // shift one up
+  simde__m256d boor_d2i_1 = simde_mm256_permute4x64_pd(*boor_d2, SIMDE_MM_SHUFFLE(3, 3, 2, 1));
+  boor_d2i_1 = simde_mm256_blendv_pd(zero, boor_d2i_1, mask_end);
+
+  bottom = simde_mm256_sub_pd(knotsi_2, knotsi); // bottom = knots[i + 2] - knots[i];
+  bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ); // if (bottom)
+
+  r = simde_mm256_div_pd(simde_mm256_sub_pd(x_, knotsi), bottom); // (x - knots[i]) / bottom;
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+  *boor_d1 = simde_mm256_mul_pd(r, *boor_d2);
+
+  *boor_d1 = simde_mm256_blendv_pd(*boor_d1, zero, bottom_mask);
+
+  bottom = simde_mm256_sub_pd(knotsi_3, knotsi_1); // bottom = knots[i + 3] - knots[i + 1];
+  bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ);
+  r = simde_mm256_div_pd(simde_mm256_sub_pd(knotsi_3, x_), bottom);  // (knots[i + 3] - x) / bottom
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+
+  *boor_d1 = simde_mm256_fmadd_pd(r, boor_d2i_1, *boor_d1);
+
+  // shift one up
+  simde__m256d boor_d1i_1 = simde_mm256_permute4x64_pd(*boor_d1, SIMDE_MM_SHUFFLE(3, 3, 2, 1));
+  boor_d1i_1 = simde_mm256_blendv_pd(zero, boor_d1i_1, mask_end);
+
+  bottom = simde_mm256_sub_pd(knotsi_3, knotsi); // bottom = knots[i + 3] - knots[i];
+  bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ); // if (bottom)
+
+  r = simde_mm256_div_pd(simde_mm256_sub_pd(x_, knotsi), bottom); // (x - knots[i]) / bottom;
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+  *boor_d0 = simde_mm256_mul_pd(r, *boor_d1);
+
+  *boor_d0 = simde_mm256_blendv_pd(*boor_d0, zero, bottom_mask);
+
+  bottom = simde_mm256_sub_pd(knotsi_4, knotsi_1); // bottom = knots[i + 4] - knots[i + 1];
+  bottom_mask = simde_mm256_cmp_pd(bottom, zero, SIMDE_CMP_EQ_OQ);
+  r = simde_mm256_div_pd(simde_mm256_sub_pd(knotsi_4, x_), bottom);  // (knots[i + 4] - x) / bottom
+  r = simde_mm256_blendv_pd(r, zero, bottom_mask);
+
+  *boor_d0 = simde_mm256_fmadd_pd(r, boor_d1i_1, *boor_d0);
+}

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

@@ -205,7 +205,7 @@ T1 casadi_smoothing_diff_err(const T1** yk, T1 h, casadi_int n_y, casadi_int i,
   // If sw is 0, no stencil worked
   if (sw == 0) {
     // Cannot be calculated
-    return std::numeric_limits<T1>::quiet_NaN();;
+    return std::numeric_limits<T1>::quiet_NaN();
   } else {
     // Finalize estimate using the sum of weights and the step length
     return ui / sw;

casadi/include/casadi/core/runtime/casadi_nlp.hpp

@@ -161,7 +161,8 @@ int casadi_detect_bounds_before(casadi_nlpsol_data<T1>* d_nlp) {
   const casadi_nlpsol_detect_bounds_prob<T1>* p_bounds = &p_nlp->detect_bounds;
 
   casadi_int nx = p_nlp->nx;
-  d_bounds->arg[0] = d_nlp->p;
+  d_bounds->arg[0] = d_nlp->z;
+  d_bounds->arg[1] = d_nlp->p;
   d_bounds->res[0] = d_bounds->a;
   d_bounds->res[1] = d_bounds->b;
   p_bounds->callback(d_bounds->arg, d_bounds->res,
@@ -203,6 +204,8 @@ int casadi_detect_bounds_before(casadi_nlpsol_data<T1>* d_nlp) {
         ub = tmp;
       }
       casadi_int j = p_bounds->target_x[k];
+      lb += d_nlp->z[j];
+      ub += d_nlp->z[j];
 
       if (lb==d_nlp->lbz[j]) {
         if (d_nlp->lam_g0) d_bounds->lam_xl[j] += (d_nlp->lam_g0[i]<0)*d_nlp->lam_g0[i];
@@ -253,7 +256,10 @@ int casadi_detect_bounds_after(casadi_nlpsol_data<T1>* d_nlp) {
   for (casadi_int i=0;i<p_bounds->ng;++i) {
     if (p_bounds->is_simple[i]) {
       casadi_int j = p_bounds->target_x[k];
-      if (d_nlp->g) d_nlp->g[i] = d_bounds->a[k]*d_nlp->z[j]+d_bounds->b[k];
+      if (d_nlp->g) {
+        d_nlp->g[i] = d_bounds->a[k]*d_nlp->z[j]-d_bounds->b[k];
+        if (d_nlp->x0) d_nlp->g[i] += d_nlp->x0[j];
+      }
       k++;
     } else {
       if (d_nlp->g) d_nlp->g[i] = d_nlp->z[nx+k_normal];

casadi/include/casadi/core/runtime/casadi_print_canonical.hpp

@@ -0,0 +1,55 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// SYMBOL "print_canonical"
+template<typename T1>
+void casadi_print_canonical(const casadi_int* sp, const T1* x) {
+  // C-REPLACE "printf" "CASADI_PRINTF"
+  // C-REPLACE "static_cast<int>" "(int) "
+  if (x) {
+    casadi_int nrow = sp[0];
+    casadi_int ncol = sp[1];
+    const casadi_int* colind = sp+2;
+    const casadi_int* row = colind + ncol + 1;
+    casadi_int nnz = sp[2+ncol];
+    if (nrow==1 && ncol==1 && nnz==1) {
+      casadi_print_scalar(x[0]);
+    } else {
+      casadi_int i;
+      printf("%dx%d: ", static_cast<int>(nrow), static_cast<int>(ncol));
+      casadi_print_vector(nnz, x);
+      if (nnz!=nrow*ncol) {
+        printf(", colind: [");
+        for (i = 0; i < ncol; ++i) {
+          if (i > 0) printf(", ");
+          printf("%d", static_cast<int>(colind[i]));
+        }
+        printf("], row: [");
+        for (i = 0; i < nnz; ++i) {
+          if (i > 0) printf(", ");
+          printf("%d", static_cast<int>(row[i]));
+        }
+        printf("]");
+      }
+    }
+  } else {
+    printf("NULL");
+  }
+
+}

casadi/include/casadi/core/runtime/casadi_print_scalar.hpp

@@ -0,0 +1,25 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// SYMBOL "print_scalar"
+template<typename T1>
+void casadi_print_scalar(T1 a) {
+  // C-REPLACE "printf" "CASADI_PRINTF"
+  printf("%.16e", a);
+}

casadi/include/casadi/core/runtime/casadi_print_vector.hpp

@@ -0,0 +1,32 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// C-REPLACE "printf" "CASADI_PRINTF"
+
+// SYMBOL "print_vector"
+template<typename T1>
+void casadi_print_vector(casadi_int sz, const T1* a) {
+  casadi_int i;
+  printf("[");
+  for (i=0; i<sz; ++i) {
+    if (i>0) printf(", ");
+    casadi_print_scalar(a[i]);
+  }
+  printf("]");
+}

casadi/include/casadi/core/runtime/casadi_printme.hpp

@@ -0,0 +1,26 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// SYMBOL "printme"
+template<typename T1>
+T1 casadi_printme(T1 a, T1 b) {
+  // C-REPLACE "printf" "CASADI_PRINTF"
+  printf("|> %.15g : %.15g\n", b, a);
+  return a;
+}

casadi/include/casadi/core/serializer.hpp

@@ -77,9 +77,9 @@ namespace casadi {
 
     enum SerializationType {
       SERIALIZED_SPARSITY,
-      SERIALIZED_MX,
+      SERIALIZED_MX_v1,
       SERIALIZED_DM,
-      SERIALIZED_SX,
+      SERIALIZED_SX_v1,
       SERIALIZED_LINSOL,
       SERIALIZED_FUNCTION,
       SERIALIZED_GENERICTYPE,
@@ -87,15 +87,19 @@ namespace casadi {
       SERIALIZED_DOUBLE,
       SERIALIZED_STRING,
       SERIALIZED_SPARSITY_VECTOR,
-      SERIALIZED_MX_VECTOR,
+      SERIALIZED_MX_VECTOR_v1,
       SERIALIZED_DM_VECTOR,
-      SERIALIZED_SX_VECTOR,
+      SERIALIZED_SX_VECTOR_v1,
       SERIALIZED_LINSOL_VECTOR,
       SERIALIZED_FUNCTION_VECTOR,
       SERIALIZED_GENERICTYPE_VECTOR,
       SERIALIZED_INT_VECTOR,
       SERIALIZED_DOUBLE_VECTOR,
       SERIALIZED_STRING_VECTOR,
+      SERIALIZED_MX,
+      SERIALIZED_SX,
+      SERIALIZED_MX_VECTOR,
+      SERIALIZED_SX_VECTOR
     };
 
     static std::string type_to_string(SerializationType type);
@@ -121,8 +125,10 @@ namespace casadi {
 
     Sparsity blind_unpack_sparsity();
     MX blind_unpack_mx();
+    MX blind_unpack_mx_v1();
     Matrix<double> blind_unpack_dm();
     Matrix<SXElem> blind_unpack_sx();
+    Matrix<SXElem> blind_unpack_sx_v1();
     Linsol blind_unpack_linsol();
     Function blind_unpack_function();
     GenericType blind_unpack_generictype();
@@ -131,8 +137,10 @@ namespace casadi {
     std::string blind_unpack_string();
     std::vector<Sparsity> blind_unpack_sparsity_vector();
     std::vector<MX> blind_unpack_mx_vector();
+    std::vector<MX> blind_unpack_mx_vector_v1();
     std::vector< Matrix<double> > blind_unpack_dm_vector();
     std::vector< Matrix<SXElem> > blind_unpack_sx_vector();
+    std::vector< Matrix<SXElem> > blind_unpack_sx_vector_v1();
     std::vector<Linsol> blind_unpack_linsol_vector();
     std::vector<Function> blind_unpack_function_vector();
     std::vector<GenericType> blind_unpack_generictype_vector();
@@ -230,7 +238,7 @@ namespace casadi {
      * \see StringDeserializer
 
         \identifier{7r} */
-    StringDeserializer(const std::string& string);
+    StringDeserializer(const std::string& string="");
     ~StringDeserializer();
 
 

casadi/include/casadi/core/serializing_stream.hpp

@@ -41,6 +41,7 @@ namespace casadi {
   class SXElem;
   class GenericType;
   class Importer;
+  class Resource;
   class Fmu;
   class SharedObject;
   class SharedObjectInternal;
@@ -76,6 +77,8 @@ namespace casadi {
     DeserializingStream(std::istream &in_s);
     DeserializingStream(const DeserializingStream&) = delete;
 
+    void setup();
+
     //@{
     /** \brief Reconstruct an object from the input stream
     *
@@ -93,13 +96,14 @@ namespace casadi {
     }
     void unpack(Function& e);
     void unpack(Importer& e);
+    void unpack(Resource& 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 || defined(__EMSCRIPTEN__)
+#if SIZE_MAX != UINT_MAX || defined(__EMSCRIPTEN__) || defined(__POWERPC__)
     void unpack(unsigned int& e);
 #endif
     void unpack(bool& e);
@@ -201,6 +205,8 @@ namespace casadi {
     std::istream& in;
     /// Debug mode?
     bool debug_;
+    /// Did setup ran?
+    bool set_up_ = false;
   };
 
   /** \brief Helper class for Serialization
@@ -231,12 +237,13 @@ namespace casadi {
     }
     void pack(const Function& e);
     void pack(const Importer& e);
+    void pack(const Resource& 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 || defined(__EMSCRIPTEN__)
+#if SIZE_MAX != UINT_MAX || defined(__EMSCRIPTEN__) || defined(__POWERPC__)
     void pack(unsigned int e);
 #endif
     void pack(bool e);