casadi 3.6.4__cp312-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/casadi/core/runtime/casadi_nd_boor_eval.hpp

@@ -0,0 +1,120 @@
+//
+//    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 "nd_boor_eval"
+template<typename T1>
+void casadi_nd_boor_eval(T1* ret, casadi_int n_dims, const T1* all_knots, const casadi_int* offset, const casadi_int* all_degree, const casadi_int* strides, const T1* c, casadi_int m, const T1* all_x, const casadi_int* lookup_mode, casadi_int* iw, T1* w) { // NOLINT(whitespace/line_length)
+  casadi_int n_iter, k, i, pivot;
+  casadi_int *boor_offset, *starts, *index, *coeff_offset;
+  T1 *cumprod, *all_boor;
+
+  boor_offset = iw; iw+=n_dims+1;
+  starts = iw; iw+=n_dims;
+  index = iw; iw+=n_dims;
+  coeff_offset = iw;
+
+  cumprod = w; w+= n_dims+1;
+  all_boor = w;
+
+  boor_offset[0] = 0;
+  cumprod[n_dims] = 1;
+  coeff_offset[n_dims] = 0;
+
+  n_iter = 1;
+  for (k=0;k<n_dims;++k) {
+    T1 *boor;
+    const T1* knots;
+    T1 x;
+    casadi_int degree, n_knots, n_b, L, start;
+    boor = all_boor+boor_offset[k];
+
+    degree = all_degree[k];
+    knots = all_knots + offset[k];
+    n_knots = offset[k+1]-offset[k];
+    n_b = n_knots-degree-1;
+
+    x = all_x[k];
+    L = casadi_low(x, knots+degree, n_knots-2*degree, lookup_mode[k]);
+
+    start = L;
+    if (start>n_b-degree-1) start = n_b-degree-1;
+
+    starts[k] = start;
+
+    casadi_clear(boor, 2*degree+1);
+    if (x>=knots[0] && x<=knots[n_knots-1]) {
+      if (x==knots[1]) {
+        casadi_fill(boor, degree+1, 1.0);
+      } else if (x==knots[n_knots-1]) {
+        boor[degree] = 1;
+      } else if (knots[L+degree]==x) {
+        boor[degree-1] = 1;
+      } else {
+        boor[degree] = 1;
+      }
+    }
+    casadi_de_boor(x, knots+start, 2*degree+2, degree, boor);
+    boor+= degree+1;
+    n_iter*= degree+1;
+    boor_offset[k+1] = boor_offset[k] + degree+1;
+  }
+
+  casadi_clear_casadi_int(index, n_dims);
+
+  // Prepare cumulative product
+  for (pivot=n_dims-1;pivot>=0;--pivot) {
+    cumprod[pivot] = (*(all_boor+boor_offset[pivot]))*cumprod[pivot+1];
+    coeff_offset[pivot] = starts[pivot]*strides[pivot]+coeff_offset[pivot+1];
+  }
+
+  for (k=0;k<n_iter;++k) {
+    casadi_int pivot = 0;
+    // accumulate result
+    for (i=0;i<m;++i) ret[i] += c[coeff_offset[0]+i]*cumprod[0];
+
+    // Increment index
+    index[0]++;
+
+    // Handle index overflow
+    {
+      // increment next index (forward)
+      while (index[pivot]==boor_offset[pivot+1]-boor_offset[pivot]) {
+        index[pivot] = 0;
+        if (pivot==n_dims-1) break;
+        index[++pivot]++;
+      }
+
+      // update cumulative structures (reverse)
+      while (pivot>0) {
+        // Compute product
+        cumprod[pivot] = (*(all_boor+boor_offset[pivot]+index[pivot]))*cumprod[pivot+1];
+        // Compute offset
+        coeff_offset[pivot] = (starts[pivot]+index[pivot])*strides[pivot]+coeff_offset[pivot+1];
+        pivot--;
+      }
+    }
+
+    // Compute product
+    cumprod[0] = (*(all_boor+index[0]))*cumprod[1];
+
+    // Compute offset
+    coeff_offset[0] = (starts[0]+index[0])*m+coeff_offset[1];
+
+  }
+}

casadi/include/casadi/core/runtime/casadi_newton.hpp

@@ -0,0 +1,66 @@
+//
+//    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 "newton_mem"
+
+template<typename T1>
+struct casadi_newton_mem {
+  casadi_int n;
+  T1 abstol;
+  T1 abstol_step;
+  T1* x;
+  T1* g;
+  T1* jac_g_x;
+
+  const casadi_int* sp_a;
+  const casadi_int* sp_v;
+  const casadi_int* sp_r;
+  const casadi_int* prinv;
+  const casadi_int* pc;
+
+  T1* lin_w;
+  T1* lin_v;
+  T1* lin_r;
+  T1* lin_beta;
+};
+
+// C-REPLACE "casadi_newton_mem<T1>" "struct casadi_newton_mem"
+// SYMBOL "newton"
+template<typename T1>
+int casadi_newton(const casadi_newton_mem<T1>* m) {
+    // Check tolerance on residual
+    if (m->abstol>0 && casadi_norm_inf(m->n, m->g) <= m->abstol) return 1;
+
+    // Factorize J
+    casadi_qr(m->sp_a, m->jac_g_x, m->lin_w,
+              m->sp_v,  m->lin_v, m->sp_r, m->lin_r, m->lin_beta,
+              m->prinv, m->pc);
+    // Solve J^(-1) g
+    casadi_qr_solve(m->g, 1, 0, m->sp_v, m->lin_v, m->sp_r, m->lin_r, m->lin_beta,
+                    m->prinv, m->pc, m->lin_w);
+
+    // Update Xk+1 = Xk - J^(-1) g
+    casadi_axpy(m->n, -1., m->g, m->x);
+
+    // Check tolerance on step
+    if (m->abstol_step>0 && casadi_norm_inf(m->n, m->g) <= m->abstol_step) return 2;
+
+    // We will need another newton step
+    return 0;
+}

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

@@ -0,0 +1,149 @@
+//
+//    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 "nlpsol_detect_bounds_prob"
+template<typename T1>
+struct casadi_nlpsol_detect_bounds_prob {
+  casadi_int sz_arg;
+  casadi_int sz_res;
+  casadi_int sz_iw;
+  casadi_int sz_w;
+  // Original number og constraints
+  casadi_int ng;
+  // Number of bounds
+  casadi_int nb;
+  casadi_int *target_x;
+  casadi_int *target_g;
+  char *is_simple;
+};
+// C-REPLACE "casadi_nlpsol_detect_bounds_prob<T1>" "struct casadi_nlpsol_detect_bounds_prob"
+
+// SYMBOL "nlpsol_prob"
+template<typename T1>
+struct casadi_nlpsol_prob {
+  casadi_int nx, ng, np;
+
+  casadi_nlpsol_detect_bounds_prob<T1> detect_bounds;
+};
+// C-REPLACE "casadi_nlpsol_prob<T1>" "struct casadi_nlpsol_prob"
+
+// SYMBOL "nlpsol_detect_bounds_data"
+template<typename T1>
+struct casadi_nlpsol_detect_bounds_data {
+  // Work vectors
+  const double** arg;
+  double** res;
+  casadi_int* iw;
+  double* w;
+
+  // Simple bounds g(x)=A(b)x+b(p);
+  // a[i]*x[target_x[i]]+b[i]
+  T1* a;
+  T1* b;
+  casadi_int* target_l;
+  casadi_int* target_u;
+  T1* lam_xl;
+  T1* lam_xu;
+};
+// C-REPLACE "casadi_nlpsol_detect_bounds_data<T1>" "struct casadi_nlpsol_detect_bounds_data"
+
+// SYMBOL "nlpsol_data"
+template<typename T1>
+struct casadi_nlpsol_data {
+  // Problem structure
+  const casadi_nlpsol_prob<T1>* prob;
+  // Variable bounds
+  T1 *lbz, *ubz;
+  // Current primal solution
+  T1 *z;
+  // Current dual solution
+  T1 *lam;
+  // Storage for f when null pointer passed
+  T1 objective;
+
+  // NLP data, pointers to arg (no allocations needed)
+  const T1 *p, *lbx, *ubx, *lbg, *ubg, *x0, *lam_x0, *lam_g0;
+  // NLP results, pointers to res (no allocations needed)
+  T1 *f, *x, *g, *lam_x, *lam_g, *lam_p;
+
+  casadi_nlpsol_detect_bounds_data<T1> detect_bounds;
+};
+// C-REPLACE "casadi_nlpsol_data<T1>" "struct casadi_nlpsol_data"
+
+// SYMBOL "nlpsol_work"
+template<typename T1>
+void casadi_nlpsol_work(const casadi_nlpsol_prob<T1>* p, casadi_int* sz_arg, casadi_int* sz_res,
+    casadi_int* sz_iw, casadi_int* sz_w) {
+  // Reset sz_arg, sz_res
+  *sz_arg = *sz_res = 0;
+  // Reset sz_w, sz_iw
+  *sz_w = *sz_iw = 0;
+  *sz_w += p->nx + p->ng; // z
+  *sz_w += p->nx + p->ng; // lbz
+  *sz_w += p->nx + p->ng; // ubz
+  *sz_w += p->nx + p->ng; // lam
+
+  if (p->detect_bounds.ng) {
+    *sz_arg += p->detect_bounds.sz_arg;
+    *sz_res += p->detect_bounds.sz_res;
+    *sz_iw += p->detect_bounds.sz_iw;
+    *sz_w += p->detect_bounds.sz_w;
+
+    *sz_w += p->detect_bounds.nb; // a;
+    *sz_w += p->detect_bounds.nb; // b;
+    *sz_iw += p->nx; // target_l
+    *sz_iw += p->nx; // target_u
+    *sz_w += p->nx; // lam_xl;
+    *sz_w += p->nx; // lam_xu;
+  }
+
+}
+
+
+// SYMBOL "nlpsol_init"
+template<typename T1>
+void casadi_nlpsol_init(casadi_nlpsol_data<T1>* d, const T1*** arg, T1*** res,
+    casadi_int** iw, T1** w) {
+  // Local variables
+  casadi_int nx, ng;
+  const casadi_nlpsol_prob<T1>* p = d->prob;
+  nx = p->nx;
+  ng = p->ng;
+  // Get matrix number of nonzeros
+  d->z = *w; *w += nx + ng;
+  d->lbz = *w; *w += nx + ng;
+  d->ubz = *w; *w += nx + ng;
+  d->lam = *w; *w += nx + ng;
+
+  if (p->detect_bounds.ng) {
+    d->detect_bounds.arg = *arg; *arg += p->detect_bounds.sz_arg;
+    d->detect_bounds.res = *res; *res += p->detect_bounds.sz_res;
+    d->detect_bounds.iw = *iw; *iw += p->detect_bounds.sz_iw;
+    d->detect_bounds.w = *w; *w += p->detect_bounds.sz_w;
+
+    d->detect_bounds.a = *w; *w += p->detect_bounds.nb;
+    d->detect_bounds.b = *w; *w += p->detect_bounds.nb;
+    d->detect_bounds.target_l = *iw; *iw += p->nx;
+    d->detect_bounds.target_u = *iw; *iw += p->nx;
+    d->detect_bounds.lam_xl = *w; *w += nx;
+    d->detect_bounds.lam_xu = *w; *w += nx;
+  }
+
+}

casadi/include/casadi/core/runtime/casadi_norm_1.hpp

@@ -0,0 +1,29 @@
+//
+//    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 "norm_1"
+template<typename T1>
+T1 casadi_norm_1(casadi_int n, const T1* x) {
+  casadi_int i;
+  T1 ret = 0;
+  if (x) {
+    for (i=0; i<n; ++i) ret += fabs(*x++);
+  }
+  return ret;
+}

casadi/include/casadi/core/runtime/casadi_norm_2.hpp

@@ -0,0 +1,24 @@
+//
+//    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 "norm_2"
+template<typename T1>
+T1 casadi_norm_2(casadi_int n, const T1* x) {
+  return sqrt(casadi_dot(n, x, x));
+}

casadi/include/casadi/core/runtime/casadi_norm_inf.hpp

@@ -0,0 +1,28 @@
+//
+//    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 "norm_inf"
+template<typename T1>
+T1 casadi_norm_inf(casadi_int n, const T1* x) {
+  casadi_int i;
+  T1 ret = 0;
+// C-REPLACE "fmax" "casadi_fmax"
+  for (i=0; i<n; ++i) ret = fmax(ret, fabs(*x++));
+  return ret;
+}

casadi/include/casadi/core/runtime/casadi_norm_inf_mul.hpp

@@ -0,0 +1,105 @@
+//
+//    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 "norm_inf_mul"
+template<typename T1>
+T1 casadi_norm_inf_mul(const T1* x, const casadi_int* sp_x, const T1* y, const casadi_int* sp_y, T1* dwork, casadi_int* iwork) { // NOLINT(whitespace/line_length)
+  casadi_int nrow_x, ncol_x, ncol_y, i, jj, kk, nnz;
+  const casadi_int *colind_x, *row_x, *colind_y, *row_y;
+  casadi_int *mask, *next;
+
+  T1 res = 0;
+  // Get sparsities
+  nrow_x = sp_x[0]; ncol_x = sp_x[1];
+  colind_x = sp_x+2; row_x = sp_x + 2 + ncol_x+1;
+  ncol_y = sp_y[1];
+  colind_y = sp_y+2; row_y = sp_y + 2 + ncol_y+1;
+
+  // Implementation inspired on Scipy's sparsetools/csr.h
+  // method that uses O(n) temp storage
+  mask = iwork + ncol_y+1;
+
+  // Pass 1
+  for (i=0; i<nrow_x; ++i) mask[i] = -1;
+  iwork[0] = 0;
+  nnz = 0;
+  for (i=0; i<ncol_y; ++i) {
+    casadi_int next_nnz;
+    casadi_int row_nnz = 0;
+    for (jj=colind_y[i]; jj < colind_y[i+1]; jj++) {
+      casadi_int j = row_y[jj];
+      for (kk=colind_x[j]; kk < colind_x[j+1]; kk++) {
+        casadi_int k = row_x[kk];
+        if (mask[k] != i) {
+          mask[k] = i;
+          row_nnz++;
+        }
+      }
+    }
+    next_nnz = nnz + row_nnz;
+    nnz = next_nnz;
+    iwork[i+1] = nnz;
+  }
+
+  // Pass 2
+  next = iwork + ncol_y+1;
+  for (i=0; i<nrow_x; ++i) next[i] = -1;
+  T1* sums = dwork;
+  for (i=0; i<nrow_x; ++i) sums[i] = 0;
+  nnz = 0;
+  iwork[0] = 0;
+  for (i=0; i<ncol_y; ++i) {
+    casadi_int head, length, jj_start, jj_end;
+    head   = -2;
+    length =  0;
+    jj_start = colind_y[i];
+    jj_end   = colind_y[i+1];
+    for (jj=jj_start; jj<jj_end; ++jj) {
+      casadi_int j, kk_start, kk_end;
+      T1 v;
+      j = row_y[jj];
+      v = y[jj];
+      kk_start = colind_x[j];
+      kk_end   = colind_x[j+1];
+      for (kk = kk_start; kk<kk_end; ++kk) {
+        casadi_int k = row_x[kk];
+        sums[k] += v*x[kk];
+        if (next[k] == -1) {
+          next[k] = head;
+          head  = k;
+          length++;
+        }
+      }
+    }
+    for (jj=0; jj<length; ++jj) {
+      casadi_int temp;
+      if (!is_zero(sums[head])) {
+        T1 a = fabs(sums[head]);
+        res = fmax(res, a);
+        nnz++;
+      }
+      temp = head;
+      head = next[head];
+      next[temp] = -1; //clear arrays
+      sums[temp] =  0;
+    }
+    iwork[i+1] = nnz;
+  }
+  return res;
+}

casadi/include/casadi/core/runtime/casadi_polyval.hpp

@@ -0,0 +1,29 @@
+//
+//    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 "polyval"
+template<typename T1>
+T1 casadi_polyval(const T1* p, casadi_int n, T1 x) {
+  casadi_int i;
+  T1 r=p[0];
+  for (i=1; i<=n; ++i) {
+    r = r*x + p[i];
+  }
+  return r;
+}

casadi/include/casadi/core/runtime/casadi_project.hpp

@@ -0,0 +1,39 @@
+//
+//    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 "project"
+template<typename T1>
+void casadi_project(const T1* x, const casadi_int* sp_x, T1* y, const casadi_int* sp_y, T1* w) {
+  // x and y should be distinct
+  casadi_int ncol_x, ncol_y, i, el;
+  const casadi_int *colind_x, *row_x, *colind_y, *row_y;
+  ncol_x = sp_x[1];
+  colind_x = sp_x+2; row_x = sp_x + 2 + ncol_x+1;
+  ncol_y = sp_y[1];
+  colind_y = sp_y+2; row_y = sp_y + 2 + ncol_y+1;
+  // Loop over columns of x and y
+  for (i=0; i<ncol_x; ++i) {
+    // Zero out requested entries in y
+    for (el=colind_y[i]; el<colind_y[i+1]; ++el) w[row_y[el]] = 0;
+    // Set x entries
+    for (el=colind_x[i]; el<colind_x[i+1]; ++el) w[row_x[el]] = x[el];
+    // Retrieve requested entries in y
+    for (el=colind_y[i]; el<colind_y[i+1]; ++el) y[el] = w[row_y[el]];
+  }
+}

casadi/include/casadi/core/runtime/casadi_qp.hpp

@@ -0,0 +1,86 @@
+//
+//    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 "fmin" "casadi_fmin"
+// C-REPLACE "fmax" "casadi_fmax"
+// C-REPLACE "std::numeric_limits<T1>::min()" "casadi_real_min"
+// C-REPLACE "std::numeric_limits<T1>::infinity()" "casadi_inf"
+// C-REPLACE "static_cast<int>" "(int) "
+
+// SYMBOL "qp_prob"
+template<typename T1>
+struct casadi_qp_prob {
+  // Sparsity patterns
+  const casadi_int *sp_a, *sp_h;
+  // Dimensions
+  casadi_int nx, na, nz;
+  casadi_int nnz_a, nnz_h;
+};
+// C-REPLACE "casadi_qp_prob<T1>" "struct casadi_qp_prob"
+
+// SYMBOL "qp_setup"
+template<typename T1>
+void casadi_qp_setup(casadi_qp_prob<T1>* p) {
+  p->na = p->sp_a[0];
+  p->nx = p->sp_a[1];
+  p->nz = p->na+p->nx;
+  p->nnz_a = p->sp_a[2+p->sp_a[1]];
+  p->nnz_h = p->sp_h[2+p->sp_h[1]];
+}
+
+// C-REPLACE "UnifiedReturnStatus" "int"
+// C-REPLACE "bool" "int"
+
+// SYMBOL "qp_data"
+template<typename T1>
+struct casadi_qp_data {
+  // Problem structure
+  const casadi_qp_prob<T1>* prob;
+
+  UnifiedReturnStatus unified_return_status;
+  bool success;
+
+  // Number of iterations performed
+  casadi_int iter_count;
+
+  // QP data, pointers to arg (no allocations needed)
+  const T1 *a, *h, *g, *lbx, *ubx, *lba, *uba, *x0, *lam_x0, *lam_a0;
+  // QP results, pointers to res (no allocations needed)
+  T1 *f, *x, *lam_x, *lam_a;
+
+};
+// C-REPLACE "casadi_qp_data<T1>" "struct casadi_qp_data"
+
+// SYMBOL "qp_init"
+template<typename T1>
+void casadi_qp_init(casadi_qp_data<T1>* d, casadi_int** iw, T1** w) {
+  // Local variables
+  //const casadi_qp_prob<T1>* p = d->prob;
+}
+
+// SYMBOL "qp_work"
+template<typename T1>
+void casadi_qp_work(const casadi_qp_prob<T1>* p, casadi_int* sz_arg, casadi_int* sz_res,
+    casadi_int* sz_iw, casadi_int* sz_w) {
+  // Reset sz_arg, sz_res
+  *sz_arg = *sz_res = 0;
+  // Reset sz_w, sz_iw
+  *sz_w = *sz_iw = 0;
+}