casadi 3.6.4__cp39-none-macosx_11_0_arm64.whl → 3.6.6__cp39-none-macosx_11_0_arm64.whl

casadi/include/include/trlib/trlib_tri_factor.h

@@ -1,409 +0,0 @@
-/* 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/include/trlib/trlib_types.h

@@ -1,36 +0,0 @@
-/* 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/licenses/alpaqa-external/LICENSE

@@ -1,165 +0,0 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.