casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

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

@@ -0,0 +1,345 @@
+//
+//    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<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 {
+  // Input precision
+  T1 reltol;
+  // Output precision
+  T1 abstol;
+  // Smoothness parameter
+  // Smaller epsilon: More discontinuity rejecting
+  // Larger epsilon: More accurate (higher order) if smooth
+  T1 smoothing;
+};
+
+// C-REPLACE "casadi_finite_diff_mem<T1>" "struct casadi_finite_diff_mem"
+
+// SYMBOL "forward_diff_old"
+template<typename T1>
+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;
+  }
+  return -1;
+}
+
+// SYMBOL "central_diff_old"
+template<typename T1>
+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
+  T1 yf, yc, yb;
+  // Local variables
+  T1 err_trunc, err_round;
+  casadi_int i;
+  // Set u and stencils to zero (also supresses warnings)
+  yf = yc = yb = u = 0;
+  for (i=0; i<n_y; ++i) {
+    // Copy to local variables, return -1 if invalid entry
+    if (!isfinite((yf=yk[1][i])) || !isfinite((yc=y0[i])) || !isfinite((yb=yk[0][i]))) {
+      J[i] = std::numeric_limits<T1>::quiet_NaN();
+      u = -1;
+      continue;
+    }
+    // Central difference approximation
+    J[i] = (yf - yb)/(2*h);
+    // Truncation error
+    err_trunc = yf - 2*yc + yb;
+    // Roundoff error
+    err_round = m->reltol/h*fmax(fabs(yf-yc), fabs(yc-yb)) + m->abstol;
+    // Update error estimate
+    if (u>=0) u = fmax(u, fabs(err_trunc/err_round));
+  }
+  return u;
+}
+
+// SYMBOL "smoothing_diff_old"
+template<typename T1>
+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
+  T1 yb, yc, yf;
+  // Local variables
+  T1 Jk, wk, sw, ui, err_trunc, err_round, sm;
+  casadi_int i, k;
+  // Set u and stencils to zero (also supresses warnings)
+  yf = yc = yb = u = 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) {
+      // Calculate shifted finite difference approximation
+      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 (!isfinite((yc=yk[0][i]))) continue;
+        if (!isfinite((yb=yk[1][i]))) continue;
+        yf = y0[i];
+        Jk = 3*yf - 4*yc + yb;
+        wk = 1;
+      } else if (k==1) {
+        // Central
+        // We give this the "nominal 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 (!isfinite((yf=yk[2][i]))) continue;
+        if (!isfinite((yb=yc))) continue;
+        yc = y0[i];
+        Jk = yf-yb;
+        wk = 4;
+      } else {
+        // Forward shifted
+        if (!isfinite((yc=yf))) continue;
+        if (!isfinite((yf=yk[3][i]))) continue;
+        yb = y0[i];
+        Jk = -3*yb + 4*yc - yf;
+        wk = 1;
+      }
+      // Truncation error
+      err_trunc = yf - 2*yc + yb;
+      // Roundoff error
+      err_round = m->reltol/h*fmax(fabs(yf-yc), fabs(yc-yb)) + m->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 + m->smoothing;
+      sw += wk;
+      // Added weighted contribution to weight and error
+      J[i] += wk * Jk;
+      ui += wk * fabs(err_trunc/err_round);
+    }
+    // If sw is 0, no stencil worked
+    if (sw==0) {
+      // Set component to 0, return -1
+      J[i] = std::numeric_limits<T1>::quiet_NaN();
+      u = -1;
+    } else {
+      // Finalize estimate using the sum of weights and the step length
+      J[i] /= 2*h*sw;
+      if (u>=0) u = fmax(u, ui/sw);
+    }
+  }
+  return u;
+}

casadi/include/casadi/core/runtime/casadi_flip.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 "flip"
+inline
+casadi_int casadi_flip(casadi_int* corner, casadi_int ndim) {
+  casadi_int i;
+  for (i=0; i<ndim; ++i) {
+    if (corner[i]) {
+      corner[i]=0;
+    } else {
+      corner[i]=1;
+      return 1;
+    }
+  }
+  return 0;
+}

casadi/include/casadi/core/runtime/casadi_getu.hpp

@@ -0,0 +1,35 @@
+//
+//    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 "getu"
+template<typename T1>
+void casadi_getu(const T1* x, const casadi_int* sp_x, T1* v) {
+  casadi_int ncol_x, cc, el;
+  const casadi_int *colind_x, *row_x;
+  // Get sparsities
+  ncol_x = sp_x[1];
+  colind_x = sp_x+2; row_x = sp_x + 2 + ncol_x+1;
+  // Loop over the columns of x
+  for (cc=0; cc<ncol_x; ++cc) {
+    // Loop over the nonzeros of x
+    for (el=colind_x[cc]; el<colind_x[cc+1] && row_x[el]<=cc; ++el) {
+      *v++ = x[el];
+    }
+  }
+}

casadi/include/casadi/core/runtime/casadi_iamax.hpp

@@ -0,0 +1,36 @@
+//
+//    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 "iamax"
+template<typename T1>
+casadi_int casadi_iamax(casadi_int n, const T1* x, casadi_int inc_x) {
+  casadi_int largest_index, i;
+  T1 t, largest_value;
+  largest_value = -1.0;
+  largest_index = -1;
+  for (i=0; i<n; ++i) {
+    t = fabs(*x);
+    x += inc_x;
+    if (t>largest_value) {
+      largest_value = t;
+      largest_index = i;
+    }
+  }
+  return largest_index;
+}

casadi/include/casadi/core/runtime/casadi_interpn.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 "interpn"
+template<typename T1>
+void casadi_interpn(T1* res, casadi_int ndim, const T1* grid, const casadi_int* offset, const T1* values, const T1* x, const casadi_int* lookup_mode, casadi_int m, casadi_int* iw, T1* w) { // NOLINT(whitespace/line_length)
+  // Work vectors
+  T1* alpha;
+  casadi_int *index, *corner;
+  alpha = w; w += ndim;
+  index = iw; iw += ndim;
+  corner = iw; iw += ndim;
+  // Left index and fraction of interval
+  casadi_interpn_weights(ndim, grid, offset, x, alpha, index, lookup_mode);
+  // Loop over all corners, add contribution to output
+  casadi_clear_casadi_int(corner, ndim);
+  casadi_clear(res, m);
+  do {
+    T1* coeff = 0;
+    casadi_interpn_interpolate(res, ndim, offset, values,
+      alpha, index, corner, coeff, m);
+  } while (casadi_flip(corner, ndim));
+}

casadi/include/casadi/core/runtime/casadi_interpn_grad.hpp

@@ -0,0 +1,72 @@
+//
+//    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 "interpn_grad"
+template<typename T1>
+void casadi_interpn_grad(T1* grad, casadi_int ndim, const T1* grid, const casadi_int* offset, const T1* values, const T1* x, const casadi_int* lookup_mode, casadi_int m, casadi_int* iw, T1* w) { // NOLINT(whitespace/line_length)
+  T1 *alpha, *coeff, *v;
+  casadi_int *index, *corner;
+  casadi_int i;
+  // Quick return
+  if (!grad) return;
+  // Work vectors
+  alpha = w; w += ndim;
+  coeff = w; w += ndim;
+  v = w; w+= m;
+  index = iw; iw += ndim;
+  corner = iw; iw += ndim;
+
+  // Left index and fraction of interval
+  casadi_interpn_weights(ndim, grid, offset, x, alpha, index, lookup_mode);
+  // Loop over all corners, add contribution to output
+  casadi_clear_casadi_int(corner, ndim);
+  casadi_clear(grad, ndim*m);
+  do {
+    casadi_int i, j;
+    // Get coefficients
+    casadi_clear(v, m);
+    casadi_interpn_interpolate(v, ndim, offset, values,
+      alpha, index, corner, coeff, m);
+    // Propagate to alpha
+    for (i=ndim-1; i>=0; --i) {
+      if (corner[i]) {
+        for (j=0; j<m; ++j) {
+          grad[i*m+j] += v[j]*coeff[i];
+          v[j] *= alpha[i];
+        }
+      } else {
+        for (j=0; j<m; ++j) {
+          grad[i*m+j] -= v[j]*coeff[i];
+          v[j] *= 1-alpha[i];
+        }
+      }
+    }
+  } while (casadi_flip(corner, ndim));
+  // Propagate to x
+  for (i=0; i<ndim; ++i) {
+    casadi_int k, j;
+    const T1* g;
+    T1 delta;
+    g = grid + offset[i];
+    j = index[i];
+    delta =  g[j+1]-g[j];
+    for (k=0;k<m;++k) grad[k] /= delta;
+    grad += m;
+  }
+}

casadi/include/casadi/core/runtime/casadi_interpn_interpolate.hpp

@@ -0,0 +1,43 @@
+//
+//    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 "interpn_interpolate"
+template<typename T1>
+void casadi_interpn_interpolate(T1* res, casadi_int ndim, const casadi_int* offset, const T1* values, const T1* alpha, const casadi_int* index, const casadi_int* corner, T1* coeff, casadi_int m) { // NOLINT(whitespace/line_length)
+  T1 c;
+  casadi_int ld, i;
+  // Get weight and value for corner
+  c=1;
+  ld=1; // leading dimension
+  for (i=0; i<ndim; ++i) {
+    if (coeff) *coeff++ = c;
+    if (corner[i]) {
+      c *= alpha[i];
+    } else {
+      c *= 1-alpha[i];
+    }
+    values += (index[i]+corner[i])*ld*m;
+    ld *= offset[i+1]-offset[i];
+  }
+  if (coeff) {
+    for (i=0;i<m;++i) res[i] += values[i];
+  } else {
+    for (i=0;i<m;++i) res[i] += c*values[i];
+  }
+}

casadi/include/casadi/core/runtime/casadi_interpn_weights.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 "interpn_weights"
+template<typename T1>
+void casadi_interpn_weights(casadi_int ndim, const T1* grid, const casadi_int* offset, const T1* x, T1* alpha, casadi_int* index, const casadi_int* lookup_mode) { // NOLINT(whitespace/line_length)
+  // Left index and fraction of interval
+  casadi_int i;
+  for (i=0; i<ndim; ++i) {
+    casadi_int ng, j;
+    T1 xi;
+    const T1* g;
+    // Grid point
+    xi = x ? x[i] : 0;
+    // Grid
+    g = grid + offset[i];
+    ng = offset[i+1]-offset[i];
+    // Find left index
+    j = index[i] = casadi_low(xi, g, ng, lookup_mode[i]);
+    // Get interpolation/extrapolation alpha
+    alpha[i] = (xi-g[j])/(g[j+1]-g[j]);
+  }
+}