casadi 3.6.3__cp311-none-manylinux2014_i686.whl → 3.6.4__cp311-none-manylinux2014_i686.whl

casadi/include/trlib/trlib_leftmost.h

@@ -0,0 +1,181 @@
+/* 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_LEFTMOST_H
+#define TRLIB_LEFTMOST_H
+
+#define TRLIB_LMR_CONV          (0)
+#define TRLIB_LMR_ITMAX         (-1)
+#define TRLIB_LMR_NEWTON_BREAK  (3)
+
+/** Computes smallest eigenvalue of symmetric tridiagonal matrix
+ *  :math:`T \in \mathbb R^{n\times n}`,
+ *  using a iteration based on last-pivot function of Parlett and Reid.
+ *
+ *  Let :math:`T = \begin{pmatrix} T_1 & & \\ & \ddots & \\ & & T_\ell \end{pmatrix}`
+ *  be composed into irreducible blocks :math:`T_i`.
+ *  
+ *  Calls :c:func:`trlib_leftmost_irreducible` on every irreducible block in case of coldstart,
+ *  in case of warmstart just updates information on :math:`T_\ell`.
+ *
+ *  :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 warm: set :math:`\ge 1` if you want to update information about block :math:`\ell`, provide values in :c:data:`leftmost_minor`, :c:data:`ileftmost`, :c:data:`leftmost`; else ``0``
+ *  :type warm: trlib_int_t, input
+ *  :param leftmost_minor: smallest eigenvalue of principal :math:`(n_\ell-1)\times (n_\ell-1)` submatrix of :math:`T_\ell`
+ *  :type leftmost_minor: trlib_flt_t, input
+ *  :param itmax: maximum number of iterations
+ *  :type itmax: trlib_int_t, input
+ *  :param tol_abs: absolute stopping tolerance in Reid-Parlett zero finding, good default may be :math:`\sqrt{\texttt{macheps}}^{3/4}` (:c:macro:`TRLIB_EPS_POW_75`)
+ *  :type tol_abs: trlib_flt_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_leftmost_timing_size`
+ *
+ *      ====== ================================
+ *      block   description
+ *      ====== ================================
+ *      0       total duration
+ *      ====== ================================
+ *
+ *  :type timing: trlib_int_t, input/output
+ *  :param ileftmost: index of block that corresponds to absolute smallest eigenvalue
+ *  :type ileftmost: trlib_int_t, input/output
+ *  :param leftmost: smallest eigenvalue of :math:`T`, length :math:`\ell`
+ *
+ *      - on entry: allocated memory
+ *      - on exit: :c:data:`leftmost[i]` smallest eigenvalue of :math:`T_i`
+ *
+ *  :type leftmost: trlib_flt_t, input/output
+ *  :returns:      status
+ *
+ *                 - :c:macro:`TRLIB_LMR_CONV`          success
+ *                 - :c:macro:`TRLIB_LMR_ITMAX`         iteration limit exceeded
+ *
+ *  :rtype: trlib_int_t
+ */
+
+trlib_int_t trlib_leftmost(
+        trlib_int_t nirblk, trlib_int_t *irblk, trlib_flt_t *diag, trlib_flt_t *offdiag,
+        trlib_int_t warm, trlib_flt_t leftmost_minor, trlib_int_t itmax, trlib_flt_t tol_abs,
+        trlib_int_t verbose, trlib_int_t unicode, char *prefix, FILE *fout,
+        trlib_int_t *timing, trlib_int_t *ileftmost, trlib_flt_t *leftmost);
+
+/** Computes smallest eigenvalue of irreducible symmetric tridiagonal matrix
+ *  :math:`T \in \mathbb R^{n\times n}`,
+ *  using a iteration based on last-pivot function of Parlett and Reid.
+ *  
+ *  Method is sketched on p. 516 in [Gould1999]_.
+ *
+ *  Note that this function most likely will fail in the case of a reducible matrix
+ *  (:c:data:`offdiag` contains 0).
+ *
+ *  **Convergence**
+ *  
+ *  Convergence is reported if :math:`\texttt{up}-\texttt{low} \le \texttt{tol}\_\texttt{abs} * \max\{1, \vert \texttt{low} \vert, \vert \texttt{up} \vert \}` or :math:`\texttt{prlp} \le \texttt{tol}\_\texttt{abs}`, :math:`\texttt{low}` and :math:`\texttt{up}` denote bracket values enclosing the leftmost eigenvalue and :math:`\texttt{prlp}` denotes the last-pivot function value used in root finding.
+ *
+ *  :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  warm: set :math:`\ge 1` if you provide a valid value in :c:data:`leftmost_minor`, else ``0``. Exact value determines which model will be used for zero-finding
+ *
+ *      ===== ======
+ *      warm  model
+ *      ===== ======
+ *      0     linear model for rational function
+ *      1     sensible heuristic model choice for lifted rational function
+ *      2     asymptotic quadratic model :math:`\theta^2 + b \theta + c` for lifted rational function
+ *      3     taylor quadratic model :math:`a \theta^2 + b \theta + c` for lifted rational function
+ *      4     linear model :math:`b \theta + c` for lifted rational function
+ *      ===== ======
+ *
+ *  :type warm: trlib_int_t, input
+ *  :param leftmost_minor: smallest eigenvalue of principal :math:`(n-1)\times (n-1)` submatrix of :math:`T`
+ *  :type leftmost_minor: trlib_flt_t, input
+ *  :param itmax: maximum number of iterations
+ *  :type itmax: trlib_int_t, input
+ *  :param tol_abs: absolute stopping tolerance in Reid-Parlett zero finding, good default may be :math:`\sqrt{\texttt{macheps}}^{3/4}` (:c:macro:`TRLIB_EPS_POW_75`)
+ *  :type tol_abs: trlib_flt_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_leftmost_timing_size`
+ *
+ *      ====== ================================
+ *      block   description
+ *      ====== ================================
+ *      0       total duration
+ *      ====== ================================
+ *
+ *  :type timing: trlib_int_t, input/output
+ *  :param leftmost: smallest eigenvalue of :math:`T`
+ *  :type leftmost: trlib_flt_t, output
+ *  :param iter_pr: number of Parlett-Reid iterations
+ *  :type iter_pr: trlib_int_t, output
+ *
+ *  :returns:      status
+ *
+ *                 - :c:macro:`TRLIB_LMR_CONV`          success
+ *                 - :c:macro:`TRLIB_LMR_ITMAX`         iteration limit exceeded
+ *
+ *  :rtype: trlib_int_t
+ */
+
+trlib_int_t trlib_leftmost_irreducible(
+        trlib_int_t n, trlib_flt_t *diag, trlib_flt_t *offdiag,
+        trlib_int_t warm, trlib_flt_t leftmost_minor, trlib_int_t itmax, trlib_flt_t tol_abs,
+        trlib_int_t verbose, trlib_int_t unicode, char *prefix, FILE *fout,
+        trlib_int_t *timing, trlib_flt_t *leftmost, trlib_int_t *iter_pr);
+
+/** size that has to be allocated for :c:data:`timing` in :c:func:`trlib_leftmost_irreducible` and :c:func:`trlib_leftmost`
+ */
+trlib_int_t trlib_leftmost_timing_size(void);
+
+#endif

casadi/include/trlib/trlib_private.h

@@ -0,0 +1,109 @@
+/* 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_PRIVATE_H
+#define TRLIB_PRIVATE_H
+
+/* #undef TRLIB_MEASURE_TIME */
+/* #undef TRLIB_MEASURE_SUBTIME */
+
+#include "trlib.h"
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#if defined(_WIN32) && !defined(TRLIB_BLAS_LAPACK_UNDERSCORE_SUFFIX)
+    // blas
+    void daxpy(trlib_int_t *n, trlib_flt_t *alpha, trlib_flt_t *x, trlib_int_t *incx, trlib_flt_t *y, trlib_int_t *incy);
+    void dscal(trlib_int_t *n, trlib_flt_t *alpha, trlib_flt_t *x, trlib_int_t *incx);
+    void dcopy(trlib_int_t *n, trlib_flt_t *x, trlib_int_t *incx, trlib_flt_t *y, trlib_int_t *incy);
+    trlib_flt_t dnrm2(trlib_int_t *n, trlib_flt_t *x, trlib_int_t *incx);
+    trlib_flt_t ddot(trlib_int_t *n, trlib_flt_t *x, trlib_int_t *incx, trlib_flt_t *y, trlib_int_t *incy);
+    
+    // lapack
+    void dpttrf(trlib_int_t *n, trlib_flt_t *d, trlib_flt_t *e, trlib_int_t *info);
+    void dpttrs(trlib_int_t *n, trlib_int_t *nrhs, trlib_flt_t *d, trlib_flt_t *e, trlib_flt_t *b, trlib_int_t *ldb, trlib_int_t *info);
+    void dptrfs(trlib_int_t *n, trlib_int_t *nrhs, trlib_flt_t *d, trlib_flt_t *e, trlib_flt_t *df, trlib_flt_t *ef, trlib_flt_t *b, trlib_int_t *ldb, trlib_flt_t *x, trlib_int_t *ldx, trlib_flt_t *ferr, trlib_flt_t *berr, trlib_flt_t *work, trlib_int_t *info);
+    void dlagtm(char *trans, trlib_int_t *n, trlib_int_t *nrhs, trlib_flt_t *alpha, trlib_flt_t *dl, trlib_flt_t *d, trlib_flt_t *du, trlib_flt_t *x, trlib_int_t *ldx, trlib_flt_t *beta, trlib_flt_t *b, trlib_int_t *ldb);
+    void dgtsv(trlib_int_t *n, trlib_int_t *nrhs, trlib_flt_t *dl, trlib_flt_t *d, trlib_flt_t *du, trlib_flt_t *b, trlib_int_t *ldb, trlib_int_t *info);
+#else
+    // blas
+    void daxpy_(trlib_int_t *n, trlib_flt_t *alpha, trlib_flt_t *x, trlib_int_t *incx, trlib_flt_t *y, trlib_int_t *incy);
+    void dscal_(trlib_int_t *n, trlib_flt_t *alpha, trlib_flt_t *x, trlib_int_t *incx);
+    void dcopy_(trlib_int_t *n, trlib_flt_t *x, trlib_int_t *incx, trlib_flt_t *y, trlib_int_t *incy);
+    trlib_flt_t dnrm2_(trlib_int_t *n, trlib_flt_t *x, trlib_int_t *incx);
+    trlib_flt_t ddot_(trlib_int_t *n, trlib_flt_t *x, trlib_int_t *incx, trlib_flt_t *y, trlib_int_t *incy);
+    
+    // lapack
+    void dpttrf_(trlib_int_t *n, trlib_flt_t *d, trlib_flt_t *e, trlib_int_t *info);
+    void dpttrs_(trlib_int_t *n, trlib_int_t *nrhs, trlib_flt_t *d, trlib_flt_t *e, trlib_flt_t *b, trlib_int_t *ldb, trlib_int_t *info);
+    void dptrfs_(trlib_int_t *n, trlib_int_t *nrhs, trlib_flt_t *d, trlib_flt_t *e, trlib_flt_t *df, trlib_flt_t *ef, trlib_flt_t *b, trlib_int_t *ldb, trlib_flt_t *x, trlib_int_t *ldx, trlib_flt_t *ferr, trlib_flt_t *berr, trlib_flt_t *work, trlib_int_t *info);
+    void dlagtm_(char *trans, trlib_int_t *n, trlib_int_t *nrhs, trlib_flt_t *alpha, trlib_flt_t *dl, trlib_flt_t *d, trlib_flt_t *du, trlib_flt_t *x, trlib_int_t *ldx, trlib_flt_t *beta, trlib_flt_t *b, trlib_int_t *ldb);
+    void dgtsv_(trlib_int_t *n, trlib_int_t *nrhs, trlib_flt_t *dl, trlib_flt_t *d, trlib_flt_t *du, trlib_flt_t *b, trlib_int_t *ldb, trlib_int_t *info);
+#endif
+
+#if TRLIB_MEASURE_TIME
+    #define TRLIB_TIC(X) { clock_gettime(CLOCK_MONOTONIC, &X); }
+    #define TRLIB_DURATION(X, Y, Z) { clock_gettime(CLOCK_MONOTONIC, &Y); Z += 1000000000L*(Y.tv_sec-X.tv_sec)+Y.tv_nsec-X.tv_nsec; }
+    #define TRLIB_SIZE_TIMING_LINALG (9)
+    #if TRLIB_MEASURE_SUBTIME
+        #define TRLIB_DURATION_SUB(X, Y, Z) { clock_gettime(CLOCK_MONOTONIC, &Y); Z += 1000000000L*(Y.tv_sec-X.tv_sec)+Y.tv_nsec-X.tv_nsec; }
+    #else
+        #define TRLIB_DURATION_SUB(X, Y, Z)
+    #endif
+#else
+    #define TRLIB_TIC(X)
+    #define TRLIB_DURATION(X, Y, Z)
+    #define TRLIB_DURATION_SUB(X, Y, Z)
+#endif
+#define TRLIB_RETURN(X) { TRLIB_DURATION(verystart, end, timing[0]) return X; }
+#if defined(_WIN32) && !defined(TRLIB_BLAS_LAPACK_UNDERSCORE_SUFFIX)
+    #define TRLIB_DCOPY(...) { TRLIB_TIC(start) dcopy(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[1]) }
+    #define TRLIB_DAXPY(...) { TRLIB_TIC(start) daxpy(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[2]) }
+    #define TRLIB_DSCAL(...) { TRLIB_TIC(start) dscal(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[3]) }
+    #define TRLIB_DNRM2(A, X, Y, Z) { TRLIB_TIC(start) A = dnrm2(X, Y, Z); TRLIB_DURATION_SUB(start, end, timing[4]) }
+    #define TRLIB_DDOT(A, N, X, IX, Y, IY) { TRLIB_TIC(start) A = ddot(N, X, IX, Y, IY); TRLIB_DURATION_SUB(start, end, timing[5]) }
+    #define TRLIB_DPTTRF(...) { TRLIB_TIC(start) dpttrf(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[6]) }
+    #define TRLIB_DPTTRS(...) { TRLIB_TIC(start) dpttrs(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[7]) }
+    #define TRLIB_DPTRFS(...) { TRLIB_TIC(start) dptrfs(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[8]) }
+    #define TRLIB_DLAGTM(...) { TRLIB_TIC(start) dlagtm(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[9]) }
+#else
+    #define TRLIB_DCOPY(...) { TRLIB_TIC(start) dcopy_(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[1]) }
+    #define TRLIB_DAXPY(...) { TRLIB_TIC(start) daxpy_(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[2]) }
+    #define TRLIB_DSCAL(...) { TRLIB_TIC(start) dscal_(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[3]) }
+    #define TRLIB_DNRM2(A, X, Y, Z) { TRLIB_TIC(start) A = dnrm2_(X, Y, Z); TRLIB_DURATION_SUB(start, end, timing[4]) }
+    #define TRLIB_DDOT(A, N, X, IX, Y, IY) { TRLIB_TIC(start) A = ddot_(N, X, IX, Y, IY); TRLIB_DURATION_SUB(start, end, timing[5]) }
+    #define TRLIB_DPTTRF(...) { TRLIB_TIC(start) dpttrf_(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[6]) }
+    #define TRLIB_DPTTRS(...) { TRLIB_TIC(start) dpttrs_(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[7]) }
+    #define TRLIB_DPTRFS(...) { TRLIB_TIC(start) dptrfs_(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[8]) }
+    #define TRLIB_DLAGTM(...) { TRLIB_TIC(start) dlagtm_(__VA_ARGS__); TRLIB_DURATION_SUB(start, end, timing[9]) }
+#endif
+#define TRLIB_PRINTLN_1(...) if (verbose > 0) { if (fout) { fprintf(fout, "%s", prefix); fprintf(fout, __VA_ARGS__); fprintf(fout, "\n"); } else { printf("%s", prefix); printf(__VA_ARGS__); printf("\n"); } }
+#define TRLIB_PRINTLN_2(...) if (verbose > 1) { if (fout) { fprintf(fout, "%s", prefix); fprintf(fout, __VA_ARGS__); fprintf(fout, "\n"); } else { printf("%s", prefix); printf(__VA_ARGS__); printf("\n"); } }
+
+#define TRLIB_PRINT_VEC(P, N, X) { for(int vc = 0; vc < N; ++vc) { printf("%s %ld: %e\n", P, vc, *(X+vc)); } }
+
+#endif

casadi/include/trlib/trlib_quadratic_zero.h

@@ -0,0 +1,57 @@
+/* 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_QUADRATIC_ZERO_H
+#define TRLIB_QUADRATIC_ZERO_H
+
+/** Computes real zeros of normalized quadratic polynomial.
+ *
+ *  :param c_abs: absolute coefficient
+ *  :type c_abs: trlib_flt_t, input
+ *  :param c_lin: coefficinet of linear term
+ *  :type c_lin: trlib_flt_t, input
+ *  :param tol: tolerance that indicates if ill-conditioning present, good default may be :math:`\texttt{macheps}^{3/4}` (:c:macro:`TRLIB_EPS_POW_75`)
+ *  :type tol: trlib_flt_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: trlib_int_t, input
+ *  :param fout: output stream
+ *  :type fout: FILE, input
+ *  :param t1: first zero, :math:`\texttt{t1} \le \texttt{t2}`
+ *  :type t2: trlib_flt_t, output
+ *  :param t2: second zero, :math:`\texttt{t1} \le \texttt{t2}`
+ *  :type t2: trlib_flt_t, output
+ *
+ *  :returns: number of zeros
+ *  :rtype: trlib_int_t
+ */
+
+trlib_int_t trlib_quadratic_zero(trlib_flt_t c_abs, trlib_flt_t c_lin, trlib_flt_t tol,
+        trlib_int_t verbose, trlib_int_t unicode, char *prefix, FILE *fout,
+        trlib_flt_t *t1, trlib_flt_t *t2);
+
+#endif