casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/casadi/core/runtime/casadi_lsqr.hpp

@@ -0,0 +1,247 @@
+// C-REPLACE "fabs" "casadi_fabs"
+// C-REPLACE "sign" "casadi_sign"
+
+//
+//    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 "lsqr_sym_ortho"
+template<typename T1>
+void casadi_lsqr_sym_ortho(T1 a, T1 b, T1* cs, T1* sn, T1* rho) {
+    T1 tau;
+    if (b == 0) {
+        *cs = sign(a);
+        *sn = 0;
+        *rho = fabs(a);
+    } else if (a==0) {
+        *cs = 0;
+        *sn = sign(b);
+        *rho = fabs(b);
+    } else if (fabs(b)>fabs(a)) {
+        tau = a/b;
+        *sn = sign(b)/sqrt(1+tau*tau);
+        *cs = (*sn)*tau;
+        *rho = b/(*sn);
+    } else {
+        tau = b/a;
+        *cs = sign(a)/sqrt(1+tau*tau);
+        *sn = (*cs)*tau;
+        *rho = a/(*cs);
+    }
+}
+
+//
+//    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 "lsqr_single_solve"
+// Ref: scipy
+template<typename T1>
+int casadi_lsqr_single_solve(const T1* A, T1* x, casadi_int tr, const casadi_int* sp, T1* w) {
+    casadi_int m, n, i;
+    T1 damp, atol, btol, conlim, ctol, anorm, acond, dampsq, ddnorm, res2, xnorm, xxnorm, z;
+    T1 cs2, sn2, alpha, beta, rhobar, phibar, bnorm, rnorm, arnorm, rhobar1, cs1, sn1, psi;
+    T1 cs, sn, rho, theta, phi, tau, t1, t2, n2dk, delta, gambar, rhs, zbar, gamma, res1;
+    T1 r1sq, r1norm, test1, test2, test3, rtol;
+    casadi_int iter_lim, itn, istop;
+    T1 *u, *v, *xx, *ww, *dk;
+
+    m = sp[0];
+    n = sp[1];
+
+    damp = 0;
+    atol = 1e-15;
+    btol = 1e-15;
+    conlim = 1e8;
+    iter_lim = 10000;
+
+    itn = 0;
+    istop = 0;
+
+    ctol = 0;
+    if (conlim > 0) ctol = 1/conlim;
+    anorm = 0;
+    acond = 0;
+    dampsq = damp*damp;
+    ddnorm = 0;
+    res2 = 0;
+    xnorm = 0;
+    xxnorm = 0;
+    z = 0;
+    cs2 = -1;
+    sn2 = 0;
+
+    u = w;  w+= m; casadi_copy(x, m, u);
+    v = w;  w+= n; casadi_clear(v, n);
+    xx = w; w+= n; casadi_clear(xx, n);
+    ww = w; w+= n; casadi_clear(v, n);
+    dk = w; w+= n;
+
+    alpha = 0;
+    beta = casadi_norm_2(m, u);
+
+    if (beta>0) {
+      for (i=0;i<m;++i) u[i]*=1/beta;
+      casadi_mv(A, sp, u, v, !tr);
+      alpha = casadi_norm_2(n, v);
+    }
+
+    if (alpha>0) {
+      for (i=0;i<n;++i) v[i]*=1/alpha;
+      casadi_copy(v, n, ww);
+    }
+
+    rhobar = alpha;
+    phibar = beta;
+    bnorm = beta;
+    rnorm = beta;
+    arnorm = alpha * beta;
+
+    if (arnorm==0.0) {
+      casadi_clear(x, m);
+      return 0;
+    }
+
+    while (itn<iter_lim) {
+      itn++;
+      for (i=0;i<m;++i) u[i]*=-alpha;
+      casadi_mv(A, sp, v, u, tr);
+      beta = casadi_norm_2(m, u);
+
+      if (beta>0) {
+        for (i=0;i<m;++i) u[i]*=1/beta;
+        anorm = sqrt(anorm*anorm + alpha*alpha+beta*beta+damp*damp);
+        for (i=0;i<n;++i) v[i]*=-beta;
+        casadi_mv(A, sp, u, v, !tr);
+        alpha = casadi_norm_2(n, v);
+        if (alpha>0) for (i=0;i<n;++i) v[i]*=1/alpha;
+      }
+
+      rhobar1 = sqrt(rhobar*rhobar+damp*damp);
+
+      cs1 = rhobar / rhobar1;
+      sn1 = damp / rhobar1;
+      psi = sn1 * phibar;
+      phibar *= cs1;
+
+      casadi_lsqr_sym_ortho(rhobar1, beta, &cs, &sn, &rho);
+
+      theta = sn * alpha;
+      rhobar = -cs * alpha;
+      phi = cs * phibar;
+      phibar *= sn;
+      tau = sn * phi;
+
+      t1 = phi / rho;
+      t2 = -theta / rho;
+
+      for (i=0;i<n;++i) dk[i]=ww[i]/rho;
+
+      for (i=0; i<n; ++i) xx[i] += t1*ww[i];
+      for (i=0; i<n; ++i) ww[i] = v[i] + t2*ww[i];
+
+      n2dk = casadi_norm_2(n, dk);
+      ddnorm += n2dk*n2dk;
+
+      delta = sn2 * rho;
+      gambar = -cs2 * rho;
+      rhs = phi - delta * z;
+      zbar = rhs / gambar;
+      xnorm = sqrt(xxnorm + zbar*zbar);
+      gamma = sqrt(gambar*gambar + theta*theta);
+      cs2 = gambar / gamma;
+      sn2 = theta / gamma;
+      z = rhs / gamma;
+      xxnorm += z*z;
+
+      acond = anorm * sqrt(ddnorm);
+      res1 = phibar*phibar;
+      res2 += psi*psi;
+      rnorm = sqrt(res1+res2);
+      arnorm = alpha*fabs(tau);
+
+      r1sq = rnorm*rnorm - dampsq * xxnorm;
+      r1norm = sqrt(fabs(r1sq));
+      if (r1sq < 0) r1norm = -r1norm;
+
+      test1 = rnorm / bnorm;
+      test2 = arnorm / (anorm * rnorm);
+      test3 = 1 / acond;
+      t1 = test1 / (1 + anorm * xnorm / bnorm);
+      rtol = btol + atol * anorm * xnorm / bnorm;
+
+      if (itn >= iter_lim) istop = 7;
+      if (1 + test3 <= 1) istop = 6;
+      if (1 + test2 <= 1) istop = 5;
+      if (1 + t1 <= 1) istop = 4;
+
+      if (test3 <= ctol) istop = 3;
+      if (test2 <= atol) istop = 2;
+      if (test1 <= rtol) istop = 1;
+
+      if (istop != 0) break;
+
+    }
+    casadi_copy(xx, m, x);
+    return 0;
+}
+
+//
+//    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 "lsqr_solve"
+template<typename T1>
+int casadi_lsqr_solve(const T1* A, T1* x, casadi_int nrhs, casadi_int tr,
+        const casadi_int* sp, T1* w) {
+    casadi_int i;
+    for (i=0; i<nrhs;++i) {
+      if (casadi_lsqr_single_solve(A, x+i*sp[1], tr, sp, w)) return 1;
+    }
+    return 0;
+}

casadi/include/casadi/core/runtime/casadi_masked_norm_inf.hpp

@@ -0,0 +1,33 @@
+//
+//    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 "masked_norm_inf"
+template<typename T1>
+T1 casadi_masked_norm_inf(casadi_int n, const T1* x, const casadi_int* mask) {
+  casadi_int i;
+  T1 ret = 0;
+// C-REPLACE "fmax" "casadi_fmax"
+  for (i=0; i<n; ++i) {
+    if (mask[i]) {
+      ret = fmax(ret, fabs(x[i]));
+    }
+  }
+
+  return ret;
+}

casadi/include/casadi/core/runtime/casadi_max_viol.hpp

@@ -0,0 +1,37 @@
+//
+//    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 "max_viol"
+template<typename T1>
+T1 casadi_max_viol(casadi_int n, const T1* x, const T1* lb, const T1* ub) {
+  T1 r;
+  casadi_int i;
+  const T1 zero = 0;
+  r = 0;
+  for (i=0; i<n; ++i) {
+    T1 x_i, lb_i, ub_i;
+    x_i = x ? *x++ : zero;
+    lb_i = lb ? *lb++ : zero;
+    ub_i = ub ? *ub++ : zero;
+    // C-REPLACE "fmax" "casadi_fmax"
+    r = fmax(r, fmax(x_i-ub_i, zero));
+    r = fmax(r, fmax(lb_i-x_i, zero));
+  }
+  return r;
+}

casadi/include/casadi/core/runtime/casadi_mmax.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.
+//
+
+
+// C-REPLACE "std::numeric_limits<double>::infinity()" "casadi_inf"
+// SYMBOL "mmax"
+template<typename T1>
+T1 casadi_mmax(const T1* x, casadi_int n, casadi_int is_dense) {
+  T1 r = is_dense ? -std::numeric_limits<double>::infinity() : 0;
+  if (!x) return r;
+  return casadi_vfmax(x, n, r);
+}

casadi/include/casadi/core/runtime/casadi_mmin.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.
+//
+
+
+// C-REPLACE "std::numeric_limits<double>::infinity()" "casadi_inf"
+// SYMBOL "mmin"
+template<typename T1>
+T1 casadi_mmin(const T1* x, casadi_int n, casadi_int is_dense) {
+  T1 r = is_dense ? std::numeric_limits<double>::infinity() : 0;
+  if (!x) return r;
+  return casadi_vfmin(x, n, r);
+}
+

casadi/include/casadi/core/runtime/casadi_mtimes.hpp

@@ -0,0 +1,75 @@
+//
+//    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 "mtimes"
+template<typename T1>
+void casadi_mtimes(const T1* x, const casadi_int* sp_x, const T1* y, const casadi_int* sp_y, T1* z, const casadi_int* sp_z, T1* w, casadi_int tr) { // NOLINT(whitespace/line_length)
+  casadi_int ncol_x, ncol_y, ncol_z, cc;
+  const casadi_int *colind_x, *row_x, *colind_y, *row_y, *colind_z, *row_z;
+
+  // Get sparsities
+  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;
+  ncol_z = sp_z[1];
+  colind_z = sp_z+2; row_z = sp_z + 2 + ncol_z+1;
+
+  if (tr) {
+    // Loop over the columns of y and z
+    for (cc=0; cc<ncol_z; ++cc) {
+      casadi_int kk;
+      // Get the dense column of y
+      for (kk=colind_y[cc]; kk<colind_y[cc+1]; ++kk) {
+        w[row_y[kk]] = y[kk];
+      }
+      // Loop over the nonzeros of z
+      for (kk=colind_z[cc]; kk<colind_z[cc+1]; ++kk) {
+        casadi_int kk1;
+        casadi_int rr = row_z[kk];
+        // Loop over corresponding columns of x
+        for (kk1=colind_x[rr]; kk1<colind_x[rr+1]; ++kk1) {
+          z[kk] += x[kk1] * w[row_x[kk1]];
+        }
+      }
+    }
+  } else {
+    // Loop over the columns of y and z
+    for (cc=0; cc<ncol_y; ++cc) {
+      casadi_int kk;
+      // Get the dense column of z
+      for (kk=colind_z[cc]; kk<colind_z[cc+1]; ++kk) {
+        w[row_z[kk]] = z[kk];
+      }
+      // Loop over the nonzeros of y
+      for (kk=colind_y[cc]; kk<colind_y[cc+1]; ++kk) {
+        casadi_int kk1;
+        casadi_int rr = row_y[kk];
+        // Loop over corresponding columns of x
+        for (kk1=colind_x[rr]; kk1<colind_x[rr+1]; ++kk1) {
+          w[row_x[kk1]] += x[kk1]*y[kk];
+        }
+      }
+      // Get the sparse column of z
+      for (kk=colind_z[cc]; kk<colind_z[cc+1]; ++kk) {
+        z[kk] = w[row_z[kk]];
+      }
+    }
+  }
+}

casadi/include/casadi/core/runtime/casadi_mv.hpp

@@ -0,0 +1,46 @@
+//
+//    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 "mv"
+template<typename T1>
+void casadi_mv(const T1* x, const casadi_int* sp_x, const T1* y, T1* z, casadi_int tr) {
+  casadi_int ncol_x, i, el;
+  const casadi_int *colind_x, *row_x;
+  if (!x || !y || !z) return;
+  // Get sparsities
+  ncol_x = sp_x[1];
+  colind_x = sp_x+2; row_x = sp_x + 2 + ncol_x+1;
+  if (tr) {
+    // loop over the columns of x
+    for (i=0; i<ncol_x; ++i) {
+      // loop over the non-zeros of x
+      for (el=colind_x[i]; el<colind_x[i+1]; ++el) {
+        z[i] += x[el] * y[row_x[el]];
+      }
+    }
+  } else {
+    // loop over the columns of x
+    for (i=0; i<ncol_x; ++i) {
+      // loop over the non-zeros of x
+      for (el=colind_x[i]; el<colind_x[i+1]; ++el) {
+        z[row_x[el]] += x[el] * y[i];
+      }
+    }
+  }
+}

casadi/include/casadi/core/runtime/casadi_mv_dense.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 "mv_dense"
+template<typename T1>
+void casadi_mv_dense(const T1* x, casadi_int nrow_x, casadi_int ncol_x,
+    const T1* y, T1* z, casadi_int tr) {
+  casadi_int i, j;
+  if (!x || !y || !z) return;
+  if (tr) {
+    for (i=0; i<ncol_x; ++i) {
+      for (j=0; j<nrow_x; ++j) {
+        z[i] += *x++ * y[j];
+      }
+    }
+  } else {
+    for (i=0; i<ncol_x; ++i) {
+      for (j=0; j<nrow_x; ++j) {
+        z[j] += *x++ * y[i];
+      }
+    }
+  }
+}

casadi/include/casadi/core/runtime/casadi_nd_boor_dual_eval.hpp

@@ -0,0 +1,127 @@
+//
+//    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_dual_eval"
+template<typename T1>
+casadi_int casadi_nd_boor_dual_eval(T1* val, casadi_int* nz, casadi_int n_dims, const T1* all_knots, const casadi_int* offset, const casadi_int* all_degree, const casadi_int* strides, const T1* all_x, const casadi_int* lookup_mode, casadi_int* iw, T1* w) { // NOLINT(whitespace/line_length)
+  casadi_int n_iter, k, pivot, nnz;
+  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;
+
+  nnz = 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
+    nz[nnz] = coeff_offset[0];
+    val[nnz++] += 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]+coeff_offset[1];
+
+  }
+
+  return nnz;
+}
+