casadi 3.6.4__cp38-none-win_amd64.whl → 3.6.6__cp38-none-win_amd64.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/highs-external/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 HiGHS
-
-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.

casadi-3.6.4.dist-info/METADATA

@@ -1,37 +0,0 @@
-Metadata-Version: 2.0
-Name: casadi
-Version: 3.6.4
-Summary: CasADi -- framework for algorithmic differentiation and numeric optimization
-Home-page: http://casadi.org
-Author: Joel Andersson, Joris Gillis, Greg Horn
-Author-email:  developer_first_name@casadi.org
-License: GNU Lesser General Public License v3 or later (LGPLv3+)
-Download-URL: http://casadi.org
-Platform: Windows
-Platform: Linux
-Platform: Mac OS-X
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved
-Classifier: Programming Language :: C++
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Topic :: Scientific/Engineering
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX
-Classifier: Operating System :: Unix
-Classifier: Operating System :: MacOS
-Requires-Dist: numpy
-
-CasADi is a symbolic framework for numeric optimization implementing automatic differentiation in forward and reverse modes on sparse matrix-valued computational graphs. It supports self-contained C-code generation and interfaces state-of-the-art codes such as SUNDIALS, IPOPT etc. It can be used from C++, Python or Matlab/Octave.