casadi 3.6.7__cp313-none-manylinux2014_aarch64.whl

casadi/include/casadi/core/polynomial.hpp

@@ -0,0 +1,126 @@
+/*
+ *    This file is part of CasADi.
+ *
+ *    CasADi -- A symbolic framework for dynamic optimization.
+ *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
+ *                            KU Leuven. All rights reserved.
+ *    Copyright (C) 2011-2014 Greg Horn
+ *
+ *    CasADi is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License as published by the Free Software Foundation; either
+ *    version 3 of the License, or (at your option) any later version.
+ *
+ *    CasADi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with CasADi; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+
+#ifndef CASADI_POLYNOMIAL_HPP
+#define CASADI_POLYNOMIAL_HPP
+
+# include "printable.hpp"
+
+namespace casadi {
+
+  /** \brief Helper class for differentiating and integrating polynomials
+
+      \author Joel Andersson
+      \date 2014
+
+      \identifier{8y} */
+  class CASADI_EXPORT Polynomial : public Printable<Polynomial> {
+  public:
+
+    /// Construct a constant polynomial
+    Polynomial(double scalar=1);
+
+    /// Construct a linear polynomial
+    Polynomial(double p0, double p1);
+
+    /// Construct a quadratic polynomial
+    Polynomial(double p0, double p1, double p2);
+
+    /// Construct a cubic polynomial
+    Polynomial(double p0, double p1, double p2, double p3);
+
+    /// Construct from a vector of polynomial coefficients
+    template<typename T>
+    Polynomial(const std::vector<T>& coeff) : p_(coeff.begin(), coeff.end()) {}
+
+    /// Evaluate numerically
+    template<typename T>
+    T operator()(const T& x) const {
+      auto it = p_.rbegin();
+      T ret = *it++;
+      while (it!=p_.rend()) {
+        ret *= x;
+        ret += *it++;
+      }
+      return ret;
+    }
+
+    /// Coefficients of the polynomial
+    const std::vector<double>& coeff() const { return p_; }
+
+    /// Degree of the polynomial
+    casadi_int degree() const;
+
+    /// Get scalar value (error if degree()!=0)
+    double scalar() const;
+
+    /// Create a new polynomial for the derivative
+    Polynomial derivative() const;
+
+    /// Create a new polynomial for the anti-derivative (primitive function)
+    Polynomial anti_derivative() const;
+
+    /// Remove excess zeros
+    void trim();
+
+    /// Readable name of the class
+    std::string type_name() const {return "Polynomial";}
+
+    /// Print a description of the object
+    void disp(std::ostream& stream, bool more=false) const;
+
+    // Add
+    Polynomial operator+(const Polynomial& b) const;
+
+    // Add (in-place)
+    Polynomial& operator+=(const Polynomial& b);
+
+    // Subtract
+    Polynomial operator-(const Polynomial& b) const;
+
+    // Subtract (in-place)
+    Polynomial& operator-=(const Polynomial& b);
+
+    // Multiply
+    Polynomial operator*(const Polynomial& b) const;
+
+    // Multiply (in-place)
+    Polynomial& operator*=(const Polynomial& b);
+
+    // Divide by constant
+    Polynomial operator/(double b) const;
+
+    // Divide by constant (in-place)
+    Polynomial& operator/=(double b);
+
+
+  protected:
+    std::vector<double> p_;
+  };
+
+} // namespace casadi
+
+
+#endif // CASADI_POLYNOMIAL_HPP

casadi/include/casadi/core/printable.hpp

@@ -0,0 +1,73 @@
+/*
+ *    This file is part of CasADi.
+ *
+ *    CasADi -- A symbolic framework for dynamic optimization.
+ *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
+ *                            KU Leuven. All rights reserved.
+ *    Copyright (C) 2011-2014 Greg Horn
+ *
+ *    CasADi is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License as published by the Free Software Foundation; either
+ *    version 3 of the License, or (at your option) any later version.
+ *
+ *    CasADi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with CasADi; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+
+#ifndef CASADI_PRINTABLE_HPP
+#define CASADI_PRINTABLE_HPP
+
+#include <iostream>
+#include <sstream>
+#include <streambuf>
+#include <string>
+#include <vector>
+
+#include "casadi_common.hpp"
+
+namespace casadi {
+
+  /** \brief Empty Base
+
+      This class is extended in SWIG.
+
+      \identifier{7h} */
+  struct CASADI_EXPORT PrintableCommon {};
+
+#ifndef SWIG
+  /** \brief Base class for objects that have a natural string representation
+
+      \author Joel Andersson
+      \date 2010-2014
+
+      \identifier{7i} */
+  template<class Derived>
+  class CASADI_EXPORT Printable : public PrintableCommon {
+  public:
+    /// Print a string representation of the object to a stream
+    inline friend
+      std::ostream& operator<<(std::ostream &stream, const Derived& obj) {
+      obj.disp(stream);
+      return stream;
+    }
+
+    /// Get string representation with type information
+    inline friend std::string repr(const Derived& obj) {
+      return Derived::type_name() + "(" + obj.get_str() + ")";
+    }
+  };
+#endif // SWIG
+
+} // namespace casadi
+
+
+#endif // CASADI_PRINTABLE_HPP

casadi/include/casadi/core/rootfinder.hpp

@@ -0,0 +1,176 @@
+/*
+ *    This file is part of CasADi.
+ *
+ *    CasADi -- A symbolic framework for dynamic optimization.
+ *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
+ *                            KU Leuven. All rights reserved.
+ *    Copyright (C) 2011-2014 Greg Horn
+ *
+ *    CasADi is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License as published by the Free Software Foundation; either
+ *    version 3 of the License, or (at your option) any later version.
+ *
+ *    CasADi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with CasADi; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+
+#ifndef CASADI_ROOTFINDER_HPP
+#define CASADI_ROOTFINDER_HPP
+
+#include "function.hpp"
+#include "linsol.hpp"
+
+namespace casadi {
+
+  /** \defgroup main_rootfinder Title
+      \par
+
+   * Create a solver for rootfinding problems
+   * Takes a function where one of the inputs is unknown and one of the outputs
+   * is a residual function that is always zero, defines a new function where
+   * the the unknown input has been replaced by a _guess_ for the unknown and the
+   * residual output has been replaced by the calculated value for the input.
+   *
+   * For a function
+   * [y0, y1, ...,yi, .., yn] = F(x0, x1, ..., xj, ..., xm),
+   * where xj is unknown and yi=0, defines a new function
+   * [y0, y1, ...,xj, .., yn] = G(x0, x1, ..., xj_guess, ..., xm),
+   *
+   * xj and yi must have the same dimension and d(yi)/d(xj) must be invertable.
+   *
+   * By default, the first input is unknown and the first output is the residual.
+   *
+   *
+   * \generalsection{Rootfinder}
+   * \pluginssection{Rootfinder}
+   *
+   * \author Joel Andersson
+   * \date 2011-2015
+
+      \identifier{21r} */
+
+
+  /** \defgroup rootfinder Title
+  * @copydoc main_rootfinder
+  *  @{
+  */
+
+  /** \if EXPANDED
+  * @copydoc main_rootfinder
+  * \endif
+  */
+  ///@{
+
+  ///@{
+  CASADI_EXPORT Function rootfinder(const std::string& name, const std::string& solver,
+                                    const SXDict& rfp, const Dict& opts=Dict());
+  CASADI_EXPORT Function rootfinder(const std::string& name, const std::string& solver,
+                                    const MXDict& rfp, const Dict& opts=Dict());
+  CASADI_EXPORT Function rootfinder(const std::string& name, const std::string& solver,
+                               const Function& f, const Dict& opts=Dict());
+  ///@}
+
+  /** \brief Get rootfinder input scheme
+
+      \identifier{1ty} */
+  CASADI_EXPORT std::vector<std::string> rootfinder_in();
+
+  /** \brief Get rootfinder output scheme
+
+      \identifier{1tz} */
+  CASADI_EXPORT std::vector<std::string> rootfinder_out();
+
+  /** \brief Get rootfinder input scheme name by index
+
+      \identifier{1u0} */
+  CASADI_EXPORT std::string rootfinder_in(casadi_int ind);
+
+  /** \brief Get rootfinder output scheme name by index
+
+      \identifier{1u1} */
+  CASADI_EXPORT std::string rootfinder_out(casadi_int ind);
+
+  /** \brief Number of rootfinder inputs
+
+      \identifier{1u2} */
+  CASADI_EXPORT casadi_int rootfinder_n_in();
+
+  /** \brief Number of rootfinder outputs
+
+      \identifier{1u3} */
+  CASADI_EXPORT casadi_int rootfinder_n_out();
+
+  /** \brief Get all options for a plugin
+
+      \identifier{1u4} */
+  CASADI_EXPORT std::vector<std::string> rootfinder_options(const std::string& name);
+
+  /** \brief Get type info for a particular option
+
+      \identifier{1u5} */
+  CASADI_EXPORT std::string rootfinder_option_type(const std::string& name, const std::string& op);
+
+  /** \brief Get documentation for a particular option
+
+      \identifier{1u6} */
+  CASADI_EXPORT std::string rootfinder_option_info(const std::string& name, const std::string& op);
+
+  /// Check if a particular plugin is available
+  CASADI_EXPORT bool has_rootfinder(const std::string& name);
+
+  /// Explicitly load a plugin dynamically
+  CASADI_EXPORT void load_rootfinder(const std::string& name);
+
+  /// Get the documentation string for a plugin
+  CASADI_EXPORT std::string doc_rootfinder(const std::string& name);
+  /** @} */
+
+  #ifndef SWIG
+  /// Inputs of the symbolic representation of the rootfinding problem
+  enum RfpIn {
+    RFP_X,
+    RFP_P,
+    RFP_NUM_IN};
+
+  /// Shortnames for DAE symbolic representation inputs
+  const std::vector<std::string> RFP_INPUTS = {"x", "p"};
+
+  /// Inputs of the symbolic representation of the rootfinding problem
+  enum RfpOut {
+    RFP_G,
+    RFP_NUM_OUT};
+
+  /// Shortnames for DAE symbolic representation outputs
+  const std::vector<std::string> RFP_OUTPUTS = {"g"};
+
+  /// Input arguments of a rootfinder
+  enum RootfinderInput {
+    /// Initial guess for the solution
+    ROOTFINDER_X0,
+    /// Parameters
+    ROOTFINDER_P,
+    /// Number of input arguments of a rootfinder
+    ROOTFINDER_NUM_IN
+  };
+
+  /// Output arguments of a rootfinder
+  enum RootfinderOutput {
+    /// Solution to the system of equations
+    ROOTFINDER_X,
+    /// Number of output arguments of a rootfinder
+    ROOTFINDER_NUM_OUT
+  };
+  #endif // SWIG
+
+} // namespace casadi
+
+#endif // CASADI_ROOTFINDER_HPP

casadi/include/casadi/core/runtime/casadi_axpy.hpp

@@ -0,0 +1,8 @@
+// NOLINT(legal/copyright)
+// SYMBOL "axpy"
+template<typename T1>
+void casadi_axpy(casadi_int n, T1 alpha, const T1* x, T1* y) {
+  casadi_int i;
+  if (!x || !y) return;
+  for (i=0; i<n; ++i) *y++ += alpha**x++;
+}

casadi/include/casadi/core/runtime/casadi_bfgs.hpp

@@ -0,0 +1,49 @@
+// NOLINT(legal/copyright)
+// SYMBOL "bfgs"
+// BFGS update
+template<typename T1>
+void casadi_bfgs(const casadi_int* sp_h, T1* h, const T1* dx,
+                 const T1* glag, const T1* glag_old, T1* w) {
+  // Local variables
+  casadi_int nx;
+  T1 *yk, *qk, dxBkdx, omega, theta, phi;
+  // Dimension
+  nx = sp_h[0];
+  // Work vectors
+  yk = w; w += nx;
+  qk = w; w += nx;
+  // yk = glag - glag_old
+  casadi_copy(glag, nx, yk);
+  casadi_axpy(nx, -1., glag_old, yk);
+  // qk = H*dx
+  casadi_clear(qk, nx);
+  casadi_mv(h, sp_h, dx, qk, 0);
+  // Calculating theta
+  dxBkdx = casadi_dot(nx, dx, qk);
+  // C-REPLACE "if_else" "casadi_if_else"
+  omega = if_else(casadi_dot(nx, yk, dx) < 0.2 * casadi_dot(nx, dx, qk),
+                  0.8 * dxBkdx / (dxBkdx - casadi_dot(nx, dx, yk)), 1);
+  // yk = omega * yk + (1 - omega) * qk;
+  casadi_scal(nx, omega, yk);
+  casadi_axpy(nx, 1 - omega, qk, yk);
+  theta = 1. / casadi_dot(nx, dx, yk);
+  phi = 1. / casadi_dot(nx, qk, dx);
+  // Update H
+  casadi_rank1(h, sp_h, theta, yk, yk);
+  casadi_rank1(h, sp_h, -phi, qk, qk);
+}
+
+// SYMBOL "bfgs_reset"
+// Removes off-diagonal entries
+template<typename T1>
+void casadi_bfgs_reset(const casadi_int* sp_h, T1* h) {
+  casadi_int ncol, c, k;
+  const casadi_int *colind, *row;
+  ncol = sp_h[1];
+  colind = sp_h+2; row = sp_h+ncol+3;
+  for (c=0; c<ncol; ++c) {
+    for (k=colind[c]; k<colind[c+1]; ++k) {
+      if (c!=row[k]) h[k] = 0;
+    }
+  }
+}

casadi/include/casadi/core/runtime/casadi_bilin.hpp

@@ -0,0 +1,42 @@
+//
+//    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 "bilin"
+template<typename T1>
+T1 casadi_bilin(const T1* A, const casadi_int* sp_A, const T1* x, const T1* y) {
+  casadi_int ncol_A, cc, rr, el;
+  const casadi_int *colind_A, *row_A;
+  T1 ret;
+  // Get sparsities
+  ncol_A = sp_A[1];
+  colind_A = sp_A+2; row_A = sp_A + 2 + ncol_A+1;
+  // Return value
+  ret=0;
+  // Loop over the columns of A
+  for (cc=0; cc<ncol_A; ++cc) {
+    // Loop over the nonzeros of A
+    for (el=colind_A[cc]; el<colind_A[cc+1]; ++el) {
+      // Get the row
+      rr=row_A[el];
+      // Add contribution
+      ret += x[rr]*A[el]*y[cc];
+    }
+  }
+  return ret;
+}

casadi/include/casadi/core/runtime/casadi_bound_consistency.hpp

@@ -0,0 +1,51 @@
+//
+//    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 "fmax" "casadi_fmax"
+// C-REPLACE "fmin" "casadi_fmin"
+// C-REPLACE "std::isinf" "casadi_isinf"
+
+// SYMBOL "bound_consistency"
+template<typename T1>
+void casadi_bound_consistency(casadi_int n, T1* x, T1* lam,
+                                 const T1* lbx, const T1* ubx) {
+    // Local variables
+    casadi_int i;
+    T1 lb, ub;
+    // Loop over variables
+    for (i=0; i<n; ++i) {
+      // Get bounds
+      lb = lbx ? lbx[i] : 0.;
+      ub = ubx ? ubx[i] : 0.;
+      // Make sure bounds are respected
+      x[i] = fmin(fmax(x[i], lb), ub);
+      // Adjust multipliers
+      if (std::isinf(lb) && std::isinf(ub)) {
+        // Both multipliers are infinite
+        lam[i] = 0.;
+      } else if (std::isinf(lb) || x[i] - lb > ub - x[i]) {
+        // Infinite lower bound or closer to upper bound than lower bound
+        lam[i] = fmax(0., lam[i]);
+      } else if (std::isinf(ub) || x[i] - lb < ub - x[i]) {
+        // Infinite upper bound or closer to lower bound than upper bound
+        lam[i] = fmin(0., lam[i]);
+      }
+    }
+}

casadi/include/casadi/core/runtime/casadi_cache.hpp

@@ -0,0 +1,59 @@
+//
+//    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 "cache_check"
+template<typename T1>
+int cache_check(const T1* key, T1* cache, int* loc, casadi_int stride, casadi_int sz, casadi_int key_sz, T1** val) { // NOLINT(whitespace/line_length)
+    char match;
+    int i, c;
+    casadi_int k;
+    T1 *lkey;
+    // Walk through cache locations
+    for (i=0;i<sz;++i) {
+      match = 1;
+      if (loc[i]<0) { // Never filled
+        loc[i] = i;
+        *val = cache + i*stride;
+        break;
+      } else {
+        *val = cache + loc[i]*stride;
+
+        // Check for a key hit
+        lkey = *val;
+        for (k=0;k<key_sz;++k) {
+          if (lkey[k]!=key[k]) {
+            match = 0;
+            break;
+          }
+        }
+      }
+
+      if (match) {
+        // Move current location to front
+        c = loc[i];
+        for (k=i;k>0;--k) loc[k] = loc[k-1];
+        loc[0] = c;
+        // Indicate cache hit
+        return 1;
+      }
+    }
+
+    // Indicate cache miss
+    return 0;
+}

casadi/include/casadi/core/runtime/casadi_clear.hpp

@@ -0,0 +1,27 @@
+//
+//    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 "clear"
+template<typename T1>
+void casadi_clear(T1* x, casadi_int n) {
+  casadi_int i;
+  if (x) {
+    for (i=0; i<n; ++i) *x++ = 0;
+  }
+}

casadi/include/casadi/core/runtime/casadi_clip_max.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 "clip_max"
+template<typename T1>
+void casadi_clip_max(T1* x, casadi_int n, T1 max, const casadi_int* mask) {
+  casadi_int i;
+  if (x) {
+    for (i=0; i<n; ++i) {
+      if (!mask || mask[i]) {
+        if (x[i] > max) {
+          x[i] = max;
+        }
+      }
+    }
+  }
+}

casadi/include/casadi/core/runtime/casadi_clip_min.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 "clip_min"
+template<typename T1>
+void casadi_clip_min(T1* x, casadi_int n, T1 min, const casadi_int* mask) {
+  casadi_int i;
+  if (x) {
+    for (i=0; i<n; ++i) {
+      if (!mask || mask[i]) {
+        if (x[i] < min) {
+          x[i] = min;
+        }
+      }
+    }
+  }
+}