casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/trlib/trlib_tri_factor.h

@@ -0,0 +1,409 @@
+/* MIT License
+ *
+ * Copyright (c) 2016--2017 Felix Lenders
+ *
+ * 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, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * 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.
+ *
+ */
+
+#ifndef TRLIB_TRI_FACTOR_H
+#define TRLIB_TRI_FACTOR_H
+
+#define TRLIB_TTR_CONV_BOUND    (0)
+#define TRLIB_TTR_CONV_INTERIOR (1)
+#define TRLIB_TTR_HARD          (2)
+#define TRLIB_TTR_NEWTON_BREAK  (3)
+#define TRLIB_TTR_HARD_INIT_LAM (4)
+#define TRLIB_TTR_ITMAX         (-1)
+#define TRLIB_TTR_FAIL_FACTOR   (-2)
+#define TRLIB_TTR_FAIL_LINSOLVE (-3)
+#define TRLIB_TTR_FAIL_EIG      (-4)
+#define TRLIB_TTR_FAIL_LM       (-5)
+#define TRLIB_TTR_FAIL_HARD     (-10)
+
+/** Solves tridiagonal trust region subproblem
+ *
+ *  Computes minimizer to
+ * 
+ *  :math:`\min \frac 12 \langle h, T h \rangle + \langle g, h \rangle`
+ *  subject to the trust region constraint :math:`\Vert h \Vert \le r`,
+ *  where :math:`T \in \mathbb R^{n \times n}` is symmetric tridiagonal.
+ *
+ *  Let :math:`T = \begin{pmatrix} T_1 & & \\ & \ddots & \\ & & T_\ell \end{pmatrix}`
+ *  be composed into irreducible blocks :math:`T_i`.
+ * 
+ *  The minimizer is a global minimizer (modulo floating point).
+ * 
+ *  The algorithm is the Moré-Sorensen-Method as decribed as Algorithm 5.2 in [Gould1999]_.
+ *
+ *  **Convergence**
+ *  
+ *  Exit with success is reported in several cases:
+ *
+ *      - interior solution: the stationary point :math:`T h = - g` is suitable, iterative refinement is used in the solution of this system.
+ *      - hard case: the smallest eigenvalue :math:`-\theta` was found to be degenerate and :math:`h = v + \alpha w` is returned with :math:`v` solution of :math:`(T + \theta I) v = -g`, :math:`w` eigenvector corresponding to :math:`- \theta` and :math:`\alpha` chosen to satisfy the trust region constraint and being a minimizer.
+ *      - boundary and hard case: convergence in Newton iteration is reported if :math:`\Vert h(\lambda) \Vert - r \le \texttt{tol}\_\texttt{rel} \, r` with :math:`(T+\lambda I) h(\lambda) = -g`, Newton breakdown reported if :math:`\vert d\lambda \vert \le \texttt{macheps} \vert \lambda \vert`.
+ *
+ *  :param nirblk: number of irreducible blocks :math:`\ell`, ensure :math:`\ell > 0`
+ *  :type nirblk: trlib_int_t, input
+ *  :param irblk: pointer to indices of irreducible blocks, length :c:data:`nirblk+1`:
+ *
+ *                 - :c:data:`irblk[i]` is the start index of block :math:`i` in :c:data:`diag` and :c:data:`offdiag`
+ *                 - :c:data:`irblk[i+1] - 1` is the stop index of block :math:`i`
+ *                 - :c:data:`irblk[i+1] - irred[i]` the dimension :math:`n_\ell` of block :math:`i`
+ *                 - :c:data:`irblk[nirred]` the dimension of :math:`T`
+ *
+ *  :type irblk: trlib_int_t, input
+ *  :param diag: pointer to array holding diagonal of :math:`T`, length :c:data:`irblk[nirblk]`
+ *  :type diag: trlib_flt_t, input
+ *  :param offdiag: pointer to array holding offdiagonal of :math:`T`, length :c:data:`irblk[nirblk]`
+ *  :type offdiag: trlib_flt_t, input
+ *  :param neglin: pointer to array holding :math:`-g`, length :c:data:`n`
+ *  :type neglin: trlib_flt_t, input
+ *  :param radius: trust region constraint radius :math:`r`
+ *  :type radius: trlib_flt_t, input
+ *  :param itmax: maximum number of Newton iterations
+ *  :type itmax: trlib_int_t, input
+ *  :param tol_rel: relative stopping tolerance for residual in Newton iteration for :c:data:`lam`, good default may be :math:`\texttt{macheps}` (:c:macro:`TRLIB_EPS`)
+ *  :type tol_rel: trlib_flt_t, input
+ *  :param tol_newton_tiny: stopping tolerance for step in Newton iteration for :c:data:`lam`, good default may be :math:`10 \texttt{macheps}^{.75}`
+ *  :type tol_newton_tiny: trlib_flt_t, input
+ *  :param pos_def: set ``1`` if you know :math:`T` to be positive definite, otherwise ``0``
+ *  :type pos_def: trlib_int_t, input
+ *  :param equality: set ``1`` if you want to enfore trust region constraint as equality, otherwise ``0``
+ *  :type equality: trlib_int_t, input
+ *  :param warm0: set ``1`` if you provide a valid value in :c:data:`lam0`, otherwise ``0``
+ *  :type warm0: trlib_int_t, input/output
+ *  :param lam0: Lagrange multiplier such that :math:`T_0+ \mathtt{lam0} I` positive definite
+ *                 and :math:`(T_0+ \mathtt{lam0} I) \mathtt{sol0} = \mathtt{neglin}`
+ *                 - on entry: estimate suitable for warmstart
+ *                 - on exit: computed multiplier
+ *  :type lam0: trlib_flt_t, input/output
+ *  :param warm: set ``1`` if you provide a valid value in :c:data:`lam`, otherwise ``0``
+ *  :type warm: trlib_int_t, input/output
+ *  :param lam: Lagrange multiplier such that :math:`T+ \mathtt{lam} I` positive definite
+ *                 and :math:`(T+ \mathtt{lam} I) \mathtt{sol} = \mathtt{neglin}`
+ *                 - on entry: estimate suitable for warmstart
+ *                 - on exit: computed multiplier
+ *  :type lam: trlib_flt_t, input/output
+ *  :param warm_leftmost:
+ *                 - on entry: set ``1`` if you provide a valid value in leftmost section in :c:data:`fwork`
+ *                 - on exit: ``1`` if leftmost section in :c:data:`fwork` holds valid exit value, otherwise ``0``
+ *  :type warm_leftmost: trlib_int_t, input/output
+ *  :param ileftmost: index to block with smallest leftmost eigenvalue
+ *  :type ileftmost: trlib_int_t, input/output
+ *  :param leftmost: array holding leftmost eigenvalues of blocks
+ *  :type leftmost: trlib_flt_t, input/output
+ *  :param warm_fac0: set ``1`` if you provide a valid factoricization in :c:data:`diag_fac0`, :c:data:`offdiag_fac0`
+ *  :type warm_fac0: trlib_int_t, input/output
+ *  :param diag_fac0: pointer to array holding diagonal of Cholesky factorization of :math:`T_0 + \texttt{lam0} I`, length :c:data:`irblk[1]`
+ *                 - on entry: factorization corresponding to provided estimation :c:data:`lam0` on entry
+ *                 - on exit: factorization corresponding to computed multiplier :c:data:`lam0`
+ *  :type diag_fac0: trlib_flt_t, input/output
+ *  :param offdiag_fac0: pointer to array holding offdiagonal of Cholesky factorization of :math:`T_0 + \texttt{lam0} I`, length :c:data:`irblk[1]-1`
+ *                 - on entry: factorization corresponding to provided estimation :c:data:`lam0` on entry
+ *                 - on exit: factorization corresponding to computed multiplier :c:data:`lam0`
+ *  :type offdiag_fac0: trlib_flt_t, input/output
+ *  :param warm_fac: set ``1`` if you provide a valid factoricization in :c:data:`diag_fac`, :c:data:`offdiag_fac`
+ *  :type warm_fac: trlib_int_t, input/output
+ *  :param diag_fac: pointer to array of length :c:data:`n` that holds the following:
+ *                 - let :math:`j = \texttt{ileftmost}` and :math:`\theta = - \texttt{leftmost[ileftmost]}`
+ *                 - on position :math:`0, \ldots, \texttt{irblk[1]}`: diagonal of factorization of :math:`T_0 + \theta I`
+ *                 - other positions have to be allocated
+ *  :type diag_fac: trlib_flt_t, input/output
+ *  :param offdiag_fac: pointer to array of length :c:data:`n-1` that holds the following:
+ *                 - let :math:`j = \texttt{ileftmost}` and :math:`\theta = - \texttt{leftmost[ileftmost]}`
+ *                 - on position :math:`0, \ldots, \texttt{irblk[1]}-1`: offdiagonal of factorization of :math:`T_0 + \theta I`
+ *                 - other positions have to be allocated
+ *  :type offdiag_fac: trlib_flt_t, input/output
+ *  :param sol0: pointer to array holding solution, length :c:data:`irblk[1]`
+ *  :type sol0: trlib_flt_t, input/output
+ *  :param sol: pointer to array holding solution, length :c:data:`n`
+ *  :type sol: trlib_flt_t, input/output
+ *  :param ones: array with every value ``1.0``, length :c:data:`n`
+ *  :type ones: trlib_flt_t, input
+ *  :param fwork: floating point workspace, must be allocated memory on input of size :c:func:`trlib_tri_factor_memory_size` (call with argument :c:data:`n`) and can be discarded on output, memory layout:
+ *
+ *      ============== ============== ==========================================================
+ *      start          end (excl)     description
+ *      ============== ============== ==========================================================
+ *                 0     :c:data:`n`  auxiliary vector
+ *        :c:data:`n`  2 :c:data:`n`  holds diagonal of :math:`T + \lambda I`
+ *      2 :c:data:`n`  4 :c:data:`n`  workspace for iterative refinement
+ *      ============== ============== ==========================================================
+ *
+ *  :type fwork: trlib_flt_t, input/output
+ *  :param refine: set to ``1`` if iterative refinement should be used on solving linear systems, otherwise to ``0``
+ *  :type refine: trlib_int_t, input
+ *  :param verbose: determines the verbosity level of output that is written to :c:data:`fout`
+ *  :type verbose: trlib_int_t, input
+ *  :param unicode: set to ``1`` if :c:data:`fout` can handle unicode, otherwise to ``0``
+ *  :type unicode: trlib_int_t, input
+ *  :param prefix: string that is printed before iteration output
+ *  :type prefix: char, input
+ *  :param fout: output stream
+ *  :type fout: FILE, input
+ *  :param timing: gives timing details, provide allocated zero initialized memory of length :c:func:`trlib_tri_timing_size`
+ *
+ *      ====== ================================
+ *      block   description
+ *      ====== ================================
+ *      0       total duration
+ *      1       timing of linear algebra calls
+ *      2       :c:data:`timing` from :c:func:`trlib_leftmost_irreducible`
+ *      3       :c:data:`timing` from :c:func:`trlib_eigen_inverse`
+ *      ====== ================================
+ *
+ *  :type timing: trlib_int_t, input/output
+ *  :param obj: objective function value at solution point
+ *  :type obj: trlib_flt_t, output
+ *  :param iter_newton: number of Newton iterations
+ *  :type iter_newton: trlib_int_t, output
+ *  :param sub_fail: status code of subroutine if failure occured in subroutines called
+ *  :type sub_fail: trlib_int_t, output
+ *
+ *  :returns: status
+ *
+ *      - :c:macro:`TRLIB_TTR_CONV_BOUND`    success with solution on boundary
+ *      - :c:macro:`TRLIB_TTR_CONV_INTERIOR` success with interior solution
+ *      - :c:macro:`TRLIB_TTR_HARD`          success, but hard case encountered and solution may be approximate  
+ *      - :c:macro:`TRLIB_TTR_NEWTON_BREAK`  most likely success with accurate result; premature end of Newton iteration due to tiny step
+ *      - :c:macro:`TRLIB_TTR_HARD_INIT_LAM` hard case encountered without being able to find suitable initial :math:`\lambda` for Newton iteration, returned approximate stationary point that maybe suboptimal
+ *      - :c:macro:`TRLIB_TTR_ITMAX`         iteration limit exceeded
+ *      - :c:macro:`TRLIB_TTR_FAIL_FACTOR`   failure on matrix factorization
+ *      - :c:macro:`TRLIB_TTR_FAIL_LINSOLVE` failure on backsolve
+ *      - :c:macro:`TRLIB_TTR_FAIL_EIG`      failure on eigenvalue computation. status code of :c:func:`trlib_eigen_inverse` in :c:data:`sub_fail`
+ *      - :c:macro:`TRLIB_TTR_FAIL_LM`       failure on leftmost eigenvalue computation. status code of :c:func:`trlib_leftmost_irreducible` in :c:data:`sub_fail`
+ *  :rtype: trlib_int_t
+ */
+
+trlib_int_t trlib_tri_factor_min(
+    trlib_int_t nirblk, trlib_int_t *irblk, trlib_flt_t *diag, trlib_flt_t *offdiag,
+    trlib_flt_t *neglin, trlib_flt_t radius, 
+    trlib_int_t itmax, trlib_flt_t tol_rel, trlib_flt_t tol_newton_tiny,
+    trlib_int_t pos_def, trlib_int_t equality,
+    trlib_int_t *warm0, trlib_flt_t *lam0, trlib_int_t *warm, trlib_flt_t *lam,
+    trlib_int_t *warm_leftmost, trlib_int_t *ileftmost, trlib_flt_t *leftmost,
+    trlib_int_t *warm_fac0, trlib_flt_t *diag_fac0, trlib_flt_t *offdiag_fac0,
+    trlib_int_t *warm_fac, trlib_flt_t *diag_fac, trlib_flt_t *offdiag_fac,
+    trlib_flt_t *sol0, trlib_flt_t *sol, trlib_flt_t *ones, trlib_flt_t *fwork,
+    trlib_int_t refine,
+    trlib_int_t verbose, trlib_int_t unicode, char *prefix, FILE *fout,
+    trlib_int_t *timing, trlib_flt_t *obj, trlib_int_t *iter_newton, trlib_int_t *sub_fail);
+
+/** Computes minimizer of regularized unconstrained problem
+ *
+ *  Computes minimizer of
+ * 
+ *  :math:`\min \frac 12 \langle h, (T + \lambda I) h \rangle + \langle g, h \rangle`,
+ *  where :math:`T \in \mathbb R^{n \times n}` is symmetric tridiagonal and :math:`\lambda` such that :math:`T + \lambda I` is spd.
+ *
+ *  :param n: dimension, ensure :math:`n > 0`
+ *  :type n: trlib_int_t, input
+ *  :param diag: pointer to array holding diagonal of :math:`T`, length :c:data:`n`
+ *  :type diag: trlib_flt_t, input
+ *  :param offdiag: pointer to array holding offdiagonal of :math:`T`, length :c:data:`n-1`
+ *  :type offdiag: trlib_flt_t, input
+ *  :param neglin: pointer to array holding :math:`-g`, length :c:data:`n`
+ *  :type neglin: trlib_flt_t, input
+ *  :param lam: regularization parameter :math:`\lambda`
+ *  :type lam: trlib_flt_t, input
+ *  :param sol: pointer to array holding solution, length :c:data:`n`
+ *  :type sol: trlib_flt_t, input/output
+ *  :param ones: array with every value ``1.0``, length :c:data:`n`
+ *  :type ones: trlib_flt_t, input
+ *  :param fwork: floating point workspace, must be allocated memory on input of size :c:func:`trlib_tri_factor_memory_size` (call with argument :c:data:`n`) and can be discarded on output, memory layout:
+ *
+ *      ============== ============== ==========================================================
+ *      start          end (excl)     description
+ *      ============== ============== ==========================================================
+ *                 0     :c:data:`n`  holds diagonal of :math:`T + \lambda I`
+ *        :c:data:`n`  2 :c:data:`n`  holds diagonal of factorization :math:`T + \lambda I`
+ *      2 :c:data:`n`  3 :c:data:`n`  holds offdiagonal of factorization :math:`T + \lambda I`
+ *      3 :c:data:`n`  5 :c:data:`n`  workspace for iterative refinement
+ *      ============== ============== ==========================================================
+ *
+ *  :type fwork: trlib_flt_t, input/output
+ *  :param refine: set to ``1`` if iterative refinement should be used on solving linear systems, otherwise to ``0``
+ *  :type refine: trlib_int_t, input
+ *  :param verbose: determines the verbosity level of output that is written to :c:data:`fout`
+ *  :type verbose: trlib_int_t, input
+ *  :param unicode: set to ``1`` if :c:data:`fout` can handle unicode, otherwise to ``0``
+ *  :type unicode: trlib_int_t, input
+ *  :param prefix: string that is printed before iteration output
+ *  :type prefix: char, input
+ *  :param fout: output stream
+ *  :type fout: FILE, input
+ *  :param timing: gives timing details, provide allocated zero initialized memory of length :c:func:`trlib_tri_timing_size`
+ *
+ *      ====== ================================
+ *      block   description
+ *      ====== ================================
+ *      0       total duration
+ *      1       timing of linear algebra calls
+ *      ====== ================================
+ *
+ *  :type timing: trlib_int_t, input/output
+ *  :param norm_sol: norm of solution fector
+ *  :type norm_sol: trlib_flt_t, output
+ *  :param sub_fail: status code of subroutine if failure occured in subroutines called
+ *  :type sub_fail: trlib_int_t, output
+ *
+ *  :returns: status
+ *
+ *      - :c:macro:`TRLIB_TTR_CONV_INTERIOR` success with interior solution
+ *      - :c:macro:`TRLIB_TTR_FAIL_FACTOR`   failure on matrix factorization
+ *      - :c:macro:`TRLIB_TTR_FAIL_LINSOLVE` failure on backsolve
+ *
+ *  :rtype: trlib_int_t
+ */
+
+trlib_int_t trlib_tri_factor_regularized_umin(
+    trlib_int_t n, trlib_flt_t *diag, trlib_flt_t *offdiag,
+    trlib_flt_t *neglin, trlib_flt_t lam,
+    trlib_flt_t *sol,
+    trlib_flt_t *ones, trlib_flt_t *fwork,
+    trlib_int_t refine,
+    trlib_int_t verbose, trlib_int_t unicode, char *prefix, FILE *fout,
+    trlib_int_t *timing, trlib_flt_t *norm_sol, trlib_int_t *sub_fail);
+
+/** Computes regularization parameter needed in trace
+ *
+ *  Let :math:`s(\lambda)` be solution of :math:`(T + \lambda I) s(\lambda) + g  = 0`,
+ *  where :math:`T \in \mathbb R^{n \times n}` is symmetric tridiagonal and :math:`\lambda` such that :math:`T + \lambda I` is spd.
+ *
+ *  Then find :math:`\lambda` with :math:`\sigma_{\text l} \le \frac{\lambda}{s(\lambda)} \le \sigma_{\text u}`.
+ *
+ *  :param n: dimension, ensure :math:`n > 0`
+ *  :type n: trlib_int_t, input
+ *  :param diag: pointer to array holding diagonal of :math:`T`, length :c:data:`n`
+ *  :type diag: trlib_flt_t, input
+ *  :param offdiag: pointer to array holding offdiagonal of :math:`T`, length :c:data:`n-1`
+ *  :type offdiag: trlib_flt_t, input
+ *  :param neglin: pointer to array holding :math:`-g`, length :c:data:`n`
+ *  :type neglin: trlib_flt_t, input
+ *  :param lam: regularization parameter :math:`\lambda`, on input initial guess, on exit desired parameter
+ *  :type lam: trlib_flt_t, input/output
+ *  :param sigma: value that is used in root finding, e.g. :math:`\frac 12 (\sigma_{\text l} + \sigma_{\text u})`
+ *  :type sigma: trlib_flt_t, input
+ *  :param sigma_l: lower bound
+ *  :type sigma_l: trlib_flt_t, input
+ *  :param sigma_u: upper bound
+ *  :type sigma_u: trlib_flt_t, input
+ *  :param sol: pointer to array holding solution, length :c:data:`n`
+ *  :type sol: trlib_flt_t, input/output
+ *  :param ones: array with every value ``1.0``, length :c:data:`n`
+ *  :type ones: trlib_flt_t, input
+ *  :param fwork: floating point workspace, must be allocated memory on input of size :c:func:`trlib_tri_factor_memory_size` (call with argument :c:data:`n`) and can be discarded on output, memory layout:
+ *
+ *      ============== ============== ==========================================================
+ *      start          end (excl)     description
+ *      ============== ============== ==========================================================
+ *                 0     :c:data:`n`  holds diagonal of :math:`T + \lambda I`
+ *        :c:data:`n`  2 :c:data:`n`  holds diagonal of factorization :math:`T + \lambda I`
+ *      2 :c:data:`n`  3 :c:data:`n`  holds offdiagonal of factorization :math:`T + \lambda I`
+ *      3 :c:data:`n`  5 :c:data:`n`  workspace for iterative refinement
+ *      5 :c:data:`n`  6 :c:data:`n`  auxiliary vector
+ *      ============== ============== ==========================================================
+ *
+ *  :type fwork: trlib_flt_t, input/output
+ *  :param refine: set to ``1`` if iterative refinement should be used on solving linear systems, otherwise to ``0``
+ *  :type refine: trlib_int_t, input
+ *  :param verbose: determines the verbosity level of output that is written to :c:data:`fout`
+ *  :type verbose: trlib_int_t, input
+ *  :param unicode: set to ``1`` if :c:data:`fout` can handle unicode, otherwise to ``0``
+ *  :type unicode: trlib_int_t, input
+ *  :param prefix: string that is printed before iteration output
+ *  :type prefix: char, input
+ *  :param fout: output stream
+ *  :type fout: FILE, input
+ *  :param timing: gives timing details, provide allocated zero initialized memory of length :c:func:`trlib_tri_timing_size`
+ *
+ *      ====== ================================
+ *      block   description
+ *      ====== ================================
+ *      0       total duration
+ *      1       timing of linear algebra calls
+ *      ====== ================================
+ *
+ *  :type timing: trlib_int_t, input/output
+ *  :param norm_sol: norm of solution fector
+ *  :type norm_sol: trlib_flt_t, output
+ *  :param sub_fail: status code of subroutine if failure occured in subroutines called
+ *  :type sub_fail: trlib_int_t, output
+ *
+ *  :returns: status
+ *
+ *      - :c:macro:`TRLIB_TTR_CONV_INTERIOR` success with interior solution
+ *      - :c:macro:`TRLIB_TTR_FAIL_FACTOR`   failure on matrix factorization
+ *      - :c:macro:`TRLIB_TTR_FAIL_LINSOLVE` failure on backsolve
+ *
+ *  :rtype: trlib_int_t
+ */
+
+trlib_int_t trlib_tri_factor_get_regularization(
+    trlib_int_t n, trlib_flt_t *diag, trlib_flt_t *offdiag,
+    trlib_flt_t *neglin, trlib_flt_t *lam,
+    trlib_flt_t sigma, trlib_flt_t sigma_l, trlib_flt_t sigma_u,
+    trlib_flt_t *sol,
+    trlib_flt_t *ones, trlib_flt_t *fwork,
+    trlib_int_t refine,
+    trlib_int_t verbose, trlib_int_t unicode, char *prefix, FILE *fout,
+    trlib_int_t *timing, trlib_flt_t *norm_sol, trlib_int_t *sub_fail);
+
+/** Compute diagonal regularization to make tridiagonal matrix positive definite
+ *
+ *  :param n: dimension, ensure :math:`n > 0`
+ *  :type n: trlib_int_t, input
+ *  :param diag: pointer to array holding diagonal of :math:`T`, length :c:data:`n`
+ *  :type diag: trlib_flt_t, input
+ *  :param offdiag: pointer to array holding offdiagonal of :math:`T`, length :c:data:`n-1`
+ *  :type offdiag: trlib_flt_t, input
+ *  :param tol_away: tolerance that diagonal entries in factorization should be away from zero, relative to previous entry. Good default :math:`10^{-12}`.
+ *  :type tol_away: trlib_flt_t, input
+ *  :param security_step: factor greater ``1.0`` that defines a margin to get away from zero in the step taken. Good default ``2.0``.
+ *  :type security_step: trlib_flt_t, input
+ *  :param regdiag: pointer to array holding regularization term, length :c:data:`n`
+ *  :type regdiag: trlib_flt_t, input/output
+ *
+ *  :returns: ``0``
+ *  :rtype: trlib_int_t
+ */
+trlib_int_t trlib_tri_factor_regularize_posdef(
+    trlib_int_t n, trlib_flt_t *diag, trlib_flt_t *offdiag,
+    trlib_flt_t tol_away, trlib_flt_t security_step, trlib_flt_t *regdiag);
+
+/** Gives information on memory that has to be allocated for :c:func:`trlib_tri_factor_min`
+ *  
+ *  :param n: dimension, ensure :math:`n > 0`
+ *  :type n: trlib_int_t, input
+ *  :param fwork_size: size of floating point workspace fwork that has to be allocated for :c:func:`trlib_tri_factor_min`
+ *  :type fwork_size: trlib_flt_t, output
+ *  
+ *  :returns: ``0``
+ *  :rtype: trlib_int_t
+ */
+
+trlib_int_t trlib_tri_factor_memory_size(trlib_int_t n);
+
+/** size that has to be allocated for :c:data:`timing` in :c:func:`trlib_tri_factor_min`
+ */
+trlib_int_t trlib_tri_timing_size(void);
+
+#endif

casadi/include/trlib/trlib_types.h

@@ -0,0 +1,36 @@
+/* MIT License
+ *
+ * Copyright (c) 2016--2017 Felix Lenders
+ *
+ * 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, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * 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.
+ *
+ */
+
+#ifndef TRLIB_TYPES_H
+#define TRLIB_TYPES_H
+
+typedef long trlib_int_t;
+typedef double trlib_flt_t;
+
+#define TRLIB_EPS            (2.2204460492503131e-16)
+#define TRLIB_EPS_POW_4      (5.4774205922939014e-07)
+#define TRLIB_EPS_POW_5      (1.4901161193847656e-08)
+#define TRLIB_EPS_POW_75     (1.8189894035458565e-12)
+
+#endif

casadi/include/trlib.h

@@ -0,0 +1,44 @@
+/* MIT License
+ *
+ * Copyright (c) 2016--2017 Felix Lenders
+ *
+ * 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, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * 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.
+ *
+ */
+
+#ifndef TRLIB_H
+#define TRLIB_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include "trlib/trlib_types.h"
+#include "trlib/trlib_eigen_inverse.h"
+#include "trlib/trlib_krylov.h"
+#include "trlib/trlib_leftmost.h"
+#include "trlib/trlib_quadratic_zero.h"
+#include "trlib/trlib_tri_factor.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

casadi/lib/cmake/tinyxml2/tinyxml2-config-version.cmake

@@ -0,0 +1,65 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version,
+# but only if the requested major version is the same as the current one.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+
+set(PACKAGE_VERSION "9.0.0")
+
+if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+
+  if("9.0.0" MATCHES "^([0-9]+)\\.")
+    set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}")
+    if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0)
+      string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}")
+    endif()
+  else()
+    set(CVF_VERSION_MAJOR "9.0.0")
+  endif()
+
+  if(PACKAGE_FIND_VERSION_RANGE)
+    # both endpoints of the range must have the expected major version
+    math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1")
+    if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+        OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR)
+          OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT)))
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+        AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX)))
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+  else()
+    if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR)
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
+  return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")
+  math(EXPR installedBits "8 * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()

casadi/lib/cmake/tinyxml2/tinyxml2-config.cmake

@@ -0,0 +1,57 @@
+cmake_minimum_required(VERSION 3.15)
+
+set(tinyxml2_known_comps static shared)
+set(tinyxml2_comp_static NO)
+set(tinyxml2_comp_shared NO)
+foreach (tinyxml2_comp IN LISTS ${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS)
+    if (tinyxml2_comp IN_LIST tinyxml2_known_comps)
+        set(tinyxml2_comp_${tinyxml2_comp} YES)
+    else ()
+        set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE
+            "tinyxml2 does not recognize component `${tinyxml2_comp}`.")
+        set(${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE)
+        return()
+    endif ()
+endforeach ()
+
+if (tinyxml2_comp_static AND tinyxml2_comp_shared)
+    set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE
+        "tinyxml2 `static` and `shared` components are mutually exclusive.")
+    set(${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE)
+    return()
+endif ()
+
+set(tinyxml2_static_targets "${CMAKE_CURRENT_LIST_DIR}/tinyxml2-static-targets.cmake")
+set(tinyxml2_shared_targets "${CMAKE_CURRENT_LIST_DIR}/tinyxml2-shared-targets.cmake")
+
+macro(tinyxml2_load_targets type)
+    if (NOT EXISTS "${tinyxml2_${type}_targets}")
+        set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE
+            "tinyxml2 `${type}` libraries were requested but not found.")
+        set(${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE)
+        return()
+    endif ()
+    include("${tinyxml2_${type}_targets}")
+endmacro()
+
+if (tinyxml2_comp_static)
+    tinyxml2_load_targets(static)
+elseif (tinyxml2_comp_shared)
+    tinyxml2_load_targets(shared)
+elseif (DEFINED tinyxml2_SHARED_LIBS AND tinyxml2_SHARED_LIBS)
+    tinyxml2_load_targets(shared)
+elseif (DEFINED tinyxml2_SHARED_LIBS AND NOT tinyxml2_SHARED_LIBS)
+    tinyxml2_load_targets(static)
+elseif (BUILD_SHARED_LIBS)
+    if (EXISTS "${tinyxml2_shared_targets}")
+        tinyxml2_load_targets(shared)
+    else ()
+        tinyxml2_load_targets(static)
+    endif ()
+else ()
+    if (EXISTS "${tinyxml2_static_targets}")
+        tinyxml2_load_targets(static)
+    else ()
+        tinyxml2_load_targets(shared)
+    endif ()
+endif ()

casadi/lib/cmake/tinyxml2/tinyxml2-static-targets-release.cmake

@@ -0,0 +1,19 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "tinyxml2::tinyxml2" for configuration "Release"
+set_property(TARGET tinyxml2::tinyxml2 APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(tinyxml2::tinyxml2 PROPERTIES
+  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libtinyxml2.a"
+  )
+
+list(APPEND _cmake_import_check_targets tinyxml2::tinyxml2 )
+list(APPEND _cmake_import_check_files_for_tinyxml2::tinyxml2 "${_IMPORT_PREFIX}/lib/libtinyxml2.a" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)