diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__init__.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9381d7a02c15a3234f38ee4bdee5d12d11d4afd1 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__init__.py @@ -0,0 +1,236 @@ +""" +==================================== +Linear algebra (:mod:`scipy.linalg`) +==================================== + +.. currentmodule:: scipy.linalg + +.. toctree:: + :hidden: + + linalg.blas + linalg.cython_blas + linalg.cython_lapack + linalg.interpolative + linalg.lapack + +Linear algebra functions. + +.. eventually, we should replace the numpy.linalg HTML link with just `numpy.linalg` + +.. seealso:: + + `numpy.linalg `__ + for more linear algebra functions. Note that + although `scipy.linalg` imports most of them, identically named + functions from `scipy.linalg` may offer more or slightly differing + functionality. + + +Basics +====== + +.. autosummary:: + :toctree: generated/ + + inv - Find the inverse of a square matrix + solve - Solve a linear system of equations + solve_banded - Solve a banded linear system + solveh_banded - Solve a Hermitian or symmetric banded system + solve_circulant - Solve a circulant system + solve_triangular - Solve a triangular matrix + solve_toeplitz - Solve a toeplitz matrix + matmul_toeplitz - Multiply a Toeplitz matrix with an array. + det - Find the determinant of a square matrix + norm - Matrix and vector norm + lstsq - Solve a linear least-squares problem + pinv - Pseudo-inverse (Moore-Penrose) using lstsq + pinvh - Pseudo-inverse of hermitian matrix + kron - Kronecker product of two arrays + khatri_rao - Khatri-Rao product of two arrays + orthogonal_procrustes - Solve an orthogonal Procrustes problem + matrix_balance - Balance matrix entries with a similarity transformation + subspace_angles - Compute the subspace angles between two matrices + bandwidth - Return the lower and upper bandwidth of an array + issymmetric - Check if a square 2D array is symmetric + ishermitian - Check if a square 2D array is Hermitian + LinAlgError + LinAlgWarning + +Eigenvalue Problems +=================== + +.. autosummary:: + :toctree: generated/ + + eig - Find the eigenvalues and eigenvectors of a square matrix + eigvals - Find just the eigenvalues of a square matrix + eigh - Find the e-vals and e-vectors of a Hermitian or symmetric matrix + eigvalsh - Find just the eigenvalues of a Hermitian or symmetric matrix + eig_banded - Find the eigenvalues and eigenvectors of a banded matrix + eigvals_banded - Find just the eigenvalues of a banded matrix + eigh_tridiagonal - Find the eigenvalues and eigenvectors of a tridiagonal matrix + eigvalsh_tridiagonal - Find just the eigenvalues of a tridiagonal matrix + +Decompositions +============== + +.. autosummary:: + :toctree: generated/ + + lu - LU decomposition of a matrix + lu_factor - LU decomposition returning unordered matrix and pivots + lu_solve - Solve Ax=b using back substitution with output of lu_factor + svd - Singular value decomposition of a matrix + svdvals - Singular values of a matrix + diagsvd - Construct matrix of singular values from output of svd + orth - Construct orthonormal basis for the range of A using svd + null_space - Construct orthonormal basis for the null space of A using svd + ldl - LDL.T decomposition of a Hermitian or a symmetric matrix. + cholesky - Cholesky decomposition of a matrix + cholesky_banded - Cholesky decomp. of a sym. or Hermitian banded matrix + cho_factor - Cholesky decomposition for use in solving a linear system + cho_solve - Solve previously factored linear system + cho_solve_banded - Solve previously factored banded linear system + polar - Compute the polar decomposition. + qr - QR decomposition of a matrix + qr_multiply - QR decomposition and multiplication by Q + qr_update - Rank k QR update + qr_delete - QR downdate on row or column deletion + qr_insert - QR update on row or column insertion + rq - RQ decomposition of a matrix + qz - QZ decomposition of a pair of matrices + ordqz - QZ decomposition of a pair of matrices with reordering + schur - Schur decomposition of a matrix + rsf2csf - Real to complex Schur form + hessenberg - Hessenberg form of a matrix + cdf2rdf - Complex diagonal form to real diagonal block form + cossin - Cosine sine decomposition of a unitary or orthogonal matrix + +.. seealso:: + + `scipy.linalg.interpolative` -- Interpolative matrix decompositions + + +Matrix Functions +================ + +.. autosummary:: + :toctree: generated/ + + expm - Matrix exponential + logm - Matrix logarithm + cosm - Matrix cosine + sinm - Matrix sine + tanm - Matrix tangent + coshm - Matrix hyperbolic cosine + sinhm - Matrix hyperbolic sine + tanhm - Matrix hyperbolic tangent + signm - Matrix sign + sqrtm - Matrix square root + funm - Evaluating an arbitrary matrix function + expm_frechet - Frechet derivative of the matrix exponential + expm_cond - Relative condition number of expm in the Frobenius norm + fractional_matrix_power - Fractional matrix power + + +Matrix Equation Solvers +======================= + +.. autosummary:: + :toctree: generated/ + + solve_sylvester - Solve the Sylvester matrix equation + solve_continuous_are - Solve the continuous-time algebraic Riccati equation + solve_discrete_are - Solve the discrete-time algebraic Riccati equation + solve_continuous_lyapunov - Solve the continuous-time Lyapunov equation + solve_discrete_lyapunov - Solve the discrete-time Lyapunov equation + + +Sketches and Random Projections +=============================== + +.. autosummary:: + :toctree: generated/ + + clarkson_woodruff_transform - Applies the Clarkson Woodruff Sketch (a.k.a CountMin Sketch) + +Special Matrices +================ + +.. autosummary:: + :toctree: generated/ + + block_diag - Construct a block diagonal matrix from submatrices + circulant - Circulant matrix + companion - Companion matrix + convolution_matrix - Convolution matrix + dft - Discrete Fourier transform matrix + fiedler - Fiedler matrix + fiedler_companion - Fiedler companion matrix + hadamard - Hadamard matrix of order 2**n + hankel - Hankel matrix + helmert - Helmert matrix + hilbert - Hilbert matrix + invhilbert - Inverse Hilbert matrix + leslie - Leslie matrix + pascal - Pascal matrix + invpascal - Inverse Pascal matrix + toeplitz - Toeplitz matrix + +Low-level routines +================== + +.. autosummary:: + :toctree: generated/ + + get_blas_funcs + get_lapack_funcs + find_best_blas_type + +.. seealso:: + + `scipy.linalg.blas` -- Low-level BLAS functions + + `scipy.linalg.lapack` -- Low-level LAPACK functions + + `scipy.linalg.cython_blas` -- Low-level BLAS functions for Cython + + `scipy.linalg.cython_lapack` -- Low-level LAPACK functions for Cython + +""" # noqa: E501 + +from ._misc import * +from ._cythonized_array_utils import * +from ._basic import * +from ._decomp import * +from ._decomp_lu import * +from ._decomp_ldl import * +from ._decomp_cholesky import * +from ._decomp_qr import * +from ._decomp_qz import * +from ._decomp_svd import * +from ._decomp_schur import * +from ._decomp_polar import * +from ._matfuncs import * +from .blas import * +from .lapack import * +from ._special_matrices import * +from ._solvers import * +from ._procrustes import * +from ._decomp_update import * +from ._sketches import * +from ._decomp_cossin import * + +# Deprecated namespaces, to be removed in v2.0.0 +from . import ( + decomp, decomp_cholesky, decomp_lu, decomp_qr, decomp_svd, decomp_schur, + basic, misc, special_matrices, matfuncs, +) + +__all__ = [s for s in dir() if not s.startswith('_')] + + +from scipy._lib._testutils import PytestTester +test = PytestTester(__name__) +del PytestTester diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..91a25521322a42f13010e969035bbc88ddb66b15 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/__init__.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_cholesky.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_cholesky.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b8548b79436504866514e40e6a1907c70d7f5a37 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_cholesky.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_cossin.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_cossin.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e0f4038944877f916ca386f3fbc10ae7969645c7 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_cossin.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_ldl.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_ldl.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8f75dd289c3de2ecbaa1069f5db3a010904f61f Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_ldl.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_lu.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_lu.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd8931f0ebfd686a6c008222b56f7f1f3a725804 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_lu.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_polar.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_polar.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6939e37e0f0b7a3b74b9ad43a9631d1c7a0fec03 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_polar.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_qz.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_qz.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..37b0c92e026bb90231293ca387a8c76ef4204158 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_qz.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_schur.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_schur.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..04c665253ab971633a2e939244e0c62c49388e2e Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_schur.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_svd.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_svd.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b78e3f654bf5d6fd60421ccc4e4f09e187c05c62 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_decomp_svd.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_interpolative_backend.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_interpolative_backend.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2386a7e2fc3d051022af9aad54eed0df1b8ab1de Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_interpolative_backend.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_misc.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_misc.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c29a019c847c0c79a3e862986074545f924a88c5 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_misc.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_sketches.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_sketches.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e1d9cafee36944c52b5f8cdd1934cd108dbd5cf Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_sketches.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_solvers.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_solvers.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a24fda34bed1d00a63939b929d70042e9b85ea4b Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_solvers.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_special_matrices.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_special_matrices.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..209b68b2518382ea52a15288246f79e0ca175bf8 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_special_matrices.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_testutils.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_testutils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..28debd4e469e565a08419159ce1890d7189288fc Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/_testutils.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/decomp_lu.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/decomp_lu.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1c2a5530e31a00d5e48933a7364b816d695e1e4 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/decomp_lu.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/decomp_qr.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/decomp_qr.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a755ce5b2f5c0b80a06d75e554392563d4fef243 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/decomp_qr.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/decomp_schur.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/decomp_schur.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d6eabe35c41c0759b2fa08fa002ad500715125fd Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/decomp_schur.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/interpolative.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/interpolative.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b730b93980c2e7457e459a9d1a2632312dd64098 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/interpolative.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/lapack.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/lapack.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d5647b62fe4a3602063e5c08f055f418394cdd17 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/lapack.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/misc.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/misc.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a7321520beae66baa10b9fc9e36a8975b226fac Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/__pycache__/misc.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_basic.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_basic.py new file mode 100644 index 0000000000000000000000000000000000000000..d561b71d93302820f82eb30a293917b3c31dc243 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_basic.py @@ -0,0 +1,1919 @@ +# +# Author: Pearu Peterson, March 2002 +# +# w/ additions by Travis Oliphant, March 2002 +# and Jake Vanderplas, August 2012 + +from warnings import warn +from itertools import product +import numpy as np +from numpy import atleast_1d, atleast_2d +from .lapack import get_lapack_funcs, _compute_lwork +from ._misc import LinAlgError, _datacopied, LinAlgWarning +from ._decomp import _asarray_validated +from . import _decomp, _decomp_svd +from ._solve_toeplitz import levinson +from ._cythonized_array_utils import find_det_from_lu +from scipy._lib.deprecation import _NoValue, _deprecate_positional_args + +__all__ = ['solve', 'solve_triangular', 'solveh_banded', 'solve_banded', + 'solve_toeplitz', 'solve_circulant', 'inv', 'det', 'lstsq', + 'pinv', 'pinvh', 'matrix_balance', 'matmul_toeplitz'] + + +# The numpy facilities for type-casting checks are too slow for small sized +# arrays and eat away the time budget for the checkups. Here we set a +# precomputed dict container of the numpy.can_cast() table. + +# It can be used to determine quickly what a dtype can be cast to LAPACK +# compatible types, i.e., 'float32, float64, complex64, complex128'. +# Then it can be checked via "casting_dict[arr.dtype.char]" +lapack_cast_dict = {x: ''.join([y for y in 'fdFD' if np.can_cast(x, y)]) + for x in np.typecodes['All']} + + +# Linear equations +def _solve_check(n, info, lamch=None, rcond=None): + """ Check arguments during the different steps of the solution phase """ + if info < 0: + raise ValueError(f'LAPACK reported an illegal value in {-info}-th argument.') + elif 0 < info: + raise LinAlgError('Matrix is singular.') + + if lamch is None: + return + E = lamch('E') + if rcond < E: + warn(f'Ill-conditioned matrix (rcond={rcond:.6g}): ' + 'result may not be accurate.', + LinAlgWarning, stacklevel=3) + + +def solve(a, b, lower=False, overwrite_a=False, + overwrite_b=False, check_finite=True, assume_a='gen', + transposed=False): + """ + Solves the linear equation set ``a @ x == b`` for the unknown ``x`` + for square `a` matrix. + + If the data matrix is known to be a particular type then supplying the + corresponding string to ``assume_a`` key chooses the dedicated solver. + The available options are + + =================== ======== + generic matrix 'gen' + symmetric 'sym' + hermitian 'her' + positive definite 'pos' + =================== ======== + + If omitted, ``'gen'`` is the default structure. + + The datatype of the arrays define which solver is called regardless + of the values. In other words, even when the complex array entries have + precisely zero imaginary parts, the complex solver will be called based + on the data type of the array. + + Parameters + ---------- + a : (N, N) array_like + Square input data + b : (N, NRHS) array_like + Input data for the right hand side. + lower : bool, default: False + Ignored if ``assume_a == 'gen'`` (the default). If True, the + calculation uses only the data in the lower triangle of `a`; + entries above the diagonal are ignored. If False (default), the + calculation uses only the data in the upper triangle of `a`; entries + below the diagonal are ignored. + overwrite_a : bool, default: False + Allow overwriting data in `a` (may enhance performance). + overwrite_b : bool, default: False + Allow overwriting data in `b` (may enhance performance). + check_finite : bool, default: True + Whether to check that the input matrices contain only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + assume_a : str, {'gen', 'sym', 'her', 'pos'} + Valid entries are explained above. + transposed : bool, default: False + If True, solve ``a.T @ x == b``. Raises `NotImplementedError` + for complex `a`. + + Returns + ------- + x : (N, NRHS) ndarray + The solution array. + + Raises + ------ + ValueError + If size mismatches detected or input a is not square. + LinAlgError + If the matrix is singular. + LinAlgWarning + If an ill-conditioned input a is detected. + NotImplementedError + If transposed is True and input a is a complex matrix. + + Notes + ----- + If the input b matrix is a 1-D array with N elements, when supplied + together with an NxN input a, it is assumed as a valid column vector + despite the apparent size mismatch. This is compatible with the + numpy.dot() behavior and the returned result is still 1-D array. + + The generic, symmetric, Hermitian and positive definite solutions are + obtained via calling ?GESV, ?SYSV, ?HESV, and ?POSV routines of + LAPACK respectively. + + Examples + -------- + Given `a` and `b`, solve for `x`: + + >>> import numpy as np + >>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]]) + >>> b = np.array([2, 4, -1]) + >>> from scipy import linalg + >>> x = linalg.solve(a, b) + >>> x + array([ 2., -2., 9.]) + >>> np.dot(a, x) == b + array([ True, True, True], dtype=bool) + + """ + # Flags for 1-D or N-D right-hand side + b_is_1D = False + + a1 = atleast_2d(_asarray_validated(a, check_finite=check_finite)) + b1 = atleast_1d(_asarray_validated(b, check_finite=check_finite)) + n = a1.shape[0] + + overwrite_a = overwrite_a or _datacopied(a1, a) + overwrite_b = overwrite_b or _datacopied(b1, b) + + if a1.shape[0] != a1.shape[1]: + raise ValueError('Input a needs to be a square matrix.') + + if n != b1.shape[0]: + # Last chance to catch 1x1 scalar a and 1-D b arrays + if not (n == 1 and b1.size != 0): + raise ValueError('Input b has to have same number of rows as ' + 'input a') + + # accommodate empty arrays + if b1.size == 0: + return np.asfortranarray(b1.copy()) + + # regularize 1-D b arrays to 2D + if b1.ndim == 1: + if n == 1: + b1 = b1[None, :] + else: + b1 = b1[:, None] + b_is_1D = True + + if assume_a not in ('gen', 'sym', 'her', 'pos'): + raise ValueError(f'{assume_a} is not a recognized matrix structure') + + # for a real matrix, describe it as "symmetric", not "hermitian" + # (lapack doesn't know what to do with real hermitian matrices) + if assume_a == 'her' and not np.iscomplexobj(a1): + assume_a = 'sym' + + # Get the correct lamch function. + # The LAMCH functions only exists for S and D + # So for complex values we have to convert to real/double. + if a1.dtype.char in 'fF': # single precision + lamch = get_lapack_funcs('lamch', dtype='f') + else: + lamch = get_lapack_funcs('lamch', dtype='d') + + # Currently we do not have the other forms of the norm calculators + # lansy, lanpo, lanhe. + # However, in any case they only reduce computations slightly... + lange = get_lapack_funcs('lange', (a1,)) + + # Since the I-norm and 1-norm are the same for symmetric matrices + # we can collect them all in this one call + # Note however, that when issuing 'gen' and form!='none', then + # the I-norm should be used + if transposed: + trans = 1 + norm = 'I' + if np.iscomplexobj(a1): + raise NotImplementedError('scipy.linalg.solve can currently ' + 'not solve a^T x = b or a^H x = b ' + 'for complex matrices.') + else: + trans = 0 + norm = '1' + + anorm = lange(norm, a1) + + # Generalized case 'gesv' + if assume_a == 'gen': + gecon, getrf, getrs = get_lapack_funcs(('gecon', 'getrf', 'getrs'), + (a1, b1)) + lu, ipvt, info = getrf(a1, overwrite_a=overwrite_a) + _solve_check(n, info) + x, info = getrs(lu, ipvt, b1, + trans=trans, overwrite_b=overwrite_b) + _solve_check(n, info) + rcond, info = gecon(lu, anorm, norm=norm) + # Hermitian case 'hesv' + elif assume_a == 'her': + hecon, hesv, hesv_lw = get_lapack_funcs(('hecon', 'hesv', + 'hesv_lwork'), (a1, b1)) + lwork = _compute_lwork(hesv_lw, n, lower) + lu, ipvt, x, info = hesv(a1, b1, lwork=lwork, + lower=lower, + overwrite_a=overwrite_a, + overwrite_b=overwrite_b) + _solve_check(n, info) + rcond, info = hecon(lu, ipvt, anorm) + # Symmetric case 'sysv' + elif assume_a == 'sym': + sycon, sysv, sysv_lw = get_lapack_funcs(('sycon', 'sysv', + 'sysv_lwork'), (a1, b1)) + lwork = _compute_lwork(sysv_lw, n, lower) + lu, ipvt, x, info = sysv(a1, b1, lwork=lwork, + lower=lower, + overwrite_a=overwrite_a, + overwrite_b=overwrite_b) + _solve_check(n, info) + rcond, info = sycon(lu, ipvt, anorm) + # Positive definite case 'posv' + else: + pocon, posv = get_lapack_funcs(('pocon', 'posv'), + (a1, b1)) + lu, x, info = posv(a1, b1, lower=lower, + overwrite_a=overwrite_a, + overwrite_b=overwrite_b) + _solve_check(n, info) + rcond, info = pocon(lu, anorm) + + _solve_check(n, info, lamch, rcond) + + if b_is_1D: + x = x.ravel() + + return x + + +def solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False, + overwrite_b=False, check_finite=True): + """ + Solve the equation `a x = b` for `x`, assuming a is a triangular matrix. + + Parameters + ---------- + a : (M, M) array_like + A triangular matrix + b : (M,) or (M, N) array_like + Right-hand side matrix in `a x = b` + lower : bool, optional + Use only data contained in the lower triangle of `a`. + Default is to use upper triangle. + trans : {0, 1, 2, 'N', 'T', 'C'}, optional + Type of system to solve: + + ======== ========= + trans system + ======== ========= + 0 or 'N' a x = b + 1 or 'T' a^T x = b + 2 or 'C' a^H x = b + ======== ========= + unit_diagonal : bool, optional + If True, diagonal elements of `a` are assumed to be 1 and + will not be referenced. + overwrite_b : bool, optional + Allow overwriting data in `b` (may enhance performance) + check_finite : bool, optional + Whether to check that the input matrices contain only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + x : (M,) or (M, N) ndarray + Solution to the system `a x = b`. Shape of return matches `b`. + + Raises + ------ + LinAlgError + If `a` is singular + + Notes + ----- + .. versionadded:: 0.9.0 + + Examples + -------- + Solve the lower triangular system a x = b, where:: + + [3 0 0 0] [4] + a = [2 1 0 0] b = [2] + [1 0 1 0] [4] + [1 1 1 1] [2] + + >>> import numpy as np + >>> from scipy.linalg import solve_triangular + >>> a = np.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]]) + >>> b = np.array([4, 2, 4, 2]) + >>> x = solve_triangular(a, b, lower=True) + >>> x + array([ 1.33333333, -0.66666667, 2.66666667, -1.33333333]) + >>> a.dot(x) # Check the result + array([ 4., 2., 4., 2.]) + + """ + + a1 = _asarray_validated(a, check_finite=check_finite) + b1 = _asarray_validated(b, check_finite=check_finite) + if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]: + raise ValueError('expected square matrix') + if a1.shape[0] != b1.shape[0]: + raise ValueError(f'shapes of a {a1.shape} and b {b1.shape} are incompatible') + overwrite_b = overwrite_b or _datacopied(b1, b) + + trans = {'N': 0, 'T': 1, 'C': 2}.get(trans, trans) + trtrs, = get_lapack_funcs(('trtrs',), (a1, b1)) + if a1.flags.f_contiguous or trans == 2: + x, info = trtrs(a1, b1, overwrite_b=overwrite_b, lower=lower, + trans=trans, unitdiag=unit_diagonal) + else: + # transposed system is solved since trtrs expects Fortran ordering + x, info = trtrs(a1.T, b1, overwrite_b=overwrite_b, lower=not lower, + trans=not trans, unitdiag=unit_diagonal) + + if info == 0: + return x + if info > 0: + raise LinAlgError("singular matrix: resolution failed at diagonal %d" % + (info-1)) + raise ValueError('illegal value in %dth argument of internal trtrs' % + (-info)) + + +def solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, + check_finite=True): + """ + Solve the equation a x = b for x, assuming a is banded matrix. + + The matrix a is stored in `ab` using the matrix diagonal ordered form:: + + ab[u + i - j, j] == a[i,j] + + Example of `ab` (shape of a is (6,6), `u` =1, `l` =2):: + + * a01 a12 a23 a34 a45 + a00 a11 a22 a33 a44 a55 + a10 a21 a32 a43 a54 * + a20 a31 a42 a53 * * + + Parameters + ---------- + (l, u) : (integer, integer) + Number of non-zero lower and upper diagonals + ab : (`l` + `u` + 1, M) array_like + Banded matrix + b : (M,) or (M, K) array_like + Right-hand side + overwrite_ab : bool, optional + Discard data in `ab` (may enhance performance) + overwrite_b : bool, optional + Discard data in `b` (may enhance performance) + check_finite : bool, optional + Whether to check that the input matrices contain only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + x : (M,) or (M, K) ndarray + The solution to the system a x = b. Returned shape depends on the + shape of `b`. + + Examples + -------- + Solve the banded system a x = b, where:: + + [5 2 -1 0 0] [0] + [1 4 2 -1 0] [1] + a = [0 1 3 2 -1] b = [2] + [0 0 1 2 2] [2] + [0 0 0 1 1] [3] + + There is one nonzero diagonal below the main diagonal (l = 1), and + two above (u = 2). The diagonal banded form of the matrix is:: + + [* * -1 -1 -1] + ab = [* 2 2 2 2] + [5 4 3 2 1] + [1 1 1 1 *] + + >>> import numpy as np + >>> from scipy.linalg import solve_banded + >>> ab = np.array([[0, 0, -1, -1, -1], + ... [0, 2, 2, 2, 2], + ... [5, 4, 3, 2, 1], + ... [1, 1, 1, 1, 0]]) + >>> b = np.array([0, 1, 2, 2, 3]) + >>> x = solve_banded((1, 2), ab, b) + >>> x + array([-2.37288136, 3.93220339, -4. , 4.3559322 , -1.3559322 ]) + + """ + + a1 = _asarray_validated(ab, check_finite=check_finite, as_inexact=True) + b1 = _asarray_validated(b, check_finite=check_finite, as_inexact=True) + # Validate shapes. + if a1.shape[-1] != b1.shape[0]: + raise ValueError("shapes of ab and b are not compatible.") + (nlower, nupper) = l_and_u + if nlower + nupper + 1 != a1.shape[0]: + raise ValueError("invalid values for the number of lower and upper " + "diagonals: l+u+1 (%d) does not equal ab.shape[0] " + "(%d)" % (nlower + nupper + 1, ab.shape[0])) + + overwrite_b = overwrite_b or _datacopied(b1, b) + if a1.shape[-1] == 1: + b2 = np.array(b1, copy=(not overwrite_b)) + b2 /= a1[1, 0] + return b2 + if nlower == nupper == 1: + overwrite_ab = overwrite_ab or _datacopied(a1, ab) + gtsv, = get_lapack_funcs(('gtsv',), (a1, b1)) + du = a1[0, 1:] + d = a1[1, :] + dl = a1[2, :-1] + du2, d, du, x, info = gtsv(dl, d, du, b1, overwrite_ab, overwrite_ab, + overwrite_ab, overwrite_b) + else: + gbsv, = get_lapack_funcs(('gbsv',), (a1, b1)) + a2 = np.zeros((2*nlower + nupper + 1, a1.shape[1]), dtype=gbsv.dtype) + a2[nlower:, :] = a1 + lu, piv, x, info = gbsv(nlower, nupper, a2, b1, overwrite_ab=True, + overwrite_b=overwrite_b) + if info == 0: + return x + if info > 0: + raise LinAlgError("singular matrix") + raise ValueError('illegal value in %d-th argument of internal ' + 'gbsv/gtsv' % -info) + + +def solveh_banded(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, + check_finite=True): + """ + Solve equation a x = b. a is Hermitian positive-definite banded matrix. + + Uses Thomas' Algorithm, which is more efficient than standard LU + factorization, but should only be used for Hermitian positive-definite + matrices. + + The matrix ``a`` is stored in `ab` either in lower diagonal or upper + diagonal ordered form: + + ab[u + i - j, j] == a[i,j] (if upper form; i <= j) + ab[ i - j, j] == a[i,j] (if lower form; i >= j) + + Example of `ab` (shape of ``a`` is (6, 6), number of upper diagonals, + ``u`` =2):: + + upper form: + * * a02 a13 a24 a35 + * a01 a12 a23 a34 a45 + a00 a11 a22 a33 a44 a55 + + lower form: + a00 a11 a22 a33 a44 a55 + a10 a21 a32 a43 a54 * + a20 a31 a42 a53 * * + + Cells marked with * are not used. + + Parameters + ---------- + ab : (``u`` + 1, M) array_like + Banded matrix + b : (M,) or (M, K) array_like + Right-hand side + overwrite_ab : bool, optional + Discard data in `ab` (may enhance performance) + overwrite_b : bool, optional + Discard data in `b` (may enhance performance) + lower : bool, optional + Is the matrix in the lower form. (Default is upper form) + check_finite : bool, optional + Whether to check that the input matrices contain only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + x : (M,) or (M, K) ndarray + The solution to the system ``a x = b``. Shape of return matches shape + of `b`. + + Notes + ----- + In the case of a non-positive definite matrix ``a``, the solver + `solve_banded` may be used. + + Examples + -------- + Solve the banded system ``A x = b``, where:: + + [ 4 2 -1 0 0 0] [1] + [ 2 5 2 -1 0 0] [2] + A = [-1 2 6 2 -1 0] b = [2] + [ 0 -1 2 7 2 -1] [3] + [ 0 0 -1 2 8 2] [3] + [ 0 0 0 -1 2 9] [3] + + >>> import numpy as np + >>> from scipy.linalg import solveh_banded + + ``ab`` contains the main diagonal and the nonzero diagonals below the + main diagonal. That is, we use the lower form: + + >>> ab = np.array([[ 4, 5, 6, 7, 8, 9], + ... [ 2, 2, 2, 2, 2, 0], + ... [-1, -1, -1, -1, 0, 0]]) + >>> b = np.array([1, 2, 2, 3, 3, 3]) + >>> x = solveh_banded(ab, b, lower=True) + >>> x + array([ 0.03431373, 0.45938375, 0.05602241, 0.47759104, 0.17577031, + 0.34733894]) + + + Solve the Hermitian banded system ``H x = b``, where:: + + [ 8 2-1j 0 0 ] [ 1 ] + H = [2+1j 5 1j 0 ] b = [1+1j] + [ 0 -1j 9 -2-1j] [1-2j] + [ 0 0 -2+1j 6 ] [ 0 ] + + In this example, we put the upper diagonals in the array ``hb``: + + >>> hb = np.array([[0, 2-1j, 1j, -2-1j], + ... [8, 5, 9, 6 ]]) + >>> b = np.array([1, 1+1j, 1-2j, 0]) + >>> x = solveh_banded(hb, b) + >>> x + array([ 0.07318536-0.02939412j, 0.11877624+0.17696461j, + 0.10077984-0.23035393j, -0.00479904-0.09358128j]) + + """ + a1 = _asarray_validated(ab, check_finite=check_finite) + b1 = _asarray_validated(b, check_finite=check_finite) + # Validate shapes. + if a1.shape[-1] != b1.shape[0]: + raise ValueError("shapes of ab and b are not compatible.") + + overwrite_b = overwrite_b or _datacopied(b1, b) + overwrite_ab = overwrite_ab or _datacopied(a1, ab) + + if a1.shape[0] == 2: + ptsv, = get_lapack_funcs(('ptsv',), (a1, b1)) + if lower: + d = a1[0, :].real + e = a1[1, :-1] + else: + d = a1[1, :].real + e = a1[0, 1:].conj() + d, du, x, info = ptsv(d, e, b1, overwrite_ab, overwrite_ab, + overwrite_b) + else: + pbsv, = get_lapack_funcs(('pbsv',), (a1, b1)) + c, x, info = pbsv(a1, b1, lower=lower, overwrite_ab=overwrite_ab, + overwrite_b=overwrite_b) + if info > 0: + raise LinAlgError("%dth leading minor not positive definite" % info) + if info < 0: + raise ValueError('illegal value in %dth argument of internal ' + 'pbsv' % -info) + return x + + +def solve_toeplitz(c_or_cr, b, check_finite=True): + """Solve a Toeplitz system using Levinson Recursion + + The Toeplitz matrix has constant diagonals, with c as its first column + and r as its first row. If r is not given, ``r == conjugate(c)`` is + assumed. + + Parameters + ---------- + c_or_cr : array_like or tuple of (array_like, array_like) + The vector ``c``, or a tuple of arrays (``c``, ``r``). Whatever the + actual shape of ``c``, it will be converted to a 1-D array. If not + supplied, ``r = conjugate(c)`` is assumed; in this case, if c[0] is + real, the Toeplitz matrix is Hermitian. r[0] is ignored; the first row + of the Toeplitz matrix is ``[c[0], r[1:]]``. Whatever the actual shape + of ``r``, it will be converted to a 1-D array. + b : (M,) or (M, K) array_like + Right-hand side in ``T x = b``. + check_finite : bool, optional + Whether to check that the input matrices contain only finite numbers. + Disabling may give a performance gain, but may result in problems + (result entirely NaNs) if the inputs do contain infinities or NaNs. + + Returns + ------- + x : (M,) or (M, K) ndarray + The solution to the system ``T x = b``. Shape of return matches shape + of `b`. + + See Also + -------- + toeplitz : Toeplitz matrix + + Notes + ----- + The solution is computed using Levinson-Durbin recursion, which is faster + than generic least-squares methods, but can be less numerically stable. + + Examples + -------- + Solve the Toeplitz system T x = b, where:: + + [ 1 -1 -2 -3] [1] + T = [ 3 1 -1 -2] b = [2] + [ 6 3 1 -1] [2] + [10 6 3 1] [5] + + To specify the Toeplitz matrix, only the first column and the first + row are needed. + + >>> import numpy as np + >>> c = np.array([1, 3, 6, 10]) # First column of T + >>> r = np.array([1, -1, -2, -3]) # First row of T + >>> b = np.array([1, 2, 2, 5]) + + >>> from scipy.linalg import solve_toeplitz, toeplitz + >>> x = solve_toeplitz((c, r), b) + >>> x + array([ 1.66666667, -1. , -2.66666667, 2.33333333]) + + Check the result by creating the full Toeplitz matrix and + multiplying it by `x`. We should get `b`. + + >>> T = toeplitz(c, r) + >>> T.dot(x) + array([ 1., 2., 2., 5.]) + + """ + # If numerical stability of this algorithm is a problem, a future + # developer might consider implementing other O(N^2) Toeplitz solvers, + # such as GKO (https://www.jstor.org/stable/2153371) or Bareiss. + + r, c, b, dtype, b_shape = _validate_args_for_toeplitz_ops( + c_or_cr, b, check_finite, keep_b_shape=True) + + # Form a 1-D array of values to be used in the matrix, containing a + # reversed copy of r[1:], followed by c. + vals = np.concatenate((r[-1:0:-1], c)) + if b is None: + raise ValueError('illegal value, `b` is a required argument') + + if b.ndim == 1: + x, _ = levinson(vals, np.ascontiguousarray(b)) + else: + x = np.column_stack([levinson(vals, np.ascontiguousarray(b[:, i]))[0] + for i in range(b.shape[1])]) + x = x.reshape(*b_shape) + + return x + + +def _get_axis_len(aname, a, axis): + ax = axis + if ax < 0: + ax += a.ndim + if 0 <= ax < a.ndim: + return a.shape[ax] + raise ValueError(f"'{aname}axis' entry is out of bounds") + + +def solve_circulant(c, b, singular='raise', tol=None, + caxis=-1, baxis=0, outaxis=0): + """Solve C x = b for x, where C is a circulant matrix. + + `C` is the circulant matrix associated with the vector `c`. + + The system is solved by doing division in Fourier space. The + calculation is:: + + x = ifft(fft(b) / fft(c)) + + where `fft` and `ifft` are the fast Fourier transform and its inverse, + respectively. For a large vector `c`, this is *much* faster than + solving the system with the full circulant matrix. + + Parameters + ---------- + c : array_like + The coefficients of the circulant matrix. + b : array_like + Right-hand side matrix in ``a x = b``. + singular : str, optional + This argument controls how a near singular circulant matrix is + handled. If `singular` is "raise" and the circulant matrix is + near singular, a `LinAlgError` is raised. If `singular` is + "lstsq", the least squares solution is returned. Default is "raise". + tol : float, optional + If any eigenvalue of the circulant matrix has an absolute value + that is less than or equal to `tol`, the matrix is considered to be + near singular. If not given, `tol` is set to:: + + tol = abs_eigs.max() * abs_eigs.size * np.finfo(np.float64).eps + + where `abs_eigs` is the array of absolute values of the eigenvalues + of the circulant matrix. + caxis : int + When `c` has dimension greater than 1, it is viewed as a collection + of circulant vectors. In this case, `caxis` is the axis of `c` that + holds the vectors of circulant coefficients. + baxis : int + When `b` has dimension greater than 1, it is viewed as a collection + of vectors. In this case, `baxis` is the axis of `b` that holds the + right-hand side vectors. + outaxis : int + When `c` or `b` are multidimensional, the value returned by + `solve_circulant` is multidimensional. In this case, `outaxis` is + the axis of the result that holds the solution vectors. + + Returns + ------- + x : ndarray + Solution to the system ``C x = b``. + + Raises + ------ + LinAlgError + If the circulant matrix associated with `c` is near singular. + + See Also + -------- + circulant : circulant matrix + + Notes + ----- + For a 1-D vector `c` with length `m`, and an array `b` + with shape ``(m, ...)``, + + solve_circulant(c, b) + + returns the same result as + + solve(circulant(c), b) + + where `solve` and `circulant` are from `scipy.linalg`. + + .. versionadded:: 0.16.0 + + Examples + -------- + >>> import numpy as np + >>> from scipy.linalg import solve_circulant, solve, circulant, lstsq + + >>> c = np.array([2, 2, 4]) + >>> b = np.array([1, 2, 3]) + >>> solve_circulant(c, b) + array([ 0.75, -0.25, 0.25]) + + Compare that result to solving the system with `scipy.linalg.solve`: + + >>> solve(circulant(c), b) + array([ 0.75, -0.25, 0.25]) + + A singular example: + + >>> c = np.array([1, 1, 0, 0]) + >>> b = np.array([1, 2, 3, 4]) + + Calling ``solve_circulant(c, b)`` will raise a `LinAlgError`. For the + least square solution, use the option ``singular='lstsq'``: + + >>> solve_circulant(c, b, singular='lstsq') + array([ 0.25, 1.25, 2.25, 1.25]) + + Compare to `scipy.linalg.lstsq`: + + >>> x, resid, rnk, s = lstsq(circulant(c), b) + >>> x + array([ 0.25, 1.25, 2.25, 1.25]) + + A broadcasting example: + + Suppose we have the vectors of two circulant matrices stored in an array + with shape (2, 5), and three `b` vectors stored in an array with shape + (3, 5). For example, + + >>> c = np.array([[1.5, 2, 3, 0, 0], [1, 1, 4, 3, 2]]) + >>> b = np.arange(15).reshape(-1, 5) + + We want to solve all combinations of circulant matrices and `b` vectors, + with the result stored in an array with shape (2, 3, 5). When we + disregard the axes of `c` and `b` that hold the vectors of coefficients, + the shapes of the collections are (2,) and (3,), respectively, which are + not compatible for broadcasting. To have a broadcast result with shape + (2, 3), we add a trivial dimension to `c`: ``c[:, np.newaxis, :]`` has + shape (2, 1, 5). The last dimension holds the coefficients of the + circulant matrices, so when we call `solve_circulant`, we can use the + default ``caxis=-1``. The coefficients of the `b` vectors are in the last + dimension of the array `b`, so we use ``baxis=-1``. If we use the + default `outaxis`, the result will have shape (5, 2, 3), so we'll use + ``outaxis=-1`` to put the solution vectors in the last dimension. + + >>> x = solve_circulant(c[:, np.newaxis, :], b, baxis=-1, outaxis=-1) + >>> x.shape + (2, 3, 5) + >>> np.set_printoptions(precision=3) # For compact output of numbers. + >>> x + array([[[-0.118, 0.22 , 1.277, -0.142, 0.302], + [ 0.651, 0.989, 2.046, 0.627, 1.072], + [ 1.42 , 1.758, 2.816, 1.396, 1.841]], + [[ 0.401, 0.304, 0.694, -0.867, 0.377], + [ 0.856, 0.758, 1.149, -0.412, 0.831], + [ 1.31 , 1.213, 1.603, 0.042, 1.286]]]) + + Check by solving one pair of `c` and `b` vectors (cf. ``x[1, 1, :]``): + + >>> solve_circulant(c[1], b[1, :]) + array([ 0.856, 0.758, 1.149, -0.412, 0.831]) + + """ + c = np.atleast_1d(c) + nc = _get_axis_len("c", c, caxis) + b = np.atleast_1d(b) + nb = _get_axis_len("b", b, baxis) + if nc != nb: + raise ValueError(f'Shapes of c {c.shape} and b {b.shape} are incompatible') + + fc = np.fft.fft(np.moveaxis(c, caxis, -1), axis=-1) + abs_fc = np.abs(fc) + if tol is None: + # This is the same tolerance as used in np.linalg.matrix_rank. + tol = abs_fc.max(axis=-1) * nc * np.finfo(np.float64).eps + if tol.shape != (): + tol.shape = tol.shape + (1,) + else: + tol = np.atleast_1d(tol) + + near_zeros = abs_fc <= tol + is_near_singular = np.any(near_zeros) + if is_near_singular: + if singular == 'raise': + raise LinAlgError("near singular circulant matrix.") + else: + # Replace the small values with 1 to avoid errors in the + # division fb/fc below. + fc[near_zeros] = 1 + + fb = np.fft.fft(np.moveaxis(b, baxis, -1), axis=-1) + + q = fb / fc + + if is_near_singular: + # `near_zeros` is a boolean array, same shape as `c`, that is + # True where `fc` is (near) zero. `q` is the broadcasted result + # of fb / fc, so to set the values of `q` to 0 where `fc` is near + # zero, we use a mask that is the broadcast result of an array + # of True values shaped like `b` with `near_zeros`. + mask = np.ones_like(b, dtype=bool) & near_zeros + q[mask] = 0 + + x = np.fft.ifft(q, axis=-1) + if not (np.iscomplexobj(c) or np.iscomplexobj(b)): + x = x.real + if outaxis != -1: + x = np.moveaxis(x, -1, outaxis) + return x + + +# matrix inversion +def inv(a, overwrite_a=False, check_finite=True): + """ + Compute the inverse of a matrix. + + Parameters + ---------- + a : array_like + Square matrix to be inverted. + overwrite_a : bool, optional + Discard data in `a` (may improve performance). Default is False. + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + ainv : ndarray + Inverse of the matrix `a`. + + Raises + ------ + LinAlgError + If `a` is singular. + ValueError + If `a` is not square, or not 2D. + + Examples + -------- + >>> import numpy as np + >>> from scipy import linalg + >>> a = np.array([[1., 2.], [3., 4.]]) + >>> linalg.inv(a) + array([[-2. , 1. ], + [ 1.5, -0.5]]) + >>> np.dot(a, linalg.inv(a)) + array([[ 1., 0.], + [ 0., 1.]]) + + """ + a1 = _asarray_validated(a, check_finite=check_finite) + if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]: + raise ValueError('expected square matrix') + overwrite_a = overwrite_a or _datacopied(a1, a) + getrf, getri, getri_lwork = get_lapack_funcs(('getrf', 'getri', + 'getri_lwork'), + (a1,)) + lu, piv, info = getrf(a1, overwrite_a=overwrite_a) + if info == 0: + lwork = _compute_lwork(getri_lwork, a1.shape[0]) + + # XXX: the following line fixes curious SEGFAULT when + # benchmarking 500x500 matrix inverse. This seems to + # be a bug in LAPACK ?getri routine because if lwork is + # minimal (when using lwork[0] instead of lwork[1]) then + # all tests pass. Further investigation is required if + # more such SEGFAULTs occur. + lwork = int(1.01 * lwork) + inv_a, info = getri(lu, piv, lwork=lwork, overwrite_lu=1) + if info > 0: + raise LinAlgError("singular matrix") + if info < 0: + raise ValueError('illegal value in %d-th argument of internal ' + 'getrf|getri' % -info) + return inv_a + + +# Determinant + +def det(a, overwrite_a=False, check_finite=True): + """ + Compute the determinant of a matrix + + The determinant is a scalar that is a function of the associated square + matrix coefficients. The determinant value is zero for singular matrices. + + Parameters + ---------- + a : (..., M, M) array_like + Input array to compute determinants for. + overwrite_a : bool, optional + Allow overwriting data in a (may enhance performance). + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + det : (...) float or complex + Determinant of `a`. For stacked arrays, a scalar is returned for each + (m, m) slice in the last two dimensions of the input. For example, an + input of shape (p, q, m, m) will produce a result of shape (p, q). If + all dimensions are 1 a scalar is returned regardless of ndim. + + Notes + ----- + The determinant is computed by performing an LU factorization of the + input with LAPACK routine 'getrf', and then calculating the product of + diagonal entries of the U factor. + + Even the input array is single precision (float32 or complex64), the result + will be returned in double precision (float64 or complex128) to prevent + overflows. + + Examples + -------- + >>> import numpy as np + >>> from scipy import linalg + >>> a = np.array([[1,2,3], [4,5,6], [7,8,9]]) # A singular matrix + >>> linalg.det(a) + 0.0 + >>> b = np.array([[0,2,3], [4,5,6], [7,8,9]]) + >>> linalg.det(b) + 3.0 + >>> # An array with the shape (3, 2, 2, 2) + >>> c = np.array([[[[1., 2.], [3., 4.]], + ... [[5., 6.], [7., 8.]]], + ... [[[9., 10.], [11., 12.]], + ... [[13., 14.], [15., 16.]]], + ... [[[17., 18.], [19., 20.]], + ... [[21., 22.], [23., 24.]]]]) + >>> linalg.det(c) # The resulting shape is (3, 2) + array([[-2., -2.], + [-2., -2.], + [-2., -2.]]) + >>> linalg.det(c[0, 0]) # Confirm the (0, 0) slice, [[1, 2], [3, 4]] + -2.0 + """ + # The goal is to end up with a writable contiguous array to pass to Cython + + # First we check and make arrays. + a1 = np.asarray_chkfinite(a) if check_finite else np.asarray(a) + if a1.ndim < 2: + raise ValueError('The input array must be at least two-dimensional.') + if a1.shape[-1] != a1.shape[-2]: + raise ValueError('Last 2 dimensions of the array must be square' + f' but received shape {a1.shape}.') + + # Also check if dtype is LAPACK compatible + if a1.dtype.char not in 'fdFD': + dtype_char = lapack_cast_dict[a1.dtype.char] + if not dtype_char: # No casting possible + raise TypeError(f'The dtype "{a1.dtype.name}" cannot be cast ' + 'to float(32, 64) or complex(64, 128).') + + a1 = a1.astype(dtype_char[0]) # makes a copy, free to scratch + overwrite_a = True + + # Empty array has determinant 1 because math. + if min(*a1.shape) == 0: + if a1.ndim == 2: + return np.float64(1.) + else: + return np.ones(shape=a1.shape[:-2], dtype=np.float64) + + # Scalar case + if a1.shape[-2:] == (1, 1): + # Either ndarray with spurious singletons or a single element + if max(*a1.shape) > 1: + temp = np.squeeze(a1) + if a1.dtype.char in 'dD': + return temp + else: + return (temp.astype('d') if a1.dtype.char == 'f' else + temp.astype('D')) + else: + return (np.float64(a1.item()) if a1.dtype.char in 'fd' else + np.complex128(a1.item())) + + # Then check overwrite permission + if not _datacopied(a1, a): # "a" still alive through "a1" + if not overwrite_a: + # Data belongs to "a" so make a copy + a1 = a1.copy(order='C') + # else: Do nothing we'll use "a" if possible + # else: a1 has its own data thus free to scratch + + # Then layout checks, might happen that overwrite is allowed but original + # array was read-only or non-C-contiguous. + if not (a1.flags['C_CONTIGUOUS'] and a1.flags['WRITEABLE']): + a1 = a1.copy(order='C') + + if a1.ndim == 2: + det = find_det_from_lu(a1) + # Convert float, complex to to NumPy scalars + return (np.float64(det) if np.isrealobj(det) else np.complex128(det)) + + # loop over the stacked array, and avoid overflows for single precision + # Cf. np.linalg.det(np.diag([1e+38, 1e+38]).astype(np.float32)) + dtype_char = a1.dtype.char + if dtype_char in 'fF': + dtype_char = 'd' if dtype_char.islower() else 'D' + + det = np.empty(a1.shape[:-2], dtype=dtype_char) + for ind in product(*[range(x) for x in a1.shape[:-2]]): + det[ind] = find_det_from_lu(a1[ind]) + return det + + +# Linear Least Squares +def lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False, + check_finite=True, lapack_driver=None): + """ + Compute least-squares solution to equation Ax = b. + + Compute a vector x such that the 2-norm ``|b - A x|`` is minimized. + + Parameters + ---------- + a : (M, N) array_like + Left-hand side array + b : (M,) or (M, K) array_like + Right hand side array + cond : float, optional + Cutoff for 'small' singular values; used to determine effective + rank of a. Singular values smaller than + ``cond * largest_singular_value`` are considered zero. + overwrite_a : bool, optional + Discard data in `a` (may enhance performance). Default is False. + overwrite_b : bool, optional + Discard data in `b` (may enhance performance). Default is False. + check_finite : bool, optional + Whether to check that the input matrices contain only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + lapack_driver : str, optional + Which LAPACK driver is used to solve the least-squares problem. + Options are ``'gelsd'``, ``'gelsy'``, ``'gelss'``. Default + (``'gelsd'``) is a good choice. However, ``'gelsy'`` can be slightly + faster on many problems. ``'gelss'`` was used historically. It is + generally slow but uses less memory. + + .. versionadded:: 0.17.0 + + Returns + ------- + x : (N,) or (N, K) ndarray + Least-squares solution. + residues : (K,) ndarray or float + Square of the 2-norm for each column in ``b - a x``, if ``M > N`` and + ``rank(A) == n`` (returns a scalar if ``b`` is 1-D). Otherwise a + (0,)-shaped array is returned. + rank : int + Effective rank of `a`. + s : (min(M, N),) ndarray or None + Singular values of `a`. The condition number of ``a`` is + ``s[0] / s[-1]``. + + Raises + ------ + LinAlgError + If computation does not converge. + + ValueError + When parameters are not compatible. + + See Also + -------- + scipy.optimize.nnls : linear least squares with non-negativity constraint + + Notes + ----- + When ``'gelsy'`` is used as a driver, `residues` is set to a (0,)-shaped + array and `s` is always ``None``. + + Examples + -------- + >>> import numpy as np + >>> from scipy.linalg import lstsq + >>> import matplotlib.pyplot as plt + + Suppose we have the following data: + + >>> x = np.array([1, 2.5, 3.5, 4, 5, 7, 8.5]) + >>> y = np.array([0.3, 1.1, 1.5, 2.0, 3.2, 6.6, 8.6]) + + We want to fit a quadratic polynomial of the form ``y = a + b*x**2`` + to this data. We first form the "design matrix" M, with a constant + column of 1s and a column containing ``x**2``: + + >>> M = x[:, np.newaxis]**[0, 2] + >>> M + array([[ 1. , 1. ], + [ 1. , 6.25], + [ 1. , 12.25], + [ 1. , 16. ], + [ 1. , 25. ], + [ 1. , 49. ], + [ 1. , 72.25]]) + + We want to find the least-squares solution to ``M.dot(p) = y``, + where ``p`` is a vector with length 2 that holds the parameters + ``a`` and ``b``. + + >>> p, res, rnk, s = lstsq(M, y) + >>> p + array([ 0.20925829, 0.12013861]) + + Plot the data and the fitted curve. + + >>> plt.plot(x, y, 'o', label='data') + >>> xx = np.linspace(0, 9, 101) + >>> yy = p[0] + p[1]*xx**2 + >>> plt.plot(xx, yy, label='least squares fit, $y = a + bx^2$') + >>> plt.xlabel('x') + >>> plt.ylabel('y') + >>> plt.legend(framealpha=1, shadow=True) + >>> plt.grid(alpha=0.25) + >>> plt.show() + + """ + a1 = _asarray_validated(a, check_finite=check_finite) + b1 = _asarray_validated(b, check_finite=check_finite) + if len(a1.shape) != 2: + raise ValueError('Input array a should be 2D') + m, n = a1.shape + if len(b1.shape) == 2: + nrhs = b1.shape[1] + else: + nrhs = 1 + if m != b1.shape[0]: + raise ValueError('Shape mismatch: a and b should have the same number' + f' of rows ({m} != {b1.shape[0]}).') + if m == 0 or n == 0: # Zero-sized problem, confuses LAPACK + x = np.zeros((n,) + b1.shape[1:], dtype=np.common_type(a1, b1)) + if n == 0: + residues = np.linalg.norm(b1, axis=0)**2 + else: + residues = np.empty((0,)) + return x, residues, 0, np.empty((0,)) + + driver = lapack_driver + if driver is None: + driver = lstsq.default_lapack_driver + if driver not in ('gelsd', 'gelsy', 'gelss'): + raise ValueError('LAPACK driver "%s" is not found' % driver) + + lapack_func, lapack_lwork = get_lapack_funcs((driver, + '%s_lwork' % driver), + (a1, b1)) + real_data = True if (lapack_func.dtype.kind == 'f') else False + + if m < n: + # need to extend b matrix as it will be filled with + # a larger solution matrix + if len(b1.shape) == 2: + b2 = np.zeros((n, nrhs), dtype=lapack_func.dtype) + b2[:m, :] = b1 + else: + b2 = np.zeros(n, dtype=lapack_func.dtype) + b2[:m] = b1 + b1 = b2 + + overwrite_a = overwrite_a or _datacopied(a1, a) + overwrite_b = overwrite_b or _datacopied(b1, b) + + if cond is None: + cond = np.finfo(lapack_func.dtype).eps + + if driver in ('gelss', 'gelsd'): + if driver == 'gelss': + lwork = _compute_lwork(lapack_lwork, m, n, nrhs, cond) + v, x, s, rank, work, info = lapack_func(a1, b1, cond, lwork, + overwrite_a=overwrite_a, + overwrite_b=overwrite_b) + + elif driver == 'gelsd': + if real_data: + lwork, iwork = _compute_lwork(lapack_lwork, m, n, nrhs, cond) + x, s, rank, info = lapack_func(a1, b1, lwork, + iwork, cond, False, False) + else: # complex data + lwork, rwork, iwork = _compute_lwork(lapack_lwork, m, n, + nrhs, cond) + x, s, rank, info = lapack_func(a1, b1, lwork, rwork, iwork, + cond, False, False) + if info > 0: + raise LinAlgError("SVD did not converge in Linear Least Squares") + if info < 0: + raise ValueError('illegal value in %d-th argument of internal %s' + % (-info, lapack_driver)) + resids = np.asarray([], dtype=x.dtype) + if m > n: + x1 = x[:n] + if rank == n: + resids = np.sum(np.abs(x[n:])**2, axis=0) + x = x1 + return x, resids, rank, s + + elif driver == 'gelsy': + lwork = _compute_lwork(lapack_lwork, m, n, nrhs, cond) + jptv = np.zeros((a1.shape[1], 1), dtype=np.int32) + v, x, j, rank, info = lapack_func(a1, b1, jptv, cond, + lwork, False, False) + if info < 0: + raise ValueError("illegal value in %d-th argument of internal " + "gelsy" % -info) + if m > n: + x1 = x[:n] + x = x1 + return x, np.array([], x.dtype), rank, None + + +lstsq.default_lapack_driver = 'gelsd' + + +@_deprecate_positional_args(version="1.14") +def pinv(a, *, atol=None, rtol=None, return_rank=False, check_finite=True, + cond=_NoValue, rcond=_NoValue): + """ + Compute the (Moore-Penrose) pseudo-inverse of a matrix. + + Calculate a generalized inverse of a matrix using its + singular-value decomposition ``U @ S @ V`` in the economy mode and picking + up only the columns/rows that are associated with significant singular + values. + + If ``s`` is the maximum singular value of ``a``, then the + significance cut-off value is determined by ``atol + rtol * s``. Any + singular value below this value is assumed insignificant. + + Parameters + ---------- + a : (M, N) array_like + Matrix to be pseudo-inverted. + atol : float, optional + Absolute threshold term, default value is 0. + + .. versionadded:: 1.7.0 + + rtol : float, optional + Relative threshold term, default value is ``max(M, N) * eps`` where + ``eps`` is the machine precision value of the datatype of ``a``. + + .. versionadded:: 1.7.0 + + return_rank : bool, optional + If True, return the effective rank of the matrix. + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + cond, rcond : float, optional + In older versions, these values were meant to be used as ``atol`` with + ``rtol=0``. If both were given ``rcond`` overwrote ``cond`` and hence + the code was not correct. Thus using these are strongly discouraged and + the tolerances above are recommended instead. In fact, if provided, + atol, rtol takes precedence over these keywords. + + .. deprecated:: 1.7.0 + Deprecated in favor of ``rtol`` and ``atol`` parameters above and + will be removed in SciPy 1.14.0. + + .. versionchanged:: 1.3.0 + Previously the default cutoff value was just ``eps*f`` where ``f`` + was ``1e3`` for single precision and ``1e6`` for double precision. + + Returns + ------- + B : (N, M) ndarray + The pseudo-inverse of matrix `a`. + rank : int + The effective rank of the matrix. Returned if `return_rank` is True. + + Raises + ------ + LinAlgError + If SVD computation does not converge. + + See Also + -------- + pinvh : Moore-Penrose pseudoinverse of a hermitian matrix. + + Notes + ----- + If ``A`` is invertible then the Moore-Penrose pseudoinverse is exactly + the inverse of ``A`` [1]_. If ``A`` is not invertible then the + Moore-Penrose pseudoinverse computes the ``x`` solution to ``Ax = b`` such + that ``||Ax - b||`` is minimized [1]_. + + References + ---------- + .. [1] Penrose, R. (1956). On best approximate solutions of linear matrix + equations. Mathematical Proceedings of the Cambridge Philosophical + Society, 52(1), 17-19. doi:10.1017/S0305004100030929 + + Examples + -------- + + Given an ``m x n`` matrix ``A`` and an ``n x m`` matrix ``B`` the four + Moore-Penrose conditions are: + + 1. ``ABA = A`` (``B`` is a generalized inverse of ``A``), + 2. ``BAB = B`` (``A`` is a generalized inverse of ``B``), + 3. ``(AB)* = AB`` (``AB`` is hermitian), + 4. ``(BA)* = BA`` (``BA`` is hermitian) [1]_. + + Here, ``A*`` denotes the conjugate transpose. The Moore-Penrose + pseudoinverse is a unique ``B`` that satisfies all four of these + conditions and exists for any ``A``. Note that, unlike the standard + matrix inverse, ``A`` does not have to be a square matrix or have + linearly independent columns/rows. + + As an example, we can calculate the Moore-Penrose pseudoinverse of a + random non-square matrix and verify it satisfies the four conditions. + + >>> import numpy as np + >>> from scipy import linalg + >>> rng = np.random.default_rng() + >>> A = rng.standard_normal((9, 6)) + >>> B = linalg.pinv(A) + >>> np.allclose(A @ B @ A, A) # Condition 1 + True + >>> np.allclose(B @ A @ B, B) # Condition 2 + True + >>> np.allclose((A @ B).conj().T, A @ B) # Condition 3 + True + >>> np.allclose((B @ A).conj().T, B @ A) # Condition 4 + True + + """ + a = _asarray_validated(a, check_finite=check_finite) + u, s, vh = _decomp_svd.svd(a, full_matrices=False, check_finite=False) + t = u.dtype.char.lower() + maxS = np.max(s) + + if rcond is not _NoValue or cond is not _NoValue: + warn('Use of the "cond" and "rcond" keywords are deprecated and ' + 'will be removed in SciPy 1.14.0. Use "atol" and ' + '"rtol" keywords instead', DeprecationWarning, stacklevel=2) + + # backwards compatible only atol and rtol are both missing + if ((rcond not in (_NoValue, None) or cond not in (_NoValue, None)) + and (atol is None) and (rtol is None)): + atol = rcond if rcond not in (_NoValue, None) else cond + rtol = 0. + + atol = 0. if atol is None else atol + rtol = max(a.shape) * np.finfo(t).eps if (rtol is None) else rtol + + if (atol < 0.) or (rtol < 0.): + raise ValueError("atol and rtol values must be positive.") + + val = atol + maxS * rtol + rank = np.sum(s > val) + + u = u[:, :rank] + u /= s[:rank] + B = (u @ vh[:rank]).conj().T + + if return_rank: + return B, rank + else: + return B + + +def pinvh(a, atol=None, rtol=None, lower=True, return_rank=False, + check_finite=True): + """ + Compute the (Moore-Penrose) pseudo-inverse of a Hermitian matrix. + + Calculate a generalized inverse of a complex Hermitian/real symmetric + matrix using its eigenvalue decomposition and including all eigenvalues + with 'large' absolute value. + + Parameters + ---------- + a : (N, N) array_like + Real symmetric or complex hermetian matrix to be pseudo-inverted + + atol : float, optional + Absolute threshold term, default value is 0. + + .. versionadded:: 1.7.0 + + rtol : float, optional + Relative threshold term, default value is ``N * eps`` where + ``eps`` is the machine precision value of the datatype of ``a``. + + .. versionadded:: 1.7.0 + + lower : bool, optional + Whether the pertinent array data is taken from the lower or upper + triangle of `a`. (Default: lower) + return_rank : bool, optional + If True, return the effective rank of the matrix. + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + B : (N, N) ndarray + The pseudo-inverse of matrix `a`. + rank : int + The effective rank of the matrix. Returned if `return_rank` is True. + + Raises + ------ + LinAlgError + If eigenvalue algorithm does not converge. + + See Also + -------- + pinv : Moore-Penrose pseudoinverse of a matrix. + + Examples + -------- + + For a more detailed example see `pinv`. + + >>> import numpy as np + >>> from scipy.linalg import pinvh + >>> rng = np.random.default_rng() + >>> a = rng.standard_normal((9, 6)) + >>> a = np.dot(a, a.T) + >>> B = pinvh(a) + >>> np.allclose(a, a @ B @ a) + True + >>> np.allclose(B, B @ a @ B) + True + + """ + a = _asarray_validated(a, check_finite=check_finite) + s, u = _decomp.eigh(a, lower=lower, check_finite=False) + t = u.dtype.char.lower() + maxS = np.max(np.abs(s)) + + atol = 0. if atol is None else atol + rtol = max(a.shape) * np.finfo(t).eps if (rtol is None) else rtol + + if (atol < 0.) or (rtol < 0.): + raise ValueError("atol and rtol values must be positive.") + + val = atol + maxS * rtol + above_cutoff = (abs(s) > val) + + psigma_diag = 1.0 / s[above_cutoff] + u = u[:, above_cutoff] + + B = (u * psigma_diag) @ u.conj().T + + if return_rank: + return B, len(psigma_diag) + else: + return B + + +def matrix_balance(A, permute=True, scale=True, separate=False, + overwrite_a=False): + """ + Compute a diagonal similarity transformation for row/column balancing. + + The balancing tries to equalize the row and column 1-norms by applying + a similarity transformation such that the magnitude variation of the + matrix entries is reflected to the scaling matrices. + + Moreover, if enabled, the matrix is first permuted to isolate the upper + triangular parts of the matrix and, again if scaling is also enabled, + only the remaining subblocks are subjected to scaling. + + The balanced matrix satisfies the following equality + + .. math:: + + B = T^{-1} A T + + The scaling coefficients are approximated to the nearest power of 2 + to avoid round-off errors. + + Parameters + ---------- + A : (n, n) array_like + Square data matrix for the balancing. + permute : bool, optional + The selector to define whether permutation of A is also performed + prior to scaling. + scale : bool, optional + The selector to turn on and off the scaling. If False, the matrix + will not be scaled. + separate : bool, optional + This switches from returning a full matrix of the transformation + to a tuple of two separate 1-D permutation and scaling arrays. + overwrite_a : bool, optional + This is passed to xGEBAL directly. Essentially, overwrites the result + to the data. It might increase the space efficiency. See LAPACK manual + for details. This is False by default. + + Returns + ------- + B : (n, n) ndarray + Balanced matrix + T : (n, n) ndarray + A possibly permuted diagonal matrix whose nonzero entries are + integer powers of 2 to avoid numerical truncation errors. + scale, perm : (n,) ndarray + If ``separate`` keyword is set to True then instead of the array + ``T`` above, the scaling and the permutation vectors are given + separately as a tuple without allocating the full array ``T``. + + Notes + ----- + This algorithm is particularly useful for eigenvalue and matrix + decompositions and in many cases it is already called by various + LAPACK routines. + + The algorithm is based on the well-known technique of [1]_ and has + been modified to account for special cases. See [2]_ for details + which have been implemented since LAPACK v3.5.0. Before this version + there are corner cases where balancing can actually worsen the + conditioning. See [3]_ for such examples. + + The code is a wrapper around LAPACK's xGEBAL routine family for matrix + balancing. + + .. versionadded:: 0.19.0 + + References + ---------- + .. [1] B.N. Parlett and C. Reinsch, "Balancing a Matrix for + Calculation of Eigenvalues and Eigenvectors", Numerische Mathematik, + Vol.13(4), 1969, :doi:`10.1007/BF02165404` + .. [2] R. James, J. Langou, B.R. Lowery, "On matrix balancing and + eigenvector computation", 2014, :arxiv:`1401.5766` + .. [3] D.S. Watkins. A case where balancing is harmful. + Electron. Trans. Numer. Anal, Vol.23, 2006. + + Examples + -------- + >>> import numpy as np + >>> from scipy import linalg + >>> x = np.array([[1,2,0], [9,1,0.01], [1,2,10*np.pi]]) + + >>> y, permscale = linalg.matrix_balance(x) + >>> np.abs(x).sum(axis=0) / np.abs(x).sum(axis=1) + array([ 3.66666667, 0.4995005 , 0.91312162]) + + >>> np.abs(y).sum(axis=0) / np.abs(y).sum(axis=1) + array([ 1.2 , 1.27041742, 0.92658316]) # may vary + + >>> permscale # only powers of 2 (0.5 == 2^(-1)) + array([[ 0.5, 0. , 0. ], # may vary + [ 0. , 1. , 0. ], + [ 0. , 0. , 1. ]]) + + """ + + A = np.atleast_2d(_asarray_validated(A, check_finite=True)) + + if not np.equal(*A.shape): + raise ValueError('The data matrix for balancing should be square.') + + gebal = get_lapack_funcs(('gebal'), (A,)) + B, lo, hi, ps, info = gebal(A, scale=scale, permute=permute, + overwrite_a=overwrite_a) + + if info < 0: + raise ValueError('xGEBAL exited with the internal error ' + f'"illegal value in argument number {-info}.". See ' + 'LAPACK documentation for the xGEBAL error codes.') + + # Separate the permutations from the scalings and then convert to int + scaling = np.ones_like(ps, dtype=float) + scaling[lo:hi+1] = ps[lo:hi+1] + + # gebal uses 1-indexing + ps = ps.astype(int, copy=False) - 1 + n = A.shape[0] + perm = np.arange(n) + + # LAPACK permutes with the ordering n --> hi, then 0--> lo + if hi < n: + for ind, x in enumerate(ps[hi+1:][::-1], 1): + if n-ind == x: + continue + perm[[x, n-ind]] = perm[[n-ind, x]] + + if lo > 0: + for ind, x in enumerate(ps[:lo]): + if ind == x: + continue + perm[[x, ind]] = perm[[ind, x]] + + if separate: + return B, (scaling, perm) + + # get the inverse permutation + iperm = np.empty_like(perm) + iperm[perm] = np.arange(n) + + return B, np.diag(scaling)[iperm, :] + + +def _validate_args_for_toeplitz_ops(c_or_cr, b, check_finite, keep_b_shape, + enforce_square=True): + """Validate arguments and format inputs for toeplitz functions + + Parameters + ---------- + c_or_cr : array_like or tuple of (array_like, array_like) + The vector ``c``, or a tuple of arrays (``c``, ``r``). Whatever the + actual shape of ``c``, it will be converted to a 1-D array. If not + supplied, ``r = conjugate(c)`` is assumed; in this case, if c[0] is + real, the Toeplitz matrix is Hermitian. r[0] is ignored; the first row + of the Toeplitz matrix is ``[c[0], r[1:]]``. Whatever the actual shape + of ``r``, it will be converted to a 1-D array. + b : (M,) or (M, K) array_like + Right-hand side in ``T x = b``. + check_finite : bool + Whether to check that the input matrices contain only finite numbers. + Disabling may give a performance gain, but may result in problems + (result entirely NaNs) if the inputs do contain infinities or NaNs. + keep_b_shape : bool + Whether to convert a (M,) dimensional b into a (M, 1) dimensional + matrix. + enforce_square : bool, optional + If True (default), this verifies that the Toeplitz matrix is square. + + Returns + ------- + r : array + 1d array corresponding to the first row of the Toeplitz matrix. + c: array + 1d array corresponding to the first column of the Toeplitz matrix. + b: array + (M,), (M, 1) or (M, K) dimensional array, post validation, + corresponding to ``b``. + dtype: numpy datatype + ``dtype`` stores the datatype of ``r``, ``c`` and ``b``. If any of + ``r``, ``c`` or ``b`` are complex, ``dtype`` is ``np.complex128``, + otherwise, it is ``np.float``. + b_shape: tuple + Shape of ``b`` after passing it through ``_asarray_validated``. + + """ + + if isinstance(c_or_cr, tuple): + c, r = c_or_cr + c = _asarray_validated(c, check_finite=check_finite).ravel() + r = _asarray_validated(r, check_finite=check_finite).ravel() + else: + c = _asarray_validated(c_or_cr, check_finite=check_finite).ravel() + r = c.conjugate() + + if b is None: + raise ValueError('`b` must be an array, not None.') + + b = _asarray_validated(b, check_finite=check_finite) + b_shape = b.shape + + is_not_square = r.shape[0] != c.shape[0] + if (enforce_square and is_not_square) or b.shape[0] != r.shape[0]: + raise ValueError('Incompatible dimensions.') + + is_cmplx = np.iscomplexobj(r) or np.iscomplexobj(c) or np.iscomplexobj(b) + dtype = np.complex128 if is_cmplx else np.float64 + r, c, b = (np.asarray(i, dtype=dtype) for i in (r, c, b)) + + if b.ndim == 1 and not keep_b_shape: + b = b.reshape(-1, 1) + elif b.ndim != 1: + b = b.reshape(b.shape[0], -1) + + return r, c, b, dtype, b_shape + + +def matmul_toeplitz(c_or_cr, x, check_finite=False, workers=None): + """Efficient Toeplitz Matrix-Matrix Multiplication using FFT + + This function returns the matrix multiplication between a Toeplitz + matrix and a dense matrix. + + The Toeplitz matrix has constant diagonals, with c as its first column + and r as its first row. If r is not given, ``r == conjugate(c)`` is + assumed. + + Parameters + ---------- + c_or_cr : array_like or tuple of (array_like, array_like) + The vector ``c``, or a tuple of arrays (``c``, ``r``). Whatever the + actual shape of ``c``, it will be converted to a 1-D array. If not + supplied, ``r = conjugate(c)`` is assumed; in this case, if c[0] is + real, the Toeplitz matrix is Hermitian. r[0] is ignored; the first row + of the Toeplitz matrix is ``[c[0], r[1:]]``. Whatever the actual shape + of ``r``, it will be converted to a 1-D array. + x : (M,) or (M, K) array_like + Matrix with which to multiply. + check_finite : bool, optional + Whether to check that the input matrices contain only finite numbers. + Disabling may give a performance gain, but may result in problems + (result entirely NaNs) if the inputs do contain infinities or NaNs. + workers : int, optional + To pass to scipy.fft.fft and ifft. Maximum number of workers to use + for parallel computation. If negative, the value wraps around from + ``os.cpu_count()``. See scipy.fft.fft for more details. + + Returns + ------- + T @ x : (M,) or (M, K) ndarray + The result of the matrix multiplication ``T @ x``. Shape of return + matches shape of `x`. + + See Also + -------- + toeplitz : Toeplitz matrix + solve_toeplitz : Solve a Toeplitz system using Levinson Recursion + + Notes + ----- + The Toeplitz matrix is embedded in a circulant matrix and the FFT is used + to efficiently calculate the matrix-matrix product. + + Because the computation is based on the FFT, integer inputs will + result in floating point outputs. This is unlike NumPy's `matmul`, + which preserves the data type of the input. + + This is partly based on the implementation that can be found in [1]_, + licensed under the MIT license. More information about the method can be + found in reference [2]_. References [3]_ and [4]_ have more reference + implementations in Python. + + .. versionadded:: 1.6.0 + + References + ---------- + .. [1] Jacob R Gardner, Geoff Pleiss, David Bindel, Kilian + Q Weinberger, Andrew Gordon Wilson, "GPyTorch: Blackbox Matrix-Matrix + Gaussian Process Inference with GPU Acceleration" with contributions + from Max Balandat and Ruihan Wu. Available online: + https://github.com/cornellius-gp/gpytorch + + .. [2] J. Demmel, P. Koev, and X. Li, "A Brief Survey of Direct Linear + Solvers". In Z. Bai, J. Demmel, J. Dongarra, A. Ruhe, and H. van der + Vorst, editors. Templates for the Solution of Algebraic Eigenvalue + Problems: A Practical Guide. SIAM, Philadelphia, 2000. Available at: + http://www.netlib.org/utk/people/JackDongarra/etemplates/node384.html + + .. [3] R. Scheibler, E. Bezzam, I. Dokmanic, Pyroomacoustics: A Python + package for audio room simulations and array processing algorithms, + Proc. IEEE ICASSP, Calgary, CA, 2018. + https://github.com/LCAV/pyroomacoustics/blob/pypi-release/ + pyroomacoustics/adaptive/util.py + + .. [4] Marano S, Edwards B, Ferrari G and Fah D (2017), "Fitting + Earthquake Spectra: Colored Noise and Incomplete Data", Bulletin of + the Seismological Society of America., January, 2017. Vol. 107(1), + pp. 276-291. + + Examples + -------- + Multiply the Toeplitz matrix T with matrix x:: + + [ 1 -1 -2 -3] [1 10] + T = [ 3 1 -1 -2] x = [2 11] + [ 6 3 1 -1] [2 11] + [10 6 3 1] [5 19] + + To specify the Toeplitz matrix, only the first column and the first + row are needed. + + >>> import numpy as np + >>> c = np.array([1, 3, 6, 10]) # First column of T + >>> r = np.array([1, -1, -2, -3]) # First row of T + >>> x = np.array([[1, 10], [2, 11], [2, 11], [5, 19]]) + + >>> from scipy.linalg import toeplitz, matmul_toeplitz + >>> matmul_toeplitz((c, r), x) + array([[-20., -80.], + [ -7., -8.], + [ 9., 85.], + [ 33., 218.]]) + + Check the result by creating the full Toeplitz matrix and + multiplying it by ``x``. + + >>> toeplitz(c, r) @ x + array([[-20, -80], + [ -7, -8], + [ 9, 85], + [ 33, 218]]) + + The full matrix is never formed explicitly, so this routine + is suitable for very large Toeplitz matrices. + + >>> n = 1000000 + >>> matmul_toeplitz([1] + [0]*(n-1), np.ones(n)) + array([1., 1., 1., ..., 1., 1., 1.]) + + """ + + from ..fft import fft, ifft, rfft, irfft + + r, c, x, dtype, x_shape = _validate_args_for_toeplitz_ops( + c_or_cr, x, check_finite, keep_b_shape=False, enforce_square=False) + n, m = x.shape + + T_nrows = len(c) + T_ncols = len(r) + p = T_nrows + T_ncols - 1 # equivalent to len(embedded_col) + + embedded_col = np.concatenate((c, r[-1:0:-1])) + + if np.iscomplexobj(embedded_col) or np.iscomplexobj(x): + fft_mat = fft(embedded_col, axis=0, workers=workers).reshape(-1, 1) + fft_x = fft(x, n=p, axis=0, workers=workers) + + mat_times_x = ifft(fft_mat*fft_x, axis=0, + workers=workers)[:T_nrows, :] + else: + # Real inputs; using rfft is faster + fft_mat = rfft(embedded_col, axis=0, workers=workers).reshape(-1, 1) + fft_x = rfft(x, n=p, axis=0, workers=workers) + + mat_times_x = irfft(fft_mat*fft_x, axis=0, + workers=workers, n=p)[:T_nrows, :] + + return_shape = (T_nrows,) if len(x_shape) == 1 else (T_nrows, m) + return mat_times_x.reshape(*return_shape) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_cythonized_array_utils.pyi b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_cythonized_array_utils.pyi new file mode 100644 index 0000000000000000000000000000000000000000..5633cb61ecf3a90eba901120f64fa6cc6634fa5a --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_cythonized_array_utils.pyi @@ -0,0 +1,16 @@ +from numpy.typing import NDArray +from typing import Any + +def bandwidth(a: NDArray[Any]) -> tuple[int, int]: ... + +def issymmetric( + a: NDArray[Any], + atol: None | float = ..., + rtol: None | float = ..., +) -> bool: ... + +def ishermitian( + a: NDArray[Any], + atol: None | float = ..., + rtol: None | float = ..., +) -> bool: ... diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_cossin.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_cossin.py new file mode 100644 index 0000000000000000000000000000000000000000..bb8603d03c7942fa472d7bf04073976f2b77c0cc --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_cossin.py @@ -0,0 +1,221 @@ +from collections.abc import Iterable +import numpy as np + +from scipy._lib._util import _asarray_validated +from scipy.linalg import block_diag, LinAlgError +from .lapack import _compute_lwork, get_lapack_funcs + +__all__ = ['cossin'] + + +def cossin(X, p=None, q=None, separate=False, + swap_sign=False, compute_u=True, compute_vh=True): + """ + Compute the cosine-sine (CS) decomposition of an orthogonal/unitary matrix. + + X is an ``(m, m)`` orthogonal/unitary matrix, partitioned as the following + where upper left block has the shape of ``(p, q)``:: + + ┌ â” + │ I 0 0 │ 0 0 0 │ + ┌ ┠┌ â”│ 0 C 0 │ 0 -S 0 │┌ â”* + │ X11 │ X12 │ │ U1 │ ││ 0 0 0 │ 0 0 -I ││ V1 │ │ + │ ────┼──── │ = │────┼────││─────────┼─────────││────┼────│ + │ X21 │ X22 │ │ │ U2 ││ 0 0 0 │ I 0 0 ││ │ V2 │ + â”” ┘ â”” ┘│ 0 S 0 │ 0 C 0 │└ ┘ + │ 0 0 I │ 0 0 0 │ + â”” ┘ + + ``U1``, ``U2``, ``V1``, ``V2`` are square orthogonal/unitary matrices of + dimensions ``(p,p)``, ``(m-p,m-p)``, ``(q,q)``, and ``(m-q,m-q)`` + respectively, and ``C`` and ``S`` are ``(r, r)`` nonnegative diagonal + matrices satisfying ``C^2 + S^2 = I`` where ``r = min(p, m-p, q, m-q)``. + + Moreover, the rank of the identity matrices are ``min(p, q) - r``, + ``min(p, m - q) - r``, ``min(m - p, q) - r``, and ``min(m - p, m - q) - r`` + respectively. + + X can be supplied either by itself and block specifications p, q or its + subblocks in an iterable from which the shapes would be derived. See the + examples below. + + Parameters + ---------- + X : array_like, iterable + complex unitary or real orthogonal matrix to be decomposed, or iterable + of subblocks ``X11``, ``X12``, ``X21``, ``X22``, when ``p``, ``q`` are + omitted. + p : int, optional + Number of rows of the upper left block ``X11``, used only when X is + given as an array. + q : int, optional + Number of columns of the upper left block ``X11``, used only when X is + given as an array. + separate : bool, optional + if ``True``, the low level components are returned instead of the + matrix factors, i.e. ``(u1,u2)``, ``theta``, ``(v1h,v2h)`` instead of + ``u``, ``cs``, ``vh``. + swap_sign : bool, optional + if ``True``, the ``-S``, ``-I`` block will be the bottom left, + otherwise (by default) they will be in the upper right block. + compute_u : bool, optional + if ``False``, ``u`` won't be computed and an empty array is returned. + compute_vh : bool, optional + if ``False``, ``vh`` won't be computed and an empty array is returned. + + Returns + ------- + u : ndarray + When ``compute_u=True``, contains the block diagonal orthogonal/unitary + matrix consisting of the blocks ``U1`` (``p`` x ``p``) and ``U2`` + (``m-p`` x ``m-p``) orthogonal/unitary matrices. If ``separate=True``, + this contains the tuple of ``(U1, U2)``. + cs : ndarray + The cosine-sine factor with the structure described above. + If ``separate=True``, this contains the ``theta`` array containing the + angles in radians. + vh : ndarray + When ``compute_vh=True`, contains the block diagonal orthogonal/unitary + matrix consisting of the blocks ``V1H`` (``q`` x ``q``) and ``V2H`` + (``m-q`` x ``m-q``) orthogonal/unitary matrices. If ``separate=True``, + this contains the tuple of ``(V1H, V2H)``. + + References + ---------- + .. [1] Brian D. Sutton. Computing the complete CS decomposition. Numer. + Algorithms, 50(1):33-65, 2009. + + Examples + -------- + >>> import numpy as np + >>> from scipy.linalg import cossin + >>> from scipy.stats import unitary_group + >>> x = unitary_group.rvs(4) + >>> u, cs, vdh = cossin(x, p=2, q=2) + >>> np.allclose(x, u @ cs @ vdh) + True + + Same can be entered via subblocks without the need of ``p`` and ``q``. Also + let's skip the computation of ``u`` + + >>> ue, cs, vdh = cossin((x[:2, :2], x[:2, 2:], x[2:, :2], x[2:, 2:]), + ... compute_u=False) + >>> print(ue) + [] + >>> np.allclose(x, u @ cs @ vdh) + True + + """ + + if p or q: + p = 1 if p is None else int(p) + q = 1 if q is None else int(q) + X = _asarray_validated(X, check_finite=True) + if not np.equal(*X.shape): + raise ValueError("Cosine Sine decomposition only supports square" + f" matrices, got {X.shape}") + m = X.shape[0] + if p >= m or p <= 0: + raise ValueError(f"invalid p={p}, 0= m or q <= 0: + raise ValueError(f"invalid q={q}, 0 0: + raise LinAlgError(f"{method_name} did not converge: {info}") + + if separate: + return (u1, u2), theta, (v1h, v2h) + + U = block_diag(u1, u2) + VDH = block_diag(v1h, v2h) + + # Construct the middle factor CS + c = np.diag(np.cos(theta)) + s = np.diag(np.sin(theta)) + r = min(p, q, m - p, m - q) + n11 = min(p, q) - r + n12 = min(p, m - q) - r + n21 = min(m - p, q) - r + n22 = min(m - p, m - q) - r + Id = np.eye(np.max([n11, n12, n21, n22, r]), dtype=theta.dtype) + CS = np.zeros((m, m), dtype=theta.dtype) + + CS[:n11, :n11] = Id[:n11, :n11] + + xs = n11 + r + xe = n11 + r + n12 + ys = n11 + n21 + n22 + 2 * r + ye = n11 + n21 + n22 + 2 * r + n12 + CS[xs: xe, ys:ye] = Id[:n12, :n12] if swap_sign else -Id[:n12, :n12] + + xs = p + n22 + r + xe = p + n22 + r + + n21 + ys = n11 + r + ye = n11 + r + n21 + CS[xs:xe, ys:ye] = -Id[:n21, :n21] if swap_sign else Id[:n21, :n21] + + CS[p:p + n22, q:q + n22] = Id[:n22, :n22] + CS[n11:n11 + r, n11:n11 + r] = c + CS[p + n22:p + n22 + r, r + n21 + n22:2 * r + n21 + n22] = c + + xs = n11 + xe = n11 + r + ys = n11 + n21 + n22 + r + ye = n11 + n21 + n22 + 2 * r + CS[xs:xe, ys:ye] = s if swap_sign else -s + + CS[p + n22:p + n22 + r, n11:n11 + r] = -s if swap_sign else s + + return U, CS, VDH diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_lu.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_lu.py new file mode 100644 index 0000000000000000000000000000000000000000..2bb088b453178335648a7dd0d345b52dbf6ef802 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_lu.py @@ -0,0 +1,374 @@ +"""LU decomposition functions.""" + +from warnings import warn + +from numpy import asarray, asarray_chkfinite +import numpy as np +from itertools import product + +# Local imports +from ._misc import _datacopied, LinAlgWarning +from .lapack import get_lapack_funcs +from ._decomp_lu_cython import lu_dispatcher + +lapack_cast_dict = {x: ''.join([y for y in 'fdFD' if np.can_cast(x, y)]) + for x in np.typecodes['All']} + +__all__ = ['lu', 'lu_solve', 'lu_factor'] + + +def lu_factor(a, overwrite_a=False, check_finite=True): + """ + Compute pivoted LU decomposition of a matrix. + + The decomposition is:: + + A = P L U + + where P is a permutation matrix, L lower triangular with unit + diagonal elements, and U upper triangular. + + Parameters + ---------- + a : (M, N) array_like + Matrix to decompose + overwrite_a : bool, optional + Whether to overwrite data in A (may increase performance) + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + lu : (M, N) ndarray + Matrix containing U in its upper triangle, and L in its lower triangle. + The unit diagonal elements of L are not stored. + piv : (K,) ndarray + Pivot indices representing the permutation matrix P: + row i of matrix was interchanged with row piv[i]. + Of shape ``(K,)``, with ``K = min(M, N)``. + + See Also + -------- + lu : gives lu factorization in more user-friendly format + lu_solve : solve an equation system using the LU factorization of a matrix + + Notes + ----- + This is a wrapper to the ``*GETRF`` routines from LAPACK. Unlike + :func:`lu`, it outputs the L and U factors into a single array + and returns pivot indices instead of a permutation matrix. + + While the underlying ``*GETRF`` routines return 1-based pivot indices, the + ``piv`` array returned by ``lu_factor`` contains 0-based indices. + + Examples + -------- + >>> import numpy as np + >>> from scipy.linalg import lu_factor + >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]]) + >>> lu, piv = lu_factor(A) + >>> piv + array([2, 2, 3, 3], dtype=int32) + + Convert LAPACK's ``piv`` array to NumPy index and test the permutation + + >>> def pivot_to_permutation(piv): + ... perm = np.arange(len(piv)) + ... for i in range(len(piv)): + ... perm[i], perm[piv[i]] = perm[piv[i]], perm[i] + ... return perm + ... + >>> p_inv = pivot_to_permutation(piv) + >>> p_inv + array([2, 0, 3, 1]) + >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu) + >>> np.allclose(A[p_inv] - L @ U, np.zeros((4, 4))) + True + + The P matrix in P L U is defined by the inverse permutation and + can be recovered using argsort: + + >>> p = np.argsort(p_inv) + >>> p + array([1, 3, 0, 2]) + >>> np.allclose(A - L[p] @ U, np.zeros((4, 4))) + True + + or alternatively: + + >>> P = np.eye(4)[p] + >>> np.allclose(A - P @ L @ U, np.zeros((4, 4))) + True + """ + if check_finite: + a1 = asarray_chkfinite(a) + else: + a1 = asarray(a) + overwrite_a = overwrite_a or (_datacopied(a1, a)) + getrf, = get_lapack_funcs(('getrf',), (a1,)) + lu, piv, info = getrf(a1, overwrite_a=overwrite_a) + if info < 0: + raise ValueError('illegal value in %dth argument of ' + 'internal getrf (lu_factor)' % -info) + if info > 0: + warn("Diagonal number %d is exactly zero. Singular matrix." % info, + LinAlgWarning, stacklevel=2) + return lu, piv + + +def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True): + """Solve an equation system, a x = b, given the LU factorization of a + + Parameters + ---------- + (lu, piv) + Factorization of the coefficient matrix a, as given by lu_factor. + In particular piv are 0-indexed pivot indices. + b : array + Right-hand side + trans : {0, 1, 2}, optional + Type of system to solve: + + ===== ========= + trans system + ===== ========= + 0 a x = b + 1 a^T x = b + 2 a^H x = b + ===== ========= + overwrite_b : bool, optional + Whether to overwrite data in b (may increase performance) + check_finite : bool, optional + Whether to check that the input matrices contain only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + x : array + Solution to the system + + See Also + -------- + lu_factor : LU factorize a matrix + + Examples + -------- + >>> import numpy as np + >>> from scipy.linalg import lu_factor, lu_solve + >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]]) + >>> b = np.array([1, 1, 1, 1]) + >>> lu, piv = lu_factor(A) + >>> x = lu_solve((lu, piv), b) + >>> np.allclose(A @ x - b, np.zeros((4,))) + True + + """ + (lu, piv) = lu_and_piv + if check_finite: + b1 = asarray_chkfinite(b) + else: + b1 = asarray(b) + overwrite_b = overwrite_b or _datacopied(b1, b) + if lu.shape[0] != b1.shape[0]: + raise ValueError(f"Shapes of lu {lu.shape} and b {b1.shape} are incompatible") + + getrs, = get_lapack_funcs(('getrs',), (lu, b1)) + x, info = getrs(lu, piv, b1, trans=trans, overwrite_b=overwrite_b) + if info == 0: + return x + raise ValueError('illegal value in %dth argument of internal gesv|posv' + % -info) + + +def lu(a, permute_l=False, overwrite_a=False, check_finite=True, + p_indices=False): + """ + Compute LU decomposition of a matrix with partial pivoting. + + The decomposition satisfies:: + + A = P @ L @ U + + where ``P`` is a permutation matrix, ``L`` lower triangular with unit + diagonal elements, and ``U`` upper triangular. If `permute_l` is set to + ``True`` then ``L`` is returned already permuted and hence satisfying + ``A = L @ U``. + + Parameters + ---------- + a : (M, N) array_like + Array to decompose + permute_l : bool, optional + Perform the multiplication P*L (Default: do not permute) + overwrite_a : bool, optional + Whether to overwrite data in a (may improve performance) + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + p_indices : bool, optional + If ``True`` the permutation information is returned as row indices. + The default is ``False`` for backwards-compatibility reasons. + + Returns + ------- + **(If `permute_l` is ``False``)** + + p : (..., M, M) ndarray + Permutation arrays or vectors depending on `p_indices` + l : (..., M, K) ndarray + Lower triangular or trapezoidal array with unit diagonal. + ``K = min(M, N)`` + u : (..., K, N) ndarray + Upper triangular or trapezoidal array + + **(If `permute_l` is ``True``)** + + pl : (..., M, K) ndarray + Permuted L matrix. + ``K = min(M, N)`` + u : (..., K, N) ndarray + Upper triangular or trapezoidal array + + Notes + ----- + Permutation matrices are costly since they are nothing but row reorder of + ``L`` and hence indices are strongly recommended to be used instead if the + permutation is required. The relation in the 2D case then becomes simply + ``A = L[P, :] @ U``. In higher dimensions, it is better to use `permute_l` + to avoid complicated indexing tricks. + + In 2D case, if one has the indices however, for some reason, the + permutation matrix is still needed then it can be constructed by + ``np.eye(M)[P, :]``. + + Examples + -------- + + >>> import numpy as np + >>> from scipy.linalg import lu + >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]]) + >>> p, l, u = lu(A) + >>> np.allclose(A, p @ l @ u) + True + >>> p # Permutation matrix + array([[0., 1., 0., 0.], # Row index 1 + [0., 0., 0., 1.], # Row index 3 + [1., 0., 0., 0.], # Row index 0 + [0., 0., 1., 0.]]) # Row index 2 + >>> p, _, _ = lu(A, p_indices=True) + >>> p + array([1, 3, 0, 2]) # as given by row indices above + >>> np.allclose(A, l[p, :] @ u) + True + + We can also use nd-arrays, for example, a demonstration with 4D array: + + >>> rng = np.random.default_rng() + >>> A = rng.uniform(low=-4, high=4, size=[3, 2, 4, 8]) + >>> p, l, u = lu(A) + >>> p.shape, l.shape, u.shape + ((3, 2, 4, 4), (3, 2, 4, 4), (3, 2, 4, 8)) + >>> np.allclose(A, p @ l @ u) + True + >>> PL, U = lu(A, permute_l=True) + >>> np.allclose(A, PL @ U) + True + + """ + a1 = np.asarray_chkfinite(a) if check_finite else np.asarray(a) + if a1.ndim < 2: + raise ValueError('The input array must be at least two-dimensional.') + + # Also check if dtype is LAPACK compatible + if a1.dtype.char not in 'fdFD': + dtype_char = lapack_cast_dict[a1.dtype.char] + if not dtype_char: # No casting possible + raise TypeError(f'The dtype {a1.dtype} cannot be cast ' + 'to float(32, 64) or complex(64, 128).') + + a1 = a1.astype(dtype_char[0]) # makes a copy, free to scratch + overwrite_a = True + + *nd, m, n = a1.shape + k = min(m, n) + real_dchar = 'f' if a1.dtype.char in 'fF' else 'd' + + # Empty input + if min(*a1.shape) == 0: + if permute_l: + PL = np.empty(shape=[*nd, m, k], dtype=a1.dtype) + U = np.empty(shape=[*nd, k, n], dtype=a1.dtype) + return PL, U + else: + P = (np.empty([*nd, 0], dtype=np.int32) if p_indices else + np.empty([*nd, 0, 0], dtype=real_dchar)) + L = np.empty(shape=[*nd, m, k], dtype=a1.dtype) + U = np.empty(shape=[*nd, k, n], dtype=a1.dtype) + return P, L, U + + # Scalar case + if a1.shape[-2:] == (1, 1): + if permute_l: + return np.ones_like(a1), (a1 if overwrite_a else a1.copy()) + else: + P = (np.zeros(shape=[*nd, m], dtype=int) if p_indices + else np.ones_like(a1)) + return P, np.ones_like(a1), (a1 if overwrite_a else a1.copy()) + + # Then check overwrite permission + if not _datacopied(a1, a): # "a" still alive through "a1" + if not overwrite_a: + # Data belongs to "a" so make a copy + a1 = a1.copy(order='C') + # else: Do nothing we'll use "a" if possible + # else: a1 has its own data thus free to scratch + + # Then layout checks, might happen that overwrite is allowed but original + # array was read-only or non-contiguous. + + if not (a1.flags['C_CONTIGUOUS'] and a1.flags['WRITEABLE']): + a1 = a1.copy(order='C') + + if not nd: # 2D array + + p = np.empty(m, dtype=np.int32) + u = np.zeros([k, k], dtype=a1.dtype) + lu_dispatcher(a1, u, p, permute_l) + P, L, U = (p, a1, u) if m > n else (p, u, a1) + + else: # Stacked array + + # Prepare the contiguous data holders + P = np.empty([*nd, m], dtype=np.int32) # perm vecs + + if m > n: # Tall arrays, U will be created + U = np.zeros([*nd, k, k], dtype=a1.dtype) + for ind in product(*[range(x) for x in a1.shape[:-2]]): + lu_dispatcher(a1[ind], U[ind], P[ind], permute_l) + L = a1 + + else: # Fat arrays, L will be created + L = np.zeros([*nd, k, k], dtype=a1.dtype) + for ind in product(*[range(x) for x in a1.shape[:-2]]): + lu_dispatcher(a1[ind], L[ind], P[ind], permute_l) + U = a1 + + # Convert permutation vecs to permutation arrays + # permute_l=False needed to enter here to avoid wasted efforts + if (not p_indices) and (not permute_l): + if nd: + Pa = np.zeros([*nd, m, m], dtype=real_dchar) + # An unreadable index hack - One-hot encoding for perm matrices + nd_ix = np.ix_(*([np.arange(x) for x in nd]+[np.arange(m)])) + Pa[(*nd_ix, P)] = 1 + P = Pa + else: # 2D case + Pa = np.zeros([m, m], dtype=real_dchar) + Pa[np.arange(m), P] = 1 + P = Pa + + return (L, U) if permute_l else (P, L, U) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_lu_cython.cpython-310-x86_64-linux-gnu.so b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_lu_cython.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..7dd9117e8db647fbab8565c968bb2118b0b1a501 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_lu_cython.cpython-310-x86_64-linux-gnu.so differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_lu_cython.pyi b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_lu_cython.pyi new file mode 100644 index 0000000000000000000000000000000000000000..0a175b1de32806102318cf69f7c5b4c3deddb03c --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_lu_cython.pyi @@ -0,0 +1,6 @@ +from numpy.typing import NDArray +from typing import Any + +def lu_decompose(a: NDArray[Any], lu: NDArray[Any], perm: NDArray[Any], permute_l: bool) -> None: ... # noqa: E501 + +def lu_dispatcher(a: NDArray[Any], lu: NDArray[Any], perm: NDArray[Any], permute_l: bool) -> None: ... # noqa: E501 diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_polar.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_polar.py new file mode 100644 index 0000000000000000000000000000000000000000..2fc3652899bed607ab1dd5e3f1663345010e93c1 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_polar.py @@ -0,0 +1,111 @@ +import numpy as np +from scipy.linalg import svd + + +__all__ = ['polar'] + + +def polar(a, side="right"): + """ + Compute the polar decomposition. + + Returns the factors of the polar decomposition [1]_ `u` and `p` such + that ``a = up`` (if `side` is "right") or ``a = pu`` (if `side` is + "left"), where `p` is positive semidefinite. Depending on the shape + of `a`, either the rows or columns of `u` are orthonormal. When `a` + is a square array, `u` is a square unitary array. When `a` is not + square, the "canonical polar decomposition" [2]_ is computed. + + Parameters + ---------- + a : (m, n) array_like + The array to be factored. + side : {'left', 'right'}, optional + Determines whether a right or left polar decomposition is computed. + If `side` is "right", then ``a = up``. If `side` is "left", then + ``a = pu``. The default is "right". + + Returns + ------- + u : (m, n) ndarray + If `a` is square, then `u` is unitary. If m > n, then the columns + of `a` are orthonormal, and if m < n, then the rows of `u` are + orthonormal. + p : ndarray + `p` is Hermitian positive semidefinite. If `a` is nonsingular, `p` + is positive definite. The shape of `p` is (n, n) or (m, m), depending + on whether `side` is "right" or "left", respectively. + + References + ---------- + .. [1] R. A. Horn and C. R. Johnson, "Matrix Analysis", Cambridge + University Press, 1985. + .. [2] N. J. Higham, "Functions of Matrices: Theory and Computation", + SIAM, 2008. + + Examples + -------- + >>> import numpy as np + >>> from scipy.linalg import polar + >>> a = np.array([[1, -1], [2, 4]]) + >>> u, p = polar(a) + >>> u + array([[ 0.85749293, -0.51449576], + [ 0.51449576, 0.85749293]]) + >>> p + array([[ 1.88648444, 1.2004901 ], + [ 1.2004901 , 3.94446746]]) + + A non-square example, with m < n: + + >>> b = np.array([[0.5, 1, 2], [1.5, 3, 4]]) + >>> u, p = polar(b) + >>> u + array([[-0.21196618, -0.42393237, 0.88054056], + [ 0.39378971, 0.78757942, 0.4739708 ]]) + >>> p + array([[ 0.48470147, 0.96940295, 1.15122648], + [ 0.96940295, 1.9388059 , 2.30245295], + [ 1.15122648, 2.30245295, 3.65696431]]) + >>> u.dot(p) # Verify the decomposition. + array([[ 0.5, 1. , 2. ], + [ 1.5, 3. , 4. ]]) + >>> u.dot(u.T) # The rows of u are orthonormal. + array([[ 1.00000000e+00, -2.07353665e-17], + [ -2.07353665e-17, 1.00000000e+00]]) + + Another non-square example, with m > n: + + >>> c = b.T + >>> u, p = polar(c) + >>> u + array([[-0.21196618, 0.39378971], + [-0.42393237, 0.78757942], + [ 0.88054056, 0.4739708 ]]) + >>> p + array([[ 1.23116567, 1.93241587], + [ 1.93241587, 4.84930602]]) + >>> u.dot(p) # Verify the decomposition. + array([[ 0.5, 1.5], + [ 1. , 3. ], + [ 2. , 4. ]]) + >>> u.T.dot(u) # The columns of u are orthonormal. + array([[ 1.00000000e+00, -1.26363763e-16], + [ -1.26363763e-16, 1.00000000e+00]]) + + """ + if side not in ['right', 'left']: + raise ValueError("`side` must be either 'right' or 'left'") + a = np.asarray(a) + if a.ndim != 2: + raise ValueError("`a` must be a 2-D array.") + + w, s, vh = svd(a, full_matrices=False) + u = w.dot(vh) + if side == 'right': + # a = up + p = (vh.T.conj() * s).dot(vh) + else: + # a = pu + p = (w * s).dot(w.T.conj()) + return u, p diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_qr.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_qr.py new file mode 100644 index 0000000000000000000000000000000000000000..2b158015e7bff9d7e11cc2e85eeabcd2b531aec5 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_qr.py @@ -0,0 +1,430 @@ +"""QR decomposition functions.""" +import numpy + +# Local imports +from .lapack import get_lapack_funcs +from ._misc import _datacopied + +__all__ = ['qr', 'qr_multiply', 'rq'] + + +def safecall(f, name, *args, **kwargs): + """Call a LAPACK routine, determining lwork automatically and handling + error return values""" + lwork = kwargs.get("lwork", None) + if lwork in (None, -1): + kwargs['lwork'] = -1 + ret = f(*args, **kwargs) + kwargs['lwork'] = ret[-2][0].real.astype(numpy.int_) + ret = f(*args, **kwargs) + if ret[-1] < 0: + raise ValueError("illegal value in %dth argument of internal %s" + % (-ret[-1], name)) + return ret[:-2] + + +def qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False, + check_finite=True): + """ + Compute QR decomposition of a matrix. + + Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal + and R upper triangular. + + Parameters + ---------- + a : (M, N) array_like + Matrix to be decomposed + overwrite_a : bool, optional + Whether data in `a` is overwritten (may improve performance if + `overwrite_a` is set to True by reusing the existing input data + structure rather than creating a new one.) + lwork : int, optional + Work array size, lwork >= a.shape[1]. If None or -1, an optimal size + is computed. + mode : {'full', 'r', 'economic', 'raw'}, optional + Determines what information is to be returned: either both Q and R + ('full', default), only R ('r') or both Q and R but computed in + economy-size ('economic', see Notes). The final option 'raw' + (added in SciPy 0.11) makes the function return two matrices + (Q, TAU) in the internal format used by LAPACK. + pivoting : bool, optional + Whether or not factorization should include pivoting for rank-revealing + qr decomposition. If pivoting, compute the decomposition + ``A[:, P] = Q @ R`` as above, but where P is chosen such that the + diagonal of R is non-increasing. + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + Q : float or complex ndarray + Of shape (M, M), or (M, K) for ``mode='economic'``. Not returned + if ``mode='r'``. Replaced by tuple ``(Q, TAU)`` if ``mode='raw'``. + R : float or complex ndarray + Of shape (M, N), or (K, N) for ``mode in ['economic', 'raw']``. + ``K = min(M, N)``. + P : int ndarray + Of shape (N,) for ``pivoting=True``. Not returned if + ``pivoting=False``. + + Raises + ------ + LinAlgError + Raised if decomposition fails + + Notes + ----- + This is an interface to the LAPACK routines dgeqrf, zgeqrf, + dorgqr, zungqr, dgeqp3, and zgeqp3. + + If ``mode=economic``, the shapes of Q and R are (M, K) and (K, N) instead + of (M,M) and (M,N), with ``K=min(M,N)``. + + Examples + -------- + >>> import numpy as np + >>> from scipy import linalg + >>> rng = np.random.default_rng() + >>> a = rng.standard_normal((9, 6)) + + >>> q, r = linalg.qr(a) + >>> np.allclose(a, np.dot(q, r)) + True + >>> q.shape, r.shape + ((9, 9), (9, 6)) + + >>> r2 = linalg.qr(a, mode='r') + >>> np.allclose(r, r2) + True + + >>> q3, r3 = linalg.qr(a, mode='economic') + >>> q3.shape, r3.shape + ((9, 6), (6, 6)) + + >>> q4, r4, p4 = linalg.qr(a, pivoting=True) + >>> d = np.abs(np.diag(r4)) + >>> np.all(d[1:] <= d[:-1]) + True + >>> np.allclose(a[:, p4], np.dot(q4, r4)) + True + >>> q4.shape, r4.shape, p4.shape + ((9, 9), (9, 6), (6,)) + + >>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True) + >>> q5.shape, r5.shape, p5.shape + ((9, 6), (6, 6), (6,)) + + """ + # 'qr' was the old default, equivalent to 'full'. Neither 'full' nor + # 'qr' are used below. + # 'raw' is used internally by qr_multiply + if mode not in ['full', 'qr', 'r', 'economic', 'raw']: + raise ValueError("Mode argument should be one of ['full', 'r'," + "'economic', 'raw']") + + if check_finite: + a1 = numpy.asarray_chkfinite(a) + else: + a1 = numpy.asarray(a) + if len(a1.shape) != 2: + raise ValueError("expected a 2-D array") + M, N = a1.shape + overwrite_a = overwrite_a or (_datacopied(a1, a)) + + if pivoting: + geqp3, = get_lapack_funcs(('geqp3',), (a1,)) + qr, jpvt, tau = safecall(geqp3, "geqp3", a1, overwrite_a=overwrite_a) + jpvt -= 1 # geqp3 returns a 1-based index array, so subtract 1 + else: + geqrf, = get_lapack_funcs(('geqrf',), (a1,)) + qr, tau = safecall(geqrf, "geqrf", a1, lwork=lwork, + overwrite_a=overwrite_a) + + if mode not in ['economic', 'raw'] or M < N: + R = numpy.triu(qr) + else: + R = numpy.triu(qr[:N, :]) + + if pivoting: + Rj = R, jpvt + else: + Rj = R, + + if mode == 'r': + return Rj + elif mode == 'raw': + return ((qr, tau),) + Rj + + gor_un_gqr, = get_lapack_funcs(('orgqr',), (qr,)) + + if M < N: + Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qr[:, :M], tau, + lwork=lwork, overwrite_a=1) + elif mode == 'economic': + Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qr, tau, lwork=lwork, + overwrite_a=1) + else: + t = qr.dtype.char + qqr = numpy.empty((M, M), dtype=t) + qqr[:, :N] = qr + Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qqr, tau, lwork=lwork, + overwrite_a=1) + + return (Q,) + Rj + + +def qr_multiply(a, c, mode='right', pivoting=False, conjugate=False, + overwrite_a=False, overwrite_c=False): + """ + Calculate the QR decomposition and multiply Q with a matrix. + + Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal + and R upper triangular. Multiply Q with a vector or a matrix c. + + Parameters + ---------- + a : (M, N), array_like + Input array + c : array_like + Input array to be multiplied by ``q``. + mode : {'left', 'right'}, optional + ``Q @ c`` is returned if mode is 'left', ``c @ Q`` is returned if + mode is 'right'. + The shape of c must be appropriate for the matrix multiplications, + if mode is 'left', ``min(a.shape) == c.shape[0]``, + if mode is 'right', ``a.shape[0] == c.shape[1]``. + pivoting : bool, optional + Whether or not factorization should include pivoting for rank-revealing + qr decomposition, see the documentation of qr. + conjugate : bool, optional + Whether Q should be complex-conjugated. This might be faster + than explicit conjugation. + overwrite_a : bool, optional + Whether data in a is overwritten (may improve performance) + overwrite_c : bool, optional + Whether data in c is overwritten (may improve performance). + If this is used, c must be big enough to keep the result, + i.e. ``c.shape[0]`` = ``a.shape[0]`` if mode is 'left'. + + Returns + ------- + CQ : ndarray + The product of ``Q`` and ``c``. + R : (K, N), ndarray + R array of the resulting QR factorization where ``K = min(M, N)``. + P : (N,) ndarray + Integer pivot array. Only returned when ``pivoting=True``. + + Raises + ------ + LinAlgError + Raised if QR decomposition fails. + + Notes + ----- + This is an interface to the LAPACK routines ``?GEQRF``, ``?ORMQR``, + ``?UNMQR``, and ``?GEQP3``. + + .. versionadded:: 0.11.0 + + Examples + -------- + >>> import numpy as np + >>> from scipy.linalg import qr_multiply, qr + >>> A = np.array([[1, 3, 3], [2, 3, 2], [2, 3, 3], [1, 3, 2]]) + >>> qc, r1, piv1 = qr_multiply(A, 2*np.eye(4), pivoting=1) + >>> qc + array([[-1., 1., -1.], + [-1., -1., 1.], + [-1., -1., -1.], + [-1., 1., 1.]]) + >>> r1 + array([[-6., -3., -5. ], + [ 0., -1., -1.11022302e-16], + [ 0., 0., -1. ]]) + >>> piv1 + array([1, 0, 2], dtype=int32) + >>> q2, r2, piv2 = qr(A, mode='economic', pivoting=1) + >>> np.allclose(2*q2 - qc, np.zeros((4, 3))) + True + + """ + if mode not in ['left', 'right']: + raise ValueError("Mode argument can only be 'left' or 'right' but " + f"not '{mode}'") + c = numpy.asarray_chkfinite(c) + if c.ndim < 2: + onedim = True + c = numpy.atleast_2d(c) + if mode == "left": + c = c.T + else: + onedim = False + + a = numpy.atleast_2d(numpy.asarray(a)) # chkfinite done in qr + M, N = a.shape + + if mode == 'left': + if c.shape[0] != min(M, N + overwrite_c*(M-N)): + raise ValueError('Array shapes are not compatible for Q @ c' + f' operation: {a.shape} vs {c.shape}') + else: + if M != c.shape[1]: + raise ValueError('Array shapes are not compatible for c @ Q' + f' operation: {c.shape} vs {a.shape}') + + raw = qr(a, overwrite_a, None, "raw", pivoting) + Q, tau = raw[0] + + gor_un_mqr, = get_lapack_funcs(('ormqr',), (Q,)) + if gor_un_mqr.typecode in ('s', 'd'): + trans = "T" + else: + trans = "C" + + Q = Q[:, :min(M, N)] + if M > N and mode == "left" and not overwrite_c: + if conjugate: + cc = numpy.zeros((c.shape[1], M), dtype=c.dtype, order="F") + cc[:, :N] = c.T + else: + cc = numpy.zeros((M, c.shape[1]), dtype=c.dtype, order="F") + cc[:N, :] = c + trans = "N" + if conjugate: + lr = "R" + else: + lr = "L" + overwrite_c = True + elif c.flags["C_CONTIGUOUS"] and trans == "T" or conjugate: + cc = c.T + if mode == "left": + lr = "R" + else: + lr = "L" + else: + trans = "N" + cc = c + if mode == "left": + lr = "L" + else: + lr = "R" + cQ, = safecall(gor_un_mqr, "gormqr/gunmqr", lr, trans, Q, tau, cc, + overwrite_c=overwrite_c) + if trans != "N": + cQ = cQ.T + if mode == "right": + cQ = cQ[:, :min(M, N)] + if onedim: + cQ = cQ.ravel() + + return (cQ,) + raw[1:] + + +def rq(a, overwrite_a=False, lwork=None, mode='full', check_finite=True): + """ + Compute RQ decomposition of a matrix. + + Calculate the decomposition ``A = R Q`` where Q is unitary/orthogonal + and R upper triangular. + + Parameters + ---------- + a : (M, N) array_like + Matrix to be decomposed + overwrite_a : bool, optional + Whether data in a is overwritten (may improve performance) + lwork : int, optional + Work array size, lwork >= a.shape[1]. If None or -1, an optimal size + is computed. + mode : {'full', 'r', 'economic'}, optional + Determines what information is to be returned: either both Q and R + ('full', default), only R ('r') or both Q and R but computed in + economy-size ('economic', see Notes). + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + R : float or complex ndarray + Of shape (M, N) or (M, K) for ``mode='economic'``. ``K = min(M, N)``. + Q : float or complex ndarray + Of shape (N, N) or (K, N) for ``mode='economic'``. Not returned + if ``mode='r'``. + + Raises + ------ + LinAlgError + If decomposition fails. + + Notes + ----- + This is an interface to the LAPACK routines sgerqf, dgerqf, cgerqf, zgerqf, + sorgrq, dorgrq, cungrq and zungrq. + + If ``mode=economic``, the shapes of Q and R are (K, N) and (M, K) instead + of (N,N) and (M,N), with ``K=min(M,N)``. + + Examples + -------- + >>> import numpy as np + >>> from scipy import linalg + >>> rng = np.random.default_rng() + >>> a = rng.standard_normal((6, 9)) + >>> r, q = linalg.rq(a) + >>> np.allclose(a, r @ q) + True + >>> r.shape, q.shape + ((6, 9), (9, 9)) + >>> r2 = linalg.rq(a, mode='r') + >>> np.allclose(r, r2) + True + >>> r3, q3 = linalg.rq(a, mode='economic') + >>> r3.shape, q3.shape + ((6, 6), (6, 9)) + + """ + if mode not in ['full', 'r', 'economic']: + raise ValueError( + "Mode argument should be one of ['full', 'r', 'economic']") + + if check_finite: + a1 = numpy.asarray_chkfinite(a) + else: + a1 = numpy.asarray(a) + if len(a1.shape) != 2: + raise ValueError('expected matrix') + M, N = a1.shape + overwrite_a = overwrite_a or (_datacopied(a1, a)) + + gerqf, = get_lapack_funcs(('gerqf',), (a1,)) + rq, tau = safecall(gerqf, 'gerqf', a1, lwork=lwork, + overwrite_a=overwrite_a) + if not mode == 'economic' or N < M: + R = numpy.triu(rq, N-M) + else: + R = numpy.triu(rq[-M:, -M:]) + + if mode == 'r': + return R + + gor_un_grq, = get_lapack_funcs(('orgrq',), (rq,)) + + if N < M: + Q, = safecall(gor_un_grq, "gorgrq/gungrq", rq[-N:], tau, lwork=lwork, + overwrite_a=1) + elif mode == 'economic': + Q, = safecall(gor_un_grq, "gorgrq/gungrq", rq, tau, lwork=lwork, + overwrite_a=1) + else: + rq1 = numpy.empty((N, N), dtype=rq.dtype) + rq1[-M:] = rq + Q, = safecall(gor_un_grq, "gorgrq/gungrq", rq1, tau, lwork=lwork, + overwrite_a=1) + + return R, Q diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_svd.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_svd.py new file mode 100644 index 0000000000000000000000000000000000000000..a2452e3dc21b76600a6a3a58b56f53804f91561b --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_decomp_svd.py @@ -0,0 +1,517 @@ +"""SVD decomposition functions.""" +import numpy +from numpy import zeros, r_, diag, dot, arccos, arcsin, where, clip + +# Local imports. +from ._misc import LinAlgError, _datacopied +from .lapack import get_lapack_funcs, _compute_lwork +from ._decomp import _asarray_validated + +__all__ = ['svd', 'svdvals', 'diagsvd', 'orth', 'subspace_angles', 'null_space'] + + +def svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, + check_finite=True, lapack_driver='gesdd'): + """ + Singular Value Decomposition. + + Factorizes the matrix `a` into two unitary matrices ``U`` and ``Vh``, and + a 1-D array ``s`` of singular values (real, non-negative) such that + ``a == U @ S @ Vh``, where ``S`` is a suitably shaped matrix of zeros with + main diagonal ``s``. + + Parameters + ---------- + a : (M, N) array_like + Matrix to decompose. + full_matrices : bool, optional + If True (default), `U` and `Vh` are of shape ``(M, M)``, ``(N, N)``. + If False, the shapes are ``(M, K)`` and ``(K, N)``, where + ``K = min(M, N)``. + compute_uv : bool, optional + Whether to compute also ``U`` and ``Vh`` in addition to ``s``. + Default is True. + overwrite_a : bool, optional + Whether to overwrite `a`; may improve performance. + Default is False. + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + lapack_driver : {'gesdd', 'gesvd'}, optional + Whether to use the more efficient divide-and-conquer approach + (``'gesdd'``) or general rectangular approach (``'gesvd'``) + to compute the SVD. MATLAB and Octave use the ``'gesvd'`` approach. + Default is ``'gesdd'``. + + .. versionadded:: 0.18 + + Returns + ------- + U : ndarray + Unitary matrix having left singular vectors as columns. + Of shape ``(M, M)`` or ``(M, K)``, depending on `full_matrices`. + s : ndarray + The singular values, sorted in non-increasing order. + Of shape (K,), with ``K = min(M, N)``. + Vh : ndarray + Unitary matrix having right singular vectors as rows. + Of shape ``(N, N)`` or ``(K, N)`` depending on `full_matrices`. + + For ``compute_uv=False``, only ``s`` is returned. + + Raises + ------ + LinAlgError + If SVD computation does not converge. + + See Also + -------- + svdvals : Compute singular values of a matrix. + diagsvd : Construct the Sigma matrix, given the vector s. + + Examples + -------- + >>> import numpy as np + >>> from scipy import linalg + >>> rng = np.random.default_rng() + >>> m, n = 9, 6 + >>> a = rng.standard_normal((m, n)) + 1.j*rng.standard_normal((m, n)) + >>> U, s, Vh = linalg.svd(a) + >>> U.shape, s.shape, Vh.shape + ((9, 9), (6,), (6, 6)) + + Reconstruct the original matrix from the decomposition: + + >>> sigma = np.zeros((m, n)) + >>> for i in range(min(m, n)): + ... sigma[i, i] = s[i] + >>> a1 = np.dot(U, np.dot(sigma, Vh)) + >>> np.allclose(a, a1) + True + + Alternatively, use ``full_matrices=False`` (notice that the shape of + ``U`` is then ``(m, n)`` instead of ``(m, m)``): + + >>> U, s, Vh = linalg.svd(a, full_matrices=False) + >>> U.shape, s.shape, Vh.shape + ((9, 6), (6,), (6, 6)) + >>> S = np.diag(s) + >>> np.allclose(a, np.dot(U, np.dot(S, Vh))) + True + + >>> s2 = linalg.svd(a, compute_uv=False) + >>> np.allclose(s, s2) + True + + """ + a1 = _asarray_validated(a, check_finite=check_finite) + if len(a1.shape) != 2: + raise ValueError('expected matrix') + m, n = a1.shape + overwrite_a = overwrite_a or (_datacopied(a1, a)) + + if not isinstance(lapack_driver, str): + raise TypeError('lapack_driver must be a string') + if lapack_driver not in ('gesdd', 'gesvd'): + message = f'lapack_driver must be "gesdd" or "gesvd", not "{lapack_driver}"' + raise ValueError(message) + + if lapack_driver == 'gesdd' and compute_uv: + # XXX: revisit int32 when ILP64 lapack becomes a thing + max_mn, min_mn = (m, n) if m > n else (n, m) + if full_matrices: + if max_mn*max_mn > numpy.iinfo(numpy.int32).max: + raise ValueError(f"Indexing a matrix size {max_mn} x {max_mn} " + " would incur integer overflow in LAPACK.") + else: + sz = max(m * min_mn, n * min_mn) + if max(m * min_mn, n * min_mn) > numpy.iinfo(numpy.int32).max: + raise ValueError(f"Indexing a matrix of {sz} elements would " + "incur an in integer overflow in LAPACK.") + + funcs = (lapack_driver, lapack_driver + '_lwork') + gesXd, gesXd_lwork = get_lapack_funcs(funcs, (a1,), ilp64='preferred') + + # compute optimal lwork + lwork = _compute_lwork(gesXd_lwork, a1.shape[0], a1.shape[1], + compute_uv=compute_uv, full_matrices=full_matrices) + + # perform decomposition + u, s, v, info = gesXd(a1, compute_uv=compute_uv, lwork=lwork, + full_matrices=full_matrices, overwrite_a=overwrite_a) + + if info > 0: + raise LinAlgError("SVD did not converge") + if info < 0: + raise ValueError('illegal value in %dth argument of internal gesdd' + % -info) + if compute_uv: + return u, s, v + else: + return s + + +def svdvals(a, overwrite_a=False, check_finite=True): + """ + Compute singular values of a matrix. + + Parameters + ---------- + a : (M, N) array_like + Matrix to decompose. + overwrite_a : bool, optional + Whether to overwrite `a`; may improve performance. + Default is False. + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + s : (min(M, N),) ndarray + The singular values, sorted in decreasing order. + + Raises + ------ + LinAlgError + If SVD computation does not converge. + + See Also + -------- + svd : Compute the full singular value decomposition of a matrix. + diagsvd : Construct the Sigma matrix, given the vector s. + + Notes + ----- + ``svdvals(a)`` only differs from ``svd(a, compute_uv=False)`` by its + handling of the edge case of empty ``a``, where it returns an + empty sequence: + + >>> import numpy as np + >>> a = np.empty((0, 2)) + >>> from scipy.linalg import svdvals + >>> svdvals(a) + array([], dtype=float64) + + Examples + -------- + >>> import numpy as np + >>> from scipy.linalg import svdvals + >>> m = np.array([[1.0, 0.0], + ... [2.0, 3.0], + ... [1.0, 1.0], + ... [0.0, 2.0], + ... [1.0, 0.0]]) + >>> svdvals(m) + array([ 4.28091555, 1.63516424]) + + We can verify the maximum singular value of `m` by computing the maximum + length of `m.dot(u)` over all the unit vectors `u` in the (x,y) plane. + We approximate "all" the unit vectors with a large sample. Because + of linearity, we only need the unit vectors with angles in [0, pi]. + + >>> t = np.linspace(0, np.pi, 2000) + >>> u = np.array([np.cos(t), np.sin(t)]) + >>> np.linalg.norm(m.dot(u), axis=0).max() + 4.2809152422538475 + + `p` is a projection matrix with rank 1. With exact arithmetic, + its singular values would be [1, 0, 0, 0]. + + >>> v = np.array([0.1, 0.3, 0.9, 0.3]) + >>> p = np.outer(v, v) + >>> svdvals(p) + array([ 1.00000000e+00, 2.02021698e-17, 1.56692500e-17, + 8.15115104e-34]) + + The singular values of an orthogonal matrix are all 1. Here, we + create a random orthogonal matrix by using the `rvs()` method of + `scipy.stats.ortho_group`. + + >>> from scipy.stats import ortho_group + >>> orth = ortho_group.rvs(4) + >>> svdvals(orth) + array([ 1., 1., 1., 1.]) + + """ + a = _asarray_validated(a, check_finite=check_finite) + if a.size: + return svd(a, compute_uv=0, overwrite_a=overwrite_a, + check_finite=False) + elif len(a.shape) != 2: + raise ValueError('expected matrix') + else: + return numpy.empty(0) + + +def diagsvd(s, M, N): + """ + Construct the sigma matrix in SVD from singular values and size M, N. + + Parameters + ---------- + s : (M,) or (N,) array_like + Singular values + M : int + Size of the matrix whose singular values are `s`. + N : int + Size of the matrix whose singular values are `s`. + + Returns + ------- + S : (M, N) ndarray + The S-matrix in the singular value decomposition + + See Also + -------- + svd : Singular value decomposition of a matrix + svdvals : Compute singular values of a matrix. + + Examples + -------- + >>> import numpy as np + >>> from scipy.linalg import diagsvd + >>> vals = np.array([1, 2, 3]) # The array representing the computed svd + >>> diagsvd(vals, 3, 4) + array([[1, 0, 0, 0], + [0, 2, 0, 0], + [0, 0, 3, 0]]) + >>> diagsvd(vals, 4, 3) + array([[1, 0, 0], + [0, 2, 0], + [0, 0, 3], + [0, 0, 0]]) + + """ + part = diag(s) + typ = part.dtype.char + MorN = len(s) + if MorN == M: + return numpy.hstack((part, zeros((M, N - M), dtype=typ))) + elif MorN == N: + return r_[part, zeros((M - N, N), dtype=typ)] + else: + raise ValueError("Length of s must be M or N.") + + +# Orthonormal decomposition + +def orth(A, rcond=None): + """ + Construct an orthonormal basis for the range of A using SVD + + Parameters + ---------- + A : (M, N) array_like + Input array + rcond : float, optional + Relative condition number. Singular values ``s`` smaller than + ``rcond * max(s)`` are considered zero. + Default: floating point eps * max(M,N). + + Returns + ------- + Q : (M, K) ndarray + Orthonormal basis for the range of A. + K = effective rank of A, as determined by rcond + + See Also + -------- + svd : Singular value decomposition of a matrix + null_space : Matrix null space + + Examples + -------- + >>> import numpy as np + >>> from scipy.linalg import orth + >>> A = np.array([[2, 0, 0], [0, 5, 0]]) # rank 2 array + >>> orth(A) + array([[0., 1.], + [1., 0.]]) + >>> orth(A.T) + array([[0., 1.], + [1., 0.], + [0., 0.]]) + + """ + u, s, vh = svd(A, full_matrices=False) + M, N = u.shape[0], vh.shape[1] + if rcond is None: + rcond = numpy.finfo(s.dtype).eps * max(M, N) + tol = numpy.amax(s) * rcond + num = numpy.sum(s > tol, dtype=int) + Q = u[:, :num] + return Q + + +def null_space(A, rcond=None): + """ + Construct an orthonormal basis for the null space of A using SVD + + Parameters + ---------- + A : (M, N) array_like + Input array + rcond : float, optional + Relative condition number. Singular values ``s`` smaller than + ``rcond * max(s)`` are considered zero. + Default: floating point eps * max(M,N). + + Returns + ------- + Z : (N, K) ndarray + Orthonormal basis for the null space of A. + K = dimension of effective null space, as determined by rcond + + See Also + -------- + svd : Singular value decomposition of a matrix + orth : Matrix range + + Examples + -------- + 1-D null space: + + >>> import numpy as np + >>> from scipy.linalg import null_space + >>> A = np.array([[1, 1], [1, 1]]) + >>> ns = null_space(A) + >>> ns * np.copysign(1, ns[0,0]) # Remove the sign ambiguity of the vector + array([[ 0.70710678], + [-0.70710678]]) + + 2-D null space: + + >>> from numpy.random import default_rng + >>> rng = default_rng() + >>> B = rng.random((3, 5)) + >>> Z = null_space(B) + >>> Z.shape + (5, 2) + >>> np.allclose(B.dot(Z), 0) + True + + The basis vectors are orthonormal (up to rounding error): + + >>> Z.T.dot(Z) + array([[ 1.00000000e+00, 6.92087741e-17], + [ 6.92087741e-17, 1.00000000e+00]]) + + """ + u, s, vh = svd(A, full_matrices=True) + M, N = u.shape[0], vh.shape[1] + if rcond is None: + rcond = numpy.finfo(s.dtype).eps * max(M, N) + tol = numpy.amax(s) * rcond + num = numpy.sum(s > tol, dtype=int) + Q = vh[num:,:].T.conj() + return Q + + +def subspace_angles(A, B): + r""" + Compute the subspace angles between two matrices. + + Parameters + ---------- + A : (M, N) array_like + The first input array. + B : (M, K) array_like + The second input array. + + Returns + ------- + angles : ndarray, shape (min(N, K),) + The subspace angles between the column spaces of `A` and `B` in + descending order. + + See Also + -------- + orth + svd + + Notes + ----- + This computes the subspace angles according to the formula + provided in [1]_. For equivalence with MATLAB and Octave behavior, + use ``angles[0]``. + + .. versionadded:: 1.0 + + References + ---------- + .. [1] Knyazev A, Argentati M (2002) Principal Angles between Subspaces + in an A-Based Scalar Product: Algorithms and Perturbation + Estimates. SIAM J. Sci. Comput. 23:2008-2040. + + Examples + -------- + An Hadamard matrix, which has orthogonal columns, so we expect that + the suspace angle to be :math:`\frac{\pi}{2}`: + + >>> import numpy as np + >>> from scipy.linalg import hadamard, subspace_angles + >>> rng = np.random.default_rng() + >>> H = hadamard(4) + >>> print(H) + [[ 1 1 1 1] + [ 1 -1 1 -1] + [ 1 1 -1 -1] + [ 1 -1 -1 1]] + >>> np.rad2deg(subspace_angles(H[:, :2], H[:, 2:])) + array([ 90., 90.]) + + And the subspace angle of a matrix to itself should be zero: + + >>> subspace_angles(H[:, :2], H[:, :2]) <= 2 * np.finfo(float).eps + array([ True, True], dtype=bool) + + The angles between non-orthogonal subspaces are in between these extremes: + + >>> x = rng.standard_normal((4, 3)) + >>> np.rad2deg(subspace_angles(x[:, :2], x[:, [2]])) + array([ 55.832]) # random + """ + # Steps here omit the U and V calculation steps from the paper + + # 1. Compute orthonormal bases of column-spaces + A = _asarray_validated(A, check_finite=True) + if len(A.shape) != 2: + raise ValueError(f'expected 2D array, got shape {A.shape}') + QA = orth(A) + del A + + B = _asarray_validated(B, check_finite=True) + if len(B.shape) != 2: + raise ValueError(f'expected 2D array, got shape {B.shape}') + if len(B) != len(QA): + raise ValueError('A and B must have the same number of rows, got ' + f'{QA.shape[0]} and {B.shape[0]}') + QB = orth(B) + del B + + # 2. Compute SVD for cosine + QA_H_QB = dot(QA.T.conj(), QB) + sigma = svdvals(QA_H_QB) + + # 3. Compute matrix B + if QA.shape[1] >= QB.shape[1]: + B = QB - dot(QA, QA_H_QB) + else: + B = QA - dot(QB, QA_H_QB.T.conj()) + del QA, QB, QA_H_QB + + # 4. Compute SVD for sine + mask = sigma ** 2 >= 0.5 + if mask.any(): + mu_arcsin = arcsin(clip(svdvals(B, overwrite_a=True), -1., 1.)) + else: + mu_arcsin = 0. + + # 5. Compute the principal angles + # with reverse ordering of sigma because smallest sigma belongs to largest + # angle theta + theta = where(mask, mu_arcsin, arccos(clip(sigma[::-1], -1., 1.))) + return theta diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_expm_frechet.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_expm_frechet.py new file mode 100644 index 0000000000000000000000000000000000000000..83d3086872986b2d6606ddbe6bdc5be8de0b95c3 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_expm_frechet.py @@ -0,0 +1,413 @@ +"""Frechet derivative of the matrix exponential.""" +import numpy as np +import scipy.linalg + +__all__ = ['expm_frechet', 'expm_cond'] + + +def expm_frechet(A, E, method=None, compute_expm=True, check_finite=True): + """ + Frechet derivative of the matrix exponential of A in the direction E. + + Parameters + ---------- + A : (N, N) array_like + Matrix of which to take the matrix exponential. + E : (N, N) array_like + Matrix direction in which to take the Frechet derivative. + method : str, optional + Choice of algorithm. Should be one of + + - `SPS` (default) + - `blockEnlarge` + + compute_expm : bool, optional + Whether to compute also `expm_A` in addition to `expm_frechet_AE`. + Default is True. + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + expm_A : ndarray + Matrix exponential of A. + expm_frechet_AE : ndarray + Frechet derivative of the matrix exponential of A in the direction E. + For ``compute_expm = False``, only `expm_frechet_AE` is returned. + + See Also + -------- + expm : Compute the exponential of a matrix. + + Notes + ----- + This section describes the available implementations that can be selected + by the `method` parameter. The default method is *SPS*. + + Method *blockEnlarge* is a naive algorithm. + + Method *SPS* is Scaling-Pade-Squaring [1]_. + It is a sophisticated implementation which should take + only about 3/8 as much time as the naive implementation. + The asymptotics are the same. + + .. versionadded:: 0.13.0 + + References + ---------- + .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009) + Computing the Frechet Derivative of the Matrix Exponential, + with an application to Condition Number Estimation. + SIAM Journal On Matrix Analysis and Applications., + 30 (4). pp. 1639-1657. ISSN 1095-7162 + + Examples + -------- + >>> import numpy as np + >>> from scipy import linalg + >>> rng = np.random.default_rng() + + >>> A = rng.standard_normal((3, 3)) + >>> E = rng.standard_normal((3, 3)) + >>> expm_A, expm_frechet_AE = linalg.expm_frechet(A, E) + >>> expm_A.shape, expm_frechet_AE.shape + ((3, 3), (3, 3)) + + Create a 6x6 matrix containing [[A, E], [0, A]]: + + >>> M = np.zeros((6, 6)) + >>> M[:3, :3] = A + >>> M[:3, 3:] = E + >>> M[3:, 3:] = A + + >>> expm_M = linalg.expm(M) + >>> np.allclose(expm_A, expm_M[:3, :3]) + True + >>> np.allclose(expm_frechet_AE, expm_M[:3, 3:]) + True + + """ + if check_finite: + A = np.asarray_chkfinite(A) + E = np.asarray_chkfinite(E) + else: + A = np.asarray(A) + E = np.asarray(E) + if A.ndim != 2 or A.shape[0] != A.shape[1]: + raise ValueError('expected A to be a square matrix') + if E.ndim != 2 or E.shape[0] != E.shape[1]: + raise ValueError('expected E to be a square matrix') + if A.shape != E.shape: + raise ValueError('expected A and E to be the same shape') + if method is None: + method = 'SPS' + if method == 'SPS': + expm_A, expm_frechet_AE = expm_frechet_algo_64(A, E) + elif method == 'blockEnlarge': + expm_A, expm_frechet_AE = expm_frechet_block_enlarge(A, E) + else: + raise ValueError('Unknown implementation %s' % method) + if compute_expm: + return expm_A, expm_frechet_AE + else: + return expm_frechet_AE + + +def expm_frechet_block_enlarge(A, E): + """ + This is a helper function, mostly for testing and profiling. + Return expm(A), frechet(A, E) + """ + n = A.shape[0] + M = np.vstack([ + np.hstack([A, E]), + np.hstack([np.zeros_like(A), A])]) + expm_M = scipy.linalg.expm(M) + return expm_M[:n, :n], expm_M[:n, n:] + + +""" +Maximal values ell_m of ||2**-s A|| such that the backward error bound +does not exceed 2**-53. +""" +ell_table_61 = ( + None, + # 1 + 2.11e-8, + 3.56e-4, + 1.08e-2, + 6.49e-2, + 2.00e-1, + 4.37e-1, + 7.83e-1, + 1.23e0, + 1.78e0, + 2.42e0, + # 11 + 3.13e0, + 3.90e0, + 4.74e0, + 5.63e0, + 6.56e0, + 7.52e0, + 8.53e0, + 9.56e0, + 1.06e1, + 1.17e1, + ) + + +# The b vectors and U and V are copypasted +# from scipy.sparse.linalg.matfuncs.py. +# M, Lu, Lv follow (6.11), (6.12), (6.13), (3.3) + +def _diff_pade3(A, E, ident): + b = (120., 60., 12., 1.) + A2 = A.dot(A) + M2 = np.dot(A, E) + np.dot(E, A) + U = A.dot(b[3]*A2 + b[1]*ident) + V = b[2]*A2 + b[0]*ident + Lu = A.dot(b[3]*M2) + E.dot(b[3]*A2 + b[1]*ident) + Lv = b[2]*M2 + return U, V, Lu, Lv + + +def _diff_pade5(A, E, ident): + b = (30240., 15120., 3360., 420., 30., 1.) + A2 = A.dot(A) + M2 = np.dot(A, E) + np.dot(E, A) + A4 = np.dot(A2, A2) + M4 = np.dot(A2, M2) + np.dot(M2, A2) + U = A.dot(b[5]*A4 + b[3]*A2 + b[1]*ident) + V = b[4]*A4 + b[2]*A2 + b[0]*ident + Lu = (A.dot(b[5]*M4 + b[3]*M2) + + E.dot(b[5]*A4 + b[3]*A2 + b[1]*ident)) + Lv = b[4]*M4 + b[2]*M2 + return U, V, Lu, Lv + + +def _diff_pade7(A, E, ident): + b = (17297280., 8648640., 1995840., 277200., 25200., 1512., 56., 1.) + A2 = A.dot(A) + M2 = np.dot(A, E) + np.dot(E, A) + A4 = np.dot(A2, A2) + M4 = np.dot(A2, M2) + np.dot(M2, A2) + A6 = np.dot(A2, A4) + M6 = np.dot(A4, M2) + np.dot(M4, A2) + U = A.dot(b[7]*A6 + b[5]*A4 + b[3]*A2 + b[1]*ident) + V = b[6]*A6 + b[4]*A4 + b[2]*A2 + b[0]*ident + Lu = (A.dot(b[7]*M6 + b[5]*M4 + b[3]*M2) + + E.dot(b[7]*A6 + b[5]*A4 + b[3]*A2 + b[1]*ident)) + Lv = b[6]*M6 + b[4]*M4 + b[2]*M2 + return U, V, Lu, Lv + + +def _diff_pade9(A, E, ident): + b = (17643225600., 8821612800., 2075673600., 302702400., 30270240., + 2162160., 110880., 3960., 90., 1.) + A2 = A.dot(A) + M2 = np.dot(A, E) + np.dot(E, A) + A4 = np.dot(A2, A2) + M4 = np.dot(A2, M2) + np.dot(M2, A2) + A6 = np.dot(A2, A4) + M6 = np.dot(A4, M2) + np.dot(M4, A2) + A8 = np.dot(A4, A4) + M8 = np.dot(A4, M4) + np.dot(M4, A4) + U = A.dot(b[9]*A8 + b[7]*A6 + b[5]*A4 + b[3]*A2 + b[1]*ident) + V = b[8]*A8 + b[6]*A6 + b[4]*A4 + b[2]*A2 + b[0]*ident + Lu = (A.dot(b[9]*M8 + b[7]*M6 + b[5]*M4 + b[3]*M2) + + E.dot(b[9]*A8 + b[7]*A6 + b[5]*A4 + b[3]*A2 + b[1]*ident)) + Lv = b[8]*M8 + b[6]*M6 + b[4]*M4 + b[2]*M2 + return U, V, Lu, Lv + + +def expm_frechet_algo_64(A, E): + n = A.shape[0] + s = None + ident = np.identity(n) + A_norm_1 = scipy.linalg.norm(A, 1) + m_pade_pairs = ( + (3, _diff_pade3), + (5, _diff_pade5), + (7, _diff_pade7), + (9, _diff_pade9)) + for m, pade in m_pade_pairs: + if A_norm_1 <= ell_table_61[m]: + U, V, Lu, Lv = pade(A, E, ident) + s = 0 + break + if s is None: + # scaling + s = max(0, int(np.ceil(np.log2(A_norm_1 / ell_table_61[13])))) + A = A * 2.0**-s + E = E * 2.0**-s + # pade order 13 + A2 = np.dot(A, A) + M2 = np.dot(A, E) + np.dot(E, A) + A4 = np.dot(A2, A2) + M4 = np.dot(A2, M2) + np.dot(M2, A2) + A6 = np.dot(A2, A4) + M6 = np.dot(A4, M2) + np.dot(M4, A2) + b = (64764752532480000., 32382376266240000., 7771770303897600., + 1187353796428800., 129060195264000., 10559470521600., + 670442572800., 33522128640., 1323241920., 40840800., 960960., + 16380., 182., 1.) + W1 = b[13]*A6 + b[11]*A4 + b[9]*A2 + W2 = b[7]*A6 + b[5]*A4 + b[3]*A2 + b[1]*ident + Z1 = b[12]*A6 + b[10]*A4 + b[8]*A2 + Z2 = b[6]*A6 + b[4]*A4 + b[2]*A2 + b[0]*ident + W = np.dot(A6, W1) + W2 + U = np.dot(A, W) + V = np.dot(A6, Z1) + Z2 + Lw1 = b[13]*M6 + b[11]*M4 + b[9]*M2 + Lw2 = b[7]*M6 + b[5]*M4 + b[3]*M2 + Lz1 = b[12]*M6 + b[10]*M4 + b[8]*M2 + Lz2 = b[6]*M6 + b[4]*M4 + b[2]*M2 + Lw = np.dot(A6, Lw1) + np.dot(M6, W1) + Lw2 + Lu = np.dot(A, Lw) + np.dot(E, W) + Lv = np.dot(A6, Lz1) + np.dot(M6, Z1) + Lz2 + # factor once and solve twice + lu_piv = scipy.linalg.lu_factor(-U + V) + R = scipy.linalg.lu_solve(lu_piv, U + V) + L = scipy.linalg.lu_solve(lu_piv, Lu + Lv + np.dot((Lu - Lv), R)) + # squaring + for k in range(s): + L = np.dot(R, L) + np.dot(L, R) + R = np.dot(R, R) + return R, L + + +def vec(M): + """ + Stack columns of M to construct a single vector. + + This is somewhat standard notation in linear algebra. + + Parameters + ---------- + M : 2-D array_like + Input matrix + + Returns + ------- + v : 1-D ndarray + Output vector + + """ + return M.T.ravel() + + +def expm_frechet_kronform(A, method=None, check_finite=True): + """ + Construct the Kronecker form of the Frechet derivative of expm. + + Parameters + ---------- + A : array_like with shape (N, N) + Matrix to be expm'd. + method : str, optional + Extra keyword to be passed to expm_frechet. + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + K : 2-D ndarray with shape (N*N, N*N) + Kronecker form of the Frechet derivative of the matrix exponential. + + Notes + ----- + This function is used to help compute the condition number + of the matrix exponential. + + See Also + -------- + expm : Compute a matrix exponential. + expm_frechet : Compute the Frechet derivative of the matrix exponential. + expm_cond : Compute the relative condition number of the matrix exponential + in the Frobenius norm. + + """ + if check_finite: + A = np.asarray_chkfinite(A) + else: + A = np.asarray(A) + if len(A.shape) != 2 or A.shape[0] != A.shape[1]: + raise ValueError('expected a square matrix') + + n = A.shape[0] + ident = np.identity(n) + cols = [] + for i in range(n): + for j in range(n): + E = np.outer(ident[i], ident[j]) + F = expm_frechet(A, E, + method=method, compute_expm=False, check_finite=False) + cols.append(vec(F)) + return np.vstack(cols).T + + +def expm_cond(A, check_finite=True): + """ + Relative condition number of the matrix exponential in the Frobenius norm. + + Parameters + ---------- + A : 2-D array_like + Square input matrix with shape (N, N). + check_finite : bool, optional + Whether to check that the input matrix contains only finite numbers. + Disabling may give a performance gain, but may result in problems + (crashes, non-termination) if the inputs do contain infinities or NaNs. + + Returns + ------- + kappa : float + The relative condition number of the matrix exponential + in the Frobenius norm + + See Also + -------- + expm : Compute the exponential of a matrix. + expm_frechet : Compute the Frechet derivative of the matrix exponential. + + Notes + ----- + A faster estimate for the condition number in the 1-norm + has been published but is not yet implemented in SciPy. + + .. versionadded:: 0.14.0 + + Examples + -------- + >>> import numpy as np + >>> from scipy.linalg import expm_cond + >>> A = np.array([[-0.3, 0.2, 0.6], [0.6, 0.3, -0.1], [-0.7, 1.2, 0.9]]) + >>> k = expm_cond(A) + >>> k + 1.7787805864469866 + + """ + if check_finite: + A = np.asarray_chkfinite(A) + else: + A = np.asarray(A) + if len(A.shape) != 2 or A.shape[0] != A.shape[1]: + raise ValueError('expected a square matrix') + + X = scipy.linalg.expm(A) + K = expm_frechet_kronform(A, check_finite=False) + + # The following norm choices are deliberate. + # The norms of A and X are Frobenius norms, + # and the norm of K is the induced 2-norm. + A_norm = scipy.linalg.norm(A, 'fro') + X_norm = scipy.linalg.norm(X, 'fro') + K_norm = scipy.linalg.norm(K, 2) + + kappa = (K_norm * A_norm) / X_norm + return kappa diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_interpolative.cpython-310-x86_64-linux-gnu.so b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_interpolative.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..342561d85bbdceb7f5d7ea9bcf4f81450c099329 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_interpolative.cpython-310-x86_64-linux-gnu.so differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_interpolative_backend.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_interpolative_backend.py new file mode 100644 index 0000000000000000000000000000000000000000..7835314f79c132c4fdc927186b3282347d681792 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_interpolative_backend.py @@ -0,0 +1,1681 @@ +#****************************************************************************** +# Copyright (C) 2013 Kenneth L. Ho +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. Redistributions in binary +# form must reproduce the above copyright notice, this list of conditions and +# the following disclaimer in the documentation and/or other materials +# provided with the distribution. +# +# None of the names of the copyright holders may be used to endorse or +# promote products derived from this software without specific prior written +# permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +#****************************************************************************** + +""" +Direct wrappers for Fortran `id_dist` backend. +""" + +import scipy.linalg._interpolative as _id +import numpy as np + +_RETCODE_ERROR = RuntimeError("nonzero return code") + + +def _asfortranarray_copy(A): + """ + Same as np.asfortranarray, but ensure a copy + """ + A = np.asarray(A) + if A.flags.f_contiguous: + A = A.copy(order="F") + else: + A = np.asfortranarray(A) + return A + + +#------------------------------------------------------------------------------ +# id_rand.f +#------------------------------------------------------------------------------ + +def id_srand(n): + """ + Generate standard uniform pseudorandom numbers via a very efficient lagged + Fibonacci method. + + :param n: + Number of pseudorandom numbers to generate. + :type n: int + + :return: + Pseudorandom numbers. + :rtype: :class:`numpy.ndarray` + """ + return _id.id_srand(n) + + +def id_srandi(t): + """ + Initialize seed values for :func:`id_srand` (any appropriately random + numbers will do). + + :param t: + Array of 55 seed values. + :type t: :class:`numpy.ndarray` + """ + t = np.asfortranarray(t) + _id.id_srandi(t) + + +def id_srando(): + """ + Reset seed values to their original values. + """ + _id.id_srando() + + +#------------------------------------------------------------------------------ +# idd_frm.f +#------------------------------------------------------------------------------ + +def idd_frm(n, w, x): + """ + Transform real vector via a composition of Rokhlin's random transform, + random subselection, and an FFT. + + In contrast to :func:`idd_sfrm`, this routine works best when the length of + the transformed vector is the power-of-two integer output by + :func:`idd_frmi`, or when the length is not specified but instead + determined a posteriori from the output. The returned transformed vector is + randomly permuted. + + :param n: + Greatest power-of-two integer satisfying `n <= x.size` as obtained from + :func:`idd_frmi`; `n` is also the length of the output vector. + :type n: int + :param w: + Initialization array constructed by :func:`idd_frmi`. + :type w: :class:`numpy.ndarray` + :param x: + Vector to be transformed. + :type x: :class:`numpy.ndarray` + + :return: + Transformed vector. + :rtype: :class:`numpy.ndarray` + """ + return _id.idd_frm(n, w, x) + + +def idd_sfrm(l, n, w, x): + """ + Transform real vector via a composition of Rokhlin's random transform, + random subselection, and an FFT. + + In contrast to :func:`idd_frm`, this routine works best when the length of + the transformed vector is known a priori. + + :param l: + Length of transformed vector, satisfying `l <= n`. + :type l: int + :param n: + Greatest power-of-two integer satisfying `n <= x.size` as obtained from + :func:`idd_sfrmi`. + :type n: int + :param w: + Initialization array constructed by :func:`idd_sfrmi`. + :type w: :class:`numpy.ndarray` + :param x: + Vector to be transformed. + :type x: :class:`numpy.ndarray` + + :return: + Transformed vector. + :rtype: :class:`numpy.ndarray` + """ + return _id.idd_sfrm(l, n, w, x) + + +def idd_frmi(m): + """ + Initialize data for :func:`idd_frm`. + + :param m: + Length of vector to be transformed. + :type m: int + + :return: + Greatest power-of-two integer `n` satisfying `n <= m`. + :rtype: int + :return: + Initialization array to be used by :func:`idd_frm`. + :rtype: :class:`numpy.ndarray` + """ + return _id.idd_frmi(m) + + +def idd_sfrmi(l, m): + """ + Initialize data for :func:`idd_sfrm`. + + :param l: + Length of output transformed vector. + :type l: int + :param m: + Length of the vector to be transformed. + :type m: int + + :return: + Greatest power-of-two integer `n` satisfying `n <= m`. + :rtype: int + :return: + Initialization array to be used by :func:`idd_sfrm`. + :rtype: :class:`numpy.ndarray` + """ + return _id.idd_sfrmi(l, m) + + +#------------------------------------------------------------------------------ +# idd_id.f +#------------------------------------------------------------------------------ + +def iddp_id(eps, A): + """ + Compute ID of a real matrix to a specified relative precision. + + :param eps: + Relative precision. + :type eps: float + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + + :return: + Rank of ID. + :rtype: int + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + A = _asfortranarray_copy(A) + k, idx, rnorms = _id.iddp_id(eps, A) + n = A.shape[1] + proj = A.T.ravel()[:k*(n-k)].reshape((k, n-k), order='F') + return k, idx, proj + + +def iddr_id(A, k): + """ + Compute ID of a real matrix to a specified rank. + + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + :param k: + Rank of ID. + :type k: int + + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + A = _asfortranarray_copy(A) + idx, rnorms = _id.iddr_id(A, k) + n = A.shape[1] + proj = A.T.ravel()[:k*(n-k)].reshape((k, n-k), order='F') + return idx, proj + + +def idd_reconid(B, idx, proj): + """ + Reconstruct matrix from real ID. + + :param B: + Skeleton matrix. + :type B: :class:`numpy.ndarray` + :param idx: + Column index array. + :type idx: :class:`numpy.ndarray` + :param proj: + Interpolation coefficients. + :type proj: :class:`numpy.ndarray` + + :return: + Reconstructed matrix. + :rtype: :class:`numpy.ndarray` + """ + B = np.asfortranarray(B) + if proj.size > 0: + return _id.idd_reconid(B, idx, proj) + else: + return B[:, np.argsort(idx)] + + +def idd_reconint(idx, proj): + """ + Reconstruct interpolation matrix from real ID. + + :param idx: + Column index array. + :type idx: :class:`numpy.ndarray` + :param proj: + Interpolation coefficients. + :type proj: :class:`numpy.ndarray` + + :return: + Interpolation matrix. + :rtype: :class:`numpy.ndarray` + """ + return _id.idd_reconint(idx, proj) + + +def idd_copycols(A, k, idx): + """ + Reconstruct skeleton matrix from real ID. + + :param A: + Original matrix. + :type A: :class:`numpy.ndarray` + :param k: + Rank of ID. + :type k: int + :param idx: + Column index array. + :type idx: :class:`numpy.ndarray` + + :return: + Skeleton matrix. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + return _id.idd_copycols(A, k, idx) + + +#------------------------------------------------------------------------------ +# idd_id2svd.f +#------------------------------------------------------------------------------ + +def idd_id2svd(B, idx, proj): + """ + Convert real ID to SVD. + + :param B: + Skeleton matrix. + :type B: :class:`numpy.ndarray` + :param idx: + Column index array. + :type idx: :class:`numpy.ndarray` + :param proj: + Interpolation coefficients. + :type proj: :class:`numpy.ndarray` + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + B = np.asfortranarray(B) + U, V, S, ier = _id.idd_id2svd(B, idx, proj) + if ier: + raise _RETCODE_ERROR + return U, V, S + + +#------------------------------------------------------------------------------ +# idd_snorm.f +#------------------------------------------------------------------------------ + +def idd_snorm(m, n, matvect, matvec, its=20): + """ + Estimate spectral norm of a real matrix by the randomized power method. + + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matvect: + Function to apply the matrix transpose to a vector, with call signature + `y = matvect(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvect: function + :param matvec: + Function to apply the matrix to a vector, with call signature + `y = matvec(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvec: function + :param its: + Number of power method iterations. + :type its: int + + :return: + Spectral norm estimate. + :rtype: float + """ + snorm, v = _id.idd_snorm(m, n, matvect, matvec, its) + return snorm + + +def idd_diffsnorm(m, n, matvect, matvect2, matvec, matvec2, its=20): + """ + Estimate spectral norm of the difference of two real matrices by the + randomized power method. + + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matvect: + Function to apply the transpose of the first matrix to a vector, with + call signature `y = matvect(x)`, where `x` and `y` are the input and + output vectors, respectively. + :type matvect: function + :param matvect2: + Function to apply the transpose of the second matrix to a vector, with + call signature `y = matvect2(x)`, where `x` and `y` are the input and + output vectors, respectively. + :type matvect2: function + :param matvec: + Function to apply the first matrix to a vector, with call signature + `y = matvec(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvec: function + :param matvec2: + Function to apply the second matrix to a vector, with call signature + `y = matvec2(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvec2: function + :param its: + Number of power method iterations. + :type its: int + + :return: + Spectral norm estimate of matrix difference. + :rtype: float + """ + return _id.idd_diffsnorm(m, n, matvect, matvect2, matvec, matvec2, its) + + +#------------------------------------------------------------------------------ +# idd_svd.f +#------------------------------------------------------------------------------ + +def iddr_svd(A, k): + """ + Compute SVD of a real matrix to a specified rank. + + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + :param k: + Rank of SVD. + :type k: int + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + U, V, S, ier = _id.iddr_svd(A, k) + if ier: + raise _RETCODE_ERROR + return U, V, S + + +def iddp_svd(eps, A): + """ + Compute SVD of a real matrix to a specified relative precision. + + :param eps: + Relative precision. + :type eps: float + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + m, n = A.shape + k, iU, iV, iS, w, ier = _id.iddp_svd(eps, A) + if ier: + raise _RETCODE_ERROR + U = w[iU-1:iU+m*k-1].reshape((m, k), order='F') + V = w[iV-1:iV+n*k-1].reshape((n, k), order='F') + S = w[iS-1:iS+k-1] + return U, V, S + + +#------------------------------------------------------------------------------ +# iddp_aid.f +#------------------------------------------------------------------------------ + +def iddp_aid(eps, A): + """ + Compute ID of a real matrix to a specified relative precision using random + sampling. + + :param eps: + Relative precision. + :type eps: float + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + + :return: + Rank of ID. + :rtype: int + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + m, n = A.shape + n2, w = idd_frmi(m) + proj = np.empty(n*(2*n2 + 1) + n2 + 1, order='F') + k, idx, proj = _id.iddp_aid(eps, A, w, proj) + proj = proj[:k*(n-k)].reshape((k, n-k), order='F') + return k, idx, proj + + +def idd_estrank(eps, A): + """ + Estimate rank of a real matrix to a specified relative precision using + random sampling. + + The output rank is typically about 8 higher than the actual rank. + + :param eps: + Relative precision. + :type eps: float + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + + :return: + Rank estimate. + :rtype: int + """ + A = np.asfortranarray(A) + m, n = A.shape + n2, w = idd_frmi(m) + ra = np.empty(n*n2 + (n + 1)*(n2 + 1), order='F') + k, ra = _id.idd_estrank(eps, A, w, ra) + return k + + +#------------------------------------------------------------------------------ +# iddp_asvd.f +#------------------------------------------------------------------------------ + +def iddp_asvd(eps, A): + """ + Compute SVD of a real matrix to a specified relative precision using random + sampling. + + :param eps: + Relative precision. + :type eps: float + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + m, n = A.shape + n2, winit = _id.idd_frmi(m) + w = np.empty( + max((min(m, n) + 1)*(3*m + 5*n + 1) + 25*min(m, n)**2, + (2*n + 1)*(n2 + 1)), + order='F') + k, iU, iV, iS, w, ier = _id.iddp_asvd(eps, A, winit, w) + if ier: + raise _RETCODE_ERROR + U = w[iU-1:iU+m*k-1].reshape((m, k), order='F') + V = w[iV-1:iV+n*k-1].reshape((n, k), order='F') + S = w[iS-1:iS+k-1] + return U, V, S + + +#------------------------------------------------------------------------------ +# iddp_rid.f +#------------------------------------------------------------------------------ + +def iddp_rid(eps, m, n, matvect): + """ + Compute ID of a real matrix to a specified relative precision using random + matrix-vector multiplication. + + :param eps: + Relative precision. + :type eps: float + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matvect: + Function to apply the matrix transpose to a vector, with call signature + `y = matvect(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvect: function + + :return: + Rank of ID. + :rtype: int + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + proj = np.empty(m + 1 + 2*n*(min(m, n) + 1), order='F') + k, idx, proj, ier = _id.iddp_rid(eps, m, n, matvect, proj) + if ier != 0: + raise _RETCODE_ERROR + proj = proj[:k*(n-k)].reshape((k, n-k), order='F') + return k, idx, proj + + +def idd_findrank(eps, m, n, matvect): + """ + Estimate rank of a real matrix to a specified relative precision using + random matrix-vector multiplication. + + :param eps: + Relative precision. + :type eps: float + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matvect: + Function to apply the matrix transpose to a vector, with call signature + `y = matvect(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvect: function + + :return: + Rank estimate. + :rtype: int + """ + k, ra, ier = _id.idd_findrank(eps, m, n, matvect) + if ier: + raise _RETCODE_ERROR + return k + + +#------------------------------------------------------------------------------ +# iddp_rsvd.f +#------------------------------------------------------------------------------ + +def iddp_rsvd(eps, m, n, matvect, matvec): + """ + Compute SVD of a real matrix to a specified relative precision using random + matrix-vector multiplication. + + :param eps: + Relative precision. + :type eps: float + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matvect: + Function to apply the matrix transpose to a vector, with call signature + `y = matvect(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvect: function + :param matvec: + Function to apply the matrix to a vector, with call signature + `y = matvec(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvec: function + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + k, iU, iV, iS, w, ier = _id.iddp_rsvd(eps, m, n, matvect, matvec) + if ier: + raise _RETCODE_ERROR + U = w[iU-1:iU+m*k-1].reshape((m, k), order='F') + V = w[iV-1:iV+n*k-1].reshape((n, k), order='F') + S = w[iS-1:iS+k-1] + return U, V, S + + +#------------------------------------------------------------------------------ +# iddr_aid.f +#------------------------------------------------------------------------------ + +def iddr_aid(A, k): + """ + Compute ID of a real matrix to a specified rank using random sampling. + + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + :param k: + Rank of ID. + :type k: int + + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + m, n = A.shape + w = iddr_aidi(m, n, k) + idx, proj = _id.iddr_aid(A, k, w) + if k == n: + proj = np.empty((k, n-k), dtype='float64', order='F') + else: + proj = proj.reshape((k, n-k), order='F') + return idx, proj + + +def iddr_aidi(m, n, k): + """ + Initialize array for :func:`iddr_aid`. + + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param k: + Rank of ID. + :type k: int + + :return: + Initialization array to be used by :func:`iddr_aid`. + :rtype: :class:`numpy.ndarray` + """ + return _id.iddr_aidi(m, n, k) + + +#------------------------------------------------------------------------------ +# iddr_asvd.f +#------------------------------------------------------------------------------ + +def iddr_asvd(A, k): + """ + Compute SVD of a real matrix to a specified rank using random sampling. + + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + :param k: + Rank of SVD. + :type k: int + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + m, n = A.shape + w = np.empty((2*k + 28)*m + (6*k + 21)*n + 25*k**2 + 100, order='F') + w_ = iddr_aidi(m, n, k) + w[:w_.size] = w_ + U, V, S, ier = _id.iddr_asvd(A, k, w) + if ier != 0: + raise _RETCODE_ERROR + return U, V, S + + +#------------------------------------------------------------------------------ +# iddr_rid.f +#------------------------------------------------------------------------------ + +def iddr_rid(m, n, matvect, k): + """ + Compute ID of a real matrix to a specified rank using random matrix-vector + multiplication. + + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matvect: + Function to apply the matrix transpose to a vector, with call signature + `y = matvect(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvect: function + :param k: + Rank of ID. + :type k: int + + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + idx, proj = _id.iddr_rid(m, n, matvect, k) + proj = proj[:k*(n-k)].reshape((k, n-k), order='F') + return idx, proj + + +#------------------------------------------------------------------------------ +# iddr_rsvd.f +#------------------------------------------------------------------------------ + +def iddr_rsvd(m, n, matvect, matvec, k): + """ + Compute SVD of a real matrix to a specified rank using random matrix-vector + multiplication. + + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matvect: + Function to apply the matrix transpose to a vector, with call signature + `y = matvect(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvect: function + :param matvec: + Function to apply the matrix to a vector, with call signature + `y = matvec(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvec: function + :param k: + Rank of SVD. + :type k: int + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + U, V, S, ier = _id.iddr_rsvd(m, n, matvect, matvec, k) + if ier != 0: + raise _RETCODE_ERROR + return U, V, S + + +#------------------------------------------------------------------------------ +# idz_frm.f +#------------------------------------------------------------------------------ + +def idz_frm(n, w, x): + """ + Transform complex vector via a composition of Rokhlin's random transform, + random subselection, and an FFT. + + In contrast to :func:`idz_sfrm`, this routine works best when the length of + the transformed vector is the power-of-two integer output by + :func:`idz_frmi`, or when the length is not specified but instead + determined a posteriori from the output. The returned transformed vector is + randomly permuted. + + :param n: + Greatest power-of-two integer satisfying `n <= x.size` as obtained from + :func:`idz_frmi`; `n` is also the length of the output vector. + :type n: int + :param w: + Initialization array constructed by :func:`idz_frmi`. + :type w: :class:`numpy.ndarray` + :param x: + Vector to be transformed. + :type x: :class:`numpy.ndarray` + + :return: + Transformed vector. + :rtype: :class:`numpy.ndarray` + """ + return _id.idz_frm(n, w, x) + + +def idz_sfrm(l, n, w, x): + """ + Transform complex vector via a composition of Rokhlin's random transform, + random subselection, and an FFT. + + In contrast to :func:`idz_frm`, this routine works best when the length of + the transformed vector is known a priori. + + :param l: + Length of transformed vector, satisfying `l <= n`. + :type l: int + :param n: + Greatest power-of-two integer satisfying `n <= x.size` as obtained from + :func:`idz_sfrmi`. + :type n: int + :param w: + Initialization array constructed by :func:`idd_sfrmi`. + :type w: :class:`numpy.ndarray` + :param x: + Vector to be transformed. + :type x: :class:`numpy.ndarray` + + :return: + Transformed vector. + :rtype: :class:`numpy.ndarray` + """ + return _id.idz_sfrm(l, n, w, x) + + +def idz_frmi(m): + """ + Initialize data for :func:`idz_frm`. + + :param m: + Length of vector to be transformed. + :type m: int + + :return: + Greatest power-of-two integer `n` satisfying `n <= m`. + :rtype: int + :return: + Initialization array to be used by :func:`idz_frm`. + :rtype: :class:`numpy.ndarray` + """ + return _id.idz_frmi(m) + + +def idz_sfrmi(l, m): + """ + Initialize data for :func:`idz_sfrm`. + + :param l: + Length of output transformed vector. + :type l: int + :param m: + Length of the vector to be transformed. + :type m: int + + :return: + Greatest power-of-two integer `n` satisfying `n <= m`. + :rtype: int + :return: + Initialization array to be used by :func:`idz_sfrm`. + :rtype: :class:`numpy.ndarray` + """ + return _id.idz_sfrmi(l, m) + + +#------------------------------------------------------------------------------ +# idz_id.f +#------------------------------------------------------------------------------ + +def idzp_id(eps, A): + """ + Compute ID of a complex matrix to a specified relative precision. + + :param eps: + Relative precision. + :type eps: float + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + + :return: + Rank of ID. + :rtype: int + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + A = _asfortranarray_copy(A) + k, idx, rnorms = _id.idzp_id(eps, A) + n = A.shape[1] + proj = A.T.ravel()[:k*(n-k)].reshape((k, n-k), order='F') + return k, idx, proj + + +def idzr_id(A, k): + """ + Compute ID of a complex matrix to a specified rank. + + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + :param k: + Rank of ID. + :type k: int + + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + A = _asfortranarray_copy(A) + idx, rnorms = _id.idzr_id(A, k) + n = A.shape[1] + proj = A.T.ravel()[:k*(n-k)].reshape((k, n-k), order='F') + return idx, proj + + +def idz_reconid(B, idx, proj): + """ + Reconstruct matrix from complex ID. + + :param B: + Skeleton matrix. + :type B: :class:`numpy.ndarray` + :param idx: + Column index array. + :type idx: :class:`numpy.ndarray` + :param proj: + Interpolation coefficients. + :type proj: :class:`numpy.ndarray` + + :return: + Reconstructed matrix. + :rtype: :class:`numpy.ndarray` + """ + B = np.asfortranarray(B) + if proj.size > 0: + return _id.idz_reconid(B, idx, proj) + else: + return B[:, np.argsort(idx)] + + +def idz_reconint(idx, proj): + """ + Reconstruct interpolation matrix from complex ID. + + :param idx: + Column index array. + :type idx: :class:`numpy.ndarray` + :param proj: + Interpolation coefficients. + :type proj: :class:`numpy.ndarray` + + :return: + Interpolation matrix. + :rtype: :class:`numpy.ndarray` + """ + return _id.idz_reconint(idx, proj) + + +def idz_copycols(A, k, idx): + """ + Reconstruct skeleton matrix from complex ID. + + :param A: + Original matrix. + :type A: :class:`numpy.ndarray` + :param k: + Rank of ID. + :type k: int + :param idx: + Column index array. + :type idx: :class:`numpy.ndarray` + + :return: + Skeleton matrix. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + return _id.idz_copycols(A, k, idx) + + +#------------------------------------------------------------------------------ +# idz_id2svd.f +#------------------------------------------------------------------------------ + +def idz_id2svd(B, idx, proj): + """ + Convert complex ID to SVD. + + :param B: + Skeleton matrix. + :type B: :class:`numpy.ndarray` + :param idx: + Column index array. + :type idx: :class:`numpy.ndarray` + :param proj: + Interpolation coefficients. + :type proj: :class:`numpy.ndarray` + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + B = np.asfortranarray(B) + U, V, S, ier = _id.idz_id2svd(B, idx, proj) + if ier: + raise _RETCODE_ERROR + return U, V, S + + +#------------------------------------------------------------------------------ +# idz_snorm.f +#------------------------------------------------------------------------------ + +def idz_snorm(m, n, matveca, matvec, its=20): + """ + Estimate spectral norm of a complex matrix by the randomized power method. + + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matveca: + Function to apply the matrix adjoint to a vector, with call signature + `y = matveca(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matveca: function + :param matvec: + Function to apply the matrix to a vector, with call signature + `y = matvec(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvec: function + :param its: + Number of power method iterations. + :type its: int + + :return: + Spectral norm estimate. + :rtype: float + """ + snorm, v = _id.idz_snorm(m, n, matveca, matvec, its) + return snorm + + +def idz_diffsnorm(m, n, matveca, matveca2, matvec, matvec2, its=20): + """ + Estimate spectral norm of the difference of two complex matrices by the + randomized power method. + + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matveca: + Function to apply the adjoint of the first matrix to a vector, with + call signature `y = matveca(x)`, where `x` and `y` are the input and + output vectors, respectively. + :type matveca: function + :param matveca2: + Function to apply the adjoint of the second matrix to a vector, with + call signature `y = matveca2(x)`, where `x` and `y` are the input and + output vectors, respectively. + :type matveca2: function + :param matvec: + Function to apply the first matrix to a vector, with call signature + `y = matvec(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvec: function + :param matvec2: + Function to apply the second matrix to a vector, with call signature + `y = matvec2(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvec2: function + :param its: + Number of power method iterations. + :type its: int + + :return: + Spectral norm estimate of matrix difference. + :rtype: float + """ + return _id.idz_diffsnorm(m, n, matveca, matveca2, matvec, matvec2, its) + + +#------------------------------------------------------------------------------ +# idz_svd.f +#------------------------------------------------------------------------------ + +def idzr_svd(A, k): + """ + Compute SVD of a complex matrix to a specified rank. + + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + :param k: + Rank of SVD. + :type k: int + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + U, V, S, ier = _id.idzr_svd(A, k) + if ier: + raise _RETCODE_ERROR + return U, V, S + + +def idzp_svd(eps, A): + """ + Compute SVD of a complex matrix to a specified relative precision. + + :param eps: + Relative precision. + :type eps: float + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + m, n = A.shape + k, iU, iV, iS, w, ier = _id.idzp_svd(eps, A) + if ier: + raise _RETCODE_ERROR + U = w[iU-1:iU+m*k-1].reshape((m, k), order='F') + V = w[iV-1:iV+n*k-1].reshape((n, k), order='F') + S = w[iS-1:iS+k-1] + return U, V, S + + +#------------------------------------------------------------------------------ +# idzp_aid.f +#------------------------------------------------------------------------------ + +def idzp_aid(eps, A): + """ + Compute ID of a complex matrix to a specified relative precision using + random sampling. + + :param eps: + Relative precision. + :type eps: float + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + + :return: + Rank of ID. + :rtype: int + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + m, n = A.shape + n2, w = idz_frmi(m) + proj = np.empty(n*(2*n2 + 1) + n2 + 1, dtype='complex128', order='F') + k, idx, proj = _id.idzp_aid(eps, A, w, proj) + proj = proj[:k*(n-k)].reshape((k, n-k), order='F') + return k, idx, proj + + +def idz_estrank(eps, A): + """ + Estimate rank of a complex matrix to a specified relative precision using + random sampling. + + The output rank is typically about 8 higher than the actual rank. + + :param eps: + Relative precision. + :type eps: float + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + + :return: + Rank estimate. + :rtype: int + """ + A = np.asfortranarray(A) + m, n = A.shape + n2, w = idz_frmi(m) + ra = np.empty(n*n2 + (n + 1)*(n2 + 1), dtype='complex128', order='F') + k, ra = _id.idz_estrank(eps, A, w, ra) + return k + + +#------------------------------------------------------------------------------ +# idzp_asvd.f +#------------------------------------------------------------------------------ + +def idzp_asvd(eps, A): + """ + Compute SVD of a complex matrix to a specified relative precision using + random sampling. + + :param eps: + Relative precision. + :type eps: float + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + m, n = A.shape + n2, winit = _id.idz_frmi(m) + w = np.empty( + max((min(m, n) + 1)*(3*m + 5*n + 11) + 8*min(m, n)**2, + (2*n + 1)*(n2 + 1)), + dtype=np.complex128, order='F') + k, iU, iV, iS, w, ier = _id.idzp_asvd(eps, A, winit, w) + if ier: + raise _RETCODE_ERROR + U = w[iU-1:iU+m*k-1].reshape((m, k), order='F') + V = w[iV-1:iV+n*k-1].reshape((n, k), order='F') + S = w[iS-1:iS+k-1] + return U, V, S + + +#------------------------------------------------------------------------------ +# idzp_rid.f +#------------------------------------------------------------------------------ + +def idzp_rid(eps, m, n, matveca): + """ + Compute ID of a complex matrix to a specified relative precision using + random matrix-vector multiplication. + + :param eps: + Relative precision. + :type eps: float + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matveca: + Function to apply the matrix adjoint to a vector, with call signature + `y = matveca(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matveca: function + + :return: + Rank of ID. + :rtype: int + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + proj = np.empty( + m + 1 + 2*n*(min(m, n) + 1), + dtype=np.complex128, order='F') + k, idx, proj, ier = _id.idzp_rid(eps, m, n, matveca, proj) + if ier: + raise _RETCODE_ERROR + proj = proj[:k*(n-k)].reshape((k, n-k), order='F') + return k, idx, proj + + +def idz_findrank(eps, m, n, matveca): + """ + Estimate rank of a complex matrix to a specified relative precision using + random matrix-vector multiplication. + + :param eps: + Relative precision. + :type eps: float + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matveca: + Function to apply the matrix adjoint to a vector, with call signature + `y = matveca(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matveca: function + + :return: + Rank estimate. + :rtype: int + """ + k, ra, ier = _id.idz_findrank(eps, m, n, matveca) + if ier: + raise _RETCODE_ERROR + return k + + +#------------------------------------------------------------------------------ +# idzp_rsvd.f +#------------------------------------------------------------------------------ + +def idzp_rsvd(eps, m, n, matveca, matvec): + """ + Compute SVD of a complex matrix to a specified relative precision using + random matrix-vector multiplication. + + :param eps: + Relative precision. + :type eps: float + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matveca: + Function to apply the matrix adjoint to a vector, with call signature + `y = matveca(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matveca: function + :param matvec: + Function to apply the matrix to a vector, with call signature + `y = matvec(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvec: function + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + k, iU, iV, iS, w, ier = _id.idzp_rsvd(eps, m, n, matveca, matvec) + if ier: + raise _RETCODE_ERROR + U = w[iU-1:iU+m*k-1].reshape((m, k), order='F') + V = w[iV-1:iV+n*k-1].reshape((n, k), order='F') + S = w[iS-1:iS+k-1] + return U, V, S + + +#------------------------------------------------------------------------------ +# idzr_aid.f +#------------------------------------------------------------------------------ + +def idzr_aid(A, k): + """ + Compute ID of a complex matrix to a specified rank using random sampling. + + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + :param k: + Rank of ID. + :type k: int + + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + m, n = A.shape + w = idzr_aidi(m, n, k) + idx, proj = _id.idzr_aid(A, k, w) + if k == n: + proj = np.empty((k, n-k), dtype='complex128', order='F') + else: + proj = proj.reshape((k, n-k), order='F') + return idx, proj + + +def idzr_aidi(m, n, k): + """ + Initialize array for :func:`idzr_aid`. + + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param k: + Rank of ID. + :type k: int + + :return: + Initialization array to be used by :func:`idzr_aid`. + :rtype: :class:`numpy.ndarray` + """ + return _id.idzr_aidi(m, n, k) + + +#------------------------------------------------------------------------------ +# idzr_asvd.f +#------------------------------------------------------------------------------ + +def idzr_asvd(A, k): + """ + Compute SVD of a complex matrix to a specified rank using random sampling. + + :param A: + Matrix. + :type A: :class:`numpy.ndarray` + :param k: + Rank of SVD. + :type k: int + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + A = np.asfortranarray(A) + m, n = A.shape + w = np.empty( + (2*k + 22)*m + (6*k + 21)*n + 8*k**2 + 10*k + 90, + dtype='complex128', order='F') + w_ = idzr_aidi(m, n, k) + w[:w_.size] = w_ + U, V, S, ier = _id.idzr_asvd(A, k, w) + if ier: + raise _RETCODE_ERROR + return U, V, S + + +#------------------------------------------------------------------------------ +# idzr_rid.f +#------------------------------------------------------------------------------ + +def idzr_rid(m, n, matveca, k): + """ + Compute ID of a complex matrix to a specified rank using random + matrix-vector multiplication. + + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matveca: + Function to apply the matrix adjoint to a vector, with call signature + `y = matveca(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matveca: function + :param k: + Rank of ID. + :type k: int + + :return: + Column index array. + :rtype: :class:`numpy.ndarray` + :return: + Interpolation coefficients. + :rtype: :class:`numpy.ndarray` + """ + idx, proj = _id.idzr_rid(m, n, matveca, k) + proj = proj[:k*(n-k)].reshape((k, n-k), order='F') + return idx, proj + + +#------------------------------------------------------------------------------ +# idzr_rsvd.f +#------------------------------------------------------------------------------ + +def idzr_rsvd(m, n, matveca, matvec, k): + """ + Compute SVD of a complex matrix to a specified rank using random + matrix-vector multiplication. + + :param m: + Matrix row dimension. + :type m: int + :param n: + Matrix column dimension. + :type n: int + :param matveca: + Function to apply the matrix adjoint to a vector, with call signature + `y = matveca(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matveca: function + :param matvec: + Function to apply the matrix to a vector, with call signature + `y = matvec(x)`, where `x` and `y` are the input and output vectors, + respectively. + :type matvec: function + :param k: + Rank of SVD. + :type k: int + + :return: + Left singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Right singular vectors. + :rtype: :class:`numpy.ndarray` + :return: + Singular values. + :rtype: :class:`numpy.ndarray` + """ + U, V, S, ier = _id.idzr_rsvd(m, n, matveca, matvec, k) + if ier: + raise _RETCODE_ERROR + return U, V, S diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_matfuncs_expm.pyi b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_matfuncs_expm.pyi new file mode 100644 index 0000000000000000000000000000000000000000..2b675a7cd9bd18023d4c14ce253ea68754c726b1 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_matfuncs_expm.pyi @@ -0,0 +1,6 @@ +from numpy.typing import NDArray +from typing import Any + +def pick_pade_structure(a: NDArray[Any]) -> tuple[int, int]: ... + +def pade_UV_calc(Am: NDArray[Any], n: int, m: int) -> None: ... diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_matfuncs_inv_ssq.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_matfuncs_inv_ssq.py new file mode 100644 index 0000000000000000000000000000000000000000..d84f53dc6c8309e2732becd846d257df8487d7d2 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_matfuncs_inv_ssq.py @@ -0,0 +1,886 @@ +""" +Matrix functions that use Pade approximation with inverse scaling and squaring. + +""" +import warnings + +import numpy as np + +from scipy.linalg._matfuncs_sqrtm import SqrtmError, _sqrtm_triu +from scipy.linalg._decomp_schur import schur, rsf2csf +from scipy.linalg._matfuncs import funm +from scipy.linalg import svdvals, solve_triangular +from scipy.sparse.linalg._interface import LinearOperator +from scipy.sparse.linalg import onenormest +import scipy.special + + +class LogmRankWarning(UserWarning): + pass + + +class LogmExactlySingularWarning(LogmRankWarning): + pass + + +class LogmNearlySingularWarning(LogmRankWarning): + pass + + +class LogmError(np.linalg.LinAlgError): + pass + + +class FractionalMatrixPowerError(np.linalg.LinAlgError): + pass + + +#TODO renovate or move this class when scipy operators are more mature +class _MatrixM1PowerOperator(LinearOperator): + """ + A representation of the linear operator (A - I)^p. + """ + + def __init__(self, A, p): + if A.ndim != 2 or A.shape[0] != A.shape[1]: + raise ValueError('expected A to be like a square matrix') + if p < 0 or p != int(p): + raise ValueError('expected p to be a non-negative integer') + self._A = A + self._p = p + self.ndim = A.ndim + self.shape = A.shape + + def _matvec(self, x): + for i in range(self._p): + x = self._A.dot(x) - x + return x + + def _rmatvec(self, x): + for i in range(self._p): + x = x.dot(self._A) - x + return x + + def _matmat(self, X): + for i in range(self._p): + X = self._A.dot(X) - X + return X + + def _adjoint(self): + return _MatrixM1PowerOperator(self._A.T, self._p) + + +#TODO renovate or move this function when SciPy operators are more mature +def _onenormest_m1_power(A, p, + t=2, itmax=5, compute_v=False, compute_w=False): + """ + Efficiently estimate the 1-norm of (A - I)^p. + + Parameters + ---------- + A : ndarray + Matrix whose 1-norm of a power is to be computed. + p : int + Non-negative integer power. + t : int, optional + A positive parameter controlling the tradeoff between + accuracy versus time and memory usage. + Larger values take longer and use more memory + but give more accurate output. + itmax : int, optional + Use at most this many iterations. + compute_v : bool, optional + Request a norm-maximizing linear operator input vector if True. + compute_w : bool, optional + Request a norm-maximizing linear operator output vector if True. + + Returns + ------- + est : float + An underestimate of the 1-norm of the sparse matrix. + v : ndarray, optional + The vector such that ||Av||_1 == est*||v||_1. + It can be thought of as an input to the linear operator + that gives an output with particularly large norm. + w : ndarray, optional + The vector Av which has relatively large 1-norm. + It can be thought of as an output of the linear operator + that is relatively large in norm compared to the input. + + """ + return onenormest(_MatrixM1PowerOperator(A, p), + t=t, itmax=itmax, compute_v=compute_v, compute_w=compute_w) + + +def _unwindk(z): + """ + Compute the scalar unwinding number. + + Uses Eq. (5.3) in [1]_, and should be equal to (z - log(exp(z)) / (2 pi i). + Note that this definition differs in sign from the original definition + in equations (5, 6) in [2]_. The sign convention is justified in [3]_. + + Parameters + ---------- + z : complex + A complex number. + + Returns + ------- + unwinding_number : integer + The scalar unwinding number of z. + + References + ---------- + .. [1] Nicholas J. Higham and Lijing lin (2011) + "A Schur-Pade Algorithm for Fractional Powers of a Matrix." + SIAM Journal on Matrix Analysis and Applications, + 32 (3). pp. 1056-1078. ISSN 0895-4798 + + .. [2] Robert M. Corless and David J. Jeffrey, + "The unwinding number." Newsletter ACM SIGSAM Bulletin + Volume 30, Issue 2, June 1996, Pages 28-35. + + .. [3] Russell Bradford and Robert M. Corless and James H. Davenport and + David J. Jeffrey and Stephen M. Watt, + "Reasoning about the elementary functions of complex analysis" + Annals of Mathematics and Artificial Intelligence, + 36: 303-318, 2002. + + """ + return int(np.ceil((z.imag - np.pi) / (2*np.pi))) + + +def _briggs_helper_function(a, k): + """ + Computes r = a^(1 / (2^k)) - 1. + + This is algorithm (2) of [1]_. + The purpose is to avoid a danger of subtractive cancellation. + For more computational efficiency it should probably be cythonized. + + Parameters + ---------- + a : complex + A complex number. + k : integer + A nonnegative integer. + + Returns + ------- + r : complex + The value r = a^(1 / (2^k)) - 1 computed with less cancellation. + + Notes + ----- + The algorithm as formulated in the reference does not handle k=0 or k=1 + correctly, so these are special-cased in this implementation. + This function is intended to not allow `a` to belong to the closed + negative real axis, but this constraint is relaxed. + + References + ---------- + .. [1] Awad H. Al-Mohy (2012) + "A more accurate Briggs method for the logarithm", + Numerical Algorithms, 59 : 393--402. + + """ + if k < 0 or int(k) != k: + raise ValueError('expected a nonnegative integer k') + if k == 0: + return a - 1 + elif k == 1: + return np.sqrt(a) - 1 + else: + k_hat = k + if np.angle(a) >= np.pi / 2: + a = np.sqrt(a) + k_hat = k - 1 + z0 = a - 1 + a = np.sqrt(a) + r = 1 + a + for j in range(1, k_hat): + a = np.sqrt(a) + r = r * (1 + a) + r = z0 / r + return r + + +def _fractional_power_superdiag_entry(l1, l2, t12, p): + """ + Compute a superdiagonal entry of a fractional matrix power. + + This is Eq. (5.6) in [1]_. + + Parameters + ---------- + l1 : complex + A diagonal entry of the matrix. + l2 : complex + A diagonal entry of the matrix. + t12 : complex + A superdiagonal entry of the matrix. + p : float + A fractional power. + + Returns + ------- + f12 : complex + A superdiagonal entry of the fractional matrix power. + + Notes + ----- + Care has been taken to return a real number if possible when + all of the inputs are real numbers. + + References + ---------- + .. [1] Nicholas J. Higham and Lijing lin (2011) + "A Schur-Pade Algorithm for Fractional Powers of a Matrix." + SIAM Journal on Matrix Analysis and Applications, + 32 (3). pp. 1056-1078. ISSN 0895-4798 + + """ + if l1 == l2: + f12 = t12 * p * l1**(p-1) + elif abs(l2 - l1) > abs(l1 + l2) / 2: + f12 = t12 * ((l2**p) - (l1**p)) / (l2 - l1) + else: + # This is Eq. (5.5) in [1]. + z = (l2 - l1) / (l2 + l1) + log_l1 = np.log(l1) + log_l2 = np.log(l2) + arctanh_z = np.arctanh(z) + tmp_a = t12 * np.exp((p/2)*(log_l2 + log_l1)) + tmp_u = _unwindk(log_l2 - log_l1) + if tmp_u: + tmp_b = p * (arctanh_z + np.pi * 1j * tmp_u) + else: + tmp_b = p * arctanh_z + tmp_c = 2 * np.sinh(tmp_b) / (l2 - l1) + f12 = tmp_a * tmp_c + return f12 + + +def _logm_superdiag_entry(l1, l2, t12): + """ + Compute a superdiagonal entry of a matrix logarithm. + + This is like Eq. (11.28) in [1]_, except the determination of whether + l1 and l2 are sufficiently far apart has been modified. + + Parameters + ---------- + l1 : complex + A diagonal entry of the matrix. + l2 : complex + A diagonal entry of the matrix. + t12 : complex + A superdiagonal entry of the matrix. + + Returns + ------- + f12 : complex + A superdiagonal entry of the matrix logarithm. + + Notes + ----- + Care has been taken to return a real number if possible when + all of the inputs are real numbers. + + References + ---------- + .. [1] Nicholas J. Higham (2008) + "Functions of Matrices: Theory and Computation" + ISBN 978-0-898716-46-7 + + """ + if l1 == l2: + f12 = t12 / l1 + elif abs(l2 - l1) > abs(l1 + l2) / 2: + f12 = t12 * (np.log(l2) - np.log(l1)) / (l2 - l1) + else: + z = (l2 - l1) / (l2 + l1) + u = _unwindk(np.log(l2) - np.log(l1)) + if u: + f12 = t12 * 2 * (np.arctanh(z) + np.pi*1j*u) / (l2 - l1) + else: + f12 = t12 * 2 * np.arctanh(z) / (l2 - l1) + return f12 + + +def _inverse_squaring_helper(T0, theta): + """ + A helper function for inverse scaling and squaring for Pade approximation. + + Parameters + ---------- + T0 : (N, N) array_like upper triangular + Matrix involved in inverse scaling and squaring. + theta : indexable + The values theta[1] .. theta[7] must be available. + They represent bounds related to Pade approximation, and they depend + on the matrix function which is being computed. + For example, different values of theta are required for + matrix logarithm than for fractional matrix power. + + Returns + ------- + R : (N, N) array_like upper triangular + Composition of zero or more matrix square roots of T0, minus I. + s : non-negative integer + Number of square roots taken. + m : positive integer + The degree of the Pade approximation. + + Notes + ----- + This subroutine appears as a chunk of lines within + a couple of published algorithms; for example it appears + as lines 4--35 in algorithm (3.1) of [1]_, and + as lines 3--34 in algorithm (4.1) of [2]_. + The instances of 'goto line 38' in algorithm (3.1) of [1]_ + probably mean 'goto line 36' and have been interpreted accordingly. + + References + ---------- + .. [1] Nicholas J. Higham and Lijing Lin (2013) + "An Improved Schur-Pade Algorithm for Fractional Powers + of a Matrix and their Frechet Derivatives." + + .. [2] Awad H. Al-Mohy and Nicholas J. Higham (2012) + "Improved Inverse Scaling and Squaring Algorithms + for the Matrix Logarithm." + SIAM Journal on Scientific Computing, 34 (4). C152-C169. + ISSN 1095-7197 + + """ + if len(T0.shape) != 2 or T0.shape[0] != T0.shape[1]: + raise ValueError('expected an upper triangular square matrix') + n, n = T0.shape + T = T0 + + # Find s0, the smallest s such that the spectral radius + # of a certain diagonal matrix is at most theta[7]. + # Note that because theta[7] < 1, + # this search will not terminate if any diagonal entry of T is zero. + s0 = 0 + tmp_diag = np.diag(T) + if np.count_nonzero(tmp_diag) != n: + raise Exception('Diagonal entries of T must be nonzero') + while np.max(np.absolute(tmp_diag - 1)) > theta[7]: + tmp_diag = np.sqrt(tmp_diag) + s0 += 1 + + # Take matrix square roots of T. + for i in range(s0): + T = _sqrtm_triu(T) + + # Flow control in this section is a little odd. + # This is because I am translating algorithm descriptions + # which have GOTOs in the publication. + s = s0 + k = 0 + d2 = _onenormest_m1_power(T, 2) ** (1/2) + d3 = _onenormest_m1_power(T, 3) ** (1/3) + a2 = max(d2, d3) + m = None + for i in (1, 2): + if a2 <= theta[i]: + m = i + break + while m is None: + if s > s0: + d3 = _onenormest_m1_power(T, 3) ** (1/3) + d4 = _onenormest_m1_power(T, 4) ** (1/4) + a3 = max(d3, d4) + if a3 <= theta[7]: + j1 = min(i for i in (3, 4, 5, 6, 7) if a3 <= theta[i]) + if j1 <= 6: + m = j1 + break + elif a3 / 2 <= theta[5] and k < 2: + k += 1 + T = _sqrtm_triu(T) + s += 1 + continue + d5 = _onenormest_m1_power(T, 5) ** (1/5) + a4 = max(d4, d5) + eta = min(a3, a4) + for i in (6, 7): + if eta <= theta[i]: + m = i + break + if m is not None: + break + T = _sqrtm_triu(T) + s += 1 + + # The subtraction of the identity is redundant here, + # because the diagonal will be replaced for improved numerical accuracy, + # but this formulation should help clarify the meaning of R. + R = T - np.identity(n) + + # Replace the diagonal and first superdiagonal of T0^(1/(2^s)) - I + # using formulas that have less subtractive cancellation. + # Skip this step if the principal branch + # does not exist at T0; this happens when a diagonal entry of T0 + # is negative with imaginary part 0. + has_principal_branch = all(x.real > 0 or x.imag != 0 for x in np.diag(T0)) + if has_principal_branch: + for j in range(n): + a = T0[j, j] + r = _briggs_helper_function(a, s) + R[j, j] = r + p = np.exp2(-s) + for j in range(n-1): + l1 = T0[j, j] + l2 = T0[j+1, j+1] + t12 = T0[j, j+1] + f12 = _fractional_power_superdiag_entry(l1, l2, t12, p) + R[j, j+1] = f12 + + # Return the T-I matrix, the number of square roots, and the Pade degree. + if not np.array_equal(R, np.triu(R)): + raise Exception('R is not upper triangular') + return R, s, m + + +def _fractional_power_pade_constant(i, t): + # A helper function for matrix fractional power. + if i < 1: + raise ValueError('expected a positive integer i') + if not (-1 < t < 1): + raise ValueError('expected -1 < t < 1') + if i == 1: + return -t + elif i % 2 == 0: + j = i // 2 + return (-j + t) / (2 * (2*j - 1)) + elif i % 2 == 1: + j = (i - 1) // 2 + return (-j - t) / (2 * (2*j + 1)) + else: + raise Exception(f'unnexpected value of i, i = {i}') + + +def _fractional_power_pade(R, t, m): + """ + Evaluate the Pade approximation of a fractional matrix power. + + Evaluate the degree-m Pade approximation of R + to the fractional matrix power t using the continued fraction + in bottom-up fashion using algorithm (4.1) in [1]_. + + Parameters + ---------- + R : (N, N) array_like + Upper triangular matrix whose fractional power to evaluate. + t : float + Fractional power between -1 and 1 exclusive. + m : positive integer + Degree of Pade approximation. + + Returns + ------- + U : (N, N) array_like + The degree-m Pade approximation of R to the fractional power t. + This matrix will be upper triangular. + + References + ---------- + .. [1] Nicholas J. Higham and Lijing lin (2011) + "A Schur-Pade Algorithm for Fractional Powers of a Matrix." + SIAM Journal on Matrix Analysis and Applications, + 32 (3). pp. 1056-1078. ISSN 0895-4798 + + """ + if m < 1 or int(m) != m: + raise ValueError('expected a positive integer m') + if not (-1 < t < 1): + raise ValueError('expected -1 < t < 1') + R = np.asarray(R) + if len(R.shape) != 2 or R.shape[0] != R.shape[1]: + raise ValueError('expected an upper triangular square matrix') + n, n = R.shape + ident = np.identity(n) + Y = R * _fractional_power_pade_constant(2*m, t) + for j in range(2*m - 1, 0, -1): + rhs = R * _fractional_power_pade_constant(j, t) + Y = solve_triangular(ident + Y, rhs) + U = ident + Y + if not np.array_equal(U, np.triu(U)): + raise Exception('U is not upper triangular') + return U + + +def _remainder_matrix_power_triu(T, t): + """ + Compute a fractional power of an upper triangular matrix. + + The fractional power is restricted to fractions -1 < t < 1. + This uses algorithm (3.1) of [1]_. + The Pade approximation itself uses algorithm (4.1) of [2]_. + + Parameters + ---------- + T : (N, N) array_like + Upper triangular matrix whose fractional power to evaluate. + t : float + Fractional power between -1 and 1 exclusive. + + Returns + ------- + X : (N, N) array_like + The fractional power of the matrix. + + References + ---------- + .. [1] Nicholas J. Higham and Lijing Lin (2013) + "An Improved Schur-Pade Algorithm for Fractional Powers + of a Matrix and their Frechet Derivatives." + + .. [2] Nicholas J. Higham and Lijing lin (2011) + "A Schur-Pade Algorithm for Fractional Powers of a Matrix." + SIAM Journal on Matrix Analysis and Applications, + 32 (3). pp. 1056-1078. ISSN 0895-4798 + + """ + m_to_theta = { + 1: 1.51e-5, + 2: 2.24e-3, + 3: 1.88e-2, + 4: 6.04e-2, + 5: 1.24e-1, + 6: 2.00e-1, + 7: 2.79e-1, + } + n, n = T.shape + T0 = T + T0_diag = np.diag(T0) + if np.array_equal(T0, np.diag(T0_diag)): + U = np.diag(T0_diag ** t) + else: + R, s, m = _inverse_squaring_helper(T0, m_to_theta) + + # Evaluate the Pade approximation. + # Note that this function expects the negative of the matrix + # returned by the inverse squaring helper. + U = _fractional_power_pade(-R, t, m) + + # Undo the inverse scaling and squaring. + # Be less clever about this + # if the principal branch does not exist at T0; + # this happens when a diagonal entry of T0 + # is negative with imaginary part 0. + eivals = np.diag(T0) + has_principal_branch = all(x.real > 0 or x.imag != 0 for x in eivals) + for i in range(s, -1, -1): + if i < s: + U = U.dot(U) + else: + if has_principal_branch: + p = t * np.exp2(-i) + U[np.diag_indices(n)] = T0_diag ** p + for j in range(n-1): + l1 = T0[j, j] + l2 = T0[j+1, j+1] + t12 = T0[j, j+1] + f12 = _fractional_power_superdiag_entry(l1, l2, t12, p) + U[j, j+1] = f12 + if not np.array_equal(U, np.triu(U)): + raise Exception('U is not upper triangular') + return U + + +def _remainder_matrix_power(A, t): + """ + Compute the fractional power of a matrix, for fractions -1 < t < 1. + + This uses algorithm (3.1) of [1]_. + The Pade approximation itself uses algorithm (4.1) of [2]_. + + Parameters + ---------- + A : (N, N) array_like + Matrix whose fractional power to evaluate. + t : float + Fractional power between -1 and 1 exclusive. + + Returns + ------- + X : (N, N) array_like + The fractional power of the matrix. + + References + ---------- + .. [1] Nicholas J. Higham and Lijing Lin (2013) + "An Improved Schur-Pade Algorithm for Fractional Powers + of a Matrix and their Frechet Derivatives." + + .. [2] Nicholas J. Higham and Lijing lin (2011) + "A Schur-Pade Algorithm for Fractional Powers of a Matrix." + SIAM Journal on Matrix Analysis and Applications, + 32 (3). pp. 1056-1078. ISSN 0895-4798 + + """ + # This code block is copied from numpy.matrix_power(). + A = np.asarray(A) + if len(A.shape) != 2 or A.shape[0] != A.shape[1]: + raise ValueError('input must be a square array') + + # Get the number of rows and columns. + n, n = A.shape + + # Triangularize the matrix if necessary, + # attempting to preserve dtype if possible. + if np.array_equal(A, np.triu(A)): + Z = None + T = A + else: + if np.isrealobj(A): + T, Z = schur(A) + if not np.array_equal(T, np.triu(T)): + T, Z = rsf2csf(T, Z) + else: + T, Z = schur(A, output='complex') + + # Zeros on the diagonal of the triangular matrix are forbidden, + # because the inverse scaling and squaring cannot deal with it. + T_diag = np.diag(T) + if np.count_nonzero(T_diag) != n: + raise FractionalMatrixPowerError( + 'cannot use inverse scaling and squaring to find ' + 'the fractional matrix power of a singular matrix') + + # If the triangular matrix is real and has a negative + # entry on the diagonal, then force the matrix to be complex. + if np.isrealobj(T) and np.min(T_diag) < 0: + T = T.astype(complex) + + # Get the fractional power of the triangular matrix, + # and de-triangularize it if necessary. + U = _remainder_matrix_power_triu(T, t) + if Z is not None: + ZH = np.conjugate(Z).T + return Z.dot(U).dot(ZH) + else: + return U + + +def _fractional_matrix_power(A, p): + """ + Compute the fractional power of a matrix. + + See the fractional_matrix_power docstring in matfuncs.py for more info. + + """ + A = np.asarray(A) + if len(A.shape) != 2 or A.shape[0] != A.shape[1]: + raise ValueError('expected a square matrix') + if p == int(p): + return np.linalg.matrix_power(A, int(p)) + # Compute singular values. + s = svdvals(A) + # Inverse scaling and squaring cannot deal with a singular matrix, + # because the process of repeatedly taking square roots + # would not converge to the identity matrix. + if s[-1]: + # Compute the condition number relative to matrix inversion, + # and use this to decide between floor(p) and ceil(p). + k2 = s[0] / s[-1] + p1 = p - np.floor(p) + p2 = p - np.ceil(p) + if p1 * k2 ** (1 - p1) <= -p2 * k2: + a = int(np.floor(p)) + b = p1 + else: + a = int(np.ceil(p)) + b = p2 + try: + R = _remainder_matrix_power(A, b) + Q = np.linalg.matrix_power(A, a) + return Q.dot(R) + except np.linalg.LinAlgError: + pass + # If p is negative then we are going to give up. + # If p is non-negative then we can fall back to generic funm. + if p < 0: + X = np.empty_like(A) + X.fill(np.nan) + return X + else: + p1 = p - np.floor(p) + a = int(np.floor(p)) + b = p1 + R, info = funm(A, lambda x: pow(x, b), disp=False) + Q = np.linalg.matrix_power(A, a) + return Q.dot(R) + + +def _logm_triu(T): + """ + Compute matrix logarithm of an upper triangular matrix. + + The matrix logarithm is the inverse of + expm: expm(logm(`T`)) == `T` + + Parameters + ---------- + T : (N, N) array_like + Upper triangular matrix whose logarithm to evaluate + + Returns + ------- + logm : (N, N) ndarray + Matrix logarithm of `T` + + References + ---------- + .. [1] Awad H. Al-Mohy and Nicholas J. Higham (2012) + "Improved Inverse Scaling and Squaring Algorithms + for the Matrix Logarithm." + SIAM Journal on Scientific Computing, 34 (4). C152-C169. + ISSN 1095-7197 + + .. [2] Nicholas J. Higham (2008) + "Functions of Matrices: Theory and Computation" + ISBN 978-0-898716-46-7 + + .. [3] Nicholas J. Higham and Lijing lin (2011) + "A Schur-Pade Algorithm for Fractional Powers of a Matrix." + SIAM Journal on Matrix Analysis and Applications, + 32 (3). pp. 1056-1078. ISSN 0895-4798 + + """ + T = np.asarray(T) + if len(T.shape) != 2 or T.shape[0] != T.shape[1]: + raise ValueError('expected an upper triangular square matrix') + n, n = T.shape + + # Construct T0 with the appropriate type, + # depending on the dtype and the spectrum of T. + T_diag = np.diag(T) + keep_it_real = np.isrealobj(T) and np.min(T_diag) >= 0 + if keep_it_real: + T0 = T + else: + T0 = T.astype(complex) + + # Define bounds given in Table (2.1). + theta = (None, + 1.59e-5, 2.31e-3, 1.94e-2, 6.21e-2, + 1.28e-1, 2.06e-1, 2.88e-1, 3.67e-1, + 4.39e-1, 5.03e-1, 5.60e-1, 6.09e-1, + 6.52e-1, 6.89e-1, 7.21e-1, 7.49e-1) + + R, s, m = _inverse_squaring_helper(T0, theta) + + # Evaluate U = 2**s r_m(T - I) using the partial fraction expansion (1.1). + # This requires the nodes and weights + # corresponding to degree-m Gauss-Legendre quadrature. + # These quadrature arrays need to be transformed from the [-1, 1] interval + # to the [0, 1] interval. + nodes, weights = scipy.special.p_roots(m) + nodes = nodes.real + if nodes.shape != (m,) or weights.shape != (m,): + raise Exception('internal error') + nodes = 0.5 + 0.5 * nodes + weights = 0.5 * weights + ident = np.identity(n) + U = np.zeros_like(R) + for alpha, beta in zip(weights, nodes): + U += solve_triangular(ident + beta*R, alpha*R) + U *= np.exp2(s) + + # Skip this step if the principal branch + # does not exist at T0; this happens when a diagonal entry of T0 + # is negative with imaginary part 0. + has_principal_branch = all(x.real > 0 or x.imag != 0 for x in np.diag(T0)) + if has_principal_branch: + + # Recompute diagonal entries of U. + U[np.diag_indices(n)] = np.log(np.diag(T0)) + + # Recompute superdiagonal entries of U. + # This indexing of this code should be renovated + # when newer np.diagonal() becomes available. + for i in range(n-1): + l1 = T0[i, i] + l2 = T0[i+1, i+1] + t12 = T0[i, i+1] + U[i, i+1] = _logm_superdiag_entry(l1, l2, t12) + + # Return the logm of the upper triangular matrix. + if not np.array_equal(U, np.triu(U)): + raise Exception('U is not upper triangular') + return U + + +def _logm_force_nonsingular_triangular_matrix(T, inplace=False): + # The input matrix should be upper triangular. + # The eps is ad hoc and is not meant to be machine precision. + tri_eps = 1e-20 + abs_diag = np.absolute(np.diag(T)) + if np.any(abs_diag == 0): + exact_singularity_msg = 'The logm input matrix is exactly singular.' + warnings.warn(exact_singularity_msg, LogmExactlySingularWarning, stacklevel=3) + if not inplace: + T = T.copy() + n = T.shape[0] + for i in range(n): + if not T[i, i]: + T[i, i] = tri_eps + elif np.any(abs_diag < tri_eps): + near_singularity_msg = 'The logm input matrix may be nearly singular.' + warnings.warn(near_singularity_msg, LogmNearlySingularWarning, stacklevel=3) + return T + + +def _logm(A): + """ + Compute the matrix logarithm. + + See the logm docstring in matfuncs.py for more info. + + Notes + ----- + In this function we look at triangular matrices that are similar + to the input matrix. If any diagonal entry of such a triangular matrix + is exactly zero then the original matrix is singular. + The matrix logarithm does not exist for such matrices, + but in such cases we will pretend that the diagonal entries that are zero + are actually slightly positive by an ad-hoc amount, in the interest + of returning something more useful than NaN. This will cause a warning. + + """ + A = np.asarray(A) + if len(A.shape) != 2 or A.shape[0] != A.shape[1]: + raise ValueError('expected a square matrix') + + # If the input matrix dtype is integer then copy to a float dtype matrix. + if issubclass(A.dtype.type, np.integer): + A = np.asarray(A, dtype=float) + + keep_it_real = np.isrealobj(A) + try: + if np.array_equal(A, np.triu(A)): + A = _logm_force_nonsingular_triangular_matrix(A) + if np.min(np.diag(A)) < 0: + A = A.astype(complex) + return _logm_triu(A) + else: + if keep_it_real: + T, Z = schur(A) + if not np.array_equal(T, np.triu(T)): + T, Z = rsf2csf(T, Z) + else: + T, Z = schur(A, output='complex') + T = _logm_force_nonsingular_triangular_matrix(T, inplace=True) + U = _logm_triu(T) + ZH = np.conjugate(Z).T + return Z.dot(U).dot(ZH) + except (SqrtmError, LogmError): + X = np.empty_like(A) + X.fill(np.nan) + return X diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_matfuncs_sqrtm_triu.cpython-310-x86_64-linux-gnu.so b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_matfuncs_sqrtm_triu.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..74867d9cfeeba679bde114d3c863b70455a72185 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_matfuncs_sqrtm_triu.cpython-310-x86_64-linux-gnu.so differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_sketches.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_sketches.py new file mode 100644 index 0000000000000000000000000000000000000000..0cefc68637ee235fdd5132d3fc1362861493cc29 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_sketches.py @@ -0,0 +1,179 @@ +""" Sketching-based Matrix Computations """ + +# Author: Jordi Montes +# August 28, 2017 + +import numpy as np + +from scipy._lib._util import check_random_state, rng_integers +from scipy.sparse import csc_matrix + +__all__ = ['clarkson_woodruff_transform'] + + +def cwt_matrix(n_rows, n_columns, seed=None): + r""" + Generate a matrix S which represents a Clarkson-Woodruff transform. + + Given the desired size of matrix, the method returns a matrix S of size + (n_rows, n_columns) where each column has all the entries set to 0 + except for one position which has been randomly set to +1 or -1 with + equal probability. + + Parameters + ---------- + n_rows : int + Number of rows of S + n_columns : int + Number of columns of S + seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional + If `seed` is None (or `np.random`), the `numpy.random.RandomState` + singleton is used. + If `seed` is an int, a new ``RandomState`` instance is used, + seeded with `seed`. + If `seed` is already a ``Generator`` or ``RandomState`` instance then + that instance is used. + + Returns + ------- + S : (n_rows, n_columns) csc_matrix + The returned matrix has ``n_columns`` nonzero entries. + + Notes + ----- + Given a matrix A, with probability at least 9/10, + .. math:: \|SA\| = (1 \pm \epsilon)\|A\| + Where the error epsilon is related to the size of S. + """ + rng = check_random_state(seed) + rows = rng_integers(rng, 0, n_rows, n_columns) + cols = np.arange(n_columns+1) + signs = rng.choice([1, -1], n_columns) + S = csc_matrix((signs, rows, cols),shape=(n_rows, n_columns)) + return S + + +def clarkson_woodruff_transform(input_matrix, sketch_size, seed=None): + r""" + Applies a Clarkson-Woodruff Transform/sketch to the input matrix. + + Given an input_matrix ``A`` of size ``(n, d)``, compute a matrix ``A'`` of + size (sketch_size, d) so that + + .. math:: \|Ax\| \approx \|A'x\| + + with high probability via the Clarkson-Woodruff Transform, otherwise + known as the CountSketch matrix. + + Parameters + ---------- + input_matrix : array_like + Input matrix, of shape ``(n, d)``. + sketch_size : int + Number of rows for the sketch. + seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional + If `seed` is None (or `np.random`), the `numpy.random.RandomState` + singleton is used. + If `seed` is an int, a new ``RandomState`` instance is used, + seeded with `seed`. + If `seed` is already a ``Generator`` or ``RandomState`` instance then + that instance is used. + + Returns + ------- + A' : array_like + Sketch of the input matrix ``A``, of size ``(sketch_size, d)``. + + Notes + ----- + To make the statement + + .. math:: \|Ax\| \approx \|A'x\| + + precise, observe the following result which is adapted from the + proof of Theorem 14 of [2]_ via Markov's Inequality. If we have + a sketch size ``sketch_size=k`` which is at least + + .. math:: k \geq \frac{2}{\epsilon^2\delta} + + Then for any fixed vector ``x``, + + .. math:: \|Ax\| = (1\pm\epsilon)\|A'x\| + + with probability at least one minus delta. + + This implementation takes advantage of sparsity: computing + a sketch takes time proportional to ``A.nnz``. Data ``A`` which + is in ``scipy.sparse.csc_matrix`` format gives the quickest + computation time for sparse input. + + >>> import numpy as np + >>> from scipy import linalg + >>> from scipy import sparse + >>> rng = np.random.default_rng() + >>> n_rows, n_columns, density, sketch_n_rows = 15000, 100, 0.01, 200 + >>> A = sparse.rand(n_rows, n_columns, density=density, format='csc') + >>> B = sparse.rand(n_rows, n_columns, density=density, format='csr') + >>> C = sparse.rand(n_rows, n_columns, density=density, format='coo') + >>> D = rng.standard_normal((n_rows, n_columns)) + >>> SA = linalg.clarkson_woodruff_transform(A, sketch_n_rows) # fastest + >>> SB = linalg.clarkson_woodruff_transform(B, sketch_n_rows) # fast + >>> SC = linalg.clarkson_woodruff_transform(C, sketch_n_rows) # slower + >>> SD = linalg.clarkson_woodruff_transform(D, sketch_n_rows) # slowest + + That said, this method does perform well on dense inputs, just slower + on a relative scale. + + References + ---------- + .. [1] Kenneth L. Clarkson and David P. Woodruff. Low rank approximation + and regression in input sparsity time. In STOC, 2013. + .. [2] David P. Woodruff. Sketching as a tool for numerical linear algebra. + In Foundations and Trends in Theoretical Computer Science, 2014. + + Examples + -------- + Create a big dense matrix ``A`` for the example: + + >>> import numpy as np + >>> from scipy import linalg + >>> n_rows, n_columns = 15000, 100 + >>> rng = np.random.default_rng() + >>> A = rng.standard_normal((n_rows, n_columns)) + + Apply the transform to create a new matrix with 200 rows: + + >>> sketch_n_rows = 200 + >>> sketch = linalg.clarkson_woodruff_transform(A, sketch_n_rows, seed=rng) + >>> sketch.shape + (200, 100) + + Now with high probability, the true norm is close to the sketched norm + in absolute value. + + >>> linalg.norm(A) + 1224.2812927123198 + >>> linalg.norm(sketch) + 1226.518328407333 + + Similarly, applying our sketch preserves the solution to a linear + regression of :math:`\min \|Ax - b\|`. + + >>> b = rng.standard_normal(n_rows) + >>> x = linalg.lstsq(A, b)[0] + >>> Ab = np.hstack((A, b.reshape(-1, 1))) + >>> SAb = linalg.clarkson_woodruff_transform(Ab, sketch_n_rows, seed=rng) + >>> SA, Sb = SAb[:, :-1], SAb[:, -1] + >>> x_sketched = linalg.lstsq(SA, Sb)[0] + + As with the matrix norm example, ``linalg.norm(A @ x - b)`` is close + to ``linalg.norm(A @ x_sketched - b)`` with high probability. + + >>> linalg.norm(A @ x - b) + 122.83242365433877 + >>> linalg.norm(A @ x_sketched - b) + 166.58473879945151 + + """ + S = cwt_matrix(sketch_size, input_matrix.shape[0], seed) + return S.dot(input_matrix) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_solve_toeplitz.cpython-310-x86_64-linux-gnu.so b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_solve_toeplitz.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..d5e5e62eb6543ac6f056bdc80a8d914350a9b0d0 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_solve_toeplitz.cpython-310-x86_64-linux-gnu.so differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_solvers.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_solvers.py new file mode 100644 index 0000000000000000000000000000000000000000..36da31c9a23957cbc08c493ae37000dca6fc0719 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_solvers.py @@ -0,0 +1,846 @@ +"""Matrix equation solver routines""" +# Author: Jeffrey Armstrong +# February 24, 2012 + +# Modified: Chad Fulton +# June 19, 2014 + +# Modified: Ilhan Polat +# September 13, 2016 + +import warnings +import numpy as np +from numpy.linalg import inv, LinAlgError, norm, cond, svd + +from ._basic import solve, solve_triangular, matrix_balance +from .lapack import get_lapack_funcs +from ._decomp_schur import schur +from ._decomp_lu import lu +from ._decomp_qr import qr +from ._decomp_qz import ordqz +from ._decomp import _asarray_validated +from ._special_matrices import kron, block_diag + +__all__ = ['solve_sylvester', + 'solve_continuous_lyapunov', 'solve_discrete_lyapunov', + 'solve_lyapunov', + 'solve_continuous_are', 'solve_discrete_are'] + + +def solve_sylvester(a, b, q): + """ + Computes a solution (X) to the Sylvester equation :math:`AX + XB = Q`. + + Parameters + ---------- + a : (M, M) array_like + Leading matrix of the Sylvester equation + b : (N, N) array_like + Trailing matrix of the Sylvester equation + q : (M, N) array_like + Right-hand side + + Returns + ------- + x : (M, N) ndarray + The solution to the Sylvester equation. + + Raises + ------ + LinAlgError + If solution was not found + + Notes + ----- + Computes a solution to the Sylvester matrix equation via the Bartels- + Stewart algorithm. The A and B matrices first undergo Schur + decompositions. The resulting matrices are used to construct an + alternative Sylvester equation (``RY + YS^T = F``) where the R and S + matrices are in quasi-triangular form (or, when R, S or F are complex, + triangular form). The simplified equation is then solved using + ``*TRSYL`` from LAPACK directly. + + .. versionadded:: 0.11.0 + + Examples + -------- + Given `a`, `b`, and `q` solve for `x`: + + >>> import numpy as np + >>> from scipy import linalg + >>> a = np.array([[-3, -2, 0], [-1, -1, 3], [3, -5, -1]]) + >>> b = np.array([[1]]) + >>> q = np.array([[1],[2],[3]]) + >>> x = linalg.solve_sylvester(a, b, q) + >>> x + array([[ 0.0625], + [-0.5625], + [ 0.6875]]) + >>> np.allclose(a.dot(x) + x.dot(b), q) + True + + """ + + # Compute the Schur decomposition form of a + r, u = schur(a, output='real') + + # Compute the Schur decomposition of b + s, v = schur(b.conj().transpose(), output='real') + + # Construct f = u'*q*v + f = np.dot(np.dot(u.conj().transpose(), q), v) + + # Call the Sylvester equation solver + trsyl, = get_lapack_funcs(('trsyl',), (r, s, f)) + if trsyl is None: + raise RuntimeError('LAPACK implementation does not contain a proper ' + 'Sylvester equation solver (TRSYL)') + y, scale, info = trsyl(r, s, f, tranb='C') + + y = scale*y + + if info < 0: + raise LinAlgError("Illegal value encountered in " + "the %d term" % (-info,)) + + return np.dot(np.dot(u, y), v.conj().transpose()) + + +def solve_continuous_lyapunov(a, q): + """ + Solves the continuous Lyapunov equation :math:`AX + XA^H = Q`. + + Uses the Bartels-Stewart algorithm to find :math:`X`. + + Parameters + ---------- + a : array_like + A square matrix + + q : array_like + Right-hand side square matrix + + Returns + ------- + x : ndarray + Solution to the continuous Lyapunov equation + + See Also + -------- + solve_discrete_lyapunov : computes the solution to the discrete-time + Lyapunov equation + solve_sylvester : computes the solution to the Sylvester equation + + Notes + ----- + The continuous Lyapunov equation is a special form of the Sylvester + equation, hence this solver relies on LAPACK routine ?TRSYL. + + .. versionadded:: 0.11.0 + + Examples + -------- + Given `a` and `q` solve for `x`: + + >>> import numpy as np + >>> from scipy import linalg + >>> a = np.array([[-3, -2, 0], [-1, -1, 0], [0, -5, -1]]) + >>> b = np.array([2, 4, -1]) + >>> q = np.eye(3) + >>> x = linalg.solve_continuous_lyapunov(a, q) + >>> x + array([[ -0.75 , 0.875 , -3.75 ], + [ 0.875 , -1.375 , 5.3125], + [ -3.75 , 5.3125, -27.0625]]) + >>> np.allclose(a.dot(x) + x.dot(a.T), q) + True + """ + + a = np.atleast_2d(_asarray_validated(a, check_finite=True)) + q = np.atleast_2d(_asarray_validated(q, check_finite=True)) + + r_or_c = float + + for ind, _ in enumerate((a, q)): + if np.iscomplexobj(_): + r_or_c = complex + + if not np.equal(*_.shape): + raise ValueError("Matrix {} should be square.".format("aq"[ind])) + + # Shape consistency check + if a.shape != q.shape: + raise ValueError("Matrix a and q should have the same shape.") + + # Compute the Schur decomposition form of a + r, u = schur(a, output='real') + + # Construct f = u'*q*u + f = u.conj().T.dot(q.dot(u)) + + # Call the Sylvester equation solver + trsyl = get_lapack_funcs('trsyl', (r, f)) + + dtype_string = 'T' if r_or_c == float else 'C' + y, scale, info = trsyl(r, r, f, tranb=dtype_string) + + if info < 0: + raise ValueError('?TRSYL exited with the internal error ' + f'"illegal value in argument number {-info}.". See ' + 'LAPACK documentation for the ?TRSYL error codes.') + elif info == 1: + warnings.warn('Input "a" has an eigenvalue pair whose sum is ' + 'very close to or exactly zero. The solution is ' + 'obtained via perturbing the coefficients.', + RuntimeWarning, stacklevel=2) + y *= scale + + return u.dot(y).dot(u.conj().T) + + +# For backwards compatibility, keep the old name +solve_lyapunov = solve_continuous_lyapunov + + +def _solve_discrete_lyapunov_direct(a, q): + """ + Solves the discrete Lyapunov equation directly. + + This function is called by the `solve_discrete_lyapunov` function with + `method=direct`. It is not supposed to be called directly. + """ + + lhs = kron(a, a.conj()) + lhs = np.eye(lhs.shape[0]) - lhs + x = solve(lhs, q.flatten()) + + return np.reshape(x, q.shape) + + +def _solve_discrete_lyapunov_bilinear(a, q): + """ + Solves the discrete Lyapunov equation using a bilinear transformation. + + This function is called by the `solve_discrete_lyapunov` function with + `method=bilinear`. It is not supposed to be called directly. + """ + eye = np.eye(a.shape[0]) + aH = a.conj().transpose() + aHI_inv = inv(aH + eye) + b = np.dot(aH - eye, aHI_inv) + c = 2*np.dot(np.dot(inv(a + eye), q), aHI_inv) + return solve_lyapunov(b.conj().transpose(), -c) + + +def solve_discrete_lyapunov(a, q, method=None): + """ + Solves the discrete Lyapunov equation :math:`AXA^H - X + Q = 0`. + + Parameters + ---------- + a, q : (M, M) array_like + Square matrices corresponding to A and Q in the equation + above respectively. Must have the same shape. + + method : {'direct', 'bilinear'}, optional + Type of solver. + + If not given, chosen to be ``direct`` if ``M`` is less than 10 and + ``bilinear`` otherwise. + + Returns + ------- + x : ndarray + Solution to the discrete Lyapunov equation + + See Also + -------- + solve_continuous_lyapunov : computes the solution to the continuous-time + Lyapunov equation + + Notes + ----- + This section describes the available solvers that can be selected by the + 'method' parameter. The default method is *direct* if ``M`` is less than 10 + and ``bilinear`` otherwise. + + Method *direct* uses a direct analytical solution to the discrete Lyapunov + equation. The algorithm is given in, for example, [1]_. However, it requires + the linear solution of a system with dimension :math:`M^2` so that + performance degrades rapidly for even moderately sized matrices. + + Method *bilinear* uses a bilinear transformation to convert the discrete + Lyapunov equation to a continuous Lyapunov equation :math:`(BX+XB'=-C)` + where :math:`B=(A-I)(A+I)^{-1}` and + :math:`C=2(A' + I)^{-1} Q (A + I)^{-1}`. The continuous equation can be + efficiently solved since it is a special case of a Sylvester equation. + The transformation algorithm is from Popov (1964) as described in [2]_. + + .. versionadded:: 0.11.0 + + References + ---------- + .. [1] Hamilton, James D. Time Series Analysis, Princeton: Princeton + University Press, 1994. 265. Print. + http://doc1.lbfl.li/aca/FLMF037168.pdf + .. [2] Gajic, Z., and M.T.J. Qureshi. 2008. + Lyapunov Matrix Equation in System Stability and Control. + Dover Books on Engineering Series. Dover Publications. + + Examples + -------- + Given `a` and `q` solve for `x`: + + >>> import numpy as np + >>> from scipy import linalg + >>> a = np.array([[0.2, 0.5],[0.7, -0.9]]) + >>> q = np.eye(2) + >>> x = linalg.solve_discrete_lyapunov(a, q) + >>> x + array([[ 0.70872893, 1.43518822], + [ 1.43518822, -2.4266315 ]]) + >>> np.allclose(a.dot(x).dot(a.T)-x, -q) + True + + """ + a = np.asarray(a) + q = np.asarray(q) + if method is None: + # Select automatically based on size of matrices + if a.shape[0] >= 10: + method = 'bilinear' + else: + method = 'direct' + + meth = method.lower() + + if meth == 'direct': + x = _solve_discrete_lyapunov_direct(a, q) + elif meth == 'bilinear': + x = _solve_discrete_lyapunov_bilinear(a, q) + else: + raise ValueError('Unknown solver %s' % method) + + return x + + +def solve_continuous_are(a, b, q, r, e=None, s=None, balanced=True): + r""" + Solves the continuous-time algebraic Riccati equation (CARE). + + The CARE is defined as + + .. math:: + + X A + A^H X - X B R^{-1} B^H X + Q = 0 + + The limitations for a solution to exist are : + + * All eigenvalues of :math:`A` on the right half plane, should be + controllable. + + * The associated hamiltonian pencil (See Notes), should have + eigenvalues sufficiently away from the imaginary axis. + + Moreover, if ``e`` or ``s`` is not precisely ``None``, then the + generalized version of CARE + + .. math:: + + E^HXA + A^HXE - (E^HXB + S) R^{-1} (B^HXE + S^H) + Q = 0 + + is solved. When omitted, ``e`` is assumed to be the identity and ``s`` + is assumed to be the zero matrix with sizes compatible with ``a`` and + ``b``, respectively. + + Parameters + ---------- + a : (M, M) array_like + Square matrix + b : (M, N) array_like + Input + q : (M, M) array_like + Input + r : (N, N) array_like + Nonsingular square matrix + e : (M, M) array_like, optional + Nonsingular square matrix + s : (M, N) array_like, optional + Input + balanced : bool, optional + The boolean that indicates whether a balancing step is performed + on the data. The default is set to True. + + Returns + ------- + x : (M, M) ndarray + Solution to the continuous-time algebraic Riccati equation. + + Raises + ------ + LinAlgError + For cases where the stable subspace of the pencil could not be + isolated. See Notes section and the references for details. + + See Also + -------- + solve_discrete_are : Solves the discrete-time algebraic Riccati equation + + Notes + ----- + The equation is solved by forming the extended hamiltonian matrix pencil, + as described in [1]_, :math:`H - \lambda J` given by the block matrices :: + + [ A 0 B ] [ E 0 0 ] + [-Q -A^H -S ] - \lambda * [ 0 E^H 0 ] + [ S^H B^H R ] [ 0 0 0 ] + + and using a QZ decomposition method. + + In this algorithm, the fail conditions are linked to the symmetry + of the product :math:`U_2 U_1^{-1}` and condition number of + :math:`U_1`. Here, :math:`U` is the 2m-by-m matrix that holds the + eigenvectors spanning the stable subspace with 2-m rows and partitioned + into two m-row matrices. See [1]_ and [2]_ for more details. + + In order to improve the QZ decomposition accuracy, the pencil goes + through a balancing step where the sum of absolute values of + :math:`H` and :math:`J` entries (after removing the diagonal entries of + the sum) is balanced following the recipe given in [3]_. + + .. versionadded:: 0.11.0 + + References + ---------- + .. [1] P. van Dooren , "A Generalized Eigenvalue Approach For Solving + Riccati Equations.", SIAM Journal on Scientific and Statistical + Computing, Vol.2(2), :doi:`10.1137/0902010` + + .. [2] A.J. Laub, "A Schur Method for Solving Algebraic Riccati + Equations.", Massachusetts Institute of Technology. Laboratory for + Information and Decision Systems. LIDS-R ; 859. Available online : + http://hdl.handle.net/1721.1/1301 + + .. [3] P. Benner, "Symplectic Balancing of Hamiltonian Matrices", 2001, + SIAM J. Sci. Comput., 2001, Vol.22(5), :doi:`10.1137/S1064827500367993` + + Examples + -------- + Given `a`, `b`, `q`, and `r` solve for `x`: + + >>> import numpy as np + >>> from scipy import linalg + >>> a = np.array([[4, 3], [-4.5, -3.5]]) + >>> b = np.array([[1], [-1]]) + >>> q = np.array([[9, 6], [6, 4.]]) + >>> r = 1 + >>> x = linalg.solve_continuous_are(a, b, q, r) + >>> x + array([[ 21.72792206, 14.48528137], + [ 14.48528137, 9.65685425]]) + >>> np.allclose(a.T.dot(x) + x.dot(a)-x.dot(b).dot(b.T).dot(x), -q) + True + + """ + + # Validate input arguments + a, b, q, r, e, s, m, n, r_or_c, gen_are = _are_validate_args( + a, b, q, r, e, s, 'care') + + H = np.empty((2*m+n, 2*m+n), dtype=r_or_c) + H[:m, :m] = a + H[:m, m:2*m] = 0. + H[:m, 2*m:] = b + H[m:2*m, :m] = -q + H[m:2*m, m:2*m] = -a.conj().T + H[m:2*m, 2*m:] = 0. if s is None else -s + H[2*m:, :m] = 0. if s is None else s.conj().T + H[2*m:, m:2*m] = b.conj().T + H[2*m:, 2*m:] = r + + if gen_are and e is not None: + J = block_diag(e, e.conj().T, np.zeros_like(r, dtype=r_or_c)) + else: + J = block_diag(np.eye(2*m), np.zeros_like(r, dtype=r_or_c)) + + if balanced: + # xGEBAL does not remove the diagonals before scaling. Also + # to avoid destroying the Symplectic structure, we follow Ref.3 + M = np.abs(H) + np.abs(J) + np.fill_diagonal(M, 0.) + _, (sca, _) = matrix_balance(M, separate=1, permute=0) + # do we need to bother? + if not np.allclose(sca, np.ones_like(sca)): + # Now impose diag(D,inv(D)) from Benner where D is + # square root of s_i/s_(n+i) for i=0,.... + sca = np.log2(sca) + # NOTE: Py3 uses "Bankers Rounding: round to the nearest even" !! + s = np.round((sca[m:2*m] - sca[:m])/2) + sca = 2 ** np.r_[s, -s, sca[2*m:]] + # Elementwise multiplication via broadcasting. + elwisescale = sca[:, None] * np.reciprocal(sca) + H *= elwisescale + J *= elwisescale + + # Deflate the pencil to 2m x 2m ala Ref.1, eq.(55) + q, r = qr(H[:, -n:]) + H = q[:, n:].conj().T.dot(H[:, :2*m]) + J = q[:2*m, n:].conj().T.dot(J[:2*m, :2*m]) + + # Decide on which output type is needed for QZ + out_str = 'real' if r_or_c == float else 'complex' + + _, _, _, _, _, u = ordqz(H, J, sort='lhp', overwrite_a=True, + overwrite_b=True, check_finite=False, + output=out_str) + + # Get the relevant parts of the stable subspace basis + if e is not None: + u, _ = qr(np.vstack((e.dot(u[:m, :m]), u[m:, :m]))) + u00 = u[:m, :m] + u10 = u[m:, :m] + + # Solve via back-substituion after checking the condition of u00 + up, ul, uu = lu(u00) + if 1/cond(uu) < np.spacing(1.): + raise LinAlgError('Failed to find a finite solution.') + + # Exploit the triangular structure + x = solve_triangular(ul.conj().T, + solve_triangular(uu.conj().T, + u10.conj().T, + lower=True), + unit_diagonal=True, + ).conj().T.dot(up.conj().T) + if balanced: + x *= sca[:m, None] * sca[:m] + + # Check the deviation from symmetry for lack of success + # See proof of Thm.5 item 3 in [2] + u_sym = u00.conj().T.dot(u10) + n_u_sym = norm(u_sym, 1) + u_sym = u_sym - u_sym.conj().T + sym_threshold = np.max([np.spacing(1000.), 0.1*n_u_sym]) + + if norm(u_sym, 1) > sym_threshold: + raise LinAlgError('The associated Hamiltonian pencil has eigenvalues ' + 'too close to the imaginary axis') + + return (x + x.conj().T)/2 + + +def solve_discrete_are(a, b, q, r, e=None, s=None, balanced=True): + r""" + Solves the discrete-time algebraic Riccati equation (DARE). + + The DARE is defined as + + .. math:: + + A^HXA - X - (A^HXB) (R + B^HXB)^{-1} (B^HXA) + Q = 0 + + The limitations for a solution to exist are : + + * All eigenvalues of :math:`A` outside the unit disc, should be + controllable. + + * The associated symplectic pencil (See Notes), should have + eigenvalues sufficiently away from the unit circle. + + Moreover, if ``e`` and ``s`` are not both precisely ``None``, then the + generalized version of DARE + + .. math:: + + A^HXA - E^HXE - (A^HXB+S) (R+B^HXB)^{-1} (B^HXA+S^H) + Q = 0 + + is solved. When omitted, ``e`` is assumed to be the identity and ``s`` + is assumed to be the zero matrix. + + Parameters + ---------- + a : (M, M) array_like + Square matrix + b : (M, N) array_like + Input + q : (M, M) array_like + Input + r : (N, N) array_like + Square matrix + e : (M, M) array_like, optional + Nonsingular square matrix + s : (M, N) array_like, optional + Input + balanced : bool + The boolean that indicates whether a balancing step is performed + on the data. The default is set to True. + + Returns + ------- + x : (M, M) ndarray + Solution to the discrete algebraic Riccati equation. + + Raises + ------ + LinAlgError + For cases where the stable subspace of the pencil could not be + isolated. See Notes section and the references for details. + + See Also + -------- + solve_continuous_are : Solves the continuous algebraic Riccati equation + + Notes + ----- + The equation is solved by forming the extended symplectic matrix pencil, + as described in [1]_, :math:`H - \lambda J` given by the block matrices :: + + [ A 0 B ] [ E 0 B ] + [ -Q E^H -S ] - \lambda * [ 0 A^H 0 ] + [ S^H 0 R ] [ 0 -B^H 0 ] + + and using a QZ decomposition method. + + In this algorithm, the fail conditions are linked to the symmetry + of the product :math:`U_2 U_1^{-1}` and condition number of + :math:`U_1`. Here, :math:`U` is the 2m-by-m matrix that holds the + eigenvectors spanning the stable subspace with 2-m rows and partitioned + into two m-row matrices. See [1]_ and [2]_ for more details. + + In order to improve the QZ decomposition accuracy, the pencil goes + through a balancing step where the sum of absolute values of + :math:`H` and :math:`J` rows/cols (after removing the diagonal entries) + is balanced following the recipe given in [3]_. If the data has small + numerical noise, balancing may amplify their effects and some clean up + is required. + + .. versionadded:: 0.11.0 + + References + ---------- + .. [1] P. van Dooren , "A Generalized Eigenvalue Approach For Solving + Riccati Equations.", SIAM Journal on Scientific and Statistical + Computing, Vol.2(2), :doi:`10.1137/0902010` + + .. [2] A.J. Laub, "A Schur Method for Solving Algebraic Riccati + Equations.", Massachusetts Institute of Technology. Laboratory for + Information and Decision Systems. LIDS-R ; 859. Available online : + http://hdl.handle.net/1721.1/1301 + + .. [3] P. Benner, "Symplectic Balancing of Hamiltonian Matrices", 2001, + SIAM J. Sci. Comput., 2001, Vol.22(5), :doi:`10.1137/S1064827500367993` + + Examples + -------- + Given `a`, `b`, `q`, and `r` solve for `x`: + + >>> import numpy as np + >>> from scipy import linalg as la + >>> a = np.array([[0, 1], [0, -1]]) + >>> b = np.array([[1, 0], [2, 1]]) + >>> q = np.array([[-4, -4], [-4, 7]]) + >>> r = np.array([[9, 3], [3, 1]]) + >>> x = la.solve_discrete_are(a, b, q, r) + >>> x + array([[-4., -4.], + [-4., 7.]]) + >>> R = la.solve(r + b.T.dot(x).dot(b), b.T.dot(x).dot(a)) + >>> np.allclose(a.T.dot(x).dot(a) - x - a.T.dot(x).dot(b).dot(R), -q) + True + + """ + + # Validate input arguments + a, b, q, r, e, s, m, n, r_or_c, gen_are = _are_validate_args( + a, b, q, r, e, s, 'dare') + + # Form the matrix pencil + H = np.zeros((2*m+n, 2*m+n), dtype=r_or_c) + H[:m, :m] = a + H[:m, 2*m:] = b + H[m:2*m, :m] = -q + H[m:2*m, m:2*m] = np.eye(m) if e is None else e.conj().T + H[m:2*m, 2*m:] = 0. if s is None else -s + H[2*m:, :m] = 0. if s is None else s.conj().T + H[2*m:, 2*m:] = r + + J = np.zeros_like(H, dtype=r_or_c) + J[:m, :m] = np.eye(m) if e is None else e + J[m:2*m, m:2*m] = a.conj().T + J[2*m:, m:2*m] = -b.conj().T + + if balanced: + # xGEBAL does not remove the diagonals before scaling. Also + # to avoid destroying the Symplectic structure, we follow Ref.3 + M = np.abs(H) + np.abs(J) + np.fill_diagonal(M, 0.) + _, (sca, _) = matrix_balance(M, separate=1, permute=0) + # do we need to bother? + if not np.allclose(sca, np.ones_like(sca)): + # Now impose diag(D,inv(D)) from Benner where D is + # square root of s_i/s_(n+i) for i=0,.... + sca = np.log2(sca) + # NOTE: Py3 uses "Bankers Rounding: round to the nearest even" !! + s = np.round((sca[m:2*m] - sca[:m])/2) + sca = 2 ** np.r_[s, -s, sca[2*m:]] + # Elementwise multiplication via broadcasting. + elwisescale = sca[:, None] * np.reciprocal(sca) + H *= elwisescale + J *= elwisescale + + # Deflate the pencil by the R column ala Ref.1 + q_of_qr, _ = qr(H[:, -n:]) + H = q_of_qr[:, n:].conj().T.dot(H[:, :2*m]) + J = q_of_qr[:, n:].conj().T.dot(J[:, :2*m]) + + # Decide on which output type is needed for QZ + out_str = 'real' if r_or_c == float else 'complex' + + _, _, _, _, _, u = ordqz(H, J, sort='iuc', + overwrite_a=True, + overwrite_b=True, + check_finite=False, + output=out_str) + + # Get the relevant parts of the stable subspace basis + if e is not None: + u, _ = qr(np.vstack((e.dot(u[:m, :m]), u[m:, :m]))) + u00 = u[:m, :m] + u10 = u[m:, :m] + + # Solve via back-substituion after checking the condition of u00 + up, ul, uu = lu(u00) + + if 1/cond(uu) < np.spacing(1.): + raise LinAlgError('Failed to find a finite solution.') + + # Exploit the triangular structure + x = solve_triangular(ul.conj().T, + solve_triangular(uu.conj().T, + u10.conj().T, + lower=True), + unit_diagonal=True, + ).conj().T.dot(up.conj().T) + if balanced: + x *= sca[:m, None] * sca[:m] + + # Check the deviation from symmetry for lack of success + # See proof of Thm.5 item 3 in [2] + u_sym = u00.conj().T.dot(u10) + n_u_sym = norm(u_sym, 1) + u_sym = u_sym - u_sym.conj().T + sym_threshold = np.max([np.spacing(1000.), 0.1*n_u_sym]) + + if norm(u_sym, 1) > sym_threshold: + raise LinAlgError('The associated symplectic pencil has eigenvalues ' + 'too close to the unit circle') + + return (x + x.conj().T)/2 + + +def _are_validate_args(a, b, q, r, e, s, eq_type='care'): + """ + A helper function to validate the arguments supplied to the + Riccati equation solvers. Any discrepancy found in the input + matrices leads to a ``ValueError`` exception. + + Essentially, it performs: + + - a check whether the input is free of NaN and Infs + - a pass for the data through ``numpy.atleast_2d()`` + - squareness check of the relevant arrays + - shape consistency check of the arrays + - singularity check of the relevant arrays + - symmetricity check of the relevant matrices + - a check whether the regular or the generalized version is asked. + + This function is used by ``solve_continuous_are`` and + ``solve_discrete_are``. + + Parameters + ---------- + a, b, q, r, e, s : array_like + Input data + eq_type : str + Accepted arguments are 'care' and 'dare'. + + Returns + ------- + a, b, q, r, e, s : ndarray + Regularized input data + m, n : int + shape of the problem + r_or_c : type + Data type of the problem, returns float or complex + gen_or_not : bool + Type of the equation, True for generalized and False for regular ARE. + + """ + + if eq_type.lower() not in ("dare", "care"): + raise ValueError("Equation type unknown. " + "Only 'care' and 'dare' is understood") + + a = np.atleast_2d(_asarray_validated(a, check_finite=True)) + b = np.atleast_2d(_asarray_validated(b, check_finite=True)) + q = np.atleast_2d(_asarray_validated(q, check_finite=True)) + r = np.atleast_2d(_asarray_validated(r, check_finite=True)) + + # Get the correct data types otherwise NumPy complains + # about pushing complex numbers into real arrays. + r_or_c = complex if np.iscomplexobj(b) else float + + for ind, mat in enumerate((a, q, r)): + if np.iscomplexobj(mat): + r_or_c = complex + + if not np.equal(*mat.shape): + raise ValueError("Matrix {} should be square.".format("aqr"[ind])) + + # Shape consistency checks + m, n = b.shape + if m != a.shape[0]: + raise ValueError("Matrix a and b should have the same number of rows.") + if m != q.shape[0]: + raise ValueError("Matrix a and q should have the same shape.") + if n != r.shape[0]: + raise ValueError("Matrix b and r should have the same number of cols.") + + # Check if the data matrices q, r are (sufficiently) hermitian + for ind, mat in enumerate((q, r)): + if norm(mat - mat.conj().T, 1) > np.spacing(norm(mat, 1))*100: + raise ValueError("Matrix {} should be symmetric/hermitian." + "".format("qr"[ind])) + + # Continuous time ARE should have a nonsingular r matrix. + if eq_type == 'care': + min_sv = svd(r, compute_uv=False)[-1] + if min_sv == 0. or min_sv < np.spacing(1.)*norm(r, 1): + raise ValueError('Matrix r is numerically singular.') + + # Check if the generalized case is required with omitted arguments + # perform late shape checking etc. + generalized_case = e is not None or s is not None + + if generalized_case: + if e is not None: + e = np.atleast_2d(_asarray_validated(e, check_finite=True)) + if not np.equal(*e.shape): + raise ValueError("Matrix e should be square.") + if m != e.shape[0]: + raise ValueError("Matrix a and e should have the same shape.") + # numpy.linalg.cond doesn't check for exact zeros and + # emits a runtime warning. Hence the following manual check. + min_sv = svd(e, compute_uv=False)[-1] + if min_sv == 0. or min_sv < np.spacing(1.) * norm(e, 1): + raise ValueError('Matrix e is numerically singular.') + if np.iscomplexobj(e): + r_or_c = complex + if s is not None: + s = np.atleast_2d(_asarray_validated(s, check_finite=True)) + if s.shape != b.shape: + raise ValueError("Matrix b and s should have the same shape.") + if np.iscomplexobj(s): + r_or_c = complex + + return a, b, q, r, e, s, m, n, r_or_c, generalized_case diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_testutils.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_testutils.py new file mode 100644 index 0000000000000000000000000000000000000000..6aa6b47296f72fbbc54ed10116505ea93622b1f9 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/_testutils.py @@ -0,0 +1,63 @@ +import numpy as np + + +class _FakeMatrix: + def __init__(self, data): + self._data = data + self.__array_interface__ = data.__array_interface__ + + +class _FakeMatrix2: + def __init__(self, data): + self._data = data + + def __array__(self, dtype=None, copy=None): + return self._data + + +def _get_array(shape, dtype): + """ + Get a test array of given shape and data type. + Returned NxN matrices are posdef, and 2xN are banded-posdef. + + """ + if len(shape) == 2 and shape[0] == 2: + # yield a banded positive definite one + x = np.zeros(shape, dtype=dtype) + x[0, 1:] = -1 + x[1] = 2 + return x + elif len(shape) == 2 and shape[0] == shape[1]: + # always yield a positive definite matrix + x = np.zeros(shape, dtype=dtype) + j = np.arange(shape[0]) + x[j, j] = 2 + x[j[:-1], j[:-1]+1] = -1 + x[j[:-1]+1, j[:-1]] = -1 + return x + else: + np.random.seed(1234) + return np.random.randn(*shape).astype(dtype) + + +def _id(x): + return x + + +def assert_no_overwrite(call, shapes, dtypes=None): + """ + Test that a call does not overwrite its input arguments + """ + + if dtypes is None: + dtypes = [np.float32, np.float64, np.complex64, np.complex128] + + for dtype in dtypes: + for order in ["C", "F"]: + for faker in [_id, _FakeMatrix, _FakeMatrix2]: + orig_inputs = [_get_array(s, dtype) for s in shapes] + inputs = [faker(x.copy(order)) for x in orig_inputs] + call(*inputs) + msg = f"call modified inputs [{dtype!r}, {faker!r}]" + for a, b in zip(inputs, orig_inputs): + np.testing.assert_equal(a, b, err_msg=msg) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_blas.pxd b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_blas.pxd new file mode 100644 index 0000000000000000000000000000000000000000..7ed44f6ea8611f926e3ea5fd2670446cdf9b398c --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_blas.pxd @@ -0,0 +1,169 @@ +""" +This file was generated by _generate_pyx.py. +Do not edit this file directly. +""" + +# Within scipy, these wrappers can be used via relative or absolute cimport. +# Examples: +# from ..linalg cimport cython_blas +# from scipy.linalg cimport cython_blas +# cimport scipy.linalg.cython_blas as cython_blas +# cimport ..linalg.cython_blas as cython_blas + +# Within SciPy, if BLAS functions are needed in C/C++/Fortran, +# these wrappers should not be used. +# The original libraries should be linked directly. + +ctypedef float s +ctypedef double d +ctypedef float complex c +ctypedef double complex z + +cdef void caxpy(int *n, c *ca, c *cx, int *incx, c *cy, int *incy) noexcept nogil +cdef void ccopy(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil +cdef c cdotc(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil +cdef c cdotu(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil +cdef void cgbmv(char *trans, int *m, int *n, int *kl, int *ku, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil +cdef void cgemm(char *transa, char *transb, int *m, int *n, int *k, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil +cdef void cgemv(char *trans, int *m, int *n, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil +cdef void cgerc(int *m, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *a, int *lda) noexcept nogil +cdef void cgeru(int *m, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *a, int *lda) noexcept nogil +cdef void chbmv(char *uplo, int *n, int *k, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil +cdef void chemm(char *side, char *uplo, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil +cdef void chemv(char *uplo, int *n, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil +cdef void cher(char *uplo, int *n, s *alpha, c *x, int *incx, c *a, int *lda) noexcept nogil +cdef void cher2(char *uplo, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *a, int *lda) noexcept nogil +cdef void cher2k(char *uplo, char *trans, int *n, int *k, c *alpha, c *a, int *lda, c *b, int *ldb, s *beta, c *c, int *ldc) noexcept nogil +cdef void cherk(char *uplo, char *trans, int *n, int *k, s *alpha, c *a, int *lda, s *beta, c *c, int *ldc) noexcept nogil +cdef void chpmv(char *uplo, int *n, c *alpha, c *ap, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil +cdef void chpr(char *uplo, int *n, s *alpha, c *x, int *incx, c *ap) noexcept nogil +cdef void chpr2(char *uplo, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *ap) noexcept nogil +cdef void crotg(c *ca, c *cb, s *c, c *s) noexcept nogil +cdef void cscal(int *n, c *ca, c *cx, int *incx) noexcept nogil +cdef void csrot(int *n, c *cx, int *incx, c *cy, int *incy, s *c, s *s) noexcept nogil +cdef void csscal(int *n, s *sa, c *cx, int *incx) noexcept nogil +cdef void cswap(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil +cdef void csymm(char *side, char *uplo, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil +cdef void csyr2k(char *uplo, char *trans, int *n, int *k, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil +cdef void csyrk(char *uplo, char *trans, int *n, int *k, c *alpha, c *a, int *lda, c *beta, c *c, int *ldc) noexcept nogil +cdef void ctbmv(char *uplo, char *trans, char *diag, int *n, int *k, c *a, int *lda, c *x, int *incx) noexcept nogil +cdef void ctbsv(char *uplo, char *trans, char *diag, int *n, int *k, c *a, int *lda, c *x, int *incx) noexcept nogil +cdef void ctpmv(char *uplo, char *trans, char *diag, int *n, c *ap, c *x, int *incx) noexcept nogil +cdef void ctpsv(char *uplo, char *trans, char *diag, int *n, c *ap, c *x, int *incx) noexcept nogil +cdef void ctrmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb) noexcept nogil +cdef void ctrmv(char *uplo, char *trans, char *diag, int *n, c *a, int *lda, c *x, int *incx) noexcept nogil +cdef void ctrsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb) noexcept nogil +cdef void ctrsv(char *uplo, char *trans, char *diag, int *n, c *a, int *lda, c *x, int *incx) noexcept nogil +cdef d dasum(int *n, d *dx, int *incx) noexcept nogil +cdef void daxpy(int *n, d *da, d *dx, int *incx, d *dy, int *incy) noexcept nogil +cdef d dcabs1(z *z) noexcept nogil +cdef void dcopy(int *n, d *dx, int *incx, d *dy, int *incy) noexcept nogil +cdef d ddot(int *n, d *dx, int *incx, d *dy, int *incy) noexcept nogil +cdef void dgbmv(char *trans, int *m, int *n, int *kl, int *ku, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil +cdef void dgemm(char *transa, char *transb, int *m, int *n, int *k, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) noexcept nogil +cdef void dgemv(char *trans, int *m, int *n, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil +cdef void dger(int *m, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *a, int *lda) noexcept nogil +cdef d dnrm2(int *n, d *x, int *incx) noexcept nogil +cdef void drot(int *n, d *dx, int *incx, d *dy, int *incy, d *c, d *s) noexcept nogil +cdef void drotg(d *da, d *db, d *c, d *s) noexcept nogil +cdef void drotm(int *n, d *dx, int *incx, d *dy, int *incy, d *dparam) noexcept nogil +cdef void drotmg(d *dd1, d *dd2, d *dx1, d *dy1, d *dparam) noexcept nogil +cdef void dsbmv(char *uplo, int *n, int *k, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil +cdef void dscal(int *n, d *da, d *dx, int *incx) noexcept nogil +cdef d dsdot(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil +cdef void dspmv(char *uplo, int *n, d *alpha, d *ap, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil +cdef void dspr(char *uplo, int *n, d *alpha, d *x, int *incx, d *ap) noexcept nogil +cdef void dspr2(char *uplo, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *ap) noexcept nogil +cdef void dswap(int *n, d *dx, int *incx, d *dy, int *incy) noexcept nogil +cdef void dsymm(char *side, char *uplo, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) noexcept nogil +cdef void dsymv(char *uplo, int *n, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil +cdef void dsyr(char *uplo, int *n, d *alpha, d *x, int *incx, d *a, int *lda) noexcept nogil +cdef void dsyr2(char *uplo, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *a, int *lda) noexcept nogil +cdef void dsyr2k(char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) noexcept nogil +cdef void dsyrk(char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *beta, d *c, int *ldc) noexcept nogil +cdef void dtbmv(char *uplo, char *trans, char *diag, int *n, int *k, d *a, int *lda, d *x, int *incx) noexcept nogil +cdef void dtbsv(char *uplo, char *trans, char *diag, int *n, int *k, d *a, int *lda, d *x, int *incx) noexcept nogil +cdef void dtpmv(char *uplo, char *trans, char *diag, int *n, d *ap, d *x, int *incx) noexcept nogil +cdef void dtpsv(char *uplo, char *trans, char *diag, int *n, d *ap, d *x, int *incx) noexcept nogil +cdef void dtrmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb) noexcept nogil +cdef void dtrmv(char *uplo, char *trans, char *diag, int *n, d *a, int *lda, d *x, int *incx) noexcept nogil +cdef void dtrsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb) noexcept nogil +cdef void dtrsv(char *uplo, char *trans, char *diag, int *n, d *a, int *lda, d *x, int *incx) noexcept nogil +cdef d dzasum(int *n, z *zx, int *incx) noexcept nogil +cdef d dznrm2(int *n, z *x, int *incx) noexcept nogil +cdef int icamax(int *n, c *cx, int *incx) noexcept nogil +cdef int idamax(int *n, d *dx, int *incx) noexcept nogil +cdef int isamax(int *n, s *sx, int *incx) noexcept nogil +cdef int izamax(int *n, z *zx, int *incx) noexcept nogil +cdef bint lsame(char *ca, char *cb) noexcept nogil +cdef s sasum(int *n, s *sx, int *incx) noexcept nogil +cdef void saxpy(int *n, s *sa, s *sx, int *incx, s *sy, int *incy) noexcept nogil +cdef s scasum(int *n, c *cx, int *incx) noexcept nogil +cdef s scnrm2(int *n, c *x, int *incx) noexcept nogil +cdef void scopy(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil +cdef s sdot(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil +cdef s sdsdot(int *n, s *sb, s *sx, int *incx, s *sy, int *incy) noexcept nogil +cdef void sgbmv(char *trans, int *m, int *n, int *kl, int *ku, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil +cdef void sgemm(char *transa, char *transb, int *m, int *n, int *k, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) noexcept nogil +cdef void sgemv(char *trans, int *m, int *n, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil +cdef void sger(int *m, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *a, int *lda) noexcept nogil +cdef s snrm2(int *n, s *x, int *incx) noexcept nogil +cdef void srot(int *n, s *sx, int *incx, s *sy, int *incy, s *c, s *s) noexcept nogil +cdef void srotg(s *sa, s *sb, s *c, s *s) noexcept nogil +cdef void srotm(int *n, s *sx, int *incx, s *sy, int *incy, s *sparam) noexcept nogil +cdef void srotmg(s *sd1, s *sd2, s *sx1, s *sy1, s *sparam) noexcept nogil +cdef void ssbmv(char *uplo, int *n, int *k, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil +cdef void sscal(int *n, s *sa, s *sx, int *incx) noexcept nogil +cdef void sspmv(char *uplo, int *n, s *alpha, s *ap, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil +cdef void sspr(char *uplo, int *n, s *alpha, s *x, int *incx, s *ap) noexcept nogil +cdef void sspr2(char *uplo, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *ap) noexcept nogil +cdef void sswap(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil +cdef void ssymm(char *side, char *uplo, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) noexcept nogil +cdef void ssymv(char *uplo, int *n, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil +cdef void ssyr(char *uplo, int *n, s *alpha, s *x, int *incx, s *a, int *lda) noexcept nogil +cdef void ssyr2(char *uplo, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *a, int *lda) noexcept nogil +cdef void ssyr2k(char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) noexcept nogil +cdef void ssyrk(char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *beta, s *c, int *ldc) noexcept nogil +cdef void stbmv(char *uplo, char *trans, char *diag, int *n, int *k, s *a, int *lda, s *x, int *incx) noexcept nogil +cdef void stbsv(char *uplo, char *trans, char *diag, int *n, int *k, s *a, int *lda, s *x, int *incx) noexcept nogil +cdef void stpmv(char *uplo, char *trans, char *diag, int *n, s *ap, s *x, int *incx) noexcept nogil +cdef void stpsv(char *uplo, char *trans, char *diag, int *n, s *ap, s *x, int *incx) noexcept nogil +cdef void strmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb) noexcept nogil +cdef void strmv(char *uplo, char *trans, char *diag, int *n, s *a, int *lda, s *x, int *incx) noexcept nogil +cdef void strsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb) noexcept nogil +cdef void strsv(char *uplo, char *trans, char *diag, int *n, s *a, int *lda, s *x, int *incx) noexcept nogil +cdef void zaxpy(int *n, z *za, z *zx, int *incx, z *zy, int *incy) noexcept nogil +cdef void zcopy(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil +cdef z zdotc(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil +cdef z zdotu(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil +cdef void zdrot(int *n, z *cx, int *incx, z *cy, int *incy, d *c, d *s) noexcept nogil +cdef void zdscal(int *n, d *da, z *zx, int *incx) noexcept nogil +cdef void zgbmv(char *trans, int *m, int *n, int *kl, int *ku, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil +cdef void zgemm(char *transa, char *transb, int *m, int *n, int *k, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil +cdef void zgemv(char *trans, int *m, int *n, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil +cdef void zgerc(int *m, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *a, int *lda) noexcept nogil +cdef void zgeru(int *m, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *a, int *lda) noexcept nogil +cdef void zhbmv(char *uplo, int *n, int *k, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil +cdef void zhemm(char *side, char *uplo, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil +cdef void zhemv(char *uplo, int *n, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil +cdef void zher(char *uplo, int *n, d *alpha, z *x, int *incx, z *a, int *lda) noexcept nogil +cdef void zher2(char *uplo, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *a, int *lda) noexcept nogil +cdef void zher2k(char *uplo, char *trans, int *n, int *k, z *alpha, z *a, int *lda, z *b, int *ldb, d *beta, z *c, int *ldc) noexcept nogil +cdef void zherk(char *uplo, char *trans, int *n, int *k, d *alpha, z *a, int *lda, d *beta, z *c, int *ldc) noexcept nogil +cdef void zhpmv(char *uplo, int *n, z *alpha, z *ap, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil +cdef void zhpr(char *uplo, int *n, d *alpha, z *x, int *incx, z *ap) noexcept nogil +cdef void zhpr2(char *uplo, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *ap) noexcept nogil +cdef void zrotg(z *ca, z *cb, d *c, z *s) noexcept nogil +cdef void zscal(int *n, z *za, z *zx, int *incx) noexcept nogil +cdef void zswap(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil +cdef void zsymm(char *side, char *uplo, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil +cdef void zsyr2k(char *uplo, char *trans, int *n, int *k, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil +cdef void zsyrk(char *uplo, char *trans, int *n, int *k, z *alpha, z *a, int *lda, z *beta, z *c, int *ldc) noexcept nogil +cdef void ztbmv(char *uplo, char *trans, char *diag, int *n, int *k, z *a, int *lda, z *x, int *incx) noexcept nogil +cdef void ztbsv(char *uplo, char *trans, char *diag, int *n, int *k, z *a, int *lda, z *x, int *incx) noexcept nogil +cdef void ztpmv(char *uplo, char *trans, char *diag, int *n, z *ap, z *x, int *incx) noexcept nogil +cdef void ztpsv(char *uplo, char *trans, char *diag, int *n, z *ap, z *x, int *incx) noexcept nogil +cdef void ztrmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb) noexcept nogil +cdef void ztrmv(char *uplo, char *trans, char *diag, int *n, z *a, int *lda, z *x, int *incx) noexcept nogil +cdef void ztrsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb) noexcept nogil +cdef void ztrsv(char *uplo, char *trans, char *diag, int *n, z *a, int *lda, z *x, int *incx) noexcept nogil diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_blas.pyx b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_blas.pyx new file mode 100644 index 0000000000000000000000000000000000000000..86207f95fc7278d66a550c807609d9edd5706cdc --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_blas.pyx @@ -0,0 +1,1422 @@ +# This file was generated by _generate_pyx.py. +# Do not edit this file directly. +# cython: boundscheck = False +# cython: wraparound = False +# cython: cdivision = True + +""" +BLAS Functions for Cython +========================= + +Usable from Cython via:: + + cimport scipy.linalg.cython_blas + +These wrappers do not check for alignment of arrays. +Alignment should be checked before these wrappers are used. + +Raw function pointers (Fortran-style pointer arguments): + +- caxpy +- ccopy +- cdotc +- cdotu +- cgbmv +- cgemm +- cgemv +- cgerc +- cgeru +- chbmv +- chemm +- chemv +- cher +- cher2 +- cher2k +- cherk +- chpmv +- chpr +- chpr2 +- crotg +- cscal +- csrot +- csscal +- cswap +- csymm +- csyr2k +- csyrk +- ctbmv +- ctbsv +- ctpmv +- ctpsv +- ctrmm +- ctrmv +- ctrsm +- ctrsv +- dasum +- daxpy +- dcabs1 +- dcopy +- ddot +- dgbmv +- dgemm +- dgemv +- dger +- dnrm2 +- drot +- drotg +- drotm +- drotmg +- dsbmv +- dscal +- dsdot +- dspmv +- dspr +- dspr2 +- dswap +- dsymm +- dsymv +- dsyr +- dsyr2 +- dsyr2k +- dsyrk +- dtbmv +- dtbsv +- dtpmv +- dtpsv +- dtrmm +- dtrmv +- dtrsm +- dtrsv +- dzasum +- dznrm2 +- icamax +- idamax +- isamax +- izamax +- lsame +- sasum +- saxpy +- scasum +- scnrm2 +- scopy +- sdot +- sdsdot +- sgbmv +- sgemm +- sgemv +- sger +- snrm2 +- srot +- srotg +- srotm +- srotmg +- ssbmv +- sscal +- sspmv +- sspr +- sspr2 +- sswap +- ssymm +- ssymv +- ssyr +- ssyr2 +- ssyr2k +- ssyrk +- stbmv +- stbsv +- stpmv +- stpsv +- strmm +- strmv +- strsm +- strsv +- zaxpy +- zcopy +- zdotc +- zdotu +- zdrot +- zdscal +- zgbmv +- zgemm +- zgemv +- zgerc +- zgeru +- zhbmv +- zhemm +- zhemv +- zher +- zher2 +- zher2k +- zherk +- zhpmv +- zhpr +- zhpr2 +- zrotg +- zscal +- zswap +- zsymm +- zsyr2k +- zsyrk +- ztbmv +- ztbsv +- ztpmv +- ztpsv +- ztrmm +- ztrmv +- ztrsm +- ztrsv + + +""" + +# Within SciPy, these wrappers can be used via relative or absolute cimport. +# Examples: +# from ..linalg cimport cython_blas +# from scipy.linalg cimport cython_blas +# cimport scipy.linalg.cython_blas as cython_blas +# cimport ..linalg.cython_blas as cython_blas + +# Within SciPy, if BLAS functions are needed in C/C++/Fortran, +# these wrappers should not be used. +# The original libraries should be linked directly. + +cdef extern from "fortran_defs.h": + pass + +from numpy cimport npy_complex64, npy_complex128 + + +cdef extern from "_blas_subroutines.h": + void _fortran_caxpy "BLAS_FUNC(caxpy)"(int *n, npy_complex64 *ca, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy) nogil +cdef void caxpy(int *n, c *ca, c *cx, int *incx, c *cy, int *incy) noexcept nogil: + + _fortran_caxpy(n, ca, cx, incx, cy, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ccopy "BLAS_FUNC(ccopy)"(int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy) nogil +cdef void ccopy(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil: + + _fortran_ccopy(n, cx, incx, cy, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_cdotc "(cdotcwrp_)"(npy_complex64 *out, int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy) nogil +cdef c cdotc(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil: + cdef c out + _fortran_cdotc(&out, n, cx, incx, cy, incy) + return out + +cdef extern from "_blas_subroutines.h": + void _fortran_cdotu "(cdotuwrp_)"(npy_complex64 *out, int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy) nogil +cdef c cdotu(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil: + cdef c out + _fortran_cdotu(&out, n, cx, incx, cy, incy) + return out + +cdef extern from "_blas_subroutines.h": + void _fortran_cgbmv "BLAS_FUNC(cgbmv)"(char *trans, int *m, int *n, int *kl, int *ku, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil +cdef void cgbmv(char *trans, int *m, int *n, int *kl, int *ku, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil: + + _fortran_cgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_cgemm "BLAS_FUNC(cgemm)"(char *transa, char *transb, int *m, int *n, int *k, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *beta, npy_complex64 *c, int *ldc) nogil +cdef void cgemm(char *transa, char *transb, int *m, int *n, int *k, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil: + + _fortran_cgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_cgemv "BLAS_FUNC(cgemv)"(char *trans, int *m, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil +cdef void cgemv(char *trans, int *m, int *n, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil: + + _fortran_cgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_cgerc "BLAS_FUNC(cgerc)"(int *m, int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *y, int *incy, npy_complex64 *a, int *lda) nogil +cdef void cgerc(int *m, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *a, int *lda) noexcept nogil: + + _fortran_cgerc(m, n, alpha, x, incx, y, incy, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_cgeru "BLAS_FUNC(cgeru)"(int *m, int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *y, int *incy, npy_complex64 *a, int *lda) nogil +cdef void cgeru(int *m, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *a, int *lda) noexcept nogil: + + _fortran_cgeru(m, n, alpha, x, incx, y, incy, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_chbmv "BLAS_FUNC(chbmv)"(char *uplo, int *n, int *k, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil +cdef void chbmv(char *uplo, int *n, int *k, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil: + + _fortran_chbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_chemm "BLAS_FUNC(chemm)"(char *side, char *uplo, int *m, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *beta, npy_complex64 *c, int *ldc) nogil +cdef void chemm(char *side, char *uplo, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil: + + _fortran_chemm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_chemv "BLAS_FUNC(chemv)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil +cdef void chemv(char *uplo, int *n, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil: + + _fortran_chemv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_cher "BLAS_FUNC(cher)"(char *uplo, int *n, s *alpha, npy_complex64 *x, int *incx, npy_complex64 *a, int *lda) nogil +cdef void cher(char *uplo, int *n, s *alpha, c *x, int *incx, c *a, int *lda) noexcept nogil: + + _fortran_cher(uplo, n, alpha, x, incx, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_cher2 "BLAS_FUNC(cher2)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *y, int *incy, npy_complex64 *a, int *lda) nogil +cdef void cher2(char *uplo, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *a, int *lda) noexcept nogil: + + _fortran_cher2(uplo, n, alpha, x, incx, y, incy, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_cher2k "BLAS_FUNC(cher2k)"(char *uplo, char *trans, int *n, int *k, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, s *beta, npy_complex64 *c, int *ldc) nogil +cdef void cher2k(char *uplo, char *trans, int *n, int *k, c *alpha, c *a, int *lda, c *b, int *ldb, s *beta, c *c, int *ldc) noexcept nogil: + + _fortran_cher2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_cherk "BLAS_FUNC(cherk)"(char *uplo, char *trans, int *n, int *k, s *alpha, npy_complex64 *a, int *lda, s *beta, npy_complex64 *c, int *ldc) nogil +cdef void cherk(char *uplo, char *trans, int *n, int *k, s *alpha, c *a, int *lda, s *beta, c *c, int *ldc) noexcept nogil: + + _fortran_cherk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_chpmv "BLAS_FUNC(chpmv)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *ap, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil +cdef void chpmv(char *uplo, int *n, c *alpha, c *ap, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil: + + _fortran_chpmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_chpr "BLAS_FUNC(chpr)"(char *uplo, int *n, s *alpha, npy_complex64 *x, int *incx, npy_complex64 *ap) nogil +cdef void chpr(char *uplo, int *n, s *alpha, c *x, int *incx, c *ap) noexcept nogil: + + _fortran_chpr(uplo, n, alpha, x, incx, ap) + + +cdef extern from "_blas_subroutines.h": + void _fortran_chpr2 "BLAS_FUNC(chpr2)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *y, int *incy, npy_complex64 *ap) nogil +cdef void chpr2(char *uplo, int *n, c *alpha, c *x, int *incx, c *y, int *incy, c *ap) noexcept nogil: + + _fortran_chpr2(uplo, n, alpha, x, incx, y, incy, ap) + + +cdef extern from "_blas_subroutines.h": + void _fortran_crotg "BLAS_FUNC(crotg)"(npy_complex64 *ca, npy_complex64 *cb, s *c, npy_complex64 *s) nogil +cdef void crotg(c *ca, c *cb, s *c, c *s) noexcept nogil: + + _fortran_crotg(ca, cb, c, s) + + +cdef extern from "_blas_subroutines.h": + void _fortran_cscal "BLAS_FUNC(cscal)"(int *n, npy_complex64 *ca, npy_complex64 *cx, int *incx) nogil +cdef void cscal(int *n, c *ca, c *cx, int *incx) noexcept nogil: + + _fortran_cscal(n, ca, cx, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_csrot "BLAS_FUNC(csrot)"(int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy, s *c, s *s) nogil +cdef void csrot(int *n, c *cx, int *incx, c *cy, int *incy, s *c, s *s) noexcept nogil: + + _fortran_csrot(n, cx, incx, cy, incy, c, s) + + +cdef extern from "_blas_subroutines.h": + void _fortran_csscal "BLAS_FUNC(csscal)"(int *n, s *sa, npy_complex64 *cx, int *incx) nogil +cdef void csscal(int *n, s *sa, c *cx, int *incx) noexcept nogil: + + _fortran_csscal(n, sa, cx, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_cswap "BLAS_FUNC(cswap)"(int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy) nogil +cdef void cswap(int *n, c *cx, int *incx, c *cy, int *incy) noexcept nogil: + + _fortran_cswap(n, cx, incx, cy, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_csymm "BLAS_FUNC(csymm)"(char *side, char *uplo, int *m, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *beta, npy_complex64 *c, int *ldc) nogil +cdef void csymm(char *side, char *uplo, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil: + + _fortran_csymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_csyr2k "BLAS_FUNC(csyr2k)"(char *uplo, char *trans, int *n, int *k, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *beta, npy_complex64 *c, int *ldc) nogil +cdef void csyr2k(char *uplo, char *trans, int *n, int *k, c *alpha, c *a, int *lda, c *b, int *ldb, c *beta, c *c, int *ldc) noexcept nogil: + + _fortran_csyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_csyrk "BLAS_FUNC(csyrk)"(char *uplo, char *trans, int *n, int *k, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *beta, npy_complex64 *c, int *ldc) nogil +cdef void csyrk(char *uplo, char *trans, int *n, int *k, c *alpha, c *a, int *lda, c *beta, c *c, int *ldc) noexcept nogil: + + _fortran_csyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ctbmv "BLAS_FUNC(ctbmv)"(char *uplo, char *trans, char *diag, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx) nogil +cdef void ctbmv(char *uplo, char *trans, char *diag, int *n, int *k, c *a, int *lda, c *x, int *incx) noexcept nogil: + + _fortran_ctbmv(uplo, trans, diag, n, k, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ctbsv "BLAS_FUNC(ctbsv)"(char *uplo, char *trans, char *diag, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx) nogil +cdef void ctbsv(char *uplo, char *trans, char *diag, int *n, int *k, c *a, int *lda, c *x, int *incx) noexcept nogil: + + _fortran_ctbsv(uplo, trans, diag, n, k, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ctpmv "BLAS_FUNC(ctpmv)"(char *uplo, char *trans, char *diag, int *n, npy_complex64 *ap, npy_complex64 *x, int *incx) nogil +cdef void ctpmv(char *uplo, char *trans, char *diag, int *n, c *ap, c *x, int *incx) noexcept nogil: + + _fortran_ctpmv(uplo, trans, diag, n, ap, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ctpsv "BLAS_FUNC(ctpsv)"(char *uplo, char *trans, char *diag, int *n, npy_complex64 *ap, npy_complex64 *x, int *incx) nogil +cdef void ctpsv(char *uplo, char *trans, char *diag, int *n, c *ap, c *x, int *incx) noexcept nogil: + + _fortran_ctpsv(uplo, trans, diag, n, ap, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ctrmm "BLAS_FUNC(ctrmm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb) nogil +cdef void ctrmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb) noexcept nogil: + + _fortran_ctrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ctrmv "BLAS_FUNC(ctrmv)"(char *uplo, char *trans, char *diag, int *n, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx) nogil +cdef void ctrmv(char *uplo, char *trans, char *diag, int *n, c *a, int *lda, c *x, int *incx) noexcept nogil: + + _fortran_ctrmv(uplo, trans, diag, n, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ctrsm "BLAS_FUNC(ctrsm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb) nogil +cdef void ctrsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, c *alpha, c *a, int *lda, c *b, int *ldb) noexcept nogil: + + _fortran_ctrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ctrsv "BLAS_FUNC(ctrsv)"(char *uplo, char *trans, char *diag, int *n, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx) nogil +cdef void ctrsv(char *uplo, char *trans, char *diag, int *n, c *a, int *lda, c *x, int *incx) noexcept nogil: + + _fortran_ctrsv(uplo, trans, diag, n, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + d _fortran_dasum "BLAS_FUNC(dasum)"(int *n, d *dx, int *incx) nogil +cdef d dasum(int *n, d *dx, int *incx) noexcept nogil: + + return _fortran_dasum(n, dx, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_daxpy "BLAS_FUNC(daxpy)"(int *n, d *da, d *dx, int *incx, d *dy, int *incy) nogil +cdef void daxpy(int *n, d *da, d *dx, int *incx, d *dy, int *incy) noexcept nogil: + + _fortran_daxpy(n, da, dx, incx, dy, incy) + + +cdef extern from "_blas_subroutines.h": + d _fortran_dcabs1 "BLAS_FUNC(dcabs1)"(npy_complex128 *z) nogil +cdef d dcabs1(z *z) noexcept nogil: + + return _fortran_dcabs1(z) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dcopy "BLAS_FUNC(dcopy)"(int *n, d *dx, int *incx, d *dy, int *incy) nogil +cdef void dcopy(int *n, d *dx, int *incx, d *dy, int *incy) noexcept nogil: + + _fortran_dcopy(n, dx, incx, dy, incy) + + +cdef extern from "_blas_subroutines.h": + d _fortran_ddot "BLAS_FUNC(ddot)"(int *n, d *dx, int *incx, d *dy, int *incy) nogil +cdef d ddot(int *n, d *dx, int *incx, d *dy, int *incy) noexcept nogil: + + return _fortran_ddot(n, dx, incx, dy, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dgbmv "BLAS_FUNC(dgbmv)"(char *trans, int *m, int *n, int *kl, int *ku, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) nogil +cdef void dgbmv(char *trans, int *m, int *n, int *kl, int *ku, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil: + + _fortran_dgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dgemm "BLAS_FUNC(dgemm)"(char *transa, char *transb, int *m, int *n, int *k, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) nogil +cdef void dgemm(char *transa, char *transb, int *m, int *n, int *k, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) noexcept nogil: + + _fortran_dgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dgemv "BLAS_FUNC(dgemv)"(char *trans, int *m, int *n, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) nogil +cdef void dgemv(char *trans, int *m, int *n, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil: + + _fortran_dgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dger "BLAS_FUNC(dger)"(int *m, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *a, int *lda) nogil +cdef void dger(int *m, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *a, int *lda) noexcept nogil: + + _fortran_dger(m, n, alpha, x, incx, y, incy, a, lda) + + +cdef extern from "_blas_subroutines.h": + d _fortran_dnrm2 "BLAS_FUNC(dnrm2)"(int *n, d *x, int *incx) nogil +cdef d dnrm2(int *n, d *x, int *incx) noexcept nogil: + + return _fortran_dnrm2(n, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_drot "BLAS_FUNC(drot)"(int *n, d *dx, int *incx, d *dy, int *incy, d *c, d *s) nogil +cdef void drot(int *n, d *dx, int *incx, d *dy, int *incy, d *c, d *s) noexcept nogil: + + _fortran_drot(n, dx, incx, dy, incy, c, s) + + +cdef extern from "_blas_subroutines.h": + void _fortran_drotg "BLAS_FUNC(drotg)"(d *da, d *db, d *c, d *s) nogil +cdef void drotg(d *da, d *db, d *c, d *s) noexcept nogil: + + _fortran_drotg(da, db, c, s) + + +cdef extern from "_blas_subroutines.h": + void _fortran_drotm "BLAS_FUNC(drotm)"(int *n, d *dx, int *incx, d *dy, int *incy, d *dparam) nogil +cdef void drotm(int *n, d *dx, int *incx, d *dy, int *incy, d *dparam) noexcept nogil: + + _fortran_drotm(n, dx, incx, dy, incy, dparam) + + +cdef extern from "_blas_subroutines.h": + void _fortran_drotmg "BLAS_FUNC(drotmg)"(d *dd1, d *dd2, d *dx1, d *dy1, d *dparam) nogil +cdef void drotmg(d *dd1, d *dd2, d *dx1, d *dy1, d *dparam) noexcept nogil: + + _fortran_drotmg(dd1, dd2, dx1, dy1, dparam) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dsbmv "BLAS_FUNC(dsbmv)"(char *uplo, int *n, int *k, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) nogil +cdef void dsbmv(char *uplo, int *n, int *k, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil: + + _fortran_dsbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dscal "BLAS_FUNC(dscal)"(int *n, d *da, d *dx, int *incx) nogil +cdef void dscal(int *n, d *da, d *dx, int *incx) noexcept nogil: + + _fortran_dscal(n, da, dx, incx) + + +cdef extern from "_blas_subroutines.h": + d _fortran_dsdot "BLAS_FUNC(dsdot)"(int *n, s *sx, int *incx, s *sy, int *incy) nogil +cdef d dsdot(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil: + + return _fortran_dsdot(n, sx, incx, sy, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dspmv "BLAS_FUNC(dspmv)"(char *uplo, int *n, d *alpha, d *ap, d *x, int *incx, d *beta, d *y, int *incy) nogil +cdef void dspmv(char *uplo, int *n, d *alpha, d *ap, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil: + + _fortran_dspmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dspr "BLAS_FUNC(dspr)"(char *uplo, int *n, d *alpha, d *x, int *incx, d *ap) nogil +cdef void dspr(char *uplo, int *n, d *alpha, d *x, int *incx, d *ap) noexcept nogil: + + _fortran_dspr(uplo, n, alpha, x, incx, ap) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dspr2 "BLAS_FUNC(dspr2)"(char *uplo, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *ap) nogil +cdef void dspr2(char *uplo, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *ap) noexcept nogil: + + _fortran_dspr2(uplo, n, alpha, x, incx, y, incy, ap) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dswap "BLAS_FUNC(dswap)"(int *n, d *dx, int *incx, d *dy, int *incy) nogil +cdef void dswap(int *n, d *dx, int *incx, d *dy, int *incy) noexcept nogil: + + _fortran_dswap(n, dx, incx, dy, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dsymm "BLAS_FUNC(dsymm)"(char *side, char *uplo, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) nogil +cdef void dsymm(char *side, char *uplo, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) noexcept nogil: + + _fortran_dsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dsymv "BLAS_FUNC(dsymv)"(char *uplo, int *n, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) nogil +cdef void dsymv(char *uplo, int *n, d *alpha, d *a, int *lda, d *x, int *incx, d *beta, d *y, int *incy) noexcept nogil: + + _fortran_dsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dsyr "BLAS_FUNC(dsyr)"(char *uplo, int *n, d *alpha, d *x, int *incx, d *a, int *lda) nogil +cdef void dsyr(char *uplo, int *n, d *alpha, d *x, int *incx, d *a, int *lda) noexcept nogil: + + _fortran_dsyr(uplo, n, alpha, x, incx, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dsyr2 "BLAS_FUNC(dsyr2)"(char *uplo, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *a, int *lda) nogil +cdef void dsyr2(char *uplo, int *n, d *alpha, d *x, int *incx, d *y, int *incy, d *a, int *lda) noexcept nogil: + + _fortran_dsyr2(uplo, n, alpha, x, incx, y, incy, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dsyr2k "BLAS_FUNC(dsyr2k)"(char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) nogil +cdef void dsyr2k(char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *b, int *ldb, d *beta, d *c, int *ldc) noexcept nogil: + + _fortran_dsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dsyrk "BLAS_FUNC(dsyrk)"(char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *beta, d *c, int *ldc) nogil +cdef void dsyrk(char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *beta, d *c, int *ldc) noexcept nogil: + + _fortran_dsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dtbmv "BLAS_FUNC(dtbmv)"(char *uplo, char *trans, char *diag, int *n, int *k, d *a, int *lda, d *x, int *incx) nogil +cdef void dtbmv(char *uplo, char *trans, char *diag, int *n, int *k, d *a, int *lda, d *x, int *incx) noexcept nogil: + + _fortran_dtbmv(uplo, trans, diag, n, k, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dtbsv "BLAS_FUNC(dtbsv)"(char *uplo, char *trans, char *diag, int *n, int *k, d *a, int *lda, d *x, int *incx) nogil +cdef void dtbsv(char *uplo, char *trans, char *diag, int *n, int *k, d *a, int *lda, d *x, int *incx) noexcept nogil: + + _fortran_dtbsv(uplo, trans, diag, n, k, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dtpmv "BLAS_FUNC(dtpmv)"(char *uplo, char *trans, char *diag, int *n, d *ap, d *x, int *incx) nogil +cdef void dtpmv(char *uplo, char *trans, char *diag, int *n, d *ap, d *x, int *incx) noexcept nogil: + + _fortran_dtpmv(uplo, trans, diag, n, ap, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dtpsv "BLAS_FUNC(dtpsv)"(char *uplo, char *trans, char *diag, int *n, d *ap, d *x, int *incx) nogil +cdef void dtpsv(char *uplo, char *trans, char *diag, int *n, d *ap, d *x, int *incx) noexcept nogil: + + _fortran_dtpsv(uplo, trans, diag, n, ap, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dtrmm "BLAS_FUNC(dtrmm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb) nogil +cdef void dtrmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb) noexcept nogil: + + _fortran_dtrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dtrmv "BLAS_FUNC(dtrmv)"(char *uplo, char *trans, char *diag, int *n, d *a, int *lda, d *x, int *incx) nogil +cdef void dtrmv(char *uplo, char *trans, char *diag, int *n, d *a, int *lda, d *x, int *incx) noexcept nogil: + + _fortran_dtrmv(uplo, trans, diag, n, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dtrsm "BLAS_FUNC(dtrsm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb) nogil +cdef void dtrsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, d *alpha, d *a, int *lda, d *b, int *ldb) noexcept nogil: + + _fortran_dtrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + + +cdef extern from "_blas_subroutines.h": + void _fortran_dtrsv "BLAS_FUNC(dtrsv)"(char *uplo, char *trans, char *diag, int *n, d *a, int *lda, d *x, int *incx) nogil +cdef void dtrsv(char *uplo, char *trans, char *diag, int *n, d *a, int *lda, d *x, int *incx) noexcept nogil: + + _fortran_dtrsv(uplo, trans, diag, n, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + d _fortran_dzasum "BLAS_FUNC(dzasum)"(int *n, npy_complex128 *zx, int *incx) nogil +cdef d dzasum(int *n, z *zx, int *incx) noexcept nogil: + + return _fortran_dzasum(n, zx, incx) + + +cdef extern from "_blas_subroutines.h": + d _fortran_dznrm2 "BLAS_FUNC(dznrm2)"(int *n, npy_complex128 *x, int *incx) nogil +cdef d dznrm2(int *n, z *x, int *incx) noexcept nogil: + + return _fortran_dznrm2(n, x, incx) + + +cdef extern from "_blas_subroutines.h": + int _fortran_icamax "BLAS_FUNC(icamax)"(int *n, npy_complex64 *cx, int *incx) nogil +cdef int icamax(int *n, c *cx, int *incx) noexcept nogil: + + return _fortran_icamax(n, cx, incx) + + +cdef extern from "_blas_subroutines.h": + int _fortran_idamax "BLAS_FUNC(idamax)"(int *n, d *dx, int *incx) nogil +cdef int idamax(int *n, d *dx, int *incx) noexcept nogil: + + return _fortran_idamax(n, dx, incx) + + +cdef extern from "_blas_subroutines.h": + int _fortran_isamax "BLAS_FUNC(isamax)"(int *n, s *sx, int *incx) nogil +cdef int isamax(int *n, s *sx, int *incx) noexcept nogil: + + return _fortran_isamax(n, sx, incx) + + +cdef extern from "_blas_subroutines.h": + int _fortran_izamax "BLAS_FUNC(izamax)"(int *n, npy_complex128 *zx, int *incx) nogil +cdef int izamax(int *n, z *zx, int *incx) noexcept nogil: + + return _fortran_izamax(n, zx, incx) + + +cdef extern from "_blas_subroutines.h": + bint _fortran_lsame "BLAS_FUNC(lsame)"(char *ca, char *cb) nogil +cdef bint lsame(char *ca, char *cb) noexcept nogil: + + return _fortran_lsame(ca, cb) + + +cdef extern from "_blas_subroutines.h": + s _fortran_sasum "BLAS_FUNC(sasum)"(int *n, s *sx, int *incx) nogil +cdef s sasum(int *n, s *sx, int *incx) noexcept nogil: + + return _fortran_sasum(n, sx, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_saxpy "BLAS_FUNC(saxpy)"(int *n, s *sa, s *sx, int *incx, s *sy, int *incy) nogil +cdef void saxpy(int *n, s *sa, s *sx, int *incx, s *sy, int *incy) noexcept nogil: + + _fortran_saxpy(n, sa, sx, incx, sy, incy) + + +cdef extern from "_blas_subroutines.h": + s _fortran_scasum "BLAS_FUNC(scasum)"(int *n, npy_complex64 *cx, int *incx) nogil +cdef s scasum(int *n, c *cx, int *incx) noexcept nogil: + + return _fortran_scasum(n, cx, incx) + + +cdef extern from "_blas_subroutines.h": + s _fortran_scnrm2 "BLAS_FUNC(scnrm2)"(int *n, npy_complex64 *x, int *incx) nogil +cdef s scnrm2(int *n, c *x, int *incx) noexcept nogil: + + return _fortran_scnrm2(n, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_scopy "BLAS_FUNC(scopy)"(int *n, s *sx, int *incx, s *sy, int *incy) nogil +cdef void scopy(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil: + + _fortran_scopy(n, sx, incx, sy, incy) + + +cdef extern from "_blas_subroutines.h": + s _fortran_sdot "BLAS_FUNC(sdot)"(int *n, s *sx, int *incx, s *sy, int *incy) nogil +cdef s sdot(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil: + + return _fortran_sdot(n, sx, incx, sy, incy) + + +cdef extern from "_blas_subroutines.h": + s _fortran_sdsdot "BLAS_FUNC(sdsdot)"(int *n, s *sb, s *sx, int *incx, s *sy, int *incy) nogil +cdef s sdsdot(int *n, s *sb, s *sx, int *incx, s *sy, int *incy) noexcept nogil: + + return _fortran_sdsdot(n, sb, sx, incx, sy, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_sgbmv "BLAS_FUNC(sgbmv)"(char *trans, int *m, int *n, int *kl, int *ku, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) nogil +cdef void sgbmv(char *trans, int *m, int *n, int *kl, int *ku, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil: + + _fortran_sgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_sgemm "BLAS_FUNC(sgemm)"(char *transa, char *transb, int *m, int *n, int *k, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) nogil +cdef void sgemm(char *transa, char *transb, int *m, int *n, int *k, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) noexcept nogil: + + _fortran_sgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_sgemv "BLAS_FUNC(sgemv)"(char *trans, int *m, int *n, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) nogil +cdef void sgemv(char *trans, int *m, int *n, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil: + + _fortran_sgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_sger "BLAS_FUNC(sger)"(int *m, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *a, int *lda) nogil +cdef void sger(int *m, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *a, int *lda) noexcept nogil: + + _fortran_sger(m, n, alpha, x, incx, y, incy, a, lda) + + +cdef extern from "_blas_subroutines.h": + s _fortran_snrm2 "BLAS_FUNC(snrm2)"(int *n, s *x, int *incx) nogil +cdef s snrm2(int *n, s *x, int *incx) noexcept nogil: + + return _fortran_snrm2(n, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_srot "BLAS_FUNC(srot)"(int *n, s *sx, int *incx, s *sy, int *incy, s *c, s *s) nogil +cdef void srot(int *n, s *sx, int *incx, s *sy, int *incy, s *c, s *s) noexcept nogil: + + _fortran_srot(n, sx, incx, sy, incy, c, s) + + +cdef extern from "_blas_subroutines.h": + void _fortran_srotg "BLAS_FUNC(srotg)"(s *sa, s *sb, s *c, s *s) nogil +cdef void srotg(s *sa, s *sb, s *c, s *s) noexcept nogil: + + _fortran_srotg(sa, sb, c, s) + + +cdef extern from "_blas_subroutines.h": + void _fortran_srotm "BLAS_FUNC(srotm)"(int *n, s *sx, int *incx, s *sy, int *incy, s *sparam) nogil +cdef void srotm(int *n, s *sx, int *incx, s *sy, int *incy, s *sparam) noexcept nogil: + + _fortran_srotm(n, sx, incx, sy, incy, sparam) + + +cdef extern from "_blas_subroutines.h": + void _fortran_srotmg "BLAS_FUNC(srotmg)"(s *sd1, s *sd2, s *sx1, s *sy1, s *sparam) nogil +cdef void srotmg(s *sd1, s *sd2, s *sx1, s *sy1, s *sparam) noexcept nogil: + + _fortran_srotmg(sd1, sd2, sx1, sy1, sparam) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ssbmv "BLAS_FUNC(ssbmv)"(char *uplo, int *n, int *k, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) nogil +cdef void ssbmv(char *uplo, int *n, int *k, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil: + + _fortran_ssbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_sscal "BLAS_FUNC(sscal)"(int *n, s *sa, s *sx, int *incx) nogil +cdef void sscal(int *n, s *sa, s *sx, int *incx) noexcept nogil: + + _fortran_sscal(n, sa, sx, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_sspmv "BLAS_FUNC(sspmv)"(char *uplo, int *n, s *alpha, s *ap, s *x, int *incx, s *beta, s *y, int *incy) nogil +cdef void sspmv(char *uplo, int *n, s *alpha, s *ap, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil: + + _fortran_sspmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_sspr "BLAS_FUNC(sspr)"(char *uplo, int *n, s *alpha, s *x, int *incx, s *ap) nogil +cdef void sspr(char *uplo, int *n, s *alpha, s *x, int *incx, s *ap) noexcept nogil: + + _fortran_sspr(uplo, n, alpha, x, incx, ap) + + +cdef extern from "_blas_subroutines.h": + void _fortran_sspr2 "BLAS_FUNC(sspr2)"(char *uplo, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *ap) nogil +cdef void sspr2(char *uplo, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *ap) noexcept nogil: + + _fortran_sspr2(uplo, n, alpha, x, incx, y, incy, ap) + + +cdef extern from "_blas_subroutines.h": + void _fortran_sswap "BLAS_FUNC(sswap)"(int *n, s *sx, int *incx, s *sy, int *incy) nogil +cdef void sswap(int *n, s *sx, int *incx, s *sy, int *incy) noexcept nogil: + + _fortran_sswap(n, sx, incx, sy, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ssymm "BLAS_FUNC(ssymm)"(char *side, char *uplo, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) nogil +cdef void ssymm(char *side, char *uplo, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) noexcept nogil: + + _fortran_ssymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ssymv "BLAS_FUNC(ssymv)"(char *uplo, int *n, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) nogil +cdef void ssymv(char *uplo, int *n, s *alpha, s *a, int *lda, s *x, int *incx, s *beta, s *y, int *incy) noexcept nogil: + + _fortran_ssymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ssyr "BLAS_FUNC(ssyr)"(char *uplo, int *n, s *alpha, s *x, int *incx, s *a, int *lda) nogil +cdef void ssyr(char *uplo, int *n, s *alpha, s *x, int *incx, s *a, int *lda) noexcept nogil: + + _fortran_ssyr(uplo, n, alpha, x, incx, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ssyr2 "BLAS_FUNC(ssyr2)"(char *uplo, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *a, int *lda) nogil +cdef void ssyr2(char *uplo, int *n, s *alpha, s *x, int *incx, s *y, int *incy, s *a, int *lda) noexcept nogil: + + _fortran_ssyr2(uplo, n, alpha, x, incx, y, incy, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ssyr2k "BLAS_FUNC(ssyr2k)"(char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) nogil +cdef void ssyr2k(char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *b, int *ldb, s *beta, s *c, int *ldc) noexcept nogil: + + _fortran_ssyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ssyrk "BLAS_FUNC(ssyrk)"(char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *beta, s *c, int *ldc) nogil +cdef void ssyrk(char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *beta, s *c, int *ldc) noexcept nogil: + + _fortran_ssyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_stbmv "BLAS_FUNC(stbmv)"(char *uplo, char *trans, char *diag, int *n, int *k, s *a, int *lda, s *x, int *incx) nogil +cdef void stbmv(char *uplo, char *trans, char *diag, int *n, int *k, s *a, int *lda, s *x, int *incx) noexcept nogil: + + _fortran_stbmv(uplo, trans, diag, n, k, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_stbsv "BLAS_FUNC(stbsv)"(char *uplo, char *trans, char *diag, int *n, int *k, s *a, int *lda, s *x, int *incx) nogil +cdef void stbsv(char *uplo, char *trans, char *diag, int *n, int *k, s *a, int *lda, s *x, int *incx) noexcept nogil: + + _fortran_stbsv(uplo, trans, diag, n, k, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_stpmv "BLAS_FUNC(stpmv)"(char *uplo, char *trans, char *diag, int *n, s *ap, s *x, int *incx) nogil +cdef void stpmv(char *uplo, char *trans, char *diag, int *n, s *ap, s *x, int *incx) noexcept nogil: + + _fortran_stpmv(uplo, trans, diag, n, ap, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_stpsv "BLAS_FUNC(stpsv)"(char *uplo, char *trans, char *diag, int *n, s *ap, s *x, int *incx) nogil +cdef void stpsv(char *uplo, char *trans, char *diag, int *n, s *ap, s *x, int *incx) noexcept nogil: + + _fortran_stpsv(uplo, trans, diag, n, ap, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_strmm "BLAS_FUNC(strmm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb) nogil +cdef void strmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb) noexcept nogil: + + _fortran_strmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + + +cdef extern from "_blas_subroutines.h": + void _fortran_strmv "BLAS_FUNC(strmv)"(char *uplo, char *trans, char *diag, int *n, s *a, int *lda, s *x, int *incx) nogil +cdef void strmv(char *uplo, char *trans, char *diag, int *n, s *a, int *lda, s *x, int *incx) noexcept nogil: + + _fortran_strmv(uplo, trans, diag, n, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_strsm "BLAS_FUNC(strsm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb) nogil +cdef void strsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, s *alpha, s *a, int *lda, s *b, int *ldb) noexcept nogil: + + _fortran_strsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + + +cdef extern from "_blas_subroutines.h": + void _fortran_strsv "BLAS_FUNC(strsv)"(char *uplo, char *trans, char *diag, int *n, s *a, int *lda, s *x, int *incx) nogil +cdef void strsv(char *uplo, char *trans, char *diag, int *n, s *a, int *lda, s *x, int *incx) noexcept nogil: + + _fortran_strsv(uplo, trans, diag, n, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zaxpy "BLAS_FUNC(zaxpy)"(int *n, npy_complex128 *za, npy_complex128 *zx, int *incx, npy_complex128 *zy, int *incy) nogil +cdef void zaxpy(int *n, z *za, z *zx, int *incx, z *zy, int *incy) noexcept nogil: + + _fortran_zaxpy(n, za, zx, incx, zy, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zcopy "BLAS_FUNC(zcopy)"(int *n, npy_complex128 *zx, int *incx, npy_complex128 *zy, int *incy) nogil +cdef void zcopy(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil: + + _fortran_zcopy(n, zx, incx, zy, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zdotc "(zdotcwrp_)"(npy_complex128 *out, int *n, npy_complex128 *zx, int *incx, npy_complex128 *zy, int *incy) nogil +cdef z zdotc(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil: + cdef z out + _fortran_zdotc(&out, n, zx, incx, zy, incy) + return out + +cdef extern from "_blas_subroutines.h": + void _fortran_zdotu "(zdotuwrp_)"(npy_complex128 *out, int *n, npy_complex128 *zx, int *incx, npy_complex128 *zy, int *incy) nogil +cdef z zdotu(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil: + cdef z out + _fortran_zdotu(&out, n, zx, incx, zy, incy) + return out + +cdef extern from "_blas_subroutines.h": + void _fortran_zdrot "BLAS_FUNC(zdrot)"(int *n, npy_complex128 *cx, int *incx, npy_complex128 *cy, int *incy, d *c, d *s) nogil +cdef void zdrot(int *n, z *cx, int *incx, z *cy, int *incy, d *c, d *s) noexcept nogil: + + _fortran_zdrot(n, cx, incx, cy, incy, c, s) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zdscal "BLAS_FUNC(zdscal)"(int *n, d *da, npy_complex128 *zx, int *incx) nogil +cdef void zdscal(int *n, d *da, z *zx, int *incx) noexcept nogil: + + _fortran_zdscal(n, da, zx, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zgbmv "BLAS_FUNC(zgbmv)"(char *trans, int *m, int *n, int *kl, int *ku, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil +cdef void zgbmv(char *trans, int *m, int *n, int *kl, int *ku, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil: + + _fortran_zgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zgemm "BLAS_FUNC(zgemm)"(char *transa, char *transb, int *m, int *n, int *k, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *beta, npy_complex128 *c, int *ldc) nogil +cdef void zgemm(char *transa, char *transb, int *m, int *n, int *k, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil: + + _fortran_zgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zgemv "BLAS_FUNC(zgemv)"(char *trans, int *m, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil +cdef void zgemv(char *trans, int *m, int *n, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil: + + _fortran_zgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zgerc "BLAS_FUNC(zgerc)"(int *m, int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *y, int *incy, npy_complex128 *a, int *lda) nogil +cdef void zgerc(int *m, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *a, int *lda) noexcept nogil: + + _fortran_zgerc(m, n, alpha, x, incx, y, incy, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zgeru "BLAS_FUNC(zgeru)"(int *m, int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *y, int *incy, npy_complex128 *a, int *lda) nogil +cdef void zgeru(int *m, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *a, int *lda) noexcept nogil: + + _fortran_zgeru(m, n, alpha, x, incx, y, incy, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zhbmv "BLAS_FUNC(zhbmv)"(char *uplo, int *n, int *k, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil +cdef void zhbmv(char *uplo, int *n, int *k, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil: + + _fortran_zhbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zhemm "BLAS_FUNC(zhemm)"(char *side, char *uplo, int *m, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *beta, npy_complex128 *c, int *ldc) nogil +cdef void zhemm(char *side, char *uplo, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil: + + _fortran_zhemm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zhemv "BLAS_FUNC(zhemv)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil +cdef void zhemv(char *uplo, int *n, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil: + + _fortran_zhemv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zher "BLAS_FUNC(zher)"(char *uplo, int *n, d *alpha, npy_complex128 *x, int *incx, npy_complex128 *a, int *lda) nogil +cdef void zher(char *uplo, int *n, d *alpha, z *x, int *incx, z *a, int *lda) noexcept nogil: + + _fortran_zher(uplo, n, alpha, x, incx, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zher2 "BLAS_FUNC(zher2)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *y, int *incy, npy_complex128 *a, int *lda) nogil +cdef void zher2(char *uplo, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *a, int *lda) noexcept nogil: + + _fortran_zher2(uplo, n, alpha, x, incx, y, incy, a, lda) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zher2k "BLAS_FUNC(zher2k)"(char *uplo, char *trans, int *n, int *k, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, d *beta, npy_complex128 *c, int *ldc) nogil +cdef void zher2k(char *uplo, char *trans, int *n, int *k, z *alpha, z *a, int *lda, z *b, int *ldb, d *beta, z *c, int *ldc) noexcept nogil: + + _fortran_zher2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zherk "BLAS_FUNC(zherk)"(char *uplo, char *trans, int *n, int *k, d *alpha, npy_complex128 *a, int *lda, d *beta, npy_complex128 *c, int *ldc) nogil +cdef void zherk(char *uplo, char *trans, int *n, int *k, d *alpha, z *a, int *lda, d *beta, z *c, int *ldc) noexcept nogil: + + _fortran_zherk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zhpmv "BLAS_FUNC(zhpmv)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *ap, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil +cdef void zhpmv(char *uplo, int *n, z *alpha, z *ap, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil: + + _fortran_zhpmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zhpr "BLAS_FUNC(zhpr)"(char *uplo, int *n, d *alpha, npy_complex128 *x, int *incx, npy_complex128 *ap) nogil +cdef void zhpr(char *uplo, int *n, d *alpha, z *x, int *incx, z *ap) noexcept nogil: + + _fortran_zhpr(uplo, n, alpha, x, incx, ap) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zhpr2 "BLAS_FUNC(zhpr2)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *y, int *incy, npy_complex128 *ap) nogil +cdef void zhpr2(char *uplo, int *n, z *alpha, z *x, int *incx, z *y, int *incy, z *ap) noexcept nogil: + + _fortran_zhpr2(uplo, n, alpha, x, incx, y, incy, ap) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zrotg "BLAS_FUNC(zrotg)"(npy_complex128 *ca, npy_complex128 *cb, d *c, npy_complex128 *s) nogil +cdef void zrotg(z *ca, z *cb, d *c, z *s) noexcept nogil: + + _fortran_zrotg(ca, cb, c, s) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zscal "BLAS_FUNC(zscal)"(int *n, npy_complex128 *za, npy_complex128 *zx, int *incx) nogil +cdef void zscal(int *n, z *za, z *zx, int *incx) noexcept nogil: + + _fortran_zscal(n, za, zx, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zswap "BLAS_FUNC(zswap)"(int *n, npy_complex128 *zx, int *incx, npy_complex128 *zy, int *incy) nogil +cdef void zswap(int *n, z *zx, int *incx, z *zy, int *incy) noexcept nogil: + + _fortran_zswap(n, zx, incx, zy, incy) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zsymm "BLAS_FUNC(zsymm)"(char *side, char *uplo, int *m, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *beta, npy_complex128 *c, int *ldc) nogil +cdef void zsymm(char *side, char *uplo, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil: + + _fortran_zsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zsyr2k "BLAS_FUNC(zsyr2k)"(char *uplo, char *trans, int *n, int *k, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *beta, npy_complex128 *c, int *ldc) nogil +cdef void zsyr2k(char *uplo, char *trans, int *n, int *k, z *alpha, z *a, int *lda, z *b, int *ldb, z *beta, z *c, int *ldc) noexcept nogil: + + _fortran_zsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_zsyrk "BLAS_FUNC(zsyrk)"(char *uplo, char *trans, int *n, int *k, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *beta, npy_complex128 *c, int *ldc) nogil +cdef void zsyrk(char *uplo, char *trans, int *n, int *k, z *alpha, z *a, int *lda, z *beta, z *c, int *ldc) noexcept nogil: + + _fortran_zsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ztbmv "BLAS_FUNC(ztbmv)"(char *uplo, char *trans, char *diag, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx) nogil +cdef void ztbmv(char *uplo, char *trans, char *diag, int *n, int *k, z *a, int *lda, z *x, int *incx) noexcept nogil: + + _fortran_ztbmv(uplo, trans, diag, n, k, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ztbsv "BLAS_FUNC(ztbsv)"(char *uplo, char *trans, char *diag, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx) nogil +cdef void ztbsv(char *uplo, char *trans, char *diag, int *n, int *k, z *a, int *lda, z *x, int *incx) noexcept nogil: + + _fortran_ztbsv(uplo, trans, diag, n, k, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ztpmv "BLAS_FUNC(ztpmv)"(char *uplo, char *trans, char *diag, int *n, npy_complex128 *ap, npy_complex128 *x, int *incx) nogil +cdef void ztpmv(char *uplo, char *trans, char *diag, int *n, z *ap, z *x, int *incx) noexcept nogil: + + _fortran_ztpmv(uplo, trans, diag, n, ap, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ztpsv "BLAS_FUNC(ztpsv)"(char *uplo, char *trans, char *diag, int *n, npy_complex128 *ap, npy_complex128 *x, int *incx) nogil +cdef void ztpsv(char *uplo, char *trans, char *diag, int *n, z *ap, z *x, int *incx) noexcept nogil: + + _fortran_ztpsv(uplo, trans, diag, n, ap, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ztrmm "BLAS_FUNC(ztrmm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb) nogil +cdef void ztrmm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb) noexcept nogil: + + _fortran_ztrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ztrmv "BLAS_FUNC(ztrmv)"(char *uplo, char *trans, char *diag, int *n, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx) nogil +cdef void ztrmv(char *uplo, char *trans, char *diag, int *n, z *a, int *lda, z *x, int *incx) noexcept nogil: + + _fortran_ztrmv(uplo, trans, diag, n, a, lda, x, incx) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ztrsm "BLAS_FUNC(ztrsm)"(char *side, char *uplo, char *transa, char *diag, int *m, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb) nogil +cdef void ztrsm(char *side, char *uplo, char *transa, char *diag, int *m, int *n, z *alpha, z *a, int *lda, z *b, int *ldb) noexcept nogil: + + _fortran_ztrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + + +cdef extern from "_blas_subroutines.h": + void _fortran_ztrsv "BLAS_FUNC(ztrsv)"(char *uplo, char *trans, char *diag, int *n, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx) nogil +cdef void ztrsv(char *uplo, char *trans, char *diag, int *n, z *a, int *lda, z *x, int *incx) noexcept nogil: + + _fortran_ztrsv(uplo, trans, diag, n, a, lda, x, incx) + + + +# Python-accessible wrappers for testing: + +cdef inline bint _is_contiguous(double[:,:] a, int axis) noexcept nogil: + return (a.strides[axis] == sizeof(a[0,0]) or a.shape[axis] == 1) + +cpdef float complex _test_cdotc(float complex[:] cx, float complex[:] cy) noexcept nogil: + cdef: + int n = cx.shape[0] + int incx = cx.strides[0] // sizeof(cx[0]) + int incy = cy.strides[0] // sizeof(cy[0]) + return cdotc(&n, &cx[0], &incx, &cy[0], &incy) + +cpdef float complex _test_cdotu(float complex[:] cx, float complex[:] cy) noexcept nogil: + cdef: + int n = cx.shape[0] + int incx = cx.strides[0] // sizeof(cx[0]) + int incy = cy.strides[0] // sizeof(cy[0]) + return cdotu(&n, &cx[0], &incx, &cy[0], &incy) + +cpdef double _test_dasum(double[:] dx) noexcept nogil: + cdef: + int n = dx.shape[0] + int incx = dx.strides[0] // sizeof(dx[0]) + return dasum(&n, &dx[0], &incx) + +cpdef double _test_ddot(double[:] dx, double[:] dy) noexcept nogil: + cdef: + int n = dx.shape[0] + int incx = dx.strides[0] // sizeof(dx[0]) + int incy = dy.strides[0] // sizeof(dy[0]) + return ddot(&n, &dx[0], &incx, &dy[0], &incy) + +cpdef int _test_dgemm(double alpha, double[:,:] a, double[:,:] b, double beta, + double[:,:] c) except -1 nogil: + cdef: + char *transa + char *transb + int m, n, k, lda, ldb, ldc + double *a0=&a[0,0] + double *b0=&b[0,0] + double *c0=&c[0,0] + # In the case that c is C contiguous, swap a and b and + # swap whether or not each of them is transposed. + # This can be done because a.dot(b) = b.T.dot(a.T).T. + if _is_contiguous(c, 1): + if _is_contiguous(a, 1): + transb = 'n' + ldb = (&a[1,0]) - a0 if a.shape[0] > 1 else 1 + elif _is_contiguous(a, 0): + transb = 't' + ldb = (&a[0,1]) - a0 if a.shape[1] > 1 else 1 + else: + with gil: + raise ValueError("Input 'a' is neither C nor Fortran contiguous.") + if _is_contiguous(b, 1): + transa = 'n' + lda = (&b[1,0]) - b0 if b.shape[0] > 1 else 1 + elif _is_contiguous(b, 0): + transa = 't' + lda = (&b[0,1]) - b0 if b.shape[1] > 1 else 1 + else: + with gil: + raise ValueError("Input 'b' is neither C nor Fortran contiguous.") + k = b.shape[0] + if k != a.shape[1]: + with gil: + raise ValueError("Shape mismatch in input arrays.") + m = b.shape[1] + n = a.shape[0] + if n != c.shape[0] or m != c.shape[1]: + with gil: + raise ValueError("Output array does not have the correct shape.") + ldc = (&c[1,0]) - c0 if c.shape[0] > 1 else 1 + dgemm(transa, transb, &m, &n, &k, &alpha, b0, &lda, a0, + &ldb, &beta, c0, &ldc) + elif _is_contiguous(c, 0): + if _is_contiguous(a, 1): + transa = 't' + lda = (&a[1,0]) - a0 if a.shape[0] > 1 else 1 + elif _is_contiguous(a, 0): + transa = 'n' + lda = (&a[0,1]) - a0 if a.shape[1] > 1 else 1 + else: + with gil: + raise ValueError("Input 'a' is neither C nor Fortran contiguous.") + if _is_contiguous(b, 1): + transb = 't' + ldb = (&b[1,0]) - b0 if b.shape[0] > 1 else 1 + elif _is_contiguous(b, 0): + transb = 'n' + ldb = (&b[0,1]) - b0 if b.shape[1] > 1 else 1 + else: + with gil: + raise ValueError("Input 'b' is neither C nor Fortran contiguous.") + m = a.shape[0] + k = a.shape[1] + if k != b.shape[0]: + with gil: + raise ValueError("Shape mismatch in input arrays.") + n = b.shape[1] + if m != c.shape[0] or n != c.shape[1]: + with gil: + raise ValueError("Output array does not have the correct shape.") + ldc = (&c[0,1]) - c0 if c.shape[1] > 1 else 1 + dgemm(transa, transb, &m, &n, &k, &alpha, a0, &lda, b0, + &ldb, &beta, c0, &ldc) + else: + with gil: + raise ValueError("Input 'c' is neither C nor Fortran contiguous.") + return 0 + +cpdef double _test_dnrm2(double[:] x) noexcept nogil: + cdef: + int n = x.shape[0] + int incx = x.strides[0] // sizeof(x[0]) + return dnrm2(&n, &x[0], &incx) + +cpdef double _test_dzasum(double complex[:] zx) noexcept nogil: + cdef: + int n = zx.shape[0] + int incx = zx.strides[0] // sizeof(zx[0]) + return dzasum(&n, &zx[0], &incx) + +cpdef double _test_dznrm2(double complex[:] x) noexcept nogil: + cdef: + int n = x.shape[0] + int incx = x.strides[0] // sizeof(x[0]) + return dznrm2(&n, &x[0], &incx) + +cpdef int _test_icamax(float complex[:] cx) noexcept nogil: + cdef: + int n = cx.shape[0] + int incx = cx.strides[0] // sizeof(cx[0]) + return icamax(&n, &cx[0], &incx) + +cpdef int _test_idamax(double[:] dx) noexcept nogil: + cdef: + int n = dx.shape[0] + int incx = dx.strides[0] // sizeof(dx[0]) + return idamax(&n, &dx[0], &incx) + +cpdef int _test_isamax(float[:] sx) noexcept nogil: + cdef: + int n = sx.shape[0] + int incx = sx.strides[0] // sizeof(sx[0]) + return isamax(&n, &sx[0], &incx) + +cpdef int _test_izamax(double complex[:] zx) noexcept nogil: + cdef: + int n = zx.shape[0] + int incx = zx.strides[0] // sizeof(zx[0]) + return izamax(&n, &zx[0], &incx) + +cpdef float _test_sasum(float[:] sx) noexcept nogil: + cdef: + int n = sx.shape[0] + int incx = sx.strides[0] // sizeof(sx[0]) + return sasum(&n, &sx[0], &incx) + +cpdef float _test_scasum(float complex[:] cx) noexcept nogil: + cdef: + int n = cx.shape[0] + int incx = cx.strides[0] // sizeof(cx[0]) + return scasum(&n, &cx[0], &incx) + +cpdef float _test_scnrm2(float complex[:] x) noexcept nogil: + cdef: + int n = x.shape[0] + int incx = x.strides[0] // sizeof(x[0]) + return scnrm2(&n, &x[0], &incx) + +cpdef float _test_sdot(float[:] sx, float[:] sy) noexcept nogil: + cdef: + int n = sx.shape[0] + int incx = sx.strides[0] // sizeof(sx[0]) + int incy = sy.strides[0] // sizeof(sy[0]) + return sdot(&n, &sx[0], &incx, &sy[0], &incy) + +cpdef float _test_snrm2(float[:] x) noexcept nogil: + cdef: + int n = x.shape[0] + int incx = x.strides[0] // sizeof(x[0]) + return snrm2(&n, &x[0], &incx) + +cpdef double complex _test_zdotc(double complex[:] zx, double complex[:] zy) noexcept nogil: + cdef: + int n = zx.shape[0] + int incx = zx.strides[0] // sizeof(zx[0]) + int incy = zy.strides[0] // sizeof(zy[0]) + return zdotc(&n, &zx[0], &incx, &zy[0], &incy) + +cpdef double complex _test_zdotu(double complex[:] zx, double complex[:] zy) noexcept nogil: + cdef: + int n = zx.shape[0] + int incx = zx.strides[0] // sizeof(zx[0]) + int incy = zy.strides[0] // sizeof(zy[0]) + return zdotu(&n, &zx[0], &incx, &zy[0], &incy) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_lapack.pxd b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_lapack.pxd new file mode 100644 index 0000000000000000000000000000000000000000..7964c52d766cd1b08bda6411960a29dbeb6bfe2d --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_lapack.pxd @@ -0,0 +1,1528 @@ +""" +This file was generated by _generate_pyx.py. +Do not edit this file directly. +""" + +# Within SciPy, these wrappers can be used via relative or absolute cimport. +# Examples: +# from ..linalg cimport cython_lapack +# from scipy.linalg cimport cython_lapack +# cimport scipy.linalg.cython_lapack as cython_lapack +# cimport ..linalg.cython_lapack as cython_lapack + +# Within SciPy, if LAPACK functions are needed in C/C++/Fortran, +# these wrappers should not be used. +# The original libraries should be linked directly. + +ctypedef float s +ctypedef double d +ctypedef float complex c +ctypedef double complex z + +# Function pointer type declarations for +# gees and gges families of functions. +ctypedef bint cselect1(c*) +ctypedef bint cselect2(c*, c*) +ctypedef bint dselect2(d*, d*) +ctypedef bint dselect3(d*, d*, d*) +ctypedef bint sselect2(s*, s*) +ctypedef bint sselect3(s*, s*, s*) +ctypedef bint zselect1(z*) +ctypedef bint zselect2(z*, z*) + +cdef void cbbcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, s *theta, s *phi, c *u1, int *ldu1, c *u2, int *ldu2, c *v1t, int *ldv1t, c *v2t, int *ldv2t, s *b11d, s *b11e, s *b12d, s *b12e, s *b21d, s *b21e, s *b22d, s *b22e, s *rwork, int *lrwork, int *info) noexcept nogil +cdef void cbdsqr(char *uplo, int *n, int *ncvt, int *nru, int *ncc, s *d, s *e, c *vt, int *ldvt, c *u, int *ldu, c *c, int *ldc, s *rwork, int *info) noexcept nogil +cdef void cgbbrd(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, c *ab, int *ldab, s *d, s *e, c *q, int *ldq, c *pt, int *ldpt, c *c, int *ldc, c *work, s *rwork, int *info) noexcept nogil +cdef void cgbcon(char *norm, int *n, int *kl, int *ku, c *ab, int *ldab, int *ipiv, s *anorm, s *rcond, c *work, s *rwork, int *info) noexcept nogil +cdef void cgbequ(int *m, int *n, int *kl, int *ku, c *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil +cdef void cgbequb(int *m, int *n, int *kl, int *ku, c *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil +cdef void cgbrfs(char *trans, int *n, int *kl, int *ku, int *nrhs, c *ab, int *ldab, c *afb, int *ldafb, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cgbsv(int *n, int *kl, int *ku, int *nrhs, c *ab, int *ldab, int *ipiv, c *b, int *ldb, int *info) noexcept nogil +cdef void cgbsvx(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, c *ab, int *ldab, c *afb, int *ldafb, int *ipiv, char *equed, s *r, s *c, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cgbtf2(int *m, int *n, int *kl, int *ku, c *ab, int *ldab, int *ipiv, int *info) noexcept nogil +cdef void cgbtrf(int *m, int *n, int *kl, int *ku, c *ab, int *ldab, int *ipiv, int *info) noexcept nogil +cdef void cgbtrs(char *trans, int *n, int *kl, int *ku, int *nrhs, c *ab, int *ldab, int *ipiv, c *b, int *ldb, int *info) noexcept nogil +cdef void cgebak(char *job, char *side, int *n, int *ilo, int *ihi, s *scale, int *m, c *v, int *ldv, int *info) noexcept nogil +cdef void cgebal(char *job, int *n, c *a, int *lda, int *ilo, int *ihi, s *scale, int *info) noexcept nogil +cdef void cgebd2(int *m, int *n, c *a, int *lda, s *d, s *e, c *tauq, c *taup, c *work, int *info) noexcept nogil +cdef void cgebrd(int *m, int *n, c *a, int *lda, s *d, s *e, c *tauq, c *taup, c *work, int *lwork, int *info) noexcept nogil +cdef void cgecon(char *norm, int *n, c *a, int *lda, s *anorm, s *rcond, c *work, s *rwork, int *info) noexcept nogil +cdef void cgeequ(int *m, int *n, c *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil +cdef void cgeequb(int *m, int *n, c *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil +cdef void cgees(char *jobvs, char *sort, cselect1 *select, int *n, c *a, int *lda, int *sdim, c *w, c *vs, int *ldvs, c *work, int *lwork, s *rwork, bint *bwork, int *info) noexcept nogil +cdef void cgeesx(char *jobvs, char *sort, cselect1 *select, char *sense, int *n, c *a, int *lda, int *sdim, c *w, c *vs, int *ldvs, s *rconde, s *rcondv, c *work, int *lwork, s *rwork, bint *bwork, int *info) noexcept nogil +cdef void cgeev(char *jobvl, char *jobvr, int *n, c *a, int *lda, c *w, c *vl, int *ldvl, c *vr, int *ldvr, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef void cgeevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, c *a, int *lda, c *w, c *vl, int *ldvl, c *vr, int *ldvr, int *ilo, int *ihi, s *scale, s *abnrm, s *rconde, s *rcondv, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef void cgehd2(int *n, int *ilo, int *ihi, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil +cdef void cgehrd(int *n, int *ilo, int *ihi, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cgelq2(int *m, int *n, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil +cdef void cgelqf(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cgels(char *trans, int *m, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, c *work, int *lwork, int *info) noexcept nogil +cdef void cgelsd(int *m, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, s *s, s *rcond, int *rank, c *work, int *lwork, s *rwork, int *iwork, int *info) noexcept nogil +cdef void cgelss(int *m, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, s *s, s *rcond, int *rank, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef void cgelsy(int *m, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, int *jpvt, s *rcond, int *rank, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef void cgemqrt(char *side, char *trans, int *m, int *n, int *k, int *nb, c *v, int *ldv, c *t, int *ldt, c *c, int *ldc, c *work, int *info) noexcept nogil +cdef void cgeql2(int *m, int *n, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil +cdef void cgeqlf(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cgeqp3(int *m, int *n, c *a, int *lda, int *jpvt, c *tau, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef void cgeqr2(int *m, int *n, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil +cdef void cgeqr2p(int *m, int *n, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil +cdef void cgeqrf(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cgeqrfp(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cgeqrt(int *m, int *n, int *nb, c *a, int *lda, c *t, int *ldt, c *work, int *info) noexcept nogil +cdef void cgeqrt2(int *m, int *n, c *a, int *lda, c *t, int *ldt, int *info) noexcept nogil +cdef void cgeqrt3(int *m, int *n, c *a, int *lda, c *t, int *ldt, int *info) noexcept nogil +cdef void cgerfs(char *trans, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cgerq2(int *m, int *n, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil +cdef void cgerqf(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cgesc2(int *n, c *a, int *lda, c *rhs, int *ipiv, int *jpiv, s *scale) noexcept nogil +cdef void cgesdd(char *jobz, int *m, int *n, c *a, int *lda, s *s, c *u, int *ldu, c *vt, int *ldvt, c *work, int *lwork, s *rwork, int *iwork, int *info) noexcept nogil +cdef void cgesv(int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, int *info) noexcept nogil +cdef void cgesvd(char *jobu, char *jobvt, int *m, int *n, c *a, int *lda, s *s, c *u, int *ldu, c *vt, int *ldvt, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef void cgesvx(char *fact, char *trans, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, char *equed, s *r, s *c, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cgetc2(int *n, c *a, int *lda, int *ipiv, int *jpiv, int *info) noexcept nogil +cdef void cgetf2(int *m, int *n, c *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void cgetrf(int *m, int *n, c *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void cgetri(int *n, c *a, int *lda, int *ipiv, c *work, int *lwork, int *info) noexcept nogil +cdef void cgetrs(char *trans, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, int *info) noexcept nogil +cdef void cggbak(char *job, char *side, int *n, int *ilo, int *ihi, s *lscale, s *rscale, int *m, c *v, int *ldv, int *info) noexcept nogil +cdef void cggbal(char *job, int *n, c *a, int *lda, c *b, int *ldb, int *ilo, int *ihi, s *lscale, s *rscale, s *work, int *info) noexcept nogil +cdef void cgges(char *jobvsl, char *jobvsr, char *sort, cselect2 *selctg, int *n, c *a, int *lda, c *b, int *ldb, int *sdim, c *alpha, c *beta, c *vsl, int *ldvsl, c *vsr, int *ldvsr, c *work, int *lwork, s *rwork, bint *bwork, int *info) noexcept nogil +cdef void cggesx(char *jobvsl, char *jobvsr, char *sort, cselect2 *selctg, char *sense, int *n, c *a, int *lda, c *b, int *ldb, int *sdim, c *alpha, c *beta, c *vsl, int *ldvsl, c *vsr, int *ldvsr, s *rconde, s *rcondv, c *work, int *lwork, s *rwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil +cdef void cggev(char *jobvl, char *jobvr, int *n, c *a, int *lda, c *b, int *ldb, c *alpha, c *beta, c *vl, int *ldvl, c *vr, int *ldvr, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef void cggevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, c *a, int *lda, c *b, int *ldb, c *alpha, c *beta, c *vl, int *ldvl, c *vr, int *ldvr, int *ilo, int *ihi, s *lscale, s *rscale, s *abnrm, s *bbnrm, s *rconde, s *rcondv, c *work, int *lwork, s *rwork, int *iwork, bint *bwork, int *info) noexcept nogil +cdef void cggglm(int *n, int *m, int *p, c *a, int *lda, c *b, int *ldb, c *d, c *x, c *y, c *work, int *lwork, int *info) noexcept nogil +cdef void cgghrd(char *compq, char *compz, int *n, int *ilo, int *ihi, c *a, int *lda, c *b, int *ldb, c *q, int *ldq, c *z, int *ldz, int *info) noexcept nogil +cdef void cgglse(int *m, int *n, int *p, c *a, int *lda, c *b, int *ldb, c *c, c *d, c *x, c *work, int *lwork, int *info) noexcept nogil +cdef void cggqrf(int *n, int *m, int *p, c *a, int *lda, c *taua, c *b, int *ldb, c *taub, c *work, int *lwork, int *info) noexcept nogil +cdef void cggrqf(int *m, int *p, int *n, c *a, int *lda, c *taua, c *b, int *ldb, c *taub, c *work, int *lwork, int *info) noexcept nogil +cdef void cgtcon(char *norm, int *n, c *dl, c *d, c *du, c *du2, int *ipiv, s *anorm, s *rcond, c *work, int *info) noexcept nogil +cdef void cgtrfs(char *trans, int *n, int *nrhs, c *dl, c *d, c *du, c *dlf, c *df, c *duf, c *du2, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cgtsv(int *n, int *nrhs, c *dl, c *d, c *du, c *b, int *ldb, int *info) noexcept nogil +cdef void cgtsvx(char *fact, char *trans, int *n, int *nrhs, c *dl, c *d, c *du, c *dlf, c *df, c *duf, c *du2, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cgttrf(int *n, c *dl, c *d, c *du, c *du2, int *ipiv, int *info) noexcept nogil +cdef void cgttrs(char *trans, int *n, int *nrhs, c *dl, c *d, c *du, c *du2, int *ipiv, c *b, int *ldb, int *info) noexcept nogil +cdef void cgtts2(int *itrans, int *n, int *nrhs, c *dl, c *d, c *du, c *du2, int *ipiv, c *b, int *ldb) noexcept nogil +cdef void chbev(char *jobz, char *uplo, int *n, int *kd, c *ab, int *ldab, s *w, c *z, int *ldz, c *work, s *rwork, int *info) noexcept nogil +cdef void chbevd(char *jobz, char *uplo, int *n, int *kd, c *ab, int *ldab, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void chbevx(char *jobz, char *range, char *uplo, int *n, int *kd, c *ab, int *ldab, c *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void chbgst(char *vect, char *uplo, int *n, int *ka, int *kb, c *ab, int *ldab, c *bb, int *ldbb, c *x, int *ldx, c *work, s *rwork, int *info) noexcept nogil +cdef void chbgv(char *jobz, char *uplo, int *n, int *ka, int *kb, c *ab, int *ldab, c *bb, int *ldbb, s *w, c *z, int *ldz, c *work, s *rwork, int *info) noexcept nogil +cdef void chbgvd(char *jobz, char *uplo, int *n, int *ka, int *kb, c *ab, int *ldab, c *bb, int *ldbb, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void chbgvx(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, c *ab, int *ldab, c *bb, int *ldbb, c *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void chbtrd(char *vect, char *uplo, int *n, int *kd, c *ab, int *ldab, s *d, s *e, c *q, int *ldq, c *work, int *info) noexcept nogil +cdef void checon(char *uplo, int *n, c *a, int *lda, int *ipiv, s *anorm, s *rcond, c *work, int *info) noexcept nogil +cdef void cheequb(char *uplo, int *n, c *a, int *lda, s *s, s *scond, s *amax, c *work, int *info) noexcept nogil +cdef void cheev(char *jobz, char *uplo, int *n, c *a, int *lda, s *w, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef void cheevd(char *jobz, char *uplo, int *n, c *a, int *lda, s *w, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void cheevr(char *jobz, char *range, char *uplo, int *n, c *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, int *isuppz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void cheevx(char *jobz, char *range, char *uplo, int *n, c *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void chegs2(int *itype, char *uplo, int *n, c *a, int *lda, c *b, int *ldb, int *info) noexcept nogil +cdef void chegst(int *itype, char *uplo, int *n, c *a, int *lda, c *b, int *ldb, int *info) noexcept nogil +cdef void chegv(int *itype, char *jobz, char *uplo, int *n, c *a, int *lda, c *b, int *ldb, s *w, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef void chegvd(int *itype, char *jobz, char *uplo, int *n, c *a, int *lda, c *b, int *ldb, s *w, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void chegvx(int *itype, char *jobz, char *range, char *uplo, int *n, c *a, int *lda, c *b, int *ldb, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void cherfs(char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void chesv(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, c *work, int *lwork, int *info) noexcept nogil +cdef void chesvx(char *fact, char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef void cheswapr(char *uplo, int *n, c *a, int *lda, int *i1, int *i2) noexcept nogil +cdef void chetd2(char *uplo, int *n, c *a, int *lda, s *d, s *e, c *tau, int *info) noexcept nogil +cdef void chetf2(char *uplo, int *n, c *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void chetrd(char *uplo, int *n, c *a, int *lda, s *d, s *e, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void chetrf(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *lwork, int *info) noexcept nogil +cdef void chetri(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *info) noexcept nogil +cdef void chetri2(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *lwork, int *info) noexcept nogil +cdef void chetri2x(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *nb, int *info) noexcept nogil +cdef void chetrs(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, int *info) noexcept nogil +cdef void chetrs2(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, c *work, int *info) noexcept nogil +cdef void chfrk(char *transr, char *uplo, char *trans, int *n, int *k, s *alpha, c *a, int *lda, s *beta, c *c) noexcept nogil +cdef void chgeqz(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, c *h, int *ldh, c *t, int *ldt, c *alpha, c *beta, c *q, int *ldq, c *z, int *ldz, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef char chla_transtype(int *trans) noexcept nogil +cdef void chpcon(char *uplo, int *n, c *ap, int *ipiv, s *anorm, s *rcond, c *work, int *info) noexcept nogil +cdef void chpev(char *jobz, char *uplo, int *n, c *ap, s *w, c *z, int *ldz, c *work, s *rwork, int *info) noexcept nogil +cdef void chpevd(char *jobz, char *uplo, int *n, c *ap, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void chpevx(char *jobz, char *range, char *uplo, int *n, c *ap, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void chpgst(int *itype, char *uplo, int *n, c *ap, c *bp, int *info) noexcept nogil +cdef void chpgv(int *itype, char *jobz, char *uplo, int *n, c *ap, c *bp, s *w, c *z, int *ldz, c *work, s *rwork, int *info) noexcept nogil +cdef void chpgvd(int *itype, char *jobz, char *uplo, int *n, c *ap, c *bp, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void chpgvx(int *itype, char *jobz, char *range, char *uplo, int *n, c *ap, c *bp, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void chprfs(char *uplo, int *n, int *nrhs, c *ap, c *afp, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void chpsv(char *uplo, int *n, int *nrhs, c *ap, int *ipiv, c *b, int *ldb, int *info) noexcept nogil +cdef void chpsvx(char *fact, char *uplo, int *n, int *nrhs, c *ap, c *afp, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void chptrd(char *uplo, int *n, c *ap, s *d, s *e, c *tau, int *info) noexcept nogil +cdef void chptrf(char *uplo, int *n, c *ap, int *ipiv, int *info) noexcept nogil +cdef void chptri(char *uplo, int *n, c *ap, int *ipiv, c *work, int *info) noexcept nogil +cdef void chptrs(char *uplo, int *n, int *nrhs, c *ap, int *ipiv, c *b, int *ldb, int *info) noexcept nogil +cdef void chsein(char *side, char *eigsrc, char *initv, bint *select, int *n, c *h, int *ldh, c *w, c *vl, int *ldvl, c *vr, int *ldvr, int *mm, int *m, c *work, s *rwork, int *ifaill, int *ifailr, int *info) noexcept nogil +cdef void chseqr(char *job, char *compz, int *n, int *ilo, int *ihi, c *h, int *ldh, c *w, c *z, int *ldz, c *work, int *lwork, int *info) noexcept nogil +cdef void clabrd(int *m, int *n, int *nb, c *a, int *lda, s *d, s *e, c *tauq, c *taup, c *x, int *ldx, c *y, int *ldy) noexcept nogil +cdef void clacgv(int *n, c *x, int *incx) noexcept nogil +cdef void clacn2(int *n, c *v, c *x, s *est, int *kase, int *isave) noexcept nogil +cdef void clacon(int *n, c *v, c *x, s *est, int *kase) noexcept nogil +cdef void clacp2(char *uplo, int *m, int *n, s *a, int *lda, c *b, int *ldb) noexcept nogil +cdef void clacpy(char *uplo, int *m, int *n, c *a, int *lda, c *b, int *ldb) noexcept nogil +cdef void clacrm(int *m, int *n, c *a, int *lda, s *b, int *ldb, c *c, int *ldc, s *rwork) noexcept nogil +cdef void clacrt(int *n, c *cx, int *incx, c *cy, int *incy, c *c, c *s) noexcept nogil +cdef c cladiv(c *x, c *y) noexcept nogil +cdef void claed0(int *qsiz, int *n, s *d, s *e, c *q, int *ldq, c *qstore, int *ldqs, s *rwork, int *iwork, int *info) noexcept nogil +cdef void claed7(int *n, int *cutpnt, int *qsiz, int *tlvls, int *curlvl, int *curpbm, s *d, c *q, int *ldq, s *rho, int *indxq, s *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, s *givnum, c *work, s *rwork, int *iwork, int *info) noexcept nogil +cdef void claed8(int *k, int *n, int *qsiz, c *q, int *ldq, s *d, s *rho, int *cutpnt, s *z, s *dlamda, c *q2, int *ldq2, s *w, int *indxp, int *indx, int *indxq, int *perm, int *givptr, int *givcol, s *givnum, int *info) noexcept nogil +cdef void claein(bint *rightv, bint *noinit, int *n, c *h, int *ldh, c *w, c *v, c *b, int *ldb, s *rwork, s *eps3, s *smlnum, int *info) noexcept nogil +cdef void claesy(c *a, c *b, c *c, c *rt1, c *rt2, c *evscal, c *cs1, c *sn1) noexcept nogil +cdef void claev2(c *a, c *b, c *c, s *rt1, s *rt2, s *cs1, c *sn1) noexcept nogil +cdef void clag2z(int *m, int *n, c *sa, int *ldsa, z *a, int *lda, int *info) noexcept nogil +cdef void clags2(bint *upper, s *a1, c *a2, s *a3, s *b1, c *b2, s *b3, s *csu, c *snu, s *csv, c *snv, s *csq, c *snq) noexcept nogil +cdef void clagtm(char *trans, int *n, int *nrhs, s *alpha, c *dl, c *d, c *du, c *x, int *ldx, s *beta, c *b, int *ldb) noexcept nogil +cdef void clahef(char *uplo, int *n, int *nb, int *kb, c *a, int *lda, int *ipiv, c *w, int *ldw, int *info) noexcept nogil +cdef void clahqr(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, c *h, int *ldh, c *w, int *iloz, int *ihiz, c *z, int *ldz, int *info) noexcept nogil +cdef void clahr2(int *n, int *k, int *nb, c *a, int *lda, c *tau, c *t, int *ldt, c *y, int *ldy) noexcept nogil +cdef void claic1(int *job, int *j, c *x, s *sest, c *w, c *gamma, s *sestpr, c *s, c *c) noexcept nogil +cdef void clals0(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, c *b, int *ldb, c *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *poles, s *difl, s *difr, s *z, int *k, s *c, s *s, s *rwork, int *info) noexcept nogil +cdef void clalsa(int *icompq, int *smlsiz, int *n, int *nrhs, c *b, int *ldb, c *bx, int *ldbx, s *u, int *ldu, s *vt, int *k, s *difl, s *difr, s *z, s *poles, int *givptr, int *givcol, int *ldgcol, int *perm, s *givnum, s *c, s *s, s *rwork, int *iwork, int *info) noexcept nogil +cdef void clalsd(char *uplo, int *smlsiz, int *n, int *nrhs, s *d, s *e, c *b, int *ldb, s *rcond, int *rank, c *work, s *rwork, int *iwork, int *info) noexcept nogil +cdef s clangb(char *norm, int *n, int *kl, int *ku, c *ab, int *ldab, s *work) noexcept nogil +cdef s clange(char *norm, int *m, int *n, c *a, int *lda, s *work) noexcept nogil +cdef s clangt(char *norm, int *n, c *dl, c *d, c *du) noexcept nogil +cdef s clanhb(char *norm, char *uplo, int *n, int *k, c *ab, int *ldab, s *work) noexcept nogil +cdef s clanhe(char *norm, char *uplo, int *n, c *a, int *lda, s *work) noexcept nogil +cdef s clanhf(char *norm, char *transr, char *uplo, int *n, c *a, s *work) noexcept nogil +cdef s clanhp(char *norm, char *uplo, int *n, c *ap, s *work) noexcept nogil +cdef s clanhs(char *norm, int *n, c *a, int *lda, s *work) noexcept nogil +cdef s clanht(char *norm, int *n, s *d, c *e) noexcept nogil +cdef s clansb(char *norm, char *uplo, int *n, int *k, c *ab, int *ldab, s *work) noexcept nogil +cdef s clansp(char *norm, char *uplo, int *n, c *ap, s *work) noexcept nogil +cdef s clansy(char *norm, char *uplo, int *n, c *a, int *lda, s *work) noexcept nogil +cdef s clantb(char *norm, char *uplo, char *diag, int *n, int *k, c *ab, int *ldab, s *work) noexcept nogil +cdef s clantp(char *norm, char *uplo, char *diag, int *n, c *ap, s *work) noexcept nogil +cdef s clantr(char *norm, char *uplo, char *diag, int *m, int *n, c *a, int *lda, s *work) noexcept nogil +cdef void clapll(int *n, c *x, int *incx, c *y, int *incy, s *ssmin) noexcept nogil +cdef void clapmr(bint *forwrd, int *m, int *n, c *x, int *ldx, int *k) noexcept nogil +cdef void clapmt(bint *forwrd, int *m, int *n, c *x, int *ldx, int *k) noexcept nogil +cdef void claqgb(int *m, int *n, int *kl, int *ku, c *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) noexcept nogil +cdef void claqge(int *m, int *n, c *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) noexcept nogil +cdef void claqhb(char *uplo, int *n, int *kd, c *ab, int *ldab, s *s, s *scond, s *amax, char *equed) noexcept nogil +cdef void claqhe(char *uplo, int *n, c *a, int *lda, s *s, s *scond, s *amax, char *equed) noexcept nogil +cdef void claqhp(char *uplo, int *n, c *ap, s *s, s *scond, s *amax, char *equed) noexcept nogil +cdef void claqp2(int *m, int *n, int *offset, c *a, int *lda, int *jpvt, c *tau, s *vn1, s *vn2, c *work) noexcept nogil +cdef void claqps(int *m, int *n, int *offset, int *nb, int *kb, c *a, int *lda, int *jpvt, c *tau, s *vn1, s *vn2, c *auxv, c *f, int *ldf) noexcept nogil +cdef void claqr0(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, c *h, int *ldh, c *w, int *iloz, int *ihiz, c *z, int *ldz, c *work, int *lwork, int *info) noexcept nogil +cdef void claqr1(int *n, c *h, int *ldh, c *s1, c *s2, c *v) noexcept nogil +cdef void claqr2(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, c *h, int *ldh, int *iloz, int *ihiz, c *z, int *ldz, int *ns, int *nd, c *sh, c *v, int *ldv, int *nh, c *t, int *ldt, int *nv, c *wv, int *ldwv, c *work, int *lwork) noexcept nogil +cdef void claqr3(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, c *h, int *ldh, int *iloz, int *ihiz, c *z, int *ldz, int *ns, int *nd, c *sh, c *v, int *ldv, int *nh, c *t, int *ldt, int *nv, c *wv, int *ldwv, c *work, int *lwork) noexcept nogil +cdef void claqr4(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, c *h, int *ldh, c *w, int *iloz, int *ihiz, c *z, int *ldz, c *work, int *lwork, int *info) noexcept nogil +cdef void claqr5(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, c *s, c *h, int *ldh, int *iloz, int *ihiz, c *z, int *ldz, c *v, int *ldv, c *u, int *ldu, int *nv, c *wv, int *ldwv, int *nh, c *wh, int *ldwh) noexcept nogil +cdef void claqsb(char *uplo, int *n, int *kd, c *ab, int *ldab, s *s, s *scond, s *amax, char *equed) noexcept nogil +cdef void claqsp(char *uplo, int *n, c *ap, s *s, s *scond, s *amax, char *equed) noexcept nogil +cdef void claqsy(char *uplo, int *n, c *a, int *lda, s *s, s *scond, s *amax, char *equed) noexcept nogil +cdef void clar1v(int *n, int *b1, int *bn, s *lambda_, s *d, s *l, s *ld, s *lld, s *pivmin, s *gaptol, c *z, bint *wantnc, int *negcnt, s *ztz, s *mingma, int *r, int *isuppz, s *nrminv, s *resid, s *rqcorr, s *work) noexcept nogil +cdef void clar2v(int *n, c *x, c *y, c *z, int *incx, s *c, c *s, int *incc) noexcept nogil +cdef void clarcm(int *m, int *n, s *a, int *lda, c *b, int *ldb, c *c, int *ldc, s *rwork) noexcept nogil +cdef void clarf(char *side, int *m, int *n, c *v, int *incv, c *tau, c *c, int *ldc, c *work) noexcept nogil +cdef void clarfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, c *v, int *ldv, c *t, int *ldt, c *c, int *ldc, c *work, int *ldwork) noexcept nogil +cdef void clarfg(int *n, c *alpha, c *x, int *incx, c *tau) noexcept nogil +cdef void clarfgp(int *n, c *alpha, c *x, int *incx, c *tau) noexcept nogil +cdef void clarft(char *direct, char *storev, int *n, int *k, c *v, int *ldv, c *tau, c *t, int *ldt) noexcept nogil +cdef void clarfx(char *side, int *m, int *n, c *v, c *tau, c *c, int *ldc, c *work) noexcept nogil +cdef void clargv(int *n, c *x, int *incx, c *y, int *incy, s *c, int *incc) noexcept nogil +cdef void clarnv(int *idist, int *iseed, int *n, c *x) noexcept nogil +cdef void clarrv(int *n, s *vl, s *vu, s *d, s *l, s *pivmin, int *isplit, int *m, int *dol, int *dou, s *minrgp, s *rtol1, s *rtol2, s *w, s *werr, s *wgap, int *iblock, int *indexw, s *gers, c *z, int *ldz, int *isuppz, s *work, int *iwork, int *info) noexcept nogil +cdef void clartg(c *f, c *g, s *cs, c *sn, c *r) noexcept nogil +cdef void clartv(int *n, c *x, int *incx, c *y, int *incy, s *c, c *s, int *incc) noexcept nogil +cdef void clarz(char *side, int *m, int *n, int *l, c *v, int *incv, c *tau, c *c, int *ldc, c *work) noexcept nogil +cdef void clarzb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, c *v, int *ldv, c *t, int *ldt, c *c, int *ldc, c *work, int *ldwork) noexcept nogil +cdef void clarzt(char *direct, char *storev, int *n, int *k, c *v, int *ldv, c *tau, c *t, int *ldt) noexcept nogil +cdef void clascl(char *type_bn, int *kl, int *ku, s *cfrom, s *cto, int *m, int *n, c *a, int *lda, int *info) noexcept nogil +cdef void claset(char *uplo, int *m, int *n, c *alpha, c *beta, c *a, int *lda) noexcept nogil +cdef void clasr(char *side, char *pivot, char *direct, int *m, int *n, s *c, s *s, c *a, int *lda) noexcept nogil +cdef void classq(int *n, c *x, int *incx, s *scale, s *sumsq) noexcept nogil +cdef void claswp(int *n, c *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) noexcept nogil +cdef void clasyf(char *uplo, int *n, int *nb, int *kb, c *a, int *lda, int *ipiv, c *w, int *ldw, int *info) noexcept nogil +cdef void clatbs(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, c *ab, int *ldab, c *x, s *scale, s *cnorm, int *info) noexcept nogil +cdef void clatdf(int *ijob, int *n, c *z, int *ldz, c *rhs, s *rdsum, s *rdscal, int *ipiv, int *jpiv) noexcept nogil +cdef void clatps(char *uplo, char *trans, char *diag, char *normin, int *n, c *ap, c *x, s *scale, s *cnorm, int *info) noexcept nogil +cdef void clatrd(char *uplo, int *n, int *nb, c *a, int *lda, s *e, c *tau, c *w, int *ldw) noexcept nogil +cdef void clatrs(char *uplo, char *trans, char *diag, char *normin, int *n, c *a, int *lda, c *x, s *scale, s *cnorm, int *info) noexcept nogil +cdef void clatrz(int *m, int *n, int *l, c *a, int *lda, c *tau, c *work) noexcept nogil +cdef void clauu2(char *uplo, int *n, c *a, int *lda, int *info) noexcept nogil +cdef void clauum(char *uplo, int *n, c *a, int *lda, int *info) noexcept nogil +cdef void cpbcon(char *uplo, int *n, int *kd, c *ab, int *ldab, s *anorm, s *rcond, c *work, s *rwork, int *info) noexcept nogil +cdef void cpbequ(char *uplo, int *n, int *kd, c *ab, int *ldab, s *s, s *scond, s *amax, int *info) noexcept nogil +cdef void cpbrfs(char *uplo, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *afb, int *ldafb, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cpbstf(char *uplo, int *n, int *kd, c *ab, int *ldab, int *info) noexcept nogil +cdef void cpbsv(char *uplo, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *b, int *ldb, int *info) noexcept nogil +cdef void cpbsvx(char *fact, char *uplo, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *afb, int *ldafb, char *equed, s *s, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cpbtf2(char *uplo, int *n, int *kd, c *ab, int *ldab, int *info) noexcept nogil +cdef void cpbtrf(char *uplo, int *n, int *kd, c *ab, int *ldab, int *info) noexcept nogil +cdef void cpbtrs(char *uplo, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *b, int *ldb, int *info) noexcept nogil +cdef void cpftrf(char *transr, char *uplo, int *n, c *a, int *info) noexcept nogil +cdef void cpftri(char *transr, char *uplo, int *n, c *a, int *info) noexcept nogil +cdef void cpftrs(char *transr, char *uplo, int *n, int *nrhs, c *a, c *b, int *ldb, int *info) noexcept nogil +cdef void cpocon(char *uplo, int *n, c *a, int *lda, s *anorm, s *rcond, c *work, s *rwork, int *info) noexcept nogil +cdef void cpoequ(int *n, c *a, int *lda, s *s, s *scond, s *amax, int *info) noexcept nogil +cdef void cpoequb(int *n, c *a, int *lda, s *s, s *scond, s *amax, int *info) noexcept nogil +cdef void cporfs(char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cposv(char *uplo, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, int *info) noexcept nogil +cdef void cposvx(char *fact, char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, char *equed, s *s, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cpotf2(char *uplo, int *n, c *a, int *lda, int *info) noexcept nogil +cdef void cpotrf(char *uplo, int *n, c *a, int *lda, int *info) noexcept nogil +cdef void cpotri(char *uplo, int *n, c *a, int *lda, int *info) noexcept nogil +cdef void cpotrs(char *uplo, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, int *info) noexcept nogil +cdef void cppcon(char *uplo, int *n, c *ap, s *anorm, s *rcond, c *work, s *rwork, int *info) noexcept nogil +cdef void cppequ(char *uplo, int *n, c *ap, s *s, s *scond, s *amax, int *info) noexcept nogil +cdef void cpprfs(char *uplo, int *n, int *nrhs, c *ap, c *afp, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cppsv(char *uplo, int *n, int *nrhs, c *ap, c *b, int *ldb, int *info) noexcept nogil +cdef void cppsvx(char *fact, char *uplo, int *n, int *nrhs, c *ap, c *afp, char *equed, s *s, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cpptrf(char *uplo, int *n, c *ap, int *info) noexcept nogil +cdef void cpptri(char *uplo, int *n, c *ap, int *info) noexcept nogil +cdef void cpptrs(char *uplo, int *n, int *nrhs, c *ap, c *b, int *ldb, int *info) noexcept nogil +cdef void cpstf2(char *uplo, int *n, c *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) noexcept nogil +cdef void cpstrf(char *uplo, int *n, c *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) noexcept nogil +cdef void cptcon(int *n, s *d, c *e, s *anorm, s *rcond, s *rwork, int *info) noexcept nogil +cdef void cpteqr(char *compz, int *n, s *d, s *e, c *z, int *ldz, s *work, int *info) noexcept nogil +cdef void cptrfs(char *uplo, int *n, int *nrhs, s *d, c *e, s *df, c *ef, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cptsv(int *n, int *nrhs, s *d, c *e, c *b, int *ldb, int *info) noexcept nogil +cdef void cptsvx(char *fact, int *n, int *nrhs, s *d, c *e, s *df, c *ef, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cpttrf(int *n, s *d, c *e, int *info) noexcept nogil +cdef void cpttrs(char *uplo, int *n, int *nrhs, s *d, c *e, c *b, int *ldb, int *info) noexcept nogil +cdef void cptts2(int *iuplo, int *n, int *nrhs, s *d, c *e, c *b, int *ldb) noexcept nogil +cdef void crot(int *n, c *cx, int *incx, c *cy, int *incy, s *c, c *s) noexcept nogil +cdef void cspcon(char *uplo, int *n, c *ap, int *ipiv, s *anorm, s *rcond, c *work, int *info) noexcept nogil +cdef void cspmv(char *uplo, int *n, c *alpha, c *ap, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil +cdef void cspr(char *uplo, int *n, c *alpha, c *x, int *incx, c *ap) noexcept nogil +cdef void csprfs(char *uplo, int *n, int *nrhs, c *ap, c *afp, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void cspsv(char *uplo, int *n, int *nrhs, c *ap, int *ipiv, c *b, int *ldb, int *info) noexcept nogil +cdef void cspsvx(char *fact, char *uplo, int *n, int *nrhs, c *ap, c *afp, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void csptrf(char *uplo, int *n, c *ap, int *ipiv, int *info) noexcept nogil +cdef void csptri(char *uplo, int *n, c *ap, int *ipiv, c *work, int *info) noexcept nogil +cdef void csptrs(char *uplo, int *n, int *nrhs, c *ap, int *ipiv, c *b, int *ldb, int *info) noexcept nogil +cdef void csrscl(int *n, s *sa, c *sx, int *incx) noexcept nogil +cdef void cstedc(char *compz, int *n, s *d, s *e, c *z, int *ldz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void cstegr(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void cstein(int *n, s *d, s *e, int *m, s *w, int *iblock, int *isplit, c *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void cstemr(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, int *m, s *w, c *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void csteqr(char *compz, int *n, s *d, s *e, c *z, int *ldz, s *work, int *info) noexcept nogil +cdef void csycon(char *uplo, int *n, c *a, int *lda, int *ipiv, s *anorm, s *rcond, c *work, int *info) noexcept nogil +cdef void csyconv(char *uplo, char *way, int *n, c *a, int *lda, int *ipiv, c *work, int *info) noexcept nogil +cdef void csyequb(char *uplo, int *n, c *a, int *lda, s *s, s *scond, s *amax, c *work, int *info) noexcept nogil +cdef void csymv(char *uplo, int *n, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil +cdef void csyr(char *uplo, int *n, c *alpha, c *x, int *incx, c *a, int *lda) noexcept nogil +cdef void csyrfs(char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void csysv(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, c *work, int *lwork, int *info) noexcept nogil +cdef void csysvx(char *fact, char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, int *lwork, s *rwork, int *info) noexcept nogil +cdef void csyswapr(char *uplo, int *n, c *a, int *lda, int *i1, int *i2) noexcept nogil +cdef void csytf2(char *uplo, int *n, c *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void csytrf(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *lwork, int *info) noexcept nogil +cdef void csytri(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *info) noexcept nogil +cdef void csytri2(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *lwork, int *info) noexcept nogil +cdef void csytri2x(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *nb, int *info) noexcept nogil +cdef void csytrs(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, int *info) noexcept nogil +cdef void csytrs2(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, c *work, int *info) noexcept nogil +cdef void ctbcon(char *norm, char *uplo, char *diag, int *n, int *kd, c *ab, int *ldab, s *rcond, c *work, s *rwork, int *info) noexcept nogil +cdef void ctbrfs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void ctbtrs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *b, int *ldb, int *info) noexcept nogil +cdef void ctfsm(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, c *alpha, c *a, c *b, int *ldb) noexcept nogil +cdef void ctftri(char *transr, char *uplo, char *diag, int *n, c *a, int *info) noexcept nogil +cdef void ctfttp(char *transr, char *uplo, int *n, c *arf, c *ap, int *info) noexcept nogil +cdef void ctfttr(char *transr, char *uplo, int *n, c *arf, c *a, int *lda, int *info) noexcept nogil +cdef void ctgevc(char *side, char *howmny, bint *select, int *n, c *s, int *lds, c *p, int *ldp, c *vl, int *ldvl, c *vr, int *ldvr, int *mm, int *m, c *work, s *rwork, int *info) noexcept nogil +cdef void ctgex2(bint *wantq, bint *wantz, int *n, c *a, int *lda, c *b, int *ldb, c *q, int *ldq, c *z, int *ldz, int *j1, int *info) noexcept nogil +cdef void ctgexc(bint *wantq, bint *wantz, int *n, c *a, int *lda, c *b, int *ldb, c *q, int *ldq, c *z, int *ldz, int *ifst, int *ilst, int *info) noexcept nogil +cdef void ctgsen(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, c *a, int *lda, c *b, int *ldb, c *alpha, c *beta, c *q, int *ldq, c *z, int *ldz, int *m, s *pl, s *pr, s *dif, c *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void ctgsja(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, c *a, int *lda, c *b, int *ldb, s *tola, s *tolb, s *alpha, s *beta, c *u, int *ldu, c *v, int *ldv, c *q, int *ldq, c *work, int *ncycle, int *info) noexcept nogil +cdef void ctgsna(char *job, char *howmny, bint *select, int *n, c *a, int *lda, c *b, int *ldb, c *vl, int *ldvl, c *vr, int *ldvr, s *s, s *dif, int *mm, int *m, c *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void ctgsy2(char *trans, int *ijob, int *m, int *n, c *a, int *lda, c *b, int *ldb, c *c, int *ldc, c *d, int *ldd, c *e, int *lde, c *f, int *ldf, s *scale, s *rdsum, s *rdscal, int *info) noexcept nogil +cdef void ctgsyl(char *trans, int *ijob, int *m, int *n, c *a, int *lda, c *b, int *ldb, c *c, int *ldc, c *d, int *ldd, c *e, int *lde, c *f, int *ldf, s *scale, s *dif, c *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void ctpcon(char *norm, char *uplo, char *diag, int *n, c *ap, s *rcond, c *work, s *rwork, int *info) noexcept nogil +cdef void ctpmqrt(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, c *v, int *ldv, c *t, int *ldt, c *a, int *lda, c *b, int *ldb, c *work, int *info) noexcept nogil +cdef void ctpqrt(int *m, int *n, int *l, int *nb, c *a, int *lda, c *b, int *ldb, c *t, int *ldt, c *work, int *info) noexcept nogil +cdef void ctpqrt2(int *m, int *n, int *l, c *a, int *lda, c *b, int *ldb, c *t, int *ldt, int *info) noexcept nogil +cdef void ctprfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, c *v, int *ldv, c *t, int *ldt, c *a, int *lda, c *b, int *ldb, c *work, int *ldwork) noexcept nogil +cdef void ctprfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, c *ap, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void ctptri(char *uplo, char *diag, int *n, c *ap, int *info) noexcept nogil +cdef void ctptrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, c *ap, c *b, int *ldb, int *info) noexcept nogil +cdef void ctpttf(char *transr, char *uplo, int *n, c *ap, c *arf, int *info) noexcept nogil +cdef void ctpttr(char *uplo, int *n, c *ap, c *a, int *lda, int *info) noexcept nogil +cdef void ctrcon(char *norm, char *uplo, char *diag, int *n, c *a, int *lda, s *rcond, c *work, s *rwork, int *info) noexcept nogil +cdef void ctrevc(char *side, char *howmny, bint *select, int *n, c *t, int *ldt, c *vl, int *ldvl, c *vr, int *ldvr, int *mm, int *m, c *work, s *rwork, int *info) noexcept nogil +cdef void ctrexc(char *compq, int *n, c *t, int *ldt, c *q, int *ldq, int *ifst, int *ilst, int *info) noexcept nogil +cdef void ctrrfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil +cdef void ctrsen(char *job, char *compq, bint *select, int *n, c *t, int *ldt, c *q, int *ldq, c *w, int *m, s *s, s *sep, c *work, int *lwork, int *info) noexcept nogil +cdef void ctrsna(char *job, char *howmny, bint *select, int *n, c *t, int *ldt, c *vl, int *ldvl, c *vr, int *ldvr, s *s, s *sep, int *mm, int *m, c *work, int *ldwork, s *rwork, int *info) noexcept nogil +cdef void ctrsyl(char *trana, char *tranb, int *isgn, int *m, int *n, c *a, int *lda, c *b, int *ldb, c *c, int *ldc, s *scale, int *info) noexcept nogil +cdef void ctrti2(char *uplo, char *diag, int *n, c *a, int *lda, int *info) noexcept nogil +cdef void ctrtri(char *uplo, char *diag, int *n, c *a, int *lda, int *info) noexcept nogil +cdef void ctrtrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, int *info) noexcept nogil +cdef void ctrttf(char *transr, char *uplo, int *n, c *a, int *lda, c *arf, int *info) noexcept nogil +cdef void ctrttp(char *uplo, int *n, c *a, int *lda, c *ap, int *info) noexcept nogil +cdef void ctzrzf(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cunbdb(char *trans, char *signs, int *m, int *p, int *q, c *x11, int *ldx11, c *x12, int *ldx12, c *x21, int *ldx21, c *x22, int *ldx22, s *theta, s *phi, c *taup1, c *taup2, c *tauq1, c *tauq2, c *work, int *lwork, int *info) noexcept nogil +cdef void cuncsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, c *x11, int *ldx11, c *x12, int *ldx12, c *x21, int *ldx21, c *x22, int *ldx22, s *theta, c *u1, int *ldu1, c *u2, int *ldu2, c *v1t, int *ldv1t, c *v2t, int *ldv2t, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *info) noexcept nogil +cdef void cung2l(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil +cdef void cung2r(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil +cdef void cungbr(char *vect, int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cunghr(int *n, int *ilo, int *ihi, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cungl2(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil +cdef void cunglq(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cungql(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cungqr(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cungr2(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil +cdef void cungrq(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cungtr(char *uplo, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil +cdef void cunm2l(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil +cdef void cunm2r(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil +cdef void cunmbr(char *vect, char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil +cdef void cunmhr(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil +cdef void cunml2(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil +cdef void cunmlq(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil +cdef void cunmql(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil +cdef void cunmqr(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil +cdef void cunmr2(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil +cdef void cunmr3(char *side, char *trans, int *m, int *n, int *k, int *l, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil +cdef void cunmrq(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil +cdef void cunmrz(char *side, char *trans, int *m, int *n, int *k, int *l, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil +cdef void cunmtr(char *side, char *uplo, char *trans, int *m, int *n, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil +cdef void cupgtr(char *uplo, int *n, c *ap, c *tau, c *q, int *ldq, c *work, int *info) noexcept nogil +cdef void cupmtr(char *side, char *uplo, char *trans, int *m, int *n, c *ap, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil +cdef void dbbcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, d *theta, d *phi, d *u1, int *ldu1, d *u2, int *ldu2, d *v1t, int *ldv1t, d *v2t, int *ldv2t, d *b11d, d *b11e, d *b12d, d *b12e, d *b21d, d *b21e, d *b22d, d *b22e, d *work, int *lwork, int *info) noexcept nogil +cdef void dbdsdc(char *uplo, char *compq, int *n, d *d, d *e, d *u, int *ldu, d *vt, int *ldvt, d *q, int *iq, d *work, int *iwork, int *info) noexcept nogil +cdef void dbdsqr(char *uplo, int *n, int *ncvt, int *nru, int *ncc, d *d, d *e, d *vt, int *ldvt, d *u, int *ldu, d *c, int *ldc, d *work, int *info) noexcept nogil +cdef void ddisna(char *job, int *m, int *n, d *d, d *sep, int *info) noexcept nogil +cdef void dgbbrd(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, d *ab, int *ldab, d *d, d *e, d *q, int *ldq, d *pt, int *ldpt, d *c, int *ldc, d *work, int *info) noexcept nogil +cdef void dgbcon(char *norm, int *n, int *kl, int *ku, d *ab, int *ldab, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil +cdef void dgbequ(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil +cdef void dgbequb(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil +cdef void dgbrfs(char *trans, int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dgbsv(int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, int *ipiv, d *b, int *ldb, int *info) noexcept nogil +cdef void dgbsvx(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, int *ipiv, char *equed, d *r, d *c, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dgbtf2(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, int *ipiv, int *info) noexcept nogil +cdef void dgbtrf(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, int *ipiv, int *info) noexcept nogil +cdef void dgbtrs(char *trans, int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, int *ipiv, d *b, int *ldb, int *info) noexcept nogil +cdef void dgebak(char *job, char *side, int *n, int *ilo, int *ihi, d *scale, int *m, d *v, int *ldv, int *info) noexcept nogil +cdef void dgebal(char *job, int *n, d *a, int *lda, int *ilo, int *ihi, d *scale, int *info) noexcept nogil +cdef void dgebd2(int *m, int *n, d *a, int *lda, d *d, d *e, d *tauq, d *taup, d *work, int *info) noexcept nogil +cdef void dgebrd(int *m, int *n, d *a, int *lda, d *d, d *e, d *tauq, d *taup, d *work, int *lwork, int *info) noexcept nogil +cdef void dgecon(char *norm, int *n, d *a, int *lda, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil +cdef void dgeequ(int *m, int *n, d *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil +cdef void dgeequb(int *m, int *n, d *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil +cdef void dgees(char *jobvs, char *sort, dselect2 *select, int *n, d *a, int *lda, int *sdim, d *wr, d *wi, d *vs, int *ldvs, d *work, int *lwork, bint *bwork, int *info) noexcept nogil +cdef void dgeesx(char *jobvs, char *sort, dselect2 *select, char *sense, int *n, d *a, int *lda, int *sdim, d *wr, d *wi, d *vs, int *ldvs, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil +cdef void dgeev(char *jobvl, char *jobvr, int *n, d *a, int *lda, d *wr, d *wi, d *vl, int *ldvl, d *vr, int *ldvr, d *work, int *lwork, int *info) noexcept nogil +cdef void dgeevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, d *a, int *lda, d *wr, d *wi, d *vl, int *ldvl, d *vr, int *ldvr, int *ilo, int *ihi, d *scale, d *abnrm, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void dgehd2(int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil +cdef void dgehrd(int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dgejsv(char *joba, char *jobu, char *jobv, char *jobr, char *jobt, char *jobp, int *m, int *n, d *a, int *lda, d *sva, d *u, int *ldu, d *v, int *ldv, d *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void dgelq2(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil +cdef void dgelqf(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dgels(char *trans, int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *work, int *lwork, int *info) noexcept nogil +cdef void dgelsd(int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *s, d *rcond, int *rank, d *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void dgelss(int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *s, d *rcond, int *rank, d *work, int *lwork, int *info) noexcept nogil +cdef void dgelsy(int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *jpvt, d *rcond, int *rank, d *work, int *lwork, int *info) noexcept nogil +cdef void dgemqrt(char *side, char *trans, int *m, int *n, int *k, int *nb, d *v, int *ldv, d *t, int *ldt, d *c, int *ldc, d *work, int *info) noexcept nogil +cdef void dgeql2(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil +cdef void dgeqlf(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dgeqp3(int *m, int *n, d *a, int *lda, int *jpvt, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dgeqr2(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil +cdef void dgeqr2p(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil +cdef void dgeqrf(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dgeqrfp(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dgeqrt(int *m, int *n, int *nb, d *a, int *lda, d *t, int *ldt, d *work, int *info) noexcept nogil +cdef void dgeqrt2(int *m, int *n, d *a, int *lda, d *t, int *ldt, int *info) noexcept nogil +cdef void dgeqrt3(int *m, int *n, d *a, int *lda, d *t, int *ldt, int *info) noexcept nogil +cdef void dgerfs(char *trans, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dgerq2(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil +cdef void dgerqf(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dgesc2(int *n, d *a, int *lda, d *rhs, int *ipiv, int *jpiv, d *scale) noexcept nogil +cdef void dgesdd(char *jobz, int *m, int *n, d *a, int *lda, d *s, d *u, int *ldu, d *vt, int *ldvt, d *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void dgesv(int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, int *info) noexcept nogil +cdef void dgesvd(char *jobu, char *jobvt, int *m, int *n, d *a, int *lda, d *s, d *u, int *ldu, d *vt, int *ldvt, d *work, int *lwork, int *info) noexcept nogil +cdef void dgesvj(char *joba, char *jobu, char *jobv, int *m, int *n, d *a, int *lda, d *sva, int *mv, d *v, int *ldv, d *work, int *lwork, int *info) noexcept nogil +cdef void dgesvx(char *fact, char *trans, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, char *equed, d *r, d *c, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dgetc2(int *n, d *a, int *lda, int *ipiv, int *jpiv, int *info) noexcept nogil +cdef void dgetf2(int *m, int *n, d *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void dgetrf(int *m, int *n, d *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void dgetri(int *n, d *a, int *lda, int *ipiv, d *work, int *lwork, int *info) noexcept nogil +cdef void dgetrs(char *trans, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, int *info) noexcept nogil +cdef void dggbak(char *job, char *side, int *n, int *ilo, int *ihi, d *lscale, d *rscale, int *m, d *v, int *ldv, int *info) noexcept nogil +cdef void dggbal(char *job, int *n, d *a, int *lda, d *b, int *ldb, int *ilo, int *ihi, d *lscale, d *rscale, d *work, int *info) noexcept nogil +cdef void dgges(char *jobvsl, char *jobvsr, char *sort, dselect3 *selctg, int *n, d *a, int *lda, d *b, int *ldb, int *sdim, d *alphar, d *alphai, d *beta, d *vsl, int *ldvsl, d *vsr, int *ldvsr, d *work, int *lwork, bint *bwork, int *info) noexcept nogil +cdef void dggesx(char *jobvsl, char *jobvsr, char *sort, dselect3 *selctg, char *sense, int *n, d *a, int *lda, d *b, int *ldb, int *sdim, d *alphar, d *alphai, d *beta, d *vsl, int *ldvsl, d *vsr, int *ldvsr, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil +cdef void dggev(char *jobvl, char *jobvr, int *n, d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *vl, int *ldvl, d *vr, int *ldvr, d *work, int *lwork, int *info) noexcept nogil +cdef void dggevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *vl, int *ldvl, d *vr, int *ldvr, int *ilo, int *ihi, d *lscale, d *rscale, d *abnrm, d *bbnrm, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, bint *bwork, int *info) noexcept nogil +cdef void dggglm(int *n, int *m, int *p, d *a, int *lda, d *b, int *ldb, d *d, d *x, d *y, d *work, int *lwork, int *info) noexcept nogil +cdef void dgghrd(char *compq, char *compz, int *n, int *ilo, int *ihi, d *a, int *lda, d *b, int *ldb, d *q, int *ldq, d *z, int *ldz, int *info) noexcept nogil +cdef void dgglse(int *m, int *n, int *p, d *a, int *lda, d *b, int *ldb, d *c, d *d, d *x, d *work, int *lwork, int *info) noexcept nogil +cdef void dggqrf(int *n, int *m, int *p, d *a, int *lda, d *taua, d *b, int *ldb, d *taub, d *work, int *lwork, int *info) noexcept nogil +cdef void dggrqf(int *m, int *p, int *n, d *a, int *lda, d *taua, d *b, int *ldb, d *taub, d *work, int *lwork, int *info) noexcept nogil +cdef void dgsvj0(char *jobv, int *m, int *n, d *a, int *lda, d *d, d *sva, int *mv, d *v, int *ldv, d *eps, d *sfmin, d *tol, int *nsweep, d *work, int *lwork, int *info) noexcept nogil +cdef void dgsvj1(char *jobv, int *m, int *n, int *n1, d *a, int *lda, d *d, d *sva, int *mv, d *v, int *ldv, d *eps, d *sfmin, d *tol, int *nsweep, d *work, int *lwork, int *info) noexcept nogil +cdef void dgtcon(char *norm, int *n, d *dl, d *d, d *du, d *du2, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil +cdef void dgtrfs(char *trans, int *n, int *nrhs, d *dl, d *d, d *du, d *dlf, d *df, d *duf, d *du2, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dgtsv(int *n, int *nrhs, d *dl, d *d, d *du, d *b, int *ldb, int *info) noexcept nogil +cdef void dgtsvx(char *fact, char *trans, int *n, int *nrhs, d *dl, d *d, d *du, d *dlf, d *df, d *duf, d *du2, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dgttrf(int *n, d *dl, d *d, d *du, d *du2, int *ipiv, int *info) noexcept nogil +cdef void dgttrs(char *trans, int *n, int *nrhs, d *dl, d *d, d *du, d *du2, int *ipiv, d *b, int *ldb, int *info) noexcept nogil +cdef void dgtts2(int *itrans, int *n, int *nrhs, d *dl, d *d, d *du, d *du2, int *ipiv, d *b, int *ldb) noexcept nogil +cdef void dhgeqz(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *t, int *ldt, d *alphar, d *alphai, d *beta, d *q, int *ldq, d *z, int *ldz, d *work, int *lwork, int *info) noexcept nogil +cdef void dhsein(char *side, char *eigsrc, char *initv, bint *select, int *n, d *h, int *ldh, d *wr, d *wi, d *vl, int *ldvl, d *vr, int *ldvr, int *mm, int *m, d *work, int *ifaill, int *ifailr, int *info) noexcept nogil +cdef void dhseqr(char *job, char *compz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, d *z, int *ldz, d *work, int *lwork, int *info) noexcept nogil +cdef bint disnan(d *din) noexcept nogil +cdef void dlabad(d *small, d *large) noexcept nogil +cdef void dlabrd(int *m, int *n, int *nb, d *a, int *lda, d *d, d *e, d *tauq, d *taup, d *x, int *ldx, d *y, int *ldy) noexcept nogil +cdef void dlacn2(int *n, d *v, d *x, int *isgn, d *est, int *kase, int *isave) noexcept nogil +cdef void dlacon(int *n, d *v, d *x, int *isgn, d *est, int *kase) noexcept nogil +cdef void dlacpy(char *uplo, int *m, int *n, d *a, int *lda, d *b, int *ldb) noexcept nogil +cdef void dladiv(d *a, d *b, d *c, d *d, d *p, d *q) noexcept nogil +cdef void dlae2(d *a, d *b, d *c, d *rt1, d *rt2) noexcept nogil +cdef void dlaebz(int *ijob, int *nitmax, int *n, int *mmax, int *minp, int *nbmin, d *abstol, d *reltol, d *pivmin, d *d, d *e, d *e2, int *nval, d *ab, d *c, int *mout, int *nab, d *work, int *iwork, int *info) noexcept nogil +cdef void dlaed0(int *icompq, int *qsiz, int *n, d *d, d *e, d *q, int *ldq, d *qstore, int *ldqs, d *work, int *iwork, int *info) noexcept nogil +cdef void dlaed1(int *n, d *d, d *q, int *ldq, int *indxq, d *rho, int *cutpnt, d *work, int *iwork, int *info) noexcept nogil +cdef void dlaed2(int *k, int *n, int *n1, d *d, d *q, int *ldq, int *indxq, d *rho, d *z, d *dlamda, d *w, d *q2, int *indx, int *indxc, int *indxp, int *coltyp, int *info) noexcept nogil +cdef void dlaed3(int *k, int *n, int *n1, d *d, d *q, int *ldq, d *rho, d *dlamda, d *q2, int *indx, int *ctot, d *w, d *s, int *info) noexcept nogil +cdef void dlaed4(int *n, int *i, d *d, d *z, d *delta, d *rho, d *dlam, int *info) noexcept nogil +cdef void dlaed5(int *i, d *d, d *z, d *delta, d *rho, d *dlam) noexcept nogil +cdef void dlaed6(int *kniter, bint *orgati, d *rho, d *d, d *z, d *finit, d *tau, int *info) noexcept nogil +cdef void dlaed7(int *icompq, int *n, int *qsiz, int *tlvls, int *curlvl, int *curpbm, d *d, d *q, int *ldq, int *indxq, d *rho, int *cutpnt, d *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, d *givnum, d *work, int *iwork, int *info) noexcept nogil +cdef void dlaed8(int *icompq, int *k, int *n, int *qsiz, d *d, d *q, int *ldq, int *indxq, d *rho, int *cutpnt, d *z, d *dlamda, d *q2, int *ldq2, d *w, int *perm, int *givptr, int *givcol, d *givnum, int *indxp, int *indx, int *info) noexcept nogil +cdef void dlaed9(int *k, int *kstart, int *kstop, int *n, d *d, d *q, int *ldq, d *rho, d *dlamda, d *w, d *s, int *lds, int *info) noexcept nogil +cdef void dlaeda(int *n, int *tlvls, int *curlvl, int *curpbm, int *prmptr, int *perm, int *givptr, int *givcol, d *givnum, d *q, int *qptr, d *z, d *ztemp, int *info) noexcept nogil +cdef void dlaein(bint *rightv, bint *noinit, int *n, d *h, int *ldh, d *wr, d *wi, d *vr, d *vi, d *b, int *ldb, d *work, d *eps3, d *smlnum, d *bignum, int *info) noexcept nogil +cdef void dlaev2(d *a, d *b, d *c, d *rt1, d *rt2, d *cs1, d *sn1) noexcept nogil +cdef void dlaexc(bint *wantq, int *n, d *t, int *ldt, d *q, int *ldq, int *j1, int *n1, int *n2, d *work, int *info) noexcept nogil +cdef void dlag2(d *a, int *lda, d *b, int *ldb, d *safmin, d *scale1, d *scale2, d *wr1, d *wr2, d *wi) noexcept nogil +cdef void dlag2s(int *m, int *n, d *a, int *lda, s *sa, int *ldsa, int *info) noexcept nogil +cdef void dlags2(bint *upper, d *a1, d *a2, d *a3, d *b1, d *b2, d *b3, d *csu, d *snu, d *csv, d *snv, d *csq, d *snq) noexcept nogil +cdef void dlagtf(int *n, d *a, d *lambda_, d *b, d *c, d *tol, d *d, int *in_, int *info) noexcept nogil +cdef void dlagtm(char *trans, int *n, int *nrhs, d *alpha, d *dl, d *d, d *du, d *x, int *ldx, d *beta, d *b, int *ldb) noexcept nogil +cdef void dlagts(int *job, int *n, d *a, d *b, d *c, d *d, int *in_, d *y, d *tol, int *info) noexcept nogil +cdef void dlagv2(d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *csl, d *snl, d *csr, d *snr) noexcept nogil +cdef void dlahqr(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, int *iloz, int *ihiz, d *z, int *ldz, int *info) noexcept nogil +cdef void dlahr2(int *n, int *k, int *nb, d *a, int *lda, d *tau, d *t, int *ldt, d *y, int *ldy) noexcept nogil +cdef void dlaic1(int *job, int *j, d *x, d *sest, d *w, d *gamma, d *sestpr, d *s, d *c) noexcept nogil +cdef void dlaln2(bint *ltrans, int *na, int *nw, d *smin, d *ca, d *a, int *lda, d *d1, d *d2, d *b, int *ldb, d *wr, d *wi, d *x, int *ldx, d *scale, d *xnorm, int *info) noexcept nogil +cdef void dlals0(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, d *b, int *ldb, d *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *poles, d *difl, d *difr, d *z, int *k, d *c, d *s, d *work, int *info) noexcept nogil +cdef void dlalsa(int *icompq, int *smlsiz, int *n, int *nrhs, d *b, int *ldb, d *bx, int *ldbx, d *u, int *ldu, d *vt, int *k, d *difl, d *difr, d *z, d *poles, int *givptr, int *givcol, int *ldgcol, int *perm, d *givnum, d *c, d *s, d *work, int *iwork, int *info) noexcept nogil +cdef void dlalsd(char *uplo, int *smlsiz, int *n, int *nrhs, d *d, d *e, d *b, int *ldb, d *rcond, int *rank, d *work, int *iwork, int *info) noexcept nogil +cdef d dlamch(char *cmach) noexcept nogil +cdef void dlamrg(int *n1, int *n2, d *a, int *dtrd1, int *dtrd2, int *index_bn) noexcept nogil +cdef int dlaneg(int *n, d *d, d *lld, d *sigma, d *pivmin, int *r) noexcept nogil +cdef d dlangb(char *norm, int *n, int *kl, int *ku, d *ab, int *ldab, d *work) noexcept nogil +cdef d dlange(char *norm, int *m, int *n, d *a, int *lda, d *work) noexcept nogil +cdef d dlangt(char *norm, int *n, d *dl, d *d_, d *du) noexcept nogil +cdef d dlanhs(char *norm, int *n, d *a, int *lda, d *work) noexcept nogil +cdef d dlansb(char *norm, char *uplo, int *n, int *k, d *ab, int *ldab, d *work) noexcept nogil +cdef d dlansf(char *norm, char *transr, char *uplo, int *n, d *a, d *work) noexcept nogil +cdef d dlansp(char *norm, char *uplo, int *n, d *ap, d *work) noexcept nogil +cdef d dlanst(char *norm, int *n, d *d_, d *e) noexcept nogil +cdef d dlansy(char *norm, char *uplo, int *n, d *a, int *lda, d *work) noexcept nogil +cdef d dlantb(char *norm, char *uplo, char *diag, int *n, int *k, d *ab, int *ldab, d *work) noexcept nogil +cdef d dlantp(char *norm, char *uplo, char *diag, int *n, d *ap, d *work) noexcept nogil +cdef d dlantr(char *norm, char *uplo, char *diag, int *m, int *n, d *a, int *lda, d *work) noexcept nogil +cdef void dlanv2(d *a, d *b, d *c, d *d, d *rt1r, d *rt1i, d *rt2r, d *rt2i, d *cs, d *sn) noexcept nogil +cdef void dlapll(int *n, d *x, int *incx, d *y, int *incy, d *ssmin) noexcept nogil +cdef void dlapmr(bint *forwrd, int *m, int *n, d *x, int *ldx, int *k) noexcept nogil +cdef void dlapmt(bint *forwrd, int *m, int *n, d *x, int *ldx, int *k) noexcept nogil +cdef d dlapy2(d *x, d *y) noexcept nogil +cdef d dlapy3(d *x, d *y, d *z) noexcept nogil +cdef void dlaqgb(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) noexcept nogil +cdef void dlaqge(int *m, int *n, d *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) noexcept nogil +cdef void dlaqp2(int *m, int *n, int *offset, d *a, int *lda, int *jpvt, d *tau, d *vn1, d *vn2, d *work) noexcept nogil +cdef void dlaqps(int *m, int *n, int *offset, int *nb, int *kb, d *a, int *lda, int *jpvt, d *tau, d *vn1, d *vn2, d *auxv, d *f, int *ldf) noexcept nogil +cdef void dlaqr0(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, int *iloz, int *ihiz, d *z, int *ldz, d *work, int *lwork, int *info) noexcept nogil +cdef void dlaqr1(int *n, d *h, int *ldh, d *sr1, d *si1, d *sr2, d *si2, d *v) noexcept nogil +cdef void dlaqr2(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, d *h, int *ldh, int *iloz, int *ihiz, d *z, int *ldz, int *ns, int *nd, d *sr, d *si, d *v, int *ldv, int *nh, d *t, int *ldt, int *nv, d *wv, int *ldwv, d *work, int *lwork) noexcept nogil +cdef void dlaqr3(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, d *h, int *ldh, int *iloz, int *ihiz, d *z, int *ldz, int *ns, int *nd, d *sr, d *si, d *v, int *ldv, int *nh, d *t, int *ldt, int *nv, d *wv, int *ldwv, d *work, int *lwork) noexcept nogil +cdef void dlaqr4(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, int *iloz, int *ihiz, d *z, int *ldz, d *work, int *lwork, int *info) noexcept nogil +cdef void dlaqr5(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, d *sr, d *si, d *h, int *ldh, int *iloz, int *ihiz, d *z, int *ldz, d *v, int *ldv, d *u, int *ldu, int *nv, d *wv, int *ldwv, int *nh, d *wh, int *ldwh) noexcept nogil +cdef void dlaqsb(char *uplo, int *n, int *kd, d *ab, int *ldab, d *s, d *scond, d *amax, char *equed) noexcept nogil +cdef void dlaqsp(char *uplo, int *n, d *ap, d *s, d *scond, d *amax, char *equed) noexcept nogil +cdef void dlaqsy(char *uplo, int *n, d *a, int *lda, d *s, d *scond, d *amax, char *equed) noexcept nogil +cdef void dlaqtr(bint *ltran, bint *lreal, int *n, d *t, int *ldt, d *b, d *w, d *scale, d *x, d *work, int *info) noexcept nogil +cdef void dlar1v(int *n, int *b1, int *bn, d *lambda_, d *d, d *l, d *ld, d *lld, d *pivmin, d *gaptol, d *z, bint *wantnc, int *negcnt, d *ztz, d *mingma, int *r, int *isuppz, d *nrminv, d *resid, d *rqcorr, d *work) noexcept nogil +cdef void dlar2v(int *n, d *x, d *y, d *z, int *incx, d *c, d *s, int *incc) noexcept nogil +cdef void dlarf(char *side, int *m, int *n, d *v, int *incv, d *tau, d *c, int *ldc, d *work) noexcept nogil +cdef void dlarfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, d *v, int *ldv, d *t, int *ldt, d *c, int *ldc, d *work, int *ldwork) noexcept nogil +cdef void dlarfg(int *n, d *alpha, d *x, int *incx, d *tau) noexcept nogil +cdef void dlarfgp(int *n, d *alpha, d *x, int *incx, d *tau) noexcept nogil +cdef void dlarft(char *direct, char *storev, int *n, int *k, d *v, int *ldv, d *tau, d *t, int *ldt) noexcept nogil +cdef void dlarfx(char *side, int *m, int *n, d *v, d *tau, d *c, int *ldc, d *work) noexcept nogil +cdef void dlargv(int *n, d *x, int *incx, d *y, int *incy, d *c, int *incc) noexcept nogil +cdef void dlarnv(int *idist, int *iseed, int *n, d *x) noexcept nogil +cdef void dlarra(int *n, d *d, d *e, d *e2, d *spltol, d *tnrm, int *nsplit, int *isplit, int *info) noexcept nogil +cdef void dlarrb(int *n, d *d, d *lld, int *ifirst, int *ilast, d *rtol1, d *rtol2, int *offset, d *w, d *wgap, d *werr, d *work, int *iwork, d *pivmin, d *spdiam, int *twist, int *info) noexcept nogil +cdef void dlarrc(char *jobt, int *n, d *vl, d *vu, d *d, d *e, d *pivmin, int *eigcnt, int *lcnt, int *rcnt, int *info) noexcept nogil +cdef void dlarrd(char *range, char *order, int *n, d *vl, d *vu, int *il, int *iu, d *gers, d *reltol, d *d, d *e, d *e2, d *pivmin, int *nsplit, int *isplit, int *m, d *w, d *werr, d *wl, d *wu, int *iblock, int *indexw, d *work, int *iwork, int *info) noexcept nogil +cdef void dlarre(char *range, int *n, d *vl, d *vu, int *il, int *iu, d *d, d *e, d *e2, d *rtol1, d *rtol2, d *spltol, int *nsplit, int *isplit, int *m, d *w, d *werr, d *wgap, int *iblock, int *indexw, d *gers, d *pivmin, d *work, int *iwork, int *info) noexcept nogil +cdef void dlarrf(int *n, d *d, d *l, d *ld, int *clstrt, int *clend, d *w, d *wgap, d *werr, d *spdiam, d *clgapl, d *clgapr, d *pivmin, d *sigma, d *dplus, d *lplus, d *work, int *info) noexcept nogil +cdef void dlarrj(int *n, d *d, d *e2, int *ifirst, int *ilast, d *rtol, int *offset, d *w, d *werr, d *work, int *iwork, d *pivmin, d *spdiam, int *info) noexcept nogil +cdef void dlarrk(int *n, int *iw, d *gl, d *gu, d *d, d *e2, d *pivmin, d *reltol, d *w, d *werr, int *info) noexcept nogil +cdef void dlarrr(int *n, d *d, d *e, int *info) noexcept nogil +cdef void dlarrv(int *n, d *vl, d *vu, d *d, d *l, d *pivmin, int *isplit, int *m, int *dol, int *dou, d *minrgp, d *rtol1, d *rtol2, d *w, d *werr, d *wgap, int *iblock, int *indexw, d *gers, d *z, int *ldz, int *isuppz, d *work, int *iwork, int *info) noexcept nogil +cdef void dlartg(d *f, d *g, d *cs, d *sn, d *r) noexcept nogil +cdef void dlartgp(d *f, d *g, d *cs, d *sn, d *r) noexcept nogil +cdef void dlartgs(d *x, d *y, d *sigma, d *cs, d *sn) noexcept nogil +cdef void dlartv(int *n, d *x, int *incx, d *y, int *incy, d *c, d *s, int *incc) noexcept nogil +cdef void dlaruv(int *iseed, int *n, d *x) noexcept nogil +cdef void dlarz(char *side, int *m, int *n, int *l, d *v, int *incv, d *tau, d *c, int *ldc, d *work) noexcept nogil +cdef void dlarzb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, d *v, int *ldv, d *t, int *ldt, d *c, int *ldc, d *work, int *ldwork) noexcept nogil +cdef void dlarzt(char *direct, char *storev, int *n, int *k, d *v, int *ldv, d *tau, d *t, int *ldt) noexcept nogil +cdef void dlas2(d *f, d *g, d *h, d *ssmin, d *ssmax) noexcept nogil +cdef void dlascl(char *type_bn, int *kl, int *ku, d *cfrom, d *cto, int *m, int *n, d *a, int *lda, int *info) noexcept nogil +cdef void dlasd0(int *n, int *sqre, d *d, d *e, d *u, int *ldu, d *vt, int *ldvt, int *smlsiz, int *iwork, d *work, int *info) noexcept nogil +cdef void dlasd1(int *nl, int *nr, int *sqre, d *d, d *alpha, d *beta, d *u, int *ldu, d *vt, int *ldvt, int *idxq, int *iwork, d *work, int *info) noexcept nogil +cdef void dlasd2(int *nl, int *nr, int *sqre, int *k, d *d, d *z, d *alpha, d *beta, d *u, int *ldu, d *vt, int *ldvt, d *dsigma, d *u2, int *ldu2, d *vt2, int *ldvt2, int *idxp, int *idx, int *idxc, int *idxq, int *coltyp, int *info) noexcept nogil +cdef void dlasd3(int *nl, int *nr, int *sqre, int *k, d *d, d *q, int *ldq, d *dsigma, d *u, int *ldu, d *u2, int *ldu2, d *vt, int *ldvt, d *vt2, int *ldvt2, int *idxc, int *ctot, d *z, int *info) noexcept nogil +cdef void dlasd4(int *n, int *i, d *d, d *z, d *delta, d *rho, d *sigma, d *work, int *info) noexcept nogil +cdef void dlasd5(int *i, d *d, d *z, d *delta, d *rho, d *dsigma, d *work) noexcept nogil +cdef void dlasd6(int *icompq, int *nl, int *nr, int *sqre, d *d, d *vf, d *vl, d *alpha, d *beta, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *poles, d *difl, d *difr, d *z, int *k, d *c, d *s, d *work, int *iwork, int *info) noexcept nogil +cdef void dlasd7(int *icompq, int *nl, int *nr, int *sqre, int *k, d *d, d *z, d *zw, d *vf, d *vfw, d *vl, d *vlw, d *alpha, d *beta, d *dsigma, int *idx, int *idxp, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *c, d *s, int *info) noexcept nogil +cdef void dlasd8(int *icompq, int *k, d *d, d *z, d *vf, d *vl, d *difl, d *difr, int *lddifr, d *dsigma, d *work, int *info) noexcept nogil +cdef void dlasda(int *icompq, int *smlsiz, int *n, int *sqre, d *d, d *e, d *u, int *ldu, d *vt, int *k, d *difl, d *difr, d *z, d *poles, int *givptr, int *givcol, int *ldgcol, int *perm, d *givnum, d *c, d *s, d *work, int *iwork, int *info) noexcept nogil +cdef void dlasdq(char *uplo, int *sqre, int *n, int *ncvt, int *nru, int *ncc, d *d, d *e, d *vt, int *ldvt, d *u, int *ldu, d *c, int *ldc, d *work, int *info) noexcept nogil +cdef void dlasdt(int *n, int *lvl, int *nd, int *inode, int *ndiml, int *ndimr, int *msub) noexcept nogil +cdef void dlaset(char *uplo, int *m, int *n, d *alpha, d *beta, d *a, int *lda) noexcept nogil +cdef void dlasq1(int *n, d *d, d *e, d *work, int *info) noexcept nogil +cdef void dlasq2(int *n, d *z, int *info) noexcept nogil +cdef void dlasq3(int *i0, int *n0, d *z, int *pp, d *dmin, d *sigma, d *desig, d *qmax, int *nfail, int *iter, int *ndiv, bint *ieee, int *ttype, d *dmin1, d *dmin2, d *dn, d *dn1, d *dn2, d *g, d *tau) noexcept nogil +cdef void dlasq4(int *i0, int *n0, d *z, int *pp, int *n0in, d *dmin, d *dmin1, d *dmin2, d *dn, d *dn1, d *dn2, d *tau, int *ttype, d *g) noexcept nogil +cdef void dlasq6(int *i0, int *n0, d *z, int *pp, d *dmin, d *dmin1, d *dmin2, d *dn, d *dnm1, d *dnm2) noexcept nogil +cdef void dlasr(char *side, char *pivot, char *direct, int *m, int *n, d *c, d *s, d *a, int *lda) noexcept nogil +cdef void dlasrt(char *id, int *n, d *d, int *info) noexcept nogil +cdef void dlassq(int *n, d *x, int *incx, d *scale, d *sumsq) noexcept nogil +cdef void dlasv2(d *f, d *g, d *h, d *ssmin, d *ssmax, d *snr, d *csr, d *snl, d *csl) noexcept nogil +cdef void dlaswp(int *n, d *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) noexcept nogil +cdef void dlasy2(bint *ltranl, bint *ltranr, int *isgn, int *n1, int *n2, d *tl, int *ldtl, d *tr, int *ldtr, d *b, int *ldb, d *scale, d *x, int *ldx, d *xnorm, int *info) noexcept nogil +cdef void dlasyf(char *uplo, int *n, int *nb, int *kb, d *a, int *lda, int *ipiv, d *w, int *ldw, int *info) noexcept nogil +cdef void dlat2s(char *uplo, int *n, d *a, int *lda, s *sa, int *ldsa, int *info) noexcept nogil +cdef void dlatbs(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, d *ab, int *ldab, d *x, d *scale, d *cnorm, int *info) noexcept nogil +cdef void dlatdf(int *ijob, int *n, d *z, int *ldz, d *rhs, d *rdsum, d *rdscal, int *ipiv, int *jpiv) noexcept nogil +cdef void dlatps(char *uplo, char *trans, char *diag, char *normin, int *n, d *ap, d *x, d *scale, d *cnorm, int *info) noexcept nogil +cdef void dlatrd(char *uplo, int *n, int *nb, d *a, int *lda, d *e, d *tau, d *w, int *ldw) noexcept nogil +cdef void dlatrs(char *uplo, char *trans, char *diag, char *normin, int *n, d *a, int *lda, d *x, d *scale, d *cnorm, int *info) noexcept nogil +cdef void dlatrz(int *m, int *n, int *l, d *a, int *lda, d *tau, d *work) noexcept nogil +cdef void dlauu2(char *uplo, int *n, d *a, int *lda, int *info) noexcept nogil +cdef void dlauum(char *uplo, int *n, d *a, int *lda, int *info) noexcept nogil +cdef void dopgtr(char *uplo, int *n, d *ap, d *tau, d *q, int *ldq, d *work, int *info) noexcept nogil +cdef void dopmtr(char *side, char *uplo, char *trans, int *m, int *n, d *ap, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil +cdef void dorbdb(char *trans, char *signs, int *m, int *p, int *q, d *x11, int *ldx11, d *x12, int *ldx12, d *x21, int *ldx21, d *x22, int *ldx22, d *theta, d *phi, d *taup1, d *taup2, d *tauq1, d *tauq2, d *work, int *lwork, int *info) noexcept nogil +cdef void dorcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, d *x11, int *ldx11, d *x12, int *ldx12, d *x21, int *ldx21, d *x22, int *ldx22, d *theta, d *u1, int *ldu1, d *u2, int *ldu2, d *v1t, int *ldv1t, d *v2t, int *ldv2t, d *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void dorg2l(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil +cdef void dorg2r(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil +cdef void dorgbr(char *vect, int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dorghr(int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dorgl2(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil +cdef void dorglq(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dorgql(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dorgqr(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dorgr2(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil +cdef void dorgrq(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dorgtr(char *uplo, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dorm2l(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil +cdef void dorm2r(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil +cdef void dormbr(char *vect, char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil +cdef void dormhr(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil +cdef void dorml2(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil +cdef void dormlq(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil +cdef void dormql(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil +cdef void dormqr(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil +cdef void dormr2(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil +cdef void dormr3(char *side, char *trans, int *m, int *n, int *k, int *l, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil +cdef void dormrq(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil +cdef void dormrz(char *side, char *trans, int *m, int *n, int *k, int *l, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil +cdef void dormtr(char *side, char *uplo, char *trans, int *m, int *n, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil +cdef void dpbcon(char *uplo, int *n, int *kd, d *ab, int *ldab, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil +cdef void dpbequ(char *uplo, int *n, int *kd, d *ab, int *ldab, d *s, d *scond, d *amax, int *info) noexcept nogil +cdef void dpbrfs(char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dpbstf(char *uplo, int *n, int *kd, d *ab, int *ldab, int *info) noexcept nogil +cdef void dpbsv(char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, int *info) noexcept nogil +cdef void dpbsvx(char *fact, char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, char *equed, d *s, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dpbtf2(char *uplo, int *n, int *kd, d *ab, int *ldab, int *info) noexcept nogil +cdef void dpbtrf(char *uplo, int *n, int *kd, d *ab, int *ldab, int *info) noexcept nogil +cdef void dpbtrs(char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, int *info) noexcept nogil +cdef void dpftrf(char *transr, char *uplo, int *n, d *a, int *info) noexcept nogil +cdef void dpftri(char *transr, char *uplo, int *n, d *a, int *info) noexcept nogil +cdef void dpftrs(char *transr, char *uplo, int *n, int *nrhs, d *a, d *b, int *ldb, int *info) noexcept nogil +cdef void dpocon(char *uplo, int *n, d *a, int *lda, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil +cdef void dpoequ(int *n, d *a, int *lda, d *s, d *scond, d *amax, int *info) noexcept nogil +cdef void dpoequb(int *n, d *a, int *lda, d *s, d *scond, d *amax, int *info) noexcept nogil +cdef void dporfs(char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dposv(char *uplo, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *info) noexcept nogil +cdef void dposvx(char *fact, char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, char *equed, d *s, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dpotf2(char *uplo, int *n, d *a, int *lda, int *info) noexcept nogil +cdef void dpotrf(char *uplo, int *n, d *a, int *lda, int *info) noexcept nogil +cdef void dpotri(char *uplo, int *n, d *a, int *lda, int *info) noexcept nogil +cdef void dpotrs(char *uplo, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *info) noexcept nogil +cdef void dppcon(char *uplo, int *n, d *ap, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil +cdef void dppequ(char *uplo, int *n, d *ap, d *s, d *scond, d *amax, int *info) noexcept nogil +cdef void dpprfs(char *uplo, int *n, int *nrhs, d *ap, d *afp, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dppsv(char *uplo, int *n, int *nrhs, d *ap, d *b, int *ldb, int *info) noexcept nogil +cdef void dppsvx(char *fact, char *uplo, int *n, int *nrhs, d *ap, d *afp, char *equed, d *s, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dpptrf(char *uplo, int *n, d *ap, int *info) noexcept nogil +cdef void dpptri(char *uplo, int *n, d *ap, int *info) noexcept nogil +cdef void dpptrs(char *uplo, int *n, int *nrhs, d *ap, d *b, int *ldb, int *info) noexcept nogil +cdef void dpstf2(char *uplo, int *n, d *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) noexcept nogil +cdef void dpstrf(char *uplo, int *n, d *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) noexcept nogil +cdef void dptcon(int *n, d *d, d *e, d *anorm, d *rcond, d *work, int *info) noexcept nogil +cdef void dpteqr(char *compz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *info) noexcept nogil +cdef void dptrfs(int *n, int *nrhs, d *d, d *e, d *df, d *ef, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *info) noexcept nogil +cdef void dptsv(int *n, int *nrhs, d *d, d *e, d *b, int *ldb, int *info) noexcept nogil +cdef void dptsvx(char *fact, int *n, int *nrhs, d *d, d *e, d *df, d *ef, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *info) noexcept nogil +cdef void dpttrf(int *n, d *d, d *e, int *info) noexcept nogil +cdef void dpttrs(int *n, int *nrhs, d *d, d *e, d *b, int *ldb, int *info) noexcept nogil +cdef void dptts2(int *n, int *nrhs, d *d, d *e, d *b, int *ldb) noexcept nogil +cdef void drscl(int *n, d *sa, d *sx, int *incx) noexcept nogil +cdef void dsbev(char *jobz, char *uplo, int *n, int *kd, d *ab, int *ldab, d *w, d *z, int *ldz, d *work, int *info) noexcept nogil +cdef void dsbevd(char *jobz, char *uplo, int *n, int *kd, d *ab, int *ldab, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dsbevx(char *jobz, char *range, char *uplo, int *n, int *kd, d *ab, int *ldab, d *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void dsbgst(char *vect, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *x, int *ldx, d *work, int *info) noexcept nogil +cdef void dsbgv(char *jobz, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *w, d *z, int *ldz, d *work, int *info) noexcept nogil +cdef void dsbgvd(char *jobz, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dsbgvx(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void dsbtrd(char *vect, char *uplo, int *n, int *kd, d *ab, int *ldab, d *d, d *e, d *q, int *ldq, d *work, int *info) noexcept nogil +cdef void dsfrk(char *transr, char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *beta, d *c) noexcept nogil +cdef void dsgesv(int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *work, s *swork, int *iter, int *info) noexcept nogil +cdef void dspcon(char *uplo, int *n, d *ap, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil +cdef void dspev(char *jobz, char *uplo, int *n, d *ap, d *w, d *z, int *ldz, d *work, int *info) noexcept nogil +cdef void dspevd(char *jobz, char *uplo, int *n, d *ap, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dspevx(char *jobz, char *range, char *uplo, int *n, d *ap, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void dspgst(int *itype, char *uplo, int *n, d *ap, d *bp, int *info) noexcept nogil +cdef void dspgv(int *itype, char *jobz, char *uplo, int *n, d *ap, d *bp, d *w, d *z, int *ldz, d *work, int *info) noexcept nogil +cdef void dspgvd(int *itype, char *jobz, char *uplo, int *n, d *ap, d *bp, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dspgvx(int *itype, char *jobz, char *range, char *uplo, int *n, d *ap, d *bp, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void dsposv(char *uplo, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *x, int *ldx, d *work, s *swork, int *iter, int *info) noexcept nogil +cdef void dsprfs(char *uplo, int *n, int *nrhs, d *ap, d *afp, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dspsv(char *uplo, int *n, int *nrhs, d *ap, int *ipiv, d *b, int *ldb, int *info) noexcept nogil +cdef void dspsvx(char *fact, char *uplo, int *n, int *nrhs, d *ap, d *afp, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dsptrd(char *uplo, int *n, d *ap, d *d, d *e, d *tau, int *info) noexcept nogil +cdef void dsptrf(char *uplo, int *n, d *ap, int *ipiv, int *info) noexcept nogil +cdef void dsptri(char *uplo, int *n, d *ap, int *ipiv, d *work, int *info) noexcept nogil +cdef void dsptrs(char *uplo, int *n, int *nrhs, d *ap, int *ipiv, d *b, int *ldb, int *info) noexcept nogil +cdef void dstebz(char *range, char *order, int *n, d *vl, d *vu, int *il, int *iu, d *abstol, d *d, d *e, int *m, int *nsplit, d *w, int *iblock, int *isplit, d *work, int *iwork, int *info) noexcept nogil +cdef void dstedc(char *compz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dstegr(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dstein(int *n, d *d, d *e, int *m, d *w, int *iblock, int *isplit, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void dstemr(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, int *m, d *w, d *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dsteqr(char *compz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *info) noexcept nogil +cdef void dsterf(int *n, d *d, d *e, int *info) noexcept nogil +cdef void dstev(char *jobz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *info) noexcept nogil +cdef void dstevd(char *jobz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dstevr(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dstevx(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void dsycon(char *uplo, int *n, d *a, int *lda, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil +cdef void dsyconv(char *uplo, char *way, int *n, d *a, int *lda, int *ipiv, d *work, int *info) noexcept nogil +cdef void dsyequb(char *uplo, int *n, d *a, int *lda, d *s, d *scond, d *amax, d *work, int *info) noexcept nogil +cdef void dsyev(char *jobz, char *uplo, int *n, d *a, int *lda, d *w, d *work, int *lwork, int *info) noexcept nogil +cdef void dsyevd(char *jobz, char *uplo, int *n, d *a, int *lda, d *w, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dsyevr(char *jobz, char *range, char *uplo, int *n, d *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dsyevx(char *jobz, char *range, char *uplo, int *n, d *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void dsygs2(int *itype, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, int *info) noexcept nogil +cdef void dsygst(int *itype, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, int *info) noexcept nogil +cdef void dsygv(int *itype, char *jobz, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, d *w, d *work, int *lwork, int *info) noexcept nogil +cdef void dsygvd(int *itype, char *jobz, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, d *w, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dsygvx(int *itype, char *jobz, char *range, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void dsyrfs(char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dsysv(char *uplo, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, d *work, int *lwork, int *info) noexcept nogil +cdef void dsysvx(char *fact, char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void dsyswapr(char *uplo, int *n, d *a, int *lda, int *i1, int *i2) noexcept nogil +cdef void dsytd2(char *uplo, int *n, d *a, int *lda, d *d, d *e, d *tau, int *info) noexcept nogil +cdef void dsytf2(char *uplo, int *n, d *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void dsytrd(char *uplo, int *n, d *a, int *lda, d *d, d *e, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef void dsytrf(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *lwork, int *info) noexcept nogil +cdef void dsytri(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *info) noexcept nogil +cdef void dsytri2(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *lwork, int *info) noexcept nogil +cdef void dsytri2x(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *nb, int *info) noexcept nogil +cdef void dsytrs(char *uplo, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, int *info) noexcept nogil +cdef void dsytrs2(char *uplo, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, d *work, int *info) noexcept nogil +cdef void dtbcon(char *norm, char *uplo, char *diag, int *n, int *kd, d *ab, int *ldab, d *rcond, d *work, int *iwork, int *info) noexcept nogil +cdef void dtbrfs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dtbtrs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, int *info) noexcept nogil +cdef void dtfsm(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, d *alpha, d *a, d *b, int *ldb) noexcept nogil +cdef void dtftri(char *transr, char *uplo, char *diag, int *n, d *a, int *info) noexcept nogil +cdef void dtfttp(char *transr, char *uplo, int *n, d *arf, d *ap, int *info) noexcept nogil +cdef void dtfttr(char *transr, char *uplo, int *n, d *arf, d *a, int *lda, int *info) noexcept nogil +cdef void dtgevc(char *side, char *howmny, bint *select, int *n, d *s, int *lds, d *p, int *ldp, d *vl, int *ldvl, d *vr, int *ldvr, int *mm, int *m, d *work, int *info) noexcept nogil +cdef void dtgex2(bint *wantq, bint *wantz, int *n, d *a, int *lda, d *b, int *ldb, d *q, int *ldq, d *z, int *ldz, int *j1, int *n1, int *n2, d *work, int *lwork, int *info) noexcept nogil +cdef void dtgexc(bint *wantq, bint *wantz, int *n, d *a, int *lda, d *b, int *ldb, d *q, int *ldq, d *z, int *ldz, int *ifst, int *ilst, d *work, int *lwork, int *info) noexcept nogil +cdef void dtgsen(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *q, int *ldq, d *z, int *ldz, int *m, d *pl, d *pr, d *dif, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dtgsja(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, d *a, int *lda, d *b, int *ldb, d *tola, d *tolb, d *alpha, d *beta, d *u, int *ldu, d *v, int *ldv, d *q, int *ldq, d *work, int *ncycle, int *info) noexcept nogil +cdef void dtgsna(char *job, char *howmny, bint *select, int *n, d *a, int *lda, d *b, int *ldb, d *vl, int *ldvl, d *vr, int *ldvr, d *s, d *dif, int *mm, int *m, d *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void dtgsy2(char *trans, int *ijob, int *m, int *n, d *a, int *lda, d *b, int *ldb, d *c, int *ldc, d *d, int *ldd, d *e, int *lde, d *f, int *ldf, d *scale, d *rdsum, d *rdscal, int *iwork, int *pq, int *info) noexcept nogil +cdef void dtgsyl(char *trans, int *ijob, int *m, int *n, d *a, int *lda, d *b, int *ldb, d *c, int *ldc, d *d, int *ldd, d *e, int *lde, d *f, int *ldf, d *scale, d *dif, d *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void dtpcon(char *norm, char *uplo, char *diag, int *n, d *ap, d *rcond, d *work, int *iwork, int *info) noexcept nogil +cdef void dtpmqrt(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, d *v, int *ldv, d *t, int *ldt, d *a, int *lda, d *b, int *ldb, d *work, int *info) noexcept nogil +cdef void dtpqrt(int *m, int *n, int *l, int *nb, d *a, int *lda, d *b, int *ldb, d *t, int *ldt, d *work, int *info) noexcept nogil +cdef void dtpqrt2(int *m, int *n, int *l, d *a, int *lda, d *b, int *ldb, d *t, int *ldt, int *info) noexcept nogil +cdef void dtprfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, d *v, int *ldv, d *t, int *ldt, d *a, int *lda, d *b, int *ldb, d *work, int *ldwork) noexcept nogil +cdef void dtprfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *ap, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dtptri(char *uplo, char *diag, int *n, d *ap, int *info) noexcept nogil +cdef void dtptrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *ap, d *b, int *ldb, int *info) noexcept nogil +cdef void dtpttf(char *transr, char *uplo, int *n, d *ap, d *arf, int *info) noexcept nogil +cdef void dtpttr(char *uplo, int *n, d *ap, d *a, int *lda, int *info) noexcept nogil +cdef void dtrcon(char *norm, char *uplo, char *diag, int *n, d *a, int *lda, d *rcond, d *work, int *iwork, int *info) noexcept nogil +cdef void dtrevc(char *side, char *howmny, bint *select, int *n, d *t, int *ldt, d *vl, int *ldvl, d *vr, int *ldvr, int *mm, int *m, d *work, int *info) noexcept nogil +cdef void dtrexc(char *compq, int *n, d *t, int *ldt, d *q, int *ldq, int *ifst, int *ilst, d *work, int *info) noexcept nogil +cdef void dtrrfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil +cdef void dtrsen(char *job, char *compq, bint *select, int *n, d *t, int *ldt, d *q, int *ldq, d *wr, d *wi, int *m, d *s, d *sep, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void dtrsna(char *job, char *howmny, bint *select, int *n, d *t, int *ldt, d *vl, int *ldvl, d *vr, int *ldvr, d *s, d *sep, int *mm, int *m, d *work, int *ldwork, int *iwork, int *info) noexcept nogil +cdef void dtrsyl(char *trana, char *tranb, int *isgn, int *m, int *n, d *a, int *lda, d *b, int *ldb, d *c, int *ldc, d *scale, int *info) noexcept nogil +cdef void dtrti2(char *uplo, char *diag, int *n, d *a, int *lda, int *info) noexcept nogil +cdef void dtrtri(char *uplo, char *diag, int *n, d *a, int *lda, int *info) noexcept nogil +cdef void dtrtrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *info) noexcept nogil +cdef void dtrttf(char *transr, char *uplo, int *n, d *a, int *lda, d *arf, int *info) noexcept nogil +cdef void dtrttp(char *uplo, int *n, d *a, int *lda, d *ap, int *info) noexcept nogil +cdef void dtzrzf(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil +cdef d dzsum1(int *n, z *cx, int *incx) noexcept nogil +cdef int icmax1(int *n, c *cx, int *incx) noexcept nogil +cdef int ieeeck(int *ispec, s *zero, s *one) noexcept nogil +cdef int ilaclc(int *m, int *n, c *a, int *lda) noexcept nogil +cdef int ilaclr(int *m, int *n, c *a, int *lda) noexcept nogil +cdef int iladiag(char *diag) noexcept nogil +cdef int iladlc(int *m, int *n, d *a, int *lda) noexcept nogil +cdef int iladlr(int *m, int *n, d *a, int *lda) noexcept nogil +cdef int ilaprec(char *prec) noexcept nogil +cdef int ilaslc(int *m, int *n, s *a, int *lda) noexcept nogil +cdef int ilaslr(int *m, int *n, s *a, int *lda) noexcept nogil +cdef int ilatrans(char *trans) noexcept nogil +cdef int ilauplo(char *uplo) noexcept nogil +cdef void ilaver(int *vers_major, int *vers_minor, int *vers_patch) noexcept nogil +cdef int ilazlc(int *m, int *n, z *a, int *lda) noexcept nogil +cdef int ilazlr(int *m, int *n, z *a, int *lda) noexcept nogil +cdef int izmax1(int *n, z *cx, int *incx) noexcept nogil +cdef void sbbcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, s *theta, s *phi, s *u1, int *ldu1, s *u2, int *ldu2, s *v1t, int *ldv1t, s *v2t, int *ldv2t, s *b11d, s *b11e, s *b12d, s *b12e, s *b21d, s *b21e, s *b22d, s *b22e, s *work, int *lwork, int *info) noexcept nogil +cdef void sbdsdc(char *uplo, char *compq, int *n, s *d, s *e, s *u, int *ldu, s *vt, int *ldvt, s *q, int *iq, s *work, int *iwork, int *info) noexcept nogil +cdef void sbdsqr(char *uplo, int *n, int *ncvt, int *nru, int *ncc, s *d, s *e, s *vt, int *ldvt, s *u, int *ldu, s *c, int *ldc, s *work, int *info) noexcept nogil +cdef s scsum1(int *n, c *cx, int *incx) noexcept nogil +cdef void sdisna(char *job, int *m, int *n, s *d, s *sep, int *info) noexcept nogil +cdef void sgbbrd(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, s *ab, int *ldab, s *d, s *e, s *q, int *ldq, s *pt, int *ldpt, s *c, int *ldc, s *work, int *info) noexcept nogil +cdef void sgbcon(char *norm, int *n, int *kl, int *ku, s *ab, int *ldab, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil +cdef void sgbequ(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil +cdef void sgbequb(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil +cdef void sgbrfs(char *trans, int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void sgbsv(int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, int *ipiv, s *b, int *ldb, int *info) noexcept nogil +cdef void sgbsvx(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, int *ipiv, char *equed, s *r, s *c, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void sgbtf2(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, int *ipiv, int *info) noexcept nogil +cdef void sgbtrf(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, int *ipiv, int *info) noexcept nogil +cdef void sgbtrs(char *trans, int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, int *ipiv, s *b, int *ldb, int *info) noexcept nogil +cdef void sgebak(char *job, char *side, int *n, int *ilo, int *ihi, s *scale, int *m, s *v, int *ldv, int *info) noexcept nogil +cdef void sgebal(char *job, int *n, s *a, int *lda, int *ilo, int *ihi, s *scale, int *info) noexcept nogil +cdef void sgebd2(int *m, int *n, s *a, int *lda, s *d, s *e, s *tauq, s *taup, s *work, int *info) noexcept nogil +cdef void sgebrd(int *m, int *n, s *a, int *lda, s *d, s *e, s *tauq, s *taup, s *work, int *lwork, int *info) noexcept nogil +cdef void sgecon(char *norm, int *n, s *a, int *lda, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil +cdef void sgeequ(int *m, int *n, s *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil +cdef void sgeequb(int *m, int *n, s *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil +cdef void sgees(char *jobvs, char *sort, sselect2 *select, int *n, s *a, int *lda, int *sdim, s *wr, s *wi, s *vs, int *ldvs, s *work, int *lwork, bint *bwork, int *info) noexcept nogil +cdef void sgeesx(char *jobvs, char *sort, sselect2 *select, char *sense, int *n, s *a, int *lda, int *sdim, s *wr, s *wi, s *vs, int *ldvs, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil +cdef void sgeev(char *jobvl, char *jobvr, int *n, s *a, int *lda, s *wr, s *wi, s *vl, int *ldvl, s *vr, int *ldvr, s *work, int *lwork, int *info) noexcept nogil +cdef void sgeevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, s *a, int *lda, s *wr, s *wi, s *vl, int *ldvl, s *vr, int *ldvr, int *ilo, int *ihi, s *scale, s *abnrm, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void sgehd2(int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil +cdef void sgehrd(int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sgejsv(char *joba, char *jobu, char *jobv, char *jobr, char *jobt, char *jobp, int *m, int *n, s *a, int *lda, s *sva, s *u, int *ldu, s *v, int *ldv, s *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void sgelq2(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil +cdef void sgelqf(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sgels(char *trans, int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *work, int *lwork, int *info) noexcept nogil +cdef void sgelsd(int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *s, s *rcond, int *rank, s *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void sgelss(int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *s, s *rcond, int *rank, s *work, int *lwork, int *info) noexcept nogil +cdef void sgelsy(int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *jpvt, s *rcond, int *rank, s *work, int *lwork, int *info) noexcept nogil +cdef void sgemqrt(char *side, char *trans, int *m, int *n, int *k, int *nb, s *v, int *ldv, s *t, int *ldt, s *c, int *ldc, s *work, int *info) noexcept nogil +cdef void sgeql2(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil +cdef void sgeqlf(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sgeqp3(int *m, int *n, s *a, int *lda, int *jpvt, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sgeqr2(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil +cdef void sgeqr2p(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil +cdef void sgeqrf(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sgeqrfp(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sgeqrt(int *m, int *n, int *nb, s *a, int *lda, s *t, int *ldt, s *work, int *info) noexcept nogil +cdef void sgeqrt2(int *m, int *n, s *a, int *lda, s *t, int *ldt, int *info) noexcept nogil +cdef void sgeqrt3(int *m, int *n, s *a, int *lda, s *t, int *ldt, int *info) noexcept nogil +cdef void sgerfs(char *trans, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void sgerq2(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil +cdef void sgerqf(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sgesc2(int *n, s *a, int *lda, s *rhs, int *ipiv, int *jpiv, s *scale) noexcept nogil +cdef void sgesdd(char *jobz, int *m, int *n, s *a, int *lda, s *s, s *u, int *ldu, s *vt, int *ldvt, s *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void sgesv(int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, int *info) noexcept nogil +cdef void sgesvd(char *jobu, char *jobvt, int *m, int *n, s *a, int *lda, s *s, s *u, int *ldu, s *vt, int *ldvt, s *work, int *lwork, int *info) noexcept nogil +cdef void sgesvj(char *joba, char *jobu, char *jobv, int *m, int *n, s *a, int *lda, s *sva, int *mv, s *v, int *ldv, s *work, int *lwork, int *info) noexcept nogil +cdef void sgesvx(char *fact, char *trans, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, char *equed, s *r, s *c, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void sgetc2(int *n, s *a, int *lda, int *ipiv, int *jpiv, int *info) noexcept nogil +cdef void sgetf2(int *m, int *n, s *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void sgetrf(int *m, int *n, s *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void sgetri(int *n, s *a, int *lda, int *ipiv, s *work, int *lwork, int *info) noexcept nogil +cdef void sgetrs(char *trans, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, int *info) noexcept nogil +cdef void sggbak(char *job, char *side, int *n, int *ilo, int *ihi, s *lscale, s *rscale, int *m, s *v, int *ldv, int *info) noexcept nogil +cdef void sggbal(char *job, int *n, s *a, int *lda, s *b, int *ldb, int *ilo, int *ihi, s *lscale, s *rscale, s *work, int *info) noexcept nogil +cdef void sgges(char *jobvsl, char *jobvsr, char *sort, sselect3 *selctg, int *n, s *a, int *lda, s *b, int *ldb, int *sdim, s *alphar, s *alphai, s *beta, s *vsl, int *ldvsl, s *vsr, int *ldvsr, s *work, int *lwork, bint *bwork, int *info) noexcept nogil +cdef void sggesx(char *jobvsl, char *jobvsr, char *sort, sselect3 *selctg, char *sense, int *n, s *a, int *lda, s *b, int *ldb, int *sdim, s *alphar, s *alphai, s *beta, s *vsl, int *ldvsl, s *vsr, int *ldvsr, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil +cdef void sggev(char *jobvl, char *jobvr, int *n, s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *vl, int *ldvl, s *vr, int *ldvr, s *work, int *lwork, int *info) noexcept nogil +cdef void sggevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *vl, int *ldvl, s *vr, int *ldvr, int *ilo, int *ihi, s *lscale, s *rscale, s *abnrm, s *bbnrm, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, bint *bwork, int *info) noexcept nogil +cdef void sggglm(int *n, int *m, int *p, s *a, int *lda, s *b, int *ldb, s *d, s *x, s *y, s *work, int *lwork, int *info) noexcept nogil +cdef void sgghrd(char *compq, char *compz, int *n, int *ilo, int *ihi, s *a, int *lda, s *b, int *ldb, s *q, int *ldq, s *z, int *ldz, int *info) noexcept nogil +cdef void sgglse(int *m, int *n, int *p, s *a, int *lda, s *b, int *ldb, s *c, s *d, s *x, s *work, int *lwork, int *info) noexcept nogil +cdef void sggqrf(int *n, int *m, int *p, s *a, int *lda, s *taua, s *b, int *ldb, s *taub, s *work, int *lwork, int *info) noexcept nogil +cdef void sggrqf(int *m, int *p, int *n, s *a, int *lda, s *taua, s *b, int *ldb, s *taub, s *work, int *lwork, int *info) noexcept nogil +cdef void sgsvj0(char *jobv, int *m, int *n, s *a, int *lda, s *d, s *sva, int *mv, s *v, int *ldv, s *eps, s *sfmin, s *tol, int *nsweep, s *work, int *lwork, int *info) noexcept nogil +cdef void sgsvj1(char *jobv, int *m, int *n, int *n1, s *a, int *lda, s *d, s *sva, int *mv, s *v, int *ldv, s *eps, s *sfmin, s *tol, int *nsweep, s *work, int *lwork, int *info) noexcept nogil +cdef void sgtcon(char *norm, int *n, s *dl, s *d, s *du, s *du2, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil +cdef void sgtrfs(char *trans, int *n, int *nrhs, s *dl, s *d, s *du, s *dlf, s *df, s *duf, s *du2, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void sgtsv(int *n, int *nrhs, s *dl, s *d, s *du, s *b, int *ldb, int *info) noexcept nogil +cdef void sgtsvx(char *fact, char *trans, int *n, int *nrhs, s *dl, s *d, s *du, s *dlf, s *df, s *duf, s *du2, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void sgttrf(int *n, s *dl, s *d, s *du, s *du2, int *ipiv, int *info) noexcept nogil +cdef void sgttrs(char *trans, int *n, int *nrhs, s *dl, s *d, s *du, s *du2, int *ipiv, s *b, int *ldb, int *info) noexcept nogil +cdef void sgtts2(int *itrans, int *n, int *nrhs, s *dl, s *d, s *du, s *du2, int *ipiv, s *b, int *ldb) noexcept nogil +cdef void shgeqz(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *t, int *ldt, s *alphar, s *alphai, s *beta, s *q, int *ldq, s *z, int *ldz, s *work, int *lwork, int *info) noexcept nogil +cdef void shsein(char *side, char *eigsrc, char *initv, bint *select, int *n, s *h, int *ldh, s *wr, s *wi, s *vl, int *ldvl, s *vr, int *ldvr, int *mm, int *m, s *work, int *ifaill, int *ifailr, int *info) noexcept nogil +cdef void shseqr(char *job, char *compz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, s *z, int *ldz, s *work, int *lwork, int *info) noexcept nogil +cdef void slabad(s *small, s *large) noexcept nogil +cdef void slabrd(int *m, int *n, int *nb, s *a, int *lda, s *d, s *e, s *tauq, s *taup, s *x, int *ldx, s *y, int *ldy) noexcept nogil +cdef void slacn2(int *n, s *v, s *x, int *isgn, s *est, int *kase, int *isave) noexcept nogil +cdef void slacon(int *n, s *v, s *x, int *isgn, s *est, int *kase) noexcept nogil +cdef void slacpy(char *uplo, int *m, int *n, s *a, int *lda, s *b, int *ldb) noexcept nogil +cdef void sladiv(s *a, s *b, s *c, s *d, s *p, s *q) noexcept nogil +cdef void slae2(s *a, s *b, s *c, s *rt1, s *rt2) noexcept nogil +cdef void slaebz(int *ijob, int *nitmax, int *n, int *mmax, int *minp, int *nbmin, s *abstol, s *reltol, s *pivmin, s *d, s *e, s *e2, int *nval, s *ab, s *c, int *mout, int *nab, s *work, int *iwork, int *info) noexcept nogil +cdef void slaed0(int *icompq, int *qsiz, int *n, s *d, s *e, s *q, int *ldq, s *qstore, int *ldqs, s *work, int *iwork, int *info) noexcept nogil +cdef void slaed1(int *n, s *d, s *q, int *ldq, int *indxq, s *rho, int *cutpnt, s *work, int *iwork, int *info) noexcept nogil +cdef void slaed2(int *k, int *n, int *n1, s *d, s *q, int *ldq, int *indxq, s *rho, s *z, s *dlamda, s *w, s *q2, int *indx, int *indxc, int *indxp, int *coltyp, int *info) noexcept nogil +cdef void slaed3(int *k, int *n, int *n1, s *d, s *q, int *ldq, s *rho, s *dlamda, s *q2, int *indx, int *ctot, s *w, s *s, int *info) noexcept nogil +cdef void slaed4(int *n, int *i, s *d, s *z, s *delta, s *rho, s *dlam, int *info) noexcept nogil +cdef void slaed5(int *i, s *d, s *z, s *delta, s *rho, s *dlam) noexcept nogil +cdef void slaed6(int *kniter, bint *orgati, s *rho, s *d, s *z, s *finit, s *tau, int *info) noexcept nogil +cdef void slaed7(int *icompq, int *n, int *qsiz, int *tlvls, int *curlvl, int *curpbm, s *d, s *q, int *ldq, int *indxq, s *rho, int *cutpnt, s *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, s *givnum, s *work, int *iwork, int *info) noexcept nogil +cdef void slaed8(int *icompq, int *k, int *n, int *qsiz, s *d, s *q, int *ldq, int *indxq, s *rho, int *cutpnt, s *z, s *dlamda, s *q2, int *ldq2, s *w, int *perm, int *givptr, int *givcol, s *givnum, int *indxp, int *indx, int *info) noexcept nogil +cdef void slaed9(int *k, int *kstart, int *kstop, int *n, s *d, s *q, int *ldq, s *rho, s *dlamda, s *w, s *s, int *lds, int *info) noexcept nogil +cdef void slaeda(int *n, int *tlvls, int *curlvl, int *curpbm, int *prmptr, int *perm, int *givptr, int *givcol, s *givnum, s *q, int *qptr, s *z, s *ztemp, int *info) noexcept nogil +cdef void slaein(bint *rightv, bint *noinit, int *n, s *h, int *ldh, s *wr, s *wi, s *vr, s *vi, s *b, int *ldb, s *work, s *eps3, s *smlnum, s *bignum, int *info) noexcept nogil +cdef void slaev2(s *a, s *b, s *c, s *rt1, s *rt2, s *cs1, s *sn1) noexcept nogil +cdef void slaexc(bint *wantq, int *n, s *t, int *ldt, s *q, int *ldq, int *j1, int *n1, int *n2, s *work, int *info) noexcept nogil +cdef void slag2(s *a, int *lda, s *b, int *ldb, s *safmin, s *scale1, s *scale2, s *wr1, s *wr2, s *wi) noexcept nogil +cdef void slag2d(int *m, int *n, s *sa, int *ldsa, d *a, int *lda, int *info) noexcept nogil +cdef void slags2(bint *upper, s *a1, s *a2, s *a3, s *b1, s *b2, s *b3, s *csu, s *snu, s *csv, s *snv, s *csq, s *snq) noexcept nogil +cdef void slagtf(int *n, s *a, s *lambda_, s *b, s *c, s *tol, s *d, int *in_, int *info) noexcept nogil +cdef void slagtm(char *trans, int *n, int *nrhs, s *alpha, s *dl, s *d, s *du, s *x, int *ldx, s *beta, s *b, int *ldb) noexcept nogil +cdef void slagts(int *job, int *n, s *a, s *b, s *c, s *d, int *in_, s *y, s *tol, int *info) noexcept nogil +cdef void slagv2(s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *csl, s *snl, s *csr, s *snr) noexcept nogil +cdef void slahqr(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, int *iloz, int *ihiz, s *z, int *ldz, int *info) noexcept nogil +cdef void slahr2(int *n, int *k, int *nb, s *a, int *lda, s *tau, s *t, int *ldt, s *y, int *ldy) noexcept nogil +cdef void slaic1(int *job, int *j, s *x, s *sest, s *w, s *gamma, s *sestpr, s *s, s *c) noexcept nogil +cdef void slaln2(bint *ltrans, int *na, int *nw, s *smin, s *ca, s *a, int *lda, s *d1, s *d2, s *b, int *ldb, s *wr, s *wi, s *x, int *ldx, s *scale, s *xnorm, int *info) noexcept nogil +cdef void slals0(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, s *b, int *ldb, s *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *poles, s *difl, s *difr, s *z, int *k, s *c, s *s, s *work, int *info) noexcept nogil +cdef void slalsa(int *icompq, int *smlsiz, int *n, int *nrhs, s *b, int *ldb, s *bx, int *ldbx, s *u, int *ldu, s *vt, int *k, s *difl, s *difr, s *z, s *poles, int *givptr, int *givcol, int *ldgcol, int *perm, s *givnum, s *c, s *s, s *work, int *iwork, int *info) noexcept nogil +cdef void slalsd(char *uplo, int *smlsiz, int *n, int *nrhs, s *d, s *e, s *b, int *ldb, s *rcond, int *rank, s *work, int *iwork, int *info) noexcept nogil +cdef s slamch(char *cmach) noexcept nogil +cdef void slamrg(int *n1, int *n2, s *a, int *strd1, int *strd2, int *index_bn) noexcept nogil +cdef s slangb(char *norm, int *n, int *kl, int *ku, s *ab, int *ldab, s *work) noexcept nogil +cdef s slange(char *norm, int *m, int *n, s *a, int *lda, s *work) noexcept nogil +cdef s slangt(char *norm, int *n, s *dl, s *d, s *du) noexcept nogil +cdef s slanhs(char *norm, int *n, s *a, int *lda, s *work) noexcept nogil +cdef s slansb(char *norm, char *uplo, int *n, int *k, s *ab, int *ldab, s *work) noexcept nogil +cdef s slansf(char *norm, char *transr, char *uplo, int *n, s *a, s *work) noexcept nogil +cdef s slansp(char *norm, char *uplo, int *n, s *ap, s *work) noexcept nogil +cdef s slanst(char *norm, int *n, s *d, s *e) noexcept nogil +cdef s slansy(char *norm, char *uplo, int *n, s *a, int *lda, s *work) noexcept nogil +cdef s slantb(char *norm, char *uplo, char *diag, int *n, int *k, s *ab, int *ldab, s *work) noexcept nogil +cdef s slantp(char *norm, char *uplo, char *diag, int *n, s *ap, s *work) noexcept nogil +cdef s slantr(char *norm, char *uplo, char *diag, int *m, int *n, s *a, int *lda, s *work) noexcept nogil +cdef void slanv2(s *a, s *b, s *c, s *d, s *rt1r, s *rt1i, s *rt2r, s *rt2i, s *cs, s *sn) noexcept nogil +cdef void slapll(int *n, s *x, int *incx, s *y, int *incy, s *ssmin) noexcept nogil +cdef void slapmr(bint *forwrd, int *m, int *n, s *x, int *ldx, int *k) noexcept nogil +cdef void slapmt(bint *forwrd, int *m, int *n, s *x, int *ldx, int *k) noexcept nogil +cdef s slapy2(s *x, s *y) noexcept nogil +cdef s slapy3(s *x, s *y, s *z) noexcept nogil +cdef void slaqgb(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) noexcept nogil +cdef void slaqge(int *m, int *n, s *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) noexcept nogil +cdef void slaqp2(int *m, int *n, int *offset, s *a, int *lda, int *jpvt, s *tau, s *vn1, s *vn2, s *work) noexcept nogil +cdef void slaqps(int *m, int *n, int *offset, int *nb, int *kb, s *a, int *lda, int *jpvt, s *tau, s *vn1, s *vn2, s *auxv, s *f, int *ldf) noexcept nogil +cdef void slaqr0(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, int *iloz, int *ihiz, s *z, int *ldz, s *work, int *lwork, int *info) noexcept nogil +cdef void slaqr1(int *n, s *h, int *ldh, s *sr1, s *si1, s *sr2, s *si2, s *v) noexcept nogil +cdef void slaqr2(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, s *h, int *ldh, int *iloz, int *ihiz, s *z, int *ldz, int *ns, int *nd, s *sr, s *si, s *v, int *ldv, int *nh, s *t, int *ldt, int *nv, s *wv, int *ldwv, s *work, int *lwork) noexcept nogil +cdef void slaqr3(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, s *h, int *ldh, int *iloz, int *ihiz, s *z, int *ldz, int *ns, int *nd, s *sr, s *si, s *v, int *ldv, int *nh, s *t, int *ldt, int *nv, s *wv, int *ldwv, s *work, int *lwork) noexcept nogil +cdef void slaqr4(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, int *iloz, int *ihiz, s *z, int *ldz, s *work, int *lwork, int *info) noexcept nogil +cdef void slaqr5(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, s *sr, s *si, s *h, int *ldh, int *iloz, int *ihiz, s *z, int *ldz, s *v, int *ldv, s *u, int *ldu, int *nv, s *wv, int *ldwv, int *nh, s *wh, int *ldwh) noexcept nogil +cdef void slaqsb(char *uplo, int *n, int *kd, s *ab, int *ldab, s *s, s *scond, s *amax, char *equed) noexcept nogil +cdef void slaqsp(char *uplo, int *n, s *ap, s *s, s *scond, s *amax, char *equed) noexcept nogil +cdef void slaqsy(char *uplo, int *n, s *a, int *lda, s *s, s *scond, s *amax, char *equed) noexcept nogil +cdef void slaqtr(bint *ltran, bint *lreal, int *n, s *t, int *ldt, s *b, s *w, s *scale, s *x, s *work, int *info) noexcept nogil +cdef void slar1v(int *n, int *b1, int *bn, s *lambda_, s *d, s *l, s *ld, s *lld, s *pivmin, s *gaptol, s *z, bint *wantnc, int *negcnt, s *ztz, s *mingma, int *r, int *isuppz, s *nrminv, s *resid, s *rqcorr, s *work) noexcept nogil +cdef void slar2v(int *n, s *x, s *y, s *z, int *incx, s *c, s *s, int *incc) noexcept nogil +cdef void slarf(char *side, int *m, int *n, s *v, int *incv, s *tau, s *c, int *ldc, s *work) noexcept nogil +cdef void slarfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, s *v, int *ldv, s *t, int *ldt, s *c, int *ldc, s *work, int *ldwork) noexcept nogil +cdef void slarfg(int *n, s *alpha, s *x, int *incx, s *tau) noexcept nogil +cdef void slarfgp(int *n, s *alpha, s *x, int *incx, s *tau) noexcept nogil +cdef void slarft(char *direct, char *storev, int *n, int *k, s *v, int *ldv, s *tau, s *t, int *ldt) noexcept nogil +cdef void slarfx(char *side, int *m, int *n, s *v, s *tau, s *c, int *ldc, s *work) noexcept nogil +cdef void slargv(int *n, s *x, int *incx, s *y, int *incy, s *c, int *incc) noexcept nogil +cdef void slarnv(int *idist, int *iseed, int *n, s *x) noexcept nogil +cdef void slarra(int *n, s *d, s *e, s *e2, s *spltol, s *tnrm, int *nsplit, int *isplit, int *info) noexcept nogil +cdef void slarrb(int *n, s *d, s *lld, int *ifirst, int *ilast, s *rtol1, s *rtol2, int *offset, s *w, s *wgap, s *werr, s *work, int *iwork, s *pivmin, s *spdiam, int *twist, int *info) noexcept nogil +cdef void slarrc(char *jobt, int *n, s *vl, s *vu, s *d, s *e, s *pivmin, int *eigcnt, int *lcnt, int *rcnt, int *info) noexcept nogil +cdef void slarrd(char *range, char *order, int *n, s *vl, s *vu, int *il, int *iu, s *gers, s *reltol, s *d, s *e, s *e2, s *pivmin, int *nsplit, int *isplit, int *m, s *w, s *werr, s *wl, s *wu, int *iblock, int *indexw, s *work, int *iwork, int *info) noexcept nogil +cdef void slarre(char *range, int *n, s *vl, s *vu, int *il, int *iu, s *d, s *e, s *e2, s *rtol1, s *rtol2, s *spltol, int *nsplit, int *isplit, int *m, s *w, s *werr, s *wgap, int *iblock, int *indexw, s *gers, s *pivmin, s *work, int *iwork, int *info) noexcept nogil +cdef void slarrf(int *n, s *d, s *l, s *ld, int *clstrt, int *clend, s *w, s *wgap, s *werr, s *spdiam, s *clgapl, s *clgapr, s *pivmin, s *sigma, s *dplus, s *lplus, s *work, int *info) noexcept nogil +cdef void slarrj(int *n, s *d, s *e2, int *ifirst, int *ilast, s *rtol, int *offset, s *w, s *werr, s *work, int *iwork, s *pivmin, s *spdiam, int *info) noexcept nogil +cdef void slarrk(int *n, int *iw, s *gl, s *gu, s *d, s *e2, s *pivmin, s *reltol, s *w, s *werr, int *info) noexcept nogil +cdef void slarrr(int *n, s *d, s *e, int *info) noexcept nogil +cdef void slarrv(int *n, s *vl, s *vu, s *d, s *l, s *pivmin, int *isplit, int *m, int *dol, int *dou, s *minrgp, s *rtol1, s *rtol2, s *w, s *werr, s *wgap, int *iblock, int *indexw, s *gers, s *z, int *ldz, int *isuppz, s *work, int *iwork, int *info) noexcept nogil +cdef void slartg(s *f, s *g, s *cs, s *sn, s *r) noexcept nogil +cdef void slartgp(s *f, s *g, s *cs, s *sn, s *r) noexcept nogil +cdef void slartgs(s *x, s *y, s *sigma, s *cs, s *sn) noexcept nogil +cdef void slartv(int *n, s *x, int *incx, s *y, int *incy, s *c, s *s, int *incc) noexcept nogil +cdef void slaruv(int *iseed, int *n, s *x) noexcept nogil +cdef void slarz(char *side, int *m, int *n, int *l, s *v, int *incv, s *tau, s *c, int *ldc, s *work) noexcept nogil +cdef void slarzb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, s *v, int *ldv, s *t, int *ldt, s *c, int *ldc, s *work, int *ldwork) noexcept nogil +cdef void slarzt(char *direct, char *storev, int *n, int *k, s *v, int *ldv, s *tau, s *t, int *ldt) noexcept nogil +cdef void slas2(s *f, s *g, s *h, s *ssmin, s *ssmax) noexcept nogil +cdef void slascl(char *type_bn, int *kl, int *ku, s *cfrom, s *cto, int *m, int *n, s *a, int *lda, int *info) noexcept nogil +cdef void slasd0(int *n, int *sqre, s *d, s *e, s *u, int *ldu, s *vt, int *ldvt, int *smlsiz, int *iwork, s *work, int *info) noexcept nogil +cdef void slasd1(int *nl, int *nr, int *sqre, s *d, s *alpha, s *beta, s *u, int *ldu, s *vt, int *ldvt, int *idxq, int *iwork, s *work, int *info) noexcept nogil +cdef void slasd2(int *nl, int *nr, int *sqre, int *k, s *d, s *z, s *alpha, s *beta, s *u, int *ldu, s *vt, int *ldvt, s *dsigma, s *u2, int *ldu2, s *vt2, int *ldvt2, int *idxp, int *idx, int *idxc, int *idxq, int *coltyp, int *info) noexcept nogil +cdef void slasd3(int *nl, int *nr, int *sqre, int *k, s *d, s *q, int *ldq, s *dsigma, s *u, int *ldu, s *u2, int *ldu2, s *vt, int *ldvt, s *vt2, int *ldvt2, int *idxc, int *ctot, s *z, int *info) noexcept nogil +cdef void slasd4(int *n, int *i, s *d, s *z, s *delta, s *rho, s *sigma, s *work, int *info) noexcept nogil +cdef void slasd5(int *i, s *d, s *z, s *delta, s *rho, s *dsigma, s *work) noexcept nogil +cdef void slasd6(int *icompq, int *nl, int *nr, int *sqre, s *d, s *vf, s *vl, s *alpha, s *beta, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *poles, s *difl, s *difr, s *z, int *k, s *c, s *s, s *work, int *iwork, int *info) noexcept nogil +cdef void slasd7(int *icompq, int *nl, int *nr, int *sqre, int *k, s *d, s *z, s *zw, s *vf, s *vfw, s *vl, s *vlw, s *alpha, s *beta, s *dsigma, int *idx, int *idxp, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *c, s *s, int *info) noexcept nogil +cdef void slasd8(int *icompq, int *k, s *d, s *z, s *vf, s *vl, s *difl, s *difr, int *lddifr, s *dsigma, s *work, int *info) noexcept nogil +cdef void slasda(int *icompq, int *smlsiz, int *n, int *sqre, s *d, s *e, s *u, int *ldu, s *vt, int *k, s *difl, s *difr, s *z, s *poles, int *givptr, int *givcol, int *ldgcol, int *perm, s *givnum, s *c, s *s, s *work, int *iwork, int *info) noexcept nogil +cdef void slasdq(char *uplo, int *sqre, int *n, int *ncvt, int *nru, int *ncc, s *d, s *e, s *vt, int *ldvt, s *u, int *ldu, s *c, int *ldc, s *work, int *info) noexcept nogil +cdef void slasdt(int *n, int *lvl, int *nd, int *inode, int *ndiml, int *ndimr, int *msub) noexcept nogil +cdef void slaset(char *uplo, int *m, int *n, s *alpha, s *beta, s *a, int *lda) noexcept nogil +cdef void slasq1(int *n, s *d, s *e, s *work, int *info) noexcept nogil +cdef void slasq2(int *n, s *z, int *info) noexcept nogil +cdef void slasq3(int *i0, int *n0, s *z, int *pp, s *dmin, s *sigma, s *desig, s *qmax, int *nfail, int *iter, int *ndiv, bint *ieee, int *ttype, s *dmin1, s *dmin2, s *dn, s *dn1, s *dn2, s *g, s *tau) noexcept nogil +cdef void slasq4(int *i0, int *n0, s *z, int *pp, int *n0in, s *dmin, s *dmin1, s *dmin2, s *dn, s *dn1, s *dn2, s *tau, int *ttype, s *g) noexcept nogil +cdef void slasq6(int *i0, int *n0, s *z, int *pp, s *dmin, s *dmin1, s *dmin2, s *dn, s *dnm1, s *dnm2) noexcept nogil +cdef void slasr(char *side, char *pivot, char *direct, int *m, int *n, s *c, s *s, s *a, int *lda) noexcept nogil +cdef void slasrt(char *id, int *n, s *d, int *info) noexcept nogil +cdef void slassq(int *n, s *x, int *incx, s *scale, s *sumsq) noexcept nogil +cdef void slasv2(s *f, s *g, s *h, s *ssmin, s *ssmax, s *snr, s *csr, s *snl, s *csl) noexcept nogil +cdef void slaswp(int *n, s *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) noexcept nogil +cdef void slasy2(bint *ltranl, bint *ltranr, int *isgn, int *n1, int *n2, s *tl, int *ldtl, s *tr, int *ldtr, s *b, int *ldb, s *scale, s *x, int *ldx, s *xnorm, int *info) noexcept nogil +cdef void slasyf(char *uplo, int *n, int *nb, int *kb, s *a, int *lda, int *ipiv, s *w, int *ldw, int *info) noexcept nogil +cdef void slatbs(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, s *ab, int *ldab, s *x, s *scale, s *cnorm, int *info) noexcept nogil +cdef void slatdf(int *ijob, int *n, s *z, int *ldz, s *rhs, s *rdsum, s *rdscal, int *ipiv, int *jpiv) noexcept nogil +cdef void slatps(char *uplo, char *trans, char *diag, char *normin, int *n, s *ap, s *x, s *scale, s *cnorm, int *info) noexcept nogil +cdef void slatrd(char *uplo, int *n, int *nb, s *a, int *lda, s *e, s *tau, s *w, int *ldw) noexcept nogil +cdef void slatrs(char *uplo, char *trans, char *diag, char *normin, int *n, s *a, int *lda, s *x, s *scale, s *cnorm, int *info) noexcept nogil +cdef void slatrz(int *m, int *n, int *l, s *a, int *lda, s *tau, s *work) noexcept nogil +cdef void slauu2(char *uplo, int *n, s *a, int *lda, int *info) noexcept nogil +cdef void slauum(char *uplo, int *n, s *a, int *lda, int *info) noexcept nogil +cdef void sopgtr(char *uplo, int *n, s *ap, s *tau, s *q, int *ldq, s *work, int *info) noexcept nogil +cdef void sopmtr(char *side, char *uplo, char *trans, int *m, int *n, s *ap, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil +cdef void sorbdb(char *trans, char *signs, int *m, int *p, int *q, s *x11, int *ldx11, s *x12, int *ldx12, s *x21, int *ldx21, s *x22, int *ldx22, s *theta, s *phi, s *taup1, s *taup2, s *tauq1, s *tauq2, s *work, int *lwork, int *info) noexcept nogil +cdef void sorcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, s *x11, int *ldx11, s *x12, int *ldx12, s *x21, int *ldx21, s *x22, int *ldx22, s *theta, s *u1, int *ldu1, s *u2, int *ldu2, s *v1t, int *ldv1t, s *v2t, int *ldv2t, s *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void sorg2l(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil +cdef void sorg2r(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil +cdef void sorgbr(char *vect, int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sorghr(int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sorgl2(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil +cdef void sorglq(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sorgql(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sorgqr(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sorgr2(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil +cdef void sorgrq(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sorgtr(char *uplo, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void sorm2l(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil +cdef void sorm2r(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil +cdef void sormbr(char *vect, char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil +cdef void sormhr(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil +cdef void sorml2(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil +cdef void sormlq(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil +cdef void sormql(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil +cdef void sormqr(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil +cdef void sormr2(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil +cdef void sormr3(char *side, char *trans, int *m, int *n, int *k, int *l, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil +cdef void sormrq(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil +cdef void sormrz(char *side, char *trans, int *m, int *n, int *k, int *l, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil +cdef void sormtr(char *side, char *uplo, char *trans, int *m, int *n, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil +cdef void spbcon(char *uplo, int *n, int *kd, s *ab, int *ldab, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil +cdef void spbequ(char *uplo, int *n, int *kd, s *ab, int *ldab, s *s, s *scond, s *amax, int *info) noexcept nogil +cdef void spbrfs(char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void spbstf(char *uplo, int *n, int *kd, s *ab, int *ldab, int *info) noexcept nogil +cdef void spbsv(char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, int *info) noexcept nogil +cdef void spbsvx(char *fact, char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, char *equed, s *s, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void spbtf2(char *uplo, int *n, int *kd, s *ab, int *ldab, int *info) noexcept nogil +cdef void spbtrf(char *uplo, int *n, int *kd, s *ab, int *ldab, int *info) noexcept nogil +cdef void spbtrs(char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, int *info) noexcept nogil +cdef void spftrf(char *transr, char *uplo, int *n, s *a, int *info) noexcept nogil +cdef void spftri(char *transr, char *uplo, int *n, s *a, int *info) noexcept nogil +cdef void spftrs(char *transr, char *uplo, int *n, int *nrhs, s *a, s *b, int *ldb, int *info) noexcept nogil +cdef void spocon(char *uplo, int *n, s *a, int *lda, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil +cdef void spoequ(int *n, s *a, int *lda, s *s, s *scond, s *amax, int *info) noexcept nogil +cdef void spoequb(int *n, s *a, int *lda, s *s, s *scond, s *amax, int *info) noexcept nogil +cdef void sporfs(char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void sposv(char *uplo, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *info) noexcept nogil +cdef void sposvx(char *fact, char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, char *equed, s *s, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void spotf2(char *uplo, int *n, s *a, int *lda, int *info) noexcept nogil +cdef void spotrf(char *uplo, int *n, s *a, int *lda, int *info) noexcept nogil +cdef void spotri(char *uplo, int *n, s *a, int *lda, int *info) noexcept nogil +cdef void spotrs(char *uplo, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *info) noexcept nogil +cdef void sppcon(char *uplo, int *n, s *ap, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil +cdef void sppequ(char *uplo, int *n, s *ap, s *s, s *scond, s *amax, int *info) noexcept nogil +cdef void spprfs(char *uplo, int *n, int *nrhs, s *ap, s *afp, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void sppsv(char *uplo, int *n, int *nrhs, s *ap, s *b, int *ldb, int *info) noexcept nogil +cdef void sppsvx(char *fact, char *uplo, int *n, int *nrhs, s *ap, s *afp, char *equed, s *s, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void spptrf(char *uplo, int *n, s *ap, int *info) noexcept nogil +cdef void spptri(char *uplo, int *n, s *ap, int *info) noexcept nogil +cdef void spptrs(char *uplo, int *n, int *nrhs, s *ap, s *b, int *ldb, int *info) noexcept nogil +cdef void spstf2(char *uplo, int *n, s *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) noexcept nogil +cdef void spstrf(char *uplo, int *n, s *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) noexcept nogil +cdef void sptcon(int *n, s *d, s *e, s *anorm, s *rcond, s *work, int *info) noexcept nogil +cdef void spteqr(char *compz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *info) noexcept nogil +cdef void sptrfs(int *n, int *nrhs, s *d, s *e, s *df, s *ef, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *info) noexcept nogil +cdef void sptsv(int *n, int *nrhs, s *d, s *e, s *b, int *ldb, int *info) noexcept nogil +cdef void sptsvx(char *fact, int *n, int *nrhs, s *d, s *e, s *df, s *ef, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *info) noexcept nogil +cdef void spttrf(int *n, s *d, s *e, int *info) noexcept nogil +cdef void spttrs(int *n, int *nrhs, s *d, s *e, s *b, int *ldb, int *info) noexcept nogil +cdef void sptts2(int *n, int *nrhs, s *d, s *e, s *b, int *ldb) noexcept nogil +cdef void srscl(int *n, s *sa, s *sx, int *incx) noexcept nogil +cdef void ssbev(char *jobz, char *uplo, int *n, int *kd, s *ab, int *ldab, s *w, s *z, int *ldz, s *work, int *info) noexcept nogil +cdef void ssbevd(char *jobz, char *uplo, int *n, int *kd, s *ab, int *ldab, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void ssbevx(char *jobz, char *range, char *uplo, int *n, int *kd, s *ab, int *ldab, s *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void ssbgst(char *vect, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *x, int *ldx, s *work, int *info) noexcept nogil +cdef void ssbgv(char *jobz, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *w, s *z, int *ldz, s *work, int *info) noexcept nogil +cdef void ssbgvd(char *jobz, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void ssbgvx(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void ssbtrd(char *vect, char *uplo, int *n, int *kd, s *ab, int *ldab, s *d, s *e, s *q, int *ldq, s *work, int *info) noexcept nogil +cdef void ssfrk(char *transr, char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *beta, s *c) noexcept nogil +cdef void sspcon(char *uplo, int *n, s *ap, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil +cdef void sspev(char *jobz, char *uplo, int *n, s *ap, s *w, s *z, int *ldz, s *work, int *info) noexcept nogil +cdef void sspevd(char *jobz, char *uplo, int *n, s *ap, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void sspevx(char *jobz, char *range, char *uplo, int *n, s *ap, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void sspgst(int *itype, char *uplo, int *n, s *ap, s *bp, int *info) noexcept nogil +cdef void sspgv(int *itype, char *jobz, char *uplo, int *n, s *ap, s *bp, s *w, s *z, int *ldz, s *work, int *info) noexcept nogil +cdef void sspgvd(int *itype, char *jobz, char *uplo, int *n, s *ap, s *bp, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void sspgvx(int *itype, char *jobz, char *range, char *uplo, int *n, s *ap, s *bp, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void ssprfs(char *uplo, int *n, int *nrhs, s *ap, s *afp, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void sspsv(char *uplo, int *n, int *nrhs, s *ap, int *ipiv, s *b, int *ldb, int *info) noexcept nogil +cdef void sspsvx(char *fact, char *uplo, int *n, int *nrhs, s *ap, s *afp, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void ssptrd(char *uplo, int *n, s *ap, s *d, s *e, s *tau, int *info) noexcept nogil +cdef void ssptrf(char *uplo, int *n, s *ap, int *ipiv, int *info) noexcept nogil +cdef void ssptri(char *uplo, int *n, s *ap, int *ipiv, s *work, int *info) noexcept nogil +cdef void ssptrs(char *uplo, int *n, int *nrhs, s *ap, int *ipiv, s *b, int *ldb, int *info) noexcept nogil +cdef void sstebz(char *range, char *order, int *n, s *vl, s *vu, int *il, int *iu, s *abstol, s *d, s *e, int *m, int *nsplit, s *w, int *iblock, int *isplit, s *work, int *iwork, int *info) noexcept nogil +cdef void sstedc(char *compz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void sstegr(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void sstein(int *n, s *d, s *e, int *m, s *w, int *iblock, int *isplit, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void sstemr(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, int *m, s *w, s *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void ssteqr(char *compz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *info) noexcept nogil +cdef void ssterf(int *n, s *d, s *e, int *info) noexcept nogil +cdef void sstev(char *jobz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *info) noexcept nogil +cdef void sstevd(char *jobz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void sstevr(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void sstevx(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void ssycon(char *uplo, int *n, s *a, int *lda, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil +cdef void ssyconv(char *uplo, char *way, int *n, s *a, int *lda, int *ipiv, s *work, int *info) noexcept nogil +cdef void ssyequb(char *uplo, int *n, s *a, int *lda, s *s, s *scond, s *amax, s *work, int *info) noexcept nogil +cdef void ssyev(char *jobz, char *uplo, int *n, s *a, int *lda, s *w, s *work, int *lwork, int *info) noexcept nogil +cdef void ssyevd(char *jobz, char *uplo, int *n, s *a, int *lda, s *w, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void ssyevr(char *jobz, char *range, char *uplo, int *n, s *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void ssyevx(char *jobz, char *range, char *uplo, int *n, s *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void ssygs2(int *itype, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, int *info) noexcept nogil +cdef void ssygst(int *itype, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, int *info) noexcept nogil +cdef void ssygv(int *itype, char *jobz, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, s *w, s *work, int *lwork, int *info) noexcept nogil +cdef void ssygvd(int *itype, char *jobz, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, s *w, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void ssygvx(int *itype, char *jobz, char *range, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void ssyrfs(char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void ssysv(char *uplo, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, s *work, int *lwork, int *info) noexcept nogil +cdef void ssysvx(char *fact, char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void ssyswapr(char *uplo, int *n, s *a, int *lda, int *i1, int *i2) noexcept nogil +cdef void ssytd2(char *uplo, int *n, s *a, int *lda, s *d, s *e, s *tau, int *info) noexcept nogil +cdef void ssytf2(char *uplo, int *n, s *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void ssytrd(char *uplo, int *n, s *a, int *lda, s *d, s *e, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void ssytrf(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *lwork, int *info) noexcept nogil +cdef void ssytri(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *info) noexcept nogil +cdef void ssytri2(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *lwork, int *info) noexcept nogil +cdef void ssytri2x(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *nb, int *info) noexcept nogil +cdef void ssytrs(char *uplo, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, int *info) noexcept nogil +cdef void ssytrs2(char *uplo, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, s *work, int *info) noexcept nogil +cdef void stbcon(char *norm, char *uplo, char *diag, int *n, int *kd, s *ab, int *ldab, s *rcond, s *work, int *iwork, int *info) noexcept nogil +cdef void stbrfs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void stbtrs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, int *info) noexcept nogil +cdef void stfsm(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, s *alpha, s *a, s *b, int *ldb) noexcept nogil +cdef void stftri(char *transr, char *uplo, char *diag, int *n, s *a, int *info) noexcept nogil +cdef void stfttp(char *transr, char *uplo, int *n, s *arf, s *ap, int *info) noexcept nogil +cdef void stfttr(char *transr, char *uplo, int *n, s *arf, s *a, int *lda, int *info) noexcept nogil +cdef void stgevc(char *side, char *howmny, bint *select, int *n, s *s, int *lds, s *p, int *ldp, s *vl, int *ldvl, s *vr, int *ldvr, int *mm, int *m, s *work, int *info) noexcept nogil +cdef void stgex2(bint *wantq, bint *wantz, int *n, s *a, int *lda, s *b, int *ldb, s *q, int *ldq, s *z, int *ldz, int *j1, int *n1, int *n2, s *work, int *lwork, int *info) noexcept nogil +cdef void stgexc(bint *wantq, bint *wantz, int *n, s *a, int *lda, s *b, int *ldb, s *q, int *ldq, s *z, int *ldz, int *ifst, int *ilst, s *work, int *lwork, int *info) noexcept nogil +cdef void stgsen(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *q, int *ldq, s *z, int *ldz, int *m, s *pl, s *pr, s *dif, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void stgsja(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, s *a, int *lda, s *b, int *ldb, s *tola, s *tolb, s *alpha, s *beta, s *u, int *ldu, s *v, int *ldv, s *q, int *ldq, s *work, int *ncycle, int *info) noexcept nogil +cdef void stgsna(char *job, char *howmny, bint *select, int *n, s *a, int *lda, s *b, int *ldb, s *vl, int *ldvl, s *vr, int *ldvr, s *s, s *dif, int *mm, int *m, s *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void stgsy2(char *trans, int *ijob, int *m, int *n, s *a, int *lda, s *b, int *ldb, s *c, int *ldc, s *d, int *ldd, s *e, int *lde, s *f, int *ldf, s *scale, s *rdsum, s *rdscal, int *iwork, int *pq, int *info) noexcept nogil +cdef void stgsyl(char *trans, int *ijob, int *m, int *n, s *a, int *lda, s *b, int *ldb, s *c, int *ldc, s *d, int *ldd, s *e, int *lde, s *f, int *ldf, s *scale, s *dif, s *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void stpcon(char *norm, char *uplo, char *diag, int *n, s *ap, s *rcond, s *work, int *iwork, int *info) noexcept nogil +cdef void stpmqrt(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, s *v, int *ldv, s *t, int *ldt, s *a, int *lda, s *b, int *ldb, s *work, int *info) noexcept nogil +cdef void stpqrt(int *m, int *n, int *l, int *nb, s *a, int *lda, s *b, int *ldb, s *t, int *ldt, s *work, int *info) noexcept nogil +cdef void stpqrt2(int *m, int *n, int *l, s *a, int *lda, s *b, int *ldb, s *t, int *ldt, int *info) noexcept nogil +cdef void stprfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, s *v, int *ldv, s *t, int *ldt, s *a, int *lda, s *b, int *ldb, s *work, int *ldwork) noexcept nogil +cdef void stprfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *ap, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void stptri(char *uplo, char *diag, int *n, s *ap, int *info) noexcept nogil +cdef void stptrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *ap, s *b, int *ldb, int *info) noexcept nogil +cdef void stpttf(char *transr, char *uplo, int *n, s *ap, s *arf, int *info) noexcept nogil +cdef void stpttr(char *uplo, int *n, s *ap, s *a, int *lda, int *info) noexcept nogil +cdef void strcon(char *norm, char *uplo, char *diag, int *n, s *a, int *lda, s *rcond, s *work, int *iwork, int *info) noexcept nogil +cdef void strevc(char *side, char *howmny, bint *select, int *n, s *t, int *ldt, s *vl, int *ldvl, s *vr, int *ldvr, int *mm, int *m, s *work, int *info) noexcept nogil +cdef void strexc(char *compq, int *n, s *t, int *ldt, s *q, int *ldq, int *ifst, int *ilst, s *work, int *info) noexcept nogil +cdef void strrfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil +cdef void strsen(char *job, char *compq, bint *select, int *n, s *t, int *ldt, s *q, int *ldq, s *wr, s *wi, int *m, s *s, s *sep, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void strsna(char *job, char *howmny, bint *select, int *n, s *t, int *ldt, s *vl, int *ldvl, s *vr, int *ldvr, s *s, s *sep, int *mm, int *m, s *work, int *ldwork, int *iwork, int *info) noexcept nogil +cdef void strsyl(char *trana, char *tranb, int *isgn, int *m, int *n, s *a, int *lda, s *b, int *ldb, s *c, int *ldc, s *scale, int *info) noexcept nogil +cdef void strti2(char *uplo, char *diag, int *n, s *a, int *lda, int *info) noexcept nogil +cdef void strtri(char *uplo, char *diag, int *n, s *a, int *lda, int *info) noexcept nogil +cdef void strtrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *info) noexcept nogil +cdef void strttf(char *transr, char *uplo, int *n, s *a, int *lda, s *arf, int *info) noexcept nogil +cdef void strttp(char *uplo, int *n, s *a, int *lda, s *ap, int *info) noexcept nogil +cdef void stzrzf(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil +cdef void xerbla_array(char *srname_array, int *srname_len, int *info) noexcept nogil +cdef void zbbcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, d *theta, d *phi, z *u1, int *ldu1, z *u2, int *ldu2, z *v1t, int *ldv1t, z *v2t, int *ldv2t, d *b11d, d *b11e, d *b12d, d *b12e, d *b21d, d *b21e, d *b22d, d *b22e, d *rwork, int *lrwork, int *info) noexcept nogil +cdef void zbdsqr(char *uplo, int *n, int *ncvt, int *nru, int *ncc, d *d, d *e, z *vt, int *ldvt, z *u, int *ldu, z *c, int *ldc, d *rwork, int *info) noexcept nogil +cdef void zcgesv(int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, z *x, int *ldx, z *work, c *swork, d *rwork, int *iter, int *info) noexcept nogil +cdef void zcposv(char *uplo, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, z *x, int *ldx, z *work, c *swork, d *rwork, int *iter, int *info) noexcept nogil +cdef void zdrscl(int *n, d *sa, z *sx, int *incx) noexcept nogil +cdef void zgbbrd(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, z *ab, int *ldab, d *d, d *e, z *q, int *ldq, z *pt, int *ldpt, z *c, int *ldc, z *work, d *rwork, int *info) noexcept nogil +cdef void zgbcon(char *norm, int *n, int *kl, int *ku, z *ab, int *ldab, int *ipiv, d *anorm, d *rcond, z *work, d *rwork, int *info) noexcept nogil +cdef void zgbequ(int *m, int *n, int *kl, int *ku, z *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil +cdef void zgbequb(int *m, int *n, int *kl, int *ku, z *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil +cdef void zgbrfs(char *trans, int *n, int *kl, int *ku, int *nrhs, z *ab, int *ldab, z *afb, int *ldafb, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zgbsv(int *n, int *kl, int *ku, int *nrhs, z *ab, int *ldab, int *ipiv, z *b, int *ldb, int *info) noexcept nogil +cdef void zgbsvx(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, z *ab, int *ldab, z *afb, int *ldafb, int *ipiv, char *equed, d *r, d *c, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zgbtf2(int *m, int *n, int *kl, int *ku, z *ab, int *ldab, int *ipiv, int *info) noexcept nogil +cdef void zgbtrf(int *m, int *n, int *kl, int *ku, z *ab, int *ldab, int *ipiv, int *info) noexcept nogil +cdef void zgbtrs(char *trans, int *n, int *kl, int *ku, int *nrhs, z *ab, int *ldab, int *ipiv, z *b, int *ldb, int *info) noexcept nogil +cdef void zgebak(char *job, char *side, int *n, int *ilo, int *ihi, d *scale, int *m, z *v, int *ldv, int *info) noexcept nogil +cdef void zgebal(char *job, int *n, z *a, int *lda, int *ilo, int *ihi, d *scale, int *info) noexcept nogil +cdef void zgebd2(int *m, int *n, z *a, int *lda, d *d, d *e, z *tauq, z *taup, z *work, int *info) noexcept nogil +cdef void zgebrd(int *m, int *n, z *a, int *lda, d *d, d *e, z *tauq, z *taup, z *work, int *lwork, int *info) noexcept nogil +cdef void zgecon(char *norm, int *n, z *a, int *lda, d *anorm, d *rcond, z *work, d *rwork, int *info) noexcept nogil +cdef void zgeequ(int *m, int *n, z *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil +cdef void zgeequb(int *m, int *n, z *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil +cdef void zgees(char *jobvs, char *sort, zselect1 *select, int *n, z *a, int *lda, int *sdim, z *w, z *vs, int *ldvs, z *work, int *lwork, d *rwork, bint *bwork, int *info) noexcept nogil +cdef void zgeesx(char *jobvs, char *sort, zselect1 *select, char *sense, int *n, z *a, int *lda, int *sdim, z *w, z *vs, int *ldvs, d *rconde, d *rcondv, z *work, int *lwork, d *rwork, bint *bwork, int *info) noexcept nogil +cdef void zgeev(char *jobvl, char *jobvr, int *n, z *a, int *lda, z *w, z *vl, int *ldvl, z *vr, int *ldvr, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zgeevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, z *a, int *lda, z *w, z *vl, int *ldvl, z *vr, int *ldvr, int *ilo, int *ihi, d *scale, d *abnrm, d *rconde, d *rcondv, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zgehd2(int *n, int *ilo, int *ihi, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil +cdef void zgehrd(int *n, int *ilo, int *ihi, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zgelq2(int *m, int *n, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil +cdef void zgelqf(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zgels(char *trans, int *m, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, z *work, int *lwork, int *info) noexcept nogil +cdef void zgelsd(int *m, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, d *s, d *rcond, int *rank, z *work, int *lwork, d *rwork, int *iwork, int *info) noexcept nogil +cdef void zgelss(int *m, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, d *s, d *rcond, int *rank, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zgelsy(int *m, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, int *jpvt, d *rcond, int *rank, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zgemqrt(char *side, char *trans, int *m, int *n, int *k, int *nb, z *v, int *ldv, z *t, int *ldt, z *c, int *ldc, z *work, int *info) noexcept nogil +cdef void zgeql2(int *m, int *n, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil +cdef void zgeqlf(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zgeqp3(int *m, int *n, z *a, int *lda, int *jpvt, z *tau, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zgeqr2(int *m, int *n, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil +cdef void zgeqr2p(int *m, int *n, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil +cdef void zgeqrf(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zgeqrfp(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zgeqrt(int *m, int *n, int *nb, z *a, int *lda, z *t, int *ldt, z *work, int *info) noexcept nogil +cdef void zgeqrt2(int *m, int *n, z *a, int *lda, z *t, int *ldt, int *info) noexcept nogil +cdef void zgeqrt3(int *m, int *n, z *a, int *lda, z *t, int *ldt, int *info) noexcept nogil +cdef void zgerfs(char *trans, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zgerq2(int *m, int *n, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil +cdef void zgerqf(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zgesc2(int *n, z *a, int *lda, z *rhs, int *ipiv, int *jpiv, d *scale) noexcept nogil +cdef void zgesdd(char *jobz, int *m, int *n, z *a, int *lda, d *s, z *u, int *ldu, z *vt, int *ldvt, z *work, int *lwork, d *rwork, int *iwork, int *info) noexcept nogil +cdef void zgesv(int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, int *info) noexcept nogil +cdef void zgesvd(char *jobu, char *jobvt, int *m, int *n, z *a, int *lda, d *s, z *u, int *ldu, z *vt, int *ldvt, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zgesvx(char *fact, char *trans, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, char *equed, d *r, d *c, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zgetc2(int *n, z *a, int *lda, int *ipiv, int *jpiv, int *info) noexcept nogil +cdef void zgetf2(int *m, int *n, z *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void zgetrf(int *m, int *n, z *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void zgetri(int *n, z *a, int *lda, int *ipiv, z *work, int *lwork, int *info) noexcept nogil +cdef void zgetrs(char *trans, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, int *info) noexcept nogil +cdef void zggbak(char *job, char *side, int *n, int *ilo, int *ihi, d *lscale, d *rscale, int *m, z *v, int *ldv, int *info) noexcept nogil +cdef void zggbal(char *job, int *n, z *a, int *lda, z *b, int *ldb, int *ilo, int *ihi, d *lscale, d *rscale, d *work, int *info) noexcept nogil +cdef void zgges(char *jobvsl, char *jobvsr, char *sort, zselect2 *selctg, int *n, z *a, int *lda, z *b, int *ldb, int *sdim, z *alpha, z *beta, z *vsl, int *ldvsl, z *vsr, int *ldvsr, z *work, int *lwork, d *rwork, bint *bwork, int *info) noexcept nogil +cdef void zggesx(char *jobvsl, char *jobvsr, char *sort, zselect2 *selctg, char *sense, int *n, z *a, int *lda, z *b, int *ldb, int *sdim, z *alpha, z *beta, z *vsl, int *ldvsl, z *vsr, int *ldvsr, d *rconde, d *rcondv, z *work, int *lwork, d *rwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil +cdef void zggev(char *jobvl, char *jobvr, int *n, z *a, int *lda, z *b, int *ldb, z *alpha, z *beta, z *vl, int *ldvl, z *vr, int *ldvr, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zggevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, z *a, int *lda, z *b, int *ldb, z *alpha, z *beta, z *vl, int *ldvl, z *vr, int *ldvr, int *ilo, int *ihi, d *lscale, d *rscale, d *abnrm, d *bbnrm, d *rconde, d *rcondv, z *work, int *lwork, d *rwork, int *iwork, bint *bwork, int *info) noexcept nogil +cdef void zggglm(int *n, int *m, int *p, z *a, int *lda, z *b, int *ldb, z *d, z *x, z *y, z *work, int *lwork, int *info) noexcept nogil +cdef void zgghrd(char *compq, char *compz, int *n, int *ilo, int *ihi, z *a, int *lda, z *b, int *ldb, z *q, int *ldq, z *z, int *ldz, int *info) noexcept nogil +cdef void zgglse(int *m, int *n, int *p, z *a, int *lda, z *b, int *ldb, z *c, z *d, z *x, z *work, int *lwork, int *info) noexcept nogil +cdef void zggqrf(int *n, int *m, int *p, z *a, int *lda, z *taua, z *b, int *ldb, z *taub, z *work, int *lwork, int *info) noexcept nogil +cdef void zggrqf(int *m, int *p, int *n, z *a, int *lda, z *taua, z *b, int *ldb, z *taub, z *work, int *lwork, int *info) noexcept nogil +cdef void zgtcon(char *norm, int *n, z *dl, z *d, z *du, z *du2, int *ipiv, d *anorm, d *rcond, z *work, int *info) noexcept nogil +cdef void zgtrfs(char *trans, int *n, int *nrhs, z *dl, z *d, z *du, z *dlf, z *df, z *duf, z *du2, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zgtsv(int *n, int *nrhs, z *dl, z *d, z *du, z *b, int *ldb, int *info) noexcept nogil +cdef void zgtsvx(char *fact, char *trans, int *n, int *nrhs, z *dl, z *d, z *du, z *dlf, z *df, z *duf, z *du2, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zgttrf(int *n, z *dl, z *d, z *du, z *du2, int *ipiv, int *info) noexcept nogil +cdef void zgttrs(char *trans, int *n, int *nrhs, z *dl, z *d, z *du, z *du2, int *ipiv, z *b, int *ldb, int *info) noexcept nogil +cdef void zgtts2(int *itrans, int *n, int *nrhs, z *dl, z *d, z *du, z *du2, int *ipiv, z *b, int *ldb) noexcept nogil +cdef void zhbev(char *jobz, char *uplo, int *n, int *kd, z *ab, int *ldab, d *w, z *z, int *ldz, z *work, d *rwork, int *info) noexcept nogil +cdef void zhbevd(char *jobz, char *uplo, int *n, int *kd, z *ab, int *ldab, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void zhbevx(char *jobz, char *range, char *uplo, int *n, int *kd, z *ab, int *ldab, z *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void zhbgst(char *vect, char *uplo, int *n, int *ka, int *kb, z *ab, int *ldab, z *bb, int *ldbb, z *x, int *ldx, z *work, d *rwork, int *info) noexcept nogil +cdef void zhbgv(char *jobz, char *uplo, int *n, int *ka, int *kb, z *ab, int *ldab, z *bb, int *ldbb, d *w, z *z, int *ldz, z *work, d *rwork, int *info) noexcept nogil +cdef void zhbgvd(char *jobz, char *uplo, int *n, int *ka, int *kb, z *ab, int *ldab, z *bb, int *ldbb, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void zhbgvx(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, z *ab, int *ldab, z *bb, int *ldbb, z *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void zhbtrd(char *vect, char *uplo, int *n, int *kd, z *ab, int *ldab, d *d, d *e, z *q, int *ldq, z *work, int *info) noexcept nogil +cdef void zhecon(char *uplo, int *n, z *a, int *lda, int *ipiv, d *anorm, d *rcond, z *work, int *info) noexcept nogil +cdef void zheequb(char *uplo, int *n, z *a, int *lda, d *s, d *scond, d *amax, z *work, int *info) noexcept nogil +cdef void zheev(char *jobz, char *uplo, int *n, z *a, int *lda, d *w, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zheevd(char *jobz, char *uplo, int *n, z *a, int *lda, d *w, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void zheevr(char *jobz, char *range, char *uplo, int *n, z *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, int *isuppz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void zheevx(char *jobz, char *range, char *uplo, int *n, z *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void zhegs2(int *itype, char *uplo, int *n, z *a, int *lda, z *b, int *ldb, int *info) noexcept nogil +cdef void zhegst(int *itype, char *uplo, int *n, z *a, int *lda, z *b, int *ldb, int *info) noexcept nogil +cdef void zhegv(int *itype, char *jobz, char *uplo, int *n, z *a, int *lda, z *b, int *ldb, d *w, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zhegvd(int *itype, char *jobz, char *uplo, int *n, z *a, int *lda, z *b, int *ldb, d *w, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void zhegvx(int *itype, char *jobz, char *range, char *uplo, int *n, z *a, int *lda, z *b, int *ldb, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void zherfs(char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zhesv(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, z *work, int *lwork, int *info) noexcept nogil +cdef void zhesvx(char *fact, char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zheswapr(char *uplo, int *n, z *a, int *lda, int *i1, int *i2) noexcept nogil +cdef void zhetd2(char *uplo, int *n, z *a, int *lda, d *d, d *e, z *tau, int *info) noexcept nogil +cdef void zhetf2(char *uplo, int *n, z *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void zhetrd(char *uplo, int *n, z *a, int *lda, d *d, d *e, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zhetrf(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *lwork, int *info) noexcept nogil +cdef void zhetri(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *info) noexcept nogil +cdef void zhetri2(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *lwork, int *info) noexcept nogil +cdef void zhetri2x(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *nb, int *info) noexcept nogil +cdef void zhetrs(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, int *info) noexcept nogil +cdef void zhetrs2(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, z *work, int *info) noexcept nogil +cdef void zhfrk(char *transr, char *uplo, char *trans, int *n, int *k, d *alpha, z *a, int *lda, d *beta, z *c) noexcept nogil +cdef void zhgeqz(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, z *h, int *ldh, z *t, int *ldt, z *alpha, z *beta, z *q, int *ldq, z *z, int *ldz, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zhpcon(char *uplo, int *n, z *ap, int *ipiv, d *anorm, d *rcond, z *work, int *info) noexcept nogil +cdef void zhpev(char *jobz, char *uplo, int *n, z *ap, d *w, z *z, int *ldz, z *work, d *rwork, int *info) noexcept nogil +cdef void zhpevd(char *jobz, char *uplo, int *n, z *ap, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void zhpevx(char *jobz, char *range, char *uplo, int *n, z *ap, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void zhpgst(int *itype, char *uplo, int *n, z *ap, z *bp, int *info) noexcept nogil +cdef void zhpgv(int *itype, char *jobz, char *uplo, int *n, z *ap, z *bp, d *w, z *z, int *ldz, z *work, d *rwork, int *info) noexcept nogil +cdef void zhpgvd(int *itype, char *jobz, char *uplo, int *n, z *ap, z *bp, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void zhpgvx(int *itype, char *jobz, char *range, char *uplo, int *n, z *ap, z *bp, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil +cdef void zhprfs(char *uplo, int *n, int *nrhs, z *ap, z *afp, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zhpsv(char *uplo, int *n, int *nrhs, z *ap, int *ipiv, z *b, int *ldb, int *info) noexcept nogil +cdef void zhpsvx(char *fact, char *uplo, int *n, int *nrhs, z *ap, z *afp, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zhptrd(char *uplo, int *n, z *ap, d *d, d *e, z *tau, int *info) noexcept nogil +cdef void zhptrf(char *uplo, int *n, z *ap, int *ipiv, int *info) noexcept nogil +cdef void zhptri(char *uplo, int *n, z *ap, int *ipiv, z *work, int *info) noexcept nogil +cdef void zhptrs(char *uplo, int *n, int *nrhs, z *ap, int *ipiv, z *b, int *ldb, int *info) noexcept nogil +cdef void zhsein(char *side, char *eigsrc, char *initv, bint *select, int *n, z *h, int *ldh, z *w, z *vl, int *ldvl, z *vr, int *ldvr, int *mm, int *m, z *work, d *rwork, int *ifaill, int *ifailr, int *info) noexcept nogil +cdef void zhseqr(char *job, char *compz, int *n, int *ilo, int *ihi, z *h, int *ldh, z *w, z *z, int *ldz, z *work, int *lwork, int *info) noexcept nogil +cdef void zlabrd(int *m, int *n, int *nb, z *a, int *lda, d *d, d *e, z *tauq, z *taup, z *x, int *ldx, z *y, int *ldy) noexcept nogil +cdef void zlacgv(int *n, z *x, int *incx) noexcept nogil +cdef void zlacn2(int *n, z *v, z *x, d *est, int *kase, int *isave) noexcept nogil +cdef void zlacon(int *n, z *v, z *x, d *est, int *kase) noexcept nogil +cdef void zlacp2(char *uplo, int *m, int *n, d *a, int *lda, z *b, int *ldb) noexcept nogil +cdef void zlacpy(char *uplo, int *m, int *n, z *a, int *lda, z *b, int *ldb) noexcept nogil +cdef void zlacrm(int *m, int *n, z *a, int *lda, d *b, int *ldb, z *c, int *ldc, d *rwork) noexcept nogil +cdef void zlacrt(int *n, z *cx, int *incx, z *cy, int *incy, z *c, z *s) noexcept nogil +cdef z zladiv(z *x, z *y) noexcept nogil +cdef void zlaed0(int *qsiz, int *n, d *d, d *e, z *q, int *ldq, z *qstore, int *ldqs, d *rwork, int *iwork, int *info) noexcept nogil +cdef void zlaed7(int *n, int *cutpnt, int *qsiz, int *tlvls, int *curlvl, int *curpbm, d *d, z *q, int *ldq, d *rho, int *indxq, d *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, d *givnum, z *work, d *rwork, int *iwork, int *info) noexcept nogil +cdef void zlaed8(int *k, int *n, int *qsiz, z *q, int *ldq, d *d, d *rho, int *cutpnt, d *z, d *dlamda, z *q2, int *ldq2, d *w, int *indxp, int *indx, int *indxq, int *perm, int *givptr, int *givcol, d *givnum, int *info) noexcept nogil +cdef void zlaein(bint *rightv, bint *noinit, int *n, z *h, int *ldh, z *w, z *v, z *b, int *ldb, d *rwork, d *eps3, d *smlnum, int *info) noexcept nogil +cdef void zlaesy(z *a, z *b, z *c, z *rt1, z *rt2, z *evscal, z *cs1, z *sn1) noexcept nogil +cdef void zlaev2(z *a, z *b, z *c, d *rt1, d *rt2, d *cs1, z *sn1) noexcept nogil +cdef void zlag2c(int *m, int *n, z *a, int *lda, c *sa, int *ldsa, int *info) noexcept nogil +cdef void zlags2(bint *upper, d *a1, z *a2, d *a3, d *b1, z *b2, d *b3, d *csu, z *snu, d *csv, z *snv, d *csq, z *snq) noexcept nogil +cdef void zlagtm(char *trans, int *n, int *nrhs, d *alpha, z *dl, z *d, z *du, z *x, int *ldx, d *beta, z *b, int *ldb) noexcept nogil +cdef void zlahef(char *uplo, int *n, int *nb, int *kb, z *a, int *lda, int *ipiv, z *w, int *ldw, int *info) noexcept nogil +cdef void zlahqr(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, z *h, int *ldh, z *w, int *iloz, int *ihiz, z *z, int *ldz, int *info) noexcept nogil +cdef void zlahr2(int *n, int *k, int *nb, z *a, int *lda, z *tau, z *t, int *ldt, z *y, int *ldy) noexcept nogil +cdef void zlaic1(int *job, int *j, z *x, d *sest, z *w, z *gamma, d *sestpr, z *s, z *c) noexcept nogil +cdef void zlals0(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, z *b, int *ldb, z *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *poles, d *difl, d *difr, d *z, int *k, d *c, d *s, d *rwork, int *info) noexcept nogil +cdef void zlalsa(int *icompq, int *smlsiz, int *n, int *nrhs, z *b, int *ldb, z *bx, int *ldbx, d *u, int *ldu, d *vt, int *k, d *difl, d *difr, d *z, d *poles, int *givptr, int *givcol, int *ldgcol, int *perm, d *givnum, d *c, d *s, d *rwork, int *iwork, int *info) noexcept nogil +cdef void zlalsd(char *uplo, int *smlsiz, int *n, int *nrhs, d *d, d *e, z *b, int *ldb, d *rcond, int *rank, z *work, d *rwork, int *iwork, int *info) noexcept nogil +cdef d zlangb(char *norm, int *n, int *kl, int *ku, z *ab, int *ldab, d *work) noexcept nogil +cdef d zlange(char *norm, int *m, int *n, z *a, int *lda, d *work) noexcept nogil +cdef d zlangt(char *norm, int *n, z *dl, z *d_, z *du) noexcept nogil +cdef d zlanhb(char *norm, char *uplo, int *n, int *k, z *ab, int *ldab, d *work) noexcept nogil +cdef d zlanhe(char *norm, char *uplo, int *n, z *a, int *lda, d *work) noexcept nogil +cdef d zlanhf(char *norm, char *transr, char *uplo, int *n, z *a, d *work) noexcept nogil +cdef d zlanhp(char *norm, char *uplo, int *n, z *ap, d *work) noexcept nogil +cdef d zlanhs(char *norm, int *n, z *a, int *lda, d *work) noexcept nogil +cdef d zlanht(char *norm, int *n, d *d_, z *e) noexcept nogil +cdef d zlansb(char *norm, char *uplo, int *n, int *k, z *ab, int *ldab, d *work) noexcept nogil +cdef d zlansp(char *norm, char *uplo, int *n, z *ap, d *work) noexcept nogil +cdef d zlansy(char *norm, char *uplo, int *n, z *a, int *lda, d *work) noexcept nogil +cdef d zlantb(char *norm, char *uplo, char *diag, int *n, int *k, z *ab, int *ldab, d *work) noexcept nogil +cdef d zlantp(char *norm, char *uplo, char *diag, int *n, z *ap, d *work) noexcept nogil +cdef d zlantr(char *norm, char *uplo, char *diag, int *m, int *n, z *a, int *lda, d *work) noexcept nogil +cdef void zlapll(int *n, z *x, int *incx, z *y, int *incy, d *ssmin) noexcept nogil +cdef void zlapmr(bint *forwrd, int *m, int *n, z *x, int *ldx, int *k) noexcept nogil +cdef void zlapmt(bint *forwrd, int *m, int *n, z *x, int *ldx, int *k) noexcept nogil +cdef void zlaqgb(int *m, int *n, int *kl, int *ku, z *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) noexcept nogil +cdef void zlaqge(int *m, int *n, z *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) noexcept nogil +cdef void zlaqhb(char *uplo, int *n, int *kd, z *ab, int *ldab, d *s, d *scond, d *amax, char *equed) noexcept nogil +cdef void zlaqhe(char *uplo, int *n, z *a, int *lda, d *s, d *scond, d *amax, char *equed) noexcept nogil +cdef void zlaqhp(char *uplo, int *n, z *ap, d *s, d *scond, d *amax, char *equed) noexcept nogil +cdef void zlaqp2(int *m, int *n, int *offset, z *a, int *lda, int *jpvt, z *tau, d *vn1, d *vn2, z *work) noexcept nogil +cdef void zlaqps(int *m, int *n, int *offset, int *nb, int *kb, z *a, int *lda, int *jpvt, z *tau, d *vn1, d *vn2, z *auxv, z *f, int *ldf) noexcept nogil +cdef void zlaqr0(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, z *h, int *ldh, z *w, int *iloz, int *ihiz, z *z, int *ldz, z *work, int *lwork, int *info) noexcept nogil +cdef void zlaqr1(int *n, z *h, int *ldh, z *s1, z *s2, z *v) noexcept nogil +cdef void zlaqr2(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, z *h, int *ldh, int *iloz, int *ihiz, z *z, int *ldz, int *ns, int *nd, z *sh, z *v, int *ldv, int *nh, z *t, int *ldt, int *nv, z *wv, int *ldwv, z *work, int *lwork) noexcept nogil +cdef void zlaqr3(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, z *h, int *ldh, int *iloz, int *ihiz, z *z, int *ldz, int *ns, int *nd, z *sh, z *v, int *ldv, int *nh, z *t, int *ldt, int *nv, z *wv, int *ldwv, z *work, int *lwork) noexcept nogil +cdef void zlaqr4(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, z *h, int *ldh, z *w, int *iloz, int *ihiz, z *z, int *ldz, z *work, int *lwork, int *info) noexcept nogil +cdef void zlaqr5(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, z *s, z *h, int *ldh, int *iloz, int *ihiz, z *z, int *ldz, z *v, int *ldv, z *u, int *ldu, int *nv, z *wv, int *ldwv, int *nh, z *wh, int *ldwh) noexcept nogil +cdef void zlaqsb(char *uplo, int *n, int *kd, z *ab, int *ldab, d *s, d *scond, d *amax, char *equed) noexcept nogil +cdef void zlaqsp(char *uplo, int *n, z *ap, d *s, d *scond, d *amax, char *equed) noexcept nogil +cdef void zlaqsy(char *uplo, int *n, z *a, int *lda, d *s, d *scond, d *amax, char *equed) noexcept nogil +cdef void zlar1v(int *n, int *b1, int *bn, d *lambda_, d *d, d *l, d *ld, d *lld, d *pivmin, d *gaptol, z *z, bint *wantnc, int *negcnt, d *ztz, d *mingma, int *r, int *isuppz, d *nrminv, d *resid, d *rqcorr, d *work) noexcept nogil +cdef void zlar2v(int *n, z *x, z *y, z *z, int *incx, d *c, z *s, int *incc) noexcept nogil +cdef void zlarcm(int *m, int *n, d *a, int *lda, z *b, int *ldb, z *c, int *ldc, d *rwork) noexcept nogil +cdef void zlarf(char *side, int *m, int *n, z *v, int *incv, z *tau, z *c, int *ldc, z *work) noexcept nogil +cdef void zlarfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, z *v, int *ldv, z *t, int *ldt, z *c, int *ldc, z *work, int *ldwork) noexcept nogil +cdef void zlarfg(int *n, z *alpha, z *x, int *incx, z *tau) noexcept nogil +cdef void zlarfgp(int *n, z *alpha, z *x, int *incx, z *tau) noexcept nogil +cdef void zlarft(char *direct, char *storev, int *n, int *k, z *v, int *ldv, z *tau, z *t, int *ldt) noexcept nogil +cdef void zlarfx(char *side, int *m, int *n, z *v, z *tau, z *c, int *ldc, z *work) noexcept nogil +cdef void zlargv(int *n, z *x, int *incx, z *y, int *incy, d *c, int *incc) noexcept nogil +cdef void zlarnv(int *idist, int *iseed, int *n, z *x) noexcept nogil +cdef void zlarrv(int *n, d *vl, d *vu, d *d, d *l, d *pivmin, int *isplit, int *m, int *dol, int *dou, d *minrgp, d *rtol1, d *rtol2, d *w, d *werr, d *wgap, int *iblock, int *indexw, d *gers, z *z, int *ldz, int *isuppz, d *work, int *iwork, int *info) noexcept nogil +cdef void zlartg(z *f, z *g, d *cs, z *sn, z *r) noexcept nogil +cdef void zlartv(int *n, z *x, int *incx, z *y, int *incy, d *c, z *s, int *incc) noexcept nogil +cdef void zlarz(char *side, int *m, int *n, int *l, z *v, int *incv, z *tau, z *c, int *ldc, z *work) noexcept nogil +cdef void zlarzb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, z *v, int *ldv, z *t, int *ldt, z *c, int *ldc, z *work, int *ldwork) noexcept nogil +cdef void zlarzt(char *direct, char *storev, int *n, int *k, z *v, int *ldv, z *tau, z *t, int *ldt) noexcept nogil +cdef void zlascl(char *type_bn, int *kl, int *ku, d *cfrom, d *cto, int *m, int *n, z *a, int *lda, int *info) noexcept nogil +cdef void zlaset(char *uplo, int *m, int *n, z *alpha, z *beta, z *a, int *lda) noexcept nogil +cdef void zlasr(char *side, char *pivot, char *direct, int *m, int *n, d *c, d *s, z *a, int *lda) noexcept nogil +cdef void zlassq(int *n, z *x, int *incx, d *scale, d *sumsq) noexcept nogil +cdef void zlaswp(int *n, z *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) noexcept nogil +cdef void zlasyf(char *uplo, int *n, int *nb, int *kb, z *a, int *lda, int *ipiv, z *w, int *ldw, int *info) noexcept nogil +cdef void zlat2c(char *uplo, int *n, z *a, int *lda, c *sa, int *ldsa, int *info) noexcept nogil +cdef void zlatbs(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, z *ab, int *ldab, z *x, d *scale, d *cnorm, int *info) noexcept nogil +cdef void zlatdf(int *ijob, int *n, z *z, int *ldz, z *rhs, d *rdsum, d *rdscal, int *ipiv, int *jpiv) noexcept nogil +cdef void zlatps(char *uplo, char *trans, char *diag, char *normin, int *n, z *ap, z *x, d *scale, d *cnorm, int *info) noexcept nogil +cdef void zlatrd(char *uplo, int *n, int *nb, z *a, int *lda, d *e, z *tau, z *w, int *ldw) noexcept nogil +cdef void zlatrs(char *uplo, char *trans, char *diag, char *normin, int *n, z *a, int *lda, z *x, d *scale, d *cnorm, int *info) noexcept nogil +cdef void zlatrz(int *m, int *n, int *l, z *a, int *lda, z *tau, z *work) noexcept nogil +cdef void zlauu2(char *uplo, int *n, z *a, int *lda, int *info) noexcept nogil +cdef void zlauum(char *uplo, int *n, z *a, int *lda, int *info) noexcept nogil +cdef void zpbcon(char *uplo, int *n, int *kd, z *ab, int *ldab, d *anorm, d *rcond, z *work, d *rwork, int *info) noexcept nogil +cdef void zpbequ(char *uplo, int *n, int *kd, z *ab, int *ldab, d *s, d *scond, d *amax, int *info) noexcept nogil +cdef void zpbrfs(char *uplo, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *afb, int *ldafb, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zpbstf(char *uplo, int *n, int *kd, z *ab, int *ldab, int *info) noexcept nogil +cdef void zpbsv(char *uplo, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *b, int *ldb, int *info) noexcept nogil +cdef void zpbsvx(char *fact, char *uplo, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *afb, int *ldafb, char *equed, d *s, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zpbtf2(char *uplo, int *n, int *kd, z *ab, int *ldab, int *info) noexcept nogil +cdef void zpbtrf(char *uplo, int *n, int *kd, z *ab, int *ldab, int *info) noexcept nogil +cdef void zpbtrs(char *uplo, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *b, int *ldb, int *info) noexcept nogil +cdef void zpftrf(char *transr, char *uplo, int *n, z *a, int *info) noexcept nogil +cdef void zpftri(char *transr, char *uplo, int *n, z *a, int *info) noexcept nogil +cdef void zpftrs(char *transr, char *uplo, int *n, int *nrhs, z *a, z *b, int *ldb, int *info) noexcept nogil +cdef void zpocon(char *uplo, int *n, z *a, int *lda, d *anorm, d *rcond, z *work, d *rwork, int *info) noexcept nogil +cdef void zpoequ(int *n, z *a, int *lda, d *s, d *scond, d *amax, int *info) noexcept nogil +cdef void zpoequb(int *n, z *a, int *lda, d *s, d *scond, d *amax, int *info) noexcept nogil +cdef void zporfs(char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zposv(char *uplo, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, int *info) noexcept nogil +cdef void zposvx(char *fact, char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, char *equed, d *s, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zpotf2(char *uplo, int *n, z *a, int *lda, int *info) noexcept nogil +cdef void zpotrf(char *uplo, int *n, z *a, int *lda, int *info) noexcept nogil +cdef void zpotri(char *uplo, int *n, z *a, int *lda, int *info) noexcept nogil +cdef void zpotrs(char *uplo, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, int *info) noexcept nogil +cdef void zppcon(char *uplo, int *n, z *ap, d *anorm, d *rcond, z *work, d *rwork, int *info) noexcept nogil +cdef void zppequ(char *uplo, int *n, z *ap, d *s, d *scond, d *amax, int *info) noexcept nogil +cdef void zpprfs(char *uplo, int *n, int *nrhs, z *ap, z *afp, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zppsv(char *uplo, int *n, int *nrhs, z *ap, z *b, int *ldb, int *info) noexcept nogil +cdef void zppsvx(char *fact, char *uplo, int *n, int *nrhs, z *ap, z *afp, char *equed, d *s, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zpptrf(char *uplo, int *n, z *ap, int *info) noexcept nogil +cdef void zpptri(char *uplo, int *n, z *ap, int *info) noexcept nogil +cdef void zpptrs(char *uplo, int *n, int *nrhs, z *ap, z *b, int *ldb, int *info) noexcept nogil +cdef void zpstf2(char *uplo, int *n, z *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) noexcept nogil +cdef void zpstrf(char *uplo, int *n, z *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) noexcept nogil +cdef void zptcon(int *n, d *d, z *e, d *anorm, d *rcond, d *rwork, int *info) noexcept nogil +cdef void zpteqr(char *compz, int *n, d *d, d *e, z *z, int *ldz, d *work, int *info) noexcept nogil +cdef void zptrfs(char *uplo, int *n, int *nrhs, d *d, z *e, d *df, z *ef, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zptsv(int *n, int *nrhs, d *d, z *e, z *b, int *ldb, int *info) noexcept nogil +cdef void zptsvx(char *fact, int *n, int *nrhs, d *d, z *e, d *df, z *ef, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zpttrf(int *n, d *d, z *e, int *info) noexcept nogil +cdef void zpttrs(char *uplo, int *n, int *nrhs, d *d, z *e, z *b, int *ldb, int *info) noexcept nogil +cdef void zptts2(int *iuplo, int *n, int *nrhs, d *d, z *e, z *b, int *ldb) noexcept nogil +cdef void zrot(int *n, z *cx, int *incx, z *cy, int *incy, d *c, z *s) noexcept nogil +cdef void zspcon(char *uplo, int *n, z *ap, int *ipiv, d *anorm, d *rcond, z *work, int *info) noexcept nogil +cdef void zspmv(char *uplo, int *n, z *alpha, z *ap, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil +cdef void zspr(char *uplo, int *n, z *alpha, z *x, int *incx, z *ap) noexcept nogil +cdef void zsprfs(char *uplo, int *n, int *nrhs, z *ap, z *afp, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zspsv(char *uplo, int *n, int *nrhs, z *ap, int *ipiv, z *b, int *ldb, int *info) noexcept nogil +cdef void zspsvx(char *fact, char *uplo, int *n, int *nrhs, z *ap, z *afp, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zsptrf(char *uplo, int *n, z *ap, int *ipiv, int *info) noexcept nogil +cdef void zsptri(char *uplo, int *n, z *ap, int *ipiv, z *work, int *info) noexcept nogil +cdef void zsptrs(char *uplo, int *n, int *nrhs, z *ap, int *ipiv, z *b, int *ldb, int *info) noexcept nogil +cdef void zstedc(char *compz, int *n, d *d, d *e, z *z, int *ldz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void zstegr(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void zstein(int *n, d *d, d *e, int *m, d *w, int *iblock, int *isplit, z *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil +cdef void zstemr(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, int *m, d *w, z *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void zsteqr(char *compz, int *n, d *d, d *e, z *z, int *ldz, d *work, int *info) noexcept nogil +cdef void zsycon(char *uplo, int *n, z *a, int *lda, int *ipiv, d *anorm, d *rcond, z *work, int *info) noexcept nogil +cdef void zsyconv(char *uplo, char *way, int *n, z *a, int *lda, int *ipiv, z *work, int *info) noexcept nogil +cdef void zsyequb(char *uplo, int *n, z *a, int *lda, d *s, d *scond, d *amax, z *work, int *info) noexcept nogil +cdef void zsymv(char *uplo, int *n, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil +cdef void zsyr(char *uplo, int *n, z *alpha, z *x, int *incx, z *a, int *lda) noexcept nogil +cdef void zsyrfs(char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void zsysv(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, z *work, int *lwork, int *info) noexcept nogil +cdef void zsysvx(char *fact, char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, int *lwork, d *rwork, int *info) noexcept nogil +cdef void zsyswapr(char *uplo, int *n, z *a, int *lda, int *i1, int *i2) noexcept nogil +cdef void zsytf2(char *uplo, int *n, z *a, int *lda, int *ipiv, int *info) noexcept nogil +cdef void zsytrf(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *lwork, int *info) noexcept nogil +cdef void zsytri(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *info) noexcept nogil +cdef void zsytri2(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *lwork, int *info) noexcept nogil +cdef void zsytri2x(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *nb, int *info) noexcept nogil +cdef void zsytrs(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, int *info) noexcept nogil +cdef void zsytrs2(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, z *work, int *info) noexcept nogil +cdef void ztbcon(char *norm, char *uplo, char *diag, int *n, int *kd, z *ab, int *ldab, d *rcond, z *work, d *rwork, int *info) noexcept nogil +cdef void ztbrfs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void ztbtrs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *b, int *ldb, int *info) noexcept nogil +cdef void ztfsm(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, z *alpha, z *a, z *b, int *ldb) noexcept nogil +cdef void ztftri(char *transr, char *uplo, char *diag, int *n, z *a, int *info) noexcept nogil +cdef void ztfttp(char *transr, char *uplo, int *n, z *arf, z *ap, int *info) noexcept nogil +cdef void ztfttr(char *transr, char *uplo, int *n, z *arf, z *a, int *lda, int *info) noexcept nogil +cdef void ztgevc(char *side, char *howmny, bint *select, int *n, z *s, int *lds, z *p, int *ldp, z *vl, int *ldvl, z *vr, int *ldvr, int *mm, int *m, z *work, d *rwork, int *info) noexcept nogil +cdef void ztgex2(bint *wantq, bint *wantz, int *n, z *a, int *lda, z *b, int *ldb, z *q, int *ldq, z *z, int *ldz, int *j1, int *info) noexcept nogil +cdef void ztgexc(bint *wantq, bint *wantz, int *n, z *a, int *lda, z *b, int *ldb, z *q, int *ldq, z *z, int *ldz, int *ifst, int *ilst, int *info) noexcept nogil +cdef void ztgsen(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, z *a, int *lda, z *b, int *ldb, z *alpha, z *beta, z *q, int *ldq, z *z, int *ldz, int *m, d *pl, d *pr, d *dif, z *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil +cdef void ztgsja(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, z *a, int *lda, z *b, int *ldb, d *tola, d *tolb, d *alpha, d *beta, z *u, int *ldu, z *v, int *ldv, z *q, int *ldq, z *work, int *ncycle, int *info) noexcept nogil +cdef void ztgsna(char *job, char *howmny, bint *select, int *n, z *a, int *lda, z *b, int *ldb, z *vl, int *ldvl, z *vr, int *ldvr, d *s, d *dif, int *mm, int *m, z *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void ztgsy2(char *trans, int *ijob, int *m, int *n, z *a, int *lda, z *b, int *ldb, z *c, int *ldc, z *d, int *ldd, z *e, int *lde, z *f, int *ldf, d *scale, d *rdsum, d *rdscal, int *info) noexcept nogil +cdef void ztgsyl(char *trans, int *ijob, int *m, int *n, z *a, int *lda, z *b, int *ldb, z *c, int *ldc, z *d, int *ldd, z *e, int *lde, z *f, int *ldf, d *scale, d *dif, z *work, int *lwork, int *iwork, int *info) noexcept nogil +cdef void ztpcon(char *norm, char *uplo, char *diag, int *n, z *ap, d *rcond, z *work, d *rwork, int *info) noexcept nogil +cdef void ztpmqrt(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, z *v, int *ldv, z *t, int *ldt, z *a, int *lda, z *b, int *ldb, z *work, int *info) noexcept nogil +cdef void ztpqrt(int *m, int *n, int *l, int *nb, z *a, int *lda, z *b, int *ldb, z *t, int *ldt, z *work, int *info) noexcept nogil +cdef void ztpqrt2(int *m, int *n, int *l, z *a, int *lda, z *b, int *ldb, z *t, int *ldt, int *info) noexcept nogil +cdef void ztprfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, z *v, int *ldv, z *t, int *ldt, z *a, int *lda, z *b, int *ldb, z *work, int *ldwork) noexcept nogil +cdef void ztprfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, z *ap, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void ztptri(char *uplo, char *diag, int *n, z *ap, int *info) noexcept nogil +cdef void ztptrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, z *ap, z *b, int *ldb, int *info) noexcept nogil +cdef void ztpttf(char *transr, char *uplo, int *n, z *ap, z *arf, int *info) noexcept nogil +cdef void ztpttr(char *uplo, int *n, z *ap, z *a, int *lda, int *info) noexcept nogil +cdef void ztrcon(char *norm, char *uplo, char *diag, int *n, z *a, int *lda, d *rcond, z *work, d *rwork, int *info) noexcept nogil +cdef void ztrevc(char *side, char *howmny, bint *select, int *n, z *t, int *ldt, z *vl, int *ldvl, z *vr, int *ldvr, int *mm, int *m, z *work, d *rwork, int *info) noexcept nogil +cdef void ztrexc(char *compq, int *n, z *t, int *ldt, z *q, int *ldq, int *ifst, int *ilst, int *info) noexcept nogil +cdef void ztrrfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil +cdef void ztrsen(char *job, char *compq, bint *select, int *n, z *t, int *ldt, z *q, int *ldq, z *w, int *m, d *s, d *sep, z *work, int *lwork, int *info) noexcept nogil +cdef void ztrsna(char *job, char *howmny, bint *select, int *n, z *t, int *ldt, z *vl, int *ldvl, z *vr, int *ldvr, d *s, d *sep, int *mm, int *m, z *work, int *ldwork, d *rwork, int *info) noexcept nogil +cdef void ztrsyl(char *trana, char *tranb, int *isgn, int *m, int *n, z *a, int *lda, z *b, int *ldb, z *c, int *ldc, d *scale, int *info) noexcept nogil +cdef void ztrti2(char *uplo, char *diag, int *n, z *a, int *lda, int *info) noexcept nogil +cdef void ztrtri(char *uplo, char *diag, int *n, z *a, int *lda, int *info) noexcept nogil +cdef void ztrtrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, int *info) noexcept nogil +cdef void ztrttf(char *transr, char *uplo, int *n, z *a, int *lda, z *arf, int *info) noexcept nogil +cdef void ztrttp(char *uplo, int *n, z *a, int *lda, z *ap, int *info) noexcept nogil +cdef void ztzrzf(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zunbdb(char *trans, char *signs, int *m, int *p, int *q, z *x11, int *ldx11, z *x12, int *ldx12, z *x21, int *ldx21, z *x22, int *ldx22, d *theta, d *phi, z *taup1, z *taup2, z *tauq1, z *tauq2, z *work, int *lwork, int *info) noexcept nogil +cdef void zuncsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, z *x11, int *ldx11, z *x12, int *ldx12, z *x21, int *ldx21, z *x22, int *ldx22, d *theta, z *u1, int *ldu1, z *u2, int *ldu2, z *v1t, int *ldv1t, z *v2t, int *ldv2t, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *info) noexcept nogil +cdef void zung2l(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil +cdef void zung2r(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil +cdef void zungbr(char *vect, int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zunghr(int *n, int *ilo, int *ihi, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zungl2(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil +cdef void zunglq(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zungql(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zungqr(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zungr2(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil +cdef void zungrq(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zungtr(char *uplo, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil +cdef void zunm2l(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil +cdef void zunm2r(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil +cdef void zunmbr(char *vect, char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil +cdef void zunmhr(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil +cdef void zunml2(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil +cdef void zunmlq(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil +cdef void zunmql(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil +cdef void zunmqr(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil +cdef void zunmr2(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil +cdef void zunmr3(char *side, char *trans, int *m, int *n, int *k, int *l, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil +cdef void zunmrq(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil +cdef void zunmrz(char *side, char *trans, int *m, int *n, int *k, int *l, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil +cdef void zunmtr(char *side, char *uplo, char *trans, int *m, int *n, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil +cdef void zupgtr(char *uplo, int *n, z *ap, z *tau, z *q, int *ldq, z *work, int *info) noexcept nogil +cdef void zupmtr(char *side, char *uplo, char *trans, int *m, int *n, z *ap, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_lapack.pyx b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_lapack.pyx new file mode 100644 index 0000000000000000000000000000000000000000..2309699ac12513e19b735cf3af9c26fa8ed0e022 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/cython_lapack.pyx @@ -0,0 +1,12045 @@ +# This file was generated by _generate_pyx.py. +# Do not edit this file directly. +""" +LAPACK functions for Cython +=========================== + +Usable from Cython via:: + + cimport scipy.linalg.cython_lapack + +This module provides Cython-level wrappers for all primary routines included +in LAPACK 3.4.0 except for ``zcgesv`` since its interface is not consistent +from LAPACK 3.4.0 to 3.6.0. It also provides some of the +fixed-api auxiliary routines. + +These wrappers do not check for alignment of arrays. +Alignment should be checked before these wrappers are used. + +Raw function pointers (Fortran-style pointer arguments): + +- cbbcsd +- cbdsqr +- cgbbrd +- cgbcon +- cgbequ +- cgbequb +- cgbrfs +- cgbsv +- cgbsvx +- cgbtf2 +- cgbtrf +- cgbtrs +- cgebak +- cgebal +- cgebd2 +- cgebrd +- cgecon +- cgeequ +- cgeequb +- cgees +- cgeesx +- cgeev +- cgeevx +- cgehd2 +- cgehrd +- cgelq2 +- cgelqf +- cgels +- cgelsd +- cgelss +- cgelsy +- cgemqrt +- cgeql2 +- cgeqlf +- cgeqp3 +- cgeqr2 +- cgeqr2p +- cgeqrf +- cgeqrfp +- cgeqrt +- cgeqrt2 +- cgeqrt3 +- cgerfs +- cgerq2 +- cgerqf +- cgesc2 +- cgesdd +- cgesv +- cgesvd +- cgesvx +- cgetc2 +- cgetf2 +- cgetrf +- cgetri +- cgetrs +- cggbak +- cggbal +- cgges +- cggesx +- cggev +- cggevx +- cggglm +- cgghrd +- cgglse +- cggqrf +- cggrqf +- cgtcon +- cgtrfs +- cgtsv +- cgtsvx +- cgttrf +- cgttrs +- cgtts2 +- chbev +- chbevd +- chbevx +- chbgst +- chbgv +- chbgvd +- chbgvx +- chbtrd +- checon +- cheequb +- cheev +- cheevd +- cheevr +- cheevx +- chegs2 +- chegst +- chegv +- chegvd +- chegvx +- cherfs +- chesv +- chesvx +- cheswapr +- chetd2 +- chetf2 +- chetrd +- chetrf +- chetri +- chetri2 +- chetri2x +- chetrs +- chetrs2 +- chfrk +- chgeqz +- chla_transtype +- chpcon +- chpev +- chpevd +- chpevx +- chpgst +- chpgv +- chpgvd +- chpgvx +- chprfs +- chpsv +- chpsvx +- chptrd +- chptrf +- chptri +- chptrs +- chsein +- chseqr +- clabrd +- clacgv +- clacn2 +- clacon +- clacp2 +- clacpy +- clacrm +- clacrt +- cladiv +- claed0 +- claed7 +- claed8 +- claein +- claesy +- claev2 +- clag2z +- clags2 +- clagtm +- clahef +- clahqr +- clahr2 +- claic1 +- clals0 +- clalsa +- clalsd +- clangb +- clange +- clangt +- clanhb +- clanhe +- clanhf +- clanhp +- clanhs +- clanht +- clansb +- clansp +- clansy +- clantb +- clantp +- clantr +- clapll +- clapmr +- clapmt +- claqgb +- claqge +- claqhb +- claqhe +- claqhp +- claqp2 +- claqps +- claqr0 +- claqr1 +- claqr2 +- claqr3 +- claqr4 +- claqr5 +- claqsb +- claqsp +- claqsy +- clar1v +- clar2v +- clarcm +- clarf +- clarfb +- clarfg +- clarfgp +- clarft +- clarfx +- clargv +- clarnv +- clarrv +- clartg +- clartv +- clarz +- clarzb +- clarzt +- clascl +- claset +- clasr +- classq +- claswp +- clasyf +- clatbs +- clatdf +- clatps +- clatrd +- clatrs +- clatrz +- clauu2 +- clauum +- cpbcon +- cpbequ +- cpbrfs +- cpbstf +- cpbsv +- cpbsvx +- cpbtf2 +- cpbtrf +- cpbtrs +- cpftrf +- cpftri +- cpftrs +- cpocon +- cpoequ +- cpoequb +- cporfs +- cposv +- cposvx +- cpotf2 +- cpotrf +- cpotri +- cpotrs +- cppcon +- cppequ +- cpprfs +- cppsv +- cppsvx +- cpptrf +- cpptri +- cpptrs +- cpstf2 +- cpstrf +- cptcon +- cpteqr +- cptrfs +- cptsv +- cptsvx +- cpttrf +- cpttrs +- cptts2 +- crot +- cspcon +- cspmv +- cspr +- csprfs +- cspsv +- cspsvx +- csptrf +- csptri +- csptrs +- csrscl +- cstedc +- cstegr +- cstein +- cstemr +- csteqr +- csycon +- csyconv +- csyequb +- csymv +- csyr +- csyrfs +- csysv +- csysvx +- csyswapr +- csytf2 +- csytrf +- csytri +- csytri2 +- csytri2x +- csytrs +- csytrs2 +- ctbcon +- ctbrfs +- ctbtrs +- ctfsm +- ctftri +- ctfttp +- ctfttr +- ctgevc +- ctgex2 +- ctgexc +- ctgsen +- ctgsja +- ctgsna +- ctgsy2 +- ctgsyl +- ctpcon +- ctpmqrt +- ctpqrt +- ctpqrt2 +- ctprfb +- ctprfs +- ctptri +- ctptrs +- ctpttf +- ctpttr +- ctrcon +- ctrevc +- ctrexc +- ctrrfs +- ctrsen +- ctrsna +- ctrsyl +- ctrti2 +- ctrtri +- ctrtrs +- ctrttf +- ctrttp +- ctzrzf +- cunbdb +- cuncsd +- cung2l +- cung2r +- cungbr +- cunghr +- cungl2 +- cunglq +- cungql +- cungqr +- cungr2 +- cungrq +- cungtr +- cunm2l +- cunm2r +- cunmbr +- cunmhr +- cunml2 +- cunmlq +- cunmql +- cunmqr +- cunmr2 +- cunmr3 +- cunmrq +- cunmrz +- cunmtr +- cupgtr +- cupmtr +- dbbcsd +- dbdsdc +- dbdsqr +- ddisna +- dgbbrd +- dgbcon +- dgbequ +- dgbequb +- dgbrfs +- dgbsv +- dgbsvx +- dgbtf2 +- dgbtrf +- dgbtrs +- dgebak +- dgebal +- dgebd2 +- dgebrd +- dgecon +- dgeequ +- dgeequb +- dgees +- dgeesx +- dgeev +- dgeevx +- dgehd2 +- dgehrd +- dgejsv +- dgelq2 +- dgelqf +- dgels +- dgelsd +- dgelss +- dgelsy +- dgemqrt +- dgeql2 +- dgeqlf +- dgeqp3 +- dgeqr2 +- dgeqr2p +- dgeqrf +- dgeqrfp +- dgeqrt +- dgeqrt2 +- dgeqrt3 +- dgerfs +- dgerq2 +- dgerqf +- dgesc2 +- dgesdd +- dgesv +- dgesvd +- dgesvj +- dgesvx +- dgetc2 +- dgetf2 +- dgetrf +- dgetri +- dgetrs +- dggbak +- dggbal +- dgges +- dggesx +- dggev +- dggevx +- dggglm +- dgghrd +- dgglse +- dggqrf +- dggrqf +- dgsvj0 +- dgsvj1 +- dgtcon +- dgtrfs +- dgtsv +- dgtsvx +- dgttrf +- dgttrs +- dgtts2 +- dhgeqz +- dhsein +- dhseqr +- disnan +- dlabad +- dlabrd +- dlacn2 +- dlacon +- dlacpy +- dladiv +- dlae2 +- dlaebz +- dlaed0 +- dlaed1 +- dlaed2 +- dlaed3 +- dlaed4 +- dlaed5 +- dlaed6 +- dlaed7 +- dlaed8 +- dlaed9 +- dlaeda +- dlaein +- dlaev2 +- dlaexc +- dlag2 +- dlag2s +- dlags2 +- dlagtf +- dlagtm +- dlagts +- dlagv2 +- dlahqr +- dlahr2 +- dlaic1 +- dlaln2 +- dlals0 +- dlalsa +- dlalsd +- dlamch +- dlamrg +- dlaneg +- dlangb +- dlange +- dlangt +- dlanhs +- dlansb +- dlansf +- dlansp +- dlanst +- dlansy +- dlantb +- dlantp +- dlantr +- dlanv2 +- dlapll +- dlapmr +- dlapmt +- dlapy2 +- dlapy3 +- dlaqgb +- dlaqge +- dlaqp2 +- dlaqps +- dlaqr0 +- dlaqr1 +- dlaqr2 +- dlaqr3 +- dlaqr4 +- dlaqr5 +- dlaqsb +- dlaqsp +- dlaqsy +- dlaqtr +- dlar1v +- dlar2v +- dlarf +- dlarfb +- dlarfg +- dlarfgp +- dlarft +- dlarfx +- dlargv +- dlarnv +- dlarra +- dlarrb +- dlarrc +- dlarrd +- dlarre +- dlarrf +- dlarrj +- dlarrk +- dlarrr +- dlarrv +- dlartg +- dlartgp +- dlartgs +- dlartv +- dlaruv +- dlarz +- dlarzb +- dlarzt +- dlas2 +- dlascl +- dlasd0 +- dlasd1 +- dlasd2 +- dlasd3 +- dlasd4 +- dlasd5 +- dlasd6 +- dlasd7 +- dlasd8 +- dlasda +- dlasdq +- dlasdt +- dlaset +- dlasq1 +- dlasq2 +- dlasq3 +- dlasq4 +- dlasq6 +- dlasr +- dlasrt +- dlassq +- dlasv2 +- dlaswp +- dlasy2 +- dlasyf +- dlat2s +- dlatbs +- dlatdf +- dlatps +- dlatrd +- dlatrs +- dlatrz +- dlauu2 +- dlauum +- dopgtr +- dopmtr +- dorbdb +- dorcsd +- dorg2l +- dorg2r +- dorgbr +- dorghr +- dorgl2 +- dorglq +- dorgql +- dorgqr +- dorgr2 +- dorgrq +- dorgtr +- dorm2l +- dorm2r +- dormbr +- dormhr +- dorml2 +- dormlq +- dormql +- dormqr +- dormr2 +- dormr3 +- dormrq +- dormrz +- dormtr +- dpbcon +- dpbequ +- dpbrfs +- dpbstf +- dpbsv +- dpbsvx +- dpbtf2 +- dpbtrf +- dpbtrs +- dpftrf +- dpftri +- dpftrs +- dpocon +- dpoequ +- dpoequb +- dporfs +- dposv +- dposvx +- dpotf2 +- dpotrf +- dpotri +- dpotrs +- dppcon +- dppequ +- dpprfs +- dppsv +- dppsvx +- dpptrf +- dpptri +- dpptrs +- dpstf2 +- dpstrf +- dptcon +- dpteqr +- dptrfs +- dptsv +- dptsvx +- dpttrf +- dpttrs +- dptts2 +- drscl +- dsbev +- dsbevd +- dsbevx +- dsbgst +- dsbgv +- dsbgvd +- dsbgvx +- dsbtrd +- dsfrk +- dsgesv +- dspcon +- dspev +- dspevd +- dspevx +- dspgst +- dspgv +- dspgvd +- dspgvx +- dsposv +- dsprfs +- dspsv +- dspsvx +- dsptrd +- dsptrf +- dsptri +- dsptrs +- dstebz +- dstedc +- dstegr +- dstein +- dstemr +- dsteqr +- dsterf +- dstev +- dstevd +- dstevr +- dstevx +- dsycon +- dsyconv +- dsyequb +- dsyev +- dsyevd +- dsyevr +- dsyevx +- dsygs2 +- dsygst +- dsygv +- dsygvd +- dsygvx +- dsyrfs +- dsysv +- dsysvx +- dsyswapr +- dsytd2 +- dsytf2 +- dsytrd +- dsytrf +- dsytri +- dsytri2 +- dsytri2x +- dsytrs +- dsytrs2 +- dtbcon +- dtbrfs +- dtbtrs +- dtfsm +- dtftri +- dtfttp +- dtfttr +- dtgevc +- dtgex2 +- dtgexc +- dtgsen +- dtgsja +- dtgsna +- dtgsy2 +- dtgsyl +- dtpcon +- dtpmqrt +- dtpqrt +- dtpqrt2 +- dtprfb +- dtprfs +- dtptri +- dtptrs +- dtpttf +- dtpttr +- dtrcon +- dtrevc +- dtrexc +- dtrrfs +- dtrsen +- dtrsna +- dtrsyl +- dtrti2 +- dtrtri +- dtrtrs +- dtrttf +- dtrttp +- dtzrzf +- dzsum1 +- icmax1 +- ieeeck +- ilaclc +- ilaclr +- iladiag +- iladlc +- iladlr +- ilaprec +- ilaslc +- ilaslr +- ilatrans +- ilauplo +- ilaver +- ilazlc +- ilazlr +- izmax1 +- sbbcsd +- sbdsdc +- sbdsqr +- scsum1 +- sdisna +- sgbbrd +- sgbcon +- sgbequ +- sgbequb +- sgbrfs +- sgbsv +- sgbsvx +- sgbtf2 +- sgbtrf +- sgbtrs +- sgebak +- sgebal +- sgebd2 +- sgebrd +- sgecon +- sgeequ +- sgeequb +- sgees +- sgeesx +- sgeev +- sgeevx +- sgehd2 +- sgehrd +- sgejsv +- sgelq2 +- sgelqf +- sgels +- sgelsd +- sgelss +- sgelsy +- sgemqrt +- sgeql2 +- sgeqlf +- sgeqp3 +- sgeqr2 +- sgeqr2p +- sgeqrf +- sgeqrfp +- sgeqrt +- sgeqrt2 +- sgeqrt3 +- sgerfs +- sgerq2 +- sgerqf +- sgesc2 +- sgesdd +- sgesv +- sgesvd +- sgesvj +- sgesvx +- sgetc2 +- sgetf2 +- sgetrf +- sgetri +- sgetrs +- sggbak +- sggbal +- sgges +- sggesx +- sggev +- sggevx +- sggglm +- sgghrd +- sgglse +- sggqrf +- sggrqf +- sgsvj0 +- sgsvj1 +- sgtcon +- sgtrfs +- sgtsv +- sgtsvx +- sgttrf +- sgttrs +- sgtts2 +- shgeqz +- shsein +- shseqr +- slabad +- slabrd +- slacn2 +- slacon +- slacpy +- sladiv +- slae2 +- slaebz +- slaed0 +- slaed1 +- slaed2 +- slaed3 +- slaed4 +- slaed5 +- slaed6 +- slaed7 +- slaed8 +- slaed9 +- slaeda +- slaein +- slaev2 +- slaexc +- slag2 +- slag2d +- slags2 +- slagtf +- slagtm +- slagts +- slagv2 +- slahqr +- slahr2 +- slaic1 +- slaln2 +- slals0 +- slalsa +- slalsd +- slamch +- slamrg +- slangb +- slange +- slangt +- slanhs +- slansb +- slansf +- slansp +- slanst +- slansy +- slantb +- slantp +- slantr +- slanv2 +- slapll +- slapmr +- slapmt +- slapy2 +- slapy3 +- slaqgb +- slaqge +- slaqp2 +- slaqps +- slaqr0 +- slaqr1 +- slaqr2 +- slaqr3 +- slaqr4 +- slaqr5 +- slaqsb +- slaqsp +- slaqsy +- slaqtr +- slar1v +- slar2v +- slarf +- slarfb +- slarfg +- slarfgp +- slarft +- slarfx +- slargv +- slarnv +- slarra +- slarrb +- slarrc +- slarrd +- slarre +- slarrf +- slarrj +- slarrk +- slarrr +- slarrv +- slartg +- slartgp +- slartgs +- slartv +- slaruv +- slarz +- slarzb +- slarzt +- slas2 +- slascl +- slasd0 +- slasd1 +- slasd2 +- slasd3 +- slasd4 +- slasd5 +- slasd6 +- slasd7 +- slasd8 +- slasda +- slasdq +- slasdt +- slaset +- slasq1 +- slasq2 +- slasq3 +- slasq4 +- slasq6 +- slasr +- slasrt +- slassq +- slasv2 +- slaswp +- slasy2 +- slasyf +- slatbs +- slatdf +- slatps +- slatrd +- slatrs +- slatrz +- slauu2 +- slauum +- sopgtr +- sopmtr +- sorbdb +- sorcsd +- sorg2l +- sorg2r +- sorgbr +- sorghr +- sorgl2 +- sorglq +- sorgql +- sorgqr +- sorgr2 +- sorgrq +- sorgtr +- sorm2l +- sorm2r +- sormbr +- sormhr +- sorml2 +- sormlq +- sormql +- sormqr +- sormr2 +- sormr3 +- sormrq +- sormrz +- sormtr +- spbcon +- spbequ +- spbrfs +- spbstf +- spbsv +- spbsvx +- spbtf2 +- spbtrf +- spbtrs +- spftrf +- spftri +- spftrs +- spocon +- spoequ +- spoequb +- sporfs +- sposv +- sposvx +- spotf2 +- spotrf +- spotri +- spotrs +- sppcon +- sppequ +- spprfs +- sppsv +- sppsvx +- spptrf +- spptri +- spptrs +- spstf2 +- spstrf +- sptcon +- spteqr +- sptrfs +- sptsv +- sptsvx +- spttrf +- spttrs +- sptts2 +- srscl +- ssbev +- ssbevd +- ssbevx +- ssbgst +- ssbgv +- ssbgvd +- ssbgvx +- ssbtrd +- ssfrk +- sspcon +- sspev +- sspevd +- sspevx +- sspgst +- sspgv +- sspgvd +- sspgvx +- ssprfs +- sspsv +- sspsvx +- ssptrd +- ssptrf +- ssptri +- ssptrs +- sstebz +- sstedc +- sstegr +- sstein +- sstemr +- ssteqr +- ssterf +- sstev +- sstevd +- sstevr +- sstevx +- ssycon +- ssyconv +- ssyequb +- ssyev +- ssyevd +- ssyevr +- ssyevx +- ssygs2 +- ssygst +- ssygv +- ssygvd +- ssygvx +- ssyrfs +- ssysv +- ssysvx +- ssyswapr +- ssytd2 +- ssytf2 +- ssytrd +- ssytrf +- ssytri +- ssytri2 +- ssytri2x +- ssytrs +- ssytrs2 +- stbcon +- stbrfs +- stbtrs +- stfsm +- stftri +- stfttp +- stfttr +- stgevc +- stgex2 +- stgexc +- stgsen +- stgsja +- stgsna +- stgsy2 +- stgsyl +- stpcon +- stpmqrt +- stpqrt +- stpqrt2 +- stprfb +- stprfs +- stptri +- stptrs +- stpttf +- stpttr +- strcon +- strevc +- strexc +- strrfs +- strsen +- strsna +- strsyl +- strti2 +- strtri +- strtrs +- strttf +- strttp +- stzrzf +- xerbla_array +- zbbcsd +- zbdsqr +- zcgesv +- zcposv +- zdrscl +- zgbbrd +- zgbcon +- zgbequ +- zgbequb +- zgbrfs +- zgbsv +- zgbsvx +- zgbtf2 +- zgbtrf +- zgbtrs +- zgebak +- zgebal +- zgebd2 +- zgebrd +- zgecon +- zgeequ +- zgeequb +- zgees +- zgeesx +- zgeev +- zgeevx +- zgehd2 +- zgehrd +- zgelq2 +- zgelqf +- zgels +- zgelsd +- zgelss +- zgelsy +- zgemqrt +- zgeql2 +- zgeqlf +- zgeqp3 +- zgeqr2 +- zgeqr2p +- zgeqrf +- zgeqrfp +- zgeqrt +- zgeqrt2 +- zgeqrt3 +- zgerfs +- zgerq2 +- zgerqf +- zgesc2 +- zgesdd +- zgesv +- zgesvd +- zgesvx +- zgetc2 +- zgetf2 +- zgetrf +- zgetri +- zgetrs +- zggbak +- zggbal +- zgges +- zggesx +- zggev +- zggevx +- zggglm +- zgghrd +- zgglse +- zggqrf +- zggrqf +- zgtcon +- zgtrfs +- zgtsv +- zgtsvx +- zgttrf +- zgttrs +- zgtts2 +- zhbev +- zhbevd +- zhbevx +- zhbgst +- zhbgv +- zhbgvd +- zhbgvx +- zhbtrd +- zhecon +- zheequb +- zheev +- zheevd +- zheevr +- zheevx +- zhegs2 +- zhegst +- zhegv +- zhegvd +- zhegvx +- zherfs +- zhesv +- zhesvx +- zheswapr +- zhetd2 +- zhetf2 +- zhetrd +- zhetrf +- zhetri +- zhetri2 +- zhetri2x +- zhetrs +- zhetrs2 +- zhfrk +- zhgeqz +- zhpcon +- zhpev +- zhpevd +- zhpevx +- zhpgst +- zhpgv +- zhpgvd +- zhpgvx +- zhprfs +- zhpsv +- zhpsvx +- zhptrd +- zhptrf +- zhptri +- zhptrs +- zhsein +- zhseqr +- zlabrd +- zlacgv +- zlacn2 +- zlacon +- zlacp2 +- zlacpy +- zlacrm +- zlacrt +- zladiv +- zlaed0 +- zlaed7 +- zlaed8 +- zlaein +- zlaesy +- zlaev2 +- zlag2c +- zlags2 +- zlagtm +- zlahef +- zlahqr +- zlahr2 +- zlaic1 +- zlals0 +- zlalsa +- zlalsd +- zlangb +- zlange +- zlangt +- zlanhb +- zlanhe +- zlanhf +- zlanhp +- zlanhs +- zlanht +- zlansb +- zlansp +- zlansy +- zlantb +- zlantp +- zlantr +- zlapll +- zlapmr +- zlapmt +- zlaqgb +- zlaqge +- zlaqhb +- zlaqhe +- zlaqhp +- zlaqp2 +- zlaqps +- zlaqr0 +- zlaqr1 +- zlaqr2 +- zlaqr3 +- zlaqr4 +- zlaqr5 +- zlaqsb +- zlaqsp +- zlaqsy +- zlar1v +- zlar2v +- zlarcm +- zlarf +- zlarfb +- zlarfg +- zlarfgp +- zlarft +- zlarfx +- zlargv +- zlarnv +- zlarrv +- zlartg +- zlartv +- zlarz +- zlarzb +- zlarzt +- zlascl +- zlaset +- zlasr +- zlassq +- zlaswp +- zlasyf +- zlat2c +- zlatbs +- zlatdf +- zlatps +- zlatrd +- zlatrs +- zlatrz +- zlauu2 +- zlauum +- zpbcon +- zpbequ +- zpbrfs +- zpbstf +- zpbsv +- zpbsvx +- zpbtf2 +- zpbtrf +- zpbtrs +- zpftrf +- zpftri +- zpftrs +- zpocon +- zpoequ +- zpoequb +- zporfs +- zposv +- zposvx +- zpotf2 +- zpotrf +- zpotri +- zpotrs +- zppcon +- zppequ +- zpprfs +- zppsv +- zppsvx +- zpptrf +- zpptri +- zpptrs +- zpstf2 +- zpstrf +- zptcon +- zpteqr +- zptrfs +- zptsv +- zptsvx +- zpttrf +- zpttrs +- zptts2 +- zrot +- zspcon +- zspmv +- zspr +- zsprfs +- zspsv +- zspsvx +- zsptrf +- zsptri +- zsptrs +- zstedc +- zstegr +- zstein +- zstemr +- zsteqr +- zsycon +- zsyconv +- zsyequb +- zsymv +- zsyr +- zsyrfs +- zsysv +- zsysvx +- zsyswapr +- zsytf2 +- zsytrf +- zsytri +- zsytri2 +- zsytri2x +- zsytrs +- zsytrs2 +- ztbcon +- ztbrfs +- ztbtrs +- ztfsm +- ztftri +- ztfttp +- ztfttr +- ztgevc +- ztgex2 +- ztgexc +- ztgsen +- ztgsja +- ztgsna +- ztgsy2 +- ztgsyl +- ztpcon +- ztpmqrt +- ztpqrt +- ztpqrt2 +- ztprfb +- ztprfs +- ztptri +- ztptrs +- ztpttf +- ztpttr +- ztrcon +- ztrevc +- ztrexc +- ztrrfs +- ztrsen +- ztrsna +- ztrsyl +- ztrti2 +- ztrtri +- ztrtrs +- ztrttf +- ztrttp +- ztzrzf +- zunbdb +- zuncsd +- zung2l +- zung2r +- zungbr +- zunghr +- zungl2 +- zunglq +- zungql +- zungqr +- zungr2 +- zungrq +- zungtr +- zunm2l +- zunm2r +- zunmbr +- zunmhr +- zunml2 +- zunmlq +- zunmql +- zunmqr +- zunmr2 +- zunmr3 +- zunmrq +- zunmrz +- zunmtr +- zupgtr +- zupmtr + + +""" + +# Within SciPy, these wrappers can be used via relative or absolute cimport. +# Examples: +# from ..linalg cimport cython_lapack +# from scipy.linalg cimport cython_lapack +# cimport scipy.linalg.cython_lapack as cython_lapack +# cimport ..linalg.cython_lapack as cython_lapack + +# Within SciPy, if LAPACK functions are needed in C/C++/Fortran, +# these wrappers should not be used. +# The original libraries should be linked directly. + +cdef extern from "fortran_defs.h": + pass + +from numpy cimport npy_complex64, npy_complex128 + +cdef extern from "_lapack_subroutines.h": + # Function pointer type declarations for + # gees and gges families of functions. + ctypedef bint _cselect1(npy_complex64*) + ctypedef bint _cselect2(npy_complex64*, npy_complex64*) + ctypedef bint _dselect2(d*, d*) + ctypedef bint _dselect3(d*, d*, d*) + ctypedef bint _sselect2(s*, s*) + ctypedef bint _sselect3(s*, s*, s*) + ctypedef bint _zselect1(npy_complex128*) + ctypedef bint _zselect2(npy_complex128*, npy_complex128*) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cbbcsd "BLAS_FUNC(cbbcsd)"(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, s *theta, s *phi, npy_complex64 *u1, int *ldu1, npy_complex64 *u2, int *ldu2, npy_complex64 *v1t, int *ldv1t, npy_complex64 *v2t, int *ldv2t, s *b11d, s *b11e, s *b12d, s *b12e, s *b21d, s *b21e, s *b22d, s *b22e, s *rwork, int *lrwork, int *info) nogil +cdef void cbbcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, s *theta, s *phi, c *u1, int *ldu1, c *u2, int *ldu2, c *v1t, int *ldv1t, c *v2t, int *ldv2t, s *b11d, s *b11e, s *b12d, s *b12e, s *b21d, s *b21e, s *b22d, s *b22e, s *rwork, int *lrwork, int *info) noexcept nogil: + + _fortran_cbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, rwork, lrwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cbdsqr "BLAS_FUNC(cbdsqr)"(char *uplo, int *n, int *ncvt, int *nru, int *ncc, s *d, s *e, npy_complex64 *vt, int *ldvt, npy_complex64 *u, int *ldu, npy_complex64 *c, int *ldc, s *rwork, int *info) nogil +cdef void cbdsqr(char *uplo, int *n, int *ncvt, int *nru, int *ncc, s *d, s *e, c *vt, int *ldvt, c *u, int *ldu, c *c, int *ldc, s *rwork, int *info) noexcept nogil: + + _fortran_cbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgbbrd "BLAS_FUNC(cgbbrd)"(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, npy_complex64 *ab, int *ldab, s *d, s *e, npy_complex64 *q, int *ldq, npy_complex64 *pt, int *ldpt, npy_complex64 *c, int *ldc, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cgbbrd(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, c *ab, int *ldab, s *d, s *e, c *q, int *ldq, c *pt, int *ldpt, c *c, int *ldc, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgbcon "BLAS_FUNC(cgbcon)"(char *norm, int *n, int *kl, int *ku, npy_complex64 *ab, int *ldab, int *ipiv, s *anorm, s *rcond, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cgbcon(char *norm, int *n, int *kl, int *ku, c *ab, int *ldab, int *ipiv, s *anorm, s *rcond, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgbequ "BLAS_FUNC(cgbequ)"(int *m, int *n, int *kl, int *ku, npy_complex64 *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) nogil +cdef void cgbequ(int *m, int *n, int *kl, int *ku, c *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil: + + _fortran_cgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgbequb "BLAS_FUNC(cgbequb)"(int *m, int *n, int *kl, int *ku, npy_complex64 *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) nogil +cdef void cgbequb(int *m, int *n, int *kl, int *ku, c *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil: + + _fortran_cgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgbrfs "BLAS_FUNC(cgbrfs)"(char *trans, int *n, int *kl, int *ku, int *nrhs, npy_complex64 *ab, int *ldab, npy_complex64 *afb, int *ldafb, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cgbrfs(char *trans, int *n, int *kl, int *ku, int *nrhs, c *ab, int *ldab, c *afb, int *ldafb, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgbsv "BLAS_FUNC(cgbsv)"(int *n, int *kl, int *ku, int *nrhs, npy_complex64 *ab, int *ldab, int *ipiv, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cgbsv(int *n, int *kl, int *ku, int *nrhs, c *ab, int *ldab, int *ipiv, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgbsvx "BLAS_FUNC(cgbsvx)"(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, npy_complex64 *ab, int *ldab, npy_complex64 *afb, int *ldafb, int *ipiv, char *equed, s *r, s *c, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *rcond, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cgbsvx(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, c *ab, int *ldab, c *afb, int *ldafb, int *ipiv, char *equed, s *r, s *c, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cgbsvx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgbtf2 "BLAS_FUNC(cgbtf2)"(int *m, int *n, int *kl, int *ku, npy_complex64 *ab, int *ldab, int *ipiv, int *info) nogil +cdef void cgbtf2(int *m, int *n, int *kl, int *ku, c *ab, int *ldab, int *ipiv, int *info) noexcept nogil: + + _fortran_cgbtf2(m, n, kl, ku, ab, ldab, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgbtrf "BLAS_FUNC(cgbtrf)"(int *m, int *n, int *kl, int *ku, npy_complex64 *ab, int *ldab, int *ipiv, int *info) nogil +cdef void cgbtrf(int *m, int *n, int *kl, int *ku, c *ab, int *ldab, int *ipiv, int *info) noexcept nogil: + + _fortran_cgbtrf(m, n, kl, ku, ab, ldab, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgbtrs "BLAS_FUNC(cgbtrs)"(char *trans, int *n, int *kl, int *ku, int *nrhs, npy_complex64 *ab, int *ldab, int *ipiv, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cgbtrs(char *trans, int *n, int *kl, int *ku, int *nrhs, c *ab, int *ldab, int *ipiv, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgebak "BLAS_FUNC(cgebak)"(char *job, char *side, int *n, int *ilo, int *ihi, s *scale, int *m, npy_complex64 *v, int *ldv, int *info) nogil +cdef void cgebak(char *job, char *side, int *n, int *ilo, int *ihi, s *scale, int *m, c *v, int *ldv, int *info) noexcept nogil: + + _fortran_cgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgebal "BLAS_FUNC(cgebal)"(char *job, int *n, npy_complex64 *a, int *lda, int *ilo, int *ihi, s *scale, int *info) nogil +cdef void cgebal(char *job, int *n, c *a, int *lda, int *ilo, int *ihi, s *scale, int *info) noexcept nogil: + + _fortran_cgebal(job, n, a, lda, ilo, ihi, scale, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgebd2 "BLAS_FUNC(cgebd2)"(int *m, int *n, npy_complex64 *a, int *lda, s *d, s *e, npy_complex64 *tauq, npy_complex64 *taup, npy_complex64 *work, int *info) nogil +cdef void cgebd2(int *m, int *n, c *a, int *lda, s *d, s *e, c *tauq, c *taup, c *work, int *info) noexcept nogil: + + _fortran_cgebd2(m, n, a, lda, d, e, tauq, taup, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgebrd "BLAS_FUNC(cgebrd)"(int *m, int *n, npy_complex64 *a, int *lda, s *d, s *e, npy_complex64 *tauq, npy_complex64 *taup, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cgebrd(int *m, int *n, c *a, int *lda, s *d, s *e, c *tauq, c *taup, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgecon "BLAS_FUNC(cgecon)"(char *norm, int *n, npy_complex64 *a, int *lda, s *anorm, s *rcond, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cgecon(char *norm, int *n, c *a, int *lda, s *anorm, s *rcond, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cgecon(norm, n, a, lda, anorm, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeequ "BLAS_FUNC(cgeequ)"(int *m, int *n, npy_complex64 *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) nogil +cdef void cgeequ(int *m, int *n, c *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil: + + _fortran_cgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeequb "BLAS_FUNC(cgeequb)"(int *m, int *n, npy_complex64 *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) nogil +cdef void cgeequb(int *m, int *n, c *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil: + + _fortran_cgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgees "BLAS_FUNC(cgees)"(char *jobvs, char *sort, _cselect1 *select, int *n, npy_complex64 *a, int *lda, int *sdim, npy_complex64 *w, npy_complex64 *vs, int *ldvs, npy_complex64 *work, int *lwork, s *rwork, bint *bwork, int *info) nogil +cdef void cgees(char *jobvs, char *sort, cselect1 *select, int *n, c *a, int *lda, int *sdim, c *w, c *vs, int *ldvs, c *work, int *lwork, s *rwork, bint *bwork, int *info) noexcept nogil: + + _fortran_cgees(jobvs, sort, <_cselect1*>select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeesx "BLAS_FUNC(cgeesx)"(char *jobvs, char *sort, _cselect1 *select, char *sense, int *n, npy_complex64 *a, int *lda, int *sdim, npy_complex64 *w, npy_complex64 *vs, int *ldvs, s *rconde, s *rcondv, npy_complex64 *work, int *lwork, s *rwork, bint *bwork, int *info) nogil +cdef void cgeesx(char *jobvs, char *sort, cselect1 *select, char *sense, int *n, c *a, int *lda, int *sdim, c *w, c *vs, int *ldvs, s *rconde, s *rcondv, c *work, int *lwork, s *rwork, bint *bwork, int *info) noexcept nogil: + + _fortran_cgeesx(jobvs, sort, <_cselect1*>select, sense, n, a, lda, sdim, w, vs, ldvs, rconde, rcondv, work, lwork, rwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeev "BLAS_FUNC(cgeev)"(char *jobvl, char *jobvr, int *n, npy_complex64 *a, int *lda, npy_complex64 *w, npy_complex64 *vl, int *ldvl, npy_complex64 *vr, int *ldvr, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void cgeev(char *jobvl, char *jobvr, int *n, c *a, int *lda, c *w, c *vl, int *ldvl, c *vr, int *ldvr, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_cgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeevx "BLAS_FUNC(cgeevx)"(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, npy_complex64 *a, int *lda, npy_complex64 *w, npy_complex64 *vl, int *ldvl, npy_complex64 *vr, int *ldvr, int *ilo, int *ihi, s *scale, s *abnrm, s *rconde, s *rcondv, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void cgeevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, c *a, int *lda, c *w, c *vl, int *ldvl, c *vr, int *ldvr, int *ilo, int *ihi, s *scale, s *abnrm, s *rconde, s *rcondv, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_cgeevx(balanc, jobvl, jobvr, sense, n, a, lda, w, vl, ldvl, vr, ldvr, ilo, ihi, scale, abnrm, rconde, rcondv, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgehd2 "BLAS_FUNC(cgehd2)"(int *n, int *ilo, int *ihi, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *info) nogil +cdef void cgehd2(int *n, int *ilo, int *ihi, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil: + + _fortran_cgehd2(n, ilo, ihi, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgehrd "BLAS_FUNC(cgehrd)"(int *n, int *ilo, int *ihi, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cgehrd(int *n, int *ilo, int *ihi, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgelq2 "BLAS_FUNC(cgelq2)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *info) nogil +cdef void cgelq2(int *m, int *n, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil: + + _fortran_cgelq2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgelqf "BLAS_FUNC(cgelqf)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cgelqf(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cgelqf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgels "BLAS_FUNC(cgels)"(char *trans, int *m, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cgels(char *trans, int *m, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgelsd "BLAS_FUNC(cgelsd)"(int *m, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, s *s, s *rcond, int *rank, npy_complex64 *work, int *lwork, s *rwork, int *iwork, int *info) nogil +cdef void cgelsd(int *m, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, s *s, s *rcond, int *rank, c *work, int *lwork, s *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_cgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgelss "BLAS_FUNC(cgelss)"(int *m, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, s *s, s *rcond, int *rank, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void cgelss(int *m, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, s *s, s *rcond, int *rank, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_cgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgelsy "BLAS_FUNC(cgelsy)"(int *m, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, int *jpvt, s *rcond, int *rank, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void cgelsy(int *m, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, int *jpvt, s *rcond, int *rank, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_cgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgemqrt "BLAS_FUNC(cgemqrt)"(char *side, char *trans, int *m, int *n, int *k, int *nb, npy_complex64 *v, int *ldv, npy_complex64 *t, int *ldt, npy_complex64 *c, int *ldc, npy_complex64 *work, int *info) nogil +cdef void cgemqrt(char *side, char *trans, int *m, int *n, int *k, int *nb, c *v, int *ldv, c *t, int *ldt, c *c, int *ldc, c *work, int *info) noexcept nogil: + + _fortran_cgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeql2 "BLAS_FUNC(cgeql2)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *info) nogil +cdef void cgeql2(int *m, int *n, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil: + + _fortran_cgeql2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeqlf "BLAS_FUNC(cgeqlf)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cgeqlf(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cgeqlf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeqp3 "BLAS_FUNC(cgeqp3)"(int *m, int *n, npy_complex64 *a, int *lda, int *jpvt, npy_complex64 *tau, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void cgeqp3(int *m, int *n, c *a, int *lda, int *jpvt, c *tau, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_cgeqp3(m, n, a, lda, jpvt, tau, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeqr2 "BLAS_FUNC(cgeqr2)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *info) nogil +cdef void cgeqr2(int *m, int *n, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil: + + _fortran_cgeqr2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeqr2p "BLAS_FUNC(cgeqr2p)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *info) nogil +cdef void cgeqr2p(int *m, int *n, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil: + + _fortran_cgeqr2p(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeqrf "BLAS_FUNC(cgeqrf)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cgeqrf(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cgeqrf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeqrfp "BLAS_FUNC(cgeqrfp)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cgeqrfp(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cgeqrfp(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeqrt "BLAS_FUNC(cgeqrt)"(int *m, int *n, int *nb, npy_complex64 *a, int *lda, npy_complex64 *t, int *ldt, npy_complex64 *work, int *info) nogil +cdef void cgeqrt(int *m, int *n, int *nb, c *a, int *lda, c *t, int *ldt, c *work, int *info) noexcept nogil: + + _fortran_cgeqrt(m, n, nb, a, lda, t, ldt, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeqrt2 "BLAS_FUNC(cgeqrt2)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *t, int *ldt, int *info) nogil +cdef void cgeqrt2(int *m, int *n, c *a, int *lda, c *t, int *ldt, int *info) noexcept nogil: + + _fortran_cgeqrt2(m, n, a, lda, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgeqrt3 "BLAS_FUNC(cgeqrt3)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *t, int *ldt, int *info) nogil +cdef void cgeqrt3(int *m, int *n, c *a, int *lda, c *t, int *ldt, int *info) noexcept nogil: + + _fortran_cgeqrt3(m, n, a, lda, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgerfs "BLAS_FUNC(cgerfs)"(char *trans, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *af, int *ldaf, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cgerfs(char *trans, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgerq2 "BLAS_FUNC(cgerq2)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *info) nogil +cdef void cgerq2(int *m, int *n, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil: + + _fortran_cgerq2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgerqf "BLAS_FUNC(cgerqf)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cgerqf(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cgerqf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgesc2 "BLAS_FUNC(cgesc2)"(int *n, npy_complex64 *a, int *lda, npy_complex64 *rhs, int *ipiv, int *jpiv, s *scale) nogil +cdef void cgesc2(int *n, c *a, int *lda, c *rhs, int *ipiv, int *jpiv, s *scale) noexcept nogil: + + _fortran_cgesc2(n, a, lda, rhs, ipiv, jpiv, scale) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgesdd "BLAS_FUNC(cgesdd)"(char *jobz, int *m, int *n, npy_complex64 *a, int *lda, s *s, npy_complex64 *u, int *ldu, npy_complex64 *vt, int *ldvt, npy_complex64 *work, int *lwork, s *rwork, int *iwork, int *info) nogil +cdef void cgesdd(char *jobz, int *m, int *n, c *a, int *lda, s *s, c *u, int *ldu, c *vt, int *ldvt, c *work, int *lwork, s *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_cgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgesv "BLAS_FUNC(cgesv)"(int *n, int *nrhs, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cgesv(int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cgesv(n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgesvd "BLAS_FUNC(cgesvd)"(char *jobu, char *jobvt, int *m, int *n, npy_complex64 *a, int *lda, s *s, npy_complex64 *u, int *ldu, npy_complex64 *vt, int *ldvt, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void cgesvd(char *jobu, char *jobvt, int *m, int *n, c *a, int *lda, s *s, c *u, int *ldu, c *vt, int *ldvt, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_cgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgesvx "BLAS_FUNC(cgesvx)"(char *fact, char *trans, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *af, int *ldaf, int *ipiv, char *equed, s *r, s *c, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *rcond, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cgesvx(char *fact, char *trans, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, char *equed, s *r, s *c, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cgesvx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgetc2 "BLAS_FUNC(cgetc2)"(int *n, npy_complex64 *a, int *lda, int *ipiv, int *jpiv, int *info) nogil +cdef void cgetc2(int *n, c *a, int *lda, int *ipiv, int *jpiv, int *info) noexcept nogil: + + _fortran_cgetc2(n, a, lda, ipiv, jpiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgetf2 "BLAS_FUNC(cgetf2)"(int *m, int *n, npy_complex64 *a, int *lda, int *ipiv, int *info) nogil +cdef void cgetf2(int *m, int *n, c *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_cgetf2(m, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgetrf "BLAS_FUNC(cgetrf)"(int *m, int *n, npy_complex64 *a, int *lda, int *ipiv, int *info) nogil +cdef void cgetrf(int *m, int *n, c *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_cgetrf(m, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgetri "BLAS_FUNC(cgetri)"(int *n, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cgetri(int *n, c *a, int *lda, int *ipiv, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cgetri(n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgetrs "BLAS_FUNC(cgetrs)"(char *trans, int *n, int *nrhs, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cgetrs(char *trans, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cggbak "BLAS_FUNC(cggbak)"(char *job, char *side, int *n, int *ilo, int *ihi, s *lscale, s *rscale, int *m, npy_complex64 *v, int *ldv, int *info) nogil +cdef void cggbak(char *job, char *side, int *n, int *ilo, int *ihi, s *lscale, s *rscale, int *m, c *v, int *ldv, int *info) noexcept nogil: + + _fortran_cggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cggbal "BLAS_FUNC(cggbal)"(char *job, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, int *ilo, int *ihi, s *lscale, s *rscale, s *work, int *info) nogil +cdef void cggbal(char *job, int *n, c *a, int *lda, c *b, int *ldb, int *ilo, int *ihi, s *lscale, s *rscale, s *work, int *info) noexcept nogil: + + _fortran_cggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgges "BLAS_FUNC(cgges)"(char *jobvsl, char *jobvsr, char *sort, _cselect2 *selctg, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, int *sdim, npy_complex64 *alpha, npy_complex64 *beta, npy_complex64 *vsl, int *ldvsl, npy_complex64 *vsr, int *ldvsr, npy_complex64 *work, int *lwork, s *rwork, bint *bwork, int *info) nogil +cdef void cgges(char *jobvsl, char *jobvsr, char *sort, cselect2 *selctg, int *n, c *a, int *lda, c *b, int *ldb, int *sdim, c *alpha, c *beta, c *vsl, int *ldvsl, c *vsr, int *ldvsr, c *work, int *lwork, s *rwork, bint *bwork, int *info) noexcept nogil: + + _fortran_cgges(jobvsl, jobvsr, sort, <_cselect2*>selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cggesx "BLAS_FUNC(cggesx)"(char *jobvsl, char *jobvsr, char *sort, _cselect2 *selctg, char *sense, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, int *sdim, npy_complex64 *alpha, npy_complex64 *beta, npy_complex64 *vsl, int *ldvsl, npy_complex64 *vsr, int *ldvsr, s *rconde, s *rcondv, npy_complex64 *work, int *lwork, s *rwork, int *iwork, int *liwork, bint *bwork, int *info) nogil +cdef void cggesx(char *jobvsl, char *jobvsr, char *sort, cselect2 *selctg, char *sense, int *n, c *a, int *lda, c *b, int *ldb, int *sdim, c *alpha, c *beta, c *vsl, int *ldvsl, c *vsr, int *ldvsr, s *rconde, s *rcondv, c *work, int *lwork, s *rwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil: + + _fortran_cggesx(jobvsl, jobvsr, sort, <_cselect2*>selctg, sense, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, rwork, iwork, liwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cggev "BLAS_FUNC(cggev)"(char *jobvl, char *jobvr, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *alpha, npy_complex64 *beta, npy_complex64 *vl, int *ldvl, npy_complex64 *vr, int *ldvr, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void cggev(char *jobvl, char *jobvr, int *n, c *a, int *lda, c *b, int *ldb, c *alpha, c *beta, c *vl, int *ldvl, c *vr, int *ldvr, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_cggev(jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cggevx "BLAS_FUNC(cggevx)"(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *alpha, npy_complex64 *beta, npy_complex64 *vl, int *ldvl, npy_complex64 *vr, int *ldvr, int *ilo, int *ihi, s *lscale, s *rscale, s *abnrm, s *bbnrm, s *rconde, s *rcondv, npy_complex64 *work, int *lwork, s *rwork, int *iwork, bint *bwork, int *info) nogil +cdef void cggevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, c *a, int *lda, c *b, int *ldb, c *alpha, c *beta, c *vl, int *ldvl, c *vr, int *ldvr, int *ilo, int *ihi, s *lscale, s *rscale, s *abnrm, s *bbnrm, s *rconde, s *rcondv, c *work, int *lwork, s *rwork, int *iwork, bint *bwork, int *info) noexcept nogil: + + _fortran_cggevx(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, rwork, iwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cggglm "BLAS_FUNC(cggglm)"(int *n, int *m, int *p, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *d, npy_complex64 *x, npy_complex64 *y, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cggglm(int *n, int *m, int *p, c *a, int *lda, c *b, int *ldb, c *d, c *x, c *y, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgghrd "BLAS_FUNC(cgghrd)"(char *compq, char *compz, int *n, int *ilo, int *ihi, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *q, int *ldq, npy_complex64 *z, int *ldz, int *info) nogil +cdef void cgghrd(char *compq, char *compz, int *n, int *ilo, int *ihi, c *a, int *lda, c *b, int *ldb, c *q, int *ldq, c *z, int *ldz, int *info) noexcept nogil: + + _fortran_cgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgglse "BLAS_FUNC(cgglse)"(int *m, int *n, int *p, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *c, npy_complex64 *d, npy_complex64 *x, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cgglse(int *m, int *n, int *p, c *a, int *lda, c *b, int *ldb, c *c, c *d, c *x, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cggqrf "BLAS_FUNC(cggqrf)"(int *n, int *m, int *p, npy_complex64 *a, int *lda, npy_complex64 *taua, npy_complex64 *b, int *ldb, npy_complex64 *taub, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cggqrf(int *n, int *m, int *p, c *a, int *lda, c *taua, c *b, int *ldb, c *taub, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cggrqf "BLAS_FUNC(cggrqf)"(int *m, int *p, int *n, npy_complex64 *a, int *lda, npy_complex64 *taua, npy_complex64 *b, int *ldb, npy_complex64 *taub, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cggrqf(int *m, int *p, int *n, c *a, int *lda, c *taua, c *b, int *ldb, c *taub, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgtcon "BLAS_FUNC(cgtcon)"(char *norm, int *n, npy_complex64 *dl, npy_complex64 *d, npy_complex64 *du, npy_complex64 *du2, int *ipiv, s *anorm, s *rcond, npy_complex64 *work, int *info) nogil +cdef void cgtcon(char *norm, int *n, c *dl, c *d, c *du, c *du2, int *ipiv, s *anorm, s *rcond, c *work, int *info) noexcept nogil: + + _fortran_cgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgtrfs "BLAS_FUNC(cgtrfs)"(char *trans, int *n, int *nrhs, npy_complex64 *dl, npy_complex64 *d, npy_complex64 *du, npy_complex64 *dlf, npy_complex64 *df, npy_complex64 *duf, npy_complex64 *du2, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cgtrfs(char *trans, int *n, int *nrhs, c *dl, c *d, c *du, c *dlf, c *df, c *duf, c *du2, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgtsv "BLAS_FUNC(cgtsv)"(int *n, int *nrhs, npy_complex64 *dl, npy_complex64 *d, npy_complex64 *du, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cgtsv(int *n, int *nrhs, c *dl, c *d, c *du, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cgtsv(n, nrhs, dl, d, du, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgtsvx "BLAS_FUNC(cgtsvx)"(char *fact, char *trans, int *n, int *nrhs, npy_complex64 *dl, npy_complex64 *d, npy_complex64 *du, npy_complex64 *dlf, npy_complex64 *df, npy_complex64 *duf, npy_complex64 *du2, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *rcond, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cgtsvx(char *fact, char *trans, int *n, int *nrhs, c *dl, c *d, c *du, c *dlf, c *df, c *duf, c *du2, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cgtsvx(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgttrf "BLAS_FUNC(cgttrf)"(int *n, npy_complex64 *dl, npy_complex64 *d, npy_complex64 *du, npy_complex64 *du2, int *ipiv, int *info) nogil +cdef void cgttrf(int *n, c *dl, c *d, c *du, c *du2, int *ipiv, int *info) noexcept nogil: + + _fortran_cgttrf(n, dl, d, du, du2, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgttrs "BLAS_FUNC(cgttrs)"(char *trans, int *n, int *nrhs, npy_complex64 *dl, npy_complex64 *d, npy_complex64 *du, npy_complex64 *du2, int *ipiv, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cgttrs(char *trans, int *n, int *nrhs, c *dl, c *d, c *du, c *du2, int *ipiv, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cgtts2 "BLAS_FUNC(cgtts2)"(int *itrans, int *n, int *nrhs, npy_complex64 *dl, npy_complex64 *d, npy_complex64 *du, npy_complex64 *du2, int *ipiv, npy_complex64 *b, int *ldb) nogil +cdef void cgtts2(int *itrans, int *n, int *nrhs, c *dl, c *d, c *du, c *du2, int *ipiv, c *b, int *ldb) noexcept nogil: + + _fortran_cgtts2(itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chbev "BLAS_FUNC(chbev)"(char *jobz, char *uplo, int *n, int *kd, npy_complex64 *ab, int *ldab, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, s *rwork, int *info) nogil +cdef void chbev(char *jobz, char *uplo, int *n, int *kd, c *ab, int *ldab, s *w, c *z, int *ldz, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_chbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chbevd "BLAS_FUNC(chbevd)"(char *jobz, char *uplo, int *n, int *kd, npy_complex64 *ab, int *ldab, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void chbevd(char *jobz, char *uplo, int *n, int *kd, c *ab, int *ldab, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_chbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chbevx "BLAS_FUNC(chbevx)"(char *jobz, char *range, char *uplo, int *n, int *kd, npy_complex64 *ab, int *ldab, npy_complex64 *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, s *rwork, int *iwork, int *ifail, int *info) nogil +cdef void chbevx(char *jobz, char *range, char *uplo, int *n, int *kd, c *ab, int *ldab, c *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_chbevx(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chbgst "BLAS_FUNC(chbgst)"(char *vect, char *uplo, int *n, int *ka, int *kb, npy_complex64 *ab, int *ldab, npy_complex64 *bb, int *ldbb, npy_complex64 *x, int *ldx, npy_complex64 *work, s *rwork, int *info) nogil +cdef void chbgst(char *vect, char *uplo, int *n, int *ka, int *kb, c *ab, int *ldab, c *bb, int *ldbb, c *x, int *ldx, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_chbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chbgv "BLAS_FUNC(chbgv)"(char *jobz, char *uplo, int *n, int *ka, int *kb, npy_complex64 *ab, int *ldab, npy_complex64 *bb, int *ldbb, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, s *rwork, int *info) nogil +cdef void chbgv(char *jobz, char *uplo, int *n, int *ka, int *kb, c *ab, int *ldab, c *bb, int *ldbb, s *w, c *z, int *ldz, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_chbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chbgvd "BLAS_FUNC(chbgvd)"(char *jobz, char *uplo, int *n, int *ka, int *kb, npy_complex64 *ab, int *ldab, npy_complex64 *bb, int *ldbb, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void chbgvd(char *jobz, char *uplo, int *n, int *ka, int *kb, c *ab, int *ldab, c *bb, int *ldbb, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_chbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chbgvx "BLAS_FUNC(chbgvx)"(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, npy_complex64 *ab, int *ldab, npy_complex64 *bb, int *ldbb, npy_complex64 *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, s *rwork, int *iwork, int *ifail, int *info) nogil +cdef void chbgvx(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, c *ab, int *ldab, c *bb, int *ldbb, c *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_chbgvx(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chbtrd "BLAS_FUNC(chbtrd)"(char *vect, char *uplo, int *n, int *kd, npy_complex64 *ab, int *ldab, s *d, s *e, npy_complex64 *q, int *ldq, npy_complex64 *work, int *info) nogil +cdef void chbtrd(char *vect, char *uplo, int *n, int *kd, c *ab, int *ldab, s *d, s *e, c *q, int *ldq, c *work, int *info) noexcept nogil: + + _fortran_chbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_checon "BLAS_FUNC(checon)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, s *anorm, s *rcond, npy_complex64 *work, int *info) nogil +cdef void checon(char *uplo, int *n, c *a, int *lda, int *ipiv, s *anorm, s *rcond, c *work, int *info) noexcept nogil: + + _fortran_checon(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cheequb "BLAS_FUNC(cheequb)"(char *uplo, int *n, npy_complex64 *a, int *lda, s *s, s *scond, s *amax, npy_complex64 *work, int *info) nogil +cdef void cheequb(char *uplo, int *n, c *a, int *lda, s *s, s *scond, s *amax, c *work, int *info) noexcept nogil: + + _fortran_cheequb(uplo, n, a, lda, s, scond, amax, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cheev "BLAS_FUNC(cheev)"(char *jobz, char *uplo, int *n, npy_complex64 *a, int *lda, s *w, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void cheev(char *jobz, char *uplo, int *n, c *a, int *lda, s *w, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_cheev(jobz, uplo, n, a, lda, w, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cheevd "BLAS_FUNC(cheevd)"(char *jobz, char *uplo, int *n, npy_complex64 *a, int *lda, s *w, npy_complex64 *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void cheevd(char *jobz, char *uplo, int *n, c *a, int *lda, s *w, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_cheevd(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cheevr "BLAS_FUNC(cheevr)"(char *jobz, char *range, char *uplo, int *n, npy_complex64 *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, npy_complex64 *z, int *ldz, int *isuppz, npy_complex64 *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void cheevr(char *jobz, char *range, char *uplo, int *n, c *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, int *isuppz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_cheevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cheevx "BLAS_FUNC(cheevx)"(char *jobz, char *range, char *uplo, int *n, npy_complex64 *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, int *lwork, s *rwork, int *iwork, int *ifail, int *info) nogil +cdef void cheevx(char *jobz, char *range, char *uplo, int *n, c *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_cheevx(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chegs2 "BLAS_FUNC(chegs2)"(int *itype, char *uplo, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, int *info) nogil +cdef void chegs2(int *itype, char *uplo, int *n, c *a, int *lda, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_chegs2(itype, uplo, n, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chegst "BLAS_FUNC(chegst)"(int *itype, char *uplo, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, int *info) nogil +cdef void chegst(int *itype, char *uplo, int *n, c *a, int *lda, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_chegst(itype, uplo, n, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chegv "BLAS_FUNC(chegv)"(int *itype, char *jobz, char *uplo, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, s *w, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void chegv(int *itype, char *jobz, char *uplo, int *n, c *a, int *lda, c *b, int *ldb, s *w, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_chegv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chegvd "BLAS_FUNC(chegvd)"(int *itype, char *jobz, char *uplo, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, s *w, npy_complex64 *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void chegvd(int *itype, char *jobz, char *uplo, int *n, c *a, int *lda, c *b, int *ldb, s *w, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_chegvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chegvx "BLAS_FUNC(chegvx)"(int *itype, char *jobz, char *range, char *uplo, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, int *lwork, s *rwork, int *iwork, int *ifail, int *info) nogil +cdef void chegvx(int *itype, char *jobz, char *range, char *uplo, int *n, c *a, int *lda, c *b, int *ldb, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_chegvx(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cherfs "BLAS_FUNC(cherfs)"(char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *af, int *ldaf, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cherfs(char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cherfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chesv "BLAS_FUNC(chesv)"(char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *work, int *lwork, int *info) nogil +cdef void chesv(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_chesv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chesvx "BLAS_FUNC(chesvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *af, int *ldaf, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *rcond, s *ferr, s *berr, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void chesvx(char *fact, char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_chesvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cheswapr "BLAS_FUNC(cheswapr)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *i1, int *i2) nogil +cdef void cheswapr(char *uplo, int *n, c *a, int *lda, int *i1, int *i2) noexcept nogil: + + _fortran_cheswapr(uplo, n, a, lda, i1, i2) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chetd2 "BLAS_FUNC(chetd2)"(char *uplo, int *n, npy_complex64 *a, int *lda, s *d, s *e, npy_complex64 *tau, int *info) nogil +cdef void chetd2(char *uplo, int *n, c *a, int *lda, s *d, s *e, c *tau, int *info) noexcept nogil: + + _fortran_chetd2(uplo, n, a, lda, d, e, tau, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chetf2 "BLAS_FUNC(chetf2)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, int *info) nogil +cdef void chetf2(char *uplo, int *n, c *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_chetf2(uplo, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chetrd "BLAS_FUNC(chetrd)"(char *uplo, int *n, npy_complex64 *a, int *lda, s *d, s *e, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void chetrd(char *uplo, int *n, c *a, int *lda, s *d, s *e, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_chetrd(uplo, n, a, lda, d, e, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chetrf "BLAS_FUNC(chetrf)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *work, int *lwork, int *info) nogil +cdef void chetrf(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_chetrf(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chetri "BLAS_FUNC(chetri)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *work, int *info) nogil +cdef void chetri(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *info) noexcept nogil: + + _fortran_chetri(uplo, n, a, lda, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chetri2 "BLAS_FUNC(chetri2)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *work, int *lwork, int *info) nogil +cdef void chetri2(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_chetri2(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chetri2x "BLAS_FUNC(chetri2x)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *work, int *nb, int *info) nogil +cdef void chetri2x(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *nb, int *info) noexcept nogil: + + _fortran_chetri2x(uplo, n, a, lda, ipiv, work, nb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chetrs "BLAS_FUNC(chetrs)"(char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *b, int *ldb, int *info) nogil +cdef void chetrs(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_chetrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chetrs2 "BLAS_FUNC(chetrs2)"(char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *work, int *info) nogil +cdef void chetrs2(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, c *work, int *info) noexcept nogil: + + _fortran_chetrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chfrk "BLAS_FUNC(chfrk)"(char *transr, char *uplo, char *trans, int *n, int *k, s *alpha, npy_complex64 *a, int *lda, s *beta, npy_complex64 *c) nogil +cdef void chfrk(char *transr, char *uplo, char *trans, int *n, int *k, s *alpha, c *a, int *lda, s *beta, c *c) noexcept nogil: + + _fortran_chfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chgeqz "BLAS_FUNC(chgeqz)"(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, npy_complex64 *h, int *ldh, npy_complex64 *t, int *ldt, npy_complex64 *alpha, npy_complex64 *beta, npy_complex64 *q, int *ldq, npy_complex64 *z, int *ldz, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void chgeqz(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, c *h, int *ldh, c *t, int *ldt, c *alpha, c *beta, c *q, int *ldq, c *z, int *ldz, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_chgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + char _fortran_chla_transtype "BLAS_FUNC(chla_transtype)"(int *trans) nogil +cdef char chla_transtype(int *trans) noexcept nogil: + + return _fortran_chla_transtype(trans) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chpcon "BLAS_FUNC(chpcon)"(char *uplo, int *n, npy_complex64 *ap, int *ipiv, s *anorm, s *rcond, npy_complex64 *work, int *info) nogil +cdef void chpcon(char *uplo, int *n, c *ap, int *ipiv, s *anorm, s *rcond, c *work, int *info) noexcept nogil: + + _fortran_chpcon(uplo, n, ap, ipiv, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chpev "BLAS_FUNC(chpev)"(char *jobz, char *uplo, int *n, npy_complex64 *ap, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, s *rwork, int *info) nogil +cdef void chpev(char *jobz, char *uplo, int *n, c *ap, s *w, c *z, int *ldz, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_chpev(jobz, uplo, n, ap, w, z, ldz, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chpevd "BLAS_FUNC(chpevd)"(char *jobz, char *uplo, int *n, npy_complex64 *ap, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void chpevd(char *jobz, char *uplo, int *n, c *ap, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_chpevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chpevx "BLAS_FUNC(chpevx)"(char *jobz, char *range, char *uplo, int *n, npy_complex64 *ap, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, s *rwork, int *iwork, int *ifail, int *info) nogil +cdef void chpevx(char *jobz, char *range, char *uplo, int *n, c *ap, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_chpevx(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chpgst "BLAS_FUNC(chpgst)"(int *itype, char *uplo, int *n, npy_complex64 *ap, npy_complex64 *bp, int *info) nogil +cdef void chpgst(int *itype, char *uplo, int *n, c *ap, c *bp, int *info) noexcept nogil: + + _fortran_chpgst(itype, uplo, n, ap, bp, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chpgv "BLAS_FUNC(chpgv)"(int *itype, char *jobz, char *uplo, int *n, npy_complex64 *ap, npy_complex64 *bp, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, s *rwork, int *info) nogil +cdef void chpgv(int *itype, char *jobz, char *uplo, int *n, c *ap, c *bp, s *w, c *z, int *ldz, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_chpgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chpgvd "BLAS_FUNC(chpgvd)"(int *itype, char *jobz, char *uplo, int *n, npy_complex64 *ap, npy_complex64 *bp, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void chpgvd(int *itype, char *jobz, char *uplo, int *n, c *ap, c *bp, s *w, c *z, int *ldz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_chpgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chpgvx "BLAS_FUNC(chpgvx)"(int *itype, char *jobz, char *range, char *uplo, int *n, npy_complex64 *ap, npy_complex64 *bp, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, npy_complex64 *z, int *ldz, npy_complex64 *work, s *rwork, int *iwork, int *ifail, int *info) nogil +cdef void chpgvx(int *itype, char *jobz, char *range, char *uplo, int *n, c *ap, c *bp, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, c *work, s *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_chpgvx(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chprfs "BLAS_FUNC(chprfs)"(char *uplo, int *n, int *nrhs, npy_complex64 *ap, npy_complex64 *afp, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void chprfs(char *uplo, int *n, int *nrhs, c *ap, c *afp, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_chprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chpsv "BLAS_FUNC(chpsv)"(char *uplo, int *n, int *nrhs, npy_complex64 *ap, int *ipiv, npy_complex64 *b, int *ldb, int *info) nogil +cdef void chpsv(char *uplo, int *n, int *nrhs, c *ap, int *ipiv, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_chpsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chpsvx "BLAS_FUNC(chpsvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex64 *ap, npy_complex64 *afp, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *rcond, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void chpsvx(char *fact, char *uplo, int *n, int *nrhs, c *ap, c *afp, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_chpsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chptrd "BLAS_FUNC(chptrd)"(char *uplo, int *n, npy_complex64 *ap, s *d, s *e, npy_complex64 *tau, int *info) nogil +cdef void chptrd(char *uplo, int *n, c *ap, s *d, s *e, c *tau, int *info) noexcept nogil: + + _fortran_chptrd(uplo, n, ap, d, e, tau, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chptrf "BLAS_FUNC(chptrf)"(char *uplo, int *n, npy_complex64 *ap, int *ipiv, int *info) nogil +cdef void chptrf(char *uplo, int *n, c *ap, int *ipiv, int *info) noexcept nogil: + + _fortran_chptrf(uplo, n, ap, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chptri "BLAS_FUNC(chptri)"(char *uplo, int *n, npy_complex64 *ap, int *ipiv, npy_complex64 *work, int *info) nogil +cdef void chptri(char *uplo, int *n, c *ap, int *ipiv, c *work, int *info) noexcept nogil: + + _fortran_chptri(uplo, n, ap, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chptrs "BLAS_FUNC(chptrs)"(char *uplo, int *n, int *nrhs, npy_complex64 *ap, int *ipiv, npy_complex64 *b, int *ldb, int *info) nogil +cdef void chptrs(char *uplo, int *n, int *nrhs, c *ap, int *ipiv, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_chptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chsein "BLAS_FUNC(chsein)"(char *side, char *eigsrc, char *initv, bint *select, int *n, npy_complex64 *h, int *ldh, npy_complex64 *w, npy_complex64 *vl, int *ldvl, npy_complex64 *vr, int *ldvr, int *mm, int *m, npy_complex64 *work, s *rwork, int *ifaill, int *ifailr, int *info) nogil +cdef void chsein(char *side, char *eigsrc, char *initv, bint *select, int *n, c *h, int *ldh, c *w, c *vl, int *ldvl, c *vr, int *ldvr, int *mm, int *m, c *work, s *rwork, int *ifaill, int *ifailr, int *info) noexcept nogil: + + _fortran_chsein(side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_chseqr "BLAS_FUNC(chseqr)"(char *job, char *compz, int *n, int *ilo, int *ihi, npy_complex64 *h, int *ldh, npy_complex64 *w, npy_complex64 *z, int *ldz, npy_complex64 *work, int *lwork, int *info) nogil +cdef void chseqr(char *job, char *compz, int *n, int *ilo, int *ihi, c *h, int *ldh, c *w, c *z, int *ldz, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_chseqr(job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clabrd "BLAS_FUNC(clabrd)"(int *m, int *n, int *nb, npy_complex64 *a, int *lda, s *d, s *e, npy_complex64 *tauq, npy_complex64 *taup, npy_complex64 *x, int *ldx, npy_complex64 *y, int *ldy) nogil +cdef void clabrd(int *m, int *n, int *nb, c *a, int *lda, s *d, s *e, c *tauq, c *taup, c *x, int *ldx, c *y, int *ldy) noexcept nogil: + + _fortran_clabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clacgv "BLAS_FUNC(clacgv)"(int *n, npy_complex64 *x, int *incx) nogil +cdef void clacgv(int *n, c *x, int *incx) noexcept nogil: + + _fortran_clacgv(n, x, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clacn2 "BLAS_FUNC(clacn2)"(int *n, npy_complex64 *v, npy_complex64 *x, s *est, int *kase, int *isave) nogil +cdef void clacn2(int *n, c *v, c *x, s *est, int *kase, int *isave) noexcept nogil: + + _fortran_clacn2(n, v, x, est, kase, isave) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clacon "BLAS_FUNC(clacon)"(int *n, npy_complex64 *v, npy_complex64 *x, s *est, int *kase) nogil +cdef void clacon(int *n, c *v, c *x, s *est, int *kase) noexcept nogil: + + _fortran_clacon(n, v, x, est, kase) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clacp2 "BLAS_FUNC(clacp2)"(char *uplo, int *m, int *n, s *a, int *lda, npy_complex64 *b, int *ldb) nogil +cdef void clacp2(char *uplo, int *m, int *n, s *a, int *lda, c *b, int *ldb) noexcept nogil: + + _fortran_clacp2(uplo, m, n, a, lda, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clacpy "BLAS_FUNC(clacpy)"(char *uplo, int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb) nogil +cdef void clacpy(char *uplo, int *m, int *n, c *a, int *lda, c *b, int *ldb) noexcept nogil: + + _fortran_clacpy(uplo, m, n, a, lda, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clacrm "BLAS_FUNC(clacrm)"(int *m, int *n, npy_complex64 *a, int *lda, s *b, int *ldb, npy_complex64 *c, int *ldc, s *rwork) nogil +cdef void clacrm(int *m, int *n, c *a, int *lda, s *b, int *ldb, c *c, int *ldc, s *rwork) noexcept nogil: + + _fortran_clacrm(m, n, a, lda, b, ldb, c, ldc, rwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clacrt "BLAS_FUNC(clacrt)"(int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy, npy_complex64 *c, npy_complex64 *s) nogil +cdef void clacrt(int *n, c *cx, int *incx, c *cy, int *incy, c *c, c *s) noexcept nogil: + + _fortran_clacrt(n, cx, incx, cy, incy, c, s) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cladiv "(cladivwrp_)"(npy_complex64 *out, npy_complex64 *x, npy_complex64 *y) nogil +cdef c cladiv(c *x, c *y) noexcept nogil: + cdef c out + _fortran_cladiv(&out, x, y) + return out + +cdef extern from "_lapack_subroutines.h": + void _fortran_claed0 "BLAS_FUNC(claed0)"(int *qsiz, int *n, s *d, s *e, npy_complex64 *q, int *ldq, npy_complex64 *qstore, int *ldqs, s *rwork, int *iwork, int *info) nogil +cdef void claed0(int *qsiz, int *n, s *d, s *e, c *q, int *ldq, c *qstore, int *ldqs, s *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_claed0(qsiz, n, d, e, q, ldq, qstore, ldqs, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claed7 "BLAS_FUNC(claed7)"(int *n, int *cutpnt, int *qsiz, int *tlvls, int *curlvl, int *curpbm, s *d, npy_complex64 *q, int *ldq, s *rho, int *indxq, s *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, s *givnum, npy_complex64 *work, s *rwork, int *iwork, int *info) nogil +cdef void claed7(int *n, int *cutpnt, int *qsiz, int *tlvls, int *curlvl, int *curpbm, s *d, c *q, int *ldq, s *rho, int *indxq, s *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, s *givnum, c *work, s *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_claed7(n, cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, ldq, rho, indxq, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claed8 "BLAS_FUNC(claed8)"(int *k, int *n, int *qsiz, npy_complex64 *q, int *ldq, s *d, s *rho, int *cutpnt, s *z, s *dlamda, npy_complex64 *q2, int *ldq2, s *w, int *indxp, int *indx, int *indxq, int *perm, int *givptr, int *givcol, s *givnum, int *info) nogil +cdef void claed8(int *k, int *n, int *qsiz, c *q, int *ldq, s *d, s *rho, int *cutpnt, s *z, s *dlamda, c *q2, int *ldq2, s *w, int *indxp, int *indx, int *indxq, int *perm, int *givptr, int *givcol, s *givnum, int *info) noexcept nogil: + + _fortran_claed8(k, n, qsiz, q, ldq, d, rho, cutpnt, z, dlamda, q2, ldq2, w, indxp, indx, indxq, perm, givptr, givcol, givnum, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claein "BLAS_FUNC(claein)"(bint *rightv, bint *noinit, int *n, npy_complex64 *h, int *ldh, npy_complex64 *w, npy_complex64 *v, npy_complex64 *b, int *ldb, s *rwork, s *eps3, s *smlnum, int *info) nogil +cdef void claein(bint *rightv, bint *noinit, int *n, c *h, int *ldh, c *w, c *v, c *b, int *ldb, s *rwork, s *eps3, s *smlnum, int *info) noexcept nogil: + + _fortran_claein(rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claesy "BLAS_FUNC(claesy)"(npy_complex64 *a, npy_complex64 *b, npy_complex64 *c, npy_complex64 *rt1, npy_complex64 *rt2, npy_complex64 *evscal, npy_complex64 *cs1, npy_complex64 *sn1) nogil +cdef void claesy(c *a, c *b, c *c, c *rt1, c *rt2, c *evscal, c *cs1, c *sn1) noexcept nogil: + + _fortran_claesy(a, b, c, rt1, rt2, evscal, cs1, sn1) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claev2 "BLAS_FUNC(claev2)"(npy_complex64 *a, npy_complex64 *b, npy_complex64 *c, s *rt1, s *rt2, s *cs1, npy_complex64 *sn1) nogil +cdef void claev2(c *a, c *b, c *c, s *rt1, s *rt2, s *cs1, c *sn1) noexcept nogil: + + _fortran_claev2(a, b, c, rt1, rt2, cs1, sn1) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clag2z "BLAS_FUNC(clag2z)"(int *m, int *n, npy_complex64 *sa, int *ldsa, npy_complex128 *a, int *lda, int *info) nogil +cdef void clag2z(int *m, int *n, c *sa, int *ldsa, z *a, int *lda, int *info) noexcept nogil: + + _fortran_clag2z(m, n, sa, ldsa, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clags2 "BLAS_FUNC(clags2)"(bint *upper, s *a1, npy_complex64 *a2, s *a3, s *b1, npy_complex64 *b2, s *b3, s *csu, npy_complex64 *snu, s *csv, npy_complex64 *snv, s *csq, npy_complex64 *snq) nogil +cdef void clags2(bint *upper, s *a1, c *a2, s *a3, s *b1, c *b2, s *b3, s *csu, c *snu, s *csv, c *snv, s *csq, c *snq) noexcept nogil: + + _fortran_clags2(upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clagtm "BLAS_FUNC(clagtm)"(char *trans, int *n, int *nrhs, s *alpha, npy_complex64 *dl, npy_complex64 *d, npy_complex64 *du, npy_complex64 *x, int *ldx, s *beta, npy_complex64 *b, int *ldb) nogil +cdef void clagtm(char *trans, int *n, int *nrhs, s *alpha, c *dl, c *d, c *du, c *x, int *ldx, s *beta, c *b, int *ldb) noexcept nogil: + + _fortran_clagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clahef "BLAS_FUNC(clahef)"(char *uplo, int *n, int *nb, int *kb, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *w, int *ldw, int *info) nogil +cdef void clahef(char *uplo, int *n, int *nb, int *kb, c *a, int *lda, int *ipiv, c *w, int *ldw, int *info) noexcept nogil: + + _fortran_clahef(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clahqr "BLAS_FUNC(clahqr)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, npy_complex64 *h, int *ldh, npy_complex64 *w, int *iloz, int *ihiz, npy_complex64 *z, int *ldz, int *info) nogil +cdef void clahqr(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, c *h, int *ldh, c *w, int *iloz, int *ihiz, c *z, int *ldz, int *info) noexcept nogil: + + _fortran_clahqr(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clahr2 "BLAS_FUNC(clahr2)"(int *n, int *k, int *nb, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *t, int *ldt, npy_complex64 *y, int *ldy) nogil +cdef void clahr2(int *n, int *k, int *nb, c *a, int *lda, c *tau, c *t, int *ldt, c *y, int *ldy) noexcept nogil: + + _fortran_clahr2(n, k, nb, a, lda, tau, t, ldt, y, ldy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claic1 "BLAS_FUNC(claic1)"(int *job, int *j, npy_complex64 *x, s *sest, npy_complex64 *w, npy_complex64 *gamma, s *sestpr, npy_complex64 *s, npy_complex64 *c) nogil +cdef void claic1(int *job, int *j, c *x, s *sest, c *w, c *gamma, s *sestpr, c *s, c *c) noexcept nogil: + + _fortran_claic1(job, j, x, sest, w, gamma, sestpr, s, c) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clals0 "BLAS_FUNC(clals0)"(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, npy_complex64 *b, int *ldb, npy_complex64 *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *poles, s *difl, s *difr, s *z, int *k, s *c, s *s, s *rwork, int *info) nogil +cdef void clals0(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, c *b, int *ldb, c *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *poles, s *difl, s *difr, s *z, int *k, s *c, s *s, s *rwork, int *info) noexcept nogil: + + _fortran_clals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clalsa "BLAS_FUNC(clalsa)"(int *icompq, int *smlsiz, int *n, int *nrhs, npy_complex64 *b, int *ldb, npy_complex64 *bx, int *ldbx, s *u, int *ldu, s *vt, int *k, s *difl, s *difr, s *z, s *poles, int *givptr, int *givcol, int *ldgcol, int *perm, s *givnum, s *c, s *s, s *rwork, int *iwork, int *info) nogil +cdef void clalsa(int *icompq, int *smlsiz, int *n, int *nrhs, c *b, int *ldb, c *bx, int *ldbx, s *u, int *ldu, s *vt, int *k, s *difl, s *difr, s *z, s *poles, int *givptr, int *givcol, int *ldgcol, int *perm, s *givnum, s *c, s *s, s *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_clalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clalsd "BLAS_FUNC(clalsd)"(char *uplo, int *smlsiz, int *n, int *nrhs, s *d, s *e, npy_complex64 *b, int *ldb, s *rcond, int *rank, npy_complex64 *work, s *rwork, int *iwork, int *info) nogil +cdef void clalsd(char *uplo, int *smlsiz, int *n, int *nrhs, s *d, s *e, c *b, int *ldb, s *rcond, int *rank, c *work, s *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_clalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clangb "BLAS_FUNC(clangb)"(char *norm, int *n, int *kl, int *ku, npy_complex64 *ab, int *ldab, s *work) nogil +cdef s clangb(char *norm, int *n, int *kl, int *ku, c *ab, int *ldab, s *work) noexcept nogil: + + return _fortran_clangb(norm, n, kl, ku, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clange "BLAS_FUNC(clange)"(char *norm, int *m, int *n, npy_complex64 *a, int *lda, s *work) nogil +cdef s clange(char *norm, int *m, int *n, c *a, int *lda, s *work) noexcept nogil: + + return _fortran_clange(norm, m, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clangt "BLAS_FUNC(clangt)"(char *norm, int *n, npy_complex64 *dl, npy_complex64 *d, npy_complex64 *du) nogil +cdef s clangt(char *norm, int *n, c *dl, c *d, c *du) noexcept nogil: + + return _fortran_clangt(norm, n, dl, d, du) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clanhb "BLAS_FUNC(clanhb)"(char *norm, char *uplo, int *n, int *k, npy_complex64 *ab, int *ldab, s *work) nogil +cdef s clanhb(char *norm, char *uplo, int *n, int *k, c *ab, int *ldab, s *work) noexcept nogil: + + return _fortran_clanhb(norm, uplo, n, k, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clanhe "BLAS_FUNC(clanhe)"(char *norm, char *uplo, int *n, npy_complex64 *a, int *lda, s *work) nogil +cdef s clanhe(char *norm, char *uplo, int *n, c *a, int *lda, s *work) noexcept nogil: + + return _fortran_clanhe(norm, uplo, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clanhf "BLAS_FUNC(clanhf)"(char *norm, char *transr, char *uplo, int *n, npy_complex64 *a, s *work) nogil +cdef s clanhf(char *norm, char *transr, char *uplo, int *n, c *a, s *work) noexcept nogil: + + return _fortran_clanhf(norm, transr, uplo, n, a, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clanhp "BLAS_FUNC(clanhp)"(char *norm, char *uplo, int *n, npy_complex64 *ap, s *work) nogil +cdef s clanhp(char *norm, char *uplo, int *n, c *ap, s *work) noexcept nogil: + + return _fortran_clanhp(norm, uplo, n, ap, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clanhs "BLAS_FUNC(clanhs)"(char *norm, int *n, npy_complex64 *a, int *lda, s *work) nogil +cdef s clanhs(char *norm, int *n, c *a, int *lda, s *work) noexcept nogil: + + return _fortran_clanhs(norm, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clanht "BLAS_FUNC(clanht)"(char *norm, int *n, s *d, npy_complex64 *e) nogil +cdef s clanht(char *norm, int *n, s *d, c *e) noexcept nogil: + + return _fortran_clanht(norm, n, d, e) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clansb "BLAS_FUNC(clansb)"(char *norm, char *uplo, int *n, int *k, npy_complex64 *ab, int *ldab, s *work) nogil +cdef s clansb(char *norm, char *uplo, int *n, int *k, c *ab, int *ldab, s *work) noexcept nogil: + + return _fortran_clansb(norm, uplo, n, k, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clansp "BLAS_FUNC(clansp)"(char *norm, char *uplo, int *n, npy_complex64 *ap, s *work) nogil +cdef s clansp(char *norm, char *uplo, int *n, c *ap, s *work) noexcept nogil: + + return _fortran_clansp(norm, uplo, n, ap, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clansy "BLAS_FUNC(clansy)"(char *norm, char *uplo, int *n, npy_complex64 *a, int *lda, s *work) nogil +cdef s clansy(char *norm, char *uplo, int *n, c *a, int *lda, s *work) noexcept nogil: + + return _fortran_clansy(norm, uplo, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clantb "BLAS_FUNC(clantb)"(char *norm, char *uplo, char *diag, int *n, int *k, npy_complex64 *ab, int *ldab, s *work) nogil +cdef s clantb(char *norm, char *uplo, char *diag, int *n, int *k, c *ab, int *ldab, s *work) noexcept nogil: + + return _fortran_clantb(norm, uplo, diag, n, k, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clantp "BLAS_FUNC(clantp)"(char *norm, char *uplo, char *diag, int *n, npy_complex64 *ap, s *work) nogil +cdef s clantp(char *norm, char *uplo, char *diag, int *n, c *ap, s *work) noexcept nogil: + + return _fortran_clantp(norm, uplo, diag, n, ap, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_clantr "BLAS_FUNC(clantr)"(char *norm, char *uplo, char *diag, int *m, int *n, npy_complex64 *a, int *lda, s *work) nogil +cdef s clantr(char *norm, char *uplo, char *diag, int *m, int *n, c *a, int *lda, s *work) noexcept nogil: + + return _fortran_clantr(norm, uplo, diag, m, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clapll "BLAS_FUNC(clapll)"(int *n, npy_complex64 *x, int *incx, npy_complex64 *y, int *incy, s *ssmin) nogil +cdef void clapll(int *n, c *x, int *incx, c *y, int *incy, s *ssmin) noexcept nogil: + + _fortran_clapll(n, x, incx, y, incy, ssmin) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clapmr "BLAS_FUNC(clapmr)"(bint *forwrd, int *m, int *n, npy_complex64 *x, int *ldx, int *k) nogil +cdef void clapmr(bint *forwrd, int *m, int *n, c *x, int *ldx, int *k) noexcept nogil: + + _fortran_clapmr(forwrd, m, n, x, ldx, k) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clapmt "BLAS_FUNC(clapmt)"(bint *forwrd, int *m, int *n, npy_complex64 *x, int *ldx, int *k) nogil +cdef void clapmt(bint *forwrd, int *m, int *n, c *x, int *ldx, int *k) noexcept nogil: + + _fortran_clapmt(forwrd, m, n, x, ldx, k) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqgb "BLAS_FUNC(claqgb)"(int *m, int *n, int *kl, int *ku, npy_complex64 *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) nogil +cdef void claqgb(int *m, int *n, int *kl, int *ku, c *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) noexcept nogil: + + _fortran_claqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqge "BLAS_FUNC(claqge)"(int *m, int *n, npy_complex64 *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) nogil +cdef void claqge(int *m, int *n, c *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) noexcept nogil: + + _fortran_claqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqhb "BLAS_FUNC(claqhb)"(char *uplo, int *n, int *kd, npy_complex64 *ab, int *ldab, s *s, s *scond, s *amax, char *equed) nogil +cdef void claqhb(char *uplo, int *n, int *kd, c *ab, int *ldab, s *s, s *scond, s *amax, char *equed) noexcept nogil: + + _fortran_claqhb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqhe "BLAS_FUNC(claqhe)"(char *uplo, int *n, npy_complex64 *a, int *lda, s *s, s *scond, s *amax, char *equed) nogil +cdef void claqhe(char *uplo, int *n, c *a, int *lda, s *s, s *scond, s *amax, char *equed) noexcept nogil: + + _fortran_claqhe(uplo, n, a, lda, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqhp "BLAS_FUNC(claqhp)"(char *uplo, int *n, npy_complex64 *ap, s *s, s *scond, s *amax, char *equed) nogil +cdef void claqhp(char *uplo, int *n, c *ap, s *s, s *scond, s *amax, char *equed) noexcept nogil: + + _fortran_claqhp(uplo, n, ap, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqp2 "BLAS_FUNC(claqp2)"(int *m, int *n, int *offset, npy_complex64 *a, int *lda, int *jpvt, npy_complex64 *tau, s *vn1, s *vn2, npy_complex64 *work) nogil +cdef void claqp2(int *m, int *n, int *offset, c *a, int *lda, int *jpvt, c *tau, s *vn1, s *vn2, c *work) noexcept nogil: + + _fortran_claqp2(m, n, offset, a, lda, jpvt, tau, vn1, vn2, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqps "BLAS_FUNC(claqps)"(int *m, int *n, int *offset, int *nb, int *kb, npy_complex64 *a, int *lda, int *jpvt, npy_complex64 *tau, s *vn1, s *vn2, npy_complex64 *auxv, npy_complex64 *f, int *ldf) nogil +cdef void claqps(int *m, int *n, int *offset, int *nb, int *kb, c *a, int *lda, int *jpvt, c *tau, s *vn1, s *vn2, c *auxv, c *f, int *ldf) noexcept nogil: + + _fortran_claqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqr0 "BLAS_FUNC(claqr0)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, npy_complex64 *h, int *ldh, npy_complex64 *w, int *iloz, int *ihiz, npy_complex64 *z, int *ldz, npy_complex64 *work, int *lwork, int *info) nogil +cdef void claqr0(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, c *h, int *ldh, c *w, int *iloz, int *ihiz, c *z, int *ldz, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_claqr0(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqr1 "BLAS_FUNC(claqr1)"(int *n, npy_complex64 *h, int *ldh, npy_complex64 *s1, npy_complex64 *s2, npy_complex64 *v) nogil +cdef void claqr1(int *n, c *h, int *ldh, c *s1, c *s2, c *v) noexcept nogil: + + _fortran_claqr1(n, h, ldh, s1, s2, v) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqr2 "BLAS_FUNC(claqr2)"(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, npy_complex64 *h, int *ldh, int *iloz, int *ihiz, npy_complex64 *z, int *ldz, int *ns, int *nd, npy_complex64 *sh, npy_complex64 *v, int *ldv, int *nh, npy_complex64 *t, int *ldt, int *nv, npy_complex64 *wv, int *ldwv, npy_complex64 *work, int *lwork) nogil +cdef void claqr2(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, c *h, int *ldh, int *iloz, int *ihiz, c *z, int *ldz, int *ns, int *nd, c *sh, c *v, int *ldv, int *nh, c *t, int *ldt, int *nv, c *wv, int *ldwv, c *work, int *lwork) noexcept nogil: + + _fortran_claqr2(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqr3 "BLAS_FUNC(claqr3)"(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, npy_complex64 *h, int *ldh, int *iloz, int *ihiz, npy_complex64 *z, int *ldz, int *ns, int *nd, npy_complex64 *sh, npy_complex64 *v, int *ldv, int *nh, npy_complex64 *t, int *ldt, int *nv, npy_complex64 *wv, int *ldwv, npy_complex64 *work, int *lwork) nogil +cdef void claqr3(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, c *h, int *ldh, int *iloz, int *ihiz, c *z, int *ldz, int *ns, int *nd, c *sh, c *v, int *ldv, int *nh, c *t, int *ldt, int *nv, c *wv, int *ldwv, c *work, int *lwork) noexcept nogil: + + _fortran_claqr3(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqr4 "BLAS_FUNC(claqr4)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, npy_complex64 *h, int *ldh, npy_complex64 *w, int *iloz, int *ihiz, npy_complex64 *z, int *ldz, npy_complex64 *work, int *lwork, int *info) nogil +cdef void claqr4(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, c *h, int *ldh, c *w, int *iloz, int *ihiz, c *z, int *ldz, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_claqr4(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqr5 "BLAS_FUNC(claqr5)"(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, npy_complex64 *s, npy_complex64 *h, int *ldh, int *iloz, int *ihiz, npy_complex64 *z, int *ldz, npy_complex64 *v, int *ldv, npy_complex64 *u, int *ldu, int *nv, npy_complex64 *wv, int *ldwv, int *nh, npy_complex64 *wh, int *ldwh) nogil +cdef void claqr5(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, c *s, c *h, int *ldh, int *iloz, int *ihiz, c *z, int *ldz, c *v, int *ldv, c *u, int *ldu, int *nv, c *wv, int *ldwv, int *nh, c *wh, int *ldwh) noexcept nogil: + + _fortran_claqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqsb "BLAS_FUNC(claqsb)"(char *uplo, int *n, int *kd, npy_complex64 *ab, int *ldab, s *s, s *scond, s *amax, char *equed) nogil +cdef void claqsb(char *uplo, int *n, int *kd, c *ab, int *ldab, s *s, s *scond, s *amax, char *equed) noexcept nogil: + + _fortran_claqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqsp "BLAS_FUNC(claqsp)"(char *uplo, int *n, npy_complex64 *ap, s *s, s *scond, s *amax, char *equed) nogil +cdef void claqsp(char *uplo, int *n, c *ap, s *s, s *scond, s *amax, char *equed) noexcept nogil: + + _fortran_claqsp(uplo, n, ap, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claqsy "BLAS_FUNC(claqsy)"(char *uplo, int *n, npy_complex64 *a, int *lda, s *s, s *scond, s *amax, char *equed) nogil +cdef void claqsy(char *uplo, int *n, c *a, int *lda, s *s, s *scond, s *amax, char *equed) noexcept nogil: + + _fortran_claqsy(uplo, n, a, lda, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clar1v "BLAS_FUNC(clar1v)"(int *n, int *b1, int *bn, s *lambda_, s *d, s *l, s *ld, s *lld, s *pivmin, s *gaptol, npy_complex64 *z, bint *wantnc, int *negcnt, s *ztz, s *mingma, int *r, int *isuppz, s *nrminv, s *resid, s *rqcorr, s *work) nogil +cdef void clar1v(int *n, int *b1, int *bn, s *lambda_, s *d, s *l, s *ld, s *lld, s *pivmin, s *gaptol, c *z, bint *wantnc, int *negcnt, s *ztz, s *mingma, int *r, int *isuppz, s *nrminv, s *resid, s *rqcorr, s *work) noexcept nogil: + + _fortran_clar1v(n, b1, bn, lambda_, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clar2v "BLAS_FUNC(clar2v)"(int *n, npy_complex64 *x, npy_complex64 *y, npy_complex64 *z, int *incx, s *c, npy_complex64 *s, int *incc) nogil +cdef void clar2v(int *n, c *x, c *y, c *z, int *incx, s *c, c *s, int *incc) noexcept nogil: + + _fortran_clar2v(n, x, y, z, incx, c, s, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarcm "BLAS_FUNC(clarcm)"(int *m, int *n, s *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *c, int *ldc, s *rwork) nogil +cdef void clarcm(int *m, int *n, s *a, int *lda, c *b, int *ldb, c *c, int *ldc, s *rwork) noexcept nogil: + + _fortran_clarcm(m, n, a, lda, b, ldb, c, ldc, rwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarf "BLAS_FUNC(clarf)"(char *side, int *m, int *n, npy_complex64 *v, int *incv, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work) nogil +cdef void clarf(char *side, int *m, int *n, c *v, int *incv, c *tau, c *c, int *ldc, c *work) noexcept nogil: + + _fortran_clarf(side, m, n, v, incv, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarfb "BLAS_FUNC(clarfb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, npy_complex64 *v, int *ldv, npy_complex64 *t, int *ldt, npy_complex64 *c, int *ldc, npy_complex64 *work, int *ldwork) nogil +cdef void clarfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, c *v, int *ldv, c *t, int *ldt, c *c, int *ldc, c *work, int *ldwork) noexcept nogil: + + _fortran_clarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarfg "BLAS_FUNC(clarfg)"(int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *tau) nogil +cdef void clarfg(int *n, c *alpha, c *x, int *incx, c *tau) noexcept nogil: + + _fortran_clarfg(n, alpha, x, incx, tau) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarfgp "BLAS_FUNC(clarfgp)"(int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *tau) nogil +cdef void clarfgp(int *n, c *alpha, c *x, int *incx, c *tau) noexcept nogil: + + _fortran_clarfgp(n, alpha, x, incx, tau) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarft "BLAS_FUNC(clarft)"(char *direct, char *storev, int *n, int *k, npy_complex64 *v, int *ldv, npy_complex64 *tau, npy_complex64 *t, int *ldt) nogil +cdef void clarft(char *direct, char *storev, int *n, int *k, c *v, int *ldv, c *tau, c *t, int *ldt) noexcept nogil: + + _fortran_clarft(direct, storev, n, k, v, ldv, tau, t, ldt) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarfx "BLAS_FUNC(clarfx)"(char *side, int *m, int *n, npy_complex64 *v, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work) nogil +cdef void clarfx(char *side, int *m, int *n, c *v, c *tau, c *c, int *ldc, c *work) noexcept nogil: + + _fortran_clarfx(side, m, n, v, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clargv "BLAS_FUNC(clargv)"(int *n, npy_complex64 *x, int *incx, npy_complex64 *y, int *incy, s *c, int *incc) nogil +cdef void clargv(int *n, c *x, int *incx, c *y, int *incy, s *c, int *incc) noexcept nogil: + + _fortran_clargv(n, x, incx, y, incy, c, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarnv "BLAS_FUNC(clarnv)"(int *idist, int *iseed, int *n, npy_complex64 *x) nogil +cdef void clarnv(int *idist, int *iseed, int *n, c *x) noexcept nogil: + + _fortran_clarnv(idist, iseed, n, x) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarrv "BLAS_FUNC(clarrv)"(int *n, s *vl, s *vu, s *d, s *l, s *pivmin, int *isplit, int *m, int *dol, int *dou, s *minrgp, s *rtol1, s *rtol2, s *w, s *werr, s *wgap, int *iblock, int *indexw, s *gers, npy_complex64 *z, int *ldz, int *isuppz, s *work, int *iwork, int *info) nogil +cdef void clarrv(int *n, s *vl, s *vu, s *d, s *l, s *pivmin, int *isplit, int *m, int *dol, int *dou, s *minrgp, s *rtol1, s *rtol2, s *w, s *werr, s *wgap, int *iblock, int *indexw, s *gers, c *z, int *ldz, int *isuppz, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_clarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clartg "BLAS_FUNC(clartg)"(npy_complex64 *f, npy_complex64 *g, s *cs, npy_complex64 *sn, npy_complex64 *r) nogil +cdef void clartg(c *f, c *g, s *cs, c *sn, c *r) noexcept nogil: + + _fortran_clartg(f, g, cs, sn, r) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clartv "BLAS_FUNC(clartv)"(int *n, npy_complex64 *x, int *incx, npy_complex64 *y, int *incy, s *c, npy_complex64 *s, int *incc) nogil +cdef void clartv(int *n, c *x, int *incx, c *y, int *incy, s *c, c *s, int *incc) noexcept nogil: + + _fortran_clartv(n, x, incx, y, incy, c, s, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarz "BLAS_FUNC(clarz)"(char *side, int *m, int *n, int *l, npy_complex64 *v, int *incv, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work) nogil +cdef void clarz(char *side, int *m, int *n, int *l, c *v, int *incv, c *tau, c *c, int *ldc, c *work) noexcept nogil: + + _fortran_clarz(side, m, n, l, v, incv, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarzb "BLAS_FUNC(clarzb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, npy_complex64 *v, int *ldv, npy_complex64 *t, int *ldt, npy_complex64 *c, int *ldc, npy_complex64 *work, int *ldwork) nogil +cdef void clarzb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, c *v, int *ldv, c *t, int *ldt, c *c, int *ldc, c *work, int *ldwork) noexcept nogil: + + _fortran_clarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clarzt "BLAS_FUNC(clarzt)"(char *direct, char *storev, int *n, int *k, npy_complex64 *v, int *ldv, npy_complex64 *tau, npy_complex64 *t, int *ldt) nogil +cdef void clarzt(char *direct, char *storev, int *n, int *k, c *v, int *ldv, c *tau, c *t, int *ldt) noexcept nogil: + + _fortran_clarzt(direct, storev, n, k, v, ldv, tau, t, ldt) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clascl "BLAS_FUNC(clascl)"(char *type_bn, int *kl, int *ku, s *cfrom, s *cto, int *m, int *n, npy_complex64 *a, int *lda, int *info) nogil +cdef void clascl(char *type_bn, int *kl, int *ku, s *cfrom, s *cto, int *m, int *n, c *a, int *lda, int *info) noexcept nogil: + + _fortran_clascl(type_bn, kl, ku, cfrom, cto, m, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claset "BLAS_FUNC(claset)"(char *uplo, int *m, int *n, npy_complex64 *alpha, npy_complex64 *beta, npy_complex64 *a, int *lda) nogil +cdef void claset(char *uplo, int *m, int *n, c *alpha, c *beta, c *a, int *lda) noexcept nogil: + + _fortran_claset(uplo, m, n, alpha, beta, a, lda) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clasr "BLAS_FUNC(clasr)"(char *side, char *pivot, char *direct, int *m, int *n, s *c, s *s, npy_complex64 *a, int *lda) nogil +cdef void clasr(char *side, char *pivot, char *direct, int *m, int *n, s *c, s *s, c *a, int *lda) noexcept nogil: + + _fortran_clasr(side, pivot, direct, m, n, c, s, a, lda) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_classq "BLAS_FUNC(classq)"(int *n, npy_complex64 *x, int *incx, s *scale, s *sumsq) nogil +cdef void classq(int *n, c *x, int *incx, s *scale, s *sumsq) noexcept nogil: + + _fortran_classq(n, x, incx, scale, sumsq) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_claswp "BLAS_FUNC(claswp)"(int *n, npy_complex64 *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) nogil +cdef void claswp(int *n, c *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) noexcept nogil: + + _fortran_claswp(n, a, lda, k1, k2, ipiv, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clasyf "BLAS_FUNC(clasyf)"(char *uplo, int *n, int *nb, int *kb, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *w, int *ldw, int *info) nogil +cdef void clasyf(char *uplo, int *n, int *nb, int *kb, c *a, int *lda, int *ipiv, c *w, int *ldw, int *info) noexcept nogil: + + _fortran_clasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clatbs "BLAS_FUNC(clatbs)"(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, npy_complex64 *ab, int *ldab, npy_complex64 *x, s *scale, s *cnorm, int *info) nogil +cdef void clatbs(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, c *ab, int *ldab, c *x, s *scale, s *cnorm, int *info) noexcept nogil: + + _fortran_clatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clatdf "BLAS_FUNC(clatdf)"(int *ijob, int *n, npy_complex64 *z, int *ldz, npy_complex64 *rhs, s *rdsum, s *rdscal, int *ipiv, int *jpiv) nogil +cdef void clatdf(int *ijob, int *n, c *z, int *ldz, c *rhs, s *rdsum, s *rdscal, int *ipiv, int *jpiv) noexcept nogil: + + _fortran_clatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clatps "BLAS_FUNC(clatps)"(char *uplo, char *trans, char *diag, char *normin, int *n, npy_complex64 *ap, npy_complex64 *x, s *scale, s *cnorm, int *info) nogil +cdef void clatps(char *uplo, char *trans, char *diag, char *normin, int *n, c *ap, c *x, s *scale, s *cnorm, int *info) noexcept nogil: + + _fortran_clatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clatrd "BLAS_FUNC(clatrd)"(char *uplo, int *n, int *nb, npy_complex64 *a, int *lda, s *e, npy_complex64 *tau, npy_complex64 *w, int *ldw) nogil +cdef void clatrd(char *uplo, int *n, int *nb, c *a, int *lda, s *e, c *tau, c *w, int *ldw) noexcept nogil: + + _fortran_clatrd(uplo, n, nb, a, lda, e, tau, w, ldw) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clatrs "BLAS_FUNC(clatrs)"(char *uplo, char *trans, char *diag, char *normin, int *n, npy_complex64 *a, int *lda, npy_complex64 *x, s *scale, s *cnorm, int *info) nogil +cdef void clatrs(char *uplo, char *trans, char *diag, char *normin, int *n, c *a, int *lda, c *x, s *scale, s *cnorm, int *info) noexcept nogil: + + _fortran_clatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clatrz "BLAS_FUNC(clatrz)"(int *m, int *n, int *l, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work) nogil +cdef void clatrz(int *m, int *n, int *l, c *a, int *lda, c *tau, c *work) noexcept nogil: + + _fortran_clatrz(m, n, l, a, lda, tau, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clauu2 "BLAS_FUNC(clauu2)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *info) nogil +cdef void clauu2(char *uplo, int *n, c *a, int *lda, int *info) noexcept nogil: + + _fortran_clauu2(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_clauum "BLAS_FUNC(clauum)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *info) nogil +cdef void clauum(char *uplo, int *n, c *a, int *lda, int *info) noexcept nogil: + + _fortran_clauum(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpbcon "BLAS_FUNC(cpbcon)"(char *uplo, int *n, int *kd, npy_complex64 *ab, int *ldab, s *anorm, s *rcond, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cpbcon(char *uplo, int *n, int *kd, c *ab, int *ldab, s *anorm, s *rcond, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpbequ "BLAS_FUNC(cpbequ)"(char *uplo, int *n, int *kd, npy_complex64 *ab, int *ldab, s *s, s *scond, s *amax, int *info) nogil +cdef void cpbequ(char *uplo, int *n, int *kd, c *ab, int *ldab, s *s, s *scond, s *amax, int *info) noexcept nogil: + + _fortran_cpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpbrfs "BLAS_FUNC(cpbrfs)"(char *uplo, int *n, int *kd, int *nrhs, npy_complex64 *ab, int *ldab, npy_complex64 *afb, int *ldafb, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cpbrfs(char *uplo, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *afb, int *ldafb, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpbstf "BLAS_FUNC(cpbstf)"(char *uplo, int *n, int *kd, npy_complex64 *ab, int *ldab, int *info) nogil +cdef void cpbstf(char *uplo, int *n, int *kd, c *ab, int *ldab, int *info) noexcept nogil: + + _fortran_cpbstf(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpbsv "BLAS_FUNC(cpbsv)"(char *uplo, int *n, int *kd, int *nrhs, npy_complex64 *ab, int *ldab, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cpbsv(char *uplo, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpbsvx "BLAS_FUNC(cpbsvx)"(char *fact, char *uplo, int *n, int *kd, int *nrhs, npy_complex64 *ab, int *ldab, npy_complex64 *afb, int *ldafb, char *equed, s *s, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *rcond, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cpbsvx(char *fact, char *uplo, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *afb, int *ldafb, char *equed, s *s, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cpbsvx(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpbtf2 "BLAS_FUNC(cpbtf2)"(char *uplo, int *n, int *kd, npy_complex64 *ab, int *ldab, int *info) nogil +cdef void cpbtf2(char *uplo, int *n, int *kd, c *ab, int *ldab, int *info) noexcept nogil: + + _fortran_cpbtf2(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpbtrf "BLAS_FUNC(cpbtrf)"(char *uplo, int *n, int *kd, npy_complex64 *ab, int *ldab, int *info) nogil +cdef void cpbtrf(char *uplo, int *n, int *kd, c *ab, int *ldab, int *info) noexcept nogil: + + _fortran_cpbtrf(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpbtrs "BLAS_FUNC(cpbtrs)"(char *uplo, int *n, int *kd, int *nrhs, npy_complex64 *ab, int *ldab, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cpbtrs(char *uplo, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpftrf "BLAS_FUNC(cpftrf)"(char *transr, char *uplo, int *n, npy_complex64 *a, int *info) nogil +cdef void cpftrf(char *transr, char *uplo, int *n, c *a, int *info) noexcept nogil: + + _fortran_cpftrf(transr, uplo, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpftri "BLAS_FUNC(cpftri)"(char *transr, char *uplo, int *n, npy_complex64 *a, int *info) nogil +cdef void cpftri(char *transr, char *uplo, int *n, c *a, int *info) noexcept nogil: + + _fortran_cpftri(transr, uplo, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpftrs "BLAS_FUNC(cpftrs)"(char *transr, char *uplo, int *n, int *nrhs, npy_complex64 *a, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cpftrs(char *transr, char *uplo, int *n, int *nrhs, c *a, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cpftrs(transr, uplo, n, nrhs, a, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpocon "BLAS_FUNC(cpocon)"(char *uplo, int *n, npy_complex64 *a, int *lda, s *anorm, s *rcond, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cpocon(char *uplo, int *n, c *a, int *lda, s *anorm, s *rcond, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cpocon(uplo, n, a, lda, anorm, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpoequ "BLAS_FUNC(cpoequ)"(int *n, npy_complex64 *a, int *lda, s *s, s *scond, s *amax, int *info) nogil +cdef void cpoequ(int *n, c *a, int *lda, s *s, s *scond, s *amax, int *info) noexcept nogil: + + _fortran_cpoequ(n, a, lda, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpoequb "BLAS_FUNC(cpoequb)"(int *n, npy_complex64 *a, int *lda, s *s, s *scond, s *amax, int *info) nogil +cdef void cpoequb(int *n, c *a, int *lda, s *s, s *scond, s *amax, int *info) noexcept nogil: + + _fortran_cpoequb(n, a, lda, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cporfs "BLAS_FUNC(cporfs)"(char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *af, int *ldaf, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cporfs(char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cposv "BLAS_FUNC(cposv)"(char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cposv(char *uplo, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cposv(uplo, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cposvx "BLAS_FUNC(cposvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *af, int *ldaf, char *equed, s *s, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *rcond, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cposvx(char *fact, char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, char *equed, s *s, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cposvx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpotf2 "BLAS_FUNC(cpotf2)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *info) nogil +cdef void cpotf2(char *uplo, int *n, c *a, int *lda, int *info) noexcept nogil: + + _fortran_cpotf2(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpotrf "BLAS_FUNC(cpotrf)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *info) nogil +cdef void cpotrf(char *uplo, int *n, c *a, int *lda, int *info) noexcept nogil: + + _fortran_cpotrf(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpotri "BLAS_FUNC(cpotri)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *info) nogil +cdef void cpotri(char *uplo, int *n, c *a, int *lda, int *info) noexcept nogil: + + _fortran_cpotri(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpotrs "BLAS_FUNC(cpotrs)"(char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cpotrs(char *uplo, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cpotrs(uplo, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cppcon "BLAS_FUNC(cppcon)"(char *uplo, int *n, npy_complex64 *ap, s *anorm, s *rcond, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cppcon(char *uplo, int *n, c *ap, s *anorm, s *rcond, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cppcon(uplo, n, ap, anorm, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cppequ "BLAS_FUNC(cppequ)"(char *uplo, int *n, npy_complex64 *ap, s *s, s *scond, s *amax, int *info) nogil +cdef void cppequ(char *uplo, int *n, c *ap, s *s, s *scond, s *amax, int *info) noexcept nogil: + + _fortran_cppequ(uplo, n, ap, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpprfs "BLAS_FUNC(cpprfs)"(char *uplo, int *n, int *nrhs, npy_complex64 *ap, npy_complex64 *afp, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cpprfs(char *uplo, int *n, int *nrhs, c *ap, c *afp, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cppsv "BLAS_FUNC(cppsv)"(char *uplo, int *n, int *nrhs, npy_complex64 *ap, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cppsv(char *uplo, int *n, int *nrhs, c *ap, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cppsv(uplo, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cppsvx "BLAS_FUNC(cppsvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex64 *ap, npy_complex64 *afp, char *equed, s *s, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *rcond, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cppsvx(char *fact, char *uplo, int *n, int *nrhs, c *ap, c *afp, char *equed, s *s, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cppsvx(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpptrf "BLAS_FUNC(cpptrf)"(char *uplo, int *n, npy_complex64 *ap, int *info) nogil +cdef void cpptrf(char *uplo, int *n, c *ap, int *info) noexcept nogil: + + _fortran_cpptrf(uplo, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpptri "BLAS_FUNC(cpptri)"(char *uplo, int *n, npy_complex64 *ap, int *info) nogil +cdef void cpptri(char *uplo, int *n, c *ap, int *info) noexcept nogil: + + _fortran_cpptri(uplo, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpptrs "BLAS_FUNC(cpptrs)"(char *uplo, int *n, int *nrhs, npy_complex64 *ap, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cpptrs(char *uplo, int *n, int *nrhs, c *ap, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cpptrs(uplo, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpstf2 "BLAS_FUNC(cpstf2)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) nogil +cdef void cpstf2(char *uplo, int *n, c *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) noexcept nogil: + + _fortran_cpstf2(uplo, n, a, lda, piv, rank, tol, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpstrf "BLAS_FUNC(cpstrf)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) nogil +cdef void cpstrf(char *uplo, int *n, c *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) noexcept nogil: + + _fortran_cpstrf(uplo, n, a, lda, piv, rank, tol, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cptcon "BLAS_FUNC(cptcon)"(int *n, s *d, npy_complex64 *e, s *anorm, s *rcond, s *rwork, int *info) nogil +cdef void cptcon(int *n, s *d, c *e, s *anorm, s *rcond, s *rwork, int *info) noexcept nogil: + + _fortran_cptcon(n, d, e, anorm, rcond, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpteqr "BLAS_FUNC(cpteqr)"(char *compz, int *n, s *d, s *e, npy_complex64 *z, int *ldz, s *work, int *info) nogil +cdef void cpteqr(char *compz, int *n, s *d, s *e, c *z, int *ldz, s *work, int *info) noexcept nogil: + + _fortran_cpteqr(compz, n, d, e, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cptrfs "BLAS_FUNC(cptrfs)"(char *uplo, int *n, int *nrhs, s *d, npy_complex64 *e, s *df, npy_complex64 *ef, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cptrfs(char *uplo, int *n, int *nrhs, s *d, c *e, s *df, c *ef, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cptrfs(uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cptsv "BLAS_FUNC(cptsv)"(int *n, int *nrhs, s *d, npy_complex64 *e, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cptsv(int *n, int *nrhs, s *d, c *e, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cptsv(n, nrhs, d, e, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cptsvx "BLAS_FUNC(cptsvx)"(char *fact, int *n, int *nrhs, s *d, npy_complex64 *e, s *df, npy_complex64 *ef, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *rcond, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cptsvx(char *fact, int *n, int *nrhs, s *d, c *e, s *df, c *ef, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cptsvx(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpttrf "BLAS_FUNC(cpttrf)"(int *n, s *d, npy_complex64 *e, int *info) nogil +cdef void cpttrf(int *n, s *d, c *e, int *info) noexcept nogil: + + _fortran_cpttrf(n, d, e, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cpttrs "BLAS_FUNC(cpttrs)"(char *uplo, int *n, int *nrhs, s *d, npy_complex64 *e, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cpttrs(char *uplo, int *n, int *nrhs, s *d, c *e, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cpttrs(uplo, n, nrhs, d, e, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cptts2 "BLAS_FUNC(cptts2)"(int *iuplo, int *n, int *nrhs, s *d, npy_complex64 *e, npy_complex64 *b, int *ldb) nogil +cdef void cptts2(int *iuplo, int *n, int *nrhs, s *d, c *e, c *b, int *ldb) noexcept nogil: + + _fortran_cptts2(iuplo, n, nrhs, d, e, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_crot "BLAS_FUNC(crot)"(int *n, npy_complex64 *cx, int *incx, npy_complex64 *cy, int *incy, s *c, npy_complex64 *s) nogil +cdef void crot(int *n, c *cx, int *incx, c *cy, int *incy, s *c, c *s) noexcept nogil: + + _fortran_crot(n, cx, incx, cy, incy, c, s) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cspcon "BLAS_FUNC(cspcon)"(char *uplo, int *n, npy_complex64 *ap, int *ipiv, s *anorm, s *rcond, npy_complex64 *work, int *info) nogil +cdef void cspcon(char *uplo, int *n, c *ap, int *ipiv, s *anorm, s *rcond, c *work, int *info) noexcept nogil: + + _fortran_cspcon(uplo, n, ap, ipiv, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cspmv "BLAS_FUNC(cspmv)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *ap, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil +cdef void cspmv(char *uplo, int *n, c *alpha, c *ap, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil: + + _fortran_cspmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cspr "BLAS_FUNC(cspr)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *ap) nogil +cdef void cspr(char *uplo, int *n, c *alpha, c *x, int *incx, c *ap) noexcept nogil: + + _fortran_cspr(uplo, n, alpha, x, incx, ap) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csprfs "BLAS_FUNC(csprfs)"(char *uplo, int *n, int *nrhs, npy_complex64 *ap, npy_complex64 *afp, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void csprfs(char *uplo, int *n, int *nrhs, c *ap, c *afp, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_csprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cspsv "BLAS_FUNC(cspsv)"(char *uplo, int *n, int *nrhs, npy_complex64 *ap, int *ipiv, npy_complex64 *b, int *ldb, int *info) nogil +cdef void cspsv(char *uplo, int *n, int *nrhs, c *ap, int *ipiv, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_cspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cspsvx "BLAS_FUNC(cspsvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex64 *ap, npy_complex64 *afp, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *rcond, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void cspsvx(char *fact, char *uplo, int *n, int *nrhs, c *ap, c *afp, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_cspsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csptrf "BLAS_FUNC(csptrf)"(char *uplo, int *n, npy_complex64 *ap, int *ipiv, int *info) nogil +cdef void csptrf(char *uplo, int *n, c *ap, int *ipiv, int *info) noexcept nogil: + + _fortran_csptrf(uplo, n, ap, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csptri "BLAS_FUNC(csptri)"(char *uplo, int *n, npy_complex64 *ap, int *ipiv, npy_complex64 *work, int *info) nogil +cdef void csptri(char *uplo, int *n, c *ap, int *ipiv, c *work, int *info) noexcept nogil: + + _fortran_csptri(uplo, n, ap, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csptrs "BLAS_FUNC(csptrs)"(char *uplo, int *n, int *nrhs, npy_complex64 *ap, int *ipiv, npy_complex64 *b, int *ldb, int *info) nogil +cdef void csptrs(char *uplo, int *n, int *nrhs, c *ap, int *ipiv, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_csptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csrscl "BLAS_FUNC(csrscl)"(int *n, s *sa, npy_complex64 *sx, int *incx) nogil +cdef void csrscl(int *n, s *sa, c *sx, int *incx) noexcept nogil: + + _fortran_csrscl(n, sa, sx, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cstedc "BLAS_FUNC(cstedc)"(char *compz, int *n, s *d, s *e, npy_complex64 *z, int *ldz, npy_complex64 *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void cstedc(char *compz, int *n, s *d, s *e, c *z, int *ldz, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_cstedc(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cstegr "BLAS_FUNC(cstegr)"(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, npy_complex64 *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void cstegr(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, c *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_cstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cstein "BLAS_FUNC(cstein)"(int *n, s *d, s *e, int *m, s *w, int *iblock, int *isplit, npy_complex64 *z, int *ldz, s *work, int *iwork, int *ifail, int *info) nogil +cdef void cstein(int *n, s *d, s *e, int *m, s *w, int *iblock, int *isplit, c *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_cstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cstemr "BLAS_FUNC(cstemr)"(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, int *m, s *w, npy_complex64 *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void cstemr(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, int *m, s *w, c *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_cstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csteqr "BLAS_FUNC(csteqr)"(char *compz, int *n, s *d, s *e, npy_complex64 *z, int *ldz, s *work, int *info) nogil +cdef void csteqr(char *compz, int *n, s *d, s *e, c *z, int *ldz, s *work, int *info) noexcept nogil: + + _fortran_csteqr(compz, n, d, e, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csycon "BLAS_FUNC(csycon)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, s *anorm, s *rcond, npy_complex64 *work, int *info) nogil +cdef void csycon(char *uplo, int *n, c *a, int *lda, int *ipiv, s *anorm, s *rcond, c *work, int *info) noexcept nogil: + + _fortran_csycon(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csyconv "BLAS_FUNC(csyconv)"(char *uplo, char *way, int *n, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *work, int *info) nogil +cdef void csyconv(char *uplo, char *way, int *n, c *a, int *lda, int *ipiv, c *work, int *info) noexcept nogil: + + _fortran_csyconv(uplo, way, n, a, lda, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csyequb "BLAS_FUNC(csyequb)"(char *uplo, int *n, npy_complex64 *a, int *lda, s *s, s *scond, s *amax, npy_complex64 *work, int *info) nogil +cdef void csyequb(char *uplo, int *n, c *a, int *lda, s *s, s *scond, s *amax, c *work, int *info) noexcept nogil: + + _fortran_csyequb(uplo, n, a, lda, s, scond, amax, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csymv "BLAS_FUNC(csymv)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *a, int *lda, npy_complex64 *x, int *incx, npy_complex64 *beta, npy_complex64 *y, int *incy) nogil +cdef void csymv(char *uplo, int *n, c *alpha, c *a, int *lda, c *x, int *incx, c *beta, c *y, int *incy) noexcept nogil: + + _fortran_csymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csyr "BLAS_FUNC(csyr)"(char *uplo, int *n, npy_complex64 *alpha, npy_complex64 *x, int *incx, npy_complex64 *a, int *lda) nogil +cdef void csyr(char *uplo, int *n, c *alpha, c *x, int *incx, c *a, int *lda) noexcept nogil: + + _fortran_csyr(uplo, n, alpha, x, incx, a, lda) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csyrfs "BLAS_FUNC(csyrfs)"(char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *af, int *ldaf, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void csyrfs(char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_csyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csysv "BLAS_FUNC(csysv)"(char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *work, int *lwork, int *info) nogil +cdef void csysv(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_csysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csysvx "BLAS_FUNC(csysvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *af, int *ldaf, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *rcond, s *ferr, s *berr, npy_complex64 *work, int *lwork, s *rwork, int *info) nogil +cdef void csysvx(char *fact, char *uplo, int *n, int *nrhs, c *a, int *lda, c *af, int *ldaf, int *ipiv, c *b, int *ldb, c *x, int *ldx, s *rcond, s *ferr, s *berr, c *work, int *lwork, s *rwork, int *info) noexcept nogil: + + _fortran_csysvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csyswapr "BLAS_FUNC(csyswapr)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *i1, int *i2) nogil +cdef void csyswapr(char *uplo, int *n, c *a, int *lda, int *i1, int *i2) noexcept nogil: + + _fortran_csyswapr(uplo, n, a, lda, i1, i2) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csytf2 "BLAS_FUNC(csytf2)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, int *info) nogil +cdef void csytf2(char *uplo, int *n, c *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_csytf2(uplo, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csytrf "BLAS_FUNC(csytrf)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *work, int *lwork, int *info) nogil +cdef void csytrf(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_csytrf(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csytri "BLAS_FUNC(csytri)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *work, int *info) nogil +cdef void csytri(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *info) noexcept nogil: + + _fortran_csytri(uplo, n, a, lda, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csytri2 "BLAS_FUNC(csytri2)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *work, int *lwork, int *info) nogil +cdef void csytri2(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_csytri2(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csytri2x "BLAS_FUNC(csytri2x)"(char *uplo, int *n, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *work, int *nb, int *info) nogil +cdef void csytri2x(char *uplo, int *n, c *a, int *lda, int *ipiv, c *work, int *nb, int *info) noexcept nogil: + + _fortran_csytri2x(uplo, n, a, lda, ipiv, work, nb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csytrs "BLAS_FUNC(csytrs)"(char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *b, int *ldb, int *info) nogil +cdef void csytrs(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_csytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_csytrs2 "BLAS_FUNC(csytrs2)"(char *uplo, int *n, int *nrhs, npy_complex64 *a, int *lda, int *ipiv, npy_complex64 *b, int *ldb, npy_complex64 *work, int *info) nogil +cdef void csytrs2(char *uplo, int *n, int *nrhs, c *a, int *lda, int *ipiv, c *b, int *ldb, c *work, int *info) noexcept nogil: + + _fortran_csytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctbcon "BLAS_FUNC(ctbcon)"(char *norm, char *uplo, char *diag, int *n, int *kd, npy_complex64 *ab, int *ldab, s *rcond, npy_complex64 *work, s *rwork, int *info) nogil +cdef void ctbcon(char *norm, char *uplo, char *diag, int *n, int *kd, c *ab, int *ldab, s *rcond, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_ctbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctbrfs "BLAS_FUNC(ctbrfs)"(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, npy_complex64 *ab, int *ldab, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void ctbrfs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_ctbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctbtrs "BLAS_FUNC(ctbtrs)"(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, npy_complex64 *ab, int *ldab, npy_complex64 *b, int *ldb, int *info) nogil +cdef void ctbtrs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, c *ab, int *ldab, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_ctbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctfsm "BLAS_FUNC(ctfsm)"(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, npy_complex64 *alpha, npy_complex64 *a, npy_complex64 *b, int *ldb) nogil +cdef void ctfsm(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, c *alpha, c *a, c *b, int *ldb) noexcept nogil: + + _fortran_ctfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctftri "BLAS_FUNC(ctftri)"(char *transr, char *uplo, char *diag, int *n, npy_complex64 *a, int *info) nogil +cdef void ctftri(char *transr, char *uplo, char *diag, int *n, c *a, int *info) noexcept nogil: + + _fortran_ctftri(transr, uplo, diag, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctfttp "BLAS_FUNC(ctfttp)"(char *transr, char *uplo, int *n, npy_complex64 *arf, npy_complex64 *ap, int *info) nogil +cdef void ctfttp(char *transr, char *uplo, int *n, c *arf, c *ap, int *info) noexcept nogil: + + _fortran_ctfttp(transr, uplo, n, arf, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctfttr "BLAS_FUNC(ctfttr)"(char *transr, char *uplo, int *n, npy_complex64 *arf, npy_complex64 *a, int *lda, int *info) nogil +cdef void ctfttr(char *transr, char *uplo, int *n, c *arf, c *a, int *lda, int *info) noexcept nogil: + + _fortran_ctfttr(transr, uplo, n, arf, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctgevc "BLAS_FUNC(ctgevc)"(char *side, char *howmny, bint *select, int *n, npy_complex64 *s, int *lds, npy_complex64 *p, int *ldp, npy_complex64 *vl, int *ldvl, npy_complex64 *vr, int *ldvr, int *mm, int *m, npy_complex64 *work, s *rwork, int *info) nogil +cdef void ctgevc(char *side, char *howmny, bint *select, int *n, c *s, int *lds, c *p, int *ldp, c *vl, int *ldvl, c *vr, int *ldvr, int *mm, int *m, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_ctgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctgex2 "BLAS_FUNC(ctgex2)"(bint *wantq, bint *wantz, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *q, int *ldq, npy_complex64 *z, int *ldz, int *j1, int *info) nogil +cdef void ctgex2(bint *wantq, bint *wantz, int *n, c *a, int *lda, c *b, int *ldb, c *q, int *ldq, c *z, int *ldz, int *j1, int *info) noexcept nogil: + + _fortran_ctgex2(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctgexc "BLAS_FUNC(ctgexc)"(bint *wantq, bint *wantz, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *q, int *ldq, npy_complex64 *z, int *ldz, int *ifst, int *ilst, int *info) nogil +cdef void ctgexc(bint *wantq, bint *wantz, int *n, c *a, int *lda, c *b, int *ldb, c *q, int *ldq, c *z, int *ldz, int *ifst, int *ilst, int *info) noexcept nogil: + + _fortran_ctgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctgsen "BLAS_FUNC(ctgsen)"(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *alpha, npy_complex64 *beta, npy_complex64 *q, int *ldq, npy_complex64 *z, int *ldz, int *m, s *pl, s *pr, s *dif, npy_complex64 *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void ctgsen(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, c *a, int *lda, c *b, int *ldb, c *alpha, c *beta, c *q, int *ldq, c *z, int *ldz, int *m, s *pl, s *pr, s *dif, c *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_ctgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctgsja "BLAS_FUNC(ctgsja)"(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, s *tola, s *tolb, s *alpha, s *beta, npy_complex64 *u, int *ldu, npy_complex64 *v, int *ldv, npy_complex64 *q, int *ldq, npy_complex64 *work, int *ncycle, int *info) nogil +cdef void ctgsja(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, c *a, int *lda, c *b, int *ldb, s *tola, s *tolb, s *alpha, s *beta, c *u, int *ldu, c *v, int *ldv, c *q, int *ldq, c *work, int *ncycle, int *info) noexcept nogil: + + _fortran_ctgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctgsna "BLAS_FUNC(ctgsna)"(char *job, char *howmny, bint *select, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *vl, int *ldvl, npy_complex64 *vr, int *ldvr, s *s, s *dif, int *mm, int *m, npy_complex64 *work, int *lwork, int *iwork, int *info) nogil +cdef void ctgsna(char *job, char *howmny, bint *select, int *n, c *a, int *lda, c *b, int *ldb, c *vl, int *ldvl, c *vr, int *ldvr, s *s, s *dif, int *mm, int *m, c *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_ctgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctgsy2 "BLAS_FUNC(ctgsy2)"(char *trans, int *ijob, int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *c, int *ldc, npy_complex64 *d, int *ldd, npy_complex64 *e, int *lde, npy_complex64 *f, int *ldf, s *scale, s *rdsum, s *rdscal, int *info) nogil +cdef void ctgsy2(char *trans, int *ijob, int *m, int *n, c *a, int *lda, c *b, int *ldb, c *c, int *ldc, c *d, int *ldd, c *e, int *lde, c *f, int *ldf, s *scale, s *rdsum, s *rdscal, int *info) noexcept nogil: + + _fortran_ctgsy2(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctgsyl "BLAS_FUNC(ctgsyl)"(char *trans, int *ijob, int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *c, int *ldc, npy_complex64 *d, int *ldd, npy_complex64 *e, int *lde, npy_complex64 *f, int *ldf, s *scale, s *dif, npy_complex64 *work, int *lwork, int *iwork, int *info) nogil +cdef void ctgsyl(char *trans, int *ijob, int *m, int *n, c *a, int *lda, c *b, int *ldb, c *c, int *ldc, c *d, int *ldd, c *e, int *lde, c *f, int *ldf, s *scale, s *dif, c *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_ctgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctpcon "BLAS_FUNC(ctpcon)"(char *norm, char *uplo, char *diag, int *n, npy_complex64 *ap, s *rcond, npy_complex64 *work, s *rwork, int *info) nogil +cdef void ctpcon(char *norm, char *uplo, char *diag, int *n, c *ap, s *rcond, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_ctpcon(norm, uplo, diag, n, ap, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctpmqrt "BLAS_FUNC(ctpmqrt)"(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, npy_complex64 *v, int *ldv, npy_complex64 *t, int *ldt, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *work, int *info) nogil +cdef void ctpmqrt(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, c *v, int *ldv, c *t, int *ldt, c *a, int *lda, c *b, int *ldb, c *work, int *info) noexcept nogil: + + _fortran_ctpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctpqrt "BLAS_FUNC(ctpqrt)"(int *m, int *n, int *l, int *nb, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *t, int *ldt, npy_complex64 *work, int *info) nogil +cdef void ctpqrt(int *m, int *n, int *l, int *nb, c *a, int *lda, c *b, int *ldb, c *t, int *ldt, c *work, int *info) noexcept nogil: + + _fortran_ctpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctpqrt2 "BLAS_FUNC(ctpqrt2)"(int *m, int *n, int *l, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *t, int *ldt, int *info) nogil +cdef void ctpqrt2(int *m, int *n, int *l, c *a, int *lda, c *b, int *ldb, c *t, int *ldt, int *info) noexcept nogil: + + _fortran_ctpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctprfb "BLAS_FUNC(ctprfb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, npy_complex64 *v, int *ldv, npy_complex64 *t, int *ldt, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *work, int *ldwork) nogil +cdef void ctprfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, c *v, int *ldv, c *t, int *ldt, c *a, int *lda, c *b, int *ldb, c *work, int *ldwork) noexcept nogil: + + _fortran_ctprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctprfs "BLAS_FUNC(ctprfs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, npy_complex64 *ap, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void ctprfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, c *ap, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_ctprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctptri "BLAS_FUNC(ctptri)"(char *uplo, char *diag, int *n, npy_complex64 *ap, int *info) nogil +cdef void ctptri(char *uplo, char *diag, int *n, c *ap, int *info) noexcept nogil: + + _fortran_ctptri(uplo, diag, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctptrs "BLAS_FUNC(ctptrs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, npy_complex64 *ap, npy_complex64 *b, int *ldb, int *info) nogil +cdef void ctptrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, c *ap, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_ctptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctpttf "BLAS_FUNC(ctpttf)"(char *transr, char *uplo, int *n, npy_complex64 *ap, npy_complex64 *arf, int *info) nogil +cdef void ctpttf(char *transr, char *uplo, int *n, c *ap, c *arf, int *info) noexcept nogil: + + _fortran_ctpttf(transr, uplo, n, ap, arf, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctpttr "BLAS_FUNC(ctpttr)"(char *uplo, int *n, npy_complex64 *ap, npy_complex64 *a, int *lda, int *info) nogil +cdef void ctpttr(char *uplo, int *n, c *ap, c *a, int *lda, int *info) noexcept nogil: + + _fortran_ctpttr(uplo, n, ap, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrcon "BLAS_FUNC(ctrcon)"(char *norm, char *uplo, char *diag, int *n, npy_complex64 *a, int *lda, s *rcond, npy_complex64 *work, s *rwork, int *info) nogil +cdef void ctrcon(char *norm, char *uplo, char *diag, int *n, c *a, int *lda, s *rcond, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_ctrcon(norm, uplo, diag, n, a, lda, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrevc "BLAS_FUNC(ctrevc)"(char *side, char *howmny, bint *select, int *n, npy_complex64 *t, int *ldt, npy_complex64 *vl, int *ldvl, npy_complex64 *vr, int *ldvr, int *mm, int *m, npy_complex64 *work, s *rwork, int *info) nogil +cdef void ctrevc(char *side, char *howmny, bint *select, int *n, c *t, int *ldt, c *vl, int *ldvl, c *vr, int *ldvr, int *mm, int *m, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_ctrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrexc "BLAS_FUNC(ctrexc)"(char *compq, int *n, npy_complex64 *t, int *ldt, npy_complex64 *q, int *ldq, int *ifst, int *ilst, int *info) nogil +cdef void ctrexc(char *compq, int *n, c *t, int *ldt, c *q, int *ldq, int *ifst, int *ilst, int *info) noexcept nogil: + + _fortran_ctrexc(compq, n, t, ldt, q, ldq, ifst, ilst, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrrfs "BLAS_FUNC(ctrrfs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *x, int *ldx, s *ferr, s *berr, npy_complex64 *work, s *rwork, int *info) nogil +cdef void ctrrfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, c *x, int *ldx, s *ferr, s *berr, c *work, s *rwork, int *info) noexcept nogil: + + _fortran_ctrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrsen "BLAS_FUNC(ctrsen)"(char *job, char *compq, bint *select, int *n, npy_complex64 *t, int *ldt, npy_complex64 *q, int *ldq, npy_complex64 *w, int *m, s *s, s *sep, npy_complex64 *work, int *lwork, int *info) nogil +cdef void ctrsen(char *job, char *compq, bint *select, int *n, c *t, int *ldt, c *q, int *ldq, c *w, int *m, s *s, s *sep, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_ctrsen(job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrsna "BLAS_FUNC(ctrsna)"(char *job, char *howmny, bint *select, int *n, npy_complex64 *t, int *ldt, npy_complex64 *vl, int *ldvl, npy_complex64 *vr, int *ldvr, s *s, s *sep, int *mm, int *m, npy_complex64 *work, int *ldwork, s *rwork, int *info) nogil +cdef void ctrsna(char *job, char *howmny, bint *select, int *n, c *t, int *ldt, c *vl, int *ldvl, c *vr, int *ldvr, s *s, s *sep, int *mm, int *m, c *work, int *ldwork, s *rwork, int *info) noexcept nogil: + + _fortran_ctrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrsyl "BLAS_FUNC(ctrsyl)"(char *trana, char *tranb, int *isgn, int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, npy_complex64 *c, int *ldc, s *scale, int *info) nogil +cdef void ctrsyl(char *trana, char *tranb, int *isgn, int *m, int *n, c *a, int *lda, c *b, int *ldb, c *c, int *ldc, s *scale, int *info) noexcept nogil: + + _fortran_ctrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrti2 "BLAS_FUNC(ctrti2)"(char *uplo, char *diag, int *n, npy_complex64 *a, int *lda, int *info) nogil +cdef void ctrti2(char *uplo, char *diag, int *n, c *a, int *lda, int *info) noexcept nogil: + + _fortran_ctrti2(uplo, diag, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrtri "BLAS_FUNC(ctrtri)"(char *uplo, char *diag, int *n, npy_complex64 *a, int *lda, int *info) nogil +cdef void ctrtri(char *uplo, char *diag, int *n, c *a, int *lda, int *info) noexcept nogil: + + _fortran_ctrtri(uplo, diag, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrtrs "BLAS_FUNC(ctrtrs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, npy_complex64 *a, int *lda, npy_complex64 *b, int *ldb, int *info) nogil +cdef void ctrtrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, c *a, int *lda, c *b, int *ldb, int *info) noexcept nogil: + + _fortran_ctrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrttf "BLAS_FUNC(ctrttf)"(char *transr, char *uplo, int *n, npy_complex64 *a, int *lda, npy_complex64 *arf, int *info) nogil +cdef void ctrttf(char *transr, char *uplo, int *n, c *a, int *lda, c *arf, int *info) noexcept nogil: + + _fortran_ctrttf(transr, uplo, n, a, lda, arf, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctrttp "BLAS_FUNC(ctrttp)"(char *uplo, int *n, npy_complex64 *a, int *lda, npy_complex64 *ap, int *info) nogil +cdef void ctrttp(char *uplo, int *n, c *a, int *lda, c *ap, int *info) noexcept nogil: + + _fortran_ctrttp(uplo, n, a, lda, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ctzrzf "BLAS_FUNC(ctzrzf)"(int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void ctzrzf(int *m, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_ctzrzf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunbdb "BLAS_FUNC(cunbdb)"(char *trans, char *signs, int *m, int *p, int *q, npy_complex64 *x11, int *ldx11, npy_complex64 *x12, int *ldx12, npy_complex64 *x21, int *ldx21, npy_complex64 *x22, int *ldx22, s *theta, s *phi, npy_complex64 *taup1, npy_complex64 *taup2, npy_complex64 *tauq1, npy_complex64 *tauq2, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cunbdb(char *trans, char *signs, int *m, int *p, int *q, c *x11, int *ldx11, c *x12, int *ldx12, c *x21, int *ldx21, c *x22, int *ldx22, s *theta, s *phi, c *taup1, c *taup2, c *tauq1, c *tauq2, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cunbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cuncsd "BLAS_FUNC(cuncsd)"(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, npy_complex64 *x11, int *ldx11, npy_complex64 *x12, int *ldx12, npy_complex64 *x21, int *ldx21, npy_complex64 *x22, int *ldx22, s *theta, npy_complex64 *u1, int *ldu1, npy_complex64 *u2, int *ldu2, npy_complex64 *v1t, int *ldv1t, npy_complex64 *v2t, int *ldv2t, npy_complex64 *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *info) nogil +cdef void cuncsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, c *x11, int *ldx11, c *x12, int *ldx12, c *x21, int *ldx21, c *x22, int *ldx22, s *theta, c *u1, int *ldu1, c *u2, int *ldu2, c *v1t, int *ldv1t, c *v2t, int *ldv2t, c *work, int *lwork, s *rwork, int *lrwork, int *iwork, int *info) noexcept nogil: + + _fortran_cuncsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, rwork, lrwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cung2l "BLAS_FUNC(cung2l)"(int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *info) nogil +cdef void cung2l(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil: + + _fortran_cung2l(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cung2r "BLAS_FUNC(cung2r)"(int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *info) nogil +cdef void cung2r(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil: + + _fortran_cung2r(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cungbr "BLAS_FUNC(cungbr)"(char *vect, int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cungbr(char *vect, int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cungbr(vect, m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunghr "BLAS_FUNC(cunghr)"(int *n, int *ilo, int *ihi, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cunghr(int *n, int *ilo, int *ihi, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cunghr(n, ilo, ihi, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cungl2 "BLAS_FUNC(cungl2)"(int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *info) nogil +cdef void cungl2(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil: + + _fortran_cungl2(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunglq "BLAS_FUNC(cunglq)"(int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cunglq(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cunglq(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cungql "BLAS_FUNC(cungql)"(int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cungql(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cungql(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cungqr "BLAS_FUNC(cungqr)"(int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cungqr(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cungqr(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cungr2 "BLAS_FUNC(cungr2)"(int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *info) nogil +cdef void cungr2(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *info) noexcept nogil: + + _fortran_cungr2(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cungrq "BLAS_FUNC(cungrq)"(int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cungrq(int *m, int *n, int *k, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cungrq(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cungtr "BLAS_FUNC(cungtr)"(char *uplo, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cungtr(char *uplo, int *n, c *a, int *lda, c *tau, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cungtr(uplo, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunm2l "BLAS_FUNC(cunm2l)"(char *side, char *trans, int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *info) nogil +cdef void cunm2l(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil: + + _fortran_cunm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunm2r "BLAS_FUNC(cunm2r)"(char *side, char *trans, int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *info) nogil +cdef void cunm2r(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil: + + _fortran_cunm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunmbr "BLAS_FUNC(cunmbr)"(char *vect, char *side, char *trans, int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cunmbr(char *vect, char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cunmbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunmhr "BLAS_FUNC(cunmhr)"(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cunmhr(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cunmhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunml2 "BLAS_FUNC(cunml2)"(char *side, char *trans, int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *info) nogil +cdef void cunml2(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil: + + _fortran_cunml2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunmlq "BLAS_FUNC(cunmlq)"(char *side, char *trans, int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cunmlq(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cunmlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunmql "BLAS_FUNC(cunmql)"(char *side, char *trans, int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cunmql(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cunmql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunmqr "BLAS_FUNC(cunmqr)"(char *side, char *trans, int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cunmqr(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cunmqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunmr2 "BLAS_FUNC(cunmr2)"(char *side, char *trans, int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *info) nogil +cdef void cunmr2(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil: + + _fortran_cunmr2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunmr3 "BLAS_FUNC(cunmr3)"(char *side, char *trans, int *m, int *n, int *k, int *l, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *info) nogil +cdef void cunmr3(char *side, char *trans, int *m, int *n, int *k, int *l, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil: + + _fortran_cunmr3(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunmrq "BLAS_FUNC(cunmrq)"(char *side, char *trans, int *m, int *n, int *k, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cunmrq(char *side, char *trans, int *m, int *n, int *k, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cunmrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunmrz "BLAS_FUNC(cunmrz)"(char *side, char *trans, int *m, int *n, int *k, int *l, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cunmrz(char *side, char *trans, int *m, int *n, int *k, int *l, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cunmrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cunmtr "BLAS_FUNC(cunmtr)"(char *side, char *uplo, char *trans, int *m, int *n, npy_complex64 *a, int *lda, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *lwork, int *info) nogil +cdef void cunmtr(char *side, char *uplo, char *trans, int *m, int *n, c *a, int *lda, c *tau, c *c, int *ldc, c *work, int *lwork, int *info) noexcept nogil: + + _fortran_cunmtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cupgtr "BLAS_FUNC(cupgtr)"(char *uplo, int *n, npy_complex64 *ap, npy_complex64 *tau, npy_complex64 *q, int *ldq, npy_complex64 *work, int *info) nogil +cdef void cupgtr(char *uplo, int *n, c *ap, c *tau, c *q, int *ldq, c *work, int *info) noexcept nogil: + + _fortran_cupgtr(uplo, n, ap, tau, q, ldq, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_cupmtr "BLAS_FUNC(cupmtr)"(char *side, char *uplo, char *trans, int *m, int *n, npy_complex64 *ap, npy_complex64 *tau, npy_complex64 *c, int *ldc, npy_complex64 *work, int *info) nogil +cdef void cupmtr(char *side, char *uplo, char *trans, int *m, int *n, c *ap, c *tau, c *c, int *ldc, c *work, int *info) noexcept nogil: + + _fortran_cupmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dbbcsd "BLAS_FUNC(dbbcsd)"(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, d *theta, d *phi, d *u1, int *ldu1, d *u2, int *ldu2, d *v1t, int *ldv1t, d *v2t, int *ldv2t, d *b11d, d *b11e, d *b12d, d *b12e, d *b21d, d *b21e, d *b22d, d *b22e, d *work, int *lwork, int *info) nogil +cdef void dbbcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, d *theta, d *phi, d *u1, int *ldu1, d *u2, int *ldu2, d *v1t, int *ldv1t, d *v2t, int *ldv2t, d *b11d, d *b11e, d *b12d, d *b12e, d *b21d, d *b21e, d *b22d, d *b22e, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dbdsdc "BLAS_FUNC(dbdsdc)"(char *uplo, char *compq, int *n, d *d, d *e, d *u, int *ldu, d *vt, int *ldvt, d *q, int *iq, d *work, int *iwork, int *info) nogil +cdef void dbdsdc(char *uplo, char *compq, int *n, d *d, d *e, d *u, int *ldu, d *vt, int *ldvt, d *q, int *iq, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dbdsdc(uplo, compq, n, d, e, u, ldu, vt, ldvt, q, iq, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dbdsqr "BLAS_FUNC(dbdsqr)"(char *uplo, int *n, int *ncvt, int *nru, int *ncc, d *d, d *e, d *vt, int *ldvt, d *u, int *ldu, d *c, int *ldc, d *work, int *info) nogil +cdef void dbdsqr(char *uplo, int *n, int *ncvt, int *nru, int *ncc, d *d, d *e, d *vt, int *ldvt, d *u, int *ldu, d *c, int *ldc, d *work, int *info) noexcept nogil: + + _fortran_dbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ddisna "BLAS_FUNC(ddisna)"(char *job, int *m, int *n, d *d, d *sep, int *info) nogil +cdef void ddisna(char *job, int *m, int *n, d *d, d *sep, int *info) noexcept nogil: + + _fortran_ddisna(job, m, n, d, sep, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgbbrd "BLAS_FUNC(dgbbrd)"(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, d *ab, int *ldab, d *d, d *e, d *q, int *ldq, d *pt, int *ldpt, d *c, int *ldc, d *work, int *info) nogil +cdef void dgbbrd(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, d *ab, int *ldab, d *d, d *e, d *q, int *ldq, d *pt, int *ldpt, d *c, int *ldc, d *work, int *info) noexcept nogil: + + _fortran_dgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgbcon "BLAS_FUNC(dgbcon)"(char *norm, int *n, int *kl, int *ku, d *ab, int *ldab, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) nogil +cdef void dgbcon(char *norm, int *n, int *kl, int *ku, d *ab, int *ldab, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgbequ "BLAS_FUNC(dgbequ)"(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) nogil +cdef void dgbequ(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil: + + _fortran_dgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgbequb "BLAS_FUNC(dgbequb)"(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) nogil +cdef void dgbequb(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil: + + _fortran_dgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgbrfs "BLAS_FUNC(dgbrfs)"(char *trans, int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dgbrfs(char *trans, int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgbsv "BLAS_FUNC(dgbsv)"(int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, int *ipiv, d *b, int *ldb, int *info) nogil +cdef void dgbsv(int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, int *ipiv, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgbsvx "BLAS_FUNC(dgbsvx)"(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, int *ipiv, char *equed, d *r, d *c, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dgbsvx(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, int *ipiv, char *equed, d *r, d *c, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dgbsvx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgbtf2 "BLAS_FUNC(dgbtf2)"(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, int *ipiv, int *info) nogil +cdef void dgbtf2(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, int *ipiv, int *info) noexcept nogil: + + _fortran_dgbtf2(m, n, kl, ku, ab, ldab, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgbtrf "BLAS_FUNC(dgbtrf)"(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, int *ipiv, int *info) nogil +cdef void dgbtrf(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, int *ipiv, int *info) noexcept nogil: + + _fortran_dgbtrf(m, n, kl, ku, ab, ldab, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgbtrs "BLAS_FUNC(dgbtrs)"(char *trans, int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, int *ipiv, d *b, int *ldb, int *info) nogil +cdef void dgbtrs(char *trans, int *n, int *kl, int *ku, int *nrhs, d *ab, int *ldab, int *ipiv, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgebak "BLAS_FUNC(dgebak)"(char *job, char *side, int *n, int *ilo, int *ihi, d *scale, int *m, d *v, int *ldv, int *info) nogil +cdef void dgebak(char *job, char *side, int *n, int *ilo, int *ihi, d *scale, int *m, d *v, int *ldv, int *info) noexcept nogil: + + _fortran_dgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgebal "BLAS_FUNC(dgebal)"(char *job, int *n, d *a, int *lda, int *ilo, int *ihi, d *scale, int *info) nogil +cdef void dgebal(char *job, int *n, d *a, int *lda, int *ilo, int *ihi, d *scale, int *info) noexcept nogil: + + _fortran_dgebal(job, n, a, lda, ilo, ihi, scale, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgebd2 "BLAS_FUNC(dgebd2)"(int *m, int *n, d *a, int *lda, d *d, d *e, d *tauq, d *taup, d *work, int *info) nogil +cdef void dgebd2(int *m, int *n, d *a, int *lda, d *d, d *e, d *tauq, d *taup, d *work, int *info) noexcept nogil: + + _fortran_dgebd2(m, n, a, lda, d, e, tauq, taup, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgebrd "BLAS_FUNC(dgebrd)"(int *m, int *n, d *a, int *lda, d *d, d *e, d *tauq, d *taup, d *work, int *lwork, int *info) nogil +cdef void dgebrd(int *m, int *n, d *a, int *lda, d *d, d *e, d *tauq, d *taup, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgecon "BLAS_FUNC(dgecon)"(char *norm, int *n, d *a, int *lda, d *anorm, d *rcond, d *work, int *iwork, int *info) nogil +cdef void dgecon(char *norm, int *n, d *a, int *lda, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dgecon(norm, n, a, lda, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeequ "BLAS_FUNC(dgeequ)"(int *m, int *n, d *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) nogil +cdef void dgeequ(int *m, int *n, d *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil: + + _fortran_dgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeequb "BLAS_FUNC(dgeequb)"(int *m, int *n, d *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) nogil +cdef void dgeequb(int *m, int *n, d *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil: + + _fortran_dgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgees "BLAS_FUNC(dgees)"(char *jobvs, char *sort, _dselect2 *select, int *n, d *a, int *lda, int *sdim, d *wr, d *wi, d *vs, int *ldvs, d *work, int *lwork, bint *bwork, int *info) nogil +cdef void dgees(char *jobvs, char *sort, dselect2 *select, int *n, d *a, int *lda, int *sdim, d *wr, d *wi, d *vs, int *ldvs, d *work, int *lwork, bint *bwork, int *info) noexcept nogil: + + _fortran_dgees(jobvs, sort, <_dselect2*>select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeesx "BLAS_FUNC(dgeesx)"(char *jobvs, char *sort, _dselect2 *select, char *sense, int *n, d *a, int *lda, int *sdim, d *wr, d *wi, d *vs, int *ldvs, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) nogil +cdef void dgeesx(char *jobvs, char *sort, dselect2 *select, char *sense, int *n, d *a, int *lda, int *sdim, d *wr, d *wi, d *vs, int *ldvs, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil: + + _fortran_dgeesx(jobvs, sort, <_dselect2*>select, sense, n, a, lda, sdim, wr, wi, vs, ldvs, rconde, rcondv, work, lwork, iwork, liwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeev "BLAS_FUNC(dgeev)"(char *jobvl, char *jobvr, int *n, d *a, int *lda, d *wr, d *wi, d *vl, int *ldvl, d *vr, int *ldvr, d *work, int *lwork, int *info) nogil +cdef void dgeev(char *jobvl, char *jobvr, int *n, d *a, int *lda, d *wr, d *wi, d *vl, int *ldvl, d *vr, int *ldvr, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeevx "BLAS_FUNC(dgeevx)"(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, d *a, int *lda, d *wr, d *wi, d *vl, int *ldvl, d *vr, int *ldvr, int *ilo, int *ihi, d *scale, d *abnrm, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, int *info) nogil +cdef void dgeevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, d *a, int *lda, d *wr, d *wi, d *vl, int *ldvl, d *vr, int *ldvr, int *ilo, int *ihi, d *scale, d *abnrm, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_dgeevx(balanc, jobvl, jobvr, sense, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, ilo, ihi, scale, abnrm, rconde, rcondv, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgehd2 "BLAS_FUNC(dgehd2)"(int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *work, int *info) nogil +cdef void dgehd2(int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil: + + _fortran_dgehd2(n, ilo, ihi, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgehrd "BLAS_FUNC(dgehrd)"(int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dgehrd(int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgejsv "BLAS_FUNC(dgejsv)"(char *joba, char *jobu, char *jobv, char *jobr, char *jobt, char *jobp, int *m, int *n, d *a, int *lda, d *sva, d *u, int *ldu, d *v, int *ldv, d *work, int *lwork, int *iwork, int *info) nogil +cdef void dgejsv(char *joba, char *jobu, char *jobv, char *jobr, char *jobt, char *jobp, int *m, int *n, d *a, int *lda, d *sva, d *u, int *ldu, d *v, int *ldv, d *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_dgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgelq2 "BLAS_FUNC(dgelq2)"(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) nogil +cdef void dgelq2(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil: + + _fortran_dgelq2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgelqf "BLAS_FUNC(dgelqf)"(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dgelqf(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgelqf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgels "BLAS_FUNC(dgels)"(char *trans, int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *work, int *lwork, int *info) nogil +cdef void dgels(char *trans, int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgelsd "BLAS_FUNC(dgelsd)"(int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *s, d *rcond, int *rank, d *work, int *lwork, int *iwork, int *info) nogil +cdef void dgelsd(int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *s, d *rcond, int *rank, d *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_dgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgelss "BLAS_FUNC(dgelss)"(int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *s, d *rcond, int *rank, d *work, int *lwork, int *info) nogil +cdef void dgelss(int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *s, d *rcond, int *rank, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgelsy "BLAS_FUNC(dgelsy)"(int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *jpvt, d *rcond, int *rank, d *work, int *lwork, int *info) nogil +cdef void dgelsy(int *m, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *jpvt, d *rcond, int *rank, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgemqrt "BLAS_FUNC(dgemqrt)"(char *side, char *trans, int *m, int *n, int *k, int *nb, d *v, int *ldv, d *t, int *ldt, d *c, int *ldc, d *work, int *info) nogil +cdef void dgemqrt(char *side, char *trans, int *m, int *n, int *k, int *nb, d *v, int *ldv, d *t, int *ldt, d *c, int *ldc, d *work, int *info) noexcept nogil: + + _fortran_dgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeql2 "BLAS_FUNC(dgeql2)"(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) nogil +cdef void dgeql2(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil: + + _fortran_dgeql2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeqlf "BLAS_FUNC(dgeqlf)"(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dgeqlf(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgeqlf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeqp3 "BLAS_FUNC(dgeqp3)"(int *m, int *n, d *a, int *lda, int *jpvt, d *tau, d *work, int *lwork, int *info) nogil +cdef void dgeqp3(int *m, int *n, d *a, int *lda, int *jpvt, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgeqp3(m, n, a, lda, jpvt, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeqr2 "BLAS_FUNC(dgeqr2)"(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) nogil +cdef void dgeqr2(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil: + + _fortran_dgeqr2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeqr2p "BLAS_FUNC(dgeqr2p)"(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) nogil +cdef void dgeqr2p(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil: + + _fortran_dgeqr2p(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeqrf "BLAS_FUNC(dgeqrf)"(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dgeqrf(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgeqrf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeqrfp "BLAS_FUNC(dgeqrfp)"(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dgeqrfp(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgeqrfp(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeqrt "BLAS_FUNC(dgeqrt)"(int *m, int *n, int *nb, d *a, int *lda, d *t, int *ldt, d *work, int *info) nogil +cdef void dgeqrt(int *m, int *n, int *nb, d *a, int *lda, d *t, int *ldt, d *work, int *info) noexcept nogil: + + _fortran_dgeqrt(m, n, nb, a, lda, t, ldt, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeqrt2 "BLAS_FUNC(dgeqrt2)"(int *m, int *n, d *a, int *lda, d *t, int *ldt, int *info) nogil +cdef void dgeqrt2(int *m, int *n, d *a, int *lda, d *t, int *ldt, int *info) noexcept nogil: + + _fortran_dgeqrt2(m, n, a, lda, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgeqrt3 "BLAS_FUNC(dgeqrt3)"(int *m, int *n, d *a, int *lda, d *t, int *ldt, int *info) nogil +cdef void dgeqrt3(int *m, int *n, d *a, int *lda, d *t, int *ldt, int *info) noexcept nogil: + + _fortran_dgeqrt3(m, n, a, lda, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgerfs "BLAS_FUNC(dgerfs)"(char *trans, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dgerfs(char *trans, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgerq2 "BLAS_FUNC(dgerq2)"(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) nogil +cdef void dgerq2(int *m, int *n, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil: + + _fortran_dgerq2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgerqf "BLAS_FUNC(dgerqf)"(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dgerqf(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgerqf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgesc2 "BLAS_FUNC(dgesc2)"(int *n, d *a, int *lda, d *rhs, int *ipiv, int *jpiv, d *scale) nogil +cdef void dgesc2(int *n, d *a, int *lda, d *rhs, int *ipiv, int *jpiv, d *scale) noexcept nogil: + + _fortran_dgesc2(n, a, lda, rhs, ipiv, jpiv, scale) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgesdd "BLAS_FUNC(dgesdd)"(char *jobz, int *m, int *n, d *a, int *lda, d *s, d *u, int *ldu, d *vt, int *ldvt, d *work, int *lwork, int *iwork, int *info) nogil +cdef void dgesdd(char *jobz, int *m, int *n, d *a, int *lda, d *s, d *u, int *ldu, d *vt, int *ldvt, d *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_dgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgesv "BLAS_FUNC(dgesv)"(int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, int *info) nogil +cdef void dgesv(int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dgesv(n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgesvd "BLAS_FUNC(dgesvd)"(char *jobu, char *jobvt, int *m, int *n, d *a, int *lda, d *s, d *u, int *ldu, d *vt, int *ldvt, d *work, int *lwork, int *info) nogil +cdef void dgesvd(char *jobu, char *jobvt, int *m, int *n, d *a, int *lda, d *s, d *u, int *ldu, d *vt, int *ldvt, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgesvj "BLAS_FUNC(dgesvj)"(char *joba, char *jobu, char *jobv, int *m, int *n, d *a, int *lda, d *sva, int *mv, d *v, int *ldv, d *work, int *lwork, int *info) nogil +cdef void dgesvj(char *joba, char *jobu, char *jobv, int *m, int *n, d *a, int *lda, d *sva, int *mv, d *v, int *ldv, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgesvx "BLAS_FUNC(dgesvx)"(char *fact, char *trans, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, char *equed, d *r, d *c, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dgesvx(char *fact, char *trans, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, char *equed, d *r, d *c, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dgesvx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgetc2 "BLAS_FUNC(dgetc2)"(int *n, d *a, int *lda, int *ipiv, int *jpiv, int *info) nogil +cdef void dgetc2(int *n, d *a, int *lda, int *ipiv, int *jpiv, int *info) noexcept nogil: + + _fortran_dgetc2(n, a, lda, ipiv, jpiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgetf2 "BLAS_FUNC(dgetf2)"(int *m, int *n, d *a, int *lda, int *ipiv, int *info) nogil +cdef void dgetf2(int *m, int *n, d *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_dgetf2(m, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgetrf "BLAS_FUNC(dgetrf)"(int *m, int *n, d *a, int *lda, int *ipiv, int *info) nogil +cdef void dgetrf(int *m, int *n, d *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_dgetrf(m, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgetri "BLAS_FUNC(dgetri)"(int *n, d *a, int *lda, int *ipiv, d *work, int *lwork, int *info) nogil +cdef void dgetri(int *n, d *a, int *lda, int *ipiv, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgetri(n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgetrs "BLAS_FUNC(dgetrs)"(char *trans, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, int *info) nogil +cdef void dgetrs(char *trans, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dggbak "BLAS_FUNC(dggbak)"(char *job, char *side, int *n, int *ilo, int *ihi, d *lscale, d *rscale, int *m, d *v, int *ldv, int *info) nogil +cdef void dggbak(char *job, char *side, int *n, int *ilo, int *ihi, d *lscale, d *rscale, int *m, d *v, int *ldv, int *info) noexcept nogil: + + _fortran_dggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dggbal "BLAS_FUNC(dggbal)"(char *job, int *n, d *a, int *lda, d *b, int *ldb, int *ilo, int *ihi, d *lscale, d *rscale, d *work, int *info) nogil +cdef void dggbal(char *job, int *n, d *a, int *lda, d *b, int *ldb, int *ilo, int *ihi, d *lscale, d *rscale, d *work, int *info) noexcept nogil: + + _fortran_dggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgges "BLAS_FUNC(dgges)"(char *jobvsl, char *jobvsr, char *sort, _dselect3 *selctg, int *n, d *a, int *lda, d *b, int *ldb, int *sdim, d *alphar, d *alphai, d *beta, d *vsl, int *ldvsl, d *vsr, int *ldvsr, d *work, int *lwork, bint *bwork, int *info) nogil +cdef void dgges(char *jobvsl, char *jobvsr, char *sort, dselect3 *selctg, int *n, d *a, int *lda, d *b, int *ldb, int *sdim, d *alphar, d *alphai, d *beta, d *vsl, int *ldvsl, d *vsr, int *ldvsr, d *work, int *lwork, bint *bwork, int *info) noexcept nogil: + + _fortran_dgges(jobvsl, jobvsr, sort, <_dselect3*>selctg, n, a, lda, b, ldb, sdim, alphar, alphai, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dggesx "BLAS_FUNC(dggesx)"(char *jobvsl, char *jobvsr, char *sort, _dselect3 *selctg, char *sense, int *n, d *a, int *lda, d *b, int *ldb, int *sdim, d *alphar, d *alphai, d *beta, d *vsl, int *ldvsl, d *vsr, int *ldvsr, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) nogil +cdef void dggesx(char *jobvsl, char *jobvsr, char *sort, dselect3 *selctg, char *sense, int *n, d *a, int *lda, d *b, int *ldb, int *sdim, d *alphar, d *alphai, d *beta, d *vsl, int *ldvsl, d *vsr, int *ldvsr, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil: + + _fortran_dggesx(jobvsl, jobvsr, sort, <_dselect3*>selctg, sense, n, a, lda, b, ldb, sdim, alphar, alphai, beta, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, iwork, liwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dggev "BLAS_FUNC(dggev)"(char *jobvl, char *jobvr, int *n, d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *vl, int *ldvl, d *vr, int *ldvr, d *work, int *lwork, int *info) nogil +cdef void dggev(char *jobvl, char *jobvr, int *n, d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *vl, int *ldvl, d *vr, int *ldvr, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dggev(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dggevx "BLAS_FUNC(dggevx)"(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *vl, int *ldvl, d *vr, int *ldvr, int *ilo, int *ihi, d *lscale, d *rscale, d *abnrm, d *bbnrm, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, bint *bwork, int *info) nogil +cdef void dggevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *vl, int *ldvl, d *vr, int *ldvr, int *ilo, int *ihi, d *lscale, d *rscale, d *abnrm, d *bbnrm, d *rconde, d *rcondv, d *work, int *lwork, int *iwork, bint *bwork, int *info) noexcept nogil: + + _fortran_dggevx(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, iwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dggglm "BLAS_FUNC(dggglm)"(int *n, int *m, int *p, d *a, int *lda, d *b, int *ldb, d *d, d *x, d *y, d *work, int *lwork, int *info) nogil +cdef void dggglm(int *n, int *m, int *p, d *a, int *lda, d *b, int *ldb, d *d, d *x, d *y, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgghrd "BLAS_FUNC(dgghrd)"(char *compq, char *compz, int *n, int *ilo, int *ihi, d *a, int *lda, d *b, int *ldb, d *q, int *ldq, d *z, int *ldz, int *info) nogil +cdef void dgghrd(char *compq, char *compz, int *n, int *ilo, int *ihi, d *a, int *lda, d *b, int *ldb, d *q, int *ldq, d *z, int *ldz, int *info) noexcept nogil: + + _fortran_dgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgglse "BLAS_FUNC(dgglse)"(int *m, int *n, int *p, d *a, int *lda, d *b, int *ldb, d *c, d *d, d *x, d *work, int *lwork, int *info) nogil +cdef void dgglse(int *m, int *n, int *p, d *a, int *lda, d *b, int *ldb, d *c, d *d, d *x, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dggqrf "BLAS_FUNC(dggqrf)"(int *n, int *m, int *p, d *a, int *lda, d *taua, d *b, int *ldb, d *taub, d *work, int *lwork, int *info) nogil +cdef void dggqrf(int *n, int *m, int *p, d *a, int *lda, d *taua, d *b, int *ldb, d *taub, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dggrqf "BLAS_FUNC(dggrqf)"(int *m, int *p, int *n, d *a, int *lda, d *taua, d *b, int *ldb, d *taub, d *work, int *lwork, int *info) nogil +cdef void dggrqf(int *m, int *p, int *n, d *a, int *lda, d *taua, d *b, int *ldb, d *taub, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgsvj0 "BLAS_FUNC(dgsvj0)"(char *jobv, int *m, int *n, d *a, int *lda, d *d, d *sva, int *mv, d *v, int *ldv, d *eps, d *sfmin, d *tol, int *nsweep, d *work, int *lwork, int *info) nogil +cdef void dgsvj0(char *jobv, int *m, int *n, d *a, int *lda, d *d, d *sva, int *mv, d *v, int *ldv, d *eps, d *sfmin, d *tol, int *nsweep, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgsvj1 "BLAS_FUNC(dgsvj1)"(char *jobv, int *m, int *n, int *n1, d *a, int *lda, d *d, d *sva, int *mv, d *v, int *ldv, d *eps, d *sfmin, d *tol, int *nsweep, d *work, int *lwork, int *info) nogil +cdef void dgsvj1(char *jobv, int *m, int *n, int *n1, d *a, int *lda, d *d, d *sva, int *mv, d *v, int *ldv, d *eps, d *sfmin, d *tol, int *nsweep, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgtcon "BLAS_FUNC(dgtcon)"(char *norm, int *n, d *dl, d *d, d *du, d *du2, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) nogil +cdef void dgtcon(char *norm, int *n, d *dl, d *d, d *du, d *du2, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgtrfs "BLAS_FUNC(dgtrfs)"(char *trans, int *n, int *nrhs, d *dl, d *d, d *du, d *dlf, d *df, d *duf, d *du2, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dgtrfs(char *trans, int *n, int *nrhs, d *dl, d *d, d *du, d *dlf, d *df, d *duf, d *du2, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgtsv "BLAS_FUNC(dgtsv)"(int *n, int *nrhs, d *dl, d *d, d *du, d *b, int *ldb, int *info) nogil +cdef void dgtsv(int *n, int *nrhs, d *dl, d *d, d *du, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dgtsv(n, nrhs, dl, d, du, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgtsvx "BLAS_FUNC(dgtsvx)"(char *fact, char *trans, int *n, int *nrhs, d *dl, d *d, d *du, d *dlf, d *df, d *duf, d *du2, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dgtsvx(char *fact, char *trans, int *n, int *nrhs, d *dl, d *d, d *du, d *dlf, d *df, d *duf, d *du2, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dgtsvx(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgttrf "BLAS_FUNC(dgttrf)"(int *n, d *dl, d *d, d *du, d *du2, int *ipiv, int *info) nogil +cdef void dgttrf(int *n, d *dl, d *d, d *du, d *du2, int *ipiv, int *info) noexcept nogil: + + _fortran_dgttrf(n, dl, d, du, du2, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgttrs "BLAS_FUNC(dgttrs)"(char *trans, int *n, int *nrhs, d *dl, d *d, d *du, d *du2, int *ipiv, d *b, int *ldb, int *info) nogil +cdef void dgttrs(char *trans, int *n, int *nrhs, d *dl, d *d, d *du, d *du2, int *ipiv, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dgtts2 "BLAS_FUNC(dgtts2)"(int *itrans, int *n, int *nrhs, d *dl, d *d, d *du, d *du2, int *ipiv, d *b, int *ldb) nogil +cdef void dgtts2(int *itrans, int *n, int *nrhs, d *dl, d *d, d *du, d *du2, int *ipiv, d *b, int *ldb) noexcept nogil: + + _fortran_dgtts2(itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dhgeqz "BLAS_FUNC(dhgeqz)"(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *t, int *ldt, d *alphar, d *alphai, d *beta, d *q, int *ldq, d *z, int *ldz, d *work, int *lwork, int *info) nogil +cdef void dhgeqz(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *t, int *ldt, d *alphar, d *alphai, d *beta, d *q, int *ldq, d *z, int *ldz, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dhgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dhsein "BLAS_FUNC(dhsein)"(char *side, char *eigsrc, char *initv, bint *select, int *n, d *h, int *ldh, d *wr, d *wi, d *vl, int *ldvl, d *vr, int *ldvr, int *mm, int *m, d *work, int *ifaill, int *ifailr, int *info) nogil +cdef void dhsein(char *side, char *eigsrc, char *initv, bint *select, int *n, d *h, int *ldh, d *wr, d *wi, d *vl, int *ldvl, d *vr, int *ldvr, int *mm, int *m, d *work, int *ifaill, int *ifailr, int *info) noexcept nogil: + + _fortran_dhsein(side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dhseqr "BLAS_FUNC(dhseqr)"(char *job, char *compz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, d *z, int *ldz, d *work, int *lwork, int *info) nogil +cdef void dhseqr(char *job, char *compz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, d *z, int *ldz, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dhseqr(job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + bint _fortran_disnan "BLAS_FUNC(disnan)"(d *din) nogil +cdef bint disnan(d *din) noexcept nogil: + + return _fortran_disnan(din) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlabad "BLAS_FUNC(dlabad)"(d *small, d *large) nogil +cdef void dlabad(d *small, d *large) noexcept nogil: + + _fortran_dlabad(small, large) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlabrd "BLAS_FUNC(dlabrd)"(int *m, int *n, int *nb, d *a, int *lda, d *d, d *e, d *tauq, d *taup, d *x, int *ldx, d *y, int *ldy) nogil +cdef void dlabrd(int *m, int *n, int *nb, d *a, int *lda, d *d, d *e, d *tauq, d *taup, d *x, int *ldx, d *y, int *ldy) noexcept nogil: + + _fortran_dlabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlacn2 "BLAS_FUNC(dlacn2)"(int *n, d *v, d *x, int *isgn, d *est, int *kase, int *isave) nogil +cdef void dlacn2(int *n, d *v, d *x, int *isgn, d *est, int *kase, int *isave) noexcept nogil: + + _fortran_dlacn2(n, v, x, isgn, est, kase, isave) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlacon "BLAS_FUNC(dlacon)"(int *n, d *v, d *x, int *isgn, d *est, int *kase) nogil +cdef void dlacon(int *n, d *v, d *x, int *isgn, d *est, int *kase) noexcept nogil: + + _fortran_dlacon(n, v, x, isgn, est, kase) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlacpy "BLAS_FUNC(dlacpy)"(char *uplo, int *m, int *n, d *a, int *lda, d *b, int *ldb) nogil +cdef void dlacpy(char *uplo, int *m, int *n, d *a, int *lda, d *b, int *ldb) noexcept nogil: + + _fortran_dlacpy(uplo, m, n, a, lda, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dladiv "BLAS_FUNC(dladiv)"(d *a, d *b, d *c, d *d, d *p, d *q) nogil +cdef void dladiv(d *a, d *b, d *c, d *d, d *p, d *q) noexcept nogil: + + _fortran_dladiv(a, b, c, d, p, q) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlae2 "BLAS_FUNC(dlae2)"(d *a, d *b, d *c, d *rt1, d *rt2) nogil +cdef void dlae2(d *a, d *b, d *c, d *rt1, d *rt2) noexcept nogil: + + _fortran_dlae2(a, b, c, rt1, rt2) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaebz "BLAS_FUNC(dlaebz)"(int *ijob, int *nitmax, int *n, int *mmax, int *minp, int *nbmin, d *abstol, d *reltol, d *pivmin, d *d, d *e, d *e2, int *nval, d *ab, d *c, int *mout, int *nab, d *work, int *iwork, int *info) nogil +cdef void dlaebz(int *ijob, int *nitmax, int *n, int *mmax, int *minp, int *nbmin, d *abstol, d *reltol, d *pivmin, d *d, d *e, d *e2, int *nval, d *ab, d *c, int *mout, int *nab, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dlaebz(ijob, nitmax, n, mmax, minp, nbmin, abstol, reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaed0 "BLAS_FUNC(dlaed0)"(int *icompq, int *qsiz, int *n, d *d, d *e, d *q, int *ldq, d *qstore, int *ldqs, d *work, int *iwork, int *info) nogil +cdef void dlaed0(int *icompq, int *qsiz, int *n, d *d, d *e, d *q, int *ldq, d *qstore, int *ldqs, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dlaed0(icompq, qsiz, n, d, e, q, ldq, qstore, ldqs, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaed1 "BLAS_FUNC(dlaed1)"(int *n, d *d, d *q, int *ldq, int *indxq, d *rho, int *cutpnt, d *work, int *iwork, int *info) nogil +cdef void dlaed1(int *n, d *d, d *q, int *ldq, int *indxq, d *rho, int *cutpnt, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dlaed1(n, d, q, ldq, indxq, rho, cutpnt, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaed2 "BLAS_FUNC(dlaed2)"(int *k, int *n, int *n1, d *d, d *q, int *ldq, int *indxq, d *rho, d *z, d *dlamda, d *w, d *q2, int *indx, int *indxc, int *indxp, int *coltyp, int *info) nogil +cdef void dlaed2(int *k, int *n, int *n1, d *d, d *q, int *ldq, int *indxq, d *rho, d *z, d *dlamda, d *w, d *q2, int *indx, int *indxc, int *indxp, int *coltyp, int *info) noexcept nogil: + + _fortran_dlaed2(k, n, n1, d, q, ldq, indxq, rho, z, dlamda, w, q2, indx, indxc, indxp, coltyp, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaed3 "BLAS_FUNC(dlaed3)"(int *k, int *n, int *n1, d *d, d *q, int *ldq, d *rho, d *dlamda, d *q2, int *indx, int *ctot, d *w, d *s, int *info) nogil +cdef void dlaed3(int *k, int *n, int *n1, d *d, d *q, int *ldq, d *rho, d *dlamda, d *q2, int *indx, int *ctot, d *w, d *s, int *info) noexcept nogil: + + _fortran_dlaed3(k, n, n1, d, q, ldq, rho, dlamda, q2, indx, ctot, w, s, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaed4 "BLAS_FUNC(dlaed4)"(int *n, int *i, d *d, d *z, d *delta, d *rho, d *dlam, int *info) nogil +cdef void dlaed4(int *n, int *i, d *d, d *z, d *delta, d *rho, d *dlam, int *info) noexcept nogil: + + _fortran_dlaed4(n, i, d, z, delta, rho, dlam, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaed5 "BLAS_FUNC(dlaed5)"(int *i, d *d, d *z, d *delta, d *rho, d *dlam) nogil +cdef void dlaed5(int *i, d *d, d *z, d *delta, d *rho, d *dlam) noexcept nogil: + + _fortran_dlaed5(i, d, z, delta, rho, dlam) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaed6 "BLAS_FUNC(dlaed6)"(int *kniter, bint *orgati, d *rho, d *d, d *z, d *finit, d *tau, int *info) nogil +cdef void dlaed6(int *kniter, bint *orgati, d *rho, d *d, d *z, d *finit, d *tau, int *info) noexcept nogil: + + _fortran_dlaed6(kniter, orgati, rho, d, z, finit, tau, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaed7 "BLAS_FUNC(dlaed7)"(int *icompq, int *n, int *qsiz, int *tlvls, int *curlvl, int *curpbm, d *d, d *q, int *ldq, int *indxq, d *rho, int *cutpnt, d *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, d *givnum, d *work, int *iwork, int *info) nogil +cdef void dlaed7(int *icompq, int *n, int *qsiz, int *tlvls, int *curlvl, int *curpbm, d *d, d *q, int *ldq, int *indxq, d *rho, int *cutpnt, d *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, d *givnum, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dlaed7(icompq, n, qsiz, tlvls, curlvl, curpbm, d, q, ldq, indxq, rho, cutpnt, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaed8 "BLAS_FUNC(dlaed8)"(int *icompq, int *k, int *n, int *qsiz, d *d, d *q, int *ldq, int *indxq, d *rho, int *cutpnt, d *z, d *dlamda, d *q2, int *ldq2, d *w, int *perm, int *givptr, int *givcol, d *givnum, int *indxp, int *indx, int *info) nogil +cdef void dlaed8(int *icompq, int *k, int *n, int *qsiz, d *d, d *q, int *ldq, int *indxq, d *rho, int *cutpnt, d *z, d *dlamda, d *q2, int *ldq2, d *w, int *perm, int *givptr, int *givcol, d *givnum, int *indxp, int *indx, int *info) noexcept nogil: + + _fortran_dlaed8(icompq, k, n, qsiz, d, q, ldq, indxq, rho, cutpnt, z, dlamda, q2, ldq2, w, perm, givptr, givcol, givnum, indxp, indx, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaed9 "BLAS_FUNC(dlaed9)"(int *k, int *kstart, int *kstop, int *n, d *d, d *q, int *ldq, d *rho, d *dlamda, d *w, d *s, int *lds, int *info) nogil +cdef void dlaed9(int *k, int *kstart, int *kstop, int *n, d *d, d *q, int *ldq, d *rho, d *dlamda, d *w, d *s, int *lds, int *info) noexcept nogil: + + _fortran_dlaed9(k, kstart, kstop, n, d, q, ldq, rho, dlamda, w, s, lds, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaeda "BLAS_FUNC(dlaeda)"(int *n, int *tlvls, int *curlvl, int *curpbm, int *prmptr, int *perm, int *givptr, int *givcol, d *givnum, d *q, int *qptr, d *z, d *ztemp, int *info) nogil +cdef void dlaeda(int *n, int *tlvls, int *curlvl, int *curpbm, int *prmptr, int *perm, int *givptr, int *givcol, d *givnum, d *q, int *qptr, d *z, d *ztemp, int *info) noexcept nogil: + + _fortran_dlaeda(n, tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, z, ztemp, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaein "BLAS_FUNC(dlaein)"(bint *rightv, bint *noinit, int *n, d *h, int *ldh, d *wr, d *wi, d *vr, d *vi, d *b, int *ldb, d *work, d *eps3, d *smlnum, d *bignum, int *info) nogil +cdef void dlaein(bint *rightv, bint *noinit, int *n, d *h, int *ldh, d *wr, d *wi, d *vr, d *vi, d *b, int *ldb, d *work, d *eps3, d *smlnum, d *bignum, int *info) noexcept nogil: + + _fortran_dlaein(rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb, work, eps3, smlnum, bignum, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaev2 "BLAS_FUNC(dlaev2)"(d *a, d *b, d *c, d *rt1, d *rt2, d *cs1, d *sn1) nogil +cdef void dlaev2(d *a, d *b, d *c, d *rt1, d *rt2, d *cs1, d *sn1) noexcept nogil: + + _fortran_dlaev2(a, b, c, rt1, rt2, cs1, sn1) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaexc "BLAS_FUNC(dlaexc)"(bint *wantq, int *n, d *t, int *ldt, d *q, int *ldq, int *j1, int *n1, int *n2, d *work, int *info) nogil +cdef void dlaexc(bint *wantq, int *n, d *t, int *ldt, d *q, int *ldq, int *j1, int *n1, int *n2, d *work, int *info) noexcept nogil: + + _fortran_dlaexc(wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlag2 "BLAS_FUNC(dlag2)"(d *a, int *lda, d *b, int *ldb, d *safmin, d *scale1, d *scale2, d *wr1, d *wr2, d *wi) nogil +cdef void dlag2(d *a, int *lda, d *b, int *ldb, d *safmin, d *scale1, d *scale2, d *wr1, d *wr2, d *wi) noexcept nogil: + + _fortran_dlag2(a, lda, b, ldb, safmin, scale1, scale2, wr1, wr2, wi) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlag2s "BLAS_FUNC(dlag2s)"(int *m, int *n, d *a, int *lda, s *sa, int *ldsa, int *info) nogil +cdef void dlag2s(int *m, int *n, d *a, int *lda, s *sa, int *ldsa, int *info) noexcept nogil: + + _fortran_dlag2s(m, n, a, lda, sa, ldsa, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlags2 "BLAS_FUNC(dlags2)"(bint *upper, d *a1, d *a2, d *a3, d *b1, d *b2, d *b3, d *csu, d *snu, d *csv, d *snv, d *csq, d *snq) nogil +cdef void dlags2(bint *upper, d *a1, d *a2, d *a3, d *b1, d *b2, d *b3, d *csu, d *snu, d *csv, d *snv, d *csq, d *snq) noexcept nogil: + + _fortran_dlags2(upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlagtf "BLAS_FUNC(dlagtf)"(int *n, d *a, d *lambda_, d *b, d *c, d *tol, d *d, int *in_, int *info) nogil +cdef void dlagtf(int *n, d *a, d *lambda_, d *b, d *c, d *tol, d *d, int *in_, int *info) noexcept nogil: + + _fortran_dlagtf(n, a, lambda_, b, c, tol, d, in_, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlagtm "BLAS_FUNC(dlagtm)"(char *trans, int *n, int *nrhs, d *alpha, d *dl, d *d, d *du, d *x, int *ldx, d *beta, d *b, int *ldb) nogil +cdef void dlagtm(char *trans, int *n, int *nrhs, d *alpha, d *dl, d *d, d *du, d *x, int *ldx, d *beta, d *b, int *ldb) noexcept nogil: + + _fortran_dlagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlagts "BLAS_FUNC(dlagts)"(int *job, int *n, d *a, d *b, d *c, d *d, int *in_, d *y, d *tol, int *info) nogil +cdef void dlagts(int *job, int *n, d *a, d *b, d *c, d *d, int *in_, d *y, d *tol, int *info) noexcept nogil: + + _fortran_dlagts(job, n, a, b, c, d, in_, y, tol, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlagv2 "BLAS_FUNC(dlagv2)"(d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *csl, d *snl, d *csr, d *snr) nogil +cdef void dlagv2(d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *csl, d *snl, d *csr, d *snr) noexcept nogil: + + _fortran_dlagv2(a, lda, b, ldb, alphar, alphai, beta, csl, snl, csr, snr) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlahqr "BLAS_FUNC(dlahqr)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, int *iloz, int *ihiz, d *z, int *ldz, int *info) nogil +cdef void dlahqr(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, int *iloz, int *ihiz, d *z, int *ldz, int *info) noexcept nogil: + + _fortran_dlahqr(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlahr2 "BLAS_FUNC(dlahr2)"(int *n, int *k, int *nb, d *a, int *lda, d *tau, d *t, int *ldt, d *y, int *ldy) nogil +cdef void dlahr2(int *n, int *k, int *nb, d *a, int *lda, d *tau, d *t, int *ldt, d *y, int *ldy) noexcept nogil: + + _fortran_dlahr2(n, k, nb, a, lda, tau, t, ldt, y, ldy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaic1 "BLAS_FUNC(dlaic1)"(int *job, int *j, d *x, d *sest, d *w, d *gamma, d *sestpr, d *s, d *c) nogil +cdef void dlaic1(int *job, int *j, d *x, d *sest, d *w, d *gamma, d *sestpr, d *s, d *c) noexcept nogil: + + _fortran_dlaic1(job, j, x, sest, w, gamma, sestpr, s, c) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaln2 "BLAS_FUNC(dlaln2)"(bint *ltrans, int *na, int *nw, d *smin, d *ca, d *a, int *lda, d *d1, d *d2, d *b, int *ldb, d *wr, d *wi, d *x, int *ldx, d *scale, d *xnorm, int *info) nogil +cdef void dlaln2(bint *ltrans, int *na, int *nw, d *smin, d *ca, d *a, int *lda, d *d1, d *d2, d *b, int *ldb, d *wr, d *wi, d *x, int *ldx, d *scale, d *xnorm, int *info) noexcept nogil: + + _fortran_dlaln2(ltrans, na, nw, smin, ca, a, lda, d1, d2, b, ldb, wr, wi, x, ldx, scale, xnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlals0 "BLAS_FUNC(dlals0)"(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, d *b, int *ldb, d *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *poles, d *difl, d *difr, d *z, int *k, d *c, d *s, d *work, int *info) nogil +cdef void dlals0(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, d *b, int *ldb, d *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *poles, d *difl, d *difr, d *z, int *k, d *c, d *s, d *work, int *info) noexcept nogil: + + _fortran_dlals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlalsa "BLAS_FUNC(dlalsa)"(int *icompq, int *smlsiz, int *n, int *nrhs, d *b, int *ldb, d *bx, int *ldbx, d *u, int *ldu, d *vt, int *k, d *difl, d *difr, d *z, d *poles, int *givptr, int *givcol, int *ldgcol, int *perm, d *givnum, d *c, d *s, d *work, int *iwork, int *info) nogil +cdef void dlalsa(int *icompq, int *smlsiz, int *n, int *nrhs, d *b, int *ldb, d *bx, int *ldbx, d *u, int *ldu, d *vt, int *k, d *difl, d *difr, d *z, d *poles, int *givptr, int *givcol, int *ldgcol, int *perm, d *givnum, d *c, d *s, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dlalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlalsd "BLAS_FUNC(dlalsd)"(char *uplo, int *smlsiz, int *n, int *nrhs, d *d, d *e, d *b, int *ldb, d *rcond, int *rank, d *work, int *iwork, int *info) nogil +cdef void dlalsd(char *uplo, int *smlsiz, int *n, int *nrhs, d *d, d *e, d *b, int *ldb, d *rcond, int *rank, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dlalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlamch "BLAS_FUNC(dlamch)"(char *cmach) nogil +cdef d dlamch(char *cmach) noexcept nogil: + + return _fortran_dlamch(cmach) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlamrg "BLAS_FUNC(dlamrg)"(int *n1, int *n2, d *a, int *dtrd1, int *dtrd2, int *index_bn) nogil +cdef void dlamrg(int *n1, int *n2, d *a, int *dtrd1, int *dtrd2, int *index_bn) noexcept nogil: + + _fortran_dlamrg(n1, n2, a, dtrd1, dtrd2, index_bn) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_dlaneg "BLAS_FUNC(dlaneg)"(int *n, d *d, d *lld, d *sigma, d *pivmin, int *r) nogil +cdef int dlaneg(int *n, d *d, d *lld, d *sigma, d *pivmin, int *r) noexcept nogil: + + return _fortran_dlaneg(n, d, lld, sigma, pivmin, r) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlangb "BLAS_FUNC(dlangb)"(char *norm, int *n, int *kl, int *ku, d *ab, int *ldab, d *work) nogil +cdef d dlangb(char *norm, int *n, int *kl, int *ku, d *ab, int *ldab, d *work) noexcept nogil: + + return _fortran_dlangb(norm, n, kl, ku, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlange "BLAS_FUNC(dlange)"(char *norm, int *m, int *n, d *a, int *lda, d *work) nogil +cdef d dlange(char *norm, int *m, int *n, d *a, int *lda, d *work) noexcept nogil: + + return _fortran_dlange(norm, m, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlangt "BLAS_FUNC(dlangt)"(char *norm, int *n, d *dl, d *d_, d *du) nogil +cdef d dlangt(char *norm, int *n, d *dl, d *d_, d *du) noexcept nogil: + + return _fortran_dlangt(norm, n, dl, d_, du) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlanhs "BLAS_FUNC(dlanhs)"(char *norm, int *n, d *a, int *lda, d *work) nogil +cdef d dlanhs(char *norm, int *n, d *a, int *lda, d *work) noexcept nogil: + + return _fortran_dlanhs(norm, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlansb "BLAS_FUNC(dlansb)"(char *norm, char *uplo, int *n, int *k, d *ab, int *ldab, d *work) nogil +cdef d dlansb(char *norm, char *uplo, int *n, int *k, d *ab, int *ldab, d *work) noexcept nogil: + + return _fortran_dlansb(norm, uplo, n, k, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlansf "BLAS_FUNC(dlansf)"(char *norm, char *transr, char *uplo, int *n, d *a, d *work) nogil +cdef d dlansf(char *norm, char *transr, char *uplo, int *n, d *a, d *work) noexcept nogil: + + return _fortran_dlansf(norm, transr, uplo, n, a, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlansp "BLAS_FUNC(dlansp)"(char *norm, char *uplo, int *n, d *ap, d *work) nogil +cdef d dlansp(char *norm, char *uplo, int *n, d *ap, d *work) noexcept nogil: + + return _fortran_dlansp(norm, uplo, n, ap, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlanst "BLAS_FUNC(dlanst)"(char *norm, int *n, d *d_, d *e) nogil +cdef d dlanst(char *norm, int *n, d *d_, d *e) noexcept nogil: + + return _fortran_dlanst(norm, n, d_, e) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlansy "BLAS_FUNC(dlansy)"(char *norm, char *uplo, int *n, d *a, int *lda, d *work) nogil +cdef d dlansy(char *norm, char *uplo, int *n, d *a, int *lda, d *work) noexcept nogil: + + return _fortran_dlansy(norm, uplo, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlantb "BLAS_FUNC(dlantb)"(char *norm, char *uplo, char *diag, int *n, int *k, d *ab, int *ldab, d *work) nogil +cdef d dlantb(char *norm, char *uplo, char *diag, int *n, int *k, d *ab, int *ldab, d *work) noexcept nogil: + + return _fortran_dlantb(norm, uplo, diag, n, k, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlantp "BLAS_FUNC(dlantp)"(char *norm, char *uplo, char *diag, int *n, d *ap, d *work) nogil +cdef d dlantp(char *norm, char *uplo, char *diag, int *n, d *ap, d *work) noexcept nogil: + + return _fortran_dlantp(norm, uplo, diag, n, ap, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlantr "BLAS_FUNC(dlantr)"(char *norm, char *uplo, char *diag, int *m, int *n, d *a, int *lda, d *work) nogil +cdef d dlantr(char *norm, char *uplo, char *diag, int *m, int *n, d *a, int *lda, d *work) noexcept nogil: + + return _fortran_dlantr(norm, uplo, diag, m, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlanv2 "BLAS_FUNC(dlanv2)"(d *a, d *b, d *c, d *d, d *rt1r, d *rt1i, d *rt2r, d *rt2i, d *cs, d *sn) nogil +cdef void dlanv2(d *a, d *b, d *c, d *d, d *rt1r, d *rt1i, d *rt2r, d *rt2i, d *cs, d *sn) noexcept nogil: + + _fortran_dlanv2(a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlapll "BLAS_FUNC(dlapll)"(int *n, d *x, int *incx, d *y, int *incy, d *ssmin) nogil +cdef void dlapll(int *n, d *x, int *incx, d *y, int *incy, d *ssmin) noexcept nogil: + + _fortran_dlapll(n, x, incx, y, incy, ssmin) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlapmr "BLAS_FUNC(dlapmr)"(bint *forwrd, int *m, int *n, d *x, int *ldx, int *k) nogil +cdef void dlapmr(bint *forwrd, int *m, int *n, d *x, int *ldx, int *k) noexcept nogil: + + _fortran_dlapmr(forwrd, m, n, x, ldx, k) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlapmt "BLAS_FUNC(dlapmt)"(bint *forwrd, int *m, int *n, d *x, int *ldx, int *k) nogil +cdef void dlapmt(bint *forwrd, int *m, int *n, d *x, int *ldx, int *k) noexcept nogil: + + _fortran_dlapmt(forwrd, m, n, x, ldx, k) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlapy2 "BLAS_FUNC(dlapy2)"(d *x, d *y) nogil +cdef d dlapy2(d *x, d *y) noexcept nogil: + + return _fortran_dlapy2(x, y) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dlapy3 "BLAS_FUNC(dlapy3)"(d *x, d *y, d *z) nogil +cdef d dlapy3(d *x, d *y, d *z) noexcept nogil: + + return _fortran_dlapy3(x, y, z) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqgb "BLAS_FUNC(dlaqgb)"(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) nogil +cdef void dlaqgb(int *m, int *n, int *kl, int *ku, d *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) noexcept nogil: + + _fortran_dlaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqge "BLAS_FUNC(dlaqge)"(int *m, int *n, d *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) nogil +cdef void dlaqge(int *m, int *n, d *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) noexcept nogil: + + _fortran_dlaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqp2 "BLAS_FUNC(dlaqp2)"(int *m, int *n, int *offset, d *a, int *lda, int *jpvt, d *tau, d *vn1, d *vn2, d *work) nogil +cdef void dlaqp2(int *m, int *n, int *offset, d *a, int *lda, int *jpvt, d *tau, d *vn1, d *vn2, d *work) noexcept nogil: + + _fortran_dlaqp2(m, n, offset, a, lda, jpvt, tau, vn1, vn2, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqps "BLAS_FUNC(dlaqps)"(int *m, int *n, int *offset, int *nb, int *kb, d *a, int *lda, int *jpvt, d *tau, d *vn1, d *vn2, d *auxv, d *f, int *ldf) nogil +cdef void dlaqps(int *m, int *n, int *offset, int *nb, int *kb, d *a, int *lda, int *jpvt, d *tau, d *vn1, d *vn2, d *auxv, d *f, int *ldf) noexcept nogil: + + _fortran_dlaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqr0 "BLAS_FUNC(dlaqr0)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, int *iloz, int *ihiz, d *z, int *ldz, d *work, int *lwork, int *info) nogil +cdef void dlaqr0(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, int *iloz, int *ihiz, d *z, int *ldz, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dlaqr0(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqr1 "BLAS_FUNC(dlaqr1)"(int *n, d *h, int *ldh, d *sr1, d *si1, d *sr2, d *si2, d *v) nogil +cdef void dlaqr1(int *n, d *h, int *ldh, d *sr1, d *si1, d *sr2, d *si2, d *v) noexcept nogil: + + _fortran_dlaqr1(n, h, ldh, sr1, si1, sr2, si2, v) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqr2 "BLAS_FUNC(dlaqr2)"(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, d *h, int *ldh, int *iloz, int *ihiz, d *z, int *ldz, int *ns, int *nd, d *sr, d *si, d *v, int *ldv, int *nh, d *t, int *ldt, int *nv, d *wv, int *ldwv, d *work, int *lwork) nogil +cdef void dlaqr2(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, d *h, int *ldh, int *iloz, int *ihiz, d *z, int *ldz, int *ns, int *nd, d *sr, d *si, d *v, int *ldv, int *nh, d *t, int *ldt, int *nv, d *wv, int *ldwv, d *work, int *lwork) noexcept nogil: + + _fortran_dlaqr2(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqr3 "BLAS_FUNC(dlaqr3)"(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, d *h, int *ldh, int *iloz, int *ihiz, d *z, int *ldz, int *ns, int *nd, d *sr, d *si, d *v, int *ldv, int *nh, d *t, int *ldt, int *nv, d *wv, int *ldwv, d *work, int *lwork) nogil +cdef void dlaqr3(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, d *h, int *ldh, int *iloz, int *ihiz, d *z, int *ldz, int *ns, int *nd, d *sr, d *si, d *v, int *ldv, int *nh, d *t, int *ldt, int *nv, d *wv, int *ldwv, d *work, int *lwork) noexcept nogil: + + _fortran_dlaqr3(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqr4 "BLAS_FUNC(dlaqr4)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, int *iloz, int *ihiz, d *z, int *ldz, d *work, int *lwork, int *info) nogil +cdef void dlaqr4(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, d *h, int *ldh, d *wr, d *wi, int *iloz, int *ihiz, d *z, int *ldz, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dlaqr4(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqr5 "BLAS_FUNC(dlaqr5)"(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, d *sr, d *si, d *h, int *ldh, int *iloz, int *ihiz, d *z, int *ldz, d *v, int *ldv, d *u, int *ldu, int *nv, d *wv, int *ldwv, int *nh, d *wh, int *ldwh) nogil +cdef void dlaqr5(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, d *sr, d *si, d *h, int *ldh, int *iloz, int *ihiz, d *z, int *ldz, d *v, int *ldv, d *u, int *ldu, int *nv, d *wv, int *ldwv, int *nh, d *wh, int *ldwh) noexcept nogil: + + _fortran_dlaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, sr, si, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqsb "BLAS_FUNC(dlaqsb)"(char *uplo, int *n, int *kd, d *ab, int *ldab, d *s, d *scond, d *amax, char *equed) nogil +cdef void dlaqsb(char *uplo, int *n, int *kd, d *ab, int *ldab, d *s, d *scond, d *amax, char *equed) noexcept nogil: + + _fortran_dlaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqsp "BLAS_FUNC(dlaqsp)"(char *uplo, int *n, d *ap, d *s, d *scond, d *amax, char *equed) nogil +cdef void dlaqsp(char *uplo, int *n, d *ap, d *s, d *scond, d *amax, char *equed) noexcept nogil: + + _fortran_dlaqsp(uplo, n, ap, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqsy "BLAS_FUNC(dlaqsy)"(char *uplo, int *n, d *a, int *lda, d *s, d *scond, d *amax, char *equed) nogil +cdef void dlaqsy(char *uplo, int *n, d *a, int *lda, d *s, d *scond, d *amax, char *equed) noexcept nogil: + + _fortran_dlaqsy(uplo, n, a, lda, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaqtr "BLAS_FUNC(dlaqtr)"(bint *ltran, bint *lreal, int *n, d *t, int *ldt, d *b, d *w, d *scale, d *x, d *work, int *info) nogil +cdef void dlaqtr(bint *ltran, bint *lreal, int *n, d *t, int *ldt, d *b, d *w, d *scale, d *x, d *work, int *info) noexcept nogil: + + _fortran_dlaqtr(ltran, lreal, n, t, ldt, b, w, scale, x, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlar1v "BLAS_FUNC(dlar1v)"(int *n, int *b1, int *bn, d *lambda_, d *d, d *l, d *ld, d *lld, d *pivmin, d *gaptol, d *z, bint *wantnc, int *negcnt, d *ztz, d *mingma, int *r, int *isuppz, d *nrminv, d *resid, d *rqcorr, d *work) nogil +cdef void dlar1v(int *n, int *b1, int *bn, d *lambda_, d *d, d *l, d *ld, d *lld, d *pivmin, d *gaptol, d *z, bint *wantnc, int *negcnt, d *ztz, d *mingma, int *r, int *isuppz, d *nrminv, d *resid, d *rqcorr, d *work) noexcept nogil: + + _fortran_dlar1v(n, b1, bn, lambda_, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlar2v "BLAS_FUNC(dlar2v)"(int *n, d *x, d *y, d *z, int *incx, d *c, d *s, int *incc) nogil +cdef void dlar2v(int *n, d *x, d *y, d *z, int *incx, d *c, d *s, int *incc) noexcept nogil: + + _fortran_dlar2v(n, x, y, z, incx, c, s, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarf "BLAS_FUNC(dlarf)"(char *side, int *m, int *n, d *v, int *incv, d *tau, d *c, int *ldc, d *work) nogil +cdef void dlarf(char *side, int *m, int *n, d *v, int *incv, d *tau, d *c, int *ldc, d *work) noexcept nogil: + + _fortran_dlarf(side, m, n, v, incv, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarfb "BLAS_FUNC(dlarfb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, d *v, int *ldv, d *t, int *ldt, d *c, int *ldc, d *work, int *ldwork) nogil +cdef void dlarfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, d *v, int *ldv, d *t, int *ldt, d *c, int *ldc, d *work, int *ldwork) noexcept nogil: + + _fortran_dlarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarfg "BLAS_FUNC(dlarfg)"(int *n, d *alpha, d *x, int *incx, d *tau) nogil +cdef void dlarfg(int *n, d *alpha, d *x, int *incx, d *tau) noexcept nogil: + + _fortran_dlarfg(n, alpha, x, incx, tau) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarfgp "BLAS_FUNC(dlarfgp)"(int *n, d *alpha, d *x, int *incx, d *tau) nogil +cdef void dlarfgp(int *n, d *alpha, d *x, int *incx, d *tau) noexcept nogil: + + _fortran_dlarfgp(n, alpha, x, incx, tau) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarft "BLAS_FUNC(dlarft)"(char *direct, char *storev, int *n, int *k, d *v, int *ldv, d *tau, d *t, int *ldt) nogil +cdef void dlarft(char *direct, char *storev, int *n, int *k, d *v, int *ldv, d *tau, d *t, int *ldt) noexcept nogil: + + _fortran_dlarft(direct, storev, n, k, v, ldv, tau, t, ldt) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarfx "BLAS_FUNC(dlarfx)"(char *side, int *m, int *n, d *v, d *tau, d *c, int *ldc, d *work) nogil +cdef void dlarfx(char *side, int *m, int *n, d *v, d *tau, d *c, int *ldc, d *work) noexcept nogil: + + _fortran_dlarfx(side, m, n, v, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlargv "BLAS_FUNC(dlargv)"(int *n, d *x, int *incx, d *y, int *incy, d *c, int *incc) nogil +cdef void dlargv(int *n, d *x, int *incx, d *y, int *incy, d *c, int *incc) noexcept nogil: + + _fortran_dlargv(n, x, incx, y, incy, c, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarnv "BLAS_FUNC(dlarnv)"(int *idist, int *iseed, int *n, d *x) nogil +cdef void dlarnv(int *idist, int *iseed, int *n, d *x) noexcept nogil: + + _fortran_dlarnv(idist, iseed, n, x) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarra "BLAS_FUNC(dlarra)"(int *n, d *d, d *e, d *e2, d *spltol, d *tnrm, int *nsplit, int *isplit, int *info) nogil +cdef void dlarra(int *n, d *d, d *e, d *e2, d *spltol, d *tnrm, int *nsplit, int *isplit, int *info) noexcept nogil: + + _fortran_dlarra(n, d, e, e2, spltol, tnrm, nsplit, isplit, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarrb "BLAS_FUNC(dlarrb)"(int *n, d *d, d *lld, int *ifirst, int *ilast, d *rtol1, d *rtol2, int *offset, d *w, d *wgap, d *werr, d *work, int *iwork, d *pivmin, d *spdiam, int *twist, int *info) nogil +cdef void dlarrb(int *n, d *d, d *lld, int *ifirst, int *ilast, d *rtol1, d *rtol2, int *offset, d *w, d *wgap, d *werr, d *work, int *iwork, d *pivmin, d *spdiam, int *twist, int *info) noexcept nogil: + + _fortran_dlarrb(n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, work, iwork, pivmin, spdiam, twist, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarrc "BLAS_FUNC(dlarrc)"(char *jobt, int *n, d *vl, d *vu, d *d, d *e, d *pivmin, int *eigcnt, int *lcnt, int *rcnt, int *info) nogil +cdef void dlarrc(char *jobt, int *n, d *vl, d *vu, d *d, d *e, d *pivmin, int *eigcnt, int *lcnt, int *rcnt, int *info) noexcept nogil: + + _fortran_dlarrc(jobt, n, vl, vu, d, e, pivmin, eigcnt, lcnt, rcnt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarrd "BLAS_FUNC(dlarrd)"(char *range, char *order, int *n, d *vl, d *vu, int *il, int *iu, d *gers, d *reltol, d *d, d *e, d *e2, d *pivmin, int *nsplit, int *isplit, int *m, d *w, d *werr, d *wl, d *wu, int *iblock, int *indexw, d *work, int *iwork, int *info) nogil +cdef void dlarrd(char *range, char *order, int *n, d *vl, d *vu, int *il, int *iu, d *gers, d *reltol, d *d, d *e, d *e2, d *pivmin, int *nsplit, int *isplit, int *m, d *w, d *werr, d *wl, d *wu, int *iblock, int *indexw, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dlarrd(range, order, n, vl, vu, il, iu, gers, reltol, d, e, e2, pivmin, nsplit, isplit, m, w, werr, wl, wu, iblock, indexw, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarre "BLAS_FUNC(dlarre)"(char *range, int *n, d *vl, d *vu, int *il, int *iu, d *d, d *e, d *e2, d *rtol1, d *rtol2, d *spltol, int *nsplit, int *isplit, int *m, d *w, d *werr, d *wgap, int *iblock, int *indexw, d *gers, d *pivmin, d *work, int *iwork, int *info) nogil +cdef void dlarre(char *range, int *n, d *vl, d *vu, int *il, int *iu, d *d, d *e, d *e2, d *rtol1, d *rtol2, d *spltol, int *nsplit, int *isplit, int *m, d *w, d *werr, d *wgap, int *iblock, int *indexw, d *gers, d *pivmin, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dlarre(range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit, m, w, werr, wgap, iblock, indexw, gers, pivmin, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarrf "BLAS_FUNC(dlarrf)"(int *n, d *d, d *l, d *ld, int *clstrt, int *clend, d *w, d *wgap, d *werr, d *spdiam, d *clgapl, d *clgapr, d *pivmin, d *sigma, d *dplus, d *lplus, d *work, int *info) nogil +cdef void dlarrf(int *n, d *d, d *l, d *ld, int *clstrt, int *clend, d *w, d *wgap, d *werr, d *spdiam, d *clgapl, d *clgapr, d *pivmin, d *sigma, d *dplus, d *lplus, d *work, int *info) noexcept nogil: + + _fortran_dlarrf(n, d, l, ld, clstrt, clend, w, wgap, werr, spdiam, clgapl, clgapr, pivmin, sigma, dplus, lplus, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarrj "BLAS_FUNC(dlarrj)"(int *n, d *d, d *e2, int *ifirst, int *ilast, d *rtol, int *offset, d *w, d *werr, d *work, int *iwork, d *pivmin, d *spdiam, int *info) nogil +cdef void dlarrj(int *n, d *d, d *e2, int *ifirst, int *ilast, d *rtol, int *offset, d *w, d *werr, d *work, int *iwork, d *pivmin, d *spdiam, int *info) noexcept nogil: + + _fortran_dlarrj(n, d, e2, ifirst, ilast, rtol, offset, w, werr, work, iwork, pivmin, spdiam, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarrk "BLAS_FUNC(dlarrk)"(int *n, int *iw, d *gl, d *gu, d *d, d *e2, d *pivmin, d *reltol, d *w, d *werr, int *info) nogil +cdef void dlarrk(int *n, int *iw, d *gl, d *gu, d *d, d *e2, d *pivmin, d *reltol, d *w, d *werr, int *info) noexcept nogil: + + _fortran_dlarrk(n, iw, gl, gu, d, e2, pivmin, reltol, w, werr, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarrr "BLAS_FUNC(dlarrr)"(int *n, d *d, d *e, int *info) nogil +cdef void dlarrr(int *n, d *d, d *e, int *info) noexcept nogil: + + _fortran_dlarrr(n, d, e, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarrv "BLAS_FUNC(dlarrv)"(int *n, d *vl, d *vu, d *d, d *l, d *pivmin, int *isplit, int *m, int *dol, int *dou, d *minrgp, d *rtol1, d *rtol2, d *w, d *werr, d *wgap, int *iblock, int *indexw, d *gers, d *z, int *ldz, int *isuppz, d *work, int *iwork, int *info) nogil +cdef void dlarrv(int *n, d *vl, d *vu, d *d, d *l, d *pivmin, int *isplit, int *m, int *dol, int *dou, d *minrgp, d *rtol1, d *rtol2, d *w, d *werr, d *wgap, int *iblock, int *indexw, d *gers, d *z, int *ldz, int *isuppz, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dlarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlartg "BLAS_FUNC(dlartg)"(d *f, d *g, d *cs, d *sn, d *r) nogil +cdef void dlartg(d *f, d *g, d *cs, d *sn, d *r) noexcept nogil: + + _fortran_dlartg(f, g, cs, sn, r) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlartgp "BLAS_FUNC(dlartgp)"(d *f, d *g, d *cs, d *sn, d *r) nogil +cdef void dlartgp(d *f, d *g, d *cs, d *sn, d *r) noexcept nogil: + + _fortran_dlartgp(f, g, cs, sn, r) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlartgs "BLAS_FUNC(dlartgs)"(d *x, d *y, d *sigma, d *cs, d *sn) nogil +cdef void dlartgs(d *x, d *y, d *sigma, d *cs, d *sn) noexcept nogil: + + _fortran_dlartgs(x, y, sigma, cs, sn) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlartv "BLAS_FUNC(dlartv)"(int *n, d *x, int *incx, d *y, int *incy, d *c, d *s, int *incc) nogil +cdef void dlartv(int *n, d *x, int *incx, d *y, int *incy, d *c, d *s, int *incc) noexcept nogil: + + _fortran_dlartv(n, x, incx, y, incy, c, s, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaruv "BLAS_FUNC(dlaruv)"(int *iseed, int *n, d *x) nogil +cdef void dlaruv(int *iseed, int *n, d *x) noexcept nogil: + + _fortran_dlaruv(iseed, n, x) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarz "BLAS_FUNC(dlarz)"(char *side, int *m, int *n, int *l, d *v, int *incv, d *tau, d *c, int *ldc, d *work) nogil +cdef void dlarz(char *side, int *m, int *n, int *l, d *v, int *incv, d *tau, d *c, int *ldc, d *work) noexcept nogil: + + _fortran_dlarz(side, m, n, l, v, incv, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarzb "BLAS_FUNC(dlarzb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, d *v, int *ldv, d *t, int *ldt, d *c, int *ldc, d *work, int *ldwork) nogil +cdef void dlarzb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, d *v, int *ldv, d *t, int *ldt, d *c, int *ldc, d *work, int *ldwork) noexcept nogil: + + _fortran_dlarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlarzt "BLAS_FUNC(dlarzt)"(char *direct, char *storev, int *n, int *k, d *v, int *ldv, d *tau, d *t, int *ldt) nogil +cdef void dlarzt(char *direct, char *storev, int *n, int *k, d *v, int *ldv, d *tau, d *t, int *ldt) noexcept nogil: + + _fortran_dlarzt(direct, storev, n, k, v, ldv, tau, t, ldt) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlas2 "BLAS_FUNC(dlas2)"(d *f, d *g, d *h, d *ssmin, d *ssmax) nogil +cdef void dlas2(d *f, d *g, d *h, d *ssmin, d *ssmax) noexcept nogil: + + _fortran_dlas2(f, g, h, ssmin, ssmax) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlascl "BLAS_FUNC(dlascl)"(char *type_bn, int *kl, int *ku, d *cfrom, d *cto, int *m, int *n, d *a, int *lda, int *info) nogil +cdef void dlascl(char *type_bn, int *kl, int *ku, d *cfrom, d *cto, int *m, int *n, d *a, int *lda, int *info) noexcept nogil: + + _fortran_dlascl(type_bn, kl, ku, cfrom, cto, m, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasd0 "BLAS_FUNC(dlasd0)"(int *n, int *sqre, d *d, d *e, d *u, int *ldu, d *vt, int *ldvt, int *smlsiz, int *iwork, d *work, int *info) nogil +cdef void dlasd0(int *n, int *sqre, d *d, d *e, d *u, int *ldu, d *vt, int *ldvt, int *smlsiz, int *iwork, d *work, int *info) noexcept nogil: + + _fortran_dlasd0(n, sqre, d, e, u, ldu, vt, ldvt, smlsiz, iwork, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasd1 "BLAS_FUNC(dlasd1)"(int *nl, int *nr, int *sqre, d *d, d *alpha, d *beta, d *u, int *ldu, d *vt, int *ldvt, int *idxq, int *iwork, d *work, int *info) nogil +cdef void dlasd1(int *nl, int *nr, int *sqre, d *d, d *alpha, d *beta, d *u, int *ldu, d *vt, int *ldvt, int *idxq, int *iwork, d *work, int *info) noexcept nogil: + + _fortran_dlasd1(nl, nr, sqre, d, alpha, beta, u, ldu, vt, ldvt, idxq, iwork, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasd2 "BLAS_FUNC(dlasd2)"(int *nl, int *nr, int *sqre, int *k, d *d, d *z, d *alpha, d *beta, d *u, int *ldu, d *vt, int *ldvt, d *dsigma, d *u2, int *ldu2, d *vt2, int *ldvt2, int *idxp, int *idx, int *idxc, int *idxq, int *coltyp, int *info) nogil +cdef void dlasd2(int *nl, int *nr, int *sqre, int *k, d *d, d *z, d *alpha, d *beta, d *u, int *ldu, d *vt, int *ldvt, d *dsigma, d *u2, int *ldu2, d *vt2, int *ldvt2, int *idxp, int *idx, int *idxc, int *idxq, int *coltyp, int *info) noexcept nogil: + + _fortran_dlasd2(nl, nr, sqre, k, d, z, alpha, beta, u, ldu, vt, ldvt, dsigma, u2, ldu2, vt2, ldvt2, idxp, idx, idxc, idxq, coltyp, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasd3 "BLAS_FUNC(dlasd3)"(int *nl, int *nr, int *sqre, int *k, d *d, d *q, int *ldq, d *dsigma, d *u, int *ldu, d *u2, int *ldu2, d *vt, int *ldvt, d *vt2, int *ldvt2, int *idxc, int *ctot, d *z, int *info) nogil +cdef void dlasd3(int *nl, int *nr, int *sqre, int *k, d *d, d *q, int *ldq, d *dsigma, d *u, int *ldu, d *u2, int *ldu2, d *vt, int *ldvt, d *vt2, int *ldvt2, int *idxc, int *ctot, d *z, int *info) noexcept nogil: + + _fortran_dlasd3(nl, nr, sqre, k, d, q, ldq, dsigma, u, ldu, u2, ldu2, vt, ldvt, vt2, ldvt2, idxc, ctot, z, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasd4 "BLAS_FUNC(dlasd4)"(int *n, int *i, d *d, d *z, d *delta, d *rho, d *sigma, d *work, int *info) nogil +cdef void dlasd4(int *n, int *i, d *d, d *z, d *delta, d *rho, d *sigma, d *work, int *info) noexcept nogil: + + _fortran_dlasd4(n, i, d, z, delta, rho, sigma, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasd5 "BLAS_FUNC(dlasd5)"(int *i, d *d, d *z, d *delta, d *rho, d *dsigma, d *work) nogil +cdef void dlasd5(int *i, d *d, d *z, d *delta, d *rho, d *dsigma, d *work) noexcept nogil: + + _fortran_dlasd5(i, d, z, delta, rho, dsigma, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasd6 "BLAS_FUNC(dlasd6)"(int *icompq, int *nl, int *nr, int *sqre, d *d, d *vf, d *vl, d *alpha, d *beta, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *poles, d *difl, d *difr, d *z, int *k, d *c, d *s, d *work, int *iwork, int *info) nogil +cdef void dlasd6(int *icompq, int *nl, int *nr, int *sqre, d *d, d *vf, d *vl, d *alpha, d *beta, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *poles, d *difl, d *difr, d *z, int *k, d *c, d *s, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dlasd6(icompq, nl, nr, sqre, d, vf, vl, alpha, beta, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasd7 "BLAS_FUNC(dlasd7)"(int *icompq, int *nl, int *nr, int *sqre, int *k, d *d, d *z, d *zw, d *vf, d *vfw, d *vl, d *vlw, d *alpha, d *beta, d *dsigma, int *idx, int *idxp, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *c, d *s, int *info) nogil +cdef void dlasd7(int *icompq, int *nl, int *nr, int *sqre, int *k, d *d, d *z, d *zw, d *vf, d *vfw, d *vl, d *vlw, d *alpha, d *beta, d *dsigma, int *idx, int *idxp, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *c, d *s, int *info) noexcept nogil: + + _fortran_dlasd7(icompq, nl, nr, sqre, k, d, z, zw, vf, vfw, vl, vlw, alpha, beta, dsigma, idx, idxp, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, c, s, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasd8 "BLAS_FUNC(dlasd8)"(int *icompq, int *k, d *d, d *z, d *vf, d *vl, d *difl, d *difr, int *lddifr, d *dsigma, d *work, int *info) nogil +cdef void dlasd8(int *icompq, int *k, d *d, d *z, d *vf, d *vl, d *difl, d *difr, int *lddifr, d *dsigma, d *work, int *info) noexcept nogil: + + _fortran_dlasd8(icompq, k, d, z, vf, vl, difl, difr, lddifr, dsigma, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasda "BLAS_FUNC(dlasda)"(int *icompq, int *smlsiz, int *n, int *sqre, d *d, d *e, d *u, int *ldu, d *vt, int *k, d *difl, d *difr, d *z, d *poles, int *givptr, int *givcol, int *ldgcol, int *perm, d *givnum, d *c, d *s, d *work, int *iwork, int *info) nogil +cdef void dlasda(int *icompq, int *smlsiz, int *n, int *sqre, d *d, d *e, d *u, int *ldu, d *vt, int *k, d *difl, d *difr, d *z, d *poles, int *givptr, int *givcol, int *ldgcol, int *perm, d *givnum, d *c, d *s, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dlasda(icompq, smlsiz, n, sqre, d, e, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasdq "BLAS_FUNC(dlasdq)"(char *uplo, int *sqre, int *n, int *ncvt, int *nru, int *ncc, d *d, d *e, d *vt, int *ldvt, d *u, int *ldu, d *c, int *ldc, d *work, int *info) nogil +cdef void dlasdq(char *uplo, int *sqre, int *n, int *ncvt, int *nru, int *ncc, d *d, d *e, d *vt, int *ldvt, d *u, int *ldu, d *c, int *ldc, d *work, int *info) noexcept nogil: + + _fortran_dlasdq(uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasdt "BLAS_FUNC(dlasdt)"(int *n, int *lvl, int *nd, int *inode, int *ndiml, int *ndimr, int *msub) nogil +cdef void dlasdt(int *n, int *lvl, int *nd, int *inode, int *ndiml, int *ndimr, int *msub) noexcept nogil: + + _fortran_dlasdt(n, lvl, nd, inode, ndiml, ndimr, msub) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaset "BLAS_FUNC(dlaset)"(char *uplo, int *m, int *n, d *alpha, d *beta, d *a, int *lda) nogil +cdef void dlaset(char *uplo, int *m, int *n, d *alpha, d *beta, d *a, int *lda) noexcept nogil: + + _fortran_dlaset(uplo, m, n, alpha, beta, a, lda) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasq1 "BLAS_FUNC(dlasq1)"(int *n, d *d, d *e, d *work, int *info) nogil +cdef void dlasq1(int *n, d *d, d *e, d *work, int *info) noexcept nogil: + + _fortran_dlasq1(n, d, e, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasq2 "BLAS_FUNC(dlasq2)"(int *n, d *z, int *info) nogil +cdef void dlasq2(int *n, d *z, int *info) noexcept nogil: + + _fortran_dlasq2(n, z, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasq3 "BLAS_FUNC(dlasq3)"(int *i0, int *n0, d *z, int *pp, d *dmin, d *sigma, d *desig, d *qmax, int *nfail, int *iter, int *ndiv, bint *ieee, int *ttype, d *dmin1, d *dmin2, d *dn, d *dn1, d *dn2, d *g, d *tau) nogil +cdef void dlasq3(int *i0, int *n0, d *z, int *pp, d *dmin, d *sigma, d *desig, d *qmax, int *nfail, int *iter, int *ndiv, bint *ieee, int *ttype, d *dmin1, d *dmin2, d *dn, d *dn1, d *dn2, d *g, d *tau) noexcept nogil: + + _fortran_dlasq3(i0, n0, z, pp, dmin, sigma, desig, qmax, nfail, iter, ndiv, ieee, ttype, dmin1, dmin2, dn, dn1, dn2, g, tau) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasq4 "BLAS_FUNC(dlasq4)"(int *i0, int *n0, d *z, int *pp, int *n0in, d *dmin, d *dmin1, d *dmin2, d *dn, d *dn1, d *dn2, d *tau, int *ttype, d *g) nogil +cdef void dlasq4(int *i0, int *n0, d *z, int *pp, int *n0in, d *dmin, d *dmin1, d *dmin2, d *dn, d *dn1, d *dn2, d *tau, int *ttype, d *g) noexcept nogil: + + _fortran_dlasq4(i0, n0, z, pp, n0in, dmin, dmin1, dmin2, dn, dn1, dn2, tau, ttype, g) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasq6 "BLAS_FUNC(dlasq6)"(int *i0, int *n0, d *z, int *pp, d *dmin, d *dmin1, d *dmin2, d *dn, d *dnm1, d *dnm2) nogil +cdef void dlasq6(int *i0, int *n0, d *z, int *pp, d *dmin, d *dmin1, d *dmin2, d *dn, d *dnm1, d *dnm2) noexcept nogil: + + _fortran_dlasq6(i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasr "BLAS_FUNC(dlasr)"(char *side, char *pivot, char *direct, int *m, int *n, d *c, d *s, d *a, int *lda) nogil +cdef void dlasr(char *side, char *pivot, char *direct, int *m, int *n, d *c, d *s, d *a, int *lda) noexcept nogil: + + _fortran_dlasr(side, pivot, direct, m, n, c, s, a, lda) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasrt "BLAS_FUNC(dlasrt)"(char *id, int *n, d *d, int *info) nogil +cdef void dlasrt(char *id, int *n, d *d, int *info) noexcept nogil: + + _fortran_dlasrt(id, n, d, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlassq "BLAS_FUNC(dlassq)"(int *n, d *x, int *incx, d *scale, d *sumsq) nogil +cdef void dlassq(int *n, d *x, int *incx, d *scale, d *sumsq) noexcept nogil: + + _fortran_dlassq(n, x, incx, scale, sumsq) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasv2 "BLAS_FUNC(dlasv2)"(d *f, d *g, d *h, d *ssmin, d *ssmax, d *snr, d *csr, d *snl, d *csl) nogil +cdef void dlasv2(d *f, d *g, d *h, d *ssmin, d *ssmax, d *snr, d *csr, d *snl, d *csl) noexcept nogil: + + _fortran_dlasv2(f, g, h, ssmin, ssmax, snr, csr, snl, csl) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlaswp "BLAS_FUNC(dlaswp)"(int *n, d *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) nogil +cdef void dlaswp(int *n, d *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) noexcept nogil: + + _fortran_dlaswp(n, a, lda, k1, k2, ipiv, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasy2 "BLAS_FUNC(dlasy2)"(bint *ltranl, bint *ltranr, int *isgn, int *n1, int *n2, d *tl, int *ldtl, d *tr, int *ldtr, d *b, int *ldb, d *scale, d *x, int *ldx, d *xnorm, int *info) nogil +cdef void dlasy2(bint *ltranl, bint *ltranr, int *isgn, int *n1, int *n2, d *tl, int *ldtl, d *tr, int *ldtr, d *b, int *ldb, d *scale, d *x, int *ldx, d *xnorm, int *info) noexcept nogil: + + _fortran_dlasy2(ltranl, ltranr, isgn, n1, n2, tl, ldtl, tr, ldtr, b, ldb, scale, x, ldx, xnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlasyf "BLAS_FUNC(dlasyf)"(char *uplo, int *n, int *nb, int *kb, d *a, int *lda, int *ipiv, d *w, int *ldw, int *info) nogil +cdef void dlasyf(char *uplo, int *n, int *nb, int *kb, d *a, int *lda, int *ipiv, d *w, int *ldw, int *info) noexcept nogil: + + _fortran_dlasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlat2s "BLAS_FUNC(dlat2s)"(char *uplo, int *n, d *a, int *lda, s *sa, int *ldsa, int *info) nogil +cdef void dlat2s(char *uplo, int *n, d *a, int *lda, s *sa, int *ldsa, int *info) noexcept nogil: + + _fortran_dlat2s(uplo, n, a, lda, sa, ldsa, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlatbs "BLAS_FUNC(dlatbs)"(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, d *ab, int *ldab, d *x, d *scale, d *cnorm, int *info) nogil +cdef void dlatbs(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, d *ab, int *ldab, d *x, d *scale, d *cnorm, int *info) noexcept nogil: + + _fortran_dlatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlatdf "BLAS_FUNC(dlatdf)"(int *ijob, int *n, d *z, int *ldz, d *rhs, d *rdsum, d *rdscal, int *ipiv, int *jpiv) nogil +cdef void dlatdf(int *ijob, int *n, d *z, int *ldz, d *rhs, d *rdsum, d *rdscal, int *ipiv, int *jpiv) noexcept nogil: + + _fortran_dlatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlatps "BLAS_FUNC(dlatps)"(char *uplo, char *trans, char *diag, char *normin, int *n, d *ap, d *x, d *scale, d *cnorm, int *info) nogil +cdef void dlatps(char *uplo, char *trans, char *diag, char *normin, int *n, d *ap, d *x, d *scale, d *cnorm, int *info) noexcept nogil: + + _fortran_dlatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlatrd "BLAS_FUNC(dlatrd)"(char *uplo, int *n, int *nb, d *a, int *lda, d *e, d *tau, d *w, int *ldw) nogil +cdef void dlatrd(char *uplo, int *n, int *nb, d *a, int *lda, d *e, d *tau, d *w, int *ldw) noexcept nogil: + + _fortran_dlatrd(uplo, n, nb, a, lda, e, tau, w, ldw) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlatrs "BLAS_FUNC(dlatrs)"(char *uplo, char *trans, char *diag, char *normin, int *n, d *a, int *lda, d *x, d *scale, d *cnorm, int *info) nogil +cdef void dlatrs(char *uplo, char *trans, char *diag, char *normin, int *n, d *a, int *lda, d *x, d *scale, d *cnorm, int *info) noexcept nogil: + + _fortran_dlatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlatrz "BLAS_FUNC(dlatrz)"(int *m, int *n, int *l, d *a, int *lda, d *tau, d *work) nogil +cdef void dlatrz(int *m, int *n, int *l, d *a, int *lda, d *tau, d *work) noexcept nogil: + + _fortran_dlatrz(m, n, l, a, lda, tau, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlauu2 "BLAS_FUNC(dlauu2)"(char *uplo, int *n, d *a, int *lda, int *info) nogil +cdef void dlauu2(char *uplo, int *n, d *a, int *lda, int *info) noexcept nogil: + + _fortran_dlauu2(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dlauum "BLAS_FUNC(dlauum)"(char *uplo, int *n, d *a, int *lda, int *info) nogil +cdef void dlauum(char *uplo, int *n, d *a, int *lda, int *info) noexcept nogil: + + _fortran_dlauum(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dopgtr "BLAS_FUNC(dopgtr)"(char *uplo, int *n, d *ap, d *tau, d *q, int *ldq, d *work, int *info) nogil +cdef void dopgtr(char *uplo, int *n, d *ap, d *tau, d *q, int *ldq, d *work, int *info) noexcept nogil: + + _fortran_dopgtr(uplo, n, ap, tau, q, ldq, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dopmtr "BLAS_FUNC(dopmtr)"(char *side, char *uplo, char *trans, int *m, int *n, d *ap, d *tau, d *c, int *ldc, d *work, int *info) nogil +cdef void dopmtr(char *side, char *uplo, char *trans, int *m, int *n, d *ap, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil: + + _fortran_dopmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorbdb "BLAS_FUNC(dorbdb)"(char *trans, char *signs, int *m, int *p, int *q, d *x11, int *ldx11, d *x12, int *ldx12, d *x21, int *ldx21, d *x22, int *ldx22, d *theta, d *phi, d *taup1, d *taup2, d *tauq1, d *tauq2, d *work, int *lwork, int *info) nogil +cdef void dorbdb(char *trans, char *signs, int *m, int *p, int *q, d *x11, int *ldx11, d *x12, int *ldx12, d *x21, int *ldx21, d *x22, int *ldx22, d *theta, d *phi, d *taup1, d *taup2, d *tauq1, d *tauq2, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dorbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorcsd "BLAS_FUNC(dorcsd)"(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, d *x11, int *ldx11, d *x12, int *ldx12, d *x21, int *ldx21, d *x22, int *ldx22, d *theta, d *u1, int *ldu1, d *u2, int *ldu2, d *v1t, int *ldv1t, d *v2t, int *ldv2t, d *work, int *lwork, int *iwork, int *info) nogil +cdef void dorcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, d *x11, int *ldx11, d *x12, int *ldx12, d *x21, int *ldx21, d *x22, int *ldx22, d *theta, d *u1, int *ldu1, d *u2, int *ldu2, d *v1t, int *ldv1t, d *v2t, int *ldv2t, d *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_dorcsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorg2l "BLAS_FUNC(dorg2l)"(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) nogil +cdef void dorg2l(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil: + + _fortran_dorg2l(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorg2r "BLAS_FUNC(dorg2r)"(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) nogil +cdef void dorg2r(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil: + + _fortran_dorg2r(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorgbr "BLAS_FUNC(dorgbr)"(char *vect, int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dorgbr(char *vect, int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dorgbr(vect, m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorghr "BLAS_FUNC(dorghr)"(int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dorghr(int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dorghr(n, ilo, ihi, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorgl2 "BLAS_FUNC(dorgl2)"(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) nogil +cdef void dorgl2(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil: + + _fortran_dorgl2(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorglq "BLAS_FUNC(dorglq)"(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dorglq(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dorglq(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorgql "BLAS_FUNC(dorgql)"(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dorgql(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dorgql(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorgqr "BLAS_FUNC(dorgqr)"(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dorgqr(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dorgqr(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorgr2 "BLAS_FUNC(dorgr2)"(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) nogil +cdef void dorgr2(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *info) noexcept nogil: + + _fortran_dorgr2(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorgrq "BLAS_FUNC(dorgrq)"(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dorgrq(int *m, int *n, int *k, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dorgrq(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorgtr "BLAS_FUNC(dorgtr)"(char *uplo, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dorgtr(char *uplo, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dorgtr(uplo, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorm2l "BLAS_FUNC(dorm2l)"(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) nogil +cdef void dorm2l(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil: + + _fortran_dorm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorm2r "BLAS_FUNC(dorm2r)"(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) nogil +cdef void dorm2r(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil: + + _fortran_dorm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dormbr "BLAS_FUNC(dormbr)"(char *vect, char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) nogil +cdef void dormbr(char *vect, char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dormbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dormhr "BLAS_FUNC(dormhr)"(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) nogil +cdef void dormhr(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dormhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dorml2 "BLAS_FUNC(dorml2)"(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) nogil +cdef void dorml2(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil: + + _fortran_dorml2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dormlq "BLAS_FUNC(dormlq)"(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) nogil +cdef void dormlq(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dormlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dormql "BLAS_FUNC(dormql)"(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) nogil +cdef void dormql(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dormql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dormqr "BLAS_FUNC(dormqr)"(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) nogil +cdef void dormqr(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dormqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dormr2 "BLAS_FUNC(dormr2)"(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) nogil +cdef void dormr2(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil: + + _fortran_dormr2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dormr3 "BLAS_FUNC(dormr3)"(char *side, char *trans, int *m, int *n, int *k, int *l, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) nogil +cdef void dormr3(char *side, char *trans, int *m, int *n, int *k, int *l, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *info) noexcept nogil: + + _fortran_dormr3(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dormrq "BLAS_FUNC(dormrq)"(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) nogil +cdef void dormrq(char *side, char *trans, int *m, int *n, int *k, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dormrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dormrz "BLAS_FUNC(dormrz)"(char *side, char *trans, int *m, int *n, int *k, int *l, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) nogil +cdef void dormrz(char *side, char *trans, int *m, int *n, int *k, int *l, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dormrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dormtr "BLAS_FUNC(dormtr)"(char *side, char *uplo, char *trans, int *m, int *n, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) nogil +cdef void dormtr(char *side, char *uplo, char *trans, int *m, int *n, d *a, int *lda, d *tau, d *c, int *ldc, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dormtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpbcon "BLAS_FUNC(dpbcon)"(char *uplo, int *n, int *kd, d *ab, int *ldab, d *anorm, d *rcond, d *work, int *iwork, int *info) nogil +cdef void dpbcon(char *uplo, int *n, int *kd, d *ab, int *ldab, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpbequ "BLAS_FUNC(dpbequ)"(char *uplo, int *n, int *kd, d *ab, int *ldab, d *s, d *scond, d *amax, int *info) nogil +cdef void dpbequ(char *uplo, int *n, int *kd, d *ab, int *ldab, d *s, d *scond, d *amax, int *info) noexcept nogil: + + _fortran_dpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpbrfs "BLAS_FUNC(dpbrfs)"(char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dpbrfs(char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpbstf "BLAS_FUNC(dpbstf)"(char *uplo, int *n, int *kd, d *ab, int *ldab, int *info) nogil +cdef void dpbstf(char *uplo, int *n, int *kd, d *ab, int *ldab, int *info) noexcept nogil: + + _fortran_dpbstf(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpbsv "BLAS_FUNC(dpbsv)"(char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, int *info) nogil +cdef void dpbsv(char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpbsvx "BLAS_FUNC(dpbsvx)"(char *fact, char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, char *equed, d *s, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dpbsvx(char *fact, char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *afb, int *ldafb, char *equed, d *s, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dpbsvx(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpbtf2 "BLAS_FUNC(dpbtf2)"(char *uplo, int *n, int *kd, d *ab, int *ldab, int *info) nogil +cdef void dpbtf2(char *uplo, int *n, int *kd, d *ab, int *ldab, int *info) noexcept nogil: + + _fortran_dpbtf2(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpbtrf "BLAS_FUNC(dpbtrf)"(char *uplo, int *n, int *kd, d *ab, int *ldab, int *info) nogil +cdef void dpbtrf(char *uplo, int *n, int *kd, d *ab, int *ldab, int *info) noexcept nogil: + + _fortran_dpbtrf(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpbtrs "BLAS_FUNC(dpbtrs)"(char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, int *info) nogil +cdef void dpbtrs(char *uplo, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpftrf "BLAS_FUNC(dpftrf)"(char *transr, char *uplo, int *n, d *a, int *info) nogil +cdef void dpftrf(char *transr, char *uplo, int *n, d *a, int *info) noexcept nogil: + + _fortran_dpftrf(transr, uplo, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpftri "BLAS_FUNC(dpftri)"(char *transr, char *uplo, int *n, d *a, int *info) nogil +cdef void dpftri(char *transr, char *uplo, int *n, d *a, int *info) noexcept nogil: + + _fortran_dpftri(transr, uplo, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpftrs "BLAS_FUNC(dpftrs)"(char *transr, char *uplo, int *n, int *nrhs, d *a, d *b, int *ldb, int *info) nogil +cdef void dpftrs(char *transr, char *uplo, int *n, int *nrhs, d *a, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dpftrs(transr, uplo, n, nrhs, a, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpocon "BLAS_FUNC(dpocon)"(char *uplo, int *n, d *a, int *lda, d *anorm, d *rcond, d *work, int *iwork, int *info) nogil +cdef void dpocon(char *uplo, int *n, d *a, int *lda, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dpocon(uplo, n, a, lda, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpoequ "BLAS_FUNC(dpoequ)"(int *n, d *a, int *lda, d *s, d *scond, d *amax, int *info) nogil +cdef void dpoequ(int *n, d *a, int *lda, d *s, d *scond, d *amax, int *info) noexcept nogil: + + _fortran_dpoequ(n, a, lda, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpoequb "BLAS_FUNC(dpoequb)"(int *n, d *a, int *lda, d *s, d *scond, d *amax, int *info) nogil +cdef void dpoequb(int *n, d *a, int *lda, d *s, d *scond, d *amax, int *info) noexcept nogil: + + _fortran_dpoequb(n, a, lda, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dporfs "BLAS_FUNC(dporfs)"(char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dporfs(char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dposv "BLAS_FUNC(dposv)"(char *uplo, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *info) nogil +cdef void dposv(char *uplo, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dposv(uplo, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dposvx "BLAS_FUNC(dposvx)"(char *fact, char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, char *equed, d *s, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dposvx(char *fact, char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, char *equed, d *s, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dposvx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpotf2 "BLAS_FUNC(dpotf2)"(char *uplo, int *n, d *a, int *lda, int *info) nogil +cdef void dpotf2(char *uplo, int *n, d *a, int *lda, int *info) noexcept nogil: + + _fortran_dpotf2(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpotrf "BLAS_FUNC(dpotrf)"(char *uplo, int *n, d *a, int *lda, int *info) nogil +cdef void dpotrf(char *uplo, int *n, d *a, int *lda, int *info) noexcept nogil: + + _fortran_dpotrf(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpotri "BLAS_FUNC(dpotri)"(char *uplo, int *n, d *a, int *lda, int *info) nogil +cdef void dpotri(char *uplo, int *n, d *a, int *lda, int *info) noexcept nogil: + + _fortran_dpotri(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpotrs "BLAS_FUNC(dpotrs)"(char *uplo, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *info) nogil +cdef void dpotrs(char *uplo, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dpotrs(uplo, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dppcon "BLAS_FUNC(dppcon)"(char *uplo, int *n, d *ap, d *anorm, d *rcond, d *work, int *iwork, int *info) nogil +cdef void dppcon(char *uplo, int *n, d *ap, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dppcon(uplo, n, ap, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dppequ "BLAS_FUNC(dppequ)"(char *uplo, int *n, d *ap, d *s, d *scond, d *amax, int *info) nogil +cdef void dppequ(char *uplo, int *n, d *ap, d *s, d *scond, d *amax, int *info) noexcept nogil: + + _fortran_dppequ(uplo, n, ap, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpprfs "BLAS_FUNC(dpprfs)"(char *uplo, int *n, int *nrhs, d *ap, d *afp, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dpprfs(char *uplo, int *n, int *nrhs, d *ap, d *afp, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dppsv "BLAS_FUNC(dppsv)"(char *uplo, int *n, int *nrhs, d *ap, d *b, int *ldb, int *info) nogil +cdef void dppsv(char *uplo, int *n, int *nrhs, d *ap, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dppsv(uplo, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dppsvx "BLAS_FUNC(dppsvx)"(char *fact, char *uplo, int *n, int *nrhs, d *ap, d *afp, char *equed, d *s, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dppsvx(char *fact, char *uplo, int *n, int *nrhs, d *ap, d *afp, char *equed, d *s, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dppsvx(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpptrf "BLAS_FUNC(dpptrf)"(char *uplo, int *n, d *ap, int *info) nogil +cdef void dpptrf(char *uplo, int *n, d *ap, int *info) noexcept nogil: + + _fortran_dpptrf(uplo, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpptri "BLAS_FUNC(dpptri)"(char *uplo, int *n, d *ap, int *info) nogil +cdef void dpptri(char *uplo, int *n, d *ap, int *info) noexcept nogil: + + _fortran_dpptri(uplo, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpptrs "BLAS_FUNC(dpptrs)"(char *uplo, int *n, int *nrhs, d *ap, d *b, int *ldb, int *info) nogil +cdef void dpptrs(char *uplo, int *n, int *nrhs, d *ap, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dpptrs(uplo, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpstf2 "BLAS_FUNC(dpstf2)"(char *uplo, int *n, d *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) nogil +cdef void dpstf2(char *uplo, int *n, d *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) noexcept nogil: + + _fortran_dpstf2(uplo, n, a, lda, piv, rank, tol, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpstrf "BLAS_FUNC(dpstrf)"(char *uplo, int *n, d *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) nogil +cdef void dpstrf(char *uplo, int *n, d *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) noexcept nogil: + + _fortran_dpstrf(uplo, n, a, lda, piv, rank, tol, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dptcon "BLAS_FUNC(dptcon)"(int *n, d *d, d *e, d *anorm, d *rcond, d *work, int *info) nogil +cdef void dptcon(int *n, d *d, d *e, d *anorm, d *rcond, d *work, int *info) noexcept nogil: + + _fortran_dptcon(n, d, e, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpteqr "BLAS_FUNC(dpteqr)"(char *compz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *info) nogil +cdef void dpteqr(char *compz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *info) noexcept nogil: + + _fortran_dpteqr(compz, n, d, e, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dptrfs "BLAS_FUNC(dptrfs)"(int *n, int *nrhs, d *d, d *e, d *df, d *ef, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *info) nogil +cdef void dptrfs(int *n, int *nrhs, d *d, d *e, d *df, d *ef, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *info) noexcept nogil: + + _fortran_dptrfs(n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dptsv "BLAS_FUNC(dptsv)"(int *n, int *nrhs, d *d, d *e, d *b, int *ldb, int *info) nogil +cdef void dptsv(int *n, int *nrhs, d *d, d *e, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dptsv(n, nrhs, d, e, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dptsvx "BLAS_FUNC(dptsvx)"(char *fact, int *n, int *nrhs, d *d, d *e, d *df, d *ef, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *info) nogil +cdef void dptsvx(char *fact, int *n, int *nrhs, d *d, d *e, d *df, d *ef, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *info) noexcept nogil: + + _fortran_dptsvx(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpttrf "BLAS_FUNC(dpttrf)"(int *n, d *d, d *e, int *info) nogil +cdef void dpttrf(int *n, d *d, d *e, int *info) noexcept nogil: + + _fortran_dpttrf(n, d, e, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dpttrs "BLAS_FUNC(dpttrs)"(int *n, int *nrhs, d *d, d *e, d *b, int *ldb, int *info) nogil +cdef void dpttrs(int *n, int *nrhs, d *d, d *e, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dpttrs(n, nrhs, d, e, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dptts2 "BLAS_FUNC(dptts2)"(int *n, int *nrhs, d *d, d *e, d *b, int *ldb) nogil +cdef void dptts2(int *n, int *nrhs, d *d, d *e, d *b, int *ldb) noexcept nogil: + + _fortran_dptts2(n, nrhs, d, e, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_drscl "BLAS_FUNC(drscl)"(int *n, d *sa, d *sx, int *incx) nogil +cdef void drscl(int *n, d *sa, d *sx, int *incx) noexcept nogil: + + _fortran_drscl(n, sa, sx, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsbev "BLAS_FUNC(dsbev)"(char *jobz, char *uplo, int *n, int *kd, d *ab, int *ldab, d *w, d *z, int *ldz, d *work, int *info) nogil +cdef void dsbev(char *jobz, char *uplo, int *n, int *kd, d *ab, int *ldab, d *w, d *z, int *ldz, d *work, int *info) noexcept nogil: + + _fortran_dsbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsbevd "BLAS_FUNC(dsbevd)"(char *jobz, char *uplo, int *n, int *kd, d *ab, int *ldab, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dsbevd(char *jobz, char *uplo, int *n, int *kd, d *ab, int *ldab, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dsbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsbevx "BLAS_FUNC(dsbevx)"(char *jobz, char *range, char *uplo, int *n, int *kd, d *ab, int *ldab, d *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) nogil +cdef void dsbevx(char *jobz, char *range, char *uplo, int *n, int *kd, d *ab, int *ldab, d *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_dsbevx(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsbgst "BLAS_FUNC(dsbgst)"(char *vect, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *x, int *ldx, d *work, int *info) nogil +cdef void dsbgst(char *vect, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *x, int *ldx, d *work, int *info) noexcept nogil: + + _fortran_dsbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsbgv "BLAS_FUNC(dsbgv)"(char *jobz, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *w, d *z, int *ldz, d *work, int *info) nogil +cdef void dsbgv(char *jobz, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *w, d *z, int *ldz, d *work, int *info) noexcept nogil: + + _fortran_dsbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsbgvd "BLAS_FUNC(dsbgvd)"(char *jobz, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dsbgvd(char *jobz, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dsbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsbgvx "BLAS_FUNC(dsbgvx)"(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) nogil +cdef void dsbgvx(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, d *ab, int *ldab, d *bb, int *ldbb, d *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_dsbgvx(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsbtrd "BLAS_FUNC(dsbtrd)"(char *vect, char *uplo, int *n, int *kd, d *ab, int *ldab, d *d, d *e, d *q, int *ldq, d *work, int *info) nogil +cdef void dsbtrd(char *vect, char *uplo, int *n, int *kd, d *ab, int *ldab, d *d, d *e, d *q, int *ldq, d *work, int *info) noexcept nogil: + + _fortran_dsbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsfrk "BLAS_FUNC(dsfrk)"(char *transr, char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *beta, d *c) nogil +cdef void dsfrk(char *transr, char *uplo, char *trans, int *n, int *k, d *alpha, d *a, int *lda, d *beta, d *c) noexcept nogil: + + _fortran_dsfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsgesv "BLAS_FUNC(dsgesv)"(int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *work, s *swork, int *iter, int *info) nogil +cdef void dsgesv(int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *work, s *swork, int *iter, int *info) noexcept nogil: + + _fortran_dsgesv(n, nrhs, a, lda, ipiv, b, ldb, x, ldx, work, swork, iter, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dspcon "BLAS_FUNC(dspcon)"(char *uplo, int *n, d *ap, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) nogil +cdef void dspcon(char *uplo, int *n, d *ap, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dspcon(uplo, n, ap, ipiv, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dspev "BLAS_FUNC(dspev)"(char *jobz, char *uplo, int *n, d *ap, d *w, d *z, int *ldz, d *work, int *info) nogil +cdef void dspev(char *jobz, char *uplo, int *n, d *ap, d *w, d *z, int *ldz, d *work, int *info) noexcept nogil: + + _fortran_dspev(jobz, uplo, n, ap, w, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dspevd "BLAS_FUNC(dspevd)"(char *jobz, char *uplo, int *n, d *ap, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dspevd(char *jobz, char *uplo, int *n, d *ap, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dspevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dspevx "BLAS_FUNC(dspevx)"(char *jobz, char *range, char *uplo, int *n, d *ap, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) nogil +cdef void dspevx(char *jobz, char *range, char *uplo, int *n, d *ap, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_dspevx(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dspgst "BLAS_FUNC(dspgst)"(int *itype, char *uplo, int *n, d *ap, d *bp, int *info) nogil +cdef void dspgst(int *itype, char *uplo, int *n, d *ap, d *bp, int *info) noexcept nogil: + + _fortran_dspgst(itype, uplo, n, ap, bp, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dspgv "BLAS_FUNC(dspgv)"(int *itype, char *jobz, char *uplo, int *n, d *ap, d *bp, d *w, d *z, int *ldz, d *work, int *info) nogil +cdef void dspgv(int *itype, char *jobz, char *uplo, int *n, d *ap, d *bp, d *w, d *z, int *ldz, d *work, int *info) noexcept nogil: + + _fortran_dspgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dspgvd "BLAS_FUNC(dspgvd)"(int *itype, char *jobz, char *uplo, int *n, d *ap, d *bp, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dspgvd(int *itype, char *jobz, char *uplo, int *n, d *ap, d *bp, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dspgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dspgvx "BLAS_FUNC(dspgvx)"(int *itype, char *jobz, char *range, char *uplo, int *n, d *ap, d *bp, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) nogil +cdef void dspgvx(int *itype, char *jobz, char *range, char *uplo, int *n, d *ap, d *bp, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_dspgvx(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsposv "BLAS_FUNC(dsposv)"(char *uplo, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *x, int *ldx, d *work, s *swork, int *iter, int *info) nogil +cdef void dsposv(char *uplo, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *x, int *ldx, d *work, s *swork, int *iter, int *info) noexcept nogil: + + _fortran_dsposv(uplo, n, nrhs, a, lda, b, ldb, x, ldx, work, swork, iter, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsprfs "BLAS_FUNC(dsprfs)"(char *uplo, int *n, int *nrhs, d *ap, d *afp, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dsprfs(char *uplo, int *n, int *nrhs, d *ap, d *afp, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dsprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dspsv "BLAS_FUNC(dspsv)"(char *uplo, int *n, int *nrhs, d *ap, int *ipiv, d *b, int *ldb, int *info) nogil +cdef void dspsv(char *uplo, int *n, int *nrhs, d *ap, int *ipiv, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dspsvx "BLAS_FUNC(dspsvx)"(char *fact, char *uplo, int *n, int *nrhs, d *ap, d *afp, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dspsvx(char *fact, char *uplo, int *n, int *nrhs, d *ap, d *afp, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dspsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsptrd "BLAS_FUNC(dsptrd)"(char *uplo, int *n, d *ap, d *d, d *e, d *tau, int *info) nogil +cdef void dsptrd(char *uplo, int *n, d *ap, d *d, d *e, d *tau, int *info) noexcept nogil: + + _fortran_dsptrd(uplo, n, ap, d, e, tau, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsptrf "BLAS_FUNC(dsptrf)"(char *uplo, int *n, d *ap, int *ipiv, int *info) nogil +cdef void dsptrf(char *uplo, int *n, d *ap, int *ipiv, int *info) noexcept nogil: + + _fortran_dsptrf(uplo, n, ap, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsptri "BLAS_FUNC(dsptri)"(char *uplo, int *n, d *ap, int *ipiv, d *work, int *info) nogil +cdef void dsptri(char *uplo, int *n, d *ap, int *ipiv, d *work, int *info) noexcept nogil: + + _fortran_dsptri(uplo, n, ap, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsptrs "BLAS_FUNC(dsptrs)"(char *uplo, int *n, int *nrhs, d *ap, int *ipiv, d *b, int *ldb, int *info) nogil +cdef void dsptrs(char *uplo, int *n, int *nrhs, d *ap, int *ipiv, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dsptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dstebz "BLAS_FUNC(dstebz)"(char *range, char *order, int *n, d *vl, d *vu, int *il, int *iu, d *abstol, d *d, d *e, int *m, int *nsplit, d *w, int *iblock, int *isplit, d *work, int *iwork, int *info) nogil +cdef void dstebz(char *range, char *order, int *n, d *vl, d *vu, int *il, int *iu, d *abstol, d *d, d *e, int *m, int *nsplit, d *w, int *iblock, int *isplit, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dstebz(range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w, iblock, isplit, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dstedc "BLAS_FUNC(dstedc)"(char *compz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dstedc(char *compz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dstedc(compz, n, d, e, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dstegr "BLAS_FUNC(dstegr)"(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dstegr(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dstein "BLAS_FUNC(dstein)"(int *n, d *d, d *e, int *m, d *w, int *iblock, int *isplit, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) nogil +cdef void dstein(int *n, d *d, d *e, int *m, d *w, int *iblock, int *isplit, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_dstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dstemr "BLAS_FUNC(dstemr)"(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, int *m, d *w, d *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dstemr(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, int *m, d *w, d *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsteqr "BLAS_FUNC(dsteqr)"(char *compz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *info) nogil +cdef void dsteqr(char *compz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *info) noexcept nogil: + + _fortran_dsteqr(compz, n, d, e, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsterf "BLAS_FUNC(dsterf)"(int *n, d *d, d *e, int *info) nogil +cdef void dsterf(int *n, d *d, d *e, int *info) noexcept nogil: + + _fortran_dsterf(n, d, e, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dstev "BLAS_FUNC(dstev)"(char *jobz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *info) nogil +cdef void dstev(char *jobz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *info) noexcept nogil: + + _fortran_dstev(jobz, n, d, e, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dstevd "BLAS_FUNC(dstevd)"(char *jobz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dstevd(char *jobz, int *n, d *d, d *e, d *z, int *ldz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dstevd(jobz, n, d, e, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dstevr "BLAS_FUNC(dstevr)"(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dstevr(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dstevr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dstevx "BLAS_FUNC(dstevx)"(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) nogil +cdef void dstevx(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_dstevx(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsycon "BLAS_FUNC(dsycon)"(char *uplo, int *n, d *a, int *lda, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) nogil +cdef void dsycon(char *uplo, int *n, d *a, int *lda, int *ipiv, d *anorm, d *rcond, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dsycon(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsyconv "BLAS_FUNC(dsyconv)"(char *uplo, char *way, int *n, d *a, int *lda, int *ipiv, d *work, int *info) nogil +cdef void dsyconv(char *uplo, char *way, int *n, d *a, int *lda, int *ipiv, d *work, int *info) noexcept nogil: + + _fortran_dsyconv(uplo, way, n, a, lda, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsyequb "BLAS_FUNC(dsyequb)"(char *uplo, int *n, d *a, int *lda, d *s, d *scond, d *amax, d *work, int *info) nogil +cdef void dsyequb(char *uplo, int *n, d *a, int *lda, d *s, d *scond, d *amax, d *work, int *info) noexcept nogil: + + _fortran_dsyequb(uplo, n, a, lda, s, scond, amax, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsyev "BLAS_FUNC(dsyev)"(char *jobz, char *uplo, int *n, d *a, int *lda, d *w, d *work, int *lwork, int *info) nogil +cdef void dsyev(char *jobz, char *uplo, int *n, d *a, int *lda, d *w, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dsyev(jobz, uplo, n, a, lda, w, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsyevd "BLAS_FUNC(dsyevd)"(char *jobz, char *uplo, int *n, d *a, int *lda, d *w, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dsyevd(char *jobz, char *uplo, int *n, d *a, int *lda, d *w, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dsyevd(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsyevr "BLAS_FUNC(dsyevr)"(char *jobz, char *range, char *uplo, int *n, d *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dsyevr(char *jobz, char *range, char *uplo, int *n, d *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dsyevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsyevx "BLAS_FUNC(dsyevx)"(char *jobz, char *range, char *uplo, int *n, d *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *ifail, int *info) nogil +cdef void dsyevx(char *jobz, char *range, char *uplo, int *n, d *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_dsyevx(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsygs2 "BLAS_FUNC(dsygs2)"(int *itype, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, int *info) nogil +cdef void dsygs2(int *itype, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dsygs2(itype, uplo, n, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsygst "BLAS_FUNC(dsygst)"(int *itype, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, int *info) nogil +cdef void dsygst(int *itype, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dsygst(itype, uplo, n, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsygv "BLAS_FUNC(dsygv)"(int *itype, char *jobz, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, d *w, d *work, int *lwork, int *info) nogil +cdef void dsygv(int *itype, char *jobz, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, d *w, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dsygv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsygvd "BLAS_FUNC(dsygvd)"(int *itype, char *jobz, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, d *w, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dsygvd(int *itype, char *jobz, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, d *w, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dsygvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsygvx "BLAS_FUNC(dsygvx)"(int *itype, char *jobz, char *range, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *ifail, int *info) nogil +cdef void dsygvx(int *itype, char *jobz, char *range, char *uplo, int *n, d *a, int *lda, d *b, int *ldb, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, d *z, int *ldz, d *work, int *lwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_dsygvx(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsyrfs "BLAS_FUNC(dsyrfs)"(char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dsyrfs(char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dsyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsysv "BLAS_FUNC(dsysv)"(char *uplo, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, d *work, int *lwork, int *info) nogil +cdef void dsysv(char *uplo, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dsysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsysvx "BLAS_FUNC(dsysvx)"(char *fact, char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *lwork, int *iwork, int *info) nogil +cdef void dsysvx(char *fact, char *uplo, int *n, int *nrhs, d *a, int *lda, d *af, int *ldaf, int *ipiv, d *b, int *ldb, d *x, int *ldx, d *rcond, d *ferr, d *berr, d *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_dsysvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsyswapr "BLAS_FUNC(dsyswapr)"(char *uplo, int *n, d *a, int *lda, int *i1, int *i2) nogil +cdef void dsyswapr(char *uplo, int *n, d *a, int *lda, int *i1, int *i2) noexcept nogil: + + _fortran_dsyswapr(uplo, n, a, lda, i1, i2) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsytd2 "BLAS_FUNC(dsytd2)"(char *uplo, int *n, d *a, int *lda, d *d, d *e, d *tau, int *info) nogil +cdef void dsytd2(char *uplo, int *n, d *a, int *lda, d *d, d *e, d *tau, int *info) noexcept nogil: + + _fortran_dsytd2(uplo, n, a, lda, d, e, tau, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsytf2 "BLAS_FUNC(dsytf2)"(char *uplo, int *n, d *a, int *lda, int *ipiv, int *info) nogil +cdef void dsytf2(char *uplo, int *n, d *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_dsytf2(uplo, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsytrd "BLAS_FUNC(dsytrd)"(char *uplo, int *n, d *a, int *lda, d *d, d *e, d *tau, d *work, int *lwork, int *info) nogil +cdef void dsytrd(char *uplo, int *n, d *a, int *lda, d *d, d *e, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dsytrd(uplo, n, a, lda, d, e, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsytrf "BLAS_FUNC(dsytrf)"(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *lwork, int *info) nogil +cdef void dsytrf(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dsytrf(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsytri "BLAS_FUNC(dsytri)"(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *info) nogil +cdef void dsytri(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *info) noexcept nogil: + + _fortran_dsytri(uplo, n, a, lda, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsytri2 "BLAS_FUNC(dsytri2)"(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *lwork, int *info) nogil +cdef void dsytri2(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dsytri2(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsytri2x "BLAS_FUNC(dsytri2x)"(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *nb, int *info) nogil +cdef void dsytri2x(char *uplo, int *n, d *a, int *lda, int *ipiv, d *work, int *nb, int *info) noexcept nogil: + + _fortran_dsytri2x(uplo, n, a, lda, ipiv, work, nb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsytrs "BLAS_FUNC(dsytrs)"(char *uplo, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, int *info) nogil +cdef void dsytrs(char *uplo, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dsytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dsytrs2 "BLAS_FUNC(dsytrs2)"(char *uplo, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, d *work, int *info) nogil +cdef void dsytrs2(char *uplo, int *n, int *nrhs, d *a, int *lda, int *ipiv, d *b, int *ldb, d *work, int *info) noexcept nogil: + + _fortran_dsytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtbcon "BLAS_FUNC(dtbcon)"(char *norm, char *uplo, char *diag, int *n, int *kd, d *ab, int *ldab, d *rcond, d *work, int *iwork, int *info) nogil +cdef void dtbcon(char *norm, char *uplo, char *diag, int *n, int *kd, d *ab, int *ldab, d *rcond, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dtbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtbrfs "BLAS_FUNC(dtbrfs)"(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dtbrfs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dtbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtbtrs "BLAS_FUNC(dtbtrs)"(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, int *info) nogil +cdef void dtbtrs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, d *ab, int *ldab, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dtbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtfsm "BLAS_FUNC(dtfsm)"(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, d *alpha, d *a, d *b, int *ldb) nogil +cdef void dtfsm(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, d *alpha, d *a, d *b, int *ldb) noexcept nogil: + + _fortran_dtfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtftri "BLAS_FUNC(dtftri)"(char *transr, char *uplo, char *diag, int *n, d *a, int *info) nogil +cdef void dtftri(char *transr, char *uplo, char *diag, int *n, d *a, int *info) noexcept nogil: + + _fortran_dtftri(transr, uplo, diag, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtfttp "BLAS_FUNC(dtfttp)"(char *transr, char *uplo, int *n, d *arf, d *ap, int *info) nogil +cdef void dtfttp(char *transr, char *uplo, int *n, d *arf, d *ap, int *info) noexcept nogil: + + _fortran_dtfttp(transr, uplo, n, arf, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtfttr "BLAS_FUNC(dtfttr)"(char *transr, char *uplo, int *n, d *arf, d *a, int *lda, int *info) nogil +cdef void dtfttr(char *transr, char *uplo, int *n, d *arf, d *a, int *lda, int *info) noexcept nogil: + + _fortran_dtfttr(transr, uplo, n, arf, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtgevc "BLAS_FUNC(dtgevc)"(char *side, char *howmny, bint *select, int *n, d *s, int *lds, d *p, int *ldp, d *vl, int *ldvl, d *vr, int *ldvr, int *mm, int *m, d *work, int *info) nogil +cdef void dtgevc(char *side, char *howmny, bint *select, int *n, d *s, int *lds, d *p, int *ldp, d *vl, int *ldvl, d *vr, int *ldvr, int *mm, int *m, d *work, int *info) noexcept nogil: + + _fortran_dtgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtgex2 "BLAS_FUNC(dtgex2)"(bint *wantq, bint *wantz, int *n, d *a, int *lda, d *b, int *ldb, d *q, int *ldq, d *z, int *ldz, int *j1, int *n1, int *n2, d *work, int *lwork, int *info) nogil +cdef void dtgex2(bint *wantq, bint *wantz, int *n, d *a, int *lda, d *b, int *ldb, d *q, int *ldq, d *z, int *ldz, int *j1, int *n1, int *n2, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dtgex2(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, n1, n2, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtgexc "BLAS_FUNC(dtgexc)"(bint *wantq, bint *wantz, int *n, d *a, int *lda, d *b, int *ldb, d *q, int *ldq, d *z, int *ldz, int *ifst, int *ilst, d *work, int *lwork, int *info) nogil +cdef void dtgexc(bint *wantq, bint *wantz, int *n, d *a, int *lda, d *b, int *ldb, d *q, int *ldq, d *z, int *ldz, int *ifst, int *ilst, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dtgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtgsen "BLAS_FUNC(dtgsen)"(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *q, int *ldq, d *z, int *ldz, int *m, d *pl, d *pr, d *dif, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dtgsen(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, d *a, int *lda, d *b, int *ldb, d *alphar, d *alphai, d *beta, d *q, int *ldq, d *z, int *ldz, int *m, d *pl, d *pr, d *dif, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dtgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtgsja "BLAS_FUNC(dtgsja)"(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, d *a, int *lda, d *b, int *ldb, d *tola, d *tolb, d *alpha, d *beta, d *u, int *ldu, d *v, int *ldv, d *q, int *ldq, d *work, int *ncycle, int *info) nogil +cdef void dtgsja(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, d *a, int *lda, d *b, int *ldb, d *tola, d *tolb, d *alpha, d *beta, d *u, int *ldu, d *v, int *ldv, d *q, int *ldq, d *work, int *ncycle, int *info) noexcept nogil: + + _fortran_dtgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtgsna "BLAS_FUNC(dtgsna)"(char *job, char *howmny, bint *select, int *n, d *a, int *lda, d *b, int *ldb, d *vl, int *ldvl, d *vr, int *ldvr, d *s, d *dif, int *mm, int *m, d *work, int *lwork, int *iwork, int *info) nogil +cdef void dtgsna(char *job, char *howmny, bint *select, int *n, d *a, int *lda, d *b, int *ldb, d *vl, int *ldvl, d *vr, int *ldvr, d *s, d *dif, int *mm, int *m, d *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_dtgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtgsy2 "BLAS_FUNC(dtgsy2)"(char *trans, int *ijob, int *m, int *n, d *a, int *lda, d *b, int *ldb, d *c, int *ldc, d *d, int *ldd, d *e, int *lde, d *f, int *ldf, d *scale, d *rdsum, d *rdscal, int *iwork, int *pq, int *info) nogil +cdef void dtgsy2(char *trans, int *ijob, int *m, int *n, d *a, int *lda, d *b, int *ldb, d *c, int *ldc, d *d, int *ldd, d *e, int *lde, d *f, int *ldf, d *scale, d *rdsum, d *rdscal, int *iwork, int *pq, int *info) noexcept nogil: + + _fortran_dtgsy2(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, iwork, pq, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtgsyl "BLAS_FUNC(dtgsyl)"(char *trans, int *ijob, int *m, int *n, d *a, int *lda, d *b, int *ldb, d *c, int *ldc, d *d, int *ldd, d *e, int *lde, d *f, int *ldf, d *scale, d *dif, d *work, int *lwork, int *iwork, int *info) nogil +cdef void dtgsyl(char *trans, int *ijob, int *m, int *n, d *a, int *lda, d *b, int *ldb, d *c, int *ldc, d *d, int *ldd, d *e, int *lde, d *f, int *ldf, d *scale, d *dif, d *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_dtgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtpcon "BLAS_FUNC(dtpcon)"(char *norm, char *uplo, char *diag, int *n, d *ap, d *rcond, d *work, int *iwork, int *info) nogil +cdef void dtpcon(char *norm, char *uplo, char *diag, int *n, d *ap, d *rcond, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dtpcon(norm, uplo, diag, n, ap, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtpmqrt "BLAS_FUNC(dtpmqrt)"(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, d *v, int *ldv, d *t, int *ldt, d *a, int *lda, d *b, int *ldb, d *work, int *info) nogil +cdef void dtpmqrt(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, d *v, int *ldv, d *t, int *ldt, d *a, int *lda, d *b, int *ldb, d *work, int *info) noexcept nogil: + + _fortran_dtpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtpqrt "BLAS_FUNC(dtpqrt)"(int *m, int *n, int *l, int *nb, d *a, int *lda, d *b, int *ldb, d *t, int *ldt, d *work, int *info) nogil +cdef void dtpqrt(int *m, int *n, int *l, int *nb, d *a, int *lda, d *b, int *ldb, d *t, int *ldt, d *work, int *info) noexcept nogil: + + _fortran_dtpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtpqrt2 "BLAS_FUNC(dtpqrt2)"(int *m, int *n, int *l, d *a, int *lda, d *b, int *ldb, d *t, int *ldt, int *info) nogil +cdef void dtpqrt2(int *m, int *n, int *l, d *a, int *lda, d *b, int *ldb, d *t, int *ldt, int *info) noexcept nogil: + + _fortran_dtpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtprfb "BLAS_FUNC(dtprfb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, d *v, int *ldv, d *t, int *ldt, d *a, int *lda, d *b, int *ldb, d *work, int *ldwork) nogil +cdef void dtprfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, d *v, int *ldv, d *t, int *ldt, d *a, int *lda, d *b, int *ldb, d *work, int *ldwork) noexcept nogil: + + _fortran_dtprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtprfs "BLAS_FUNC(dtprfs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *ap, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dtprfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *ap, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dtprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtptri "BLAS_FUNC(dtptri)"(char *uplo, char *diag, int *n, d *ap, int *info) nogil +cdef void dtptri(char *uplo, char *diag, int *n, d *ap, int *info) noexcept nogil: + + _fortran_dtptri(uplo, diag, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtptrs "BLAS_FUNC(dtptrs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *ap, d *b, int *ldb, int *info) nogil +cdef void dtptrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *ap, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dtptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtpttf "BLAS_FUNC(dtpttf)"(char *transr, char *uplo, int *n, d *ap, d *arf, int *info) nogil +cdef void dtpttf(char *transr, char *uplo, int *n, d *ap, d *arf, int *info) noexcept nogil: + + _fortran_dtpttf(transr, uplo, n, ap, arf, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtpttr "BLAS_FUNC(dtpttr)"(char *uplo, int *n, d *ap, d *a, int *lda, int *info) nogil +cdef void dtpttr(char *uplo, int *n, d *ap, d *a, int *lda, int *info) noexcept nogil: + + _fortran_dtpttr(uplo, n, ap, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrcon "BLAS_FUNC(dtrcon)"(char *norm, char *uplo, char *diag, int *n, d *a, int *lda, d *rcond, d *work, int *iwork, int *info) nogil +cdef void dtrcon(char *norm, char *uplo, char *diag, int *n, d *a, int *lda, d *rcond, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dtrcon(norm, uplo, diag, n, a, lda, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrevc "BLAS_FUNC(dtrevc)"(char *side, char *howmny, bint *select, int *n, d *t, int *ldt, d *vl, int *ldvl, d *vr, int *ldvr, int *mm, int *m, d *work, int *info) nogil +cdef void dtrevc(char *side, char *howmny, bint *select, int *n, d *t, int *ldt, d *vl, int *ldvl, d *vr, int *ldvr, int *mm, int *m, d *work, int *info) noexcept nogil: + + _fortran_dtrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrexc "BLAS_FUNC(dtrexc)"(char *compq, int *n, d *t, int *ldt, d *q, int *ldq, int *ifst, int *ilst, d *work, int *info) nogil +cdef void dtrexc(char *compq, int *n, d *t, int *ldt, d *q, int *ldq, int *ifst, int *ilst, d *work, int *info) noexcept nogil: + + _fortran_dtrexc(compq, n, t, ldt, q, ldq, ifst, ilst, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrrfs "BLAS_FUNC(dtrrfs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) nogil +cdef void dtrrfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, d *x, int *ldx, d *ferr, d *berr, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_dtrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrsen "BLAS_FUNC(dtrsen)"(char *job, char *compq, bint *select, int *n, d *t, int *ldt, d *q, int *ldq, d *wr, d *wi, int *m, d *s, d *sep, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void dtrsen(char *job, char *compq, bint *select, int *n, d *t, int *ldt, d *q, int *ldq, d *wr, d *wi, int *m, d *s, d *sep, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_dtrsen(job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrsna "BLAS_FUNC(dtrsna)"(char *job, char *howmny, bint *select, int *n, d *t, int *ldt, d *vl, int *ldvl, d *vr, int *ldvr, d *s, d *sep, int *mm, int *m, d *work, int *ldwork, int *iwork, int *info) nogil +cdef void dtrsna(char *job, char *howmny, bint *select, int *n, d *t, int *ldt, d *vl, int *ldvl, d *vr, int *ldvr, d *s, d *sep, int *mm, int *m, d *work, int *ldwork, int *iwork, int *info) noexcept nogil: + + _fortran_dtrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrsyl "BLAS_FUNC(dtrsyl)"(char *trana, char *tranb, int *isgn, int *m, int *n, d *a, int *lda, d *b, int *ldb, d *c, int *ldc, d *scale, int *info) nogil +cdef void dtrsyl(char *trana, char *tranb, int *isgn, int *m, int *n, d *a, int *lda, d *b, int *ldb, d *c, int *ldc, d *scale, int *info) noexcept nogil: + + _fortran_dtrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrti2 "BLAS_FUNC(dtrti2)"(char *uplo, char *diag, int *n, d *a, int *lda, int *info) nogil +cdef void dtrti2(char *uplo, char *diag, int *n, d *a, int *lda, int *info) noexcept nogil: + + _fortran_dtrti2(uplo, diag, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrtri "BLAS_FUNC(dtrtri)"(char *uplo, char *diag, int *n, d *a, int *lda, int *info) nogil +cdef void dtrtri(char *uplo, char *diag, int *n, d *a, int *lda, int *info) noexcept nogil: + + _fortran_dtrtri(uplo, diag, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrtrs "BLAS_FUNC(dtrtrs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *info) nogil +cdef void dtrtrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, d *a, int *lda, d *b, int *ldb, int *info) noexcept nogil: + + _fortran_dtrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrttf "BLAS_FUNC(dtrttf)"(char *transr, char *uplo, int *n, d *a, int *lda, d *arf, int *info) nogil +cdef void dtrttf(char *transr, char *uplo, int *n, d *a, int *lda, d *arf, int *info) noexcept nogil: + + _fortran_dtrttf(transr, uplo, n, a, lda, arf, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtrttp "BLAS_FUNC(dtrttp)"(char *uplo, int *n, d *a, int *lda, d *ap, int *info) nogil +cdef void dtrttp(char *uplo, int *n, d *a, int *lda, d *ap, int *info) noexcept nogil: + + _fortran_dtrttp(uplo, n, a, lda, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_dtzrzf "BLAS_FUNC(dtzrzf)"(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) nogil +cdef void dtzrzf(int *m, int *n, d *a, int *lda, d *tau, d *work, int *lwork, int *info) noexcept nogil: + + _fortran_dtzrzf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_dzsum1 "BLAS_FUNC(dzsum1)"(int *n, npy_complex128 *cx, int *incx) nogil +cdef d dzsum1(int *n, z *cx, int *incx) noexcept nogil: + + return _fortran_dzsum1(n, cx, incx) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_icmax1 "BLAS_FUNC(icmax1)"(int *n, npy_complex64 *cx, int *incx) nogil +cdef int icmax1(int *n, c *cx, int *incx) noexcept nogil: + + return _fortran_icmax1(n, cx, incx) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_ieeeck "BLAS_FUNC(ieeeck)"(int *ispec, s *zero, s *one) nogil +cdef int ieeeck(int *ispec, s *zero, s *one) noexcept nogil: + + return _fortran_ieeeck(ispec, zero, one) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_ilaclc "BLAS_FUNC(ilaclc)"(int *m, int *n, npy_complex64 *a, int *lda) nogil +cdef int ilaclc(int *m, int *n, c *a, int *lda) noexcept nogil: + + return _fortran_ilaclc(m, n, a, lda) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_ilaclr "BLAS_FUNC(ilaclr)"(int *m, int *n, npy_complex64 *a, int *lda) nogil +cdef int ilaclr(int *m, int *n, c *a, int *lda) noexcept nogil: + + return _fortran_ilaclr(m, n, a, lda) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_iladiag "BLAS_FUNC(iladiag)"(char *diag) nogil +cdef int iladiag(char *diag) noexcept nogil: + + return _fortran_iladiag(diag) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_iladlc "BLAS_FUNC(iladlc)"(int *m, int *n, d *a, int *lda) nogil +cdef int iladlc(int *m, int *n, d *a, int *lda) noexcept nogil: + + return _fortran_iladlc(m, n, a, lda) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_iladlr "BLAS_FUNC(iladlr)"(int *m, int *n, d *a, int *lda) nogil +cdef int iladlr(int *m, int *n, d *a, int *lda) noexcept nogil: + + return _fortran_iladlr(m, n, a, lda) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_ilaprec "BLAS_FUNC(ilaprec)"(char *prec) nogil +cdef int ilaprec(char *prec) noexcept nogil: + + return _fortran_ilaprec(prec) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_ilaslc "BLAS_FUNC(ilaslc)"(int *m, int *n, s *a, int *lda) nogil +cdef int ilaslc(int *m, int *n, s *a, int *lda) noexcept nogil: + + return _fortran_ilaslc(m, n, a, lda) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_ilaslr "BLAS_FUNC(ilaslr)"(int *m, int *n, s *a, int *lda) nogil +cdef int ilaslr(int *m, int *n, s *a, int *lda) noexcept nogil: + + return _fortran_ilaslr(m, n, a, lda) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_ilatrans "BLAS_FUNC(ilatrans)"(char *trans) nogil +cdef int ilatrans(char *trans) noexcept nogil: + + return _fortran_ilatrans(trans) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_ilauplo "BLAS_FUNC(ilauplo)"(char *uplo) nogil +cdef int ilauplo(char *uplo) noexcept nogil: + + return _fortran_ilauplo(uplo) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ilaver "BLAS_FUNC(ilaver)"(int *vers_major, int *vers_minor, int *vers_patch) nogil +cdef void ilaver(int *vers_major, int *vers_minor, int *vers_patch) noexcept nogil: + + _fortran_ilaver(vers_major, vers_minor, vers_patch) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_ilazlc "BLAS_FUNC(ilazlc)"(int *m, int *n, npy_complex128 *a, int *lda) nogil +cdef int ilazlc(int *m, int *n, z *a, int *lda) noexcept nogil: + + return _fortran_ilazlc(m, n, a, lda) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_ilazlr "BLAS_FUNC(ilazlr)"(int *m, int *n, npy_complex128 *a, int *lda) nogil +cdef int ilazlr(int *m, int *n, z *a, int *lda) noexcept nogil: + + return _fortran_ilazlr(m, n, a, lda) + + +cdef extern from "_lapack_subroutines.h": + int _fortran_izmax1 "BLAS_FUNC(izmax1)"(int *n, npy_complex128 *cx, int *incx) nogil +cdef int izmax1(int *n, z *cx, int *incx) noexcept nogil: + + return _fortran_izmax1(n, cx, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sbbcsd "BLAS_FUNC(sbbcsd)"(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, s *theta, s *phi, s *u1, int *ldu1, s *u2, int *ldu2, s *v1t, int *ldv1t, s *v2t, int *ldv2t, s *b11d, s *b11e, s *b12d, s *b12e, s *b21d, s *b21e, s *b22d, s *b22e, s *work, int *lwork, int *info) nogil +cdef void sbbcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, s *theta, s *phi, s *u1, int *ldu1, s *u2, int *ldu2, s *v1t, int *ldv1t, s *v2t, int *ldv2t, s *b11d, s *b11e, s *b12d, s *b12e, s *b21d, s *b21e, s *b22d, s *b22e, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sbdsdc "BLAS_FUNC(sbdsdc)"(char *uplo, char *compq, int *n, s *d, s *e, s *u, int *ldu, s *vt, int *ldvt, s *q, int *iq, s *work, int *iwork, int *info) nogil +cdef void sbdsdc(char *uplo, char *compq, int *n, s *d, s *e, s *u, int *ldu, s *vt, int *ldvt, s *q, int *iq, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sbdsdc(uplo, compq, n, d, e, u, ldu, vt, ldvt, q, iq, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sbdsqr "BLAS_FUNC(sbdsqr)"(char *uplo, int *n, int *ncvt, int *nru, int *ncc, s *d, s *e, s *vt, int *ldvt, s *u, int *ldu, s *c, int *ldc, s *work, int *info) nogil +cdef void sbdsqr(char *uplo, int *n, int *ncvt, int *nru, int *ncc, s *d, s *e, s *vt, int *ldvt, s *u, int *ldu, s *c, int *ldc, s *work, int *info) noexcept nogil: + + _fortran_sbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_scsum1 "BLAS_FUNC(scsum1)"(int *n, npy_complex64 *cx, int *incx) nogil +cdef s scsum1(int *n, c *cx, int *incx) noexcept nogil: + + return _fortran_scsum1(n, cx, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sdisna "BLAS_FUNC(sdisna)"(char *job, int *m, int *n, s *d, s *sep, int *info) nogil +cdef void sdisna(char *job, int *m, int *n, s *d, s *sep, int *info) noexcept nogil: + + _fortran_sdisna(job, m, n, d, sep, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgbbrd "BLAS_FUNC(sgbbrd)"(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, s *ab, int *ldab, s *d, s *e, s *q, int *ldq, s *pt, int *ldpt, s *c, int *ldc, s *work, int *info) nogil +cdef void sgbbrd(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, s *ab, int *ldab, s *d, s *e, s *q, int *ldq, s *pt, int *ldpt, s *c, int *ldc, s *work, int *info) noexcept nogil: + + _fortran_sgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgbcon "BLAS_FUNC(sgbcon)"(char *norm, int *n, int *kl, int *ku, s *ab, int *ldab, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) nogil +cdef void sgbcon(char *norm, int *n, int *kl, int *ku, s *ab, int *ldab, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgbequ "BLAS_FUNC(sgbequ)"(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) nogil +cdef void sgbequ(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil: + + _fortran_sgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgbequb "BLAS_FUNC(sgbequb)"(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) nogil +cdef void sgbequb(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil: + + _fortran_sgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgbrfs "BLAS_FUNC(sgbrfs)"(char *trans, int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void sgbrfs(char *trans, int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgbsv "BLAS_FUNC(sgbsv)"(int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, int *ipiv, s *b, int *ldb, int *info) nogil +cdef void sgbsv(int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, int *ipiv, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_sgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgbsvx "BLAS_FUNC(sgbsvx)"(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, int *ipiv, char *equed, s *r, s *c, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void sgbsvx(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, int *ipiv, char *equed, s *r, s *c, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sgbsvx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgbtf2 "BLAS_FUNC(sgbtf2)"(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, int *ipiv, int *info) nogil +cdef void sgbtf2(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, int *ipiv, int *info) noexcept nogil: + + _fortran_sgbtf2(m, n, kl, ku, ab, ldab, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgbtrf "BLAS_FUNC(sgbtrf)"(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, int *ipiv, int *info) nogil +cdef void sgbtrf(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, int *ipiv, int *info) noexcept nogil: + + _fortran_sgbtrf(m, n, kl, ku, ab, ldab, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgbtrs "BLAS_FUNC(sgbtrs)"(char *trans, int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, int *ipiv, s *b, int *ldb, int *info) nogil +cdef void sgbtrs(char *trans, int *n, int *kl, int *ku, int *nrhs, s *ab, int *ldab, int *ipiv, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_sgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgebak "BLAS_FUNC(sgebak)"(char *job, char *side, int *n, int *ilo, int *ihi, s *scale, int *m, s *v, int *ldv, int *info) nogil +cdef void sgebak(char *job, char *side, int *n, int *ilo, int *ihi, s *scale, int *m, s *v, int *ldv, int *info) noexcept nogil: + + _fortran_sgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgebal "BLAS_FUNC(sgebal)"(char *job, int *n, s *a, int *lda, int *ilo, int *ihi, s *scale, int *info) nogil +cdef void sgebal(char *job, int *n, s *a, int *lda, int *ilo, int *ihi, s *scale, int *info) noexcept nogil: + + _fortran_sgebal(job, n, a, lda, ilo, ihi, scale, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgebd2 "BLAS_FUNC(sgebd2)"(int *m, int *n, s *a, int *lda, s *d, s *e, s *tauq, s *taup, s *work, int *info) nogil +cdef void sgebd2(int *m, int *n, s *a, int *lda, s *d, s *e, s *tauq, s *taup, s *work, int *info) noexcept nogil: + + _fortran_sgebd2(m, n, a, lda, d, e, tauq, taup, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgebrd "BLAS_FUNC(sgebrd)"(int *m, int *n, s *a, int *lda, s *d, s *e, s *tauq, s *taup, s *work, int *lwork, int *info) nogil +cdef void sgebrd(int *m, int *n, s *a, int *lda, s *d, s *e, s *tauq, s *taup, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgecon "BLAS_FUNC(sgecon)"(char *norm, int *n, s *a, int *lda, s *anorm, s *rcond, s *work, int *iwork, int *info) nogil +cdef void sgecon(char *norm, int *n, s *a, int *lda, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sgecon(norm, n, a, lda, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeequ "BLAS_FUNC(sgeequ)"(int *m, int *n, s *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) nogil +cdef void sgeequ(int *m, int *n, s *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil: + + _fortran_sgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeequb "BLAS_FUNC(sgeequb)"(int *m, int *n, s *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) nogil +cdef void sgeequb(int *m, int *n, s *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, int *info) noexcept nogil: + + _fortran_sgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgees "BLAS_FUNC(sgees)"(char *jobvs, char *sort, _sselect2 *select, int *n, s *a, int *lda, int *sdim, s *wr, s *wi, s *vs, int *ldvs, s *work, int *lwork, bint *bwork, int *info) nogil +cdef void sgees(char *jobvs, char *sort, sselect2 *select, int *n, s *a, int *lda, int *sdim, s *wr, s *wi, s *vs, int *ldvs, s *work, int *lwork, bint *bwork, int *info) noexcept nogil: + + _fortran_sgees(jobvs, sort, <_sselect2*>select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeesx "BLAS_FUNC(sgeesx)"(char *jobvs, char *sort, _sselect2 *select, char *sense, int *n, s *a, int *lda, int *sdim, s *wr, s *wi, s *vs, int *ldvs, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) nogil +cdef void sgeesx(char *jobvs, char *sort, sselect2 *select, char *sense, int *n, s *a, int *lda, int *sdim, s *wr, s *wi, s *vs, int *ldvs, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil: + + _fortran_sgeesx(jobvs, sort, <_sselect2*>select, sense, n, a, lda, sdim, wr, wi, vs, ldvs, rconde, rcondv, work, lwork, iwork, liwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeev "BLAS_FUNC(sgeev)"(char *jobvl, char *jobvr, int *n, s *a, int *lda, s *wr, s *wi, s *vl, int *ldvl, s *vr, int *ldvr, s *work, int *lwork, int *info) nogil +cdef void sgeev(char *jobvl, char *jobvr, int *n, s *a, int *lda, s *wr, s *wi, s *vl, int *ldvl, s *vr, int *ldvr, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeevx "BLAS_FUNC(sgeevx)"(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, s *a, int *lda, s *wr, s *wi, s *vl, int *ldvl, s *vr, int *ldvr, int *ilo, int *ihi, s *scale, s *abnrm, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, int *info) nogil +cdef void sgeevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, s *a, int *lda, s *wr, s *wi, s *vl, int *ldvl, s *vr, int *ldvr, int *ilo, int *ihi, s *scale, s *abnrm, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_sgeevx(balanc, jobvl, jobvr, sense, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, ilo, ihi, scale, abnrm, rconde, rcondv, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgehd2 "BLAS_FUNC(sgehd2)"(int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *work, int *info) nogil +cdef void sgehd2(int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil: + + _fortran_sgehd2(n, ilo, ihi, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgehrd "BLAS_FUNC(sgehrd)"(int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sgehrd(int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgejsv "BLAS_FUNC(sgejsv)"(char *joba, char *jobu, char *jobv, char *jobr, char *jobt, char *jobp, int *m, int *n, s *a, int *lda, s *sva, s *u, int *ldu, s *v, int *ldv, s *work, int *lwork, int *iwork, int *info) nogil +cdef void sgejsv(char *joba, char *jobu, char *jobv, char *jobr, char *jobt, char *jobp, int *m, int *n, s *a, int *lda, s *sva, s *u, int *ldu, s *v, int *ldv, s *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_sgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgelq2 "BLAS_FUNC(sgelq2)"(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) nogil +cdef void sgelq2(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil: + + _fortran_sgelq2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgelqf "BLAS_FUNC(sgelqf)"(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sgelqf(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgelqf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgels "BLAS_FUNC(sgels)"(char *trans, int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *work, int *lwork, int *info) nogil +cdef void sgels(char *trans, int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgelsd "BLAS_FUNC(sgelsd)"(int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *s, s *rcond, int *rank, s *work, int *lwork, int *iwork, int *info) nogil +cdef void sgelsd(int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *s, s *rcond, int *rank, s *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_sgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgelss "BLAS_FUNC(sgelss)"(int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *s, s *rcond, int *rank, s *work, int *lwork, int *info) nogil +cdef void sgelss(int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *s, s *rcond, int *rank, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgelsy "BLAS_FUNC(sgelsy)"(int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *jpvt, s *rcond, int *rank, s *work, int *lwork, int *info) nogil +cdef void sgelsy(int *m, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *jpvt, s *rcond, int *rank, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgemqrt "BLAS_FUNC(sgemqrt)"(char *side, char *trans, int *m, int *n, int *k, int *nb, s *v, int *ldv, s *t, int *ldt, s *c, int *ldc, s *work, int *info) nogil +cdef void sgemqrt(char *side, char *trans, int *m, int *n, int *k, int *nb, s *v, int *ldv, s *t, int *ldt, s *c, int *ldc, s *work, int *info) noexcept nogil: + + _fortran_sgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeql2 "BLAS_FUNC(sgeql2)"(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) nogil +cdef void sgeql2(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil: + + _fortran_sgeql2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeqlf "BLAS_FUNC(sgeqlf)"(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sgeqlf(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgeqlf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeqp3 "BLAS_FUNC(sgeqp3)"(int *m, int *n, s *a, int *lda, int *jpvt, s *tau, s *work, int *lwork, int *info) nogil +cdef void sgeqp3(int *m, int *n, s *a, int *lda, int *jpvt, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgeqp3(m, n, a, lda, jpvt, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeqr2 "BLAS_FUNC(sgeqr2)"(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) nogil +cdef void sgeqr2(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil: + + _fortran_sgeqr2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeqr2p "BLAS_FUNC(sgeqr2p)"(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) nogil +cdef void sgeqr2p(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil: + + _fortran_sgeqr2p(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeqrf "BLAS_FUNC(sgeqrf)"(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sgeqrf(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgeqrf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeqrfp "BLAS_FUNC(sgeqrfp)"(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sgeqrfp(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgeqrfp(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeqrt "BLAS_FUNC(sgeqrt)"(int *m, int *n, int *nb, s *a, int *lda, s *t, int *ldt, s *work, int *info) nogil +cdef void sgeqrt(int *m, int *n, int *nb, s *a, int *lda, s *t, int *ldt, s *work, int *info) noexcept nogil: + + _fortran_sgeqrt(m, n, nb, a, lda, t, ldt, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeqrt2 "BLAS_FUNC(sgeqrt2)"(int *m, int *n, s *a, int *lda, s *t, int *ldt, int *info) nogil +cdef void sgeqrt2(int *m, int *n, s *a, int *lda, s *t, int *ldt, int *info) noexcept nogil: + + _fortran_sgeqrt2(m, n, a, lda, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgeqrt3 "BLAS_FUNC(sgeqrt3)"(int *m, int *n, s *a, int *lda, s *t, int *ldt, int *info) nogil +cdef void sgeqrt3(int *m, int *n, s *a, int *lda, s *t, int *ldt, int *info) noexcept nogil: + + _fortran_sgeqrt3(m, n, a, lda, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgerfs "BLAS_FUNC(sgerfs)"(char *trans, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void sgerfs(char *trans, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgerq2 "BLAS_FUNC(sgerq2)"(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) nogil +cdef void sgerq2(int *m, int *n, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil: + + _fortran_sgerq2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgerqf "BLAS_FUNC(sgerqf)"(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sgerqf(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgerqf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgesc2 "BLAS_FUNC(sgesc2)"(int *n, s *a, int *lda, s *rhs, int *ipiv, int *jpiv, s *scale) nogil +cdef void sgesc2(int *n, s *a, int *lda, s *rhs, int *ipiv, int *jpiv, s *scale) noexcept nogil: + + _fortran_sgesc2(n, a, lda, rhs, ipiv, jpiv, scale) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgesdd "BLAS_FUNC(sgesdd)"(char *jobz, int *m, int *n, s *a, int *lda, s *s, s *u, int *ldu, s *vt, int *ldvt, s *work, int *lwork, int *iwork, int *info) nogil +cdef void sgesdd(char *jobz, int *m, int *n, s *a, int *lda, s *s, s *u, int *ldu, s *vt, int *ldvt, s *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_sgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgesv "BLAS_FUNC(sgesv)"(int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, int *info) nogil +cdef void sgesv(int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_sgesv(n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgesvd "BLAS_FUNC(sgesvd)"(char *jobu, char *jobvt, int *m, int *n, s *a, int *lda, s *s, s *u, int *ldu, s *vt, int *ldvt, s *work, int *lwork, int *info) nogil +cdef void sgesvd(char *jobu, char *jobvt, int *m, int *n, s *a, int *lda, s *s, s *u, int *ldu, s *vt, int *ldvt, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgesvj "BLAS_FUNC(sgesvj)"(char *joba, char *jobu, char *jobv, int *m, int *n, s *a, int *lda, s *sva, int *mv, s *v, int *ldv, s *work, int *lwork, int *info) nogil +cdef void sgesvj(char *joba, char *jobu, char *jobv, int *m, int *n, s *a, int *lda, s *sva, int *mv, s *v, int *ldv, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgesvx "BLAS_FUNC(sgesvx)"(char *fact, char *trans, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, char *equed, s *r, s *c, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void sgesvx(char *fact, char *trans, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, char *equed, s *r, s *c, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sgesvx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgetc2 "BLAS_FUNC(sgetc2)"(int *n, s *a, int *lda, int *ipiv, int *jpiv, int *info) nogil +cdef void sgetc2(int *n, s *a, int *lda, int *ipiv, int *jpiv, int *info) noexcept nogil: + + _fortran_sgetc2(n, a, lda, ipiv, jpiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgetf2 "BLAS_FUNC(sgetf2)"(int *m, int *n, s *a, int *lda, int *ipiv, int *info) nogil +cdef void sgetf2(int *m, int *n, s *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_sgetf2(m, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgetrf "BLAS_FUNC(sgetrf)"(int *m, int *n, s *a, int *lda, int *ipiv, int *info) nogil +cdef void sgetrf(int *m, int *n, s *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_sgetrf(m, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgetri "BLAS_FUNC(sgetri)"(int *n, s *a, int *lda, int *ipiv, s *work, int *lwork, int *info) nogil +cdef void sgetri(int *n, s *a, int *lda, int *ipiv, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgetri(n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgetrs "BLAS_FUNC(sgetrs)"(char *trans, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, int *info) nogil +cdef void sgetrs(char *trans, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_sgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sggbak "BLAS_FUNC(sggbak)"(char *job, char *side, int *n, int *ilo, int *ihi, s *lscale, s *rscale, int *m, s *v, int *ldv, int *info) nogil +cdef void sggbak(char *job, char *side, int *n, int *ilo, int *ihi, s *lscale, s *rscale, int *m, s *v, int *ldv, int *info) noexcept nogil: + + _fortran_sggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sggbal "BLAS_FUNC(sggbal)"(char *job, int *n, s *a, int *lda, s *b, int *ldb, int *ilo, int *ihi, s *lscale, s *rscale, s *work, int *info) nogil +cdef void sggbal(char *job, int *n, s *a, int *lda, s *b, int *ldb, int *ilo, int *ihi, s *lscale, s *rscale, s *work, int *info) noexcept nogil: + + _fortran_sggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgges "BLAS_FUNC(sgges)"(char *jobvsl, char *jobvsr, char *sort, _sselect3 *selctg, int *n, s *a, int *lda, s *b, int *ldb, int *sdim, s *alphar, s *alphai, s *beta, s *vsl, int *ldvsl, s *vsr, int *ldvsr, s *work, int *lwork, bint *bwork, int *info) nogil +cdef void sgges(char *jobvsl, char *jobvsr, char *sort, sselect3 *selctg, int *n, s *a, int *lda, s *b, int *ldb, int *sdim, s *alphar, s *alphai, s *beta, s *vsl, int *ldvsl, s *vsr, int *ldvsr, s *work, int *lwork, bint *bwork, int *info) noexcept nogil: + + _fortran_sgges(jobvsl, jobvsr, sort, <_sselect3*>selctg, n, a, lda, b, ldb, sdim, alphar, alphai, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sggesx "BLAS_FUNC(sggesx)"(char *jobvsl, char *jobvsr, char *sort, _sselect3 *selctg, char *sense, int *n, s *a, int *lda, s *b, int *ldb, int *sdim, s *alphar, s *alphai, s *beta, s *vsl, int *ldvsl, s *vsr, int *ldvsr, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) nogil +cdef void sggesx(char *jobvsl, char *jobvsr, char *sort, sselect3 *selctg, char *sense, int *n, s *a, int *lda, s *b, int *ldb, int *sdim, s *alphar, s *alphai, s *beta, s *vsl, int *ldvsl, s *vsr, int *ldvsr, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil: + + _fortran_sggesx(jobvsl, jobvsr, sort, <_sselect3*>selctg, sense, n, a, lda, b, ldb, sdim, alphar, alphai, beta, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, iwork, liwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sggev "BLAS_FUNC(sggev)"(char *jobvl, char *jobvr, int *n, s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *vl, int *ldvl, s *vr, int *ldvr, s *work, int *lwork, int *info) nogil +cdef void sggev(char *jobvl, char *jobvr, int *n, s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *vl, int *ldvl, s *vr, int *ldvr, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sggev(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sggevx "BLAS_FUNC(sggevx)"(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *vl, int *ldvl, s *vr, int *ldvr, int *ilo, int *ihi, s *lscale, s *rscale, s *abnrm, s *bbnrm, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, bint *bwork, int *info) nogil +cdef void sggevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *vl, int *ldvl, s *vr, int *ldvr, int *ilo, int *ihi, s *lscale, s *rscale, s *abnrm, s *bbnrm, s *rconde, s *rcondv, s *work, int *lwork, int *iwork, bint *bwork, int *info) noexcept nogil: + + _fortran_sggevx(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, iwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sggglm "BLAS_FUNC(sggglm)"(int *n, int *m, int *p, s *a, int *lda, s *b, int *ldb, s *d, s *x, s *y, s *work, int *lwork, int *info) nogil +cdef void sggglm(int *n, int *m, int *p, s *a, int *lda, s *b, int *ldb, s *d, s *x, s *y, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgghrd "BLAS_FUNC(sgghrd)"(char *compq, char *compz, int *n, int *ilo, int *ihi, s *a, int *lda, s *b, int *ldb, s *q, int *ldq, s *z, int *ldz, int *info) nogil +cdef void sgghrd(char *compq, char *compz, int *n, int *ilo, int *ihi, s *a, int *lda, s *b, int *ldb, s *q, int *ldq, s *z, int *ldz, int *info) noexcept nogil: + + _fortran_sgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgglse "BLAS_FUNC(sgglse)"(int *m, int *n, int *p, s *a, int *lda, s *b, int *ldb, s *c, s *d, s *x, s *work, int *lwork, int *info) nogil +cdef void sgglse(int *m, int *n, int *p, s *a, int *lda, s *b, int *ldb, s *c, s *d, s *x, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sggqrf "BLAS_FUNC(sggqrf)"(int *n, int *m, int *p, s *a, int *lda, s *taua, s *b, int *ldb, s *taub, s *work, int *lwork, int *info) nogil +cdef void sggqrf(int *n, int *m, int *p, s *a, int *lda, s *taua, s *b, int *ldb, s *taub, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sggrqf "BLAS_FUNC(sggrqf)"(int *m, int *p, int *n, s *a, int *lda, s *taua, s *b, int *ldb, s *taub, s *work, int *lwork, int *info) nogil +cdef void sggrqf(int *m, int *p, int *n, s *a, int *lda, s *taua, s *b, int *ldb, s *taub, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgsvj0 "BLAS_FUNC(sgsvj0)"(char *jobv, int *m, int *n, s *a, int *lda, s *d, s *sva, int *mv, s *v, int *ldv, s *eps, s *sfmin, s *tol, int *nsweep, s *work, int *lwork, int *info) nogil +cdef void sgsvj0(char *jobv, int *m, int *n, s *a, int *lda, s *d, s *sva, int *mv, s *v, int *ldv, s *eps, s *sfmin, s *tol, int *nsweep, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgsvj1 "BLAS_FUNC(sgsvj1)"(char *jobv, int *m, int *n, int *n1, s *a, int *lda, s *d, s *sva, int *mv, s *v, int *ldv, s *eps, s *sfmin, s *tol, int *nsweep, s *work, int *lwork, int *info) nogil +cdef void sgsvj1(char *jobv, int *m, int *n, int *n1, s *a, int *lda, s *d, s *sva, int *mv, s *v, int *ldv, s *eps, s *sfmin, s *tol, int *nsweep, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgtcon "BLAS_FUNC(sgtcon)"(char *norm, int *n, s *dl, s *d, s *du, s *du2, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) nogil +cdef void sgtcon(char *norm, int *n, s *dl, s *d, s *du, s *du2, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgtrfs "BLAS_FUNC(sgtrfs)"(char *trans, int *n, int *nrhs, s *dl, s *d, s *du, s *dlf, s *df, s *duf, s *du2, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void sgtrfs(char *trans, int *n, int *nrhs, s *dl, s *d, s *du, s *dlf, s *df, s *duf, s *du2, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgtsv "BLAS_FUNC(sgtsv)"(int *n, int *nrhs, s *dl, s *d, s *du, s *b, int *ldb, int *info) nogil +cdef void sgtsv(int *n, int *nrhs, s *dl, s *d, s *du, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_sgtsv(n, nrhs, dl, d, du, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgtsvx "BLAS_FUNC(sgtsvx)"(char *fact, char *trans, int *n, int *nrhs, s *dl, s *d, s *du, s *dlf, s *df, s *duf, s *du2, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void sgtsvx(char *fact, char *trans, int *n, int *nrhs, s *dl, s *d, s *du, s *dlf, s *df, s *duf, s *du2, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sgtsvx(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgttrf "BLAS_FUNC(sgttrf)"(int *n, s *dl, s *d, s *du, s *du2, int *ipiv, int *info) nogil +cdef void sgttrf(int *n, s *dl, s *d, s *du, s *du2, int *ipiv, int *info) noexcept nogil: + + _fortran_sgttrf(n, dl, d, du, du2, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgttrs "BLAS_FUNC(sgttrs)"(char *trans, int *n, int *nrhs, s *dl, s *d, s *du, s *du2, int *ipiv, s *b, int *ldb, int *info) nogil +cdef void sgttrs(char *trans, int *n, int *nrhs, s *dl, s *d, s *du, s *du2, int *ipiv, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_sgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sgtts2 "BLAS_FUNC(sgtts2)"(int *itrans, int *n, int *nrhs, s *dl, s *d, s *du, s *du2, int *ipiv, s *b, int *ldb) nogil +cdef void sgtts2(int *itrans, int *n, int *nrhs, s *dl, s *d, s *du, s *du2, int *ipiv, s *b, int *ldb) noexcept nogil: + + _fortran_sgtts2(itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_shgeqz "BLAS_FUNC(shgeqz)"(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *t, int *ldt, s *alphar, s *alphai, s *beta, s *q, int *ldq, s *z, int *ldz, s *work, int *lwork, int *info) nogil +cdef void shgeqz(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *t, int *ldt, s *alphar, s *alphai, s *beta, s *q, int *ldq, s *z, int *ldz, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_shgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_shsein "BLAS_FUNC(shsein)"(char *side, char *eigsrc, char *initv, bint *select, int *n, s *h, int *ldh, s *wr, s *wi, s *vl, int *ldvl, s *vr, int *ldvr, int *mm, int *m, s *work, int *ifaill, int *ifailr, int *info) nogil +cdef void shsein(char *side, char *eigsrc, char *initv, bint *select, int *n, s *h, int *ldh, s *wr, s *wi, s *vl, int *ldvl, s *vr, int *ldvr, int *mm, int *m, s *work, int *ifaill, int *ifailr, int *info) noexcept nogil: + + _fortran_shsein(side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_shseqr "BLAS_FUNC(shseqr)"(char *job, char *compz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, s *z, int *ldz, s *work, int *lwork, int *info) nogil +cdef void shseqr(char *job, char *compz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, s *z, int *ldz, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_shseqr(job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slabad "BLAS_FUNC(slabad)"(s *small, s *large) nogil +cdef void slabad(s *small, s *large) noexcept nogil: + + _fortran_slabad(small, large) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slabrd "BLAS_FUNC(slabrd)"(int *m, int *n, int *nb, s *a, int *lda, s *d, s *e, s *tauq, s *taup, s *x, int *ldx, s *y, int *ldy) nogil +cdef void slabrd(int *m, int *n, int *nb, s *a, int *lda, s *d, s *e, s *tauq, s *taup, s *x, int *ldx, s *y, int *ldy) noexcept nogil: + + _fortran_slabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slacn2 "BLAS_FUNC(slacn2)"(int *n, s *v, s *x, int *isgn, s *est, int *kase, int *isave) nogil +cdef void slacn2(int *n, s *v, s *x, int *isgn, s *est, int *kase, int *isave) noexcept nogil: + + _fortran_slacn2(n, v, x, isgn, est, kase, isave) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slacon "BLAS_FUNC(slacon)"(int *n, s *v, s *x, int *isgn, s *est, int *kase) nogil +cdef void slacon(int *n, s *v, s *x, int *isgn, s *est, int *kase) noexcept nogil: + + _fortran_slacon(n, v, x, isgn, est, kase) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slacpy "BLAS_FUNC(slacpy)"(char *uplo, int *m, int *n, s *a, int *lda, s *b, int *ldb) nogil +cdef void slacpy(char *uplo, int *m, int *n, s *a, int *lda, s *b, int *ldb) noexcept nogil: + + _fortran_slacpy(uplo, m, n, a, lda, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sladiv "BLAS_FUNC(sladiv)"(s *a, s *b, s *c, s *d, s *p, s *q) nogil +cdef void sladiv(s *a, s *b, s *c, s *d, s *p, s *q) noexcept nogil: + + _fortran_sladiv(a, b, c, d, p, q) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slae2 "BLAS_FUNC(slae2)"(s *a, s *b, s *c, s *rt1, s *rt2) nogil +cdef void slae2(s *a, s *b, s *c, s *rt1, s *rt2) noexcept nogil: + + _fortran_slae2(a, b, c, rt1, rt2) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaebz "BLAS_FUNC(slaebz)"(int *ijob, int *nitmax, int *n, int *mmax, int *minp, int *nbmin, s *abstol, s *reltol, s *pivmin, s *d, s *e, s *e2, int *nval, s *ab, s *c, int *mout, int *nab, s *work, int *iwork, int *info) nogil +cdef void slaebz(int *ijob, int *nitmax, int *n, int *mmax, int *minp, int *nbmin, s *abstol, s *reltol, s *pivmin, s *d, s *e, s *e2, int *nval, s *ab, s *c, int *mout, int *nab, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_slaebz(ijob, nitmax, n, mmax, minp, nbmin, abstol, reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaed0 "BLAS_FUNC(slaed0)"(int *icompq, int *qsiz, int *n, s *d, s *e, s *q, int *ldq, s *qstore, int *ldqs, s *work, int *iwork, int *info) nogil +cdef void slaed0(int *icompq, int *qsiz, int *n, s *d, s *e, s *q, int *ldq, s *qstore, int *ldqs, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_slaed0(icompq, qsiz, n, d, e, q, ldq, qstore, ldqs, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaed1 "BLAS_FUNC(slaed1)"(int *n, s *d, s *q, int *ldq, int *indxq, s *rho, int *cutpnt, s *work, int *iwork, int *info) nogil +cdef void slaed1(int *n, s *d, s *q, int *ldq, int *indxq, s *rho, int *cutpnt, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_slaed1(n, d, q, ldq, indxq, rho, cutpnt, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaed2 "BLAS_FUNC(slaed2)"(int *k, int *n, int *n1, s *d, s *q, int *ldq, int *indxq, s *rho, s *z, s *dlamda, s *w, s *q2, int *indx, int *indxc, int *indxp, int *coltyp, int *info) nogil +cdef void slaed2(int *k, int *n, int *n1, s *d, s *q, int *ldq, int *indxq, s *rho, s *z, s *dlamda, s *w, s *q2, int *indx, int *indxc, int *indxp, int *coltyp, int *info) noexcept nogil: + + _fortran_slaed2(k, n, n1, d, q, ldq, indxq, rho, z, dlamda, w, q2, indx, indxc, indxp, coltyp, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaed3 "BLAS_FUNC(slaed3)"(int *k, int *n, int *n1, s *d, s *q, int *ldq, s *rho, s *dlamda, s *q2, int *indx, int *ctot, s *w, s *s, int *info) nogil +cdef void slaed3(int *k, int *n, int *n1, s *d, s *q, int *ldq, s *rho, s *dlamda, s *q2, int *indx, int *ctot, s *w, s *s, int *info) noexcept nogil: + + _fortran_slaed3(k, n, n1, d, q, ldq, rho, dlamda, q2, indx, ctot, w, s, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaed4 "BLAS_FUNC(slaed4)"(int *n, int *i, s *d, s *z, s *delta, s *rho, s *dlam, int *info) nogil +cdef void slaed4(int *n, int *i, s *d, s *z, s *delta, s *rho, s *dlam, int *info) noexcept nogil: + + _fortran_slaed4(n, i, d, z, delta, rho, dlam, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaed5 "BLAS_FUNC(slaed5)"(int *i, s *d, s *z, s *delta, s *rho, s *dlam) nogil +cdef void slaed5(int *i, s *d, s *z, s *delta, s *rho, s *dlam) noexcept nogil: + + _fortran_slaed5(i, d, z, delta, rho, dlam) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaed6 "BLAS_FUNC(slaed6)"(int *kniter, bint *orgati, s *rho, s *d, s *z, s *finit, s *tau, int *info) nogil +cdef void slaed6(int *kniter, bint *orgati, s *rho, s *d, s *z, s *finit, s *tau, int *info) noexcept nogil: + + _fortran_slaed6(kniter, orgati, rho, d, z, finit, tau, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaed7 "BLAS_FUNC(slaed7)"(int *icompq, int *n, int *qsiz, int *tlvls, int *curlvl, int *curpbm, s *d, s *q, int *ldq, int *indxq, s *rho, int *cutpnt, s *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, s *givnum, s *work, int *iwork, int *info) nogil +cdef void slaed7(int *icompq, int *n, int *qsiz, int *tlvls, int *curlvl, int *curpbm, s *d, s *q, int *ldq, int *indxq, s *rho, int *cutpnt, s *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, s *givnum, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_slaed7(icompq, n, qsiz, tlvls, curlvl, curpbm, d, q, ldq, indxq, rho, cutpnt, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaed8 "BLAS_FUNC(slaed8)"(int *icompq, int *k, int *n, int *qsiz, s *d, s *q, int *ldq, int *indxq, s *rho, int *cutpnt, s *z, s *dlamda, s *q2, int *ldq2, s *w, int *perm, int *givptr, int *givcol, s *givnum, int *indxp, int *indx, int *info) nogil +cdef void slaed8(int *icompq, int *k, int *n, int *qsiz, s *d, s *q, int *ldq, int *indxq, s *rho, int *cutpnt, s *z, s *dlamda, s *q2, int *ldq2, s *w, int *perm, int *givptr, int *givcol, s *givnum, int *indxp, int *indx, int *info) noexcept nogil: + + _fortran_slaed8(icompq, k, n, qsiz, d, q, ldq, indxq, rho, cutpnt, z, dlamda, q2, ldq2, w, perm, givptr, givcol, givnum, indxp, indx, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaed9 "BLAS_FUNC(slaed9)"(int *k, int *kstart, int *kstop, int *n, s *d, s *q, int *ldq, s *rho, s *dlamda, s *w, s *s, int *lds, int *info) nogil +cdef void slaed9(int *k, int *kstart, int *kstop, int *n, s *d, s *q, int *ldq, s *rho, s *dlamda, s *w, s *s, int *lds, int *info) noexcept nogil: + + _fortran_slaed9(k, kstart, kstop, n, d, q, ldq, rho, dlamda, w, s, lds, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaeda "BLAS_FUNC(slaeda)"(int *n, int *tlvls, int *curlvl, int *curpbm, int *prmptr, int *perm, int *givptr, int *givcol, s *givnum, s *q, int *qptr, s *z, s *ztemp, int *info) nogil +cdef void slaeda(int *n, int *tlvls, int *curlvl, int *curpbm, int *prmptr, int *perm, int *givptr, int *givcol, s *givnum, s *q, int *qptr, s *z, s *ztemp, int *info) noexcept nogil: + + _fortran_slaeda(n, tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, z, ztemp, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaein "BLAS_FUNC(slaein)"(bint *rightv, bint *noinit, int *n, s *h, int *ldh, s *wr, s *wi, s *vr, s *vi, s *b, int *ldb, s *work, s *eps3, s *smlnum, s *bignum, int *info) nogil +cdef void slaein(bint *rightv, bint *noinit, int *n, s *h, int *ldh, s *wr, s *wi, s *vr, s *vi, s *b, int *ldb, s *work, s *eps3, s *smlnum, s *bignum, int *info) noexcept nogil: + + _fortran_slaein(rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb, work, eps3, smlnum, bignum, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaev2 "BLAS_FUNC(slaev2)"(s *a, s *b, s *c, s *rt1, s *rt2, s *cs1, s *sn1) nogil +cdef void slaev2(s *a, s *b, s *c, s *rt1, s *rt2, s *cs1, s *sn1) noexcept nogil: + + _fortran_slaev2(a, b, c, rt1, rt2, cs1, sn1) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaexc "BLAS_FUNC(slaexc)"(bint *wantq, int *n, s *t, int *ldt, s *q, int *ldq, int *j1, int *n1, int *n2, s *work, int *info) nogil +cdef void slaexc(bint *wantq, int *n, s *t, int *ldt, s *q, int *ldq, int *j1, int *n1, int *n2, s *work, int *info) noexcept nogil: + + _fortran_slaexc(wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slag2 "BLAS_FUNC(slag2)"(s *a, int *lda, s *b, int *ldb, s *safmin, s *scale1, s *scale2, s *wr1, s *wr2, s *wi) nogil +cdef void slag2(s *a, int *lda, s *b, int *ldb, s *safmin, s *scale1, s *scale2, s *wr1, s *wr2, s *wi) noexcept nogil: + + _fortran_slag2(a, lda, b, ldb, safmin, scale1, scale2, wr1, wr2, wi) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slag2d "BLAS_FUNC(slag2d)"(int *m, int *n, s *sa, int *ldsa, d *a, int *lda, int *info) nogil +cdef void slag2d(int *m, int *n, s *sa, int *ldsa, d *a, int *lda, int *info) noexcept nogil: + + _fortran_slag2d(m, n, sa, ldsa, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slags2 "BLAS_FUNC(slags2)"(bint *upper, s *a1, s *a2, s *a3, s *b1, s *b2, s *b3, s *csu, s *snu, s *csv, s *snv, s *csq, s *snq) nogil +cdef void slags2(bint *upper, s *a1, s *a2, s *a3, s *b1, s *b2, s *b3, s *csu, s *snu, s *csv, s *snv, s *csq, s *snq) noexcept nogil: + + _fortran_slags2(upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slagtf "BLAS_FUNC(slagtf)"(int *n, s *a, s *lambda_, s *b, s *c, s *tol, s *d, int *in_, int *info) nogil +cdef void slagtf(int *n, s *a, s *lambda_, s *b, s *c, s *tol, s *d, int *in_, int *info) noexcept nogil: + + _fortran_slagtf(n, a, lambda_, b, c, tol, d, in_, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slagtm "BLAS_FUNC(slagtm)"(char *trans, int *n, int *nrhs, s *alpha, s *dl, s *d, s *du, s *x, int *ldx, s *beta, s *b, int *ldb) nogil +cdef void slagtm(char *trans, int *n, int *nrhs, s *alpha, s *dl, s *d, s *du, s *x, int *ldx, s *beta, s *b, int *ldb) noexcept nogil: + + _fortran_slagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slagts "BLAS_FUNC(slagts)"(int *job, int *n, s *a, s *b, s *c, s *d, int *in_, s *y, s *tol, int *info) nogil +cdef void slagts(int *job, int *n, s *a, s *b, s *c, s *d, int *in_, s *y, s *tol, int *info) noexcept nogil: + + _fortran_slagts(job, n, a, b, c, d, in_, y, tol, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slagv2 "BLAS_FUNC(slagv2)"(s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *csl, s *snl, s *csr, s *snr) nogil +cdef void slagv2(s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *csl, s *snl, s *csr, s *snr) noexcept nogil: + + _fortran_slagv2(a, lda, b, ldb, alphar, alphai, beta, csl, snl, csr, snr) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slahqr "BLAS_FUNC(slahqr)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, int *iloz, int *ihiz, s *z, int *ldz, int *info) nogil +cdef void slahqr(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, int *iloz, int *ihiz, s *z, int *ldz, int *info) noexcept nogil: + + _fortran_slahqr(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slahr2 "BLAS_FUNC(slahr2)"(int *n, int *k, int *nb, s *a, int *lda, s *tau, s *t, int *ldt, s *y, int *ldy) nogil +cdef void slahr2(int *n, int *k, int *nb, s *a, int *lda, s *tau, s *t, int *ldt, s *y, int *ldy) noexcept nogil: + + _fortran_slahr2(n, k, nb, a, lda, tau, t, ldt, y, ldy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaic1 "BLAS_FUNC(slaic1)"(int *job, int *j, s *x, s *sest, s *w, s *gamma, s *sestpr, s *s, s *c) nogil +cdef void slaic1(int *job, int *j, s *x, s *sest, s *w, s *gamma, s *sestpr, s *s, s *c) noexcept nogil: + + _fortran_slaic1(job, j, x, sest, w, gamma, sestpr, s, c) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaln2 "BLAS_FUNC(slaln2)"(bint *ltrans, int *na, int *nw, s *smin, s *ca, s *a, int *lda, s *d1, s *d2, s *b, int *ldb, s *wr, s *wi, s *x, int *ldx, s *scale, s *xnorm, int *info) nogil +cdef void slaln2(bint *ltrans, int *na, int *nw, s *smin, s *ca, s *a, int *lda, s *d1, s *d2, s *b, int *ldb, s *wr, s *wi, s *x, int *ldx, s *scale, s *xnorm, int *info) noexcept nogil: + + _fortran_slaln2(ltrans, na, nw, smin, ca, a, lda, d1, d2, b, ldb, wr, wi, x, ldx, scale, xnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slals0 "BLAS_FUNC(slals0)"(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, s *b, int *ldb, s *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *poles, s *difl, s *difr, s *z, int *k, s *c, s *s, s *work, int *info) nogil +cdef void slals0(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, s *b, int *ldb, s *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *poles, s *difl, s *difr, s *z, int *k, s *c, s *s, s *work, int *info) noexcept nogil: + + _fortran_slals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slalsa "BLAS_FUNC(slalsa)"(int *icompq, int *smlsiz, int *n, int *nrhs, s *b, int *ldb, s *bx, int *ldbx, s *u, int *ldu, s *vt, int *k, s *difl, s *difr, s *z, s *poles, int *givptr, int *givcol, int *ldgcol, int *perm, s *givnum, s *c, s *s, s *work, int *iwork, int *info) nogil +cdef void slalsa(int *icompq, int *smlsiz, int *n, int *nrhs, s *b, int *ldb, s *bx, int *ldbx, s *u, int *ldu, s *vt, int *k, s *difl, s *difr, s *z, s *poles, int *givptr, int *givcol, int *ldgcol, int *perm, s *givnum, s *c, s *s, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_slalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slalsd "BLAS_FUNC(slalsd)"(char *uplo, int *smlsiz, int *n, int *nrhs, s *d, s *e, s *b, int *ldb, s *rcond, int *rank, s *work, int *iwork, int *info) nogil +cdef void slalsd(char *uplo, int *smlsiz, int *n, int *nrhs, s *d, s *e, s *b, int *ldb, s *rcond, int *rank, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_slalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slamch "BLAS_FUNC(slamch)"(char *cmach) nogil +cdef s slamch(char *cmach) noexcept nogil: + + return _fortran_slamch(cmach) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slamrg "BLAS_FUNC(slamrg)"(int *n1, int *n2, s *a, int *strd1, int *strd2, int *index_bn) nogil +cdef void slamrg(int *n1, int *n2, s *a, int *strd1, int *strd2, int *index_bn) noexcept nogil: + + _fortran_slamrg(n1, n2, a, strd1, strd2, index_bn) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slangb "BLAS_FUNC(slangb)"(char *norm, int *n, int *kl, int *ku, s *ab, int *ldab, s *work) nogil +cdef s slangb(char *norm, int *n, int *kl, int *ku, s *ab, int *ldab, s *work) noexcept nogil: + + return _fortran_slangb(norm, n, kl, ku, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slange "BLAS_FUNC(slange)"(char *norm, int *m, int *n, s *a, int *lda, s *work) nogil +cdef s slange(char *norm, int *m, int *n, s *a, int *lda, s *work) noexcept nogil: + + return _fortran_slange(norm, m, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slangt "BLAS_FUNC(slangt)"(char *norm, int *n, s *dl, s *d, s *du) nogil +cdef s slangt(char *norm, int *n, s *dl, s *d, s *du) noexcept nogil: + + return _fortran_slangt(norm, n, dl, d, du) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slanhs "BLAS_FUNC(slanhs)"(char *norm, int *n, s *a, int *lda, s *work) nogil +cdef s slanhs(char *norm, int *n, s *a, int *lda, s *work) noexcept nogil: + + return _fortran_slanhs(norm, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slansb "BLAS_FUNC(slansb)"(char *norm, char *uplo, int *n, int *k, s *ab, int *ldab, s *work) nogil +cdef s slansb(char *norm, char *uplo, int *n, int *k, s *ab, int *ldab, s *work) noexcept nogil: + + return _fortran_slansb(norm, uplo, n, k, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slansf "BLAS_FUNC(slansf)"(char *norm, char *transr, char *uplo, int *n, s *a, s *work) nogil +cdef s slansf(char *norm, char *transr, char *uplo, int *n, s *a, s *work) noexcept nogil: + + return _fortran_slansf(norm, transr, uplo, n, a, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slansp "BLAS_FUNC(slansp)"(char *norm, char *uplo, int *n, s *ap, s *work) nogil +cdef s slansp(char *norm, char *uplo, int *n, s *ap, s *work) noexcept nogil: + + return _fortran_slansp(norm, uplo, n, ap, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slanst "BLAS_FUNC(slanst)"(char *norm, int *n, s *d, s *e) nogil +cdef s slanst(char *norm, int *n, s *d, s *e) noexcept nogil: + + return _fortran_slanst(norm, n, d, e) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slansy "BLAS_FUNC(slansy)"(char *norm, char *uplo, int *n, s *a, int *lda, s *work) nogil +cdef s slansy(char *norm, char *uplo, int *n, s *a, int *lda, s *work) noexcept nogil: + + return _fortran_slansy(norm, uplo, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slantb "BLAS_FUNC(slantb)"(char *norm, char *uplo, char *diag, int *n, int *k, s *ab, int *ldab, s *work) nogil +cdef s slantb(char *norm, char *uplo, char *diag, int *n, int *k, s *ab, int *ldab, s *work) noexcept nogil: + + return _fortran_slantb(norm, uplo, diag, n, k, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slantp "BLAS_FUNC(slantp)"(char *norm, char *uplo, char *diag, int *n, s *ap, s *work) nogil +cdef s slantp(char *norm, char *uplo, char *diag, int *n, s *ap, s *work) noexcept nogil: + + return _fortran_slantp(norm, uplo, diag, n, ap, work) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slantr "BLAS_FUNC(slantr)"(char *norm, char *uplo, char *diag, int *m, int *n, s *a, int *lda, s *work) nogil +cdef s slantr(char *norm, char *uplo, char *diag, int *m, int *n, s *a, int *lda, s *work) noexcept nogil: + + return _fortran_slantr(norm, uplo, diag, m, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slanv2 "BLAS_FUNC(slanv2)"(s *a, s *b, s *c, s *d, s *rt1r, s *rt1i, s *rt2r, s *rt2i, s *cs, s *sn) nogil +cdef void slanv2(s *a, s *b, s *c, s *d, s *rt1r, s *rt1i, s *rt2r, s *rt2i, s *cs, s *sn) noexcept nogil: + + _fortran_slanv2(a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slapll "BLAS_FUNC(slapll)"(int *n, s *x, int *incx, s *y, int *incy, s *ssmin) nogil +cdef void slapll(int *n, s *x, int *incx, s *y, int *incy, s *ssmin) noexcept nogil: + + _fortran_slapll(n, x, incx, y, incy, ssmin) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slapmr "BLAS_FUNC(slapmr)"(bint *forwrd, int *m, int *n, s *x, int *ldx, int *k) nogil +cdef void slapmr(bint *forwrd, int *m, int *n, s *x, int *ldx, int *k) noexcept nogil: + + _fortran_slapmr(forwrd, m, n, x, ldx, k) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slapmt "BLAS_FUNC(slapmt)"(bint *forwrd, int *m, int *n, s *x, int *ldx, int *k) nogil +cdef void slapmt(bint *forwrd, int *m, int *n, s *x, int *ldx, int *k) noexcept nogil: + + _fortran_slapmt(forwrd, m, n, x, ldx, k) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slapy2 "BLAS_FUNC(slapy2)"(s *x, s *y) nogil +cdef s slapy2(s *x, s *y) noexcept nogil: + + return _fortran_slapy2(x, y) + + +cdef extern from "_lapack_subroutines.h": + s _fortran_slapy3 "BLAS_FUNC(slapy3)"(s *x, s *y, s *z) nogil +cdef s slapy3(s *x, s *y, s *z) noexcept nogil: + + return _fortran_slapy3(x, y, z) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqgb "BLAS_FUNC(slaqgb)"(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) nogil +cdef void slaqgb(int *m, int *n, int *kl, int *ku, s *ab, int *ldab, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) noexcept nogil: + + _fortran_slaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqge "BLAS_FUNC(slaqge)"(int *m, int *n, s *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) nogil +cdef void slaqge(int *m, int *n, s *a, int *lda, s *r, s *c, s *rowcnd, s *colcnd, s *amax, char *equed) noexcept nogil: + + _fortran_slaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqp2 "BLAS_FUNC(slaqp2)"(int *m, int *n, int *offset, s *a, int *lda, int *jpvt, s *tau, s *vn1, s *vn2, s *work) nogil +cdef void slaqp2(int *m, int *n, int *offset, s *a, int *lda, int *jpvt, s *tau, s *vn1, s *vn2, s *work) noexcept nogil: + + _fortran_slaqp2(m, n, offset, a, lda, jpvt, tau, vn1, vn2, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqps "BLAS_FUNC(slaqps)"(int *m, int *n, int *offset, int *nb, int *kb, s *a, int *lda, int *jpvt, s *tau, s *vn1, s *vn2, s *auxv, s *f, int *ldf) nogil +cdef void slaqps(int *m, int *n, int *offset, int *nb, int *kb, s *a, int *lda, int *jpvt, s *tau, s *vn1, s *vn2, s *auxv, s *f, int *ldf) noexcept nogil: + + _fortran_slaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqr0 "BLAS_FUNC(slaqr0)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, int *iloz, int *ihiz, s *z, int *ldz, s *work, int *lwork, int *info) nogil +cdef void slaqr0(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, int *iloz, int *ihiz, s *z, int *ldz, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_slaqr0(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqr1 "BLAS_FUNC(slaqr1)"(int *n, s *h, int *ldh, s *sr1, s *si1, s *sr2, s *si2, s *v) nogil +cdef void slaqr1(int *n, s *h, int *ldh, s *sr1, s *si1, s *sr2, s *si2, s *v) noexcept nogil: + + _fortran_slaqr1(n, h, ldh, sr1, si1, sr2, si2, v) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqr2 "BLAS_FUNC(slaqr2)"(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, s *h, int *ldh, int *iloz, int *ihiz, s *z, int *ldz, int *ns, int *nd, s *sr, s *si, s *v, int *ldv, int *nh, s *t, int *ldt, int *nv, s *wv, int *ldwv, s *work, int *lwork) nogil +cdef void slaqr2(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, s *h, int *ldh, int *iloz, int *ihiz, s *z, int *ldz, int *ns, int *nd, s *sr, s *si, s *v, int *ldv, int *nh, s *t, int *ldt, int *nv, s *wv, int *ldwv, s *work, int *lwork) noexcept nogil: + + _fortran_slaqr2(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqr3 "BLAS_FUNC(slaqr3)"(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, s *h, int *ldh, int *iloz, int *ihiz, s *z, int *ldz, int *ns, int *nd, s *sr, s *si, s *v, int *ldv, int *nh, s *t, int *ldt, int *nv, s *wv, int *ldwv, s *work, int *lwork) nogil +cdef void slaqr3(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, s *h, int *ldh, int *iloz, int *ihiz, s *z, int *ldz, int *ns, int *nd, s *sr, s *si, s *v, int *ldv, int *nh, s *t, int *ldt, int *nv, s *wv, int *ldwv, s *work, int *lwork) noexcept nogil: + + _fortran_slaqr3(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqr4 "BLAS_FUNC(slaqr4)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, int *iloz, int *ihiz, s *z, int *ldz, s *work, int *lwork, int *info) nogil +cdef void slaqr4(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, s *h, int *ldh, s *wr, s *wi, int *iloz, int *ihiz, s *z, int *ldz, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_slaqr4(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqr5 "BLAS_FUNC(slaqr5)"(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, s *sr, s *si, s *h, int *ldh, int *iloz, int *ihiz, s *z, int *ldz, s *v, int *ldv, s *u, int *ldu, int *nv, s *wv, int *ldwv, int *nh, s *wh, int *ldwh) nogil +cdef void slaqr5(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, s *sr, s *si, s *h, int *ldh, int *iloz, int *ihiz, s *z, int *ldz, s *v, int *ldv, s *u, int *ldu, int *nv, s *wv, int *ldwv, int *nh, s *wh, int *ldwh) noexcept nogil: + + _fortran_slaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, sr, si, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqsb "BLAS_FUNC(slaqsb)"(char *uplo, int *n, int *kd, s *ab, int *ldab, s *s, s *scond, s *amax, char *equed) nogil +cdef void slaqsb(char *uplo, int *n, int *kd, s *ab, int *ldab, s *s, s *scond, s *amax, char *equed) noexcept nogil: + + _fortran_slaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqsp "BLAS_FUNC(slaqsp)"(char *uplo, int *n, s *ap, s *s, s *scond, s *amax, char *equed) nogil +cdef void slaqsp(char *uplo, int *n, s *ap, s *s, s *scond, s *amax, char *equed) noexcept nogil: + + _fortran_slaqsp(uplo, n, ap, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqsy "BLAS_FUNC(slaqsy)"(char *uplo, int *n, s *a, int *lda, s *s, s *scond, s *amax, char *equed) nogil +cdef void slaqsy(char *uplo, int *n, s *a, int *lda, s *s, s *scond, s *amax, char *equed) noexcept nogil: + + _fortran_slaqsy(uplo, n, a, lda, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaqtr "BLAS_FUNC(slaqtr)"(bint *ltran, bint *lreal, int *n, s *t, int *ldt, s *b, s *w, s *scale, s *x, s *work, int *info) nogil +cdef void slaqtr(bint *ltran, bint *lreal, int *n, s *t, int *ldt, s *b, s *w, s *scale, s *x, s *work, int *info) noexcept nogil: + + _fortran_slaqtr(ltran, lreal, n, t, ldt, b, w, scale, x, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slar1v "BLAS_FUNC(slar1v)"(int *n, int *b1, int *bn, s *lambda_, s *d, s *l, s *ld, s *lld, s *pivmin, s *gaptol, s *z, bint *wantnc, int *negcnt, s *ztz, s *mingma, int *r, int *isuppz, s *nrminv, s *resid, s *rqcorr, s *work) nogil +cdef void slar1v(int *n, int *b1, int *bn, s *lambda_, s *d, s *l, s *ld, s *lld, s *pivmin, s *gaptol, s *z, bint *wantnc, int *negcnt, s *ztz, s *mingma, int *r, int *isuppz, s *nrminv, s *resid, s *rqcorr, s *work) noexcept nogil: + + _fortran_slar1v(n, b1, bn, lambda_, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slar2v "BLAS_FUNC(slar2v)"(int *n, s *x, s *y, s *z, int *incx, s *c, s *s, int *incc) nogil +cdef void slar2v(int *n, s *x, s *y, s *z, int *incx, s *c, s *s, int *incc) noexcept nogil: + + _fortran_slar2v(n, x, y, z, incx, c, s, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarf "BLAS_FUNC(slarf)"(char *side, int *m, int *n, s *v, int *incv, s *tau, s *c, int *ldc, s *work) nogil +cdef void slarf(char *side, int *m, int *n, s *v, int *incv, s *tau, s *c, int *ldc, s *work) noexcept nogil: + + _fortran_slarf(side, m, n, v, incv, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarfb "BLAS_FUNC(slarfb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, s *v, int *ldv, s *t, int *ldt, s *c, int *ldc, s *work, int *ldwork) nogil +cdef void slarfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, s *v, int *ldv, s *t, int *ldt, s *c, int *ldc, s *work, int *ldwork) noexcept nogil: + + _fortran_slarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarfg "BLAS_FUNC(slarfg)"(int *n, s *alpha, s *x, int *incx, s *tau) nogil +cdef void slarfg(int *n, s *alpha, s *x, int *incx, s *tau) noexcept nogil: + + _fortran_slarfg(n, alpha, x, incx, tau) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarfgp "BLAS_FUNC(slarfgp)"(int *n, s *alpha, s *x, int *incx, s *tau) nogil +cdef void slarfgp(int *n, s *alpha, s *x, int *incx, s *tau) noexcept nogil: + + _fortran_slarfgp(n, alpha, x, incx, tau) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarft "BLAS_FUNC(slarft)"(char *direct, char *storev, int *n, int *k, s *v, int *ldv, s *tau, s *t, int *ldt) nogil +cdef void slarft(char *direct, char *storev, int *n, int *k, s *v, int *ldv, s *tau, s *t, int *ldt) noexcept nogil: + + _fortran_slarft(direct, storev, n, k, v, ldv, tau, t, ldt) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarfx "BLAS_FUNC(slarfx)"(char *side, int *m, int *n, s *v, s *tau, s *c, int *ldc, s *work) nogil +cdef void slarfx(char *side, int *m, int *n, s *v, s *tau, s *c, int *ldc, s *work) noexcept nogil: + + _fortran_slarfx(side, m, n, v, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slargv "BLAS_FUNC(slargv)"(int *n, s *x, int *incx, s *y, int *incy, s *c, int *incc) nogil +cdef void slargv(int *n, s *x, int *incx, s *y, int *incy, s *c, int *incc) noexcept nogil: + + _fortran_slargv(n, x, incx, y, incy, c, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarnv "BLAS_FUNC(slarnv)"(int *idist, int *iseed, int *n, s *x) nogil +cdef void slarnv(int *idist, int *iseed, int *n, s *x) noexcept nogil: + + _fortran_slarnv(idist, iseed, n, x) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarra "BLAS_FUNC(slarra)"(int *n, s *d, s *e, s *e2, s *spltol, s *tnrm, int *nsplit, int *isplit, int *info) nogil +cdef void slarra(int *n, s *d, s *e, s *e2, s *spltol, s *tnrm, int *nsplit, int *isplit, int *info) noexcept nogil: + + _fortran_slarra(n, d, e, e2, spltol, tnrm, nsplit, isplit, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarrb "BLAS_FUNC(slarrb)"(int *n, s *d, s *lld, int *ifirst, int *ilast, s *rtol1, s *rtol2, int *offset, s *w, s *wgap, s *werr, s *work, int *iwork, s *pivmin, s *spdiam, int *twist, int *info) nogil +cdef void slarrb(int *n, s *d, s *lld, int *ifirst, int *ilast, s *rtol1, s *rtol2, int *offset, s *w, s *wgap, s *werr, s *work, int *iwork, s *pivmin, s *spdiam, int *twist, int *info) noexcept nogil: + + _fortran_slarrb(n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, work, iwork, pivmin, spdiam, twist, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarrc "BLAS_FUNC(slarrc)"(char *jobt, int *n, s *vl, s *vu, s *d, s *e, s *pivmin, int *eigcnt, int *lcnt, int *rcnt, int *info) nogil +cdef void slarrc(char *jobt, int *n, s *vl, s *vu, s *d, s *e, s *pivmin, int *eigcnt, int *lcnt, int *rcnt, int *info) noexcept nogil: + + _fortran_slarrc(jobt, n, vl, vu, d, e, pivmin, eigcnt, lcnt, rcnt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarrd "BLAS_FUNC(slarrd)"(char *range, char *order, int *n, s *vl, s *vu, int *il, int *iu, s *gers, s *reltol, s *d, s *e, s *e2, s *pivmin, int *nsplit, int *isplit, int *m, s *w, s *werr, s *wl, s *wu, int *iblock, int *indexw, s *work, int *iwork, int *info) nogil +cdef void slarrd(char *range, char *order, int *n, s *vl, s *vu, int *il, int *iu, s *gers, s *reltol, s *d, s *e, s *e2, s *pivmin, int *nsplit, int *isplit, int *m, s *w, s *werr, s *wl, s *wu, int *iblock, int *indexw, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_slarrd(range, order, n, vl, vu, il, iu, gers, reltol, d, e, e2, pivmin, nsplit, isplit, m, w, werr, wl, wu, iblock, indexw, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarre "BLAS_FUNC(slarre)"(char *range, int *n, s *vl, s *vu, int *il, int *iu, s *d, s *e, s *e2, s *rtol1, s *rtol2, s *spltol, int *nsplit, int *isplit, int *m, s *w, s *werr, s *wgap, int *iblock, int *indexw, s *gers, s *pivmin, s *work, int *iwork, int *info) nogil +cdef void slarre(char *range, int *n, s *vl, s *vu, int *il, int *iu, s *d, s *e, s *e2, s *rtol1, s *rtol2, s *spltol, int *nsplit, int *isplit, int *m, s *w, s *werr, s *wgap, int *iblock, int *indexw, s *gers, s *pivmin, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_slarre(range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit, m, w, werr, wgap, iblock, indexw, gers, pivmin, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarrf "BLAS_FUNC(slarrf)"(int *n, s *d, s *l, s *ld, int *clstrt, int *clend, s *w, s *wgap, s *werr, s *spdiam, s *clgapl, s *clgapr, s *pivmin, s *sigma, s *dplus, s *lplus, s *work, int *info) nogil +cdef void slarrf(int *n, s *d, s *l, s *ld, int *clstrt, int *clend, s *w, s *wgap, s *werr, s *spdiam, s *clgapl, s *clgapr, s *pivmin, s *sigma, s *dplus, s *lplus, s *work, int *info) noexcept nogil: + + _fortran_slarrf(n, d, l, ld, clstrt, clend, w, wgap, werr, spdiam, clgapl, clgapr, pivmin, sigma, dplus, lplus, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarrj "BLAS_FUNC(slarrj)"(int *n, s *d, s *e2, int *ifirst, int *ilast, s *rtol, int *offset, s *w, s *werr, s *work, int *iwork, s *pivmin, s *spdiam, int *info) nogil +cdef void slarrj(int *n, s *d, s *e2, int *ifirst, int *ilast, s *rtol, int *offset, s *w, s *werr, s *work, int *iwork, s *pivmin, s *spdiam, int *info) noexcept nogil: + + _fortran_slarrj(n, d, e2, ifirst, ilast, rtol, offset, w, werr, work, iwork, pivmin, spdiam, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarrk "BLAS_FUNC(slarrk)"(int *n, int *iw, s *gl, s *gu, s *d, s *e2, s *pivmin, s *reltol, s *w, s *werr, int *info) nogil +cdef void slarrk(int *n, int *iw, s *gl, s *gu, s *d, s *e2, s *pivmin, s *reltol, s *w, s *werr, int *info) noexcept nogil: + + _fortran_slarrk(n, iw, gl, gu, d, e2, pivmin, reltol, w, werr, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarrr "BLAS_FUNC(slarrr)"(int *n, s *d, s *e, int *info) nogil +cdef void slarrr(int *n, s *d, s *e, int *info) noexcept nogil: + + _fortran_slarrr(n, d, e, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarrv "BLAS_FUNC(slarrv)"(int *n, s *vl, s *vu, s *d, s *l, s *pivmin, int *isplit, int *m, int *dol, int *dou, s *minrgp, s *rtol1, s *rtol2, s *w, s *werr, s *wgap, int *iblock, int *indexw, s *gers, s *z, int *ldz, int *isuppz, s *work, int *iwork, int *info) nogil +cdef void slarrv(int *n, s *vl, s *vu, s *d, s *l, s *pivmin, int *isplit, int *m, int *dol, int *dou, s *minrgp, s *rtol1, s *rtol2, s *w, s *werr, s *wgap, int *iblock, int *indexw, s *gers, s *z, int *ldz, int *isuppz, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_slarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slartg "BLAS_FUNC(slartg)"(s *f, s *g, s *cs, s *sn, s *r) nogil +cdef void slartg(s *f, s *g, s *cs, s *sn, s *r) noexcept nogil: + + _fortran_slartg(f, g, cs, sn, r) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slartgp "BLAS_FUNC(slartgp)"(s *f, s *g, s *cs, s *sn, s *r) nogil +cdef void slartgp(s *f, s *g, s *cs, s *sn, s *r) noexcept nogil: + + _fortran_slartgp(f, g, cs, sn, r) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slartgs "BLAS_FUNC(slartgs)"(s *x, s *y, s *sigma, s *cs, s *sn) nogil +cdef void slartgs(s *x, s *y, s *sigma, s *cs, s *sn) noexcept nogil: + + _fortran_slartgs(x, y, sigma, cs, sn) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slartv "BLAS_FUNC(slartv)"(int *n, s *x, int *incx, s *y, int *incy, s *c, s *s, int *incc) nogil +cdef void slartv(int *n, s *x, int *incx, s *y, int *incy, s *c, s *s, int *incc) noexcept nogil: + + _fortran_slartv(n, x, incx, y, incy, c, s, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaruv "BLAS_FUNC(slaruv)"(int *iseed, int *n, s *x) nogil +cdef void slaruv(int *iseed, int *n, s *x) noexcept nogil: + + _fortran_slaruv(iseed, n, x) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarz "BLAS_FUNC(slarz)"(char *side, int *m, int *n, int *l, s *v, int *incv, s *tau, s *c, int *ldc, s *work) nogil +cdef void slarz(char *side, int *m, int *n, int *l, s *v, int *incv, s *tau, s *c, int *ldc, s *work) noexcept nogil: + + _fortran_slarz(side, m, n, l, v, incv, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarzb "BLAS_FUNC(slarzb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, s *v, int *ldv, s *t, int *ldt, s *c, int *ldc, s *work, int *ldwork) nogil +cdef void slarzb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, s *v, int *ldv, s *t, int *ldt, s *c, int *ldc, s *work, int *ldwork) noexcept nogil: + + _fortran_slarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slarzt "BLAS_FUNC(slarzt)"(char *direct, char *storev, int *n, int *k, s *v, int *ldv, s *tau, s *t, int *ldt) nogil +cdef void slarzt(char *direct, char *storev, int *n, int *k, s *v, int *ldv, s *tau, s *t, int *ldt) noexcept nogil: + + _fortran_slarzt(direct, storev, n, k, v, ldv, tau, t, ldt) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slas2 "BLAS_FUNC(slas2)"(s *f, s *g, s *h, s *ssmin, s *ssmax) nogil +cdef void slas2(s *f, s *g, s *h, s *ssmin, s *ssmax) noexcept nogil: + + _fortran_slas2(f, g, h, ssmin, ssmax) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slascl "BLAS_FUNC(slascl)"(char *type_bn, int *kl, int *ku, s *cfrom, s *cto, int *m, int *n, s *a, int *lda, int *info) nogil +cdef void slascl(char *type_bn, int *kl, int *ku, s *cfrom, s *cto, int *m, int *n, s *a, int *lda, int *info) noexcept nogil: + + _fortran_slascl(type_bn, kl, ku, cfrom, cto, m, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasd0 "BLAS_FUNC(slasd0)"(int *n, int *sqre, s *d, s *e, s *u, int *ldu, s *vt, int *ldvt, int *smlsiz, int *iwork, s *work, int *info) nogil +cdef void slasd0(int *n, int *sqre, s *d, s *e, s *u, int *ldu, s *vt, int *ldvt, int *smlsiz, int *iwork, s *work, int *info) noexcept nogil: + + _fortran_slasd0(n, sqre, d, e, u, ldu, vt, ldvt, smlsiz, iwork, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasd1 "BLAS_FUNC(slasd1)"(int *nl, int *nr, int *sqre, s *d, s *alpha, s *beta, s *u, int *ldu, s *vt, int *ldvt, int *idxq, int *iwork, s *work, int *info) nogil +cdef void slasd1(int *nl, int *nr, int *sqre, s *d, s *alpha, s *beta, s *u, int *ldu, s *vt, int *ldvt, int *idxq, int *iwork, s *work, int *info) noexcept nogil: + + _fortran_slasd1(nl, nr, sqre, d, alpha, beta, u, ldu, vt, ldvt, idxq, iwork, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasd2 "BLAS_FUNC(slasd2)"(int *nl, int *nr, int *sqre, int *k, s *d, s *z, s *alpha, s *beta, s *u, int *ldu, s *vt, int *ldvt, s *dsigma, s *u2, int *ldu2, s *vt2, int *ldvt2, int *idxp, int *idx, int *idxc, int *idxq, int *coltyp, int *info) nogil +cdef void slasd2(int *nl, int *nr, int *sqre, int *k, s *d, s *z, s *alpha, s *beta, s *u, int *ldu, s *vt, int *ldvt, s *dsigma, s *u2, int *ldu2, s *vt2, int *ldvt2, int *idxp, int *idx, int *idxc, int *idxq, int *coltyp, int *info) noexcept nogil: + + _fortran_slasd2(nl, nr, sqre, k, d, z, alpha, beta, u, ldu, vt, ldvt, dsigma, u2, ldu2, vt2, ldvt2, idxp, idx, idxc, idxq, coltyp, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasd3 "BLAS_FUNC(slasd3)"(int *nl, int *nr, int *sqre, int *k, s *d, s *q, int *ldq, s *dsigma, s *u, int *ldu, s *u2, int *ldu2, s *vt, int *ldvt, s *vt2, int *ldvt2, int *idxc, int *ctot, s *z, int *info) nogil +cdef void slasd3(int *nl, int *nr, int *sqre, int *k, s *d, s *q, int *ldq, s *dsigma, s *u, int *ldu, s *u2, int *ldu2, s *vt, int *ldvt, s *vt2, int *ldvt2, int *idxc, int *ctot, s *z, int *info) noexcept nogil: + + _fortran_slasd3(nl, nr, sqre, k, d, q, ldq, dsigma, u, ldu, u2, ldu2, vt, ldvt, vt2, ldvt2, idxc, ctot, z, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasd4 "BLAS_FUNC(slasd4)"(int *n, int *i, s *d, s *z, s *delta, s *rho, s *sigma, s *work, int *info) nogil +cdef void slasd4(int *n, int *i, s *d, s *z, s *delta, s *rho, s *sigma, s *work, int *info) noexcept nogil: + + _fortran_slasd4(n, i, d, z, delta, rho, sigma, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasd5 "BLAS_FUNC(slasd5)"(int *i, s *d, s *z, s *delta, s *rho, s *dsigma, s *work) nogil +cdef void slasd5(int *i, s *d, s *z, s *delta, s *rho, s *dsigma, s *work) noexcept nogil: + + _fortran_slasd5(i, d, z, delta, rho, dsigma, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasd6 "BLAS_FUNC(slasd6)"(int *icompq, int *nl, int *nr, int *sqre, s *d, s *vf, s *vl, s *alpha, s *beta, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *poles, s *difl, s *difr, s *z, int *k, s *c, s *s, s *work, int *iwork, int *info) nogil +cdef void slasd6(int *icompq, int *nl, int *nr, int *sqre, s *d, s *vf, s *vl, s *alpha, s *beta, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *poles, s *difl, s *difr, s *z, int *k, s *c, s *s, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_slasd6(icompq, nl, nr, sqre, d, vf, vl, alpha, beta, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasd7 "BLAS_FUNC(slasd7)"(int *icompq, int *nl, int *nr, int *sqre, int *k, s *d, s *z, s *zw, s *vf, s *vfw, s *vl, s *vlw, s *alpha, s *beta, s *dsigma, int *idx, int *idxp, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *c, s *s, int *info) nogil +cdef void slasd7(int *icompq, int *nl, int *nr, int *sqre, int *k, s *d, s *z, s *zw, s *vf, s *vfw, s *vl, s *vlw, s *alpha, s *beta, s *dsigma, int *idx, int *idxp, int *idxq, int *perm, int *givptr, int *givcol, int *ldgcol, s *givnum, int *ldgnum, s *c, s *s, int *info) noexcept nogil: + + _fortran_slasd7(icompq, nl, nr, sqre, k, d, z, zw, vf, vfw, vl, vlw, alpha, beta, dsigma, idx, idxp, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, c, s, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasd8 "BLAS_FUNC(slasd8)"(int *icompq, int *k, s *d, s *z, s *vf, s *vl, s *difl, s *difr, int *lddifr, s *dsigma, s *work, int *info) nogil +cdef void slasd8(int *icompq, int *k, s *d, s *z, s *vf, s *vl, s *difl, s *difr, int *lddifr, s *dsigma, s *work, int *info) noexcept nogil: + + _fortran_slasd8(icompq, k, d, z, vf, vl, difl, difr, lddifr, dsigma, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasda "BLAS_FUNC(slasda)"(int *icompq, int *smlsiz, int *n, int *sqre, s *d, s *e, s *u, int *ldu, s *vt, int *k, s *difl, s *difr, s *z, s *poles, int *givptr, int *givcol, int *ldgcol, int *perm, s *givnum, s *c, s *s, s *work, int *iwork, int *info) nogil +cdef void slasda(int *icompq, int *smlsiz, int *n, int *sqre, s *d, s *e, s *u, int *ldu, s *vt, int *k, s *difl, s *difr, s *z, s *poles, int *givptr, int *givcol, int *ldgcol, int *perm, s *givnum, s *c, s *s, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_slasda(icompq, smlsiz, n, sqre, d, e, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasdq "BLAS_FUNC(slasdq)"(char *uplo, int *sqre, int *n, int *ncvt, int *nru, int *ncc, s *d, s *e, s *vt, int *ldvt, s *u, int *ldu, s *c, int *ldc, s *work, int *info) nogil +cdef void slasdq(char *uplo, int *sqre, int *n, int *ncvt, int *nru, int *ncc, s *d, s *e, s *vt, int *ldvt, s *u, int *ldu, s *c, int *ldc, s *work, int *info) noexcept nogil: + + _fortran_slasdq(uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasdt "BLAS_FUNC(slasdt)"(int *n, int *lvl, int *nd, int *inode, int *ndiml, int *ndimr, int *msub) nogil +cdef void slasdt(int *n, int *lvl, int *nd, int *inode, int *ndiml, int *ndimr, int *msub) noexcept nogil: + + _fortran_slasdt(n, lvl, nd, inode, ndiml, ndimr, msub) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaset "BLAS_FUNC(slaset)"(char *uplo, int *m, int *n, s *alpha, s *beta, s *a, int *lda) nogil +cdef void slaset(char *uplo, int *m, int *n, s *alpha, s *beta, s *a, int *lda) noexcept nogil: + + _fortran_slaset(uplo, m, n, alpha, beta, a, lda) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasq1 "BLAS_FUNC(slasq1)"(int *n, s *d, s *e, s *work, int *info) nogil +cdef void slasq1(int *n, s *d, s *e, s *work, int *info) noexcept nogil: + + _fortran_slasq1(n, d, e, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasq2 "BLAS_FUNC(slasq2)"(int *n, s *z, int *info) nogil +cdef void slasq2(int *n, s *z, int *info) noexcept nogil: + + _fortran_slasq2(n, z, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasq3 "BLAS_FUNC(slasq3)"(int *i0, int *n0, s *z, int *pp, s *dmin, s *sigma, s *desig, s *qmax, int *nfail, int *iter, int *ndiv, bint *ieee, int *ttype, s *dmin1, s *dmin2, s *dn, s *dn1, s *dn2, s *g, s *tau) nogil +cdef void slasq3(int *i0, int *n0, s *z, int *pp, s *dmin, s *sigma, s *desig, s *qmax, int *nfail, int *iter, int *ndiv, bint *ieee, int *ttype, s *dmin1, s *dmin2, s *dn, s *dn1, s *dn2, s *g, s *tau) noexcept nogil: + + _fortran_slasq3(i0, n0, z, pp, dmin, sigma, desig, qmax, nfail, iter, ndiv, ieee, ttype, dmin1, dmin2, dn, dn1, dn2, g, tau) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasq4 "BLAS_FUNC(slasq4)"(int *i0, int *n0, s *z, int *pp, int *n0in, s *dmin, s *dmin1, s *dmin2, s *dn, s *dn1, s *dn2, s *tau, int *ttype, s *g) nogil +cdef void slasq4(int *i0, int *n0, s *z, int *pp, int *n0in, s *dmin, s *dmin1, s *dmin2, s *dn, s *dn1, s *dn2, s *tau, int *ttype, s *g) noexcept nogil: + + _fortran_slasq4(i0, n0, z, pp, n0in, dmin, dmin1, dmin2, dn, dn1, dn2, tau, ttype, g) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasq6 "BLAS_FUNC(slasq6)"(int *i0, int *n0, s *z, int *pp, s *dmin, s *dmin1, s *dmin2, s *dn, s *dnm1, s *dnm2) nogil +cdef void slasq6(int *i0, int *n0, s *z, int *pp, s *dmin, s *dmin1, s *dmin2, s *dn, s *dnm1, s *dnm2) noexcept nogil: + + _fortran_slasq6(i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasr "BLAS_FUNC(slasr)"(char *side, char *pivot, char *direct, int *m, int *n, s *c, s *s, s *a, int *lda) nogil +cdef void slasr(char *side, char *pivot, char *direct, int *m, int *n, s *c, s *s, s *a, int *lda) noexcept nogil: + + _fortran_slasr(side, pivot, direct, m, n, c, s, a, lda) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasrt "BLAS_FUNC(slasrt)"(char *id, int *n, s *d, int *info) nogil +cdef void slasrt(char *id, int *n, s *d, int *info) noexcept nogil: + + _fortran_slasrt(id, n, d, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slassq "BLAS_FUNC(slassq)"(int *n, s *x, int *incx, s *scale, s *sumsq) nogil +cdef void slassq(int *n, s *x, int *incx, s *scale, s *sumsq) noexcept nogil: + + _fortran_slassq(n, x, incx, scale, sumsq) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasv2 "BLAS_FUNC(slasv2)"(s *f, s *g, s *h, s *ssmin, s *ssmax, s *snr, s *csr, s *snl, s *csl) nogil +cdef void slasv2(s *f, s *g, s *h, s *ssmin, s *ssmax, s *snr, s *csr, s *snl, s *csl) noexcept nogil: + + _fortran_slasv2(f, g, h, ssmin, ssmax, snr, csr, snl, csl) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slaswp "BLAS_FUNC(slaswp)"(int *n, s *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) nogil +cdef void slaswp(int *n, s *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) noexcept nogil: + + _fortran_slaswp(n, a, lda, k1, k2, ipiv, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasy2 "BLAS_FUNC(slasy2)"(bint *ltranl, bint *ltranr, int *isgn, int *n1, int *n2, s *tl, int *ldtl, s *tr, int *ldtr, s *b, int *ldb, s *scale, s *x, int *ldx, s *xnorm, int *info) nogil +cdef void slasy2(bint *ltranl, bint *ltranr, int *isgn, int *n1, int *n2, s *tl, int *ldtl, s *tr, int *ldtr, s *b, int *ldb, s *scale, s *x, int *ldx, s *xnorm, int *info) noexcept nogil: + + _fortran_slasy2(ltranl, ltranr, isgn, n1, n2, tl, ldtl, tr, ldtr, b, ldb, scale, x, ldx, xnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slasyf "BLAS_FUNC(slasyf)"(char *uplo, int *n, int *nb, int *kb, s *a, int *lda, int *ipiv, s *w, int *ldw, int *info) nogil +cdef void slasyf(char *uplo, int *n, int *nb, int *kb, s *a, int *lda, int *ipiv, s *w, int *ldw, int *info) noexcept nogil: + + _fortran_slasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slatbs "BLAS_FUNC(slatbs)"(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, s *ab, int *ldab, s *x, s *scale, s *cnorm, int *info) nogil +cdef void slatbs(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, s *ab, int *ldab, s *x, s *scale, s *cnorm, int *info) noexcept nogil: + + _fortran_slatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slatdf "BLAS_FUNC(slatdf)"(int *ijob, int *n, s *z, int *ldz, s *rhs, s *rdsum, s *rdscal, int *ipiv, int *jpiv) nogil +cdef void slatdf(int *ijob, int *n, s *z, int *ldz, s *rhs, s *rdsum, s *rdscal, int *ipiv, int *jpiv) noexcept nogil: + + _fortran_slatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slatps "BLAS_FUNC(slatps)"(char *uplo, char *trans, char *diag, char *normin, int *n, s *ap, s *x, s *scale, s *cnorm, int *info) nogil +cdef void slatps(char *uplo, char *trans, char *diag, char *normin, int *n, s *ap, s *x, s *scale, s *cnorm, int *info) noexcept nogil: + + _fortran_slatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slatrd "BLAS_FUNC(slatrd)"(char *uplo, int *n, int *nb, s *a, int *lda, s *e, s *tau, s *w, int *ldw) nogil +cdef void slatrd(char *uplo, int *n, int *nb, s *a, int *lda, s *e, s *tau, s *w, int *ldw) noexcept nogil: + + _fortran_slatrd(uplo, n, nb, a, lda, e, tau, w, ldw) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slatrs "BLAS_FUNC(slatrs)"(char *uplo, char *trans, char *diag, char *normin, int *n, s *a, int *lda, s *x, s *scale, s *cnorm, int *info) nogil +cdef void slatrs(char *uplo, char *trans, char *diag, char *normin, int *n, s *a, int *lda, s *x, s *scale, s *cnorm, int *info) noexcept nogil: + + _fortran_slatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slatrz "BLAS_FUNC(slatrz)"(int *m, int *n, int *l, s *a, int *lda, s *tau, s *work) nogil +cdef void slatrz(int *m, int *n, int *l, s *a, int *lda, s *tau, s *work) noexcept nogil: + + _fortran_slatrz(m, n, l, a, lda, tau, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slauu2 "BLAS_FUNC(slauu2)"(char *uplo, int *n, s *a, int *lda, int *info) nogil +cdef void slauu2(char *uplo, int *n, s *a, int *lda, int *info) noexcept nogil: + + _fortran_slauu2(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_slauum "BLAS_FUNC(slauum)"(char *uplo, int *n, s *a, int *lda, int *info) nogil +cdef void slauum(char *uplo, int *n, s *a, int *lda, int *info) noexcept nogil: + + _fortran_slauum(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sopgtr "BLAS_FUNC(sopgtr)"(char *uplo, int *n, s *ap, s *tau, s *q, int *ldq, s *work, int *info) nogil +cdef void sopgtr(char *uplo, int *n, s *ap, s *tau, s *q, int *ldq, s *work, int *info) noexcept nogil: + + _fortran_sopgtr(uplo, n, ap, tau, q, ldq, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sopmtr "BLAS_FUNC(sopmtr)"(char *side, char *uplo, char *trans, int *m, int *n, s *ap, s *tau, s *c, int *ldc, s *work, int *info) nogil +cdef void sopmtr(char *side, char *uplo, char *trans, int *m, int *n, s *ap, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil: + + _fortran_sopmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorbdb "BLAS_FUNC(sorbdb)"(char *trans, char *signs, int *m, int *p, int *q, s *x11, int *ldx11, s *x12, int *ldx12, s *x21, int *ldx21, s *x22, int *ldx22, s *theta, s *phi, s *taup1, s *taup2, s *tauq1, s *tauq2, s *work, int *lwork, int *info) nogil +cdef void sorbdb(char *trans, char *signs, int *m, int *p, int *q, s *x11, int *ldx11, s *x12, int *ldx12, s *x21, int *ldx21, s *x22, int *ldx22, s *theta, s *phi, s *taup1, s *taup2, s *tauq1, s *tauq2, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sorbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorcsd "BLAS_FUNC(sorcsd)"(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, s *x11, int *ldx11, s *x12, int *ldx12, s *x21, int *ldx21, s *x22, int *ldx22, s *theta, s *u1, int *ldu1, s *u2, int *ldu2, s *v1t, int *ldv1t, s *v2t, int *ldv2t, s *work, int *lwork, int *iwork, int *info) nogil +cdef void sorcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, s *x11, int *ldx11, s *x12, int *ldx12, s *x21, int *ldx21, s *x22, int *ldx22, s *theta, s *u1, int *ldu1, s *u2, int *ldu2, s *v1t, int *ldv1t, s *v2t, int *ldv2t, s *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_sorcsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorg2l "BLAS_FUNC(sorg2l)"(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) nogil +cdef void sorg2l(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil: + + _fortran_sorg2l(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorg2r "BLAS_FUNC(sorg2r)"(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) nogil +cdef void sorg2r(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil: + + _fortran_sorg2r(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorgbr "BLAS_FUNC(sorgbr)"(char *vect, int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sorgbr(char *vect, int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sorgbr(vect, m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorghr "BLAS_FUNC(sorghr)"(int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sorghr(int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sorghr(n, ilo, ihi, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorgl2 "BLAS_FUNC(sorgl2)"(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) nogil +cdef void sorgl2(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil: + + _fortran_sorgl2(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorglq "BLAS_FUNC(sorglq)"(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sorglq(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sorglq(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorgql "BLAS_FUNC(sorgql)"(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sorgql(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sorgql(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorgqr "BLAS_FUNC(sorgqr)"(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sorgqr(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sorgqr(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorgr2 "BLAS_FUNC(sorgr2)"(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) nogil +cdef void sorgr2(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *info) noexcept nogil: + + _fortran_sorgr2(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorgrq "BLAS_FUNC(sorgrq)"(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sorgrq(int *m, int *n, int *k, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sorgrq(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorgtr "BLAS_FUNC(sorgtr)"(char *uplo, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void sorgtr(char *uplo, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sorgtr(uplo, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorm2l "BLAS_FUNC(sorm2l)"(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) nogil +cdef void sorm2l(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil: + + _fortran_sorm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorm2r "BLAS_FUNC(sorm2r)"(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) nogil +cdef void sorm2r(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil: + + _fortran_sorm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sormbr "BLAS_FUNC(sormbr)"(char *vect, char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) nogil +cdef void sormbr(char *vect, char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sormbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sormhr "BLAS_FUNC(sormhr)"(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) nogil +cdef void sormhr(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sormhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sorml2 "BLAS_FUNC(sorml2)"(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) nogil +cdef void sorml2(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil: + + _fortran_sorml2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sormlq "BLAS_FUNC(sormlq)"(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) nogil +cdef void sormlq(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sormlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sormql "BLAS_FUNC(sormql)"(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) nogil +cdef void sormql(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sormql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sormqr "BLAS_FUNC(sormqr)"(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) nogil +cdef void sormqr(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sormqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sormr2 "BLAS_FUNC(sormr2)"(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) nogil +cdef void sormr2(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil: + + _fortran_sormr2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sormr3 "BLAS_FUNC(sormr3)"(char *side, char *trans, int *m, int *n, int *k, int *l, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) nogil +cdef void sormr3(char *side, char *trans, int *m, int *n, int *k, int *l, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *info) noexcept nogil: + + _fortran_sormr3(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sormrq "BLAS_FUNC(sormrq)"(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) nogil +cdef void sormrq(char *side, char *trans, int *m, int *n, int *k, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sormrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sormrz "BLAS_FUNC(sormrz)"(char *side, char *trans, int *m, int *n, int *k, int *l, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) nogil +cdef void sormrz(char *side, char *trans, int *m, int *n, int *k, int *l, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sormrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sormtr "BLAS_FUNC(sormtr)"(char *side, char *uplo, char *trans, int *m, int *n, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) nogil +cdef void sormtr(char *side, char *uplo, char *trans, int *m, int *n, s *a, int *lda, s *tau, s *c, int *ldc, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_sormtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spbcon "BLAS_FUNC(spbcon)"(char *uplo, int *n, int *kd, s *ab, int *ldab, s *anorm, s *rcond, s *work, int *iwork, int *info) nogil +cdef void spbcon(char *uplo, int *n, int *kd, s *ab, int *ldab, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_spbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spbequ "BLAS_FUNC(spbequ)"(char *uplo, int *n, int *kd, s *ab, int *ldab, s *s, s *scond, s *amax, int *info) nogil +cdef void spbequ(char *uplo, int *n, int *kd, s *ab, int *ldab, s *s, s *scond, s *amax, int *info) noexcept nogil: + + _fortran_spbequ(uplo, n, kd, ab, ldab, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spbrfs "BLAS_FUNC(spbrfs)"(char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void spbrfs(char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_spbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spbstf "BLAS_FUNC(spbstf)"(char *uplo, int *n, int *kd, s *ab, int *ldab, int *info) nogil +cdef void spbstf(char *uplo, int *n, int *kd, s *ab, int *ldab, int *info) noexcept nogil: + + _fortran_spbstf(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spbsv "BLAS_FUNC(spbsv)"(char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, int *info) nogil +cdef void spbsv(char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_spbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spbsvx "BLAS_FUNC(spbsvx)"(char *fact, char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, char *equed, s *s, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void spbsvx(char *fact, char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *afb, int *ldafb, char *equed, s *s, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_spbsvx(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spbtf2 "BLAS_FUNC(spbtf2)"(char *uplo, int *n, int *kd, s *ab, int *ldab, int *info) nogil +cdef void spbtf2(char *uplo, int *n, int *kd, s *ab, int *ldab, int *info) noexcept nogil: + + _fortran_spbtf2(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spbtrf "BLAS_FUNC(spbtrf)"(char *uplo, int *n, int *kd, s *ab, int *ldab, int *info) nogil +cdef void spbtrf(char *uplo, int *n, int *kd, s *ab, int *ldab, int *info) noexcept nogil: + + _fortran_spbtrf(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spbtrs "BLAS_FUNC(spbtrs)"(char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, int *info) nogil +cdef void spbtrs(char *uplo, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_spbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spftrf "BLAS_FUNC(spftrf)"(char *transr, char *uplo, int *n, s *a, int *info) nogil +cdef void spftrf(char *transr, char *uplo, int *n, s *a, int *info) noexcept nogil: + + _fortran_spftrf(transr, uplo, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spftri "BLAS_FUNC(spftri)"(char *transr, char *uplo, int *n, s *a, int *info) nogil +cdef void spftri(char *transr, char *uplo, int *n, s *a, int *info) noexcept nogil: + + _fortran_spftri(transr, uplo, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spftrs "BLAS_FUNC(spftrs)"(char *transr, char *uplo, int *n, int *nrhs, s *a, s *b, int *ldb, int *info) nogil +cdef void spftrs(char *transr, char *uplo, int *n, int *nrhs, s *a, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_spftrs(transr, uplo, n, nrhs, a, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spocon "BLAS_FUNC(spocon)"(char *uplo, int *n, s *a, int *lda, s *anorm, s *rcond, s *work, int *iwork, int *info) nogil +cdef void spocon(char *uplo, int *n, s *a, int *lda, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_spocon(uplo, n, a, lda, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spoequ "BLAS_FUNC(spoequ)"(int *n, s *a, int *lda, s *s, s *scond, s *amax, int *info) nogil +cdef void spoequ(int *n, s *a, int *lda, s *s, s *scond, s *amax, int *info) noexcept nogil: + + _fortran_spoequ(n, a, lda, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spoequb "BLAS_FUNC(spoequb)"(int *n, s *a, int *lda, s *s, s *scond, s *amax, int *info) nogil +cdef void spoequb(int *n, s *a, int *lda, s *s, s *scond, s *amax, int *info) noexcept nogil: + + _fortran_spoequb(n, a, lda, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sporfs "BLAS_FUNC(sporfs)"(char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void sporfs(char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sposv "BLAS_FUNC(sposv)"(char *uplo, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *info) nogil +cdef void sposv(char *uplo, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_sposv(uplo, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sposvx "BLAS_FUNC(sposvx)"(char *fact, char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, char *equed, s *s, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void sposvx(char *fact, char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, char *equed, s *s, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sposvx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spotf2 "BLAS_FUNC(spotf2)"(char *uplo, int *n, s *a, int *lda, int *info) nogil +cdef void spotf2(char *uplo, int *n, s *a, int *lda, int *info) noexcept nogil: + + _fortran_spotf2(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spotrf "BLAS_FUNC(spotrf)"(char *uplo, int *n, s *a, int *lda, int *info) nogil +cdef void spotrf(char *uplo, int *n, s *a, int *lda, int *info) noexcept nogil: + + _fortran_spotrf(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spotri "BLAS_FUNC(spotri)"(char *uplo, int *n, s *a, int *lda, int *info) nogil +cdef void spotri(char *uplo, int *n, s *a, int *lda, int *info) noexcept nogil: + + _fortran_spotri(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spotrs "BLAS_FUNC(spotrs)"(char *uplo, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *info) nogil +cdef void spotrs(char *uplo, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_spotrs(uplo, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sppcon "BLAS_FUNC(sppcon)"(char *uplo, int *n, s *ap, s *anorm, s *rcond, s *work, int *iwork, int *info) nogil +cdef void sppcon(char *uplo, int *n, s *ap, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sppcon(uplo, n, ap, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sppequ "BLAS_FUNC(sppequ)"(char *uplo, int *n, s *ap, s *s, s *scond, s *amax, int *info) nogil +cdef void sppequ(char *uplo, int *n, s *ap, s *s, s *scond, s *amax, int *info) noexcept nogil: + + _fortran_sppequ(uplo, n, ap, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spprfs "BLAS_FUNC(spprfs)"(char *uplo, int *n, int *nrhs, s *ap, s *afp, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void spprfs(char *uplo, int *n, int *nrhs, s *ap, s *afp, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_spprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sppsv "BLAS_FUNC(sppsv)"(char *uplo, int *n, int *nrhs, s *ap, s *b, int *ldb, int *info) nogil +cdef void sppsv(char *uplo, int *n, int *nrhs, s *ap, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_sppsv(uplo, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sppsvx "BLAS_FUNC(sppsvx)"(char *fact, char *uplo, int *n, int *nrhs, s *ap, s *afp, char *equed, s *s, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void sppsvx(char *fact, char *uplo, int *n, int *nrhs, s *ap, s *afp, char *equed, s *s, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sppsvx(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spptrf "BLAS_FUNC(spptrf)"(char *uplo, int *n, s *ap, int *info) nogil +cdef void spptrf(char *uplo, int *n, s *ap, int *info) noexcept nogil: + + _fortran_spptrf(uplo, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spptri "BLAS_FUNC(spptri)"(char *uplo, int *n, s *ap, int *info) nogil +cdef void spptri(char *uplo, int *n, s *ap, int *info) noexcept nogil: + + _fortran_spptri(uplo, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spptrs "BLAS_FUNC(spptrs)"(char *uplo, int *n, int *nrhs, s *ap, s *b, int *ldb, int *info) nogil +cdef void spptrs(char *uplo, int *n, int *nrhs, s *ap, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_spptrs(uplo, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spstf2 "BLAS_FUNC(spstf2)"(char *uplo, int *n, s *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) nogil +cdef void spstf2(char *uplo, int *n, s *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) noexcept nogil: + + _fortran_spstf2(uplo, n, a, lda, piv, rank, tol, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spstrf "BLAS_FUNC(spstrf)"(char *uplo, int *n, s *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) nogil +cdef void spstrf(char *uplo, int *n, s *a, int *lda, int *piv, int *rank, s *tol, s *work, int *info) noexcept nogil: + + _fortran_spstrf(uplo, n, a, lda, piv, rank, tol, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sptcon "BLAS_FUNC(sptcon)"(int *n, s *d, s *e, s *anorm, s *rcond, s *work, int *info) nogil +cdef void sptcon(int *n, s *d, s *e, s *anorm, s *rcond, s *work, int *info) noexcept nogil: + + _fortran_sptcon(n, d, e, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spteqr "BLAS_FUNC(spteqr)"(char *compz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *info) nogil +cdef void spteqr(char *compz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *info) noexcept nogil: + + _fortran_spteqr(compz, n, d, e, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sptrfs "BLAS_FUNC(sptrfs)"(int *n, int *nrhs, s *d, s *e, s *df, s *ef, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *info) nogil +cdef void sptrfs(int *n, int *nrhs, s *d, s *e, s *df, s *ef, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *info) noexcept nogil: + + _fortran_sptrfs(n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sptsv "BLAS_FUNC(sptsv)"(int *n, int *nrhs, s *d, s *e, s *b, int *ldb, int *info) nogil +cdef void sptsv(int *n, int *nrhs, s *d, s *e, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_sptsv(n, nrhs, d, e, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sptsvx "BLAS_FUNC(sptsvx)"(char *fact, int *n, int *nrhs, s *d, s *e, s *df, s *ef, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *info) nogil +cdef void sptsvx(char *fact, int *n, int *nrhs, s *d, s *e, s *df, s *ef, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *info) noexcept nogil: + + _fortran_sptsvx(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spttrf "BLAS_FUNC(spttrf)"(int *n, s *d, s *e, int *info) nogil +cdef void spttrf(int *n, s *d, s *e, int *info) noexcept nogil: + + _fortran_spttrf(n, d, e, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_spttrs "BLAS_FUNC(spttrs)"(int *n, int *nrhs, s *d, s *e, s *b, int *ldb, int *info) nogil +cdef void spttrs(int *n, int *nrhs, s *d, s *e, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_spttrs(n, nrhs, d, e, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sptts2 "BLAS_FUNC(sptts2)"(int *n, int *nrhs, s *d, s *e, s *b, int *ldb) nogil +cdef void sptts2(int *n, int *nrhs, s *d, s *e, s *b, int *ldb) noexcept nogil: + + _fortran_sptts2(n, nrhs, d, e, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_srscl "BLAS_FUNC(srscl)"(int *n, s *sa, s *sx, int *incx) nogil +cdef void srscl(int *n, s *sa, s *sx, int *incx) noexcept nogil: + + _fortran_srscl(n, sa, sx, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssbev "BLAS_FUNC(ssbev)"(char *jobz, char *uplo, int *n, int *kd, s *ab, int *ldab, s *w, s *z, int *ldz, s *work, int *info) nogil +cdef void ssbev(char *jobz, char *uplo, int *n, int *kd, s *ab, int *ldab, s *w, s *z, int *ldz, s *work, int *info) noexcept nogil: + + _fortran_ssbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssbevd "BLAS_FUNC(ssbevd)"(char *jobz, char *uplo, int *n, int *kd, s *ab, int *ldab, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void ssbevd(char *jobz, char *uplo, int *n, int *kd, s *ab, int *ldab, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_ssbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssbevx "BLAS_FUNC(ssbevx)"(char *jobz, char *range, char *uplo, int *n, int *kd, s *ab, int *ldab, s *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) nogil +cdef void ssbevx(char *jobz, char *range, char *uplo, int *n, int *kd, s *ab, int *ldab, s *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_ssbevx(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssbgst "BLAS_FUNC(ssbgst)"(char *vect, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *x, int *ldx, s *work, int *info) nogil +cdef void ssbgst(char *vect, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *x, int *ldx, s *work, int *info) noexcept nogil: + + _fortran_ssbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssbgv "BLAS_FUNC(ssbgv)"(char *jobz, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *w, s *z, int *ldz, s *work, int *info) nogil +cdef void ssbgv(char *jobz, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *w, s *z, int *ldz, s *work, int *info) noexcept nogil: + + _fortran_ssbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssbgvd "BLAS_FUNC(ssbgvd)"(char *jobz, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void ssbgvd(char *jobz, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_ssbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssbgvx "BLAS_FUNC(ssbgvx)"(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) nogil +cdef void ssbgvx(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, s *ab, int *ldab, s *bb, int *ldbb, s *q, int *ldq, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_ssbgvx(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssbtrd "BLAS_FUNC(ssbtrd)"(char *vect, char *uplo, int *n, int *kd, s *ab, int *ldab, s *d, s *e, s *q, int *ldq, s *work, int *info) nogil +cdef void ssbtrd(char *vect, char *uplo, int *n, int *kd, s *ab, int *ldab, s *d, s *e, s *q, int *ldq, s *work, int *info) noexcept nogil: + + _fortran_ssbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssfrk "BLAS_FUNC(ssfrk)"(char *transr, char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *beta, s *c) nogil +cdef void ssfrk(char *transr, char *uplo, char *trans, int *n, int *k, s *alpha, s *a, int *lda, s *beta, s *c) noexcept nogil: + + _fortran_ssfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sspcon "BLAS_FUNC(sspcon)"(char *uplo, int *n, s *ap, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) nogil +cdef void sspcon(char *uplo, int *n, s *ap, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sspcon(uplo, n, ap, ipiv, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sspev "BLAS_FUNC(sspev)"(char *jobz, char *uplo, int *n, s *ap, s *w, s *z, int *ldz, s *work, int *info) nogil +cdef void sspev(char *jobz, char *uplo, int *n, s *ap, s *w, s *z, int *ldz, s *work, int *info) noexcept nogil: + + _fortran_sspev(jobz, uplo, n, ap, w, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sspevd "BLAS_FUNC(sspevd)"(char *jobz, char *uplo, int *n, s *ap, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void sspevd(char *jobz, char *uplo, int *n, s *ap, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_sspevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sspevx "BLAS_FUNC(sspevx)"(char *jobz, char *range, char *uplo, int *n, s *ap, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) nogil +cdef void sspevx(char *jobz, char *range, char *uplo, int *n, s *ap, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_sspevx(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sspgst "BLAS_FUNC(sspgst)"(int *itype, char *uplo, int *n, s *ap, s *bp, int *info) nogil +cdef void sspgst(int *itype, char *uplo, int *n, s *ap, s *bp, int *info) noexcept nogil: + + _fortran_sspgst(itype, uplo, n, ap, bp, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sspgv "BLAS_FUNC(sspgv)"(int *itype, char *jobz, char *uplo, int *n, s *ap, s *bp, s *w, s *z, int *ldz, s *work, int *info) nogil +cdef void sspgv(int *itype, char *jobz, char *uplo, int *n, s *ap, s *bp, s *w, s *z, int *ldz, s *work, int *info) noexcept nogil: + + _fortran_sspgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sspgvd "BLAS_FUNC(sspgvd)"(int *itype, char *jobz, char *uplo, int *n, s *ap, s *bp, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void sspgvd(int *itype, char *jobz, char *uplo, int *n, s *ap, s *bp, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_sspgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sspgvx "BLAS_FUNC(sspgvx)"(int *itype, char *jobz, char *range, char *uplo, int *n, s *ap, s *bp, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) nogil +cdef void sspgvx(int *itype, char *jobz, char *range, char *uplo, int *n, s *ap, s *bp, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_sspgvx(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssprfs "BLAS_FUNC(ssprfs)"(char *uplo, int *n, int *nrhs, s *ap, s *afp, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void ssprfs(char *uplo, int *n, int *nrhs, s *ap, s *afp, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_ssprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sspsv "BLAS_FUNC(sspsv)"(char *uplo, int *n, int *nrhs, s *ap, int *ipiv, s *b, int *ldb, int *info) nogil +cdef void sspsv(char *uplo, int *n, int *nrhs, s *ap, int *ipiv, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_sspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sspsvx "BLAS_FUNC(sspsvx)"(char *fact, char *uplo, int *n, int *nrhs, s *ap, s *afp, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void sspsvx(char *fact, char *uplo, int *n, int *nrhs, s *ap, s *afp, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sspsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssptrd "BLAS_FUNC(ssptrd)"(char *uplo, int *n, s *ap, s *d, s *e, s *tau, int *info) nogil +cdef void ssptrd(char *uplo, int *n, s *ap, s *d, s *e, s *tau, int *info) noexcept nogil: + + _fortran_ssptrd(uplo, n, ap, d, e, tau, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssptrf "BLAS_FUNC(ssptrf)"(char *uplo, int *n, s *ap, int *ipiv, int *info) nogil +cdef void ssptrf(char *uplo, int *n, s *ap, int *ipiv, int *info) noexcept nogil: + + _fortran_ssptrf(uplo, n, ap, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssptri "BLAS_FUNC(ssptri)"(char *uplo, int *n, s *ap, int *ipiv, s *work, int *info) nogil +cdef void ssptri(char *uplo, int *n, s *ap, int *ipiv, s *work, int *info) noexcept nogil: + + _fortran_ssptri(uplo, n, ap, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssptrs "BLAS_FUNC(ssptrs)"(char *uplo, int *n, int *nrhs, s *ap, int *ipiv, s *b, int *ldb, int *info) nogil +cdef void ssptrs(char *uplo, int *n, int *nrhs, s *ap, int *ipiv, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_ssptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sstebz "BLAS_FUNC(sstebz)"(char *range, char *order, int *n, s *vl, s *vu, int *il, int *iu, s *abstol, s *d, s *e, int *m, int *nsplit, s *w, int *iblock, int *isplit, s *work, int *iwork, int *info) nogil +cdef void sstebz(char *range, char *order, int *n, s *vl, s *vu, int *il, int *iu, s *abstol, s *d, s *e, int *m, int *nsplit, s *w, int *iblock, int *isplit, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_sstebz(range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w, iblock, isplit, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sstedc "BLAS_FUNC(sstedc)"(char *compz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void sstedc(char *compz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_sstedc(compz, n, d, e, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sstegr "BLAS_FUNC(sstegr)"(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void sstegr(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_sstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sstein "BLAS_FUNC(sstein)"(int *n, s *d, s *e, int *m, s *w, int *iblock, int *isplit, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) nogil +cdef void sstein(int *n, s *d, s *e, int *m, s *w, int *iblock, int *isplit, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_sstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sstemr "BLAS_FUNC(sstemr)"(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, int *m, s *w, s *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void sstemr(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, int *m, s *w, s *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_sstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssteqr "BLAS_FUNC(ssteqr)"(char *compz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *info) nogil +cdef void ssteqr(char *compz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *info) noexcept nogil: + + _fortran_ssteqr(compz, n, d, e, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssterf "BLAS_FUNC(ssterf)"(int *n, s *d, s *e, int *info) nogil +cdef void ssterf(int *n, s *d, s *e, int *info) noexcept nogil: + + _fortran_ssterf(n, d, e, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sstev "BLAS_FUNC(sstev)"(char *jobz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *info) nogil +cdef void sstev(char *jobz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *info) noexcept nogil: + + _fortran_sstev(jobz, n, d, e, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sstevd "BLAS_FUNC(sstevd)"(char *jobz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void sstevd(char *jobz, int *n, s *d, s *e, s *z, int *ldz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_sstevd(jobz, n, d, e, z, ldz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sstevr "BLAS_FUNC(sstevr)"(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void sstevr(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_sstevr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_sstevx "BLAS_FUNC(sstevx)"(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) nogil +cdef void sstevx(char *jobz, char *range, int *n, s *d, s *e, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_sstevx(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssycon "BLAS_FUNC(ssycon)"(char *uplo, int *n, s *a, int *lda, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) nogil +cdef void ssycon(char *uplo, int *n, s *a, int *lda, int *ipiv, s *anorm, s *rcond, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_ssycon(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssyconv "BLAS_FUNC(ssyconv)"(char *uplo, char *way, int *n, s *a, int *lda, int *ipiv, s *work, int *info) nogil +cdef void ssyconv(char *uplo, char *way, int *n, s *a, int *lda, int *ipiv, s *work, int *info) noexcept nogil: + + _fortran_ssyconv(uplo, way, n, a, lda, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssyequb "BLAS_FUNC(ssyequb)"(char *uplo, int *n, s *a, int *lda, s *s, s *scond, s *amax, s *work, int *info) nogil +cdef void ssyequb(char *uplo, int *n, s *a, int *lda, s *s, s *scond, s *amax, s *work, int *info) noexcept nogil: + + _fortran_ssyequb(uplo, n, a, lda, s, scond, amax, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssyev "BLAS_FUNC(ssyev)"(char *jobz, char *uplo, int *n, s *a, int *lda, s *w, s *work, int *lwork, int *info) nogil +cdef void ssyev(char *jobz, char *uplo, int *n, s *a, int *lda, s *w, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_ssyev(jobz, uplo, n, a, lda, w, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssyevd "BLAS_FUNC(ssyevd)"(char *jobz, char *uplo, int *n, s *a, int *lda, s *w, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void ssyevd(char *jobz, char *uplo, int *n, s *a, int *lda, s *w, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_ssyevd(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssyevr "BLAS_FUNC(ssyevr)"(char *jobz, char *range, char *uplo, int *n, s *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void ssyevr(char *jobz, char *range, char *uplo, int *n, s *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, int *isuppz, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_ssyevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssyevx "BLAS_FUNC(ssyevx)"(char *jobz, char *range, char *uplo, int *n, s *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *ifail, int *info) nogil +cdef void ssyevx(char *jobz, char *range, char *uplo, int *n, s *a, int *lda, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_ssyevx(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssygs2 "BLAS_FUNC(ssygs2)"(int *itype, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, int *info) nogil +cdef void ssygs2(int *itype, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_ssygs2(itype, uplo, n, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssygst "BLAS_FUNC(ssygst)"(int *itype, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, int *info) nogil +cdef void ssygst(int *itype, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_ssygst(itype, uplo, n, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssygv "BLAS_FUNC(ssygv)"(int *itype, char *jobz, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, s *w, s *work, int *lwork, int *info) nogil +cdef void ssygv(int *itype, char *jobz, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, s *w, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_ssygv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssygvd "BLAS_FUNC(ssygvd)"(int *itype, char *jobz, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, s *w, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void ssygvd(int *itype, char *jobz, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, s *w, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_ssygvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssygvx "BLAS_FUNC(ssygvx)"(int *itype, char *jobz, char *range, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *ifail, int *info) nogil +cdef void ssygvx(int *itype, char *jobz, char *range, char *uplo, int *n, s *a, int *lda, s *b, int *ldb, s *vl, s *vu, int *il, int *iu, s *abstol, int *m, s *w, s *z, int *ldz, s *work, int *lwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_ssygvx(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssyrfs "BLAS_FUNC(ssyrfs)"(char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void ssyrfs(char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_ssyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssysv "BLAS_FUNC(ssysv)"(char *uplo, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, s *work, int *lwork, int *info) nogil +cdef void ssysv(char *uplo, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_ssysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssysvx "BLAS_FUNC(ssysvx)"(char *fact, char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *lwork, int *iwork, int *info) nogil +cdef void ssysvx(char *fact, char *uplo, int *n, int *nrhs, s *a, int *lda, s *af, int *ldaf, int *ipiv, s *b, int *ldb, s *x, int *ldx, s *rcond, s *ferr, s *berr, s *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_ssysvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssyswapr "BLAS_FUNC(ssyswapr)"(char *uplo, int *n, s *a, int *lda, int *i1, int *i2) nogil +cdef void ssyswapr(char *uplo, int *n, s *a, int *lda, int *i1, int *i2) noexcept nogil: + + _fortran_ssyswapr(uplo, n, a, lda, i1, i2) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssytd2 "BLAS_FUNC(ssytd2)"(char *uplo, int *n, s *a, int *lda, s *d, s *e, s *tau, int *info) nogil +cdef void ssytd2(char *uplo, int *n, s *a, int *lda, s *d, s *e, s *tau, int *info) noexcept nogil: + + _fortran_ssytd2(uplo, n, a, lda, d, e, tau, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssytf2 "BLAS_FUNC(ssytf2)"(char *uplo, int *n, s *a, int *lda, int *ipiv, int *info) nogil +cdef void ssytf2(char *uplo, int *n, s *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_ssytf2(uplo, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssytrd "BLAS_FUNC(ssytrd)"(char *uplo, int *n, s *a, int *lda, s *d, s *e, s *tau, s *work, int *lwork, int *info) nogil +cdef void ssytrd(char *uplo, int *n, s *a, int *lda, s *d, s *e, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_ssytrd(uplo, n, a, lda, d, e, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssytrf "BLAS_FUNC(ssytrf)"(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *lwork, int *info) nogil +cdef void ssytrf(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_ssytrf(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssytri "BLAS_FUNC(ssytri)"(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *info) nogil +cdef void ssytri(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *info) noexcept nogil: + + _fortran_ssytri(uplo, n, a, lda, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssytri2 "BLAS_FUNC(ssytri2)"(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *lwork, int *info) nogil +cdef void ssytri2(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_ssytri2(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssytri2x "BLAS_FUNC(ssytri2x)"(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *nb, int *info) nogil +cdef void ssytri2x(char *uplo, int *n, s *a, int *lda, int *ipiv, s *work, int *nb, int *info) noexcept nogil: + + _fortran_ssytri2x(uplo, n, a, lda, ipiv, work, nb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssytrs "BLAS_FUNC(ssytrs)"(char *uplo, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, int *info) nogil +cdef void ssytrs(char *uplo, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_ssytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ssytrs2 "BLAS_FUNC(ssytrs2)"(char *uplo, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, s *work, int *info) nogil +cdef void ssytrs2(char *uplo, int *n, int *nrhs, s *a, int *lda, int *ipiv, s *b, int *ldb, s *work, int *info) noexcept nogil: + + _fortran_ssytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stbcon "BLAS_FUNC(stbcon)"(char *norm, char *uplo, char *diag, int *n, int *kd, s *ab, int *ldab, s *rcond, s *work, int *iwork, int *info) nogil +cdef void stbcon(char *norm, char *uplo, char *diag, int *n, int *kd, s *ab, int *ldab, s *rcond, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_stbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stbrfs "BLAS_FUNC(stbrfs)"(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void stbrfs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_stbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stbtrs "BLAS_FUNC(stbtrs)"(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, int *info) nogil +cdef void stbtrs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, s *ab, int *ldab, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_stbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stfsm "BLAS_FUNC(stfsm)"(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, s *alpha, s *a, s *b, int *ldb) nogil +cdef void stfsm(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, s *alpha, s *a, s *b, int *ldb) noexcept nogil: + + _fortran_stfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stftri "BLAS_FUNC(stftri)"(char *transr, char *uplo, char *diag, int *n, s *a, int *info) nogil +cdef void stftri(char *transr, char *uplo, char *diag, int *n, s *a, int *info) noexcept nogil: + + _fortran_stftri(transr, uplo, diag, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stfttp "BLAS_FUNC(stfttp)"(char *transr, char *uplo, int *n, s *arf, s *ap, int *info) nogil +cdef void stfttp(char *transr, char *uplo, int *n, s *arf, s *ap, int *info) noexcept nogil: + + _fortran_stfttp(transr, uplo, n, arf, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stfttr "BLAS_FUNC(stfttr)"(char *transr, char *uplo, int *n, s *arf, s *a, int *lda, int *info) nogil +cdef void stfttr(char *transr, char *uplo, int *n, s *arf, s *a, int *lda, int *info) noexcept nogil: + + _fortran_stfttr(transr, uplo, n, arf, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stgevc "BLAS_FUNC(stgevc)"(char *side, char *howmny, bint *select, int *n, s *s, int *lds, s *p, int *ldp, s *vl, int *ldvl, s *vr, int *ldvr, int *mm, int *m, s *work, int *info) nogil +cdef void stgevc(char *side, char *howmny, bint *select, int *n, s *s, int *lds, s *p, int *ldp, s *vl, int *ldvl, s *vr, int *ldvr, int *mm, int *m, s *work, int *info) noexcept nogil: + + _fortran_stgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stgex2 "BLAS_FUNC(stgex2)"(bint *wantq, bint *wantz, int *n, s *a, int *lda, s *b, int *ldb, s *q, int *ldq, s *z, int *ldz, int *j1, int *n1, int *n2, s *work, int *lwork, int *info) nogil +cdef void stgex2(bint *wantq, bint *wantz, int *n, s *a, int *lda, s *b, int *ldb, s *q, int *ldq, s *z, int *ldz, int *j1, int *n1, int *n2, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_stgex2(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, n1, n2, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stgexc "BLAS_FUNC(stgexc)"(bint *wantq, bint *wantz, int *n, s *a, int *lda, s *b, int *ldb, s *q, int *ldq, s *z, int *ldz, int *ifst, int *ilst, s *work, int *lwork, int *info) nogil +cdef void stgexc(bint *wantq, bint *wantz, int *n, s *a, int *lda, s *b, int *ldb, s *q, int *ldq, s *z, int *ldz, int *ifst, int *ilst, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_stgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stgsen "BLAS_FUNC(stgsen)"(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *q, int *ldq, s *z, int *ldz, int *m, s *pl, s *pr, s *dif, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void stgsen(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, s *a, int *lda, s *b, int *ldb, s *alphar, s *alphai, s *beta, s *q, int *ldq, s *z, int *ldz, int *m, s *pl, s *pr, s *dif, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_stgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stgsja "BLAS_FUNC(stgsja)"(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, s *a, int *lda, s *b, int *ldb, s *tola, s *tolb, s *alpha, s *beta, s *u, int *ldu, s *v, int *ldv, s *q, int *ldq, s *work, int *ncycle, int *info) nogil +cdef void stgsja(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, s *a, int *lda, s *b, int *ldb, s *tola, s *tolb, s *alpha, s *beta, s *u, int *ldu, s *v, int *ldv, s *q, int *ldq, s *work, int *ncycle, int *info) noexcept nogil: + + _fortran_stgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stgsna "BLAS_FUNC(stgsna)"(char *job, char *howmny, bint *select, int *n, s *a, int *lda, s *b, int *ldb, s *vl, int *ldvl, s *vr, int *ldvr, s *s, s *dif, int *mm, int *m, s *work, int *lwork, int *iwork, int *info) nogil +cdef void stgsna(char *job, char *howmny, bint *select, int *n, s *a, int *lda, s *b, int *ldb, s *vl, int *ldvl, s *vr, int *ldvr, s *s, s *dif, int *mm, int *m, s *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_stgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stgsy2 "BLAS_FUNC(stgsy2)"(char *trans, int *ijob, int *m, int *n, s *a, int *lda, s *b, int *ldb, s *c, int *ldc, s *d, int *ldd, s *e, int *lde, s *f, int *ldf, s *scale, s *rdsum, s *rdscal, int *iwork, int *pq, int *info) nogil +cdef void stgsy2(char *trans, int *ijob, int *m, int *n, s *a, int *lda, s *b, int *ldb, s *c, int *ldc, s *d, int *ldd, s *e, int *lde, s *f, int *ldf, s *scale, s *rdsum, s *rdscal, int *iwork, int *pq, int *info) noexcept nogil: + + _fortran_stgsy2(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, iwork, pq, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stgsyl "BLAS_FUNC(stgsyl)"(char *trans, int *ijob, int *m, int *n, s *a, int *lda, s *b, int *ldb, s *c, int *ldc, s *d, int *ldd, s *e, int *lde, s *f, int *ldf, s *scale, s *dif, s *work, int *lwork, int *iwork, int *info) nogil +cdef void stgsyl(char *trans, int *ijob, int *m, int *n, s *a, int *lda, s *b, int *ldb, s *c, int *ldc, s *d, int *ldd, s *e, int *lde, s *f, int *ldf, s *scale, s *dif, s *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_stgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stpcon "BLAS_FUNC(stpcon)"(char *norm, char *uplo, char *diag, int *n, s *ap, s *rcond, s *work, int *iwork, int *info) nogil +cdef void stpcon(char *norm, char *uplo, char *diag, int *n, s *ap, s *rcond, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_stpcon(norm, uplo, diag, n, ap, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stpmqrt "BLAS_FUNC(stpmqrt)"(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, s *v, int *ldv, s *t, int *ldt, s *a, int *lda, s *b, int *ldb, s *work, int *info) nogil +cdef void stpmqrt(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, s *v, int *ldv, s *t, int *ldt, s *a, int *lda, s *b, int *ldb, s *work, int *info) noexcept nogil: + + _fortran_stpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stpqrt "BLAS_FUNC(stpqrt)"(int *m, int *n, int *l, int *nb, s *a, int *lda, s *b, int *ldb, s *t, int *ldt, s *work, int *info) nogil +cdef void stpqrt(int *m, int *n, int *l, int *nb, s *a, int *lda, s *b, int *ldb, s *t, int *ldt, s *work, int *info) noexcept nogil: + + _fortran_stpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stpqrt2 "BLAS_FUNC(stpqrt2)"(int *m, int *n, int *l, s *a, int *lda, s *b, int *ldb, s *t, int *ldt, int *info) nogil +cdef void stpqrt2(int *m, int *n, int *l, s *a, int *lda, s *b, int *ldb, s *t, int *ldt, int *info) noexcept nogil: + + _fortran_stpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stprfb "BLAS_FUNC(stprfb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, s *v, int *ldv, s *t, int *ldt, s *a, int *lda, s *b, int *ldb, s *work, int *ldwork) nogil +cdef void stprfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, s *v, int *ldv, s *t, int *ldt, s *a, int *lda, s *b, int *ldb, s *work, int *ldwork) noexcept nogil: + + _fortran_stprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stprfs "BLAS_FUNC(stprfs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *ap, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void stprfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *ap, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_stprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stptri "BLAS_FUNC(stptri)"(char *uplo, char *diag, int *n, s *ap, int *info) nogil +cdef void stptri(char *uplo, char *diag, int *n, s *ap, int *info) noexcept nogil: + + _fortran_stptri(uplo, diag, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stptrs "BLAS_FUNC(stptrs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *ap, s *b, int *ldb, int *info) nogil +cdef void stptrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *ap, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_stptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stpttf "BLAS_FUNC(stpttf)"(char *transr, char *uplo, int *n, s *ap, s *arf, int *info) nogil +cdef void stpttf(char *transr, char *uplo, int *n, s *ap, s *arf, int *info) noexcept nogil: + + _fortran_stpttf(transr, uplo, n, ap, arf, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stpttr "BLAS_FUNC(stpttr)"(char *uplo, int *n, s *ap, s *a, int *lda, int *info) nogil +cdef void stpttr(char *uplo, int *n, s *ap, s *a, int *lda, int *info) noexcept nogil: + + _fortran_stpttr(uplo, n, ap, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strcon "BLAS_FUNC(strcon)"(char *norm, char *uplo, char *diag, int *n, s *a, int *lda, s *rcond, s *work, int *iwork, int *info) nogil +cdef void strcon(char *norm, char *uplo, char *diag, int *n, s *a, int *lda, s *rcond, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_strcon(norm, uplo, diag, n, a, lda, rcond, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strevc "BLAS_FUNC(strevc)"(char *side, char *howmny, bint *select, int *n, s *t, int *ldt, s *vl, int *ldvl, s *vr, int *ldvr, int *mm, int *m, s *work, int *info) nogil +cdef void strevc(char *side, char *howmny, bint *select, int *n, s *t, int *ldt, s *vl, int *ldvl, s *vr, int *ldvr, int *mm, int *m, s *work, int *info) noexcept nogil: + + _fortran_strevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strexc "BLAS_FUNC(strexc)"(char *compq, int *n, s *t, int *ldt, s *q, int *ldq, int *ifst, int *ilst, s *work, int *info) nogil +cdef void strexc(char *compq, int *n, s *t, int *ldt, s *q, int *ldq, int *ifst, int *ilst, s *work, int *info) noexcept nogil: + + _fortran_strexc(compq, n, t, ldt, q, ldq, ifst, ilst, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strrfs "BLAS_FUNC(strrfs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) nogil +cdef void strrfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, s *x, int *ldx, s *ferr, s *berr, s *work, int *iwork, int *info) noexcept nogil: + + _fortran_strrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strsen "BLAS_FUNC(strsen)"(char *job, char *compq, bint *select, int *n, s *t, int *ldt, s *q, int *ldq, s *wr, s *wi, int *m, s *s, s *sep, s *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void strsen(char *job, char *compq, bint *select, int *n, s *t, int *ldt, s *q, int *ldq, s *wr, s *wi, int *m, s *s, s *sep, s *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_strsen(job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strsna "BLAS_FUNC(strsna)"(char *job, char *howmny, bint *select, int *n, s *t, int *ldt, s *vl, int *ldvl, s *vr, int *ldvr, s *s, s *sep, int *mm, int *m, s *work, int *ldwork, int *iwork, int *info) nogil +cdef void strsna(char *job, char *howmny, bint *select, int *n, s *t, int *ldt, s *vl, int *ldvl, s *vr, int *ldvr, s *s, s *sep, int *mm, int *m, s *work, int *ldwork, int *iwork, int *info) noexcept nogil: + + _fortran_strsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strsyl "BLAS_FUNC(strsyl)"(char *trana, char *tranb, int *isgn, int *m, int *n, s *a, int *lda, s *b, int *ldb, s *c, int *ldc, s *scale, int *info) nogil +cdef void strsyl(char *trana, char *tranb, int *isgn, int *m, int *n, s *a, int *lda, s *b, int *ldb, s *c, int *ldc, s *scale, int *info) noexcept nogil: + + _fortran_strsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strti2 "BLAS_FUNC(strti2)"(char *uplo, char *diag, int *n, s *a, int *lda, int *info) nogil +cdef void strti2(char *uplo, char *diag, int *n, s *a, int *lda, int *info) noexcept nogil: + + _fortran_strti2(uplo, diag, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strtri "BLAS_FUNC(strtri)"(char *uplo, char *diag, int *n, s *a, int *lda, int *info) nogil +cdef void strtri(char *uplo, char *diag, int *n, s *a, int *lda, int *info) noexcept nogil: + + _fortran_strtri(uplo, diag, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strtrs "BLAS_FUNC(strtrs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *info) nogil +cdef void strtrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, s *a, int *lda, s *b, int *ldb, int *info) noexcept nogil: + + _fortran_strtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strttf "BLAS_FUNC(strttf)"(char *transr, char *uplo, int *n, s *a, int *lda, s *arf, int *info) nogil +cdef void strttf(char *transr, char *uplo, int *n, s *a, int *lda, s *arf, int *info) noexcept nogil: + + _fortran_strttf(transr, uplo, n, a, lda, arf, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_strttp "BLAS_FUNC(strttp)"(char *uplo, int *n, s *a, int *lda, s *ap, int *info) nogil +cdef void strttp(char *uplo, int *n, s *a, int *lda, s *ap, int *info) noexcept nogil: + + _fortran_strttp(uplo, n, a, lda, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_stzrzf "BLAS_FUNC(stzrzf)"(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) nogil +cdef void stzrzf(int *m, int *n, s *a, int *lda, s *tau, s *work, int *lwork, int *info) noexcept nogil: + + _fortran_stzrzf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_xerbla_array "BLAS_FUNC(xerbla_array)"(char *srname_array, int *srname_len, int *info) nogil +cdef void xerbla_array(char *srname_array, int *srname_len, int *info) noexcept nogil: + + _fortran_xerbla_array(srname_array, srname_len, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zbbcsd "BLAS_FUNC(zbbcsd)"(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, d *theta, d *phi, npy_complex128 *u1, int *ldu1, npy_complex128 *u2, int *ldu2, npy_complex128 *v1t, int *ldv1t, npy_complex128 *v2t, int *ldv2t, d *b11d, d *b11e, d *b12d, d *b12e, d *b21d, d *b21e, d *b22d, d *b22e, d *rwork, int *lrwork, int *info) nogil +cdef void zbbcsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, int *m, int *p, int *q, d *theta, d *phi, z *u1, int *ldu1, z *u2, int *ldu2, z *v1t, int *ldv1t, z *v2t, int *ldv2t, d *b11d, d *b11e, d *b12d, d *b12e, d *b21d, d *b21e, d *b22d, d *b22e, d *rwork, int *lrwork, int *info) noexcept nogil: + + _fortran_zbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, b22e, rwork, lrwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zbdsqr "BLAS_FUNC(zbdsqr)"(char *uplo, int *n, int *ncvt, int *nru, int *ncc, d *d, d *e, npy_complex128 *vt, int *ldvt, npy_complex128 *u, int *ldu, npy_complex128 *c, int *ldc, d *rwork, int *info) nogil +cdef void zbdsqr(char *uplo, int *n, int *ncvt, int *nru, int *ncc, d *d, d *e, z *vt, int *ldvt, z *u, int *ldu, z *c, int *ldc, d *rwork, int *info) noexcept nogil: + + _fortran_zbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zcgesv "BLAS_FUNC(zcgesv)"(int *n, int *nrhs, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, npy_complex128 *work, npy_complex64 *swork, d *rwork, int *iter, int *info) nogil +cdef void zcgesv(int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, z *x, int *ldx, z *work, c *swork, d *rwork, int *iter, int *info) noexcept nogil: + + _fortran_zcgesv(n, nrhs, a, lda, ipiv, b, ldb, x, ldx, work, swork, rwork, iter, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zcposv "BLAS_FUNC(zcposv)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, npy_complex128 *work, npy_complex64 *swork, d *rwork, int *iter, int *info) nogil +cdef void zcposv(char *uplo, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, z *x, int *ldx, z *work, c *swork, d *rwork, int *iter, int *info) noexcept nogil: + + _fortran_zcposv(uplo, n, nrhs, a, lda, b, ldb, x, ldx, work, swork, rwork, iter, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zdrscl "BLAS_FUNC(zdrscl)"(int *n, d *sa, npy_complex128 *sx, int *incx) nogil +cdef void zdrscl(int *n, d *sa, z *sx, int *incx) noexcept nogil: + + _fortran_zdrscl(n, sa, sx, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgbbrd "BLAS_FUNC(zgbbrd)"(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, npy_complex128 *ab, int *ldab, d *d, d *e, npy_complex128 *q, int *ldq, npy_complex128 *pt, int *ldpt, npy_complex128 *c, int *ldc, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zgbbrd(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, z *ab, int *ldab, d *d, d *e, z *q, int *ldq, z *pt, int *ldpt, z *c, int *ldc, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgbcon "BLAS_FUNC(zgbcon)"(char *norm, int *n, int *kl, int *ku, npy_complex128 *ab, int *ldab, int *ipiv, d *anorm, d *rcond, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zgbcon(char *norm, int *n, int *kl, int *ku, z *ab, int *ldab, int *ipiv, d *anorm, d *rcond, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgbequ "BLAS_FUNC(zgbequ)"(int *m, int *n, int *kl, int *ku, npy_complex128 *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) nogil +cdef void zgbequ(int *m, int *n, int *kl, int *ku, z *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil: + + _fortran_zgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgbequb "BLAS_FUNC(zgbequb)"(int *m, int *n, int *kl, int *ku, npy_complex128 *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) nogil +cdef void zgbequb(int *m, int *n, int *kl, int *ku, z *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil: + + _fortran_zgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgbrfs "BLAS_FUNC(zgbrfs)"(char *trans, int *n, int *kl, int *ku, int *nrhs, npy_complex128 *ab, int *ldab, npy_complex128 *afb, int *ldafb, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zgbrfs(char *trans, int *n, int *kl, int *ku, int *nrhs, z *ab, int *ldab, z *afb, int *ldafb, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgbsv "BLAS_FUNC(zgbsv)"(int *n, int *kl, int *ku, int *nrhs, npy_complex128 *ab, int *ldab, int *ipiv, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zgbsv(int *n, int *kl, int *ku, int *nrhs, z *ab, int *ldab, int *ipiv, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgbsvx "BLAS_FUNC(zgbsvx)"(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, npy_complex128 *ab, int *ldab, npy_complex128 *afb, int *ldafb, int *ipiv, char *equed, d *r, d *c, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *rcond, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zgbsvx(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, z *ab, int *ldab, z *afb, int *ldafb, int *ipiv, char *equed, d *r, d *c, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zgbsvx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgbtf2 "BLAS_FUNC(zgbtf2)"(int *m, int *n, int *kl, int *ku, npy_complex128 *ab, int *ldab, int *ipiv, int *info) nogil +cdef void zgbtf2(int *m, int *n, int *kl, int *ku, z *ab, int *ldab, int *ipiv, int *info) noexcept nogil: + + _fortran_zgbtf2(m, n, kl, ku, ab, ldab, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgbtrf "BLAS_FUNC(zgbtrf)"(int *m, int *n, int *kl, int *ku, npy_complex128 *ab, int *ldab, int *ipiv, int *info) nogil +cdef void zgbtrf(int *m, int *n, int *kl, int *ku, z *ab, int *ldab, int *ipiv, int *info) noexcept nogil: + + _fortran_zgbtrf(m, n, kl, ku, ab, ldab, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgbtrs "BLAS_FUNC(zgbtrs)"(char *trans, int *n, int *kl, int *ku, int *nrhs, npy_complex128 *ab, int *ldab, int *ipiv, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zgbtrs(char *trans, int *n, int *kl, int *ku, int *nrhs, z *ab, int *ldab, int *ipiv, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgebak "BLAS_FUNC(zgebak)"(char *job, char *side, int *n, int *ilo, int *ihi, d *scale, int *m, npy_complex128 *v, int *ldv, int *info) nogil +cdef void zgebak(char *job, char *side, int *n, int *ilo, int *ihi, d *scale, int *m, z *v, int *ldv, int *info) noexcept nogil: + + _fortran_zgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgebal "BLAS_FUNC(zgebal)"(char *job, int *n, npy_complex128 *a, int *lda, int *ilo, int *ihi, d *scale, int *info) nogil +cdef void zgebal(char *job, int *n, z *a, int *lda, int *ilo, int *ihi, d *scale, int *info) noexcept nogil: + + _fortran_zgebal(job, n, a, lda, ilo, ihi, scale, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgebd2 "BLAS_FUNC(zgebd2)"(int *m, int *n, npy_complex128 *a, int *lda, d *d, d *e, npy_complex128 *tauq, npy_complex128 *taup, npy_complex128 *work, int *info) nogil +cdef void zgebd2(int *m, int *n, z *a, int *lda, d *d, d *e, z *tauq, z *taup, z *work, int *info) noexcept nogil: + + _fortran_zgebd2(m, n, a, lda, d, e, tauq, taup, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgebrd "BLAS_FUNC(zgebrd)"(int *m, int *n, npy_complex128 *a, int *lda, d *d, d *e, npy_complex128 *tauq, npy_complex128 *taup, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zgebrd(int *m, int *n, z *a, int *lda, d *d, d *e, z *tauq, z *taup, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgecon "BLAS_FUNC(zgecon)"(char *norm, int *n, npy_complex128 *a, int *lda, d *anorm, d *rcond, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zgecon(char *norm, int *n, z *a, int *lda, d *anorm, d *rcond, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zgecon(norm, n, a, lda, anorm, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeequ "BLAS_FUNC(zgeequ)"(int *m, int *n, npy_complex128 *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) nogil +cdef void zgeequ(int *m, int *n, z *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil: + + _fortran_zgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeequb "BLAS_FUNC(zgeequb)"(int *m, int *n, npy_complex128 *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) nogil +cdef void zgeequb(int *m, int *n, z *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, int *info) noexcept nogil: + + _fortran_zgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgees "BLAS_FUNC(zgees)"(char *jobvs, char *sort, _zselect1 *select, int *n, npy_complex128 *a, int *lda, int *sdim, npy_complex128 *w, npy_complex128 *vs, int *ldvs, npy_complex128 *work, int *lwork, d *rwork, bint *bwork, int *info) nogil +cdef void zgees(char *jobvs, char *sort, zselect1 *select, int *n, z *a, int *lda, int *sdim, z *w, z *vs, int *ldvs, z *work, int *lwork, d *rwork, bint *bwork, int *info) noexcept nogil: + + _fortran_zgees(jobvs, sort, <_zselect1*>select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeesx "BLAS_FUNC(zgeesx)"(char *jobvs, char *sort, _zselect1 *select, char *sense, int *n, npy_complex128 *a, int *lda, int *sdim, npy_complex128 *w, npy_complex128 *vs, int *ldvs, d *rconde, d *rcondv, npy_complex128 *work, int *lwork, d *rwork, bint *bwork, int *info) nogil +cdef void zgeesx(char *jobvs, char *sort, zselect1 *select, char *sense, int *n, z *a, int *lda, int *sdim, z *w, z *vs, int *ldvs, d *rconde, d *rcondv, z *work, int *lwork, d *rwork, bint *bwork, int *info) noexcept nogil: + + _fortran_zgeesx(jobvs, sort, <_zselect1*>select, sense, n, a, lda, sdim, w, vs, ldvs, rconde, rcondv, work, lwork, rwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeev "BLAS_FUNC(zgeev)"(char *jobvl, char *jobvr, int *n, npy_complex128 *a, int *lda, npy_complex128 *w, npy_complex128 *vl, int *ldvl, npy_complex128 *vr, int *ldvr, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zgeev(char *jobvl, char *jobvr, int *n, z *a, int *lda, z *w, z *vl, int *ldvl, z *vr, int *ldvr, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeevx "BLAS_FUNC(zgeevx)"(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, npy_complex128 *a, int *lda, npy_complex128 *w, npy_complex128 *vl, int *ldvl, npy_complex128 *vr, int *ldvr, int *ilo, int *ihi, d *scale, d *abnrm, d *rconde, d *rcondv, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zgeevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, z *a, int *lda, z *w, z *vl, int *ldvl, z *vr, int *ldvr, int *ilo, int *ihi, d *scale, d *abnrm, d *rconde, d *rcondv, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zgeevx(balanc, jobvl, jobvr, sense, n, a, lda, w, vl, ldvl, vr, ldvr, ilo, ihi, scale, abnrm, rconde, rcondv, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgehd2 "BLAS_FUNC(zgehd2)"(int *n, int *ilo, int *ihi, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *info) nogil +cdef void zgehd2(int *n, int *ilo, int *ihi, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil: + + _fortran_zgehd2(n, ilo, ihi, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgehrd "BLAS_FUNC(zgehrd)"(int *n, int *ilo, int *ihi, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zgehrd(int *n, int *ilo, int *ihi, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgelq2 "BLAS_FUNC(zgelq2)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *info) nogil +cdef void zgelq2(int *m, int *n, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil: + + _fortran_zgelq2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgelqf "BLAS_FUNC(zgelqf)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zgelqf(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zgelqf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgels "BLAS_FUNC(zgels)"(char *trans, int *m, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zgels(char *trans, int *m, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgelsd "BLAS_FUNC(zgelsd)"(int *m, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, d *s, d *rcond, int *rank, npy_complex128 *work, int *lwork, d *rwork, int *iwork, int *info) nogil +cdef void zgelsd(int *m, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, d *s, d *rcond, int *rank, z *work, int *lwork, d *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_zgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgelss "BLAS_FUNC(zgelss)"(int *m, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, d *s, d *rcond, int *rank, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zgelss(int *m, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, d *s, d *rcond, int *rank, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgelsy "BLAS_FUNC(zgelsy)"(int *m, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, int *jpvt, d *rcond, int *rank, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zgelsy(int *m, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, int *jpvt, d *rcond, int *rank, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgemqrt "BLAS_FUNC(zgemqrt)"(char *side, char *trans, int *m, int *n, int *k, int *nb, npy_complex128 *v, int *ldv, npy_complex128 *t, int *ldt, npy_complex128 *c, int *ldc, npy_complex128 *work, int *info) nogil +cdef void zgemqrt(char *side, char *trans, int *m, int *n, int *k, int *nb, z *v, int *ldv, z *t, int *ldt, z *c, int *ldc, z *work, int *info) noexcept nogil: + + _fortran_zgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeql2 "BLAS_FUNC(zgeql2)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *info) nogil +cdef void zgeql2(int *m, int *n, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil: + + _fortran_zgeql2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeqlf "BLAS_FUNC(zgeqlf)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zgeqlf(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zgeqlf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeqp3 "BLAS_FUNC(zgeqp3)"(int *m, int *n, npy_complex128 *a, int *lda, int *jpvt, npy_complex128 *tau, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zgeqp3(int *m, int *n, z *a, int *lda, int *jpvt, z *tau, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zgeqp3(m, n, a, lda, jpvt, tau, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeqr2 "BLAS_FUNC(zgeqr2)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *info) nogil +cdef void zgeqr2(int *m, int *n, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil: + + _fortran_zgeqr2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeqr2p "BLAS_FUNC(zgeqr2p)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *info) nogil +cdef void zgeqr2p(int *m, int *n, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil: + + _fortran_zgeqr2p(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeqrf "BLAS_FUNC(zgeqrf)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zgeqrf(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zgeqrf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeqrfp "BLAS_FUNC(zgeqrfp)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zgeqrfp(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zgeqrfp(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeqrt "BLAS_FUNC(zgeqrt)"(int *m, int *n, int *nb, npy_complex128 *a, int *lda, npy_complex128 *t, int *ldt, npy_complex128 *work, int *info) nogil +cdef void zgeqrt(int *m, int *n, int *nb, z *a, int *lda, z *t, int *ldt, z *work, int *info) noexcept nogil: + + _fortran_zgeqrt(m, n, nb, a, lda, t, ldt, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeqrt2 "BLAS_FUNC(zgeqrt2)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *t, int *ldt, int *info) nogil +cdef void zgeqrt2(int *m, int *n, z *a, int *lda, z *t, int *ldt, int *info) noexcept nogil: + + _fortran_zgeqrt2(m, n, a, lda, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgeqrt3 "BLAS_FUNC(zgeqrt3)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *t, int *ldt, int *info) nogil +cdef void zgeqrt3(int *m, int *n, z *a, int *lda, z *t, int *ldt, int *info) noexcept nogil: + + _fortran_zgeqrt3(m, n, a, lda, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgerfs "BLAS_FUNC(zgerfs)"(char *trans, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *af, int *ldaf, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zgerfs(char *trans, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgerq2 "BLAS_FUNC(zgerq2)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *info) nogil +cdef void zgerq2(int *m, int *n, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil: + + _fortran_zgerq2(m, n, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgerqf "BLAS_FUNC(zgerqf)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zgerqf(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zgerqf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgesc2 "BLAS_FUNC(zgesc2)"(int *n, npy_complex128 *a, int *lda, npy_complex128 *rhs, int *ipiv, int *jpiv, d *scale) nogil +cdef void zgesc2(int *n, z *a, int *lda, z *rhs, int *ipiv, int *jpiv, d *scale) noexcept nogil: + + _fortran_zgesc2(n, a, lda, rhs, ipiv, jpiv, scale) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgesdd "BLAS_FUNC(zgesdd)"(char *jobz, int *m, int *n, npy_complex128 *a, int *lda, d *s, npy_complex128 *u, int *ldu, npy_complex128 *vt, int *ldvt, npy_complex128 *work, int *lwork, d *rwork, int *iwork, int *info) nogil +cdef void zgesdd(char *jobz, int *m, int *n, z *a, int *lda, d *s, z *u, int *ldu, z *vt, int *ldvt, z *work, int *lwork, d *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_zgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgesv "BLAS_FUNC(zgesv)"(int *n, int *nrhs, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zgesv(int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zgesv(n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgesvd "BLAS_FUNC(zgesvd)"(char *jobu, char *jobvt, int *m, int *n, npy_complex128 *a, int *lda, d *s, npy_complex128 *u, int *ldu, npy_complex128 *vt, int *ldvt, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zgesvd(char *jobu, char *jobvt, int *m, int *n, z *a, int *lda, d *s, z *u, int *ldu, z *vt, int *ldvt, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgesvx "BLAS_FUNC(zgesvx)"(char *fact, char *trans, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *af, int *ldaf, int *ipiv, char *equed, d *r, d *c, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *rcond, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zgesvx(char *fact, char *trans, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, char *equed, d *r, d *c, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zgesvx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgetc2 "BLAS_FUNC(zgetc2)"(int *n, npy_complex128 *a, int *lda, int *ipiv, int *jpiv, int *info) nogil +cdef void zgetc2(int *n, z *a, int *lda, int *ipiv, int *jpiv, int *info) noexcept nogil: + + _fortran_zgetc2(n, a, lda, ipiv, jpiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgetf2 "BLAS_FUNC(zgetf2)"(int *m, int *n, npy_complex128 *a, int *lda, int *ipiv, int *info) nogil +cdef void zgetf2(int *m, int *n, z *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_zgetf2(m, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgetrf "BLAS_FUNC(zgetrf)"(int *m, int *n, npy_complex128 *a, int *lda, int *ipiv, int *info) nogil +cdef void zgetrf(int *m, int *n, z *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_zgetrf(m, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgetri "BLAS_FUNC(zgetri)"(int *n, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zgetri(int *n, z *a, int *lda, int *ipiv, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zgetri(n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgetrs "BLAS_FUNC(zgetrs)"(char *trans, int *n, int *nrhs, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zgetrs(char *trans, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zggbak "BLAS_FUNC(zggbak)"(char *job, char *side, int *n, int *ilo, int *ihi, d *lscale, d *rscale, int *m, npy_complex128 *v, int *ldv, int *info) nogil +cdef void zggbak(char *job, char *side, int *n, int *ilo, int *ihi, d *lscale, d *rscale, int *m, z *v, int *ldv, int *info) noexcept nogil: + + _fortran_zggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zggbal "BLAS_FUNC(zggbal)"(char *job, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, int *ilo, int *ihi, d *lscale, d *rscale, d *work, int *info) nogil +cdef void zggbal(char *job, int *n, z *a, int *lda, z *b, int *ldb, int *ilo, int *ihi, d *lscale, d *rscale, d *work, int *info) noexcept nogil: + + _fortran_zggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgges "BLAS_FUNC(zgges)"(char *jobvsl, char *jobvsr, char *sort, _zselect2 *selctg, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, int *sdim, npy_complex128 *alpha, npy_complex128 *beta, npy_complex128 *vsl, int *ldvsl, npy_complex128 *vsr, int *ldvsr, npy_complex128 *work, int *lwork, d *rwork, bint *bwork, int *info) nogil +cdef void zgges(char *jobvsl, char *jobvsr, char *sort, zselect2 *selctg, int *n, z *a, int *lda, z *b, int *ldb, int *sdim, z *alpha, z *beta, z *vsl, int *ldvsl, z *vsr, int *ldvsr, z *work, int *lwork, d *rwork, bint *bwork, int *info) noexcept nogil: + + _fortran_zgges(jobvsl, jobvsr, sort, <_zselect2*>selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zggesx "BLAS_FUNC(zggesx)"(char *jobvsl, char *jobvsr, char *sort, _zselect2 *selctg, char *sense, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, int *sdim, npy_complex128 *alpha, npy_complex128 *beta, npy_complex128 *vsl, int *ldvsl, npy_complex128 *vsr, int *ldvsr, d *rconde, d *rcondv, npy_complex128 *work, int *lwork, d *rwork, int *iwork, int *liwork, bint *bwork, int *info) nogil +cdef void zggesx(char *jobvsl, char *jobvsr, char *sort, zselect2 *selctg, char *sense, int *n, z *a, int *lda, z *b, int *ldb, int *sdim, z *alpha, z *beta, z *vsl, int *ldvsl, z *vsr, int *ldvsr, d *rconde, d *rcondv, z *work, int *lwork, d *rwork, int *iwork, int *liwork, bint *bwork, int *info) noexcept nogil: + + _fortran_zggesx(jobvsl, jobvsr, sort, <_zselect2*>selctg, sense, n, a, lda, b, ldb, sdim, alpha, beta, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, rwork, iwork, liwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zggev "BLAS_FUNC(zggev)"(char *jobvl, char *jobvr, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *alpha, npy_complex128 *beta, npy_complex128 *vl, int *ldvl, npy_complex128 *vr, int *ldvr, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zggev(char *jobvl, char *jobvr, int *n, z *a, int *lda, z *b, int *ldb, z *alpha, z *beta, z *vl, int *ldvl, z *vr, int *ldvr, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zggev(jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zggevx "BLAS_FUNC(zggevx)"(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *alpha, npy_complex128 *beta, npy_complex128 *vl, int *ldvl, npy_complex128 *vr, int *ldvr, int *ilo, int *ihi, d *lscale, d *rscale, d *abnrm, d *bbnrm, d *rconde, d *rcondv, npy_complex128 *work, int *lwork, d *rwork, int *iwork, bint *bwork, int *info) nogil +cdef void zggevx(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, z *a, int *lda, z *b, int *ldb, z *alpha, z *beta, z *vl, int *ldvl, z *vr, int *ldvr, int *ilo, int *ihi, d *lscale, d *rscale, d *abnrm, d *bbnrm, d *rconde, d *rcondv, z *work, int *lwork, d *rwork, int *iwork, bint *bwork, int *info) noexcept nogil: + + _fortran_zggevx(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, rwork, iwork, bwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zggglm "BLAS_FUNC(zggglm)"(int *n, int *m, int *p, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *d, npy_complex128 *x, npy_complex128 *y, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zggglm(int *n, int *m, int *p, z *a, int *lda, z *b, int *ldb, z *d, z *x, z *y, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgghrd "BLAS_FUNC(zgghrd)"(char *compq, char *compz, int *n, int *ilo, int *ihi, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *q, int *ldq, npy_complex128 *z, int *ldz, int *info) nogil +cdef void zgghrd(char *compq, char *compz, int *n, int *ilo, int *ihi, z *a, int *lda, z *b, int *ldb, z *q, int *ldq, z *z, int *ldz, int *info) noexcept nogil: + + _fortran_zgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgglse "BLAS_FUNC(zgglse)"(int *m, int *n, int *p, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *c, npy_complex128 *d, npy_complex128 *x, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zgglse(int *m, int *n, int *p, z *a, int *lda, z *b, int *ldb, z *c, z *d, z *x, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zggqrf "BLAS_FUNC(zggqrf)"(int *n, int *m, int *p, npy_complex128 *a, int *lda, npy_complex128 *taua, npy_complex128 *b, int *ldb, npy_complex128 *taub, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zggqrf(int *n, int *m, int *p, z *a, int *lda, z *taua, z *b, int *ldb, z *taub, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zggrqf "BLAS_FUNC(zggrqf)"(int *m, int *p, int *n, npy_complex128 *a, int *lda, npy_complex128 *taua, npy_complex128 *b, int *ldb, npy_complex128 *taub, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zggrqf(int *m, int *p, int *n, z *a, int *lda, z *taua, z *b, int *ldb, z *taub, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgtcon "BLAS_FUNC(zgtcon)"(char *norm, int *n, npy_complex128 *dl, npy_complex128 *d, npy_complex128 *du, npy_complex128 *du2, int *ipiv, d *anorm, d *rcond, npy_complex128 *work, int *info) nogil +cdef void zgtcon(char *norm, int *n, z *dl, z *d, z *du, z *du2, int *ipiv, d *anorm, d *rcond, z *work, int *info) noexcept nogil: + + _fortran_zgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgtrfs "BLAS_FUNC(zgtrfs)"(char *trans, int *n, int *nrhs, npy_complex128 *dl, npy_complex128 *d, npy_complex128 *du, npy_complex128 *dlf, npy_complex128 *df, npy_complex128 *duf, npy_complex128 *du2, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zgtrfs(char *trans, int *n, int *nrhs, z *dl, z *d, z *du, z *dlf, z *df, z *duf, z *du2, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgtsv "BLAS_FUNC(zgtsv)"(int *n, int *nrhs, npy_complex128 *dl, npy_complex128 *d, npy_complex128 *du, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zgtsv(int *n, int *nrhs, z *dl, z *d, z *du, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zgtsv(n, nrhs, dl, d, du, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgtsvx "BLAS_FUNC(zgtsvx)"(char *fact, char *trans, int *n, int *nrhs, npy_complex128 *dl, npy_complex128 *d, npy_complex128 *du, npy_complex128 *dlf, npy_complex128 *df, npy_complex128 *duf, npy_complex128 *du2, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *rcond, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zgtsvx(char *fact, char *trans, int *n, int *nrhs, z *dl, z *d, z *du, z *dlf, z *df, z *duf, z *du2, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zgtsvx(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgttrf "BLAS_FUNC(zgttrf)"(int *n, npy_complex128 *dl, npy_complex128 *d, npy_complex128 *du, npy_complex128 *du2, int *ipiv, int *info) nogil +cdef void zgttrf(int *n, z *dl, z *d, z *du, z *du2, int *ipiv, int *info) noexcept nogil: + + _fortran_zgttrf(n, dl, d, du, du2, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgttrs "BLAS_FUNC(zgttrs)"(char *trans, int *n, int *nrhs, npy_complex128 *dl, npy_complex128 *d, npy_complex128 *du, npy_complex128 *du2, int *ipiv, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zgttrs(char *trans, int *n, int *nrhs, z *dl, z *d, z *du, z *du2, int *ipiv, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zgtts2 "BLAS_FUNC(zgtts2)"(int *itrans, int *n, int *nrhs, npy_complex128 *dl, npy_complex128 *d, npy_complex128 *du, npy_complex128 *du2, int *ipiv, npy_complex128 *b, int *ldb) nogil +cdef void zgtts2(int *itrans, int *n, int *nrhs, z *dl, z *d, z *du, z *du2, int *ipiv, z *b, int *ldb) noexcept nogil: + + _fortran_zgtts2(itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhbev "BLAS_FUNC(zhbev)"(char *jobz, char *uplo, int *n, int *kd, npy_complex128 *ab, int *ldab, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zhbev(char *jobz, char *uplo, int *n, int *kd, z *ab, int *ldab, d *w, z *z, int *ldz, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zhbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhbevd "BLAS_FUNC(zhbevd)"(char *jobz, char *uplo, int *n, int *kd, npy_complex128 *ab, int *ldab, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void zhbevd(char *jobz, char *uplo, int *n, int *kd, z *ab, int *ldab, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_zhbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhbevx "BLAS_FUNC(zhbevx)"(char *jobz, char *range, char *uplo, int *n, int *kd, npy_complex128 *ab, int *ldab, npy_complex128 *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, d *rwork, int *iwork, int *ifail, int *info) nogil +cdef void zhbevx(char *jobz, char *range, char *uplo, int *n, int *kd, z *ab, int *ldab, z *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_zhbevx(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhbgst "BLAS_FUNC(zhbgst)"(char *vect, char *uplo, int *n, int *ka, int *kb, npy_complex128 *ab, int *ldab, npy_complex128 *bb, int *ldbb, npy_complex128 *x, int *ldx, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zhbgst(char *vect, char *uplo, int *n, int *ka, int *kb, z *ab, int *ldab, z *bb, int *ldbb, z *x, int *ldx, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zhbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhbgv "BLAS_FUNC(zhbgv)"(char *jobz, char *uplo, int *n, int *ka, int *kb, npy_complex128 *ab, int *ldab, npy_complex128 *bb, int *ldbb, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zhbgv(char *jobz, char *uplo, int *n, int *ka, int *kb, z *ab, int *ldab, z *bb, int *ldbb, d *w, z *z, int *ldz, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zhbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhbgvd "BLAS_FUNC(zhbgvd)"(char *jobz, char *uplo, int *n, int *ka, int *kb, npy_complex128 *ab, int *ldab, npy_complex128 *bb, int *ldbb, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void zhbgvd(char *jobz, char *uplo, int *n, int *ka, int *kb, z *ab, int *ldab, z *bb, int *ldbb, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_zhbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhbgvx "BLAS_FUNC(zhbgvx)"(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, npy_complex128 *ab, int *ldab, npy_complex128 *bb, int *ldbb, npy_complex128 *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, d *rwork, int *iwork, int *ifail, int *info) nogil +cdef void zhbgvx(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, z *ab, int *ldab, z *bb, int *ldbb, z *q, int *ldq, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_zhbgvx(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhbtrd "BLAS_FUNC(zhbtrd)"(char *vect, char *uplo, int *n, int *kd, npy_complex128 *ab, int *ldab, d *d, d *e, npy_complex128 *q, int *ldq, npy_complex128 *work, int *info) nogil +cdef void zhbtrd(char *vect, char *uplo, int *n, int *kd, z *ab, int *ldab, d *d, d *e, z *q, int *ldq, z *work, int *info) noexcept nogil: + + _fortran_zhbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhecon "BLAS_FUNC(zhecon)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, d *anorm, d *rcond, npy_complex128 *work, int *info) nogil +cdef void zhecon(char *uplo, int *n, z *a, int *lda, int *ipiv, d *anorm, d *rcond, z *work, int *info) noexcept nogil: + + _fortran_zhecon(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zheequb "BLAS_FUNC(zheequb)"(char *uplo, int *n, npy_complex128 *a, int *lda, d *s, d *scond, d *amax, npy_complex128 *work, int *info) nogil +cdef void zheequb(char *uplo, int *n, z *a, int *lda, d *s, d *scond, d *amax, z *work, int *info) noexcept nogil: + + _fortran_zheequb(uplo, n, a, lda, s, scond, amax, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zheev "BLAS_FUNC(zheev)"(char *jobz, char *uplo, int *n, npy_complex128 *a, int *lda, d *w, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zheev(char *jobz, char *uplo, int *n, z *a, int *lda, d *w, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zheev(jobz, uplo, n, a, lda, w, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zheevd "BLAS_FUNC(zheevd)"(char *jobz, char *uplo, int *n, npy_complex128 *a, int *lda, d *w, npy_complex128 *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void zheevd(char *jobz, char *uplo, int *n, z *a, int *lda, d *w, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_zheevd(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zheevr "BLAS_FUNC(zheevr)"(char *jobz, char *range, char *uplo, int *n, npy_complex128 *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, npy_complex128 *z, int *ldz, int *isuppz, npy_complex128 *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void zheevr(char *jobz, char *range, char *uplo, int *n, z *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, int *isuppz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_zheevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zheevx "BLAS_FUNC(zheevx)"(char *jobz, char *range, char *uplo, int *n, npy_complex128 *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, int *lwork, d *rwork, int *iwork, int *ifail, int *info) nogil +cdef void zheevx(char *jobz, char *range, char *uplo, int *n, z *a, int *lda, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_zheevx(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhegs2 "BLAS_FUNC(zhegs2)"(int *itype, char *uplo, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zhegs2(int *itype, char *uplo, int *n, z *a, int *lda, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zhegs2(itype, uplo, n, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhegst "BLAS_FUNC(zhegst)"(int *itype, char *uplo, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zhegst(int *itype, char *uplo, int *n, z *a, int *lda, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zhegst(itype, uplo, n, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhegv "BLAS_FUNC(zhegv)"(int *itype, char *jobz, char *uplo, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, d *w, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zhegv(int *itype, char *jobz, char *uplo, int *n, z *a, int *lda, z *b, int *ldb, d *w, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zhegv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhegvd "BLAS_FUNC(zhegvd)"(int *itype, char *jobz, char *uplo, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, d *w, npy_complex128 *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void zhegvd(int *itype, char *jobz, char *uplo, int *n, z *a, int *lda, z *b, int *ldb, d *w, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_zhegvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhegvx "BLAS_FUNC(zhegvx)"(int *itype, char *jobz, char *range, char *uplo, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, int *lwork, d *rwork, int *iwork, int *ifail, int *info) nogil +cdef void zhegvx(int *itype, char *jobz, char *range, char *uplo, int *n, z *a, int *lda, z *b, int *ldb, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_zhegvx(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zherfs "BLAS_FUNC(zherfs)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *af, int *ldaf, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zherfs(char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zherfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhesv "BLAS_FUNC(zhesv)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zhesv(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zhesv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhesvx "BLAS_FUNC(zhesvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *af, int *ldaf, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *rcond, d *ferr, d *berr, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zhesvx(char *fact, char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zhesvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zheswapr "BLAS_FUNC(zheswapr)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *i1, int *i2) nogil +cdef void zheswapr(char *uplo, int *n, z *a, int *lda, int *i1, int *i2) noexcept nogil: + + _fortran_zheswapr(uplo, n, a, lda, i1, i2) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhetd2 "BLAS_FUNC(zhetd2)"(char *uplo, int *n, npy_complex128 *a, int *lda, d *d, d *e, npy_complex128 *tau, int *info) nogil +cdef void zhetd2(char *uplo, int *n, z *a, int *lda, d *d, d *e, z *tau, int *info) noexcept nogil: + + _fortran_zhetd2(uplo, n, a, lda, d, e, tau, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhetf2 "BLAS_FUNC(zhetf2)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, int *info) nogil +cdef void zhetf2(char *uplo, int *n, z *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_zhetf2(uplo, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhetrd "BLAS_FUNC(zhetrd)"(char *uplo, int *n, npy_complex128 *a, int *lda, d *d, d *e, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zhetrd(char *uplo, int *n, z *a, int *lda, d *d, d *e, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zhetrd(uplo, n, a, lda, d, e, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhetrf "BLAS_FUNC(zhetrf)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zhetrf(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zhetrf(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhetri "BLAS_FUNC(zhetri)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *work, int *info) nogil +cdef void zhetri(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *info) noexcept nogil: + + _fortran_zhetri(uplo, n, a, lda, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhetri2 "BLAS_FUNC(zhetri2)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zhetri2(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zhetri2(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhetri2x "BLAS_FUNC(zhetri2x)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *work, int *nb, int *info) nogil +cdef void zhetri2x(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *nb, int *info) noexcept nogil: + + _fortran_zhetri2x(uplo, n, a, lda, ipiv, work, nb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhetrs "BLAS_FUNC(zhetrs)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zhetrs(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zhetrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhetrs2 "BLAS_FUNC(zhetrs2)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *work, int *info) nogil +cdef void zhetrs2(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, z *work, int *info) noexcept nogil: + + _fortran_zhetrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhfrk "BLAS_FUNC(zhfrk)"(char *transr, char *uplo, char *trans, int *n, int *k, d *alpha, npy_complex128 *a, int *lda, d *beta, npy_complex128 *c) nogil +cdef void zhfrk(char *transr, char *uplo, char *trans, int *n, int *k, d *alpha, z *a, int *lda, d *beta, z *c) noexcept nogil: + + _fortran_zhfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhgeqz "BLAS_FUNC(zhgeqz)"(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, npy_complex128 *h, int *ldh, npy_complex128 *t, int *ldt, npy_complex128 *alpha, npy_complex128 *beta, npy_complex128 *q, int *ldq, npy_complex128 *z, int *ldz, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zhgeqz(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, z *h, int *ldh, z *t, int *ldt, z *alpha, z *beta, z *q, int *ldq, z *z, int *ldz, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zhgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhpcon "BLAS_FUNC(zhpcon)"(char *uplo, int *n, npy_complex128 *ap, int *ipiv, d *anorm, d *rcond, npy_complex128 *work, int *info) nogil +cdef void zhpcon(char *uplo, int *n, z *ap, int *ipiv, d *anorm, d *rcond, z *work, int *info) noexcept nogil: + + _fortran_zhpcon(uplo, n, ap, ipiv, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhpev "BLAS_FUNC(zhpev)"(char *jobz, char *uplo, int *n, npy_complex128 *ap, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zhpev(char *jobz, char *uplo, int *n, z *ap, d *w, z *z, int *ldz, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zhpev(jobz, uplo, n, ap, w, z, ldz, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhpevd "BLAS_FUNC(zhpevd)"(char *jobz, char *uplo, int *n, npy_complex128 *ap, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void zhpevd(char *jobz, char *uplo, int *n, z *ap, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_zhpevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhpevx "BLAS_FUNC(zhpevx)"(char *jobz, char *range, char *uplo, int *n, npy_complex128 *ap, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, d *rwork, int *iwork, int *ifail, int *info) nogil +cdef void zhpevx(char *jobz, char *range, char *uplo, int *n, z *ap, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_zhpevx(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhpgst "BLAS_FUNC(zhpgst)"(int *itype, char *uplo, int *n, npy_complex128 *ap, npy_complex128 *bp, int *info) nogil +cdef void zhpgst(int *itype, char *uplo, int *n, z *ap, z *bp, int *info) noexcept nogil: + + _fortran_zhpgst(itype, uplo, n, ap, bp, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhpgv "BLAS_FUNC(zhpgv)"(int *itype, char *jobz, char *uplo, int *n, npy_complex128 *ap, npy_complex128 *bp, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zhpgv(int *itype, char *jobz, char *uplo, int *n, z *ap, z *bp, d *w, z *z, int *ldz, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zhpgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhpgvd "BLAS_FUNC(zhpgvd)"(int *itype, char *jobz, char *uplo, int *n, npy_complex128 *ap, npy_complex128 *bp, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void zhpgvd(int *itype, char *jobz, char *uplo, int *n, z *ap, z *bp, d *w, z *z, int *ldz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_zhpgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhpgvx "BLAS_FUNC(zhpgvx)"(int *itype, char *jobz, char *range, char *uplo, int *n, npy_complex128 *ap, npy_complex128 *bp, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, npy_complex128 *z, int *ldz, npy_complex128 *work, d *rwork, int *iwork, int *ifail, int *info) nogil +cdef void zhpgvx(int *itype, char *jobz, char *range, char *uplo, int *n, z *ap, z *bp, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, z *work, d *rwork, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_zhpgvx(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhprfs "BLAS_FUNC(zhprfs)"(char *uplo, int *n, int *nrhs, npy_complex128 *ap, npy_complex128 *afp, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zhprfs(char *uplo, int *n, int *nrhs, z *ap, z *afp, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zhprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhpsv "BLAS_FUNC(zhpsv)"(char *uplo, int *n, int *nrhs, npy_complex128 *ap, int *ipiv, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zhpsv(char *uplo, int *n, int *nrhs, z *ap, int *ipiv, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zhpsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhpsvx "BLAS_FUNC(zhpsvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex128 *ap, npy_complex128 *afp, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *rcond, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zhpsvx(char *fact, char *uplo, int *n, int *nrhs, z *ap, z *afp, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zhpsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhptrd "BLAS_FUNC(zhptrd)"(char *uplo, int *n, npy_complex128 *ap, d *d, d *e, npy_complex128 *tau, int *info) nogil +cdef void zhptrd(char *uplo, int *n, z *ap, d *d, d *e, z *tau, int *info) noexcept nogil: + + _fortran_zhptrd(uplo, n, ap, d, e, tau, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhptrf "BLAS_FUNC(zhptrf)"(char *uplo, int *n, npy_complex128 *ap, int *ipiv, int *info) nogil +cdef void zhptrf(char *uplo, int *n, z *ap, int *ipiv, int *info) noexcept nogil: + + _fortran_zhptrf(uplo, n, ap, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhptri "BLAS_FUNC(zhptri)"(char *uplo, int *n, npy_complex128 *ap, int *ipiv, npy_complex128 *work, int *info) nogil +cdef void zhptri(char *uplo, int *n, z *ap, int *ipiv, z *work, int *info) noexcept nogil: + + _fortran_zhptri(uplo, n, ap, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhptrs "BLAS_FUNC(zhptrs)"(char *uplo, int *n, int *nrhs, npy_complex128 *ap, int *ipiv, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zhptrs(char *uplo, int *n, int *nrhs, z *ap, int *ipiv, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zhptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhsein "BLAS_FUNC(zhsein)"(char *side, char *eigsrc, char *initv, bint *select, int *n, npy_complex128 *h, int *ldh, npy_complex128 *w, npy_complex128 *vl, int *ldvl, npy_complex128 *vr, int *ldvr, int *mm, int *m, npy_complex128 *work, d *rwork, int *ifaill, int *ifailr, int *info) nogil +cdef void zhsein(char *side, char *eigsrc, char *initv, bint *select, int *n, z *h, int *ldh, z *w, z *vl, int *ldvl, z *vr, int *ldvr, int *mm, int *m, z *work, d *rwork, int *ifaill, int *ifailr, int *info) noexcept nogil: + + _fortran_zhsein(side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zhseqr "BLAS_FUNC(zhseqr)"(char *job, char *compz, int *n, int *ilo, int *ihi, npy_complex128 *h, int *ldh, npy_complex128 *w, npy_complex128 *z, int *ldz, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zhseqr(char *job, char *compz, int *n, int *ilo, int *ihi, z *h, int *ldh, z *w, z *z, int *ldz, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zhseqr(job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlabrd "BLAS_FUNC(zlabrd)"(int *m, int *n, int *nb, npy_complex128 *a, int *lda, d *d, d *e, npy_complex128 *tauq, npy_complex128 *taup, npy_complex128 *x, int *ldx, npy_complex128 *y, int *ldy) nogil +cdef void zlabrd(int *m, int *n, int *nb, z *a, int *lda, d *d, d *e, z *tauq, z *taup, z *x, int *ldx, z *y, int *ldy) noexcept nogil: + + _fortran_zlabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlacgv "BLAS_FUNC(zlacgv)"(int *n, npy_complex128 *x, int *incx) nogil +cdef void zlacgv(int *n, z *x, int *incx) noexcept nogil: + + _fortran_zlacgv(n, x, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlacn2 "BLAS_FUNC(zlacn2)"(int *n, npy_complex128 *v, npy_complex128 *x, d *est, int *kase, int *isave) nogil +cdef void zlacn2(int *n, z *v, z *x, d *est, int *kase, int *isave) noexcept nogil: + + _fortran_zlacn2(n, v, x, est, kase, isave) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlacon "BLAS_FUNC(zlacon)"(int *n, npy_complex128 *v, npy_complex128 *x, d *est, int *kase) nogil +cdef void zlacon(int *n, z *v, z *x, d *est, int *kase) noexcept nogil: + + _fortran_zlacon(n, v, x, est, kase) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlacp2 "BLAS_FUNC(zlacp2)"(char *uplo, int *m, int *n, d *a, int *lda, npy_complex128 *b, int *ldb) nogil +cdef void zlacp2(char *uplo, int *m, int *n, d *a, int *lda, z *b, int *ldb) noexcept nogil: + + _fortran_zlacp2(uplo, m, n, a, lda, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlacpy "BLAS_FUNC(zlacpy)"(char *uplo, int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb) nogil +cdef void zlacpy(char *uplo, int *m, int *n, z *a, int *lda, z *b, int *ldb) noexcept nogil: + + _fortran_zlacpy(uplo, m, n, a, lda, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlacrm "BLAS_FUNC(zlacrm)"(int *m, int *n, npy_complex128 *a, int *lda, d *b, int *ldb, npy_complex128 *c, int *ldc, d *rwork) nogil +cdef void zlacrm(int *m, int *n, z *a, int *lda, d *b, int *ldb, z *c, int *ldc, d *rwork) noexcept nogil: + + _fortran_zlacrm(m, n, a, lda, b, ldb, c, ldc, rwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlacrt "BLAS_FUNC(zlacrt)"(int *n, npy_complex128 *cx, int *incx, npy_complex128 *cy, int *incy, npy_complex128 *c, npy_complex128 *s) nogil +cdef void zlacrt(int *n, z *cx, int *incx, z *cy, int *incy, z *c, z *s) noexcept nogil: + + _fortran_zlacrt(n, cx, incx, cy, incy, c, s) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zladiv "(zladivwrp_)"(npy_complex128 *out, npy_complex128 *x, npy_complex128 *y) nogil +cdef z zladiv(z *x, z *y) noexcept nogil: + cdef z out + _fortran_zladiv(&out, x, y) + return out + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaed0 "BLAS_FUNC(zlaed0)"(int *qsiz, int *n, d *d, d *e, npy_complex128 *q, int *ldq, npy_complex128 *qstore, int *ldqs, d *rwork, int *iwork, int *info) nogil +cdef void zlaed0(int *qsiz, int *n, d *d, d *e, z *q, int *ldq, z *qstore, int *ldqs, d *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_zlaed0(qsiz, n, d, e, q, ldq, qstore, ldqs, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaed7 "BLAS_FUNC(zlaed7)"(int *n, int *cutpnt, int *qsiz, int *tlvls, int *curlvl, int *curpbm, d *d, npy_complex128 *q, int *ldq, d *rho, int *indxq, d *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, d *givnum, npy_complex128 *work, d *rwork, int *iwork, int *info) nogil +cdef void zlaed7(int *n, int *cutpnt, int *qsiz, int *tlvls, int *curlvl, int *curpbm, d *d, z *q, int *ldq, d *rho, int *indxq, d *qstore, int *qptr, int *prmptr, int *perm, int *givptr, int *givcol, d *givnum, z *work, d *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_zlaed7(n, cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, ldq, rho, indxq, qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaed8 "BLAS_FUNC(zlaed8)"(int *k, int *n, int *qsiz, npy_complex128 *q, int *ldq, d *d, d *rho, int *cutpnt, d *z, d *dlamda, npy_complex128 *q2, int *ldq2, d *w, int *indxp, int *indx, int *indxq, int *perm, int *givptr, int *givcol, d *givnum, int *info) nogil +cdef void zlaed8(int *k, int *n, int *qsiz, z *q, int *ldq, d *d, d *rho, int *cutpnt, d *z, d *dlamda, z *q2, int *ldq2, d *w, int *indxp, int *indx, int *indxq, int *perm, int *givptr, int *givcol, d *givnum, int *info) noexcept nogil: + + _fortran_zlaed8(k, n, qsiz, q, ldq, d, rho, cutpnt, z, dlamda, q2, ldq2, w, indxp, indx, indxq, perm, givptr, givcol, givnum, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaein "BLAS_FUNC(zlaein)"(bint *rightv, bint *noinit, int *n, npy_complex128 *h, int *ldh, npy_complex128 *w, npy_complex128 *v, npy_complex128 *b, int *ldb, d *rwork, d *eps3, d *smlnum, int *info) nogil +cdef void zlaein(bint *rightv, bint *noinit, int *n, z *h, int *ldh, z *w, z *v, z *b, int *ldb, d *rwork, d *eps3, d *smlnum, int *info) noexcept nogil: + + _fortran_zlaein(rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaesy "BLAS_FUNC(zlaesy)"(npy_complex128 *a, npy_complex128 *b, npy_complex128 *c, npy_complex128 *rt1, npy_complex128 *rt2, npy_complex128 *evscal, npy_complex128 *cs1, npy_complex128 *sn1) nogil +cdef void zlaesy(z *a, z *b, z *c, z *rt1, z *rt2, z *evscal, z *cs1, z *sn1) noexcept nogil: + + _fortran_zlaesy(a, b, c, rt1, rt2, evscal, cs1, sn1) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaev2 "BLAS_FUNC(zlaev2)"(npy_complex128 *a, npy_complex128 *b, npy_complex128 *c, d *rt1, d *rt2, d *cs1, npy_complex128 *sn1) nogil +cdef void zlaev2(z *a, z *b, z *c, d *rt1, d *rt2, d *cs1, z *sn1) noexcept nogil: + + _fortran_zlaev2(a, b, c, rt1, rt2, cs1, sn1) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlag2c "BLAS_FUNC(zlag2c)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex64 *sa, int *ldsa, int *info) nogil +cdef void zlag2c(int *m, int *n, z *a, int *lda, c *sa, int *ldsa, int *info) noexcept nogil: + + _fortran_zlag2c(m, n, a, lda, sa, ldsa, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlags2 "BLAS_FUNC(zlags2)"(bint *upper, d *a1, npy_complex128 *a2, d *a3, d *b1, npy_complex128 *b2, d *b3, d *csu, npy_complex128 *snu, d *csv, npy_complex128 *snv, d *csq, npy_complex128 *snq) nogil +cdef void zlags2(bint *upper, d *a1, z *a2, d *a3, d *b1, z *b2, d *b3, d *csu, z *snu, d *csv, z *snv, d *csq, z *snq) noexcept nogil: + + _fortran_zlags2(upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlagtm "BLAS_FUNC(zlagtm)"(char *trans, int *n, int *nrhs, d *alpha, npy_complex128 *dl, npy_complex128 *d, npy_complex128 *du, npy_complex128 *x, int *ldx, d *beta, npy_complex128 *b, int *ldb) nogil +cdef void zlagtm(char *trans, int *n, int *nrhs, d *alpha, z *dl, z *d, z *du, z *x, int *ldx, d *beta, z *b, int *ldb) noexcept nogil: + + _fortran_zlagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlahef "BLAS_FUNC(zlahef)"(char *uplo, int *n, int *nb, int *kb, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *w, int *ldw, int *info) nogil +cdef void zlahef(char *uplo, int *n, int *nb, int *kb, z *a, int *lda, int *ipiv, z *w, int *ldw, int *info) noexcept nogil: + + _fortran_zlahef(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlahqr "BLAS_FUNC(zlahqr)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, npy_complex128 *h, int *ldh, npy_complex128 *w, int *iloz, int *ihiz, npy_complex128 *z, int *ldz, int *info) nogil +cdef void zlahqr(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, z *h, int *ldh, z *w, int *iloz, int *ihiz, z *z, int *ldz, int *info) noexcept nogil: + + _fortran_zlahqr(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlahr2 "BLAS_FUNC(zlahr2)"(int *n, int *k, int *nb, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *t, int *ldt, npy_complex128 *y, int *ldy) nogil +cdef void zlahr2(int *n, int *k, int *nb, z *a, int *lda, z *tau, z *t, int *ldt, z *y, int *ldy) noexcept nogil: + + _fortran_zlahr2(n, k, nb, a, lda, tau, t, ldt, y, ldy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaic1 "BLAS_FUNC(zlaic1)"(int *job, int *j, npy_complex128 *x, d *sest, npy_complex128 *w, npy_complex128 *gamma, d *sestpr, npy_complex128 *s, npy_complex128 *c) nogil +cdef void zlaic1(int *job, int *j, z *x, d *sest, z *w, z *gamma, d *sestpr, z *s, z *c) noexcept nogil: + + _fortran_zlaic1(job, j, x, sest, w, gamma, sestpr, s, c) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlals0 "BLAS_FUNC(zlals0)"(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, npy_complex128 *b, int *ldb, npy_complex128 *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *poles, d *difl, d *difr, d *z, int *k, d *c, d *s, d *rwork, int *info) nogil +cdef void zlals0(int *icompq, int *nl, int *nr, int *sqre, int *nrhs, z *b, int *ldb, z *bx, int *ldbx, int *perm, int *givptr, int *givcol, int *ldgcol, d *givnum, int *ldgnum, d *poles, d *difl, d *difr, d *z, int *k, d *c, d *s, d *rwork, int *info) noexcept nogil: + + _fortran_zlals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlalsa "BLAS_FUNC(zlalsa)"(int *icompq, int *smlsiz, int *n, int *nrhs, npy_complex128 *b, int *ldb, npy_complex128 *bx, int *ldbx, d *u, int *ldu, d *vt, int *k, d *difl, d *difr, d *z, d *poles, int *givptr, int *givcol, int *ldgcol, int *perm, d *givnum, d *c, d *s, d *rwork, int *iwork, int *info) nogil +cdef void zlalsa(int *icompq, int *smlsiz, int *n, int *nrhs, z *b, int *ldb, z *bx, int *ldbx, d *u, int *ldu, d *vt, int *k, d *difl, d *difr, d *z, d *poles, int *givptr, int *givcol, int *ldgcol, int *perm, d *givnum, d *c, d *s, d *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_zlalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlalsd "BLAS_FUNC(zlalsd)"(char *uplo, int *smlsiz, int *n, int *nrhs, d *d, d *e, npy_complex128 *b, int *ldb, d *rcond, int *rank, npy_complex128 *work, d *rwork, int *iwork, int *info) nogil +cdef void zlalsd(char *uplo, int *smlsiz, int *n, int *nrhs, d *d, d *e, z *b, int *ldb, d *rcond, int *rank, z *work, d *rwork, int *iwork, int *info) noexcept nogil: + + _fortran_zlalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlangb "BLAS_FUNC(zlangb)"(char *norm, int *n, int *kl, int *ku, npy_complex128 *ab, int *ldab, d *work) nogil +cdef d zlangb(char *norm, int *n, int *kl, int *ku, z *ab, int *ldab, d *work) noexcept nogil: + + return _fortran_zlangb(norm, n, kl, ku, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlange "BLAS_FUNC(zlange)"(char *norm, int *m, int *n, npy_complex128 *a, int *lda, d *work) nogil +cdef d zlange(char *norm, int *m, int *n, z *a, int *lda, d *work) noexcept nogil: + + return _fortran_zlange(norm, m, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlangt "BLAS_FUNC(zlangt)"(char *norm, int *n, npy_complex128 *dl, npy_complex128 *d_, npy_complex128 *du) nogil +cdef d zlangt(char *norm, int *n, z *dl, z *d_, z *du) noexcept nogil: + + return _fortran_zlangt(norm, n, dl, d_, du) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlanhb "BLAS_FUNC(zlanhb)"(char *norm, char *uplo, int *n, int *k, npy_complex128 *ab, int *ldab, d *work) nogil +cdef d zlanhb(char *norm, char *uplo, int *n, int *k, z *ab, int *ldab, d *work) noexcept nogil: + + return _fortran_zlanhb(norm, uplo, n, k, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlanhe "BLAS_FUNC(zlanhe)"(char *norm, char *uplo, int *n, npy_complex128 *a, int *lda, d *work) nogil +cdef d zlanhe(char *norm, char *uplo, int *n, z *a, int *lda, d *work) noexcept nogil: + + return _fortran_zlanhe(norm, uplo, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlanhf "BLAS_FUNC(zlanhf)"(char *norm, char *transr, char *uplo, int *n, npy_complex128 *a, d *work) nogil +cdef d zlanhf(char *norm, char *transr, char *uplo, int *n, z *a, d *work) noexcept nogil: + + return _fortran_zlanhf(norm, transr, uplo, n, a, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlanhp "BLAS_FUNC(zlanhp)"(char *norm, char *uplo, int *n, npy_complex128 *ap, d *work) nogil +cdef d zlanhp(char *norm, char *uplo, int *n, z *ap, d *work) noexcept nogil: + + return _fortran_zlanhp(norm, uplo, n, ap, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlanhs "BLAS_FUNC(zlanhs)"(char *norm, int *n, npy_complex128 *a, int *lda, d *work) nogil +cdef d zlanhs(char *norm, int *n, z *a, int *lda, d *work) noexcept nogil: + + return _fortran_zlanhs(norm, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlanht "BLAS_FUNC(zlanht)"(char *norm, int *n, d *d_, npy_complex128 *e) nogil +cdef d zlanht(char *norm, int *n, d *d_, z *e) noexcept nogil: + + return _fortran_zlanht(norm, n, d_, e) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlansb "BLAS_FUNC(zlansb)"(char *norm, char *uplo, int *n, int *k, npy_complex128 *ab, int *ldab, d *work) nogil +cdef d zlansb(char *norm, char *uplo, int *n, int *k, z *ab, int *ldab, d *work) noexcept nogil: + + return _fortran_zlansb(norm, uplo, n, k, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlansp "BLAS_FUNC(zlansp)"(char *norm, char *uplo, int *n, npy_complex128 *ap, d *work) nogil +cdef d zlansp(char *norm, char *uplo, int *n, z *ap, d *work) noexcept nogil: + + return _fortran_zlansp(norm, uplo, n, ap, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlansy "BLAS_FUNC(zlansy)"(char *norm, char *uplo, int *n, npy_complex128 *a, int *lda, d *work) nogil +cdef d zlansy(char *norm, char *uplo, int *n, z *a, int *lda, d *work) noexcept nogil: + + return _fortran_zlansy(norm, uplo, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlantb "BLAS_FUNC(zlantb)"(char *norm, char *uplo, char *diag, int *n, int *k, npy_complex128 *ab, int *ldab, d *work) nogil +cdef d zlantb(char *norm, char *uplo, char *diag, int *n, int *k, z *ab, int *ldab, d *work) noexcept nogil: + + return _fortran_zlantb(norm, uplo, diag, n, k, ab, ldab, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlantp "BLAS_FUNC(zlantp)"(char *norm, char *uplo, char *diag, int *n, npy_complex128 *ap, d *work) nogil +cdef d zlantp(char *norm, char *uplo, char *diag, int *n, z *ap, d *work) noexcept nogil: + + return _fortran_zlantp(norm, uplo, diag, n, ap, work) + + +cdef extern from "_lapack_subroutines.h": + d _fortran_zlantr "BLAS_FUNC(zlantr)"(char *norm, char *uplo, char *diag, int *m, int *n, npy_complex128 *a, int *lda, d *work) nogil +cdef d zlantr(char *norm, char *uplo, char *diag, int *m, int *n, z *a, int *lda, d *work) noexcept nogil: + + return _fortran_zlantr(norm, uplo, diag, m, n, a, lda, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlapll "BLAS_FUNC(zlapll)"(int *n, npy_complex128 *x, int *incx, npy_complex128 *y, int *incy, d *ssmin) nogil +cdef void zlapll(int *n, z *x, int *incx, z *y, int *incy, d *ssmin) noexcept nogil: + + _fortran_zlapll(n, x, incx, y, incy, ssmin) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlapmr "BLAS_FUNC(zlapmr)"(bint *forwrd, int *m, int *n, npy_complex128 *x, int *ldx, int *k) nogil +cdef void zlapmr(bint *forwrd, int *m, int *n, z *x, int *ldx, int *k) noexcept nogil: + + _fortran_zlapmr(forwrd, m, n, x, ldx, k) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlapmt "BLAS_FUNC(zlapmt)"(bint *forwrd, int *m, int *n, npy_complex128 *x, int *ldx, int *k) nogil +cdef void zlapmt(bint *forwrd, int *m, int *n, z *x, int *ldx, int *k) noexcept nogil: + + _fortran_zlapmt(forwrd, m, n, x, ldx, k) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqgb "BLAS_FUNC(zlaqgb)"(int *m, int *n, int *kl, int *ku, npy_complex128 *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) nogil +cdef void zlaqgb(int *m, int *n, int *kl, int *ku, z *ab, int *ldab, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) noexcept nogil: + + _fortran_zlaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqge "BLAS_FUNC(zlaqge)"(int *m, int *n, npy_complex128 *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) nogil +cdef void zlaqge(int *m, int *n, z *a, int *lda, d *r, d *c, d *rowcnd, d *colcnd, d *amax, char *equed) noexcept nogil: + + _fortran_zlaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqhb "BLAS_FUNC(zlaqhb)"(char *uplo, int *n, int *kd, npy_complex128 *ab, int *ldab, d *s, d *scond, d *amax, char *equed) nogil +cdef void zlaqhb(char *uplo, int *n, int *kd, z *ab, int *ldab, d *s, d *scond, d *amax, char *equed) noexcept nogil: + + _fortran_zlaqhb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqhe "BLAS_FUNC(zlaqhe)"(char *uplo, int *n, npy_complex128 *a, int *lda, d *s, d *scond, d *amax, char *equed) nogil +cdef void zlaqhe(char *uplo, int *n, z *a, int *lda, d *s, d *scond, d *amax, char *equed) noexcept nogil: + + _fortran_zlaqhe(uplo, n, a, lda, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqhp "BLAS_FUNC(zlaqhp)"(char *uplo, int *n, npy_complex128 *ap, d *s, d *scond, d *amax, char *equed) nogil +cdef void zlaqhp(char *uplo, int *n, z *ap, d *s, d *scond, d *amax, char *equed) noexcept nogil: + + _fortran_zlaqhp(uplo, n, ap, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqp2 "BLAS_FUNC(zlaqp2)"(int *m, int *n, int *offset, npy_complex128 *a, int *lda, int *jpvt, npy_complex128 *tau, d *vn1, d *vn2, npy_complex128 *work) nogil +cdef void zlaqp2(int *m, int *n, int *offset, z *a, int *lda, int *jpvt, z *tau, d *vn1, d *vn2, z *work) noexcept nogil: + + _fortran_zlaqp2(m, n, offset, a, lda, jpvt, tau, vn1, vn2, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqps "BLAS_FUNC(zlaqps)"(int *m, int *n, int *offset, int *nb, int *kb, npy_complex128 *a, int *lda, int *jpvt, npy_complex128 *tau, d *vn1, d *vn2, npy_complex128 *auxv, npy_complex128 *f, int *ldf) nogil +cdef void zlaqps(int *m, int *n, int *offset, int *nb, int *kb, z *a, int *lda, int *jpvt, z *tau, d *vn1, d *vn2, z *auxv, z *f, int *ldf) noexcept nogil: + + _fortran_zlaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqr0 "BLAS_FUNC(zlaqr0)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, npy_complex128 *h, int *ldh, npy_complex128 *w, int *iloz, int *ihiz, npy_complex128 *z, int *ldz, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zlaqr0(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, z *h, int *ldh, z *w, int *iloz, int *ihiz, z *z, int *ldz, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zlaqr0(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqr1 "BLAS_FUNC(zlaqr1)"(int *n, npy_complex128 *h, int *ldh, npy_complex128 *s1, npy_complex128 *s2, npy_complex128 *v) nogil +cdef void zlaqr1(int *n, z *h, int *ldh, z *s1, z *s2, z *v) noexcept nogil: + + _fortran_zlaqr1(n, h, ldh, s1, s2, v) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqr2 "BLAS_FUNC(zlaqr2)"(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, npy_complex128 *h, int *ldh, int *iloz, int *ihiz, npy_complex128 *z, int *ldz, int *ns, int *nd, npy_complex128 *sh, npy_complex128 *v, int *ldv, int *nh, npy_complex128 *t, int *ldt, int *nv, npy_complex128 *wv, int *ldwv, npy_complex128 *work, int *lwork) nogil +cdef void zlaqr2(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, z *h, int *ldh, int *iloz, int *ihiz, z *z, int *ldz, int *ns, int *nd, z *sh, z *v, int *ldv, int *nh, z *t, int *ldt, int *nv, z *wv, int *ldwv, z *work, int *lwork) noexcept nogil: + + _fortran_zlaqr2(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqr3 "BLAS_FUNC(zlaqr3)"(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, npy_complex128 *h, int *ldh, int *iloz, int *ihiz, npy_complex128 *z, int *ldz, int *ns, int *nd, npy_complex128 *sh, npy_complex128 *v, int *ldv, int *nh, npy_complex128 *t, int *ldt, int *nv, npy_complex128 *wv, int *ldwv, npy_complex128 *work, int *lwork) nogil +cdef void zlaqr3(bint *wantt, bint *wantz, int *n, int *ktop, int *kbot, int *nw, z *h, int *ldh, int *iloz, int *ihiz, z *z, int *ldz, int *ns, int *nd, z *sh, z *v, int *ldv, int *nh, z *t, int *ldt, int *nv, z *wv, int *ldwv, z *work, int *lwork) noexcept nogil: + + _fortran_zlaqr3(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqr4 "BLAS_FUNC(zlaqr4)"(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, npy_complex128 *h, int *ldh, npy_complex128 *w, int *iloz, int *ihiz, npy_complex128 *z, int *ldz, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zlaqr4(bint *wantt, bint *wantz, int *n, int *ilo, int *ihi, z *h, int *ldh, z *w, int *iloz, int *ihiz, z *z, int *ldz, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zlaqr4(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqr5 "BLAS_FUNC(zlaqr5)"(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, npy_complex128 *s, npy_complex128 *h, int *ldh, int *iloz, int *ihiz, npy_complex128 *z, int *ldz, npy_complex128 *v, int *ldv, npy_complex128 *u, int *ldu, int *nv, npy_complex128 *wv, int *ldwv, int *nh, npy_complex128 *wh, int *ldwh) nogil +cdef void zlaqr5(bint *wantt, bint *wantz, int *kacc22, int *n, int *ktop, int *kbot, int *nshfts, z *s, z *h, int *ldh, int *iloz, int *ihiz, z *z, int *ldz, z *v, int *ldv, z *u, int *ldu, int *nv, z *wv, int *ldwv, int *nh, z *wh, int *ldwh) noexcept nogil: + + _fortran_zlaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqsb "BLAS_FUNC(zlaqsb)"(char *uplo, int *n, int *kd, npy_complex128 *ab, int *ldab, d *s, d *scond, d *amax, char *equed) nogil +cdef void zlaqsb(char *uplo, int *n, int *kd, z *ab, int *ldab, d *s, d *scond, d *amax, char *equed) noexcept nogil: + + _fortran_zlaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqsp "BLAS_FUNC(zlaqsp)"(char *uplo, int *n, npy_complex128 *ap, d *s, d *scond, d *amax, char *equed) nogil +cdef void zlaqsp(char *uplo, int *n, z *ap, d *s, d *scond, d *amax, char *equed) noexcept nogil: + + _fortran_zlaqsp(uplo, n, ap, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaqsy "BLAS_FUNC(zlaqsy)"(char *uplo, int *n, npy_complex128 *a, int *lda, d *s, d *scond, d *amax, char *equed) nogil +cdef void zlaqsy(char *uplo, int *n, z *a, int *lda, d *s, d *scond, d *amax, char *equed) noexcept nogil: + + _fortran_zlaqsy(uplo, n, a, lda, s, scond, amax, equed) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlar1v "BLAS_FUNC(zlar1v)"(int *n, int *b1, int *bn, d *lambda_, d *d, d *l, d *ld, d *lld, d *pivmin, d *gaptol, npy_complex128 *z, bint *wantnc, int *negcnt, d *ztz, d *mingma, int *r, int *isuppz, d *nrminv, d *resid, d *rqcorr, d *work) nogil +cdef void zlar1v(int *n, int *b1, int *bn, d *lambda_, d *d, d *l, d *ld, d *lld, d *pivmin, d *gaptol, z *z, bint *wantnc, int *negcnt, d *ztz, d *mingma, int *r, int *isuppz, d *nrminv, d *resid, d *rqcorr, d *work) noexcept nogil: + + _fortran_zlar1v(n, b1, bn, lambda_, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, mingma, r, isuppz, nrminv, resid, rqcorr, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlar2v "BLAS_FUNC(zlar2v)"(int *n, npy_complex128 *x, npy_complex128 *y, npy_complex128 *z, int *incx, d *c, npy_complex128 *s, int *incc) nogil +cdef void zlar2v(int *n, z *x, z *y, z *z, int *incx, d *c, z *s, int *incc) noexcept nogil: + + _fortran_zlar2v(n, x, y, z, incx, c, s, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarcm "BLAS_FUNC(zlarcm)"(int *m, int *n, d *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *c, int *ldc, d *rwork) nogil +cdef void zlarcm(int *m, int *n, d *a, int *lda, z *b, int *ldb, z *c, int *ldc, d *rwork) noexcept nogil: + + _fortran_zlarcm(m, n, a, lda, b, ldb, c, ldc, rwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarf "BLAS_FUNC(zlarf)"(char *side, int *m, int *n, npy_complex128 *v, int *incv, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work) nogil +cdef void zlarf(char *side, int *m, int *n, z *v, int *incv, z *tau, z *c, int *ldc, z *work) noexcept nogil: + + _fortran_zlarf(side, m, n, v, incv, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarfb "BLAS_FUNC(zlarfb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, npy_complex128 *v, int *ldv, npy_complex128 *t, int *ldt, npy_complex128 *c, int *ldc, npy_complex128 *work, int *ldwork) nogil +cdef void zlarfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, z *v, int *ldv, z *t, int *ldt, z *c, int *ldc, z *work, int *ldwork) noexcept nogil: + + _fortran_zlarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarfg "BLAS_FUNC(zlarfg)"(int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *tau) nogil +cdef void zlarfg(int *n, z *alpha, z *x, int *incx, z *tau) noexcept nogil: + + _fortran_zlarfg(n, alpha, x, incx, tau) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarfgp "BLAS_FUNC(zlarfgp)"(int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *tau) nogil +cdef void zlarfgp(int *n, z *alpha, z *x, int *incx, z *tau) noexcept nogil: + + _fortran_zlarfgp(n, alpha, x, incx, tau) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarft "BLAS_FUNC(zlarft)"(char *direct, char *storev, int *n, int *k, npy_complex128 *v, int *ldv, npy_complex128 *tau, npy_complex128 *t, int *ldt) nogil +cdef void zlarft(char *direct, char *storev, int *n, int *k, z *v, int *ldv, z *tau, z *t, int *ldt) noexcept nogil: + + _fortran_zlarft(direct, storev, n, k, v, ldv, tau, t, ldt) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarfx "BLAS_FUNC(zlarfx)"(char *side, int *m, int *n, npy_complex128 *v, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work) nogil +cdef void zlarfx(char *side, int *m, int *n, z *v, z *tau, z *c, int *ldc, z *work) noexcept nogil: + + _fortran_zlarfx(side, m, n, v, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlargv "BLAS_FUNC(zlargv)"(int *n, npy_complex128 *x, int *incx, npy_complex128 *y, int *incy, d *c, int *incc) nogil +cdef void zlargv(int *n, z *x, int *incx, z *y, int *incy, d *c, int *incc) noexcept nogil: + + _fortran_zlargv(n, x, incx, y, incy, c, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarnv "BLAS_FUNC(zlarnv)"(int *idist, int *iseed, int *n, npy_complex128 *x) nogil +cdef void zlarnv(int *idist, int *iseed, int *n, z *x) noexcept nogil: + + _fortran_zlarnv(idist, iseed, n, x) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarrv "BLAS_FUNC(zlarrv)"(int *n, d *vl, d *vu, d *d, d *l, d *pivmin, int *isplit, int *m, int *dol, int *dou, d *minrgp, d *rtol1, d *rtol2, d *w, d *werr, d *wgap, int *iblock, int *indexw, d *gers, npy_complex128 *z, int *ldz, int *isuppz, d *work, int *iwork, int *info) nogil +cdef void zlarrv(int *n, d *vl, d *vu, d *d, d *l, d *pivmin, int *isplit, int *m, int *dol, int *dou, d *minrgp, d *rtol1, d *rtol2, d *w, d *werr, d *wgap, int *iblock, int *indexw, d *gers, z *z, int *ldz, int *isuppz, d *work, int *iwork, int *info) noexcept nogil: + + _fortran_zlarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlartg "BLAS_FUNC(zlartg)"(npy_complex128 *f, npy_complex128 *g, d *cs, npy_complex128 *sn, npy_complex128 *r) nogil +cdef void zlartg(z *f, z *g, d *cs, z *sn, z *r) noexcept nogil: + + _fortran_zlartg(f, g, cs, sn, r) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlartv "BLAS_FUNC(zlartv)"(int *n, npy_complex128 *x, int *incx, npy_complex128 *y, int *incy, d *c, npy_complex128 *s, int *incc) nogil +cdef void zlartv(int *n, z *x, int *incx, z *y, int *incy, d *c, z *s, int *incc) noexcept nogil: + + _fortran_zlartv(n, x, incx, y, incy, c, s, incc) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarz "BLAS_FUNC(zlarz)"(char *side, int *m, int *n, int *l, npy_complex128 *v, int *incv, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work) nogil +cdef void zlarz(char *side, int *m, int *n, int *l, z *v, int *incv, z *tau, z *c, int *ldc, z *work) noexcept nogil: + + _fortran_zlarz(side, m, n, l, v, incv, tau, c, ldc, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarzb "BLAS_FUNC(zlarzb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, npy_complex128 *v, int *ldv, npy_complex128 *t, int *ldt, npy_complex128 *c, int *ldc, npy_complex128 *work, int *ldwork) nogil +cdef void zlarzb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, z *v, int *ldv, z *t, int *ldt, z *c, int *ldc, z *work, int *ldwork) noexcept nogil: + + _fortran_zlarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlarzt "BLAS_FUNC(zlarzt)"(char *direct, char *storev, int *n, int *k, npy_complex128 *v, int *ldv, npy_complex128 *tau, npy_complex128 *t, int *ldt) nogil +cdef void zlarzt(char *direct, char *storev, int *n, int *k, z *v, int *ldv, z *tau, z *t, int *ldt) noexcept nogil: + + _fortran_zlarzt(direct, storev, n, k, v, ldv, tau, t, ldt) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlascl "BLAS_FUNC(zlascl)"(char *type_bn, int *kl, int *ku, d *cfrom, d *cto, int *m, int *n, npy_complex128 *a, int *lda, int *info) nogil +cdef void zlascl(char *type_bn, int *kl, int *ku, d *cfrom, d *cto, int *m, int *n, z *a, int *lda, int *info) noexcept nogil: + + _fortran_zlascl(type_bn, kl, ku, cfrom, cto, m, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaset "BLAS_FUNC(zlaset)"(char *uplo, int *m, int *n, npy_complex128 *alpha, npy_complex128 *beta, npy_complex128 *a, int *lda) nogil +cdef void zlaset(char *uplo, int *m, int *n, z *alpha, z *beta, z *a, int *lda) noexcept nogil: + + _fortran_zlaset(uplo, m, n, alpha, beta, a, lda) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlasr "BLAS_FUNC(zlasr)"(char *side, char *pivot, char *direct, int *m, int *n, d *c, d *s, npy_complex128 *a, int *lda) nogil +cdef void zlasr(char *side, char *pivot, char *direct, int *m, int *n, d *c, d *s, z *a, int *lda) noexcept nogil: + + _fortran_zlasr(side, pivot, direct, m, n, c, s, a, lda) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlassq "BLAS_FUNC(zlassq)"(int *n, npy_complex128 *x, int *incx, d *scale, d *sumsq) nogil +cdef void zlassq(int *n, z *x, int *incx, d *scale, d *sumsq) noexcept nogil: + + _fortran_zlassq(n, x, incx, scale, sumsq) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlaswp "BLAS_FUNC(zlaswp)"(int *n, npy_complex128 *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) nogil +cdef void zlaswp(int *n, z *a, int *lda, int *k1, int *k2, int *ipiv, int *incx) noexcept nogil: + + _fortran_zlaswp(n, a, lda, k1, k2, ipiv, incx) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlasyf "BLAS_FUNC(zlasyf)"(char *uplo, int *n, int *nb, int *kb, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *w, int *ldw, int *info) nogil +cdef void zlasyf(char *uplo, int *n, int *nb, int *kb, z *a, int *lda, int *ipiv, z *w, int *ldw, int *info) noexcept nogil: + + _fortran_zlasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlat2c "BLAS_FUNC(zlat2c)"(char *uplo, int *n, npy_complex128 *a, int *lda, npy_complex64 *sa, int *ldsa, int *info) nogil +cdef void zlat2c(char *uplo, int *n, z *a, int *lda, c *sa, int *ldsa, int *info) noexcept nogil: + + _fortran_zlat2c(uplo, n, a, lda, sa, ldsa, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlatbs "BLAS_FUNC(zlatbs)"(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, npy_complex128 *ab, int *ldab, npy_complex128 *x, d *scale, d *cnorm, int *info) nogil +cdef void zlatbs(char *uplo, char *trans, char *diag, char *normin, int *n, int *kd, z *ab, int *ldab, z *x, d *scale, d *cnorm, int *info) noexcept nogil: + + _fortran_zlatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlatdf "BLAS_FUNC(zlatdf)"(int *ijob, int *n, npy_complex128 *z, int *ldz, npy_complex128 *rhs, d *rdsum, d *rdscal, int *ipiv, int *jpiv) nogil +cdef void zlatdf(int *ijob, int *n, z *z, int *ldz, z *rhs, d *rdsum, d *rdscal, int *ipiv, int *jpiv) noexcept nogil: + + _fortran_zlatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlatps "BLAS_FUNC(zlatps)"(char *uplo, char *trans, char *diag, char *normin, int *n, npy_complex128 *ap, npy_complex128 *x, d *scale, d *cnorm, int *info) nogil +cdef void zlatps(char *uplo, char *trans, char *diag, char *normin, int *n, z *ap, z *x, d *scale, d *cnorm, int *info) noexcept nogil: + + _fortran_zlatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlatrd "BLAS_FUNC(zlatrd)"(char *uplo, int *n, int *nb, npy_complex128 *a, int *lda, d *e, npy_complex128 *tau, npy_complex128 *w, int *ldw) nogil +cdef void zlatrd(char *uplo, int *n, int *nb, z *a, int *lda, d *e, z *tau, z *w, int *ldw) noexcept nogil: + + _fortran_zlatrd(uplo, n, nb, a, lda, e, tau, w, ldw) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlatrs "BLAS_FUNC(zlatrs)"(char *uplo, char *trans, char *diag, char *normin, int *n, npy_complex128 *a, int *lda, npy_complex128 *x, d *scale, d *cnorm, int *info) nogil +cdef void zlatrs(char *uplo, char *trans, char *diag, char *normin, int *n, z *a, int *lda, z *x, d *scale, d *cnorm, int *info) noexcept nogil: + + _fortran_zlatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlatrz "BLAS_FUNC(zlatrz)"(int *m, int *n, int *l, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work) nogil +cdef void zlatrz(int *m, int *n, int *l, z *a, int *lda, z *tau, z *work) noexcept nogil: + + _fortran_zlatrz(m, n, l, a, lda, tau, work) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlauu2 "BLAS_FUNC(zlauu2)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *info) nogil +cdef void zlauu2(char *uplo, int *n, z *a, int *lda, int *info) noexcept nogil: + + _fortran_zlauu2(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zlauum "BLAS_FUNC(zlauum)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *info) nogil +cdef void zlauum(char *uplo, int *n, z *a, int *lda, int *info) noexcept nogil: + + _fortran_zlauum(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpbcon "BLAS_FUNC(zpbcon)"(char *uplo, int *n, int *kd, npy_complex128 *ab, int *ldab, d *anorm, d *rcond, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zpbcon(char *uplo, int *n, int *kd, z *ab, int *ldab, d *anorm, d *rcond, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpbequ "BLAS_FUNC(zpbequ)"(char *uplo, int *n, int *kd, npy_complex128 *ab, int *ldab, d *s, d *scond, d *amax, int *info) nogil +cdef void zpbequ(char *uplo, int *n, int *kd, z *ab, int *ldab, d *s, d *scond, d *amax, int *info) noexcept nogil: + + _fortran_zpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpbrfs "BLAS_FUNC(zpbrfs)"(char *uplo, int *n, int *kd, int *nrhs, npy_complex128 *ab, int *ldab, npy_complex128 *afb, int *ldafb, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zpbrfs(char *uplo, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *afb, int *ldafb, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpbstf "BLAS_FUNC(zpbstf)"(char *uplo, int *n, int *kd, npy_complex128 *ab, int *ldab, int *info) nogil +cdef void zpbstf(char *uplo, int *n, int *kd, z *ab, int *ldab, int *info) noexcept nogil: + + _fortran_zpbstf(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpbsv "BLAS_FUNC(zpbsv)"(char *uplo, int *n, int *kd, int *nrhs, npy_complex128 *ab, int *ldab, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zpbsv(char *uplo, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpbsvx "BLAS_FUNC(zpbsvx)"(char *fact, char *uplo, int *n, int *kd, int *nrhs, npy_complex128 *ab, int *ldab, npy_complex128 *afb, int *ldafb, char *equed, d *s, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *rcond, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zpbsvx(char *fact, char *uplo, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *afb, int *ldafb, char *equed, d *s, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zpbsvx(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpbtf2 "BLAS_FUNC(zpbtf2)"(char *uplo, int *n, int *kd, npy_complex128 *ab, int *ldab, int *info) nogil +cdef void zpbtf2(char *uplo, int *n, int *kd, z *ab, int *ldab, int *info) noexcept nogil: + + _fortran_zpbtf2(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpbtrf "BLAS_FUNC(zpbtrf)"(char *uplo, int *n, int *kd, npy_complex128 *ab, int *ldab, int *info) nogil +cdef void zpbtrf(char *uplo, int *n, int *kd, z *ab, int *ldab, int *info) noexcept nogil: + + _fortran_zpbtrf(uplo, n, kd, ab, ldab, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpbtrs "BLAS_FUNC(zpbtrs)"(char *uplo, int *n, int *kd, int *nrhs, npy_complex128 *ab, int *ldab, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zpbtrs(char *uplo, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpftrf "BLAS_FUNC(zpftrf)"(char *transr, char *uplo, int *n, npy_complex128 *a, int *info) nogil +cdef void zpftrf(char *transr, char *uplo, int *n, z *a, int *info) noexcept nogil: + + _fortran_zpftrf(transr, uplo, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpftri "BLAS_FUNC(zpftri)"(char *transr, char *uplo, int *n, npy_complex128 *a, int *info) nogil +cdef void zpftri(char *transr, char *uplo, int *n, z *a, int *info) noexcept nogil: + + _fortran_zpftri(transr, uplo, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpftrs "BLAS_FUNC(zpftrs)"(char *transr, char *uplo, int *n, int *nrhs, npy_complex128 *a, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zpftrs(char *transr, char *uplo, int *n, int *nrhs, z *a, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zpftrs(transr, uplo, n, nrhs, a, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpocon "BLAS_FUNC(zpocon)"(char *uplo, int *n, npy_complex128 *a, int *lda, d *anorm, d *rcond, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zpocon(char *uplo, int *n, z *a, int *lda, d *anorm, d *rcond, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zpocon(uplo, n, a, lda, anorm, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpoequ "BLAS_FUNC(zpoequ)"(int *n, npy_complex128 *a, int *lda, d *s, d *scond, d *amax, int *info) nogil +cdef void zpoequ(int *n, z *a, int *lda, d *s, d *scond, d *amax, int *info) noexcept nogil: + + _fortran_zpoequ(n, a, lda, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpoequb "BLAS_FUNC(zpoequb)"(int *n, npy_complex128 *a, int *lda, d *s, d *scond, d *amax, int *info) nogil +cdef void zpoequb(int *n, z *a, int *lda, d *s, d *scond, d *amax, int *info) noexcept nogil: + + _fortran_zpoequb(n, a, lda, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zporfs "BLAS_FUNC(zporfs)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *af, int *ldaf, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zporfs(char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zposv "BLAS_FUNC(zposv)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zposv(char *uplo, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zposv(uplo, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zposvx "BLAS_FUNC(zposvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *af, int *ldaf, char *equed, d *s, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *rcond, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zposvx(char *fact, char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, char *equed, d *s, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zposvx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpotf2 "BLAS_FUNC(zpotf2)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *info) nogil +cdef void zpotf2(char *uplo, int *n, z *a, int *lda, int *info) noexcept nogil: + + _fortran_zpotf2(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpotrf "BLAS_FUNC(zpotrf)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *info) nogil +cdef void zpotrf(char *uplo, int *n, z *a, int *lda, int *info) noexcept nogil: + + _fortran_zpotrf(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpotri "BLAS_FUNC(zpotri)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *info) nogil +cdef void zpotri(char *uplo, int *n, z *a, int *lda, int *info) noexcept nogil: + + _fortran_zpotri(uplo, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpotrs "BLAS_FUNC(zpotrs)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zpotrs(char *uplo, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zpotrs(uplo, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zppcon "BLAS_FUNC(zppcon)"(char *uplo, int *n, npy_complex128 *ap, d *anorm, d *rcond, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zppcon(char *uplo, int *n, z *ap, d *anorm, d *rcond, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zppcon(uplo, n, ap, anorm, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zppequ "BLAS_FUNC(zppequ)"(char *uplo, int *n, npy_complex128 *ap, d *s, d *scond, d *amax, int *info) nogil +cdef void zppequ(char *uplo, int *n, z *ap, d *s, d *scond, d *amax, int *info) noexcept nogil: + + _fortran_zppequ(uplo, n, ap, s, scond, amax, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpprfs "BLAS_FUNC(zpprfs)"(char *uplo, int *n, int *nrhs, npy_complex128 *ap, npy_complex128 *afp, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zpprfs(char *uplo, int *n, int *nrhs, z *ap, z *afp, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zppsv "BLAS_FUNC(zppsv)"(char *uplo, int *n, int *nrhs, npy_complex128 *ap, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zppsv(char *uplo, int *n, int *nrhs, z *ap, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zppsv(uplo, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zppsvx "BLAS_FUNC(zppsvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex128 *ap, npy_complex128 *afp, char *equed, d *s, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *rcond, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zppsvx(char *fact, char *uplo, int *n, int *nrhs, z *ap, z *afp, char *equed, d *s, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zppsvx(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpptrf "BLAS_FUNC(zpptrf)"(char *uplo, int *n, npy_complex128 *ap, int *info) nogil +cdef void zpptrf(char *uplo, int *n, z *ap, int *info) noexcept nogil: + + _fortran_zpptrf(uplo, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpptri "BLAS_FUNC(zpptri)"(char *uplo, int *n, npy_complex128 *ap, int *info) nogil +cdef void zpptri(char *uplo, int *n, z *ap, int *info) noexcept nogil: + + _fortran_zpptri(uplo, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpptrs "BLAS_FUNC(zpptrs)"(char *uplo, int *n, int *nrhs, npy_complex128 *ap, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zpptrs(char *uplo, int *n, int *nrhs, z *ap, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zpptrs(uplo, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpstf2 "BLAS_FUNC(zpstf2)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) nogil +cdef void zpstf2(char *uplo, int *n, z *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) noexcept nogil: + + _fortran_zpstf2(uplo, n, a, lda, piv, rank, tol, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpstrf "BLAS_FUNC(zpstrf)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) nogil +cdef void zpstrf(char *uplo, int *n, z *a, int *lda, int *piv, int *rank, d *tol, d *work, int *info) noexcept nogil: + + _fortran_zpstrf(uplo, n, a, lda, piv, rank, tol, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zptcon "BLAS_FUNC(zptcon)"(int *n, d *d, npy_complex128 *e, d *anorm, d *rcond, d *rwork, int *info) nogil +cdef void zptcon(int *n, d *d, z *e, d *anorm, d *rcond, d *rwork, int *info) noexcept nogil: + + _fortran_zptcon(n, d, e, anorm, rcond, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpteqr "BLAS_FUNC(zpteqr)"(char *compz, int *n, d *d, d *e, npy_complex128 *z, int *ldz, d *work, int *info) nogil +cdef void zpteqr(char *compz, int *n, d *d, d *e, z *z, int *ldz, d *work, int *info) noexcept nogil: + + _fortran_zpteqr(compz, n, d, e, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zptrfs "BLAS_FUNC(zptrfs)"(char *uplo, int *n, int *nrhs, d *d, npy_complex128 *e, d *df, npy_complex128 *ef, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zptrfs(char *uplo, int *n, int *nrhs, d *d, z *e, d *df, z *ef, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zptrfs(uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zptsv "BLAS_FUNC(zptsv)"(int *n, int *nrhs, d *d, npy_complex128 *e, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zptsv(int *n, int *nrhs, d *d, z *e, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zptsv(n, nrhs, d, e, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zptsvx "BLAS_FUNC(zptsvx)"(char *fact, int *n, int *nrhs, d *d, npy_complex128 *e, d *df, npy_complex128 *ef, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *rcond, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zptsvx(char *fact, int *n, int *nrhs, d *d, z *e, d *df, z *ef, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zptsvx(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpttrf "BLAS_FUNC(zpttrf)"(int *n, d *d, npy_complex128 *e, int *info) nogil +cdef void zpttrf(int *n, d *d, z *e, int *info) noexcept nogil: + + _fortran_zpttrf(n, d, e, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zpttrs "BLAS_FUNC(zpttrs)"(char *uplo, int *n, int *nrhs, d *d, npy_complex128 *e, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zpttrs(char *uplo, int *n, int *nrhs, d *d, z *e, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zpttrs(uplo, n, nrhs, d, e, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zptts2 "BLAS_FUNC(zptts2)"(int *iuplo, int *n, int *nrhs, d *d, npy_complex128 *e, npy_complex128 *b, int *ldb) nogil +cdef void zptts2(int *iuplo, int *n, int *nrhs, d *d, z *e, z *b, int *ldb) noexcept nogil: + + _fortran_zptts2(iuplo, n, nrhs, d, e, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zrot "BLAS_FUNC(zrot)"(int *n, npy_complex128 *cx, int *incx, npy_complex128 *cy, int *incy, d *c, npy_complex128 *s) nogil +cdef void zrot(int *n, z *cx, int *incx, z *cy, int *incy, d *c, z *s) noexcept nogil: + + _fortran_zrot(n, cx, incx, cy, incy, c, s) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zspcon "BLAS_FUNC(zspcon)"(char *uplo, int *n, npy_complex128 *ap, int *ipiv, d *anorm, d *rcond, npy_complex128 *work, int *info) nogil +cdef void zspcon(char *uplo, int *n, z *ap, int *ipiv, d *anorm, d *rcond, z *work, int *info) noexcept nogil: + + _fortran_zspcon(uplo, n, ap, ipiv, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zspmv "BLAS_FUNC(zspmv)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *ap, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil +cdef void zspmv(char *uplo, int *n, z *alpha, z *ap, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil: + + _fortran_zspmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zspr "BLAS_FUNC(zspr)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *ap) nogil +cdef void zspr(char *uplo, int *n, z *alpha, z *x, int *incx, z *ap) noexcept nogil: + + _fortran_zspr(uplo, n, alpha, x, incx, ap) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsprfs "BLAS_FUNC(zsprfs)"(char *uplo, int *n, int *nrhs, npy_complex128 *ap, npy_complex128 *afp, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zsprfs(char *uplo, int *n, int *nrhs, z *ap, z *afp, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zsprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zspsv "BLAS_FUNC(zspsv)"(char *uplo, int *n, int *nrhs, npy_complex128 *ap, int *ipiv, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zspsv(char *uplo, int *n, int *nrhs, z *ap, int *ipiv, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zspsvx "BLAS_FUNC(zspsvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex128 *ap, npy_complex128 *afp, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *rcond, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zspsvx(char *fact, char *uplo, int *n, int *nrhs, z *ap, z *afp, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zspsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsptrf "BLAS_FUNC(zsptrf)"(char *uplo, int *n, npy_complex128 *ap, int *ipiv, int *info) nogil +cdef void zsptrf(char *uplo, int *n, z *ap, int *ipiv, int *info) noexcept nogil: + + _fortran_zsptrf(uplo, n, ap, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsptri "BLAS_FUNC(zsptri)"(char *uplo, int *n, npy_complex128 *ap, int *ipiv, npy_complex128 *work, int *info) nogil +cdef void zsptri(char *uplo, int *n, z *ap, int *ipiv, z *work, int *info) noexcept nogil: + + _fortran_zsptri(uplo, n, ap, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsptrs "BLAS_FUNC(zsptrs)"(char *uplo, int *n, int *nrhs, npy_complex128 *ap, int *ipiv, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zsptrs(char *uplo, int *n, int *nrhs, z *ap, int *ipiv, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zsptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zstedc "BLAS_FUNC(zstedc)"(char *compz, int *n, d *d, d *e, npy_complex128 *z, int *ldz, npy_complex128 *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) nogil +cdef void zstedc(char *compz, int *n, d *d, d *e, z *z, int *ldz, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_zstedc(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zstegr "BLAS_FUNC(zstegr)"(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, npy_complex128 *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void zstegr(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, d *abstol, int *m, d *w, z *z, int *ldz, int *isuppz, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_zstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zstein "BLAS_FUNC(zstein)"(int *n, d *d, d *e, int *m, d *w, int *iblock, int *isplit, npy_complex128 *z, int *ldz, d *work, int *iwork, int *ifail, int *info) nogil +cdef void zstein(int *n, d *d, d *e, int *m, d *w, int *iblock, int *isplit, z *z, int *ldz, d *work, int *iwork, int *ifail, int *info) noexcept nogil: + + _fortran_zstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zstemr "BLAS_FUNC(zstemr)"(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, int *m, d *w, npy_complex128 *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, d *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void zstemr(char *jobz, char *range, int *n, d *d, d *e, d *vl, d *vu, int *il, int *iu, int *m, d *w, z *z, int *ldz, int *nzc, int *isuppz, bint *tryrac, d *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_zstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsteqr "BLAS_FUNC(zsteqr)"(char *compz, int *n, d *d, d *e, npy_complex128 *z, int *ldz, d *work, int *info) nogil +cdef void zsteqr(char *compz, int *n, d *d, d *e, z *z, int *ldz, d *work, int *info) noexcept nogil: + + _fortran_zsteqr(compz, n, d, e, z, ldz, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsycon "BLAS_FUNC(zsycon)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, d *anorm, d *rcond, npy_complex128 *work, int *info) nogil +cdef void zsycon(char *uplo, int *n, z *a, int *lda, int *ipiv, d *anorm, d *rcond, z *work, int *info) noexcept nogil: + + _fortran_zsycon(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsyconv "BLAS_FUNC(zsyconv)"(char *uplo, char *way, int *n, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *work, int *info) nogil +cdef void zsyconv(char *uplo, char *way, int *n, z *a, int *lda, int *ipiv, z *work, int *info) noexcept nogil: + + _fortran_zsyconv(uplo, way, n, a, lda, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsyequb "BLAS_FUNC(zsyequb)"(char *uplo, int *n, npy_complex128 *a, int *lda, d *s, d *scond, d *amax, npy_complex128 *work, int *info) nogil +cdef void zsyequb(char *uplo, int *n, z *a, int *lda, d *s, d *scond, d *amax, z *work, int *info) noexcept nogil: + + _fortran_zsyequb(uplo, n, a, lda, s, scond, amax, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsymv "BLAS_FUNC(zsymv)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *a, int *lda, npy_complex128 *x, int *incx, npy_complex128 *beta, npy_complex128 *y, int *incy) nogil +cdef void zsymv(char *uplo, int *n, z *alpha, z *a, int *lda, z *x, int *incx, z *beta, z *y, int *incy) noexcept nogil: + + _fortran_zsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsyr "BLAS_FUNC(zsyr)"(char *uplo, int *n, npy_complex128 *alpha, npy_complex128 *x, int *incx, npy_complex128 *a, int *lda) nogil +cdef void zsyr(char *uplo, int *n, z *alpha, z *x, int *incx, z *a, int *lda) noexcept nogil: + + _fortran_zsyr(uplo, n, alpha, x, incx, a, lda) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsyrfs "BLAS_FUNC(zsyrfs)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *af, int *ldaf, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void zsyrfs(char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_zsyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsysv "BLAS_FUNC(zsysv)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zsysv(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zsysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsysvx "BLAS_FUNC(zsysvx)"(char *fact, char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *af, int *ldaf, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *rcond, d *ferr, d *berr, npy_complex128 *work, int *lwork, d *rwork, int *info) nogil +cdef void zsysvx(char *fact, char *uplo, int *n, int *nrhs, z *a, int *lda, z *af, int *ldaf, int *ipiv, z *b, int *ldb, z *x, int *ldx, d *rcond, d *ferr, d *berr, z *work, int *lwork, d *rwork, int *info) noexcept nogil: + + _fortran_zsysvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsyswapr "BLAS_FUNC(zsyswapr)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *i1, int *i2) nogil +cdef void zsyswapr(char *uplo, int *n, z *a, int *lda, int *i1, int *i2) noexcept nogil: + + _fortran_zsyswapr(uplo, n, a, lda, i1, i2) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsytf2 "BLAS_FUNC(zsytf2)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, int *info) nogil +cdef void zsytf2(char *uplo, int *n, z *a, int *lda, int *ipiv, int *info) noexcept nogil: + + _fortran_zsytf2(uplo, n, a, lda, ipiv, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsytrf "BLAS_FUNC(zsytrf)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zsytrf(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zsytrf(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsytri "BLAS_FUNC(zsytri)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *work, int *info) nogil +cdef void zsytri(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *info) noexcept nogil: + + _fortran_zsytri(uplo, n, a, lda, ipiv, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsytri2 "BLAS_FUNC(zsytri2)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zsytri2(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zsytri2(uplo, n, a, lda, ipiv, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsytri2x "BLAS_FUNC(zsytri2x)"(char *uplo, int *n, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *work, int *nb, int *info) nogil +cdef void zsytri2x(char *uplo, int *n, z *a, int *lda, int *ipiv, z *work, int *nb, int *info) noexcept nogil: + + _fortran_zsytri2x(uplo, n, a, lda, ipiv, work, nb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsytrs "BLAS_FUNC(zsytrs)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *b, int *ldb, int *info) nogil +cdef void zsytrs(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_zsytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zsytrs2 "BLAS_FUNC(zsytrs2)"(char *uplo, int *n, int *nrhs, npy_complex128 *a, int *lda, int *ipiv, npy_complex128 *b, int *ldb, npy_complex128 *work, int *info) nogil +cdef void zsytrs2(char *uplo, int *n, int *nrhs, z *a, int *lda, int *ipiv, z *b, int *ldb, z *work, int *info) noexcept nogil: + + _fortran_zsytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztbcon "BLAS_FUNC(ztbcon)"(char *norm, char *uplo, char *diag, int *n, int *kd, npy_complex128 *ab, int *ldab, d *rcond, npy_complex128 *work, d *rwork, int *info) nogil +cdef void ztbcon(char *norm, char *uplo, char *diag, int *n, int *kd, z *ab, int *ldab, d *rcond, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_ztbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztbrfs "BLAS_FUNC(ztbrfs)"(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, npy_complex128 *ab, int *ldab, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void ztbrfs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_ztbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztbtrs "BLAS_FUNC(ztbtrs)"(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, npy_complex128 *ab, int *ldab, npy_complex128 *b, int *ldb, int *info) nogil +cdef void ztbtrs(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, z *ab, int *ldab, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_ztbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztfsm "BLAS_FUNC(ztfsm)"(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, npy_complex128 *alpha, npy_complex128 *a, npy_complex128 *b, int *ldb) nogil +cdef void ztfsm(char *transr, char *side, char *uplo, char *trans, char *diag, int *m, int *n, z *alpha, z *a, z *b, int *ldb) noexcept nogil: + + _fortran_ztfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztftri "BLAS_FUNC(ztftri)"(char *transr, char *uplo, char *diag, int *n, npy_complex128 *a, int *info) nogil +cdef void ztftri(char *transr, char *uplo, char *diag, int *n, z *a, int *info) noexcept nogil: + + _fortran_ztftri(transr, uplo, diag, n, a, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztfttp "BLAS_FUNC(ztfttp)"(char *transr, char *uplo, int *n, npy_complex128 *arf, npy_complex128 *ap, int *info) nogil +cdef void ztfttp(char *transr, char *uplo, int *n, z *arf, z *ap, int *info) noexcept nogil: + + _fortran_ztfttp(transr, uplo, n, arf, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztfttr "BLAS_FUNC(ztfttr)"(char *transr, char *uplo, int *n, npy_complex128 *arf, npy_complex128 *a, int *lda, int *info) nogil +cdef void ztfttr(char *transr, char *uplo, int *n, z *arf, z *a, int *lda, int *info) noexcept nogil: + + _fortran_ztfttr(transr, uplo, n, arf, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztgevc "BLAS_FUNC(ztgevc)"(char *side, char *howmny, bint *select, int *n, npy_complex128 *s, int *lds, npy_complex128 *p, int *ldp, npy_complex128 *vl, int *ldvl, npy_complex128 *vr, int *ldvr, int *mm, int *m, npy_complex128 *work, d *rwork, int *info) nogil +cdef void ztgevc(char *side, char *howmny, bint *select, int *n, z *s, int *lds, z *p, int *ldp, z *vl, int *ldvl, z *vr, int *ldvr, int *mm, int *m, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_ztgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztgex2 "BLAS_FUNC(ztgex2)"(bint *wantq, bint *wantz, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *q, int *ldq, npy_complex128 *z, int *ldz, int *j1, int *info) nogil +cdef void ztgex2(bint *wantq, bint *wantz, int *n, z *a, int *lda, z *b, int *ldb, z *q, int *ldq, z *z, int *ldz, int *j1, int *info) noexcept nogil: + + _fortran_ztgex2(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztgexc "BLAS_FUNC(ztgexc)"(bint *wantq, bint *wantz, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *q, int *ldq, npy_complex128 *z, int *ldz, int *ifst, int *ilst, int *info) nogil +cdef void ztgexc(bint *wantq, bint *wantz, int *n, z *a, int *lda, z *b, int *ldb, z *q, int *ldq, z *z, int *ldz, int *ifst, int *ilst, int *info) noexcept nogil: + + _fortran_ztgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztgsen "BLAS_FUNC(ztgsen)"(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *alpha, npy_complex128 *beta, npy_complex128 *q, int *ldq, npy_complex128 *z, int *ldz, int *m, d *pl, d *pr, d *dif, npy_complex128 *work, int *lwork, int *iwork, int *liwork, int *info) nogil +cdef void ztgsen(int *ijob, bint *wantq, bint *wantz, bint *select, int *n, z *a, int *lda, z *b, int *ldb, z *alpha, z *beta, z *q, int *ldq, z *z, int *ldz, int *m, d *pl, d *pr, d *dif, z *work, int *lwork, int *iwork, int *liwork, int *info) noexcept nogil: + + _fortran_ztgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztgsja "BLAS_FUNC(ztgsja)"(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, d *tola, d *tolb, d *alpha, d *beta, npy_complex128 *u, int *ldu, npy_complex128 *v, int *ldv, npy_complex128 *q, int *ldq, npy_complex128 *work, int *ncycle, int *info) nogil +cdef void ztgsja(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, z *a, int *lda, z *b, int *ldb, d *tola, d *tolb, d *alpha, d *beta, z *u, int *ldu, z *v, int *ldv, z *q, int *ldq, z *work, int *ncycle, int *info) noexcept nogil: + + _fortran_ztgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, ldu, v, ldv, q, ldq, work, ncycle, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztgsna "BLAS_FUNC(ztgsna)"(char *job, char *howmny, bint *select, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *vl, int *ldvl, npy_complex128 *vr, int *ldvr, d *s, d *dif, int *mm, int *m, npy_complex128 *work, int *lwork, int *iwork, int *info) nogil +cdef void ztgsna(char *job, char *howmny, bint *select, int *n, z *a, int *lda, z *b, int *ldb, z *vl, int *ldvl, z *vr, int *ldvr, d *s, d *dif, int *mm, int *m, z *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_ztgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztgsy2 "BLAS_FUNC(ztgsy2)"(char *trans, int *ijob, int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *c, int *ldc, npy_complex128 *d, int *ldd, npy_complex128 *e, int *lde, npy_complex128 *f, int *ldf, d *scale, d *rdsum, d *rdscal, int *info) nogil +cdef void ztgsy2(char *trans, int *ijob, int *m, int *n, z *a, int *lda, z *b, int *ldb, z *c, int *ldc, z *d, int *ldd, z *e, int *lde, z *f, int *ldf, d *scale, d *rdsum, d *rdscal, int *info) noexcept nogil: + + _fortran_ztgsy2(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztgsyl "BLAS_FUNC(ztgsyl)"(char *trans, int *ijob, int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *c, int *ldc, npy_complex128 *d, int *ldd, npy_complex128 *e, int *lde, npy_complex128 *f, int *ldf, d *scale, d *dif, npy_complex128 *work, int *lwork, int *iwork, int *info) nogil +cdef void ztgsyl(char *trans, int *ijob, int *m, int *n, z *a, int *lda, z *b, int *ldb, z *c, int *ldc, z *d, int *ldd, z *e, int *lde, z *f, int *ldf, d *scale, d *dif, z *work, int *lwork, int *iwork, int *info) noexcept nogil: + + _fortran_ztgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztpcon "BLAS_FUNC(ztpcon)"(char *norm, char *uplo, char *diag, int *n, npy_complex128 *ap, d *rcond, npy_complex128 *work, d *rwork, int *info) nogil +cdef void ztpcon(char *norm, char *uplo, char *diag, int *n, z *ap, d *rcond, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_ztpcon(norm, uplo, diag, n, ap, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztpmqrt "BLAS_FUNC(ztpmqrt)"(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, npy_complex128 *v, int *ldv, npy_complex128 *t, int *ldt, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *work, int *info) nogil +cdef void ztpmqrt(char *side, char *trans, int *m, int *n, int *k, int *l, int *nb, z *v, int *ldv, z *t, int *ldt, z *a, int *lda, z *b, int *ldb, z *work, int *info) noexcept nogil: + + _fortran_ztpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztpqrt "BLAS_FUNC(ztpqrt)"(int *m, int *n, int *l, int *nb, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *t, int *ldt, npy_complex128 *work, int *info) nogil +cdef void ztpqrt(int *m, int *n, int *l, int *nb, z *a, int *lda, z *b, int *ldb, z *t, int *ldt, z *work, int *info) noexcept nogil: + + _fortran_ztpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztpqrt2 "BLAS_FUNC(ztpqrt2)"(int *m, int *n, int *l, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *t, int *ldt, int *info) nogil +cdef void ztpqrt2(int *m, int *n, int *l, z *a, int *lda, z *b, int *ldb, z *t, int *ldt, int *info) noexcept nogil: + + _fortran_ztpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztprfb "BLAS_FUNC(ztprfb)"(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, npy_complex128 *v, int *ldv, npy_complex128 *t, int *ldt, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *work, int *ldwork) nogil +cdef void ztprfb(char *side, char *trans, char *direct, char *storev, int *m, int *n, int *k, int *l, z *v, int *ldv, z *t, int *ldt, z *a, int *lda, z *b, int *ldb, z *work, int *ldwork) noexcept nogil: + + _fortran_ztprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztprfs "BLAS_FUNC(ztprfs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, npy_complex128 *ap, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void ztprfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, z *ap, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_ztprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztptri "BLAS_FUNC(ztptri)"(char *uplo, char *diag, int *n, npy_complex128 *ap, int *info) nogil +cdef void ztptri(char *uplo, char *diag, int *n, z *ap, int *info) noexcept nogil: + + _fortran_ztptri(uplo, diag, n, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztptrs "BLAS_FUNC(ztptrs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, npy_complex128 *ap, npy_complex128 *b, int *ldb, int *info) nogil +cdef void ztptrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, z *ap, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_ztptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztpttf "BLAS_FUNC(ztpttf)"(char *transr, char *uplo, int *n, npy_complex128 *ap, npy_complex128 *arf, int *info) nogil +cdef void ztpttf(char *transr, char *uplo, int *n, z *ap, z *arf, int *info) noexcept nogil: + + _fortran_ztpttf(transr, uplo, n, ap, arf, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztpttr "BLAS_FUNC(ztpttr)"(char *uplo, int *n, npy_complex128 *ap, npy_complex128 *a, int *lda, int *info) nogil +cdef void ztpttr(char *uplo, int *n, z *ap, z *a, int *lda, int *info) noexcept nogil: + + _fortran_ztpttr(uplo, n, ap, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrcon "BLAS_FUNC(ztrcon)"(char *norm, char *uplo, char *diag, int *n, npy_complex128 *a, int *lda, d *rcond, npy_complex128 *work, d *rwork, int *info) nogil +cdef void ztrcon(char *norm, char *uplo, char *diag, int *n, z *a, int *lda, d *rcond, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_ztrcon(norm, uplo, diag, n, a, lda, rcond, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrevc "BLAS_FUNC(ztrevc)"(char *side, char *howmny, bint *select, int *n, npy_complex128 *t, int *ldt, npy_complex128 *vl, int *ldvl, npy_complex128 *vr, int *ldvr, int *mm, int *m, npy_complex128 *work, d *rwork, int *info) nogil +cdef void ztrevc(char *side, char *howmny, bint *select, int *n, z *t, int *ldt, z *vl, int *ldvl, z *vr, int *ldvr, int *mm, int *m, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_ztrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrexc "BLAS_FUNC(ztrexc)"(char *compq, int *n, npy_complex128 *t, int *ldt, npy_complex128 *q, int *ldq, int *ifst, int *ilst, int *info) nogil +cdef void ztrexc(char *compq, int *n, z *t, int *ldt, z *q, int *ldq, int *ifst, int *ilst, int *info) noexcept nogil: + + _fortran_ztrexc(compq, n, t, ldt, q, ldq, ifst, ilst, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrrfs "BLAS_FUNC(ztrrfs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *x, int *ldx, d *ferr, d *berr, npy_complex128 *work, d *rwork, int *info) nogil +cdef void ztrrfs(char *uplo, char *trans, char *diag, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, z *x, int *ldx, d *ferr, d *berr, z *work, d *rwork, int *info) noexcept nogil: + + _fortran_ztrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrsen "BLAS_FUNC(ztrsen)"(char *job, char *compq, bint *select, int *n, npy_complex128 *t, int *ldt, npy_complex128 *q, int *ldq, npy_complex128 *w, int *m, d *s, d *sep, npy_complex128 *work, int *lwork, int *info) nogil +cdef void ztrsen(char *job, char *compq, bint *select, int *n, z *t, int *ldt, z *q, int *ldq, z *w, int *m, d *s, d *sep, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_ztrsen(job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrsna "BLAS_FUNC(ztrsna)"(char *job, char *howmny, bint *select, int *n, npy_complex128 *t, int *ldt, npy_complex128 *vl, int *ldvl, npy_complex128 *vr, int *ldvr, d *s, d *sep, int *mm, int *m, npy_complex128 *work, int *ldwork, d *rwork, int *info) nogil +cdef void ztrsna(char *job, char *howmny, bint *select, int *n, z *t, int *ldt, z *vl, int *ldvl, z *vr, int *ldvr, d *s, d *sep, int *mm, int *m, z *work, int *ldwork, d *rwork, int *info) noexcept nogil: + + _fortran_ztrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrsyl "BLAS_FUNC(ztrsyl)"(char *trana, char *tranb, int *isgn, int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, npy_complex128 *c, int *ldc, d *scale, int *info) nogil +cdef void ztrsyl(char *trana, char *tranb, int *isgn, int *m, int *n, z *a, int *lda, z *b, int *ldb, z *c, int *ldc, d *scale, int *info) noexcept nogil: + + _fortran_ztrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrti2 "BLAS_FUNC(ztrti2)"(char *uplo, char *diag, int *n, npy_complex128 *a, int *lda, int *info) nogil +cdef void ztrti2(char *uplo, char *diag, int *n, z *a, int *lda, int *info) noexcept nogil: + + _fortran_ztrti2(uplo, diag, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrtri "BLAS_FUNC(ztrtri)"(char *uplo, char *diag, int *n, npy_complex128 *a, int *lda, int *info) nogil +cdef void ztrtri(char *uplo, char *diag, int *n, z *a, int *lda, int *info) noexcept nogil: + + _fortran_ztrtri(uplo, diag, n, a, lda, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrtrs "BLAS_FUNC(ztrtrs)"(char *uplo, char *trans, char *diag, int *n, int *nrhs, npy_complex128 *a, int *lda, npy_complex128 *b, int *ldb, int *info) nogil +cdef void ztrtrs(char *uplo, char *trans, char *diag, int *n, int *nrhs, z *a, int *lda, z *b, int *ldb, int *info) noexcept nogil: + + _fortran_ztrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrttf "BLAS_FUNC(ztrttf)"(char *transr, char *uplo, int *n, npy_complex128 *a, int *lda, npy_complex128 *arf, int *info) nogil +cdef void ztrttf(char *transr, char *uplo, int *n, z *a, int *lda, z *arf, int *info) noexcept nogil: + + _fortran_ztrttf(transr, uplo, n, a, lda, arf, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztrttp "BLAS_FUNC(ztrttp)"(char *uplo, int *n, npy_complex128 *a, int *lda, npy_complex128 *ap, int *info) nogil +cdef void ztrttp(char *uplo, int *n, z *a, int *lda, z *ap, int *info) noexcept nogil: + + _fortran_ztrttp(uplo, n, a, lda, ap, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_ztzrzf "BLAS_FUNC(ztzrzf)"(int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void ztzrzf(int *m, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_ztzrzf(m, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunbdb "BLAS_FUNC(zunbdb)"(char *trans, char *signs, int *m, int *p, int *q, npy_complex128 *x11, int *ldx11, npy_complex128 *x12, int *ldx12, npy_complex128 *x21, int *ldx21, npy_complex128 *x22, int *ldx22, d *theta, d *phi, npy_complex128 *taup1, npy_complex128 *taup2, npy_complex128 *tauq1, npy_complex128 *tauq2, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zunbdb(char *trans, char *signs, int *m, int *p, int *q, z *x11, int *ldx11, z *x12, int *ldx12, z *x21, int *ldx21, z *x22, int *ldx22, d *theta, d *phi, z *taup1, z *taup2, z *tauq1, z *tauq2, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zunbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zuncsd "BLAS_FUNC(zuncsd)"(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, npy_complex128 *x11, int *ldx11, npy_complex128 *x12, int *ldx12, npy_complex128 *x21, int *ldx21, npy_complex128 *x22, int *ldx22, d *theta, npy_complex128 *u1, int *ldu1, npy_complex128 *u2, int *ldu2, npy_complex128 *v1t, int *ldv1t, npy_complex128 *v2t, int *ldv2t, npy_complex128 *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *info) nogil +cdef void zuncsd(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, int *m, int *p, int *q, z *x11, int *ldx11, z *x12, int *ldx12, z *x21, int *ldx21, z *x22, int *ldx22, d *theta, z *u1, int *ldu1, z *u2, int *ldu2, z *v1t, int *ldv1t, z *v2t, int *ldv2t, z *work, int *lwork, d *rwork, int *lrwork, int *iwork, int *info) noexcept nogil: + + _fortran_zuncsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, work, lwork, rwork, lrwork, iwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zung2l "BLAS_FUNC(zung2l)"(int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *info) nogil +cdef void zung2l(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil: + + _fortran_zung2l(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zung2r "BLAS_FUNC(zung2r)"(int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *info) nogil +cdef void zung2r(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil: + + _fortran_zung2r(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zungbr "BLAS_FUNC(zungbr)"(char *vect, int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zungbr(char *vect, int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zungbr(vect, m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunghr "BLAS_FUNC(zunghr)"(int *n, int *ilo, int *ihi, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zunghr(int *n, int *ilo, int *ihi, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zunghr(n, ilo, ihi, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zungl2 "BLAS_FUNC(zungl2)"(int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *info) nogil +cdef void zungl2(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil: + + _fortran_zungl2(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunglq "BLAS_FUNC(zunglq)"(int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zunglq(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zunglq(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zungql "BLAS_FUNC(zungql)"(int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zungql(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zungql(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zungqr "BLAS_FUNC(zungqr)"(int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zungqr(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zungqr(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zungr2 "BLAS_FUNC(zungr2)"(int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *info) nogil +cdef void zungr2(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *info) noexcept nogil: + + _fortran_zungr2(m, n, k, a, lda, tau, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zungrq "BLAS_FUNC(zungrq)"(int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zungrq(int *m, int *n, int *k, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zungrq(m, n, k, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zungtr "BLAS_FUNC(zungtr)"(char *uplo, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zungtr(char *uplo, int *n, z *a, int *lda, z *tau, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zungtr(uplo, n, a, lda, tau, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunm2l "BLAS_FUNC(zunm2l)"(char *side, char *trans, int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *info) nogil +cdef void zunm2l(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil: + + _fortran_zunm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunm2r "BLAS_FUNC(zunm2r)"(char *side, char *trans, int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *info) nogil +cdef void zunm2r(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil: + + _fortran_zunm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunmbr "BLAS_FUNC(zunmbr)"(char *vect, char *side, char *trans, int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zunmbr(char *vect, char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zunmbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunmhr "BLAS_FUNC(zunmhr)"(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zunmhr(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zunmhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunml2 "BLAS_FUNC(zunml2)"(char *side, char *trans, int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *info) nogil +cdef void zunml2(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil: + + _fortran_zunml2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunmlq "BLAS_FUNC(zunmlq)"(char *side, char *trans, int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zunmlq(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zunmlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunmql "BLAS_FUNC(zunmql)"(char *side, char *trans, int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zunmql(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zunmql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunmqr "BLAS_FUNC(zunmqr)"(char *side, char *trans, int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zunmqr(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zunmqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunmr2 "BLAS_FUNC(zunmr2)"(char *side, char *trans, int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *info) nogil +cdef void zunmr2(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil: + + _fortran_zunmr2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunmr3 "BLAS_FUNC(zunmr3)"(char *side, char *trans, int *m, int *n, int *k, int *l, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *info) nogil +cdef void zunmr3(char *side, char *trans, int *m, int *n, int *k, int *l, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil: + + _fortran_zunmr3(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunmrq "BLAS_FUNC(zunmrq)"(char *side, char *trans, int *m, int *n, int *k, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zunmrq(char *side, char *trans, int *m, int *n, int *k, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zunmrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunmrz "BLAS_FUNC(zunmrz)"(char *side, char *trans, int *m, int *n, int *k, int *l, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zunmrz(char *side, char *trans, int *m, int *n, int *k, int *l, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zunmrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zunmtr "BLAS_FUNC(zunmtr)"(char *side, char *uplo, char *trans, int *m, int *n, npy_complex128 *a, int *lda, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *lwork, int *info) nogil +cdef void zunmtr(char *side, char *uplo, char *trans, int *m, int *n, z *a, int *lda, z *tau, z *c, int *ldc, z *work, int *lwork, int *info) noexcept nogil: + + _fortran_zunmtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zupgtr "BLAS_FUNC(zupgtr)"(char *uplo, int *n, npy_complex128 *ap, npy_complex128 *tau, npy_complex128 *q, int *ldq, npy_complex128 *work, int *info) nogil +cdef void zupgtr(char *uplo, int *n, z *ap, z *tau, z *q, int *ldq, z *work, int *info) noexcept nogil: + + _fortran_zupgtr(uplo, n, ap, tau, q, ldq, work, info) + + +cdef extern from "_lapack_subroutines.h": + void _fortran_zupmtr "BLAS_FUNC(zupmtr)"(char *side, char *uplo, char *trans, int *m, int *n, npy_complex128 *ap, npy_complex128 *tau, npy_complex128 *c, int *ldc, npy_complex128 *work, int *info) nogil +cdef void zupmtr(char *side, char *uplo, char *trans, int *m, int *n, z *ap, z *tau, z *c, int *ldc, z *work, int *info) noexcept nogil: + + _fortran_zupmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info) + + + +# Python accessible wrappers for testing: + +def _test_dlamch(cmach): + # This conversion is necessary to handle Python 3 strings. + cmach_bytes = bytes(cmach) + # Now that it is a bytes representation, a non-temporary variable + # must be passed as a part of the function call. + cdef char* cmach_char = cmach_bytes + return dlamch(cmach_char) + +def _test_slamch(cmach): + # This conversion is necessary to handle Python 3 strings. + cmach_bytes = bytes(cmach) + # Now that it is a bytes representation, a non-temporary variable + # must be passed as a part of the function call. + cdef char* cmach_char = cmach_bytes + return slamch(cmach_char) + +cpdef double complex _test_zladiv(double complex zx, double complex zy) noexcept nogil: + return zladiv(&zx, &zy) + +cpdef float complex _test_cladiv(float complex cx, float complex cy) noexcept nogil: + return cladiv(&cx, &cy) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp.py new file mode 100644 index 0000000000000000000000000000000000000000..b1c61752110cf270f9cbd8c113c81032cf551511 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp.py @@ -0,0 +1,25 @@ +# This file is not meant for public use and will be removed in SciPy v2.0.0. +# Use the `scipy.linalg` namespace for importing the functions +# included below. + +from scipy._lib.deprecation import _sub_module_deprecation + + +__all__ = [ # noqa: F822 + 'eig', 'eigvals', 'eigh', 'eigvalsh', + 'eig_banded', 'eigvals_banded', + 'eigh_tridiagonal', 'eigvalsh_tridiagonal', 'hessenberg', 'cdf2rdf', + 'array', 'isfinite', 'inexact', 'nonzero', 'iscomplexobj', + 'flatnonzero', 'argsort', 'iscomplex', 'einsum', 'eye', 'inf', + 'LinAlgError', 'norm', 'get_lapack_funcs' +] + + +def __dir__(): + return __all__ + + +def __getattr__(name): + return _sub_module_deprecation(sub_package="linalg", module="decomp", + private_modules=["_decomp"], all=__all__, + attribute=name) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp_cholesky.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp_cholesky.py new file mode 100644 index 0000000000000000000000000000000000000000..beec324d3503725c40438b6a09789b0804df5688 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp_cholesky.py @@ -0,0 +1,22 @@ +# This file is not meant for public use and will be removed in SciPy v2.0.0. +# Use the `scipy.linalg` namespace for importing the functions +# included below. + +from scipy._lib.deprecation import _sub_module_deprecation + + +__all__ = [ # noqa: F822 + 'cholesky', 'cho_factor', 'cho_solve', 'cholesky_banded', + 'cho_solve_banded', 'asarray_chkfinite', 'atleast_2d', + 'LinAlgError', 'get_lapack_funcs' +] + + +def __dir__(): + return __all__ + + +def __getattr__(name): + return _sub_module_deprecation(sub_package="linalg", module="decomp_cholesky", + private_modules=["_decomp_cholesky"], all=__all__, + attribute=name) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp_qr.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp_qr.py new file mode 100644 index 0000000000000000000000000000000000000000..77df617b5edf0b4d7f5b812a08a2621a891047d2 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp_qr.py @@ -0,0 +1,20 @@ +# This file is not meant for public use and will be removed in SciPy v2.0.0. +# Use the `scipy.linalg` namespace for importing the functions +# included below. + +from scipy._lib.deprecation import _sub_module_deprecation + + +__all__ = [ # noqa: F822 + 'qr', 'qr_multiply', 'rq', 'get_lapack_funcs', 'safecall' +] + + +def __dir__(): + return __all__ + + +def __getattr__(name): + return _sub_module_deprecation(sub_package="linalg", module="decomp_qr", + private_modules=["_decomp_qr"], all=__all__, + attribute=name) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp_schur.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp_schur.py new file mode 100644 index 0000000000000000000000000000000000000000..387fe8ad5c2acb36144b3f84e8afdf6e5762a1d3 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/decomp_schur.py @@ -0,0 +1,22 @@ +# This file is not meant for public use and will be removed in SciPy v2.0.0. +# Use the `scipy.linalg` namespace for importing the functions +# included below. + +from scipy._lib.deprecation import _sub_module_deprecation + + +__all__ = [ # noqa: F822 + 'schur', 'rsf2csf', 'asarray_chkfinite', 'single', 'array', 'norm', + 'LinAlgError', 'get_lapack_funcs', 'eigvals', 'eps', 'feps' +] + + +def __dir__(): + return __all__ + + +def __getattr__(name): + return _sub_module_deprecation(sub_package="linalg", module="decomp_schur", + private_modules=["_decomp_schur"], all=__all__, + attribute=name) + diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/interpolative.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/interpolative.py new file mode 100644 index 0000000000000000000000000000000000000000..b91cdd63a6a5dbf63446de81997747b548beb6bb --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/interpolative.py @@ -0,0 +1,1015 @@ +#****************************************************************************** +# Copyright (C) 2013 Kenneth L. Ho +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. Redistributions in binary +# form must reproduce the above copyright notice, this list of conditions and +# the following disclaimer in the documentation and/or other materials +# provided with the distribution. +# +# None of the names of the copyright holders may be used to endorse or +# promote products derived from this software without specific prior written +# permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +#****************************************************************************** + +# Python module for interfacing with `id_dist`. + +r""" +====================================================================== +Interpolative matrix decomposition (:mod:`scipy.linalg.interpolative`) +====================================================================== + +.. moduleauthor:: Kenneth L. Ho + +.. versionadded:: 0.13 + +.. currentmodule:: scipy.linalg.interpolative + +An interpolative decomposition (ID) of a matrix :math:`A \in +\mathbb{C}^{m \times n}` of rank :math:`k \leq \min \{ m, n \}` is a +factorization + +.. math:: + A \Pi = + \begin{bmatrix} + A \Pi_{1} & A \Pi_{2} + \end{bmatrix} = + A \Pi_{1} + \begin{bmatrix} + I & T + \end{bmatrix}, + +where :math:`\Pi = [\Pi_{1}, \Pi_{2}]` is a permutation matrix with +:math:`\Pi_{1} \in \{ 0, 1 \}^{n \times k}`, i.e., :math:`A \Pi_{2} = +A \Pi_{1} T`. This can equivalently be written as :math:`A = BP`, +where :math:`B = A \Pi_{1}` and :math:`P = [I, T] \Pi^{\mathsf{T}}` +are the *skeleton* and *interpolation matrices*, respectively. + +If :math:`A` does not have exact rank :math:`k`, then there exists an +approximation in the form of an ID such that :math:`A = BP + E`, where +:math:`\| E \| \sim \sigma_{k + 1}` is on the order of the :math:`(k + +1)`-th largest singular value of :math:`A`. Note that :math:`\sigma_{k ++ 1}` is the best possible error for a rank-:math:`k` approximation +and, in fact, is achieved by the singular value decomposition (SVD) +:math:`A \approx U S V^{*}`, where :math:`U \in \mathbb{C}^{m \times +k}` and :math:`V \in \mathbb{C}^{n \times k}` have orthonormal columns +and :math:`S = \mathop{\mathrm{diag}} (\sigma_{i}) \in \mathbb{C}^{k +\times k}` is diagonal with nonnegative entries. The principal +advantages of using an ID over an SVD are that: + +- it is cheaper to construct; +- it preserves the structure of :math:`A`; and +- it is more efficient to compute with in light of the identity submatrix of :math:`P`. + +Routines +======== + +Main functionality: + +.. autosummary:: + :toctree: generated/ + + interp_decomp + reconstruct_matrix_from_id + reconstruct_interp_matrix + reconstruct_skel_matrix + id_to_svd + svd + estimate_spectral_norm + estimate_spectral_norm_diff + estimate_rank + +Support functions: + +.. autosummary:: + :toctree: generated/ + + seed + rand + + +References +========== + +This module uses the ID software package [1]_ by Martinsson, Rokhlin, +Shkolnisky, and Tygert, which is a Fortran library for computing IDs +using various algorithms, including the rank-revealing QR approach of +[2]_ and the more recent randomized methods described in [3]_, [4]_, +and [5]_. This module exposes its functionality in a way convenient +for Python users. Note that this module does not add any functionality +beyond that of organizing a simpler and more consistent interface. + +We advise the user to consult also the `documentation for the ID package +`_. + +.. [1] P.G. Martinsson, V. Rokhlin, Y. Shkolnisky, M. Tygert. "ID: a + software package for low-rank approximation of matrices via interpolative + decompositions, version 0.2." http://tygert.com/id_doc.4.pdf. + +.. [2] H. Cheng, Z. Gimbutas, P.G. Martinsson, V. Rokhlin. "On the + compression of low rank matrices." *SIAM J. Sci. Comput.* 26 (4): 1389--1404, + 2005. :doi:`10.1137/030602678`. + +.. [3] E. Liberty, F. Woolfe, P.G. Martinsson, V. Rokhlin, M. + Tygert. "Randomized algorithms for the low-rank approximation of matrices." + *Proc. Natl. Acad. Sci. U.S.A.* 104 (51): 20167--20172, 2007. + :doi:`10.1073/pnas.0709640104`. + +.. [4] P.G. Martinsson, V. Rokhlin, M. Tygert. "A randomized + algorithm for the decomposition of matrices." *Appl. Comput. Harmon. Anal.* 30 + (1): 47--68, 2011. :doi:`10.1016/j.acha.2010.02.003`. + +.. [5] F. Woolfe, E. Liberty, V. Rokhlin, M. Tygert. "A fast + randomized algorithm for the approximation of matrices." *Appl. Comput. + Harmon. Anal.* 25 (3): 335--366, 2008. :doi:`10.1016/j.acha.2007.12.002`. + + +Tutorial +======== + +Initializing +------------ + +The first step is to import :mod:`scipy.linalg.interpolative` by issuing the +command: + +>>> import scipy.linalg.interpolative as sli + +Now let's build a matrix. For this, we consider a Hilbert matrix, which is well +know to have low rank: + +>>> from scipy.linalg import hilbert +>>> n = 1000 +>>> A = hilbert(n) + +We can also do this explicitly via: + +>>> import numpy as np +>>> n = 1000 +>>> A = np.empty((n, n), order='F') +>>> for j in range(n): +... for i in range(n): +... A[i,j] = 1. / (i + j + 1) + +Note the use of the flag ``order='F'`` in :func:`numpy.empty`. This +instantiates the matrix in Fortran-contiguous order and is important for +avoiding data copying when passing to the backend. + +We then define multiplication routines for the matrix by regarding it as a +:class:`scipy.sparse.linalg.LinearOperator`: + +>>> from scipy.sparse.linalg import aslinearoperator +>>> L = aslinearoperator(A) + +This automatically sets up methods describing the action of the matrix and its +adjoint on a vector. + +Computing an ID +--------------- + +We have several choices of algorithm to compute an ID. These fall largely +according to two dichotomies: + +1. how the matrix is represented, i.e., via its entries or via its action on a + vector; and +2. whether to approximate it to a fixed relative precision or to a fixed rank. + +We step through each choice in turn below. + +In all cases, the ID is represented by three parameters: + +1. a rank ``k``; +2. an index array ``idx``; and +3. interpolation coefficients ``proj``. + +The ID is specified by the relation +``np.dot(A[:,idx[:k]], proj) == A[:,idx[k:]]``. + +From matrix entries +................... + +We first consider a matrix given in terms of its entries. + +To compute an ID to a fixed precision, type: + +>>> eps = 1e-3 +>>> k, idx, proj = sli.interp_decomp(A, eps) + +where ``eps < 1`` is the desired precision. + +To compute an ID to a fixed rank, use: + +>>> idx, proj = sli.interp_decomp(A, k) + +where ``k >= 1`` is the desired rank. + +Both algorithms use random sampling and are usually faster than the +corresponding older, deterministic algorithms, which can be accessed via the +commands: + +>>> k, idx, proj = sli.interp_decomp(A, eps, rand=False) + +and: + +>>> idx, proj = sli.interp_decomp(A, k, rand=False) + +respectively. + +From matrix action +.................. + +Now consider a matrix given in terms of its action on a vector as a +:class:`scipy.sparse.linalg.LinearOperator`. + +To compute an ID to a fixed precision, type: + +>>> k, idx, proj = sli.interp_decomp(L, eps) + +To compute an ID to a fixed rank, use: + +>>> idx, proj = sli.interp_decomp(L, k) + +These algorithms are randomized. + +Reconstructing an ID +-------------------- + +The ID routines above do not output the skeleton and interpolation matrices +explicitly but instead return the relevant information in a more compact (and +sometimes more useful) form. To build these matrices, write: + +>>> B = sli.reconstruct_skel_matrix(A, k, idx) + +for the skeleton matrix and: + +>>> P = sli.reconstruct_interp_matrix(idx, proj) + +for the interpolation matrix. The ID approximation can then be computed as: + +>>> C = np.dot(B, P) + +This can also be constructed directly using: + +>>> C = sli.reconstruct_matrix_from_id(B, idx, proj) + +without having to first compute ``P``. + +Alternatively, this can be done explicitly as well using: + +>>> B = A[:,idx[:k]] +>>> P = np.hstack([np.eye(k), proj])[:,np.argsort(idx)] +>>> C = np.dot(B, P) + +Computing an SVD +---------------- + +An ID can be converted to an SVD via the command: + +>>> U, S, V = sli.id_to_svd(B, idx, proj) + +The SVD approximation is then: + +>>> approx = U @ np.diag(S) @ V.conj().T + +The SVD can also be computed "fresh" by combining both the ID and conversion +steps into one command. Following the various ID algorithms above, there are +correspondingly various SVD algorithms that one can employ. + +From matrix entries +................... + +We consider first SVD algorithms for a matrix given in terms of its entries. + +To compute an SVD to a fixed precision, type: + +>>> U, S, V = sli.svd(A, eps) + +To compute an SVD to a fixed rank, use: + +>>> U, S, V = sli.svd(A, k) + +Both algorithms use random sampling; for the deterministic versions, issue the +keyword ``rand=False`` as above. + +From matrix action +.................. + +Now consider a matrix given in terms of its action on a vector. + +To compute an SVD to a fixed precision, type: + +>>> U, S, V = sli.svd(L, eps) + +To compute an SVD to a fixed rank, use: + +>>> U, S, V = sli.svd(L, k) + +Utility routines +---------------- + +Several utility routines are also available. + +To estimate the spectral norm of a matrix, use: + +>>> snorm = sli.estimate_spectral_norm(A) + +This algorithm is based on the randomized power method and thus requires only +matrix-vector products. The number of iterations to take can be set using the +keyword ``its`` (default: ``its=20``). The matrix is interpreted as a +:class:`scipy.sparse.linalg.LinearOperator`, but it is also valid to supply it +as a :class:`numpy.ndarray`, in which case it is trivially converted using +:func:`scipy.sparse.linalg.aslinearoperator`. + +The same algorithm can also estimate the spectral norm of the difference of two +matrices ``A1`` and ``A2`` as follows: + +>>> A1, A2 = A**2, A +>>> diff = sli.estimate_spectral_norm_diff(A1, A2) + +This is often useful for checking the accuracy of a matrix approximation. + +Some routines in :mod:`scipy.linalg.interpolative` require estimating the rank +of a matrix as well. This can be done with either: + +>>> k = sli.estimate_rank(A, eps) + +or: + +>>> k = sli.estimate_rank(L, eps) + +depending on the representation. The parameter ``eps`` controls the definition +of the numerical rank. + +Finally, the random number generation required for all randomized routines can +be controlled via :func:`scipy.linalg.interpolative.seed`. To reset the seed +values to their original values, use: + +>>> sli.seed('default') + +To specify the seed values, use: + +>>> s = 42 +>>> sli.seed(s) + +where ``s`` must be an integer or array of 55 floats. If an integer, the array +of floats is obtained by using ``numpy.random.rand`` with the given integer +seed. + +To simply generate some random numbers, type: + +>>> arr = sli.rand(n) + +where ``n`` is the number of random numbers to generate. + +Remarks +------- + +The above functions all automatically detect the appropriate interface and work +with both real and complex data types, passing input arguments to the proper +backend routine. + +""" + +import scipy.linalg._interpolative_backend as _backend +import numpy as np +import sys + +__all__ = [ + 'estimate_rank', + 'estimate_spectral_norm', + 'estimate_spectral_norm_diff', + 'id_to_svd', + 'interp_decomp', + 'rand', + 'reconstruct_interp_matrix', + 'reconstruct_matrix_from_id', + 'reconstruct_skel_matrix', + 'seed', + 'svd', +] + +_DTYPE_ERROR = ValueError("invalid input dtype (input must be float64 or complex128)") +_TYPE_ERROR = TypeError("invalid input type (must be array or LinearOperator)") +_32BIT_ERROR = ValueError("interpolative decomposition on 32-bit systems " + "with complex128 is buggy") +_IS_32BIT = (sys.maxsize < 2**32) + + +def _is_real(A): + try: + if A.dtype == np.complex128: + return False + elif A.dtype == np.float64: + return True + else: + raise _DTYPE_ERROR + except AttributeError as e: + raise _TYPE_ERROR from e + + +def seed(seed=None): + """ + Seed the internal random number generator used in this ID package. + + The generator is a lagged Fibonacci method with 55-element internal state. + + Parameters + ---------- + seed : int, sequence, 'default', optional + If 'default', the random seed is reset to a default value. + + If `seed` is a sequence containing 55 floating-point numbers + in range [0,1], these are used to set the internal state of + the generator. + + If the value is an integer, the internal state is obtained + from `numpy.random.RandomState` (MT19937) with the integer + used as the initial seed. + + If `seed` is omitted (None), ``numpy.random.rand`` is used to + initialize the generator. + + """ + # For details, see :func:`_backend.id_srand`, :func:`_backend.id_srandi`, + # and :func:`_backend.id_srando`. + + if isinstance(seed, str) and seed == 'default': + _backend.id_srando() + elif hasattr(seed, '__len__'): + state = np.asfortranarray(seed, dtype=float) + if state.shape != (55,): + raise ValueError("invalid input size") + elif state.min() < 0 or state.max() > 1: + raise ValueError("values not in range [0,1]") + _backend.id_srandi(state) + elif seed is None: + _backend.id_srandi(np.random.rand(55)) + else: + rnd = np.random.RandomState(seed) + _backend.id_srandi(rnd.rand(55)) + + +def rand(*shape): + """ + Generate standard uniform pseudorandom numbers via a very efficient lagged + Fibonacci method. + + This routine is used for all random number generation in this package and + can affect ID and SVD results. + + Parameters + ---------- + *shape + Shape of output array + + """ + # For details, see :func:`_backend.id_srand`, and :func:`_backend.id_srando`. + return _backend.id_srand(np.prod(shape)).reshape(shape) + + +def interp_decomp(A, eps_or_k, rand=True): + """ + Compute ID of a matrix. + + An ID of a matrix `A` is a factorization defined by a rank `k`, a column + index array `idx`, and interpolation coefficients `proj` such that:: + + numpy.dot(A[:,idx[:k]], proj) = A[:,idx[k:]] + + The original matrix can then be reconstructed as:: + + numpy.hstack([A[:,idx[:k]], + numpy.dot(A[:,idx[:k]], proj)] + )[:,numpy.argsort(idx)] + + or via the routine :func:`reconstruct_matrix_from_id`. This can + equivalently be written as:: + + numpy.dot(A[:,idx[:k]], + numpy.hstack([numpy.eye(k), proj]) + )[:,np.argsort(idx)] + + in terms of the skeleton and interpolation matrices:: + + B = A[:,idx[:k]] + + and:: + + P = numpy.hstack([numpy.eye(k), proj])[:,np.argsort(idx)] + + respectively. See also :func:`reconstruct_interp_matrix` and + :func:`reconstruct_skel_matrix`. + + The ID can be computed to any relative precision or rank (depending on the + value of `eps_or_k`). If a precision is specified (`eps_or_k < 1`), then + this function has the output signature:: + + k, idx, proj = interp_decomp(A, eps_or_k) + + Otherwise, if a rank is specified (`eps_or_k >= 1`), then the output + signature is:: + + idx, proj = interp_decomp(A, eps_or_k) + + .. This function automatically detects the form of the input parameters + and passes them to the appropriate backend. For details, see + :func:`_backend.iddp_id`, :func:`_backend.iddp_aid`, + :func:`_backend.iddp_rid`, :func:`_backend.iddr_id`, + :func:`_backend.iddr_aid`, :func:`_backend.iddr_rid`, + :func:`_backend.idzp_id`, :func:`_backend.idzp_aid`, + :func:`_backend.idzp_rid`, :func:`_backend.idzr_id`, + :func:`_backend.idzr_aid`, and :func:`_backend.idzr_rid`. + + Parameters + ---------- + A : :class:`numpy.ndarray` or :class:`scipy.sparse.linalg.LinearOperator` with `rmatvec` + Matrix to be factored + eps_or_k : float or int + Relative error (if `eps_or_k < 1`) or rank (if `eps_or_k >= 1`) of + approximation. + rand : bool, optional + Whether to use random sampling if `A` is of type :class:`numpy.ndarray` + (randomized algorithms are always used if `A` is of type + :class:`scipy.sparse.linalg.LinearOperator`). + + Returns + ------- + k : int + Rank required to achieve specified relative precision if + `eps_or_k < 1`. + idx : :class:`numpy.ndarray` + Column index array. + proj : :class:`numpy.ndarray` + Interpolation coefficients. + """ # numpy/numpydoc#87 # noqa: E501 + from scipy.sparse.linalg import LinearOperator + + real = _is_real(A) + + if isinstance(A, np.ndarray): + if eps_or_k < 1: + eps = eps_or_k + if rand: + if real: + k, idx, proj = _backend.iddp_aid(eps, A) + else: + if _IS_32BIT: + raise _32BIT_ERROR + k, idx, proj = _backend.idzp_aid(eps, A) + else: + if real: + k, idx, proj = _backend.iddp_id(eps, A) + else: + k, idx, proj = _backend.idzp_id(eps, A) + return k, idx - 1, proj + else: + k = int(eps_or_k) + if rand: + if real: + idx, proj = _backend.iddr_aid(A, k) + else: + if _IS_32BIT: + raise _32BIT_ERROR + idx, proj = _backend.idzr_aid(A, k) + else: + if real: + idx, proj = _backend.iddr_id(A, k) + else: + idx, proj = _backend.idzr_id(A, k) + return idx - 1, proj + elif isinstance(A, LinearOperator): + m, n = A.shape + matveca = A.rmatvec + if eps_or_k < 1: + eps = eps_or_k + if real: + k, idx, proj = _backend.iddp_rid(eps, m, n, matveca) + else: + if _IS_32BIT: + raise _32BIT_ERROR + k, idx, proj = _backend.idzp_rid(eps, m, n, matveca) + return k, idx - 1, proj + else: + k = int(eps_or_k) + if real: + idx, proj = _backend.iddr_rid(m, n, matveca, k) + else: + if _IS_32BIT: + raise _32BIT_ERROR + idx, proj = _backend.idzr_rid(m, n, matveca, k) + return idx - 1, proj + else: + raise _TYPE_ERROR + + +def reconstruct_matrix_from_id(B, idx, proj): + """ + Reconstruct matrix from its ID. + + A matrix `A` with skeleton matrix `B` and ID indices and coefficients `idx` + and `proj`, respectively, can be reconstructed as:: + + numpy.hstack([B, numpy.dot(B, proj)])[:,numpy.argsort(idx)] + + See also :func:`reconstruct_interp_matrix` and + :func:`reconstruct_skel_matrix`. + + .. This function automatically detects the matrix data type and calls the + appropriate backend. For details, see :func:`_backend.idd_reconid` and + :func:`_backend.idz_reconid`. + + Parameters + ---------- + B : :class:`numpy.ndarray` + Skeleton matrix. + idx : :class:`numpy.ndarray` + Column index array. + proj : :class:`numpy.ndarray` + Interpolation coefficients. + + Returns + ------- + :class:`numpy.ndarray` + Reconstructed matrix. + """ + if _is_real(B): + return _backend.idd_reconid(B, idx + 1, proj) + else: + return _backend.idz_reconid(B, idx + 1, proj) + + +def reconstruct_interp_matrix(idx, proj): + """ + Reconstruct interpolation matrix from ID. + + The interpolation matrix can be reconstructed from the ID indices and + coefficients `idx` and `proj`, respectively, as:: + + P = numpy.hstack([numpy.eye(proj.shape[0]), proj])[:,numpy.argsort(idx)] + + The original matrix can then be reconstructed from its skeleton matrix `B` + via:: + + numpy.dot(B, P) + + See also :func:`reconstruct_matrix_from_id` and + :func:`reconstruct_skel_matrix`. + + .. This function automatically detects the matrix data type and calls the + appropriate backend. For details, see :func:`_backend.idd_reconint` and + :func:`_backend.idz_reconint`. + + Parameters + ---------- + idx : :class:`numpy.ndarray` + Column index array. + proj : :class:`numpy.ndarray` + Interpolation coefficients. + + Returns + ------- + :class:`numpy.ndarray` + Interpolation matrix. + """ + if _is_real(proj): + return _backend.idd_reconint(idx + 1, proj) + else: + return _backend.idz_reconint(idx + 1, proj) + + +def reconstruct_skel_matrix(A, k, idx): + """ + Reconstruct skeleton matrix from ID. + + The skeleton matrix can be reconstructed from the original matrix `A` and its + ID rank and indices `k` and `idx`, respectively, as:: + + B = A[:,idx[:k]] + + The original matrix can then be reconstructed via:: + + numpy.hstack([B, numpy.dot(B, proj)])[:,numpy.argsort(idx)] + + See also :func:`reconstruct_matrix_from_id` and + :func:`reconstruct_interp_matrix`. + + .. This function automatically detects the matrix data type and calls the + appropriate backend. For details, see :func:`_backend.idd_copycols` and + :func:`_backend.idz_copycols`. + + Parameters + ---------- + A : :class:`numpy.ndarray` + Original matrix. + k : int + Rank of ID. + idx : :class:`numpy.ndarray` + Column index array. + + Returns + ------- + :class:`numpy.ndarray` + Skeleton matrix. + """ + if _is_real(A): + return _backend.idd_copycols(A, k, idx + 1) + else: + return _backend.idz_copycols(A, k, idx + 1) + + +def id_to_svd(B, idx, proj): + """ + Convert ID to SVD. + + The SVD reconstruction of a matrix with skeleton matrix `B` and ID indices and + coefficients `idx` and `proj`, respectively, is:: + + U, S, V = id_to_svd(B, idx, proj) + A = numpy.dot(U, numpy.dot(numpy.diag(S), V.conj().T)) + + See also :func:`svd`. + + .. This function automatically detects the matrix data type and calls the + appropriate backend. For details, see :func:`_backend.idd_id2svd` and + :func:`_backend.idz_id2svd`. + + Parameters + ---------- + B : :class:`numpy.ndarray` + Skeleton matrix. + idx : :class:`numpy.ndarray` + Column index array. + proj : :class:`numpy.ndarray` + Interpolation coefficients. + + Returns + ------- + U : :class:`numpy.ndarray` + Left singular vectors. + S : :class:`numpy.ndarray` + Singular values. + V : :class:`numpy.ndarray` + Right singular vectors. + """ + if _is_real(B): + U, V, S = _backend.idd_id2svd(B, idx + 1, proj) + else: + U, V, S = _backend.idz_id2svd(B, idx + 1, proj) + return U, S, V + + +def estimate_spectral_norm(A, its=20): + """ + Estimate spectral norm of a matrix by the randomized power method. + + .. This function automatically detects the matrix data type and calls the + appropriate backend. For details, see :func:`_backend.idd_snorm` and + :func:`_backend.idz_snorm`. + + Parameters + ---------- + A : :class:`scipy.sparse.linalg.LinearOperator` + Matrix given as a :class:`scipy.sparse.linalg.LinearOperator` with the + `matvec` and `rmatvec` methods (to apply the matrix and its adjoint). + its : int, optional + Number of power method iterations. + + Returns + ------- + float + Spectral norm estimate. + """ + from scipy.sparse.linalg import aslinearoperator + A = aslinearoperator(A) + m, n = A.shape + def matvec(x): + return A.matvec(x) + def matveca(x): + return A.rmatvec(x) + if _is_real(A): + return _backend.idd_snorm(m, n, matveca, matvec, its=its) + else: + return _backend.idz_snorm(m, n, matveca, matvec, its=its) + + +def estimate_spectral_norm_diff(A, B, its=20): + """ + Estimate spectral norm of the difference of two matrices by the randomized + power method. + + .. This function automatically detects the matrix data type and calls the + appropriate backend. For details, see :func:`_backend.idd_diffsnorm` and + :func:`_backend.idz_diffsnorm`. + + Parameters + ---------- + A : :class:`scipy.sparse.linalg.LinearOperator` + First matrix given as a :class:`scipy.sparse.linalg.LinearOperator` with the + `matvec` and `rmatvec` methods (to apply the matrix and its adjoint). + B : :class:`scipy.sparse.linalg.LinearOperator` + Second matrix given as a :class:`scipy.sparse.linalg.LinearOperator` with + the `matvec` and `rmatvec` methods (to apply the matrix and its adjoint). + its : int, optional + Number of power method iterations. + + Returns + ------- + float + Spectral norm estimate of matrix difference. + """ + from scipy.sparse.linalg import aslinearoperator + A = aslinearoperator(A) + B = aslinearoperator(B) + m, n = A.shape + def matvec1(x): + return A.matvec(x) + def matveca1(x): + return A.rmatvec(x) + def matvec2(x): + return B.matvec(x) + def matveca2(x): + return B.rmatvec(x) + if _is_real(A): + return _backend.idd_diffsnorm( + m, n, matveca1, matveca2, matvec1, matvec2, its=its) + else: + return _backend.idz_diffsnorm( + m, n, matveca1, matveca2, matvec1, matvec2, its=its) + + +def svd(A, eps_or_k, rand=True): + """ + Compute SVD of a matrix via an ID. + + An SVD of a matrix `A` is a factorization:: + + A = numpy.dot(U, numpy.dot(numpy.diag(S), V.conj().T)) + + where `U` and `V` have orthonormal columns and `S` is nonnegative. + + The SVD can be computed to any relative precision or rank (depending on the + value of `eps_or_k`). + + See also :func:`interp_decomp` and :func:`id_to_svd`. + + .. This function automatically detects the form of the input parameters and + passes them to the appropriate backend. For details, see + :func:`_backend.iddp_svd`, :func:`_backend.iddp_asvd`, + :func:`_backend.iddp_rsvd`, :func:`_backend.iddr_svd`, + :func:`_backend.iddr_asvd`, :func:`_backend.iddr_rsvd`, + :func:`_backend.idzp_svd`, :func:`_backend.idzp_asvd`, + :func:`_backend.idzp_rsvd`, :func:`_backend.idzr_svd`, + :func:`_backend.idzr_asvd`, and :func:`_backend.idzr_rsvd`. + + Parameters + ---------- + A : :class:`numpy.ndarray` or :class:`scipy.sparse.linalg.LinearOperator` + Matrix to be factored, given as either a :class:`numpy.ndarray` or a + :class:`scipy.sparse.linalg.LinearOperator` with the `matvec` and + `rmatvec` methods (to apply the matrix and its adjoint). + eps_or_k : float or int + Relative error (if `eps_or_k < 1`) or rank (if `eps_or_k >= 1`) of + approximation. + rand : bool, optional + Whether to use random sampling if `A` is of type :class:`numpy.ndarray` + (randomized algorithms are always used if `A` is of type + :class:`scipy.sparse.linalg.LinearOperator`). + + Returns + ------- + U : :class:`numpy.ndarray` + Left singular vectors. + S : :class:`numpy.ndarray` + Singular values. + V : :class:`numpy.ndarray` + Right singular vectors. + """ + from scipy.sparse.linalg import LinearOperator + + real = _is_real(A) + + if isinstance(A, np.ndarray): + if eps_or_k < 1: + eps = eps_or_k + if rand: + if real: + U, V, S = _backend.iddp_asvd(eps, A) + else: + if _IS_32BIT: + raise _32BIT_ERROR + U, V, S = _backend.idzp_asvd(eps, A) + else: + if real: + U, V, S = _backend.iddp_svd(eps, A) + else: + U, V, S = _backend.idzp_svd(eps, A) + else: + k = int(eps_or_k) + if k > min(A.shape): + raise ValueError(f"Approximation rank {k} exceeds min(A.shape) = " + f" {min(A.shape)} ") + if rand: + if real: + U, V, S = _backend.iddr_asvd(A, k) + else: + if _IS_32BIT: + raise _32BIT_ERROR + U, V, S = _backend.idzr_asvd(A, k) + else: + if real: + U, V, S = _backend.iddr_svd(A, k) + else: + U, V, S = _backend.idzr_svd(A, k) + elif isinstance(A, LinearOperator): + m, n = A.shape + def matvec(x): + return A.matvec(x) + def matveca(x): + return A.rmatvec(x) + if eps_or_k < 1: + eps = eps_or_k + if real: + U, V, S = _backend.iddp_rsvd(eps, m, n, matveca, matvec) + else: + if _IS_32BIT: + raise _32BIT_ERROR + U, V, S = _backend.idzp_rsvd(eps, m, n, matveca, matvec) + else: + k = int(eps_or_k) + if real: + U, V, S = _backend.iddr_rsvd(m, n, matveca, matvec, k) + else: + if _IS_32BIT: + raise _32BIT_ERROR + U, V, S = _backend.idzr_rsvd(m, n, matveca, matvec, k) + else: + raise _TYPE_ERROR + return U, S, V + + +def estimate_rank(A, eps): + """ + Estimate matrix rank to a specified relative precision using randomized + methods. + + The matrix `A` can be given as either a :class:`numpy.ndarray` or a + :class:`scipy.sparse.linalg.LinearOperator`, with different algorithms used + for each case. If `A` is of type :class:`numpy.ndarray`, then the output + rank is typically about 8 higher than the actual numerical rank. + + .. This function automatically detects the form of the input parameters and + passes them to the appropriate backend. For details, + see :func:`_backend.idd_estrank`, :func:`_backend.idd_findrank`, + :func:`_backend.idz_estrank`, and :func:`_backend.idz_findrank`. + + Parameters + ---------- + A : :class:`numpy.ndarray` or :class:`scipy.sparse.linalg.LinearOperator` + Matrix whose rank is to be estimated, given as either a + :class:`numpy.ndarray` or a :class:`scipy.sparse.linalg.LinearOperator` + with the `rmatvec` method (to apply the matrix adjoint). + eps : float + Relative error for numerical rank definition. + + Returns + ------- + int + Estimated matrix rank. + """ + from scipy.sparse.linalg import LinearOperator + + real = _is_real(A) + + if isinstance(A, np.ndarray): + if real: + rank = _backend.idd_estrank(eps, A) + else: + rank = _backend.idz_estrank(eps, A) + if rank == 0: + # special return value for nearly full rank + rank = min(A.shape) + return rank + elif isinstance(A, LinearOperator): + m, n = A.shape + matveca = A.rmatvec + if real: + return _backend.idd_findrank(eps, m, n, matveca) + else: + return _backend.idz_findrank(eps, m, n, matveca) + else: + raise _TYPE_ERROR diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/lapack.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/lapack.py new file mode 100644 index 0000000000000000000000000000000000000000..57b0f65138b36dc9542f429dc73f88b6aac03004 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/lapack.py @@ -0,0 +1,1039 @@ +""" +Low-level LAPACK functions (:mod:`scipy.linalg.lapack`) +======================================================= + +This module contains low-level functions from the LAPACK library. + +.. versionadded:: 0.12.0 + +.. note:: + + The common ``overwrite_<>`` option in many routines, allows the + input arrays to be overwritten to avoid extra memory allocation. + However this requires the array to satisfy two conditions + which are memory order and the data type to match exactly the + order and the type expected by the routine. + + As an example, if you pass a double precision float array to any + ``S....`` routine which expects single precision arguments, f2py + will create an intermediate array to match the argument types and + overwriting will be performed on that intermediate array. + + Similarly, if a C-contiguous array is passed, f2py will pass a + FORTRAN-contiguous array internally. Please make sure that these + details are satisfied. More information can be found in the f2py + documentation. + +.. warning:: + + These functions do little to no error checking. + It is possible to cause crashes by mis-using them, + so prefer using the higher-level routines in `scipy.linalg`. + +Finding functions +----------------- + +.. autosummary:: + :toctree: generated/ + + get_lapack_funcs + +All functions +------------- + +.. autosummary:: + :toctree: generated/ + + sgbsv + dgbsv + cgbsv + zgbsv + + sgbtrf + dgbtrf + cgbtrf + zgbtrf + + sgbtrs + dgbtrs + cgbtrs + zgbtrs + + sgebal + dgebal + cgebal + zgebal + + sgecon + dgecon + cgecon + zgecon + + sgeequ + dgeequ + cgeequ + zgeequ + + sgeequb + dgeequb + cgeequb + zgeequb + + sgees + dgees + cgees + zgees + + sgeev + dgeev + cgeev + zgeev + + sgeev_lwork + dgeev_lwork + cgeev_lwork + zgeev_lwork + + sgehrd + dgehrd + cgehrd + zgehrd + + sgehrd_lwork + dgehrd_lwork + cgehrd_lwork + zgehrd_lwork + + sgejsv + dgejsv + + sgels + dgels + cgels + zgels + + sgels_lwork + dgels_lwork + cgels_lwork + zgels_lwork + + sgelsd + dgelsd + cgelsd + zgelsd + + sgelsd_lwork + dgelsd_lwork + cgelsd_lwork + zgelsd_lwork + + sgelss + dgelss + cgelss + zgelss + + sgelss_lwork + dgelss_lwork + cgelss_lwork + zgelss_lwork + + sgelsy + dgelsy + cgelsy + zgelsy + + sgelsy_lwork + dgelsy_lwork + cgelsy_lwork + zgelsy_lwork + + sgeqp3 + dgeqp3 + cgeqp3 + zgeqp3 + + sgeqrf + dgeqrf + cgeqrf + zgeqrf + + sgeqrf_lwork + dgeqrf_lwork + cgeqrf_lwork + zgeqrf_lwork + + sgeqrfp + dgeqrfp + cgeqrfp + zgeqrfp + + sgeqrfp_lwork + dgeqrfp_lwork + cgeqrfp_lwork + zgeqrfp_lwork + + sgerqf + dgerqf + cgerqf + zgerqf + + sgesdd + dgesdd + cgesdd + zgesdd + + sgesdd_lwork + dgesdd_lwork + cgesdd_lwork + zgesdd_lwork + + sgesv + dgesv + cgesv + zgesv + + sgesvd + dgesvd + cgesvd + zgesvd + + sgesvd_lwork + dgesvd_lwork + cgesvd_lwork + zgesvd_lwork + + sgesvx + dgesvx + cgesvx + zgesvx + + sgetrf + dgetrf + cgetrf + zgetrf + + sgetc2 + dgetc2 + cgetc2 + zgetc2 + + sgetri + dgetri + cgetri + zgetri + + sgetri_lwork + dgetri_lwork + cgetri_lwork + zgetri_lwork + + sgetrs + dgetrs + cgetrs + zgetrs + + sgesc2 + dgesc2 + cgesc2 + zgesc2 + + sgges + dgges + cgges + zgges + + sggev + dggev + cggev + zggev + + sgglse + dgglse + cgglse + zgglse + + sgglse_lwork + dgglse_lwork + cgglse_lwork + zgglse_lwork + + sgtsv + dgtsv + cgtsv + zgtsv + + sgtsvx + dgtsvx + cgtsvx + zgtsvx + + chbevd + zhbevd + + chbevx + zhbevx + + checon + zhecon + + cheequb + zheequb + + cheev + zheev + + cheev_lwork + zheev_lwork + + cheevd + zheevd + + cheevd_lwork + zheevd_lwork + + cheevr + zheevr + + cheevr_lwork + zheevr_lwork + + cheevx + zheevx + + cheevx_lwork + zheevx_lwork + + chegst + zhegst + + chegv + zhegv + + chegv_lwork + zhegv_lwork + + chegvd + zhegvd + + chegvx + zhegvx + + chegvx_lwork + zhegvx_lwork + + chesv + zhesv + + chesv_lwork + zhesv_lwork + + chesvx + zhesvx + + chesvx_lwork + zhesvx_lwork + + chetrd + zhetrd + + chetrd_lwork + zhetrd_lwork + + chetrf + zhetrf + + chetrf_lwork + zhetrf_lwork + + chfrk + zhfrk + + slamch + dlamch + + slange + dlange + clange + zlange + + slarf + dlarf + clarf + zlarf + + slarfg + dlarfg + clarfg + zlarfg + + slartg + dlartg + clartg + zlartg + + slasd4 + dlasd4 + + slaswp + dlaswp + claswp + zlaswp + + slauum + dlauum + clauum + zlauum + + sorcsd + dorcsd + sorcsd_lwork + dorcsd_lwork + + sorghr + dorghr + sorghr_lwork + dorghr_lwork + + sorgqr + dorgqr + + sorgrq + dorgrq + + sormqr + dormqr + + sormrz + dormrz + + sormrz_lwork + dormrz_lwork + + spbsv + dpbsv + cpbsv + zpbsv + + spbtrf + dpbtrf + cpbtrf + zpbtrf + + spbtrs + dpbtrs + cpbtrs + zpbtrs + + spftrf + dpftrf + cpftrf + zpftrf + + spftri + dpftri + cpftri + zpftri + + spftrs + dpftrs + cpftrs + zpftrs + + spocon + dpocon + cpocon + zpocon + + spstrf + dpstrf + cpstrf + zpstrf + + spstf2 + dpstf2 + cpstf2 + zpstf2 + + sposv + dposv + cposv + zposv + + sposvx + dposvx + cposvx + zposvx + + spotrf + dpotrf + cpotrf + zpotrf + + spotri + dpotri + cpotri + zpotri + + spotrs + dpotrs + cpotrs + zpotrs + + sppcon + dppcon + cppcon + zppcon + + sppsv + dppsv + cppsv + zppsv + + spptrf + dpptrf + cpptrf + zpptrf + + spptri + dpptri + cpptri + zpptri + + spptrs + dpptrs + cpptrs + zpptrs + + sptsv + dptsv + cptsv + zptsv + + sptsvx + dptsvx + cptsvx + zptsvx + + spttrf + dpttrf + cpttrf + zpttrf + + spttrs + dpttrs + cpttrs + zpttrs + + spteqr + dpteqr + cpteqr + zpteqr + + crot + zrot + + ssbev + dsbev + + ssbevd + dsbevd + + ssbevx + dsbevx + + ssfrk + dsfrk + + sstebz + dstebz + + sstein + dstein + + sstemr + dstemr + + sstemr_lwork + dstemr_lwork + + ssterf + dsterf + + sstev + dstev + + ssycon + dsycon + csycon + zsycon + + ssyconv + dsyconv + csyconv + zsyconv + + ssyequb + dsyequb + csyequb + zsyequb + + ssyev + dsyev + + ssyev_lwork + dsyev_lwork + + ssyevd + dsyevd + + ssyevd_lwork + dsyevd_lwork + + ssyevr + dsyevr + + ssyevr_lwork + dsyevr_lwork + + ssyevx + dsyevx + + ssyevx_lwork + dsyevx_lwork + + ssygst + dsygst + + ssygv + dsygv + + ssygv_lwork + dsygv_lwork + + ssygvd + dsygvd + + ssygvx + dsygvx + + ssygvx_lwork + dsygvx_lwork + + ssysv + dsysv + csysv + zsysv + + ssysv_lwork + dsysv_lwork + csysv_lwork + zsysv_lwork + + ssysvx + dsysvx + csysvx + zsysvx + + ssysvx_lwork + dsysvx_lwork + csysvx_lwork + zsysvx_lwork + + ssytf2 + dsytf2 + csytf2 + zsytf2 + + ssytrd + dsytrd + + ssytrd_lwork + dsytrd_lwork + + ssytrf + dsytrf + csytrf + zsytrf + + ssytrf_lwork + dsytrf_lwork + csytrf_lwork + zsytrf_lwork + + stbtrs + dtbtrs + ctbtrs + ztbtrs + + stfsm + dtfsm + ctfsm + ztfsm + + stfttp + dtfttp + ctfttp + ztfttp + + stfttr + dtfttr + ctfttr + ztfttr + + stgexc + dtgexc + ctgexc + ztgexc + + stgsen + dtgsen + ctgsen + ztgsen + + stgsen_lwork + dtgsen_lwork + ctgsen_lwork + ztgsen_lwork + + stgsyl + dtgsyl + + stpttf + dtpttf + ctpttf + ztpttf + + stpttr + dtpttr + ctpttr + ztpttr + + strexc + dtrexc + ctrexc + ztrexc + + strsen + dtrsen + ctrsen + ztrsen + + strsen_lwork + dtrsen_lwork + ctrsen_lwork + ztrsen_lwork + + strsyl + dtrsyl + ctrsyl + ztrsyl + + strtri + dtrtri + ctrtri + ztrtri + + strtrs + dtrtrs + ctrtrs + ztrtrs + + strttf + dtrttf + ctrttf + ztrttf + + strttp + dtrttp + ctrttp + ztrttp + + stzrzf + dtzrzf + ctzrzf + ztzrzf + + stzrzf_lwork + dtzrzf_lwork + ctzrzf_lwork + ztzrzf_lwork + + cunghr + zunghr + + cunghr_lwork + zunghr_lwork + + cungqr + zungqr + + cungrq + zungrq + + cunmqr + zunmqr + + sgeqrt + dgeqrt + cgeqrt + zgeqrt + + sgemqrt + dgemqrt + cgemqrt + zgemqrt + + sgttrf + dgttrf + cgttrf + zgttrf + + sgttrs + dgttrs + cgttrs + zgttrs + + stpqrt + dtpqrt + ctpqrt + ztpqrt + + stpmqrt + dtpmqrt + ctpmqrt + ztpmqrt + + cuncsd + zuncsd + + cuncsd_lwork + zuncsd_lwork + + cunmrz + zunmrz + + cunmrz_lwork + zunmrz_lwork + + ilaver + +""" +# +# Author: Pearu Peterson, March 2002 +# + +import numpy as _np +from .blas import _get_funcs, _memoize_get_funcs +from scipy.linalg import _flapack +from re import compile as regex_compile +try: + from scipy.linalg import _clapack +except ImportError: + _clapack = None + +try: + from scipy.linalg import _flapack_64 + HAS_ILP64 = True +except ImportError: + HAS_ILP64 = False + _flapack_64 = None + + +# Expose all functions (only flapack --- clapack is an implementation detail) +empty_module = None +from scipy.linalg._flapack import * # noqa: E402, F403 +del empty_module + +__all__ = ['get_lapack_funcs'] + +# some convenience alias for complex functions +_lapack_alias = { + 'corghr': 'cunghr', 'zorghr': 'zunghr', + 'corghr_lwork': 'cunghr_lwork', 'zorghr_lwork': 'zunghr_lwork', + 'corgqr': 'cungqr', 'zorgqr': 'zungqr', + 'cormqr': 'cunmqr', 'zormqr': 'zunmqr', + 'corgrq': 'cungrq', 'zorgrq': 'zungrq', +} + + +# Place guards against docstring rendering issues with special characters +p1 = regex_compile(r'with bounds (?P.*?)( and (?P.*?) storage){0,1}\n') +p2 = regex_compile(r'Default: (?P.*?)\n') + + +def backtickrepl(m): + if m.group('s'): + return ('with bounds ``{}`` with ``{}`` storage\n' + ''.format(m.group('b'), m.group('s'))) + else: + return 'with bounds ``{}``\n'.format(m.group('b')) + + +for routine in [ssyevr, dsyevr, cheevr, zheevr, + ssyevx, dsyevx, cheevx, zheevx, + ssygvd, dsygvd, chegvd, zhegvd]: + if routine.__doc__: + routine.__doc__ = p1.sub(backtickrepl, routine.__doc__) + routine.__doc__ = p2.sub('Default ``\\1``\n', routine.__doc__) + else: + continue + +del regex_compile, p1, p2, backtickrepl + + +@_memoize_get_funcs +def get_lapack_funcs(names, arrays=(), dtype=None, ilp64=False): + """Return available LAPACK function objects from names. + + Arrays are used to determine the optimal prefix of LAPACK routines. + + Parameters + ---------- + names : str or sequence of str + Name(s) of LAPACK functions without type prefix. + + arrays : sequence of ndarrays, optional + Arrays can be given to determine optimal prefix of LAPACK + routines. If not given, double-precision routines will be + used, otherwise the most generic type in arrays will be used. + + dtype : str or dtype, optional + Data-type specifier. Not used if `arrays` is non-empty. + + ilp64 : {True, False, 'preferred'}, optional + Whether to return ILP64 routine variant. + Choosing 'preferred' returns ILP64 routine if available, and + otherwise the 32-bit routine. Default: False + + Returns + ------- + funcs : list + List containing the found function(s). + + Notes + ----- + This routine automatically chooses between Fortran/C + interfaces. Fortran code is used whenever possible for arrays with + column major order. In all other cases, C code is preferred. + + In LAPACK, the naming convention is that all functions start with a + type prefix, which depends on the type of the principal + matrix. These can be one of {'s', 'd', 'c', 'z'} for the NumPy + types {float32, float64, complex64, complex128} respectively, and + are stored in attribute ``typecode`` of the returned functions. + + Examples + -------- + Suppose we would like to use '?lange' routine which computes the selected + norm of an array. We pass our array in order to get the correct 'lange' + flavor. + + >>> import numpy as np + >>> import scipy.linalg as LA + >>> rng = np.random.default_rng() + + >>> a = rng.random((3,2)) + >>> x_lange = LA.get_lapack_funcs('lange', (a,)) + >>> x_lange.typecode + 'd' + >>> x_lange = LA.get_lapack_funcs('lange',(a*1j,)) + >>> x_lange.typecode + 'z' + + Several LAPACK routines work best when its internal WORK array has + the optimal size (big enough for fast computation and small enough to + avoid waste of memory). This size is determined also by a dedicated query + to the function which is often wrapped as a standalone function and + commonly denoted as ``###_lwork``. Below is an example for ``?sysv`` + + >>> a = rng.random((1000, 1000)) + >>> b = rng.random((1000, 1)) * 1j + >>> # We pick up zsysv and zsysv_lwork due to b array + ... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b)) + >>> opt_lwork, _ = xlwork(a.shape[0]) # returns a complex for 'z' prefix + >>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real)) + + """ + if isinstance(ilp64, str): + if ilp64 == 'preferred': + ilp64 = HAS_ILP64 + else: + raise ValueError("Invalid value for 'ilp64'") + + if not ilp64: + return _get_funcs(names, arrays, dtype, + "LAPACK", _flapack, _clapack, + "flapack", "clapack", _lapack_alias, + ilp64=False) + else: + if not HAS_ILP64: + raise RuntimeError("LAPACK ILP64 routine requested, but Scipy " + "compiled only with 32-bit BLAS") + return _get_funcs(names, arrays, dtype, + "LAPACK", _flapack_64, None, + "flapack_64", None, _lapack_alias, + ilp64=True) + + +_int32_max = _np.iinfo(_np.int32).max +_int64_max = _np.iinfo(_np.int64).max + + +def _compute_lwork(routine, *args, **kwargs): + """ + Round floating-point lwork returned by lapack to integer. + + Several LAPACK routines compute optimal values for LWORK, which + they return in a floating-point variable. However, for large + values of LWORK, single-precision floating point is not sufficient + to hold the exact value --- some LAPACK versions (<= 3.5.0 at + least) truncate the returned integer to single precision and in + some cases this can be smaller than the required value. + + Examples + -------- + >>> from scipy.linalg import lapack + >>> n = 5000 + >>> s_r, s_lw = lapack.get_lapack_funcs(('sysvx', 'sysvx_lwork')) + >>> lwork = lapack._compute_lwork(s_lw, n) + >>> lwork + 32000 + + """ + dtype = getattr(routine, 'dtype', None) + int_dtype = getattr(routine, 'int_dtype', None) + ret = routine(*args, **kwargs) + if ret[-1] != 0: + raise ValueError("Internal work array size computation failed: " + "%d" % (ret[-1],)) + + if len(ret) == 2: + return _check_work_float(ret[0].real, dtype, int_dtype) + else: + return tuple(_check_work_float(x.real, dtype, int_dtype) + for x in ret[:-1]) + + +def _check_work_float(value, dtype, int_dtype): + """ + Convert LAPACK-returned work array size float to integer, + carefully for single-precision types. + """ + + if dtype == _np.float32 or dtype == _np.complex64: + # Single-precision routine -- take next fp value to work + # around possible truncation in LAPACK code + value = _np.nextafter(value, _np.inf, dtype=_np.float32) + + value = int(value) + if int_dtype.itemsize == 4: + if value < 0 or value > _int32_max: + raise ValueError("Too large work array required -- computation " + "cannot be performed with standard 32-bit" + " LAPACK.") + elif int_dtype.itemsize == 8: + if value < 0 or value > _int64_max: + raise ValueError("Too large work array required -- computation" + " cannot be performed with standard 64-bit" + " LAPACK.") + return value diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/matfuncs.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/matfuncs.py new file mode 100644 index 0000000000000000000000000000000000000000..f845585070b461ffe2638f87ead493bdec42e571 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/matfuncs.py @@ -0,0 +1,25 @@ +# This file is not meant for public use and will be removed in SciPy v2.0.0. +# Use the `scipy.linalg` namespace for importing the functions +# included below. + +from scipy._lib.deprecation import _sub_module_deprecation + + +__all__ = [ # noqa: F822 + 'expm', 'cosm', 'sinm', 'tanm', 'coshm', 'sinhm', + 'tanhm', 'logm', 'funm', 'signm', 'sqrtm', + 'expm_frechet', 'expm_cond', 'fractional_matrix_power', + 'khatri_rao', 'prod', 'logical_not', 'ravel', 'transpose', + 'conjugate', 'absolute', 'amax', 'sign', 'isfinite', 'single', + 'norm', 'solve', 'inv', 'triu', 'svd', 'schur', 'rsf2csf', 'eps', 'feps' +] + + +def __dir__(): + return __all__ + + +def __getattr__(name): + return _sub_module_deprecation(sub_package="linalg", module="matfuncs", + private_modules=["_matfuncs"], all=__all__, + attribute=name) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/misc.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/misc.py new file mode 100644 index 0000000000000000000000000000000000000000..1fad087489c6a24c8e33df54b811b6c37a3a46d4 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/misc.py @@ -0,0 +1,21 @@ +# This file is not meant for public use and will be removed in SciPy v2.0.0. +# Use the `scipy.linalg` namespace for importing the functions +# included below. + +from scipy._lib.deprecation import _sub_module_deprecation + + +__all__ = [ # noqa: F822 + 'LinAlgError', 'LinAlgWarning', 'norm', 'get_blas_funcs', + 'get_lapack_funcs' +] + + +def __dir__(): + return __all__ + + +def __getattr__(name): + return _sub_module_deprecation(sub_package="linalg", module="misc", + private_modules=["_misc"], all=__all__, + attribute=name) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/linalg/special_matrices.py b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/special_matrices.py new file mode 100644 index 0000000000000000000000000000000000000000..03091d12c70c4fce4a81786f9f223f9882286fd3 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/linalg/special_matrices.py @@ -0,0 +1,22 @@ +# This file is not meant for public use and will be removed in SciPy v2.0.0. +# Use the `scipy.linalg` namespace for importing the functions +# included below. + +from scipy._lib.deprecation import _sub_module_deprecation + +__all__ = [ # noqa: F822 + 'toeplitz', 'circulant', 'hankel', + 'hadamard', 'leslie', 'kron', 'block_diag', 'companion', + 'helmert', 'hilbert', 'invhilbert', 'pascal', 'invpascal', 'dft', + 'fiedler', 'fiedler_companion', 'convolution_matrix', 'as_strided' +] + + +def __dir__(): + return __all__ + + +def __getattr__(name): + return _sub_module_deprecation(sub_package="linalg", module="special_matrices", + private_modules=["_special_matrices"], all=__all__, + attribute=name) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/misc/__init__.py b/env-llmeval/lib/python3.10/site-packages/scipy/misc/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..90b393b4ff585e467d781e9e5a6060cafbadfc34 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/misc/__init__.py @@ -0,0 +1,67 @@ +""" +========================================== +Miscellaneous routines (:mod:`scipy.misc`) +========================================== + +.. currentmodule:: scipy.misc + +.. deprecated:: 1.10.0 + + This module is deprecated and will be completely + removed in SciPy v2.0.0. + +Various utilities that don't have another home. + +.. autosummary:: + :toctree: generated/ + + ascent - Get example image for processing + central_diff_weights - Weights for an n-point central mth derivative + derivative - Find the nth derivative of a function at a point + face - Get example image for processing + electrocardiogram - Load an example of a 1-D signal + +""" + + +from ._common import * +from . import _common +import warnings + +# Deprecated namespaces, to be removed in v2.0.0 +from . import common, doccer + +__all__ = _common.__all__ + +dataset_methods = ['ascent', 'face', 'electrocardiogram'] + + +def __dir__(): + return __all__ + + +def __getattr__(name): + if name not in __all__: + raise AttributeError( + "scipy.misc is deprecated and has no attribute " + f"{name}.") + + if name in dataset_methods: + msg = ("The module `scipy.misc` is deprecated and will be " + "completely removed in SciPy v2.0.0. " + f"All dataset methods including {name}, must be imported " + "directly from the new `scipy.datasets` module.") + else: + msg = (f"The method `{name}` from the `scipy.misc` namespace is" + " deprecated, and will be removed in SciPy v1.12.0.") + + warnings.warn(msg, category=DeprecationWarning, stacklevel=2) + + return getattr(name) + + +del _common + +from scipy._lib._testutils import PytestTester +test = PytestTester(__name__) +del PytestTester diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ca3338867aefcf0f359477adab655ae25cb66d76 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/__init__.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/_common.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/_common.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..785eb47d65ec81313d2d1161bfb041703d839f11 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/_common.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/common.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/common.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d7b177371a53defb7dcfd01e2c60b2a4bf2b2c4 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/common.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/doccer.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/doccer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cd49acd4424d0d2b1034285b6f0af8d1d56f302e Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/misc/__pycache__/doccer.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/misc/_common.py b/env-llmeval/lib/python3.10/site-packages/scipy/misc/_common.py new file mode 100644 index 0000000000000000000000000000000000000000..ae9dfcc704b3cf8870c0c78b58e9957a09f9eeb9 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/misc/_common.py @@ -0,0 +1,344 @@ +""" +Functions which are common and require SciPy Base and Level 1 SciPy +(special, linalg) +""" + +from scipy._lib.deprecation import _deprecated +from scipy._lib._finite_differences import _central_diff_weights, _derivative +from numpy import array, frombuffer, load + + +__all__ = ['central_diff_weights', 'derivative', 'ascent', 'face', + 'electrocardiogram'] + + +@_deprecated(msg="scipy.misc.central_diff_weights is deprecated in " + "SciPy v1.10.0; and will be completely removed in " + "SciPy v1.12.0. You may consider using " + "findiff: https://github.com/maroba/findiff or " + "numdifftools: https://github.com/pbrod/numdifftools") +def central_diff_weights(Np, ndiv=1): + """ + Return weights for an Np-point central derivative. + + Assumes equally-spaced function points. + + If weights are in the vector w, then + derivative is w[0] * f(x-ho*dx) + ... + w[-1] * f(x+h0*dx) + + .. deprecated:: 1.10.0 + `central_diff_weights` has been deprecated from + `scipy.misc.central_diff_weights` in SciPy 1.10.0 and + it will be completely removed in SciPy 1.12.0. + You may consider using + findiff: https://github.com/maroba/findiff or + numdifftools: https://github.com/pbrod/numdifftools + + Parameters + ---------- + Np : int + Number of points for the central derivative. + ndiv : int, optional + Number of divisions. Default is 1. + + Returns + ------- + w : ndarray + Weights for an Np-point central derivative. Its size is `Np`. + + Notes + ----- + Can be inaccurate for a large number of points. + + Examples + -------- + We can calculate a derivative value of a function. + + >>> from scipy.misc import central_diff_weights + >>> def f(x): + ... return 2 * x**2 + 3 + >>> x = 3.0 # derivative point + >>> h = 0.1 # differential step + >>> Np = 3 # point number for central derivative + >>> weights = central_diff_weights(Np) # weights for first derivative + >>> vals = [f(x + (i - Np/2) * h) for i in range(Np)] + >>> sum(w * v for (w, v) in zip(weights, vals))/h + 11.79999999999998 + + This value is close to the analytical solution: + f'(x) = 4x, so f'(3) = 12 + + References + ---------- + .. [1] https://en.wikipedia.org/wiki/Finite_difference + + """ + return _central_diff_weights(Np, ndiv) + + +@_deprecated(msg="scipy.misc.derivative is deprecated in " + "SciPy v1.10.0; and will be completely removed in " + "SciPy v1.12.0. You may consider using " + "findiff: https://github.com/maroba/findiff or " + "numdifftools: https://github.com/pbrod/numdifftools") +def derivative(func, x0, dx=1.0, n=1, args=(), order=3): + """ + Find the nth derivative of a function at a point. + + Given a function, use a central difference formula with spacing `dx` to + compute the nth derivative at `x0`. + + .. deprecated:: 1.10.0 + `derivative` has been deprecated from `scipy.misc.derivative` + in SciPy 1.10.0 and it will be completely removed in SciPy 1.12.0. + You may consider using + findiff: https://github.com/maroba/findiff or + numdifftools: https://github.com/pbrod/numdifftools + + Parameters + ---------- + func : function + Input function. + x0 : float + The point at which the nth derivative is found. + dx : float, optional + Spacing. + n : int, optional + Order of the derivative. Default is 1. + args : tuple, optional + Arguments + order : int, optional + Number of points to use, must be odd. + + Notes + ----- + Decreasing the step size too small can result in round-off error. + + Examples + -------- + >>> from scipy.misc import derivative + >>> def f(x): + ... return x**3 + x**2 + >>> derivative(f, 1.0, dx=1e-6) + 4.9999999999217337 + + """ + return _derivative(func, x0, dx, n, args, order) + + +@_deprecated(msg="scipy.misc.ascent has been deprecated in SciPy v1.10.0;" + " and will be completely removed in SciPy v1.12.0. " + "Dataset methods have moved into the scipy.datasets " + "module. Use scipy.datasets.ascent instead.") +def ascent(): + """ + Get an 8-bit grayscale bit-depth, 512 x 512 derived image for easy use in demos + + The image is derived from accent-to-the-top.jpg at + http://www.public-domain-image.com/people-public-domain-images-pictures/ + + .. deprecated:: 1.10.0 + `ascent` has been deprecated from `scipy.misc.ascent` + in SciPy 1.10.0 and it will be completely removed in SciPy 1.12.0. + Dataset methods have moved into the `scipy.datasets` module. + Use `scipy.datasets.ascent` instead. + + Parameters + ---------- + None + + Returns + ------- + ascent : ndarray + convenient image to use for testing and demonstration + + Examples + -------- + >>> import scipy.misc + >>> ascent = scipy.misc.ascent() + >>> ascent.shape + (512, 512) + >>> ascent.max() + 255 + + >>> import matplotlib.pyplot as plt + >>> plt.gray() + >>> plt.imshow(ascent) + >>> plt.show() + + """ + import pickle + import os + fname = os.path.join(os.path.dirname(__file__),'ascent.dat') + with open(fname, 'rb') as f: + ascent = array(pickle.load(f)) + return ascent + + +@_deprecated(msg="scipy.misc.face has been deprecated in SciPy v1.10.0; " + "and will be completely removed in SciPy v1.12.0. " + "Dataset methods have moved into the scipy.datasets " + "module. Use scipy.datasets.face instead.") +def face(gray=False): + """ + Get a 1024 x 768, color image of a raccoon face. + + raccoon-procyon-lotor.jpg at http://www.public-domain-image.com + + .. deprecated:: 1.10.0 + `face` has been deprecated from `scipy.misc.face` + in SciPy 1.10.0 and it will be completely removed in SciPy 1.12.0. + Dataset methods have moved into the `scipy.datasets` module. + Use `scipy.datasets.face` instead. + + Parameters + ---------- + gray : bool, optional + If True return 8-bit grey-scale image, otherwise return a color image + + Returns + ------- + face : ndarray + image of a raccoon face + + Examples + -------- + >>> import scipy.misc + >>> face = scipy.misc.face() + >>> face.shape + (768, 1024, 3) + >>> face.max() + 255 + >>> face.dtype + dtype('uint8') + + >>> import matplotlib.pyplot as plt + >>> plt.gray() + >>> plt.imshow(face) + >>> plt.show() + + """ + import bz2 + import os + with open(os.path.join(os.path.dirname(__file__), 'face.dat'), 'rb') as f: + rawdata = f.read() + data = bz2.decompress(rawdata) + face = frombuffer(data, dtype='uint8') + face.shape = (768, 1024, 3) + if gray is True: + face = (0.21 * face[:,:,0] + + 0.71 * face[:,:,1] + + 0.07 * face[:,:,2]).astype('uint8') + return face + + +@_deprecated(msg="scipy.misc.electrocardiogram has been " + "deprecated in SciPy v1.10.0; and will " + "be completely removed in SciPy v1.12.0. " + "Dataset methods have moved into the scipy.datasets " + "module. Use scipy.datasets.electrocardiogram instead.") +def electrocardiogram(): + """ + Load an electrocardiogram as an example for a 1-D signal. + + The returned signal is a 5 minute long electrocardiogram (ECG), a medical + recording of the heart's electrical activity, sampled at 360 Hz. + + .. deprecated:: 1.10.0 + `electrocardiogram` has been deprecated from + `scipy.misc.electrocardiogram` in SciPy 1.10.0 and it will be + completely removed in SciPy 1.12.0. + Dataset methods have moved into the `scipy.datasets` module. + Use `scipy.datasets.electrocardiogram` instead. + + Returns + ------- + ecg : ndarray + The electrocardiogram in millivolt (mV) sampled at 360 Hz. + + Notes + ----- + The provided signal is an excerpt (19:35 to 24:35) from the `record 208`_ + (lead MLII) provided by the MIT-BIH Arrhythmia Database [1]_ on + PhysioNet [2]_. The excerpt includes noise induced artifacts, typical + heartbeats as well as pathological changes. + + .. _record 208: https://physionet.org/physiobank/database/html/mitdbdir/records.htm#208 + + .. versionadded:: 1.1.0 + + References + ---------- + .. [1] Moody GB, Mark RG. The impact of the MIT-BIH Arrhythmia Database. + IEEE Eng in Med and Biol 20(3):45-50 (May-June 2001). + (PMID: 11446209); :doi:`10.13026/C2F305` + .. [2] Goldberger AL, Amaral LAN, Glass L, Hausdorff JM, Ivanov PCh, + Mark RG, Mietus JE, Moody GB, Peng C-K, Stanley HE. PhysioBank, + PhysioToolkit, and PhysioNet: Components of a New Research Resource + for Complex Physiologic Signals. Circulation 101(23):e215-e220; + :doi:`10.1161/01.CIR.101.23.e215` + + Examples + -------- + >>> from scipy.misc import electrocardiogram + >>> ecg = electrocardiogram() + >>> ecg + array([-0.245, -0.215, -0.185, ..., -0.405, -0.395, -0.385]) + >>> ecg.shape, ecg.mean(), ecg.std() + ((108000,), -0.16510875, 0.5992473991177294) + + As stated the signal features several areas with a different morphology. + E.g., the first few seconds show the electrical activity of a heart in + normal sinus rhythm as seen below. + + >>> import numpy as np + >>> import matplotlib.pyplot as plt + >>> fs = 360 + >>> time = np.arange(ecg.size) / fs + >>> plt.plot(time, ecg) + >>> plt.xlabel("time in s") + >>> plt.ylabel("ECG in mV") + >>> plt.xlim(9, 10.2) + >>> plt.ylim(-1, 1.5) + >>> plt.show() + + After second 16, however, the first premature ventricular contractions, also + called extrasystoles, appear. These have a different morphology compared to + typical heartbeats. The difference can easily be observed in the following + plot. + + >>> plt.plot(time, ecg) + >>> plt.xlabel("time in s") + >>> plt.ylabel("ECG in mV") + >>> plt.xlim(46.5, 50) + >>> plt.ylim(-2, 1.5) + >>> plt.show() + + At several points large artifacts disturb the recording, e.g.: + + >>> plt.plot(time, ecg) + >>> plt.xlabel("time in s") + >>> plt.ylabel("ECG in mV") + >>> plt.xlim(207, 215) + >>> plt.ylim(-2, 3.5) + >>> plt.show() + + Finally, examining the power spectrum reveals that most of the biosignal is + made up of lower frequencies. At 60 Hz the noise induced by the mains + electricity can be clearly observed. + + >>> from scipy.signal import welch + >>> f, Pxx = welch(ecg, fs=fs, nperseg=2048, scaling="spectrum") + >>> plt.semilogy(f, Pxx) + >>> plt.xlabel("Frequency in Hz") + >>> plt.ylabel("Power spectrum of the ECG in mV**2") + >>> plt.xlim(f[[0, -1]]) + >>> plt.show() + """ + import os + file_path = os.path.join(os.path.dirname(__file__), "ecg.dat") + with load(file_path) as file: + ecg = file["ecg"].astype(int) # np.uint16 -> int + # Convert raw output of ADC to mV: (ecg - adc_zero) / adc_gain + ecg = (ecg - 1024) / 200.0 + return ecg diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/misc/ascent.dat b/env-llmeval/lib/python3.10/site-packages/scipy/misc/ascent.dat new file mode 100644 index 0000000000000000000000000000000000000000..f3602460a5170a78ef09b038171853ce8e76fca7 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/misc/ascent.dat @@ -0,0 +1,749 @@ +€]q(]q(KSKSKSKSKSKSKSKRKRKRKRKRKRKRKRKRKRKSKSKSKSKSKSKSKRKRKRKRKRKRKRKRKRKUKVKUKUKUKVKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKTKUKVKUKUKUKUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKYK[KZK[KZKZKZKZK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[KZKZKZKZKZKZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K_K_K`K]K\K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKaKaKaKcKeKdKdKdKdKeKbK^KOKQKRKTKRKVKTKVKNKRKMKOKIKPKYKXKRKPKUK`KjK[KSKRKUK9K!K$K%K&K&K'K*K0K K +K KKKKKCKBKAKEK*KKKK!K)K-K(K)K-K+K"KKKK8KBKK9K2K/K/K+K"KKK!K/K0K$K+K3K5K4K?KGKAK;K9K-K+K+K+K$K8KGKFKFKFKFKFKFKFKFKFKFKGK6KK$KBKIKJKJKHKHKAK9K=K=K=KKKHKFKFKFKFKFKFKFKGKFKGKHK2KK*KEKFKHKIKHKGK?KKdKsKrKtKsKsKsKsKsKsKsKsKsKsKuKuKsKtKuKtKsKtKtKtKtKvKtKsKsKsKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKue]q(KPKQKSKSKSKSKSKRKRKRKRKRKRKRKRKRKRKSKSKSKSKSKSKSKRKRKRKRKRKRKRKRKRKUKVKUKUKUKUKUKUKUKUKUKVKTKUKVKUKUKUKUKUKUKWKXKUKUKUKUKUKUKUKWKWKUKVKXKWKWKUKVKWKWKWKWKWKXKXKWKWKWKWKWKWKWKWKWKWKWKWKZK[K[KYKWKWKWKZKZKZKZK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKYKZKZKZKZKZKZKZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKdKeKdKdKdKdKeKcKaKcK^KNKTKTKVKQKVKTKSKQKUKOKTKIKCKVKZKYKMKCKJKNKVKUKSKPK*K$K&K%K!KKKKK K +K +KKKK?KAK@KK=K;K;K?K?K=KK.K-K+K)K KKKK'K'K&K%K)K$K K"K%K%K1K>K(K)K)K+K"KKKK0KDKDKFKGKFKFKFKFKFKGKFKFKFK)KK4KFKGKIKHKFKEK@K;KK=K=K=KK=KK:K:K9KK?K=KK?K=K=K=K;K4K*K,K0K4K8K7K5K4K3K1K0K/K0K4K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K1K6KYKrKtKsKsKsKsKsKsKsKsKsKsKsKtKvKvKvKuKuKsKtKvKtKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKue]q(KSKRKSKSKSKSKSKSKSKSKSKSKSKSKRKRKRKRKRKRKSKUKTKRKSKRKSKSKUKUKTKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKVKUKVKTKVKUKUKUKUKUKUKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKUKUKXKWKWKXKWKXKYK[KYKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[KZKZKZKZKZKZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K_K]K\K\K\K\K]K]K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKbKaKdKdKeKcKbKdKeKdKdKeKcKbKbKXKOKQKWKWKTKVKUKWKSKWKRKVKLKMKLKPKDKNKSK]KhKPKVKVKBK!K&K%K&KK K K +K KKK K K KKKKKKKK K KKKKKKKKKKKKKKKKKKKKK KKKKKKKKKKKKK#K)K'K)K&KKKKKKKKKKKKKKK1K/K(K+K(K%KKKKKKKKKKKKKK#K/K)K'K)K)K&KKKKKKK1KGKGKGKFKFKFKFKFKFKGKFKHKBK!KK:KHKHKIKIKGKCK?K;K=K=K=K=K>K>K=KK;KK?K=KKK?K=K=KK?K>K>K>K>KKHKHKHKIKGKBKK>KK>K>K?K>K=K;K=K>K4K'K.K2K5K5K8K6K5K2K/K*K*K,K$K0K2K2K4K3K3K3K3K3K3K3K3K3K3K3K3K3K2K0KHKlKtKsKsKtKuKtKtKtKtKuKuKuKuKuKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKuKuKuKuKuKuKuKuKue]q (KSKSKSKSKSKSKSKSKSKSKSKSKSKSKRKTKVKTKRKRKSKVKVKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKWKXKXKXKWKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZK[K[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[KZKZK\K]K\K\K]K\KZK\K]KZKZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K\K\K]K`K`K`K]K\K\K]K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKcKeKdKeKeKeKdKdKdKdKdKdKdKeKdKaK`KUKSKUKYKWKWKYKWKVKUKVKTKZKRKVKLKGKWKDKMKIKBKTKSKNK(K"K%K&K!K K +K +K K +K +KKK K +K K K K K KKKKK K K K K K K K K K K K K K K K K K K K K K +K K +KK K K K K KKKKKKKKK K K K K K K K K K KKKKKKKKKK K K K K K K K K KKKKKKKKKKKKK K KKKKKKKK%KDKGKFKFKFKFKFKGKFKGKIKHKGK3KK#KEKGKHKHKHKIKBK:KKK?K?K>KK=K>K?K>KK=KK?K=KKK?K=KK?K=K=K>K>K>K>K>K>K>K?K>K=K5K+K2K6K3K4K6K5K1K2K/K*KKKK2K6K2K4K4K5K5K4K3K3K4K4K4K3K3K4K4K3K0KK?K=K=K>K?K?K?K>K?K?K?K>KK>K>K>K>K>K>K>K>K?K>KK3K*K0K/K4K7K8K5K3K2K0K+KKKK,K4K4K3K4K5K3K3K3K3K3K3K3K3K3K4K4K4K3K9KYKrKsKrKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKue]q(KSKSKSKSKSKSKSKRKSKSKTKVKUKUKSKTKVKUKVKVKVKUKUKUKUKUKUKUKTKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKVKVKVKUKVKXKWKVKVKVKWKWKWKWKWKVKVKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KYKWKZKZKXKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[KZKZK\K\K[K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K^K]K]K]K]K]K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKaKbKbKcKeKdKdKdKdKdKdKdKdKdKdKdKeKdKaKXKTKRKXKYKWKXKWKYKTKWKWKYKXKXK[KPKWKXK^KdKJKTKTKQK,K$K&K&K"KK&K'K(K'K'K)K%K$K'K'K'K'K(K&K&K&K&K&K%K$K&K&K$K$K$K#K"K"K"K"K!K K K K K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK KKKKKKKKKKKKKKK$KDKFKGKGKFKFKGKFKHKHKFKFKGK>K?KAKEKGKJKKKIKFKFK=K;K=KK?K>K>K>K?K?K?K>K?K>K=K=KKYK\KXKWKWKXKTKXKXKXKXKWK[KRKXKYKcKdKVKUKUKNK)K%K&K'K#K K&K%K&K&K$K&K'K#K%K&K%K%K%K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K&K'K'K'K'K'K&K$K$K#K$K$K$K$K$K$K$K"K!K!K!K K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK-KEKFKGKGKFKFKGKHKHKFKGKIKHKFKEKFKFKFKIKIKHKKKFK>K=K=KK?K?K?K?K=KK?K>K>K?K>K=KK>K>K>K>K=KK?K>K>K?K=K;KK>K5K,K0K4K7K7K5K4K2K0K2K-KKKK-K3K4K4K5K5K5K3K4K4K4K4K5K4K4K3K3K3K3K4KPKoKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKwKwKyKwKuKuKuKwKwKxKyKxKwKwKvKvKwKwKwKvKuKwKwKuKuKuKuKuKuKue]q(KRKRKRKRKRKSKSKRKSKVKUKUKUKUKUKWKUKTKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKXKWKXKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZKZKWKWKWKZK[KZK[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K\K\K\K\KZKZK]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K`K_K]K\K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKaKaKaKaKaKbKeKbKaKdKdKdKdKdKdKdKdKdKeKdK]KRKMKGK[KYKTKYKWKXKTKWKSKXKXKVK\KVKXK^KlKaKUKUKWKBK#K&K&K'K"K#K%K$K&K'K'K&K%K'K%K%K%K%K%K&K&K&K&K%K%K%K%K%K%K&K%K&K&K&K&K&K&K&K&K&K&K&K%K&K&K&K&K%K'K&K%K#K#K#K#K#K#K$K&K$K#K#K#K#K#K$K#K#K%K&K#K$K&K%K#K$K$K!K%K$K$K$K$K$K$K$K$K$K$K&K#K$K$K!K"K"K"K#K#K#K#K#K#K#K#K!K K!K!K!KKKKKKKKKKK;KDKDKFKHKFKFKGKIKIKIKGKFKFKGKGKCKFKIKIKHKHKGKDK?KK>KK?K?K?K>K>K?K=KK=K>K>K>K?K?K>K>K>K=K=K5K-K2K2K4K6K8K6K4K2K2K-KKKK-K4K5K4K4K5K5K5K4K4K3K3K3K3K3K3K3K3K3K3KJKmKsKsKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKuKuKvKvKuKuKuKwKxKyKxKvKvKvKwKwKuKwKyKxKwKxKwKuKuKuKwKxKxKwe]q(KVKUKRKUKVKSKSKVKVKUKUKUKUKUKVKVKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKXKVKUKWKWKUKUKUKUKUKUKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKXKWKYK[KZKZK[KZKWKYK[KXKWKWKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K]K\K\KZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K_K_K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKaKcKeKdKeKeKeKeKdKdKdKeKdKdKdKdKdKdKdKdKdKeKdK[KOKPKVK[K\KWK[KZK[KXKYKWK\K[KYKWKUKYKaKnK\KUKUKUK.K#K'K&K$K'K=KBKHKKKKKK)KK8K/K1K1K7K1K,K-K-K.K(K%K'K$K*K0K.K.K.K.K.K.K-K*K+K(K'K'K%K&K%K%K&K&K%K#K$K%K$K$K$K$K%K$K%K$K#K#K#K$K$K$K$K#K%K&K$K$K$K$K$K$K$K$K$K$K$K#K$K$K$K$K$K$K$K$K$K#K$K$K$K$K$K$K$K#K#K#K#K$K#K!K!K*KDKGKDKGKIKHKIKHKIKGKFKHKHKFKHKBKAKEKHKIKLKJKHKEK>KK>K>K>K>K?K?K?K>KK6K-K/K4K6K8K6K5K3K2K2K.KKKK-K4K4K4K5K5K5K5K5K3K3K3K3K3K3K3K3K3K2K2KEKhKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKyKxKwKuKuKuKxKxKuKwKxKxKxKyKxKuKuKuKwKyKyKxe]q(KUKUKUKUKVKUKUKVKVKVKVKVKVKVKUKUKUKUKVKVKVKVKTKUKWKUKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKXKVKUKWKWKWKWKWKWKWKWKXKWKWKXKWKVKWKWKWKWKWKWKWKWKWKXKXKWKYK[KXKWKZKZKWKYK[KZKZKWKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K[K[K\K\KZKZK[KZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K_K]K\K\K]K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K_K_K_K_K_K_K_KaKaK_K_K_K_K_KaKaK`K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKXKPKSKVK\K[KWK[KYK[KWKYKZK]KYKZKZKYKZKfKkKXKTKVKQK&K$K&K&K$K+K>KBK?KKKKKK,K;K7K5K9K5K+K+K$K7KIKDKDKCKIK;K7K8K;KBKKGKEKJKJKLKKK:K.K0K2K5K,K&K#K#K+K,K-K-K0K6K7K6K5K5K/K(K(K&K%K'K&K&K%K$K%K%K&K'K#K$K#K"K"K"K$K$K!K!K#K$K$K$K$K#K#K$K#K!K#K#K#K$K#K#K$K$K$K#K K"K$K#K$K K2KGKGKFKHKIKIKIKIKHKHKGKFKFKFKGKCKCKDKHKMKKKKKJKCKK?K?K>K>K>K?K>K=K=K=K>KK>K>K>K>K>K?K>K=KK5K/K4K5K6K7K7K4K3K2K1K-KKKK+K7K6K4K3K4K5K4K4K3K3K3K4K4K3K3K3K2K4K2K>KdKuKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKuKuKuKxKxKxKwKvKxKyKxKwKuKvKvKvKvKxKxKyKwKvKvKuKvKvKuKuKuKwKyKvKve]q(KVKVKUKVKVKVKVKVKVKVKVKVKVKVKTKUKVKUKVKVKVKUKUKUKUKVKVKVKUKVKXKVKUKUKUKUKVKXKWKWKWKWKXKXKXKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K]KZKZKZKZKZKZKZK\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K\K\K`K_K\K^K`K_K_K_K_K_K_K_K_K_K_K_K`K^K\K_K`K_K_K_K_K_K_K_KaKaK_K_K_K_K_KaKaK_K_K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKaKcKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKbKUKTKYK\K^K\KWK[KXKXKVKYKYK^KXKZKZKWK]KoKhKUKVKXKIK"K&K&K&K#K3KK>K@K9KEKHKJKKKPKQKLK:K3K6K8K7K)K&K!K)K4K4K4K5KHKSKVKQK\KUKAK4K0K0K+K.K'K#K$K,K-K/K+K1KMKWKXKYKWKRK8K-K+K+K)K$K#KK'K+K*K)K&K=KDKCKCK@K=K7K%K!K!K"K KK"K%K%K%K"K%KK>K?K?K?K?K?K>KK?K>KKHKGKJKLKKKIKAK>K?K>K=K=K?K>K=K>K>K?K>K>K=K>K?K=KK6K-K2K5K6K7K9K8K3K1K/K,KKKK)K2K1K4K5K4K4K5K5K5K3K3K2K3K4K3K3K4K5K5K:K]KtKuKuKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKwKuKvKwKwKwKvKvKwKwKyKwKwKwKwKxKxKxKwKwKxKxKuKvKwKwKwKwKwe]q(KRKSKVKUKUKUKUKUKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKWKWKUKUKUKUKUKUKUKUKUKUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZKZKWKWKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K`K_K\K\K\K\K\K_K`K_K_K_K_K_K_K_K_K_K_K_K`K_K_K_K_K_K_K_K_K_KaKaK_K`KbKaKbKaKaKbKbKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKcK`KTKRKXK\K_K[KWK[KZK[KVKYK\KaK[K]K]KXK`KpKaKVKVKXKK>KFK!KKKKK%K:K9K:K3K8K,K,K$K1KEKCKBK@KGKAK6K8K9K=K?K;K6K4K6K/K#K'K#K1K?K?KBKAKDKDKPKRKTKQKCK-K.K3K:K2K(K%K"K.K4K5K3KK=KK?K?K>KK?K>K?K?K?K?K=KK>KK5K/K2K3K6K8K7K5K5K2K0K.KKKK*K2K4K5K5K5K4K4K5K3K2K2K3K5K4K2K4K5K5K3K7KYKqKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKyKyKvKuKuKvKxKxKxKxKyKyKxKuKvKyKvKuKuKue]q(KTKUKUKUKUKUKUKVKVKVKUKUKTKVKVKUKVKTKSKUKUKUKUKUKUKUKWKWKUKVKWKVKUKWKWKUKUKUKVKXKVKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKYKYKYKYKZKZKWKWKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K\K[KZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K_K_K_K^K^K^K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKbKaKaKaKaKbKbKcKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKcKbKdKdKcK^KRKSKXK\K^K]KXK[K[KZKWK[K\K`K[K]K\KYKcKqK_KVKVKXK5K"K&K'K$K2K>K?K?KKKKKK(K9K9K;K;K4K-K-K#K4KGKCKCK@KFK=K8K9K;K?K>K8K6K4K6K.K&K(K%K6K=KAK?K@KHKGKQKTKUKIK:K-K2K3K7K*K(K"K%K2K3K4K4KCKTKTKYK\KWKJK7K,K-K1K/K(K#K K,K.K/K-K1KKKSKUKWKRKPK:K+K/K0K-K'K"KK$K/K-K+K(KCKKKLKPKOKKKEK+K$K#K$K KK K(K+K+K)K4KOKQKSKTKJKFKHKIKHKHKHKHKHKHKHKIKJKEK)KK)KDKHKLKLKKKGKEKAK>K>K=K>K?K=K>K>K?K?K>K=K=K?K>K>K>K>K>K?K>K3K.K2K6K5K6K8K7K4K4K1K.KK KK'K4K4K4K5K4K4K5K3K2K2K3K3K4K4K5K5K3K4K3K5KWKsKwKuKuKuKuKuKuKuKuKvKxKwKuKuKuKuKvKxKwKxKvKuKwKxKwKwKwKxKwKuKvKyKwKvKvKuKwKxKxKxKxKxKxKxKxKwKxKxKxKwKwKxe]q(KVKUKUKUKUKUKUKVKVKVKUKUKSKVKVKUKUKVKVKUKUKUKUKUKUKUKWKWKUKVKXKVKUKWKWKUKUKUKVKXKVKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KZK[K[KZKZKZKWKWKWKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K]K\KZK\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K_K_K`K`K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbKaKaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKaKaKaKaKaKcKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKdKdKcK]KQKSKXK\K^K^KYK[K[KZKXK\K\K`K[K^K\KZKfKpKZKVKXKUK.K"K&K'K"K5KK=KK?K?K?K>K?K>KK?K>K?K@K=K1K.K4K4K6K8K7K4K3K0K1K.KKKK)K2K4K5K4K4K5K3K2K3K3K2K4K5K5K5K3K3K5K4K5KSKsKvKvKuKuKuKuKuKuKvKyKwKuKuKuKuKvKyKxKyKvKuKxKyKyKyKyKyKyKvKvKyKwKuKuKuKxKyKxKxKxKxKxKxKxKyKxKxKxKyKyKye]q(KUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKVKUKUKUKUKUKUKUKWKWKUKUKUKUKUKWKWKWKWKUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZKZKWKYK[KZKZKXKWKWKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaK_K`KbK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKgKeKdKcK\KRKVKZK\K^K[KXK[KZKZKVKZK^K`K[K^K\K[KjKnKXKWKXKQK)K%K)K'K%K9K=KBK7KKKKKK3KKCKEK@KFKFK9K:K:K@K=K4K.K2K5K4K(K)K'K*K?KBKBK=KFKLKPKTKXKUKEK3K2K4K9K4K(K'K"K-K3K3K0K9KQKTKXK[KZKMK>K6K3K2K2K+K$K"K)K.K.K,K,KAKSKUKVKTKSKIK/K/K0K.K(K#K K!K+K+K+K(K9KLKMKNKNKLKPK7K%K$K$K$KKK(K+K+K*K-KIKMKVKWKVKYKNKGKIKIKIKHKHKHKHKHKHKIKHKIKEK$KK3KFKGKJKIKIKGKDK@KK?K?K?K?K?K>K>K>K>K?K>K>K?K>K>K?KAK=K2K,K1K3K5K7K8K6K2K2K/K/KKKK(K5K3K2K4K5K5K4K3K3K3K3K3K4K5K3K3K3K3K3K2KNKrKwKuKvKuKuKuKtKwKuKwKyKvKuKuKuKuKvKuKwKxKxKxKxKxKxKxKxKxKxKuKwKxKxKxKxKxKyKwKuKwKyKxKxKxKxKxKxKxKxKxe]q(KUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKWKWKVKVKVKVKVKWKWKWKWKVKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZKYKWKYK[KZKZKXKXKXKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[KZKZKZK[K[K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K\K^K`K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaK`K`KbK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKfKeKdKcKZKRKTKZK\K^K\KYK[KZKZKVKZK_K`K[K_K[K[KjKlKWKWKXKLK&K&K)K&K&K-K8KFK/KKKKKK4K6K6K8K4K0K.K(K+K?KAKEKAKEKDK6K:K;K?KKGKJKQKUK\KRKAK3K3K4K9K/K%K&K#K-K3K3K2K@KSKUKYK\KYKJKKKKHKHKHKHKHKHKHKHKHKIKHKKKAKKK8KHKIKIKIKJKMKEK=KK>K>K>K>K>K?K?K?K>K?K>K>K?K>K>K>K>K?K=K1K+K0K5K7K7K8K6K4K2K0K-KKKK'K0K3K4K5K5K5K3K3K3K3K3K4K5K3K3K3K3K3K2K1KJKpKwKuKuKuKuKuKvKuKvKxKwKvKvKvKvKvKvKxKyKxKxKxKxKxKxKxKyKxKvKwKyKxKxKxKxKyKwKvKwKyKxKxKxKxKxKxKxKxKxe]q (KUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKUKUKUKUKUKUKUKUKWKWKWKWKWKWKWKVKUKWKWKXKVKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKYK[KXKWKZKZK[KYKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\KZKZKZK\K]K\K\K]K\KZK\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K_K\K^K`K_K_K\K]K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaKaKaKbK`K_KaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKaKaKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKcKYKOKQK[K[K^K^KYK[K\KZKXK\K_K`K\K_KZK_KoKfKUKXKYKEK$K&K&K%KKK7KEK'KKKKKK2K7K9K4K5K.K.K&K/KAKDKDKAKGKCK9K;K>K=K;K9K4K4K8K/K#K$K"K4K@K?K?KBKKKOKVKYK[KNK2K.K3K3K6K-K&K"K'K.K2K3K4KHKRKYK^K^KMK@K4K.K2K6K0K%K#K$K-K/K.K,K5KMKTKVKUKSKNK7K.K0K,K(K"K!K K&K*K+K+K-KIKOKQKPKMKOK>K%K%K$K#KKK#K*K+K*K*KAKQKUK[K[KYKRK/K-KAKIKFKHKIKHKHKHKHKHKIKHKEKHKAKKKK?K>K>K>K>K>K>K>K>K>K?K>K>K>K;K1K/K3K5K4K7K8K4K4K2K0K.KK KK(K4K5K5K5K5K5K5K5K5K5K5K5K3K3K3K3K3K2K3K0KGKlKuKuKuKuKuKuKuKuKuKwKyKyKyKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKuKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q!(KUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKUKTKVKUKUKVKVKUKUKUKWKWKWKWKWKWKWKVKVKWKWKWKWKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKYKYKYKYKYKZKZKZKZKXKZKZKZKZKZKZKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K[K[K[K\K\K\K\K\K\K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K^K^K\K^K`K_K_K^K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`KaKaKaKaKaKaK`K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKcKcKcKcKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKeKdKdKdKdKdKdKWKPKRK^K\K^K\KYK[K\KZKXK\K^K`KZK^K[KaKpKfKVKWKYK?K"K'K'K"K&K5K=KCK KKKKK&K5K5K8K7K1K-K.K$K2KAKDKCK>KJK?K:K;K?K=K9K8K5K4K5K-K'K#K!K;K>K:K>KCKIKPKVKYKXKJK0K.K1K5K5K*K'K"K)K1K3K2K6KMKTKYK]KYKJK@K2K0K2K5K.K!KK&K-K/K.K+K;KOKTKUKTKSKLK2K.K.K+K'K"K!K"K(K*K+K(K6KMKQKQKQKLKQK6K%K&K&KKKK'K*K)K(K/KKKSKVKZKZKZKFK-K+K,KCKGKHKIKHKHKHKHKHKIKHKGKHKFK7KKK@KGKHKLKLKKKHKBK=K=K=K=KK?K>K>K>K>K>K>K>K>K>K>K>K>K>K?K=K/K.K4K5K7K8K7K7K3K1K1K0K KKK%K2K5K5K5K5K5K5K5K5K4K4K2K4K4K4K4K3K4K3K1KCKjKxKuKuKuKuKuKuKuKwKxKwKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q"(KVKVKVKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKXKWKUKUKUKWKWKWKWKWKWKWKWKXKWKWKWKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KYKWKZK[KZKZK[K[K[KZKZKZKZKZKZKZK\KYKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K\K]K]K\K\K\K\K\K\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K_K\K\K\K^K`K_K_K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbKaKaKaKaKaKaKbKbKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKcKeKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKfKdKdKdKdKdKbKTKNKRK]K\K^KZKXK[K\KZKXK[K^K`KXK]K[KbKqKbKUKXKYK7K!K'K(K K-KK2K.K1K3K+K#KK*K+K"K(K-KGKOKSKVKTKSK@K.K/K,K,K&K#K!K$K+K+K+K)KCKOKQKQKPKNKLK,K%K&K$KKK!K)K*K)K)K9KPKUKXKZK[KWK9K.K)K"K/KFKIKHKHKHKHKHKHKHKIKHKJKFKEK4KK KBKGKHKLKLKKKHKDKK?K>K>K>K>K>K>K>K>K>K>K>K>K?K>K>K:K1K0K2K4K5K8K8K5K4K2K.K/KKKK'K3K2K2K5K5K5K5K5K3K2K2K2K2K3K5K5K5K3K4K2KBKgKwKuKuKuKuKuKuKwKxKuKuKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q#(KVKVKVKUKUKUKUKUKUKUKUKUKUKUKVKUKUKVKUKUKUKVKVKWKVKUKWKWKVKVKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKYKZKZKZKYKZKZKZKZKXKYKZKZKZKZKZKZKZKZK[KZKZKZKZKZKZKZKZKZK[K\K[KZKZKZK\K\K\K\K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K_K]K]K\K\K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaK`K_KaK`K_K`KaKaKaKaKaKaKaKaKbKbKaKaKaKaKaKaKaKaKaKaKaKaKcKdKcKcKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKfKeKdKeKcK`KRKNKRK]K^K`KZKXK[K]KYKZK\K^KaK[K]K[KiKrK^KUKXKXK0K$K(K'K#K.K9K?K;KKKKKK-K9K5K6K4K*K.K*K$K?KEKAK?KAKHK:K9K;K?K=K7K7K8K6K-K'K*K#K,KAK:K1K@KJKHKRKYKZKUK;K.K3K0K6K1K(K#K$K1K3K4K3K@KTKSKZK[KOKBK5K0K1K5K2K(K$K"K)K$KK&K1KMKQKTKUKQKLK3K.K-K*K)K#K KK%K+K+K*K/KOKPKSKSKOKPKBK%K'K$K"KKK$K)K&K%K)KFKTKUKXKYK\KNK1K,K$K#K#K4KIKHKHKIKHKHKHKHKHKHKIKIKGKFK/KK#KCKGKIKKKLKKKIK?K>K>KK?K@K@K>K>K>K>K>K>K>K>K>K>K>K>K>K@K>K1K/K3K4K5K6K7K8K6K2K/K-KKKK$K2K3K3K4K5K5K5K4K4K5K3K1K2K3K3K3K2K3K4K4K>KfKwKtKvKuKuKuKwKyKxKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q$(KVKVKVKUKUKUKUKUKUKUKUKUKUKUKUKVKUKUKUKUKUKUKVKXKVKUKWKWKUKUKUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKZKZKZK[KZKZK[KZKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K\KZKZKZK\K\K\K\KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K\K\K\K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbK`K_KbKaK_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKeKdKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKeKdKeKdK^KNKMKTK\K`K`KZKXK[K]KYK\K]K^KaK\K]K[KkKqKYKVKXKUK*K'K)K&K%K3K9K@K4KKKKKK.K4K5K9K7K,K/K(K*K?K?KCKBKDKDK9K:K;K@KBK8K2K8K8K0K$K*K#K2KAK>K=KAKIKJKVKZK\KVK8K.K1K2K9K.K&K$K&K2K3K2K5KHKTKTKZKVKMKAK3K0K5K7K.K#K K$K*K%K&K*K;KOKQKUKSKPKKK3K/K,K*K*K#K K!K)K+K+K(K7KOKRKSKQKLKOK2K"K!K#KKK K'K*K$KK0KOKUKXKXKYK^KAK(K*K$K$K"K#K:KIKHKHKIKHKHKHKHKHKIKHKIKJKHK*KK(KFKEKHKKKKKJKIKCK=KK>K=K>K?K>K>K>K>K>K>K>K>K>K>K?K>K?K@K>K1K/K2K4K6K8K9K7K5K2K2K.KKKK'K4K2K3K5K5K5K5K5K5K5K3K3K2K2K3K2K3K4K6K5K=KcKwKvKvKuKuKwKyKxKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q%(KUKUKUKUKUKUKUKUKUKUKUKUKUKUKVKVKVKUKUKUKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKYKZKZKZKXKXK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K]K\KZK\K\K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K\K\K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K_K_K_K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKcKdKbKaKaKbKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKeKdKeKdK^KOKLKRK\K_K`K\K[KZK\KYK[K\K^K`K\K^K^KmKpKVKWKYKPK&K(K)K$K#K4K9K@K.KKKKK K3K6K7K5K3K-K,K&K-K>K?KCKBKEKAK9K=K=KBK:K6K/K2K7K/K'K)K%K8K@K;K6KAKLKWK^K_K_KPK;K4K2K4K3K+K'K$K+K3K3K2K8KKKTKWKYKRKNK>K0K2K4K7K*K#K!K&K,K.K2K+KEKTKQKSKSKRKHK/K-K+K*K'K#KK%K*K.K-K'KBKRKRKPKOKNKNK(K#K#K$KKK%K)K)K)K'K:KTKVKYK]K\KVK2K+K(K$K$K$K#K'K?KJKHKHKIKIKHKIKHKIKIKIKHKJKEK&KK.KGKHKGKJKLKKKEK>K=K=K=KK>K>K>K>K>K>K>K>K>K>K>K>K?K?K:K/K-K4K4K5K6K8K7K3K2K2K,KKKK#K4K4K5K5K5K5K5K5K5K5K4K3K4K5K3K3K3K3K5K3KK9K>K>KBK8K5K2K5K5K+K'K(K'KK>K>K>K>K>K>K>K>K>K>K>K>K>K=K?K;K-K/K2K5K6K8K7K4K3K2K1K.KKKK%K3K4K4K5K5K5K5K5K5K4K3K4K5K3K3K3K2K/K2K4K9K\KuKwKuKwKxKxKxKvKvKvKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKvKwKyKxKxKxKxKxKxKxKxKxKxKxe]q'(KUKUKUKUKUKUKUKUKUKUKUKUKWKWKVKVKVKUKUKUKVKWKWKUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKYK[KXKWKWKWKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K]K\KZKZKZK\K\KZK[K]K\K\K\K\K\K\K]K[KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K_K\K\K\K^K`K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbKbKbKbK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbK`KaKeKeKeKeKeKdKdKdKdKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKgKfKdKVKLK?KOK]K]KbK]K\KYK[KYK\K]K^K^K^K[K_KsKhKVKWKXKAK!K(K)K%K*K6K;K>KKKKKK'K6K8K8K5K1K.K*K&K9KCKBK@K>KKK=K:K>K@KDK8K6K8K9K8K*K&K%K*KKKK7KHKGKHKKKLKJKDK@KK?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K?K?K>K9K2K/K1K5K8K8K8K5K5K1K/K/KKKK+K4K4K5K5K5K5K4K4K5K2K1K3K5K4K3K2K1K3K5K3K6KWKqKuKvKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q((KUKUKUKUKUKUKUKUKVKVKVKUKVKVKVKVKVKUKUKUKVKWKWKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKYKWKWKWKYK[KXKWKYKYKYKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[K[KZK\K\K\K\KZKZKZK\K\KZK[K\K\K\K\K\K\K\K\K\K[K\K\K\K\K\K\K\K]K]K\K\K\K\K\K^K^K^K^K^K^K^K^K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K`KaKaKaKaK`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKcKbKaKaKbKcKcKcKcKcKdKdKdKdKcKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKfKfKeKeKRKIK8KOK]K^K`K[K\KYK[KYK\K\K_K]K\KZKdKvKdKVKXKXKK?KDKGK;K;K=KAKAK8K9K9K;K/K%K'K%K-K:K9K:KBKPKVK\K\K[KSK;K2K/K6K4K,K(K"K(K5K4K4K7KGKTKWKZK\KQKBK1K0K3K7K.K!KK(K/K/K0K,K?KTKTKVKVKVKKK-K,K,K-K'K$K K!K)K.K+K'KBKSKSKRKQKOK?K'K$K#K%KKK%K)K)K)K'K?KVKVKZK[KYKVK.K,K)K%K#K"K"K$K!K!K"K3KHKKKIKIKHKHKJKLKKKJKIKIKGKKK;KKK;KGKGKJKLKIKIKFK?K>K?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K?KK9KKKKKK0K6K8K8K8K-K+K)K*K>KCKBK?KEKHK9K;K=KAKBK=K:K:K8K2K&K&K%K4K;K:K:KBKRKWK\K^K\KVK=K3K5K7K5K,K'K"K+K2K5K8K;KOKUKXKYKZKKK@K6K5K8K4K(K#K!K)K/K1K/K0KHKSKWKVKUKQK>K,K.K-K,K%K$KK$K*K+K'K+KHKQKRKRKSKQK9K$K#K#K%KKK%K)K)K(K,KLKVKUK[KXKZKGK.K/K'K$K$K$K#K#K K!K"K$KK>K?K?K>K?K>K>K>K>K>K>K>K>K>K>K>K>K>K?K?K>K:K.K.K3K4K5K5K5K5K4K2K0K-K,K(K+K/K3K5K5K5K5K5K5K5K3K2K3K3K2K3K5K3K3K3K3K2K3KOKqKwKxKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKxKxKxKxe]q*(KUKUKUKUKUKUKUKUKVKVKVKWKWKWKWKVKUKVKWKWKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKXKYKYKYKZKZKZKYKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[K[KZK[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K\K\K\K^K_K]K]K_K_K]K]K\K^K_K`K]K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaK`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKaKbKdKcKcKcKcKcKcKeKdKdKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKfKfKfKcKIKAK"KNK^K]K^KYK[KYK\KYK\K\K_K_KZKYKiKxK_KVKXKTK-K$K(K%K"K.K8K>K1KKKKKK3K5K6K5K5K/K+K&K+K@KCKCK?KGKCK7K;K=KBKDK;K:K8K5K.K%K%K%K7KK>K?K>K?K>K>K>K>K>K>K>K>K>K>K>K?K=K=K>K?K:K/K/K4K3K6K7K8K8K5K2K1K.K*K0K4K2K3K4K5K5K5K5K5K4K4K3K3K1K3K5K3K3K3K3K3K3K4KNKrKxKvKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKvKxKxKxKxe]q+(KVKUKUKUKUKUKUKUKUKUKTKTKWKXKXKWKUKWKXKYKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZK[K[KZKZK[K[K[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K\K\K\K\K\K\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K]K`K^K\K\K\K_K`K`K\K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbK`K_KaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKcKeKdKeKdKdKeKdKeKdKeKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKcKdKgKgKfK`KFK;KKPK]K\K]KYK[KYK\KYK\K\K_K^KZK\KmKtK\KWKYKOK(K%K'K$K K0K7K=K*KKKKK"K6K4K4K4K5K-K+K%K0KAKCKBK>KJK?K9K:K>KFK@K:K?K8K2K-K%K%K(K;K9K5K;KIKXK]K`KXKUKJK9K5K2K7K4K'K$K(K2K5K8K6KCKVKWK[K]K\KIK2K3K3K7K-K%K"K%K.K1K4K,KK=K?K>K?K>K>K>K>K>K>K>K>K>K>K>K?K=KK?K8K,K-K4K8K8K7K9K7K4K1K2K/K,K*K/K3K3K5K5K5K5K5K5K5K3K3K3K4K5K3K3K3K3K3K2K4K3KHKoKxKtKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKwKuKwKyKxKxe]q,(KUKUKUKUKUKUKUKUKUKUKUKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKYKWKWKWKWKWKZKZKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\KZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K\K\K\K\K\K\K\K]K`K]K\K_K_K\K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaK_K_K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKdKdKbKbKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKgKdK]K=KYK'KLK^K]K]KYK\KYK[KYK^K[KaK\K\K]KnKpKZKWKYKJK$K&K'K#K#K5K9K?K$KKKKK(K5K2K8K8K4K*K)K$K4KDK@KBKAKHKK7K6K'K&K$K/K;K8K8KK?K>K>K>K>K>K>K>K>K>K>K?K>K>K>K>K>K>K>K>K@K6K*K0K6K8K8K8K8K6K2K3K2K0K)K)K1K2K4K4K5K5K5K5K5K5K4K5K4K3K3K3K4K4K3K2K2K5K3KFKkKwKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q-(KVKVKUKVKVKUKUKVKVKUKUKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKYKXKXKWKXKXKZKYKXKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K_K^K]K_K_K]K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaK_K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKaKaKaKdKdKaKbKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKfKdK`KAKrKPKKK_K]K]KYK\KYK[KYK^K[KaK\K\K_KrKmKXKWKYKCK$K&K'K#K%K5K:K>KKKKKK*K1K3K8K8K1K*K(K%K;KCK?KAKBKGK:K:K=KCKEKK>K?K>K>K>K?K>K>K>K?K>K>K?K>K>K>K?K>K?K=KK?K;K>KBKDK8K=K?KGKFK9K8K:K6K.K$K'K%K8KK?K>K?K?K>K?K>K>K?K>K>K@K>K>K>K?K=K?K=KK:K-K-K3K7K8K8K8K6K2K3K1K/K-K-K0K2K3K4K6K5K5K5K5K5K4K2K3K3K3K3K3K3K3K3K2K5K2K=KeKwKuKuKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q/(KWKVKUKVKWKVKVKWKWKUKUKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KYKXKZKZKWKXKZKZKZKYKYKZKZKZKZKZKZKZKZKZKZKZKZK[K[KZKZKZKZKZK[K[KZKZKZKZKZKZKZK[K[KZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K]K\K\K\K\K]K^K^K]K_K_K_K_K_K_K_K_K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K`K`K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKdKaKbKcKcKcKcKcKbKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKeKfKUK]K[KPK…K`K\K]K]KYK\KYK\KYK]K[KaK]KZKbKtKfKWKXKXK6K$K(K&K#K*K5K:K4KKKKKK.K4K4K2K4K.K(K%K*KKCKJKBK:K=K;K9K.K#K&K'K;KK?K>K>K?K>K?K>K?K>K>K?K>K@K@K?K>K?K>K=K?K@K9K.K/K4K7K7K7K8K6K3K3K2K/K,K+K1K3K3K4K4K4K6K6K5K4K4K3K3K3K3K4K3K3K2K3K4K4K2K;KcKvKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q0(KUKUKUKUKUKUKUKWKWKUKUKUKWKWKWKWKWKWKWKUKUKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZK[K[K[KZKWKXK[KZK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K]K[KZKZKZKZKZKZKZKZKZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K_K_K_K_K_K_K`K]K\K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbKbKaK_K`KbK_K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKdKaKcKeKbKaKeKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKfKhKXKXK`KOKfK^K^K\K\KYK\KYK\KXK^K[KbK\KZKhKuKaKYKYKTK/K'K)K%K"K,K5K9K.KKKKK K3K4K2K6K3K(K'K%K-K>K?K;KK?K?K>K>K>K>K>K?K?K>K>K>K>K>K?K>K?K?K>K>K?K2K*K0K3K5K5K8K8K5K4K2K/K1K-K.K3K3K2K2K3K5K5K5K5K5K3K2K3K3K5K4K2K3K3K3K3K5K4K>K`KtKtKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q1(KUKUKUKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKXKWKWKXKYKZK[KYKXKZKZKYKYKXKYK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZKYKYKZKZKZKZKZK[K[KZK[K\K[KZK[KYK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K^K^K]K]K^K^K]K_K`K_K_K_K_K_K_K^K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaK`K_K`KaK`K`K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKcKcKdKdKdKcKbKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKfKfKeKeKhKcKXKTKcKQKTK`KYK[K^K[K]K[K]K[K^K[KaK]K[KkKsK^KZKYKQK)K(K)K&K$K1K5K:K&KKKKKK0K5K1K4K1K&K#K#K0K?K>K;K=KFK9K8K=KGKLK:KKFKGKIKLKLKIKBK>K@K?K>K?K>K>K?K>K=K>K?K>K?K>K>K>K>K>K?K>K>K8K)K,K,K3K5K6K6K7K6K3K1K1K0K-K1K0K1K3K4K2K3K3K4K5K4K4K3K3K5K4K4K3K3K3K3K3K4K3K8K[KtKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q2(KUKUKUKWKXKWKWKWKWKWKXKXKWKWKWKWKWKWKWKWKXKWKXKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KYKWKWKXKZKZK[KYKWKZK[K[KZKWKYK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZK[K[KZKZKZKZKZKZKZKZK[K]K\KZK\KYK\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K_K`K]K]K`K^K\K^K`K_K_K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbKaK_KaKbK`K_K_K`KbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKdKdKdKeKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKgKgKfKdKfKcK\KVKaKVKTK{KTK[K_K]K]K\K^K]K^KZKaK^K\KnKrK\KZK[KLK&K'K*K'K&K2K4K7K KKKKK%K6K3K2K1K,K'K$K#K7K=K=KKDK8K;KAKLKKK:K5K5K1K.K"K$K%K7K>K;KK;K9K8K(K"K%K4K8K8K5K=KTK^KaK`K_KMK3K0K0K0K,K#K"K&K0K3K4K.K?KTKYK[KYKWKAK,K*K*K)K&K#K K&K+K,K*K.KLKOKRKSKQKSK7K$K'K&K$KKK$K&K(K'K2KLKQKPKRKUKVK9K6K.K%K&K$K$K$K#KK#K%K#K\KwKsKsKsKsKsKsKsKtKfKPKJKKKLKLKLKKKLKLKHKJKLKKKIKIK/KKK@KCKDKGKLKLKIKDK?K>K?K>K>K>K>K?K?K?K>K>K>K>K>K>K>K>K?K>K=K;K;K6K&K)K5K5K5K8K7K4K3K3K1K/K-K(K2K4K2K3K3K2K4K5K5K5K3K3K5K5K5K3K3K3K3K2K2K3K2K6KWKuKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q3(KUKVKWKWKXKXKXKWKWKWKWKXKXKXKWKWKWKWKVKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKWKWKWKXKZKZK[KYKWKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K[KZKZKZKZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K]K_K_K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K_K_K`K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKaKcKeKdKdKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKfKeKdKdKeKfKfKfKgKdK]K[K\K^KHK~K\KWK]K\K]K\K^K\K^K\KaK]K_KpKoK[KZKZKFK$K)K)K#K%K1K7K8KKKKKK+K6K4K5K5K,K&K%K'K;K=K:K:K=K@K6K=KCKNKHK;K9K0K,K*K#K#K&KK?K>K?K>K>K?K?K?K>K>K>K>K>K>K>K>K>K>K>K>K?K?K4K)K-K2K5K5K6K8K5K5K3K3K0K)K&K$K!K-K3K2K3K5K5K5K3K3K5K4K3K4K5K5K4K3K3K3K5K4K5KYKuKvKuKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q4(KVKVKXKXKXKXKXKWKWKWKXKXKXKXKWKWKWKXKYKXKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKXKWKXKZKZKZKYKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZKZKZK[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K\K\K\K\K\K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKcKaKcKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKeKdKeKeKfKfKfKdK_KZK[K[KbKHKsKuKTK]K\K]K\K^K]K^K\KbK\K_KrKlKZKZKZKKK6K9K:KK>K?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K>K@K=K4K-K0K4K5K6K8K6K5K3K2K/K0K$KK KK1K3K2K5K5K5K3K3K5K4K3K4K5K5K4K3K3K3K4K5K2K3KPKrKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q5(KWKWKWKXKXKXKXKWKWKWKXKXKXKXKWKWKWKXKXKXKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KWKWKWKWKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZKZK[K]K\KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K_K\K\K\K\K\K\K]K_K_K`K]K\K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKdKeKbKaKdKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKeKdKfKfKfKfKeK\KTK]K_KWKaKOK`K}KUK]K\K]K]K\K^K\K]KdK]KbKqKfKZKXKYK5K#K&K&K"K(K2K6K/KKKKKK,K3K4K5K4K(K&K K+K;K9K8K7K?K8K6K@KJKRK=K;K8K1K1K'K"K#K/K=K9K;K;KLKVKQK_KhKVK@K9K:KK>K>K>K>K>K>K>K>K>K>K>K>K>K?K>KK?K>K5K-K2K3K4K5K7K8K4K4K1K0K-KK K K!K2K5K5K5K5K4K1K2K4K5K3K2K5K4K3K3K3K2K2K3K2K3KPKqKvKvKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q6(KWKWKWKWKXKXKXKWKWKWKWKXKXKWKWKWKWKWKWKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKXKWKXKXKYK[KYKXKYKYKXKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZK[K[K\K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K^K]K^K^K^K^K\K]K_K_K_K^K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaK`KaKaKaKaKaKaKaKaKaKaKaKbKaKaKaKaKaKaKaKbKcKcKcKcKcKbKcKdKdKdKcKcKcKcKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKfKeKdKfKfKfKgKeK]KVK]KdKWK^KZKOKZKVKZK\K]K]K\K]K^K^KbK]KdKuKeKYKYKWK0K%K(K(K#K*K2K7K)KKKKK"K0K4K4K5K1K&K'K#K/K:K9K8K7K@K:K;KDKOKPK;K9K7K5K0K"K#K#K5K=K9K:K=KLKFKCKSKbKMK;K:K:K>K9K&K K$K5K:K8K6K=KYKcKfKbK`KHK6K3K2K2K*K"K"K)K2K3K1K/KFKSKXKWKTKQK9K)K*K&K%K%K#KK%K+K/K)K4KNKPKQKQKQKPK+K!K)K*KKK#K(K&K'K*K?KJKIKKKMKPKIK0K2K(K$K"K$K&K%K#K#K&K K?KuKsKtKsKsKsKsKsKsKsKsKtKsKuKpKQKIKJKJKJKJKIKIKJKIKHKIKHKIKKK>KKK7KFKFKIKJKKKKKJKCK>K?K?K>K?K?K?K?K>K>K>K>K>K>K>K?K>K=K?K>K>K?K>K5K-K/K2K4K7K8K7K7K5K2K0K/K!K KKK1K5K4K5K4K2K3K4K5K4K3K5K5K3K4K4K3K3K3K2K2K2KLKqKuKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q7(KXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZK[KWKXK[KZKZK[K[K[K[K[KZKZK[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZK\K\KZK[K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K`K`K`K`K]K]K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaK_K`KbKaKaKaKaKaKaKaKaKbKbK`KaKaKaKaKaKaKbKeKeKeKeKeKeKeKdKdKdKeKdKaKbKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKfKfKcKcK]K`K[KYKaKZK[K`KLKlKcKUK^K]K]K\K\K_K_KaK[KgKtK`KYK\KSK+K(K)K(K$K-K2K5K"KKKKK%K1K1K4K3K.K#K#K$K4K9K7K8K8K@KK?K?K?K?K?K>K>K>K>K>K>K>K>K?K?K>K>K>K>K?K=K4K-K4K2K6K8K8K9K8K5K2K/K.K KKK!K1K5K5K5K5K5K5K5K5K5K5K5K5K5K5K5K5K3K3K3K2K2KHKpKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q8(KVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKXKWKXKZKZKZKYKXKZKZKZKZKZKYKXKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K\K]K[KZK\K\KZK[K\K\K\K\K\K\K\K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K^K_K_K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaKaKaKaKaKaKaK`K`KaKaKaKaKaKaKaKaKaKbKaKaKaKaKaKaKaKbKeKcKbKdKdKdKdKdKdKdKdKdK`KaKeKdKdKdKdKdKdKdKdKdKdKdKdKeKfKfKfKeKdKeKhKjK[KVK`K]KUK\K_KXKaKKKmKlKLK]K[K[K\K_K_K_K^K\KkKsK^KZK[KMK'K)K'K%K#K+K1K7KKKKKK$K.K/K2K3K*K$K#K&K7K9K8K7K9K@KK>K?K?K?K@K?K>K>K>K>K>K>K?K>K>K?K>K>K>K>K>K?K>K2K-K2K4K6K6K7K9K7K3K0K/K.K KKKK2K5K4K5K5K5K5K5K5K5K5K5K5K5K5K5K3K3K3K3K3K0KFKkKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q9(KUKVKXKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXK[KZK[KXKWKZKZKZKZK[KXKWKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K\K\K[KZK\K\KZK[K]K\K\K\K\K\K]K]K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K`K_K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K`K^K_K`K_K_K_K_K_K_K_K_K_K_K_K_K`KbKaKaKaKaKaKaKbK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKcKaKdKeKdKdKdKdKdKdKdKbKcKdKdKdKdKdKdKdKdKdKdKdKdKdKeKgKgKgKfKfKaK`K^KVKVKaKaKVKYK`KWK`KSKXK|KRK\KZKZK]K`K_K_K\K]KoKsK\KZK[KCK#K)K(K%K%K-K1K4KKKKKK&K0K.K1K4K(K$K"K&K7K8K8K6K9K@K=KIKTKTK;K9K9K5K1K%K K!K,K;K:K=KK>K>K?K>K>K>K>K>K>K?K?K>K>K>K>K>K>K>K>K;K3K.K0K1K4K5K8K7K5K2K.K/K0K KKK K1K5K4K5K5K5K5K5K5K5K5K5K5K5K5K3K3K3K3K3K4K2K@KjKvKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q:(KWKWKVKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKXKZKYKWKWKWKWKXKZKYKWKYKZKXKWKWKWKWKWKWKWKXKZKZKZKZKZKZKZKZKZK[KYKWKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K\K[KZKZKZKZK[K]K\KYK\K\K\K\K\K\K\K\K\K\K\K\K]K]K]K\K\K\K\K\K\K[K]K]K\K\K\K\K\K\K\K\K\K]K`K^K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKaKdKeKdKdKdKdKdKdKdKeKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKfKeKaKbK[KSKNKSKTKZK`KUKSK`KTK]K^KIK†KgKZK\K\K^K`K_K_K^K`KqKpKYKZK^K>K$K*K(K%K(K-K0K0KKKKKK-K0K.K1K2K&K"KK)K8K8K8K5K;K?K@KJKXKQK:K9K6K2K+K"K!K"K2K;K:K;KKLKKKLKJKOKDK)K)K)K'KKK$K'K K K*KFKEKHKKKIKLK7K3K.K&K$K$K%K&K#K#K&K$K%KfKvKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKsK[KIKIKJKIKKKKKKKKKKKKKKKHKIKGKEKJKGKDKGKFKFKHKIKJKLKFK?K>K>K>K>K?K>K>K>K>K>K>K>K>K>K?K>KK?K>K?K?KK?K@KJKXKKK8K:K5K2K,K!K!K"K2K;K9K7K:K9K4KKtKsKtKsKsKsKsKsKsKsKsKsKsKtKsKsKtKtKsKuKpKVKIKMKLKKKKKLKKKKKKKKKIKJKKKIKHKBKCKFKGKFKGKHKJKKKIKFK?K?K?K>K>K>K>K>K>K>K>K>K>K>K?K>K=K>K?K>K?K?K=KKAKMKRKAK7K8K6K-K)K K K$K7K;K9K7KK4K5K2K6K,K"K!K2KK3K0K'K$K$K$K%K"K!K%K'K#K[KwKsKsKsKsKsKsKsKsKsKsKsKtKvKtKsKuKvKvKuKtKkKPKLKJKHKIKLKJKHKKKLKKKKKLKJKIKDKCKFKDKGKFKFKGKJKKKLKFK?K>K?K>K>K>K>K>K>K>K>K>K?K>K>K?K>K>K>K>K>K>K?KK?K>K>K>K>K>K>K?K?K>K>K>K>K>K>K>K>K>K>K>K>K:K2K.K3K4K4K6K7K7K7K4K1K0K0K KKK K1K4K3K4K5K5K3K4K4K4K5K5K5K5K4K3K3K3K3K3K3K2K9K^KuKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxe]q>(KWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZK[KWKWKWKWKWKWKWK[KYKYK\KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K]K]K]K\K\K\K]K\K\K[KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K_K_K_K_K_K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbK`K_K_K`KbKaKbKaKbKbKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKdKeKeKdKeKeKeKaK_K^K\K]K^K]K]K[K[KZK[KZKPKTKAKIK`KTKQK_KXK]KaKGK~K^KRK^K]KaKWKXK\KiKrK`KXKZKRK(K&K)K'K!K&K*K-KKKKKK(K/K,K*K-K*K K K&K5K5K4K4K6K=K;KCKNKSK:K6K8K2K,K#KK K/K9K8K7K6K:K5K7KEKPKCK1K6K8K6K2K'K"K'K9K:KKAK@KAKAK.K,K*K*K%K KK#K*K+K'K+KEKHKGKGKEKLK5K&K)K*K"KK"K%K%K&K&K7KEKEKHKFKHKCK3K6K'K$K$K$K$K$K"K$K$KKLKxKrKsKsKsKsKsKsKsKsKuKuKsKtKvKtKsKsKsKsKtKvKuKuKdKJKHKJKLKLKLKLKKKKKKKLKJKHKJKJKIKHKCKDKGKDKHKKKJKHKIKBK>K?K?K?K?K?K>K>K?K@K=K>K>K>K>K>K>K>K>K>K?K=KKaKWKQK]K]KWKdKJKiKxKRK_K]K`KVKYK[KkKoK\KYK[KGK#K'K)K'KK$K,K/KKKKKK)K.K-K-K-K%K!KK)K5K5K4K4K9K=K;KDKKKGK6K6K4K.K-KKKK1K4K4K2K6K9K4K9KEKMKK>KAK;K,K+K*K)K%K K!K(K*K*K&K4KJKFKEKEKHKHK*K(K)K*KKK%K'K(K(K,K@KCKCKFKEKJK:K9K2K'K%K%K%K$K"K$K%K%K,KfKuKsKsKsKsKsKsKsKtKuKuKuKuKtKtKtKuKuKuKuKuKuKuKuKvK^KJKJKLKKKKKKKKKKKKKLKKKJKIKIKGKFKHKBKEKFKGKGKGKIKLKHK@K>K=K=K=K>K?K>K?K?K>K>K>K>K>K>K>K>K>K>K?K>K>K=K;K1K2K4K4K5K6K6K5K4K3K3K0K/K KKKK0K4K5K7K5K4K3K3K4K3K3K4K3K3K4K4K3K3K3K3K3K2K3KUKtKwKwKyKxKxKxKxKxKxKxKxKxKxKxe]q@(KWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKWKZKZKWKWKWKWKWKWKWKWKWKWKWKWKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZKZKZKZKZKZKZKZKZKZK\K\K\K\K\K\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K\K\K^K`K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbKaK_KaKaKaKaK_K_K_K`KbKaKaK_K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKeKdKdKdKdKdKdKdKdKdKdKdKdKdKdKcKdKeKdKeKbK^K^K\K]K^KXKMKK"K(K)K&KKK%K-KKKKK K.K-K.K.K-K"K K K,K3K5K3K0K=K;K;KEKOKEK5K7K2K*K'KKK K7K&KK)K:K6K4KKAK5K,K+K+K'K#K K#K*K(K)K'K=KGKDKCKCKJK@K*K)K'K&KKK%K&K)K(K3KCKAKBKFKFKEK5K9K-K'K#K%K%K$K!K$K'K!K@KuKsKsKsKsKsKsKsKsKuKvKuKuKvKuKsKuKvKuKvKvKuKuKuKuKvKrKZKJKLKLKKKLKLKKKKKKKLKLKIKIKKKGKIKIKFKFKFKFKFKHKLKLKHK>KK>K>K?K>K>K>K>K>K>K>K>K>K>K?K?K?K?KKIKAK1K/K5K7K1K'K#K#K7K:K:KK4K1K2K4K*K"K K0K6K4K2K7K>K9K:K:KKK>K>K>K>K>K>K>K>K>K>K>K>K?K=K=K>K>K?KKBKPKKKUKUKYK[KZKWKXKXKWKXKPKQKCKFK`KSKQK_KZKYK_KIKRKVKUK[K`K[K\KdKtKhKZKZKXK0K'K)K)K$K&K(K.K%KKKKK$K,K-K-K.K)K!KK#K4K4K2K2K3K5K4K8K>KBK8K4K4K1K0K$KK K,K5K3K0K4K=K5K4K@KFK>K0K3K5K2K/K&K!K)K;K8K:K=K@KEKHKJKKKIK:K6K3K2K0K&K"K%K2K,K)K2K9K=K9K:K8K9K:K0K0K-K*K"K!KK&K)K)K'K3KFKCKCKDKCKBK-K(K(K'KKK%K)K)K(K,K@KAKBKCKCKGK5K5K/K&K'K$K"K&K#K#K$K"K0KnKtKsKsKsKsKsKtKtKsKtKuKuKuKsKtKvKuKuKtKtKuKuKuKuKuKuKvKwKmKQKMKJKIKJKKKLKKKKKKKLKLKLKKKHKHKLKHK;KBKFKFKGKJKMKMKFK?KK?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K=K=K>K?K>K?K8K.K.K4K5K4K6K8K7K4K1K.K.K.K!KKKK-K3K3K5K3K3K3K3K3K3K3K3K3K3K3K3K2K2K3K3K1K1K2KKKoKxKyKxKxKxKxKxKxKxKxKxe]qC(KWKXK[KXKWKWKWKWKWKWKWKWKZKZKWKWKWKWKWKWKWKWKXK[KYKWKZKZKWKWKWKWKWKWKWKVKYKWKWKWKWKXKZKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K\K\K\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K_K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKaKaKaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKcKfKeKeKeKdKdKdKdKdKdKdKeKeKcKcKaK\K\K_KaKZKIK=KEKUKLK+KKRKYKYK[K[K[KXKXKWKYKSKMKLKK8KEKDKGKGKLKLKIKEK?K?K?K?K>K>K>K>K?K?K?K>K>K?K?K?K>K?K>K>K>K?K=K=K9K/K/K3K5K5K5K7K8K5K3K.K0K/KKKKK/K3K2K4K5K3K3K3K4K5K4K3K3K3K3K2K1K2K3K3K3K2K1KJKpKxKwKyKxKxKxKxKxKxKxe]qD(KXKYK[KYKWKWKXKWKXKYKXKWKZKZKXKXKXKXKXKXKXKXKYK[KYKWKZKZKWKWKWKWKWKWKWKWKXKYKXKWKWKXKZKZKYKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[K[K[KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K^K_K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K_K_K_K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKbKdKcKcKcKdKdKdKeKeKdKeKdKbK`K_K]K]K_KZKLKAKFKSKKK0KK#KAK[KWKXK[K[K[KXKXKXKWKQKIKOK5KYK\KUK[K]KVK^KSKKKKKKXK^KYK[KiKtK`KXKZKOK'K(K)K&K#K(K(K.KKKKKK'K*K*K+K-K&K!K K+K3K2K/K/K2K.K,K4K;KKDKCK4K-K2K4K3K)K#K$K5K:K8K8K=K?K>K@K>K@KAK;K5K1K3K,K"K K.K7K3K2K4K=K6K7K7K;KBK2K0K.K/K(K K!K%K*K)K)K-KAK?K@KBK=KBK0K"K(K+K KK#K(K(K%K&K;K>K>KAKAKCK:K9K5K%K%K$K$K&K#K#K&K%K%KeKvKsKsKsKsKsKtKuKtKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKtKtKuKaKLKKKJKKKLKKKKKKKLKKKKKJKJKJKGKFKAK$K,KCKDKCKFKKKLKJKEK?K=K>K?K>K>K>K>K>K>K?K?K>K>K>K>K?K>K>K>K?K>K=K=K9K-K/K4K5K5K6K7K6K6K2K1K/K-K KKKK.K3K3K5K4K3K3K3K4K2K3K3K3K3K4K5K3K3K3K3K3K4K2KFKnKxKxKxKxKxKxKxKxKxe]qE(K[K[K[KYKWKVKYKWKXK[KYKWKZK[K[K[K[K[K[KXKWK[K[K[KYKWKZKZKWKWKWKWKWKWKWKWKXK[KYKWKWKWKZKZKWKYK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK\K]K]K\KZK\K\K\K\KZKZKZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K`K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KbKaK_K_K_KaKaK_K`KbK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKdKdKaKaKaKaKaKdKeKeKeKeKbK^K^KZK_K_K]KXKJKBKHKUKLK.KK$KDK^KhK`KWKWK[K\K[KXKVKTKWKRKJKOK8KOK^KUKWK^KYK\K\KCKzKfKUK_KXK]KmKsK^KYK^KIK$K)K(K%K%K*K)K+KKKKKK*K*K*K+K)K"K K!K*K4K1K/K/K1K+K*K3K:KKFK=K/K0K3K1K0K%K"K'K7K8K6K7K=K;KK2K2K,K,K&K K!K'K,K+K)K3KAK=K>K?K>K@K)K$K'K)KKK'K)K)K(K.K=KK?K?KBK6K=K/K$K#K&K%K'K$K"K'K!K@KwKsKtKsKsKsKsKsKsKsKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKtK\KKKIKLKKKKKKKKKLKKKHKIKLKJKHKGKAKK +K/KGKCKDKGKLKMKJKBK=K>K?K>K>K?K=KK?K?K>KK?K?K>K>K?K?K=K=K9K.K.K4K5K5K5K5K5K3K0K/K,K+K KKKK/K5K5K5K4K3K3K3K1K3K3K3K3K2K2K3K3K3K3K3K3K3K3KEKjKwKxKyKxKxKxKxKxe]qF(KXKXKYKXKWKYKZKYKZKZKZKYKZK[KZKZKZKYKXKYKYKXKYK[KYKWKZKZKYKYKWKXKYKXKWKWKXK[KZKYKYKYKZKZKYKZKZKZKZKZKZKZKZKZKZKZKZK[K\K[KZK[K\K[K[K[K[KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K^K^K^K^K^K^K^K^K\K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaK`K_K_K_K_K_K_K`KaKaKaK_K`KaK`K`KaK`K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKcKcKcKdKdKaKbKcKbKaKbKcKeKbK_K[K[K]K_KbK[KHK?KIKTKIK/KK(KDK`KiKgKgKcKYKTKZKYKYKXKVKUKXKWKLKJKFKKK_KUKSKYK[KVKaKHKiKƒKUK_KYK\KoKtK[KXK\KAK$K*K)K'K$K%K*K(KKKKKK,K*K*K+K(KKK!K-K3K1K/K/K.K*K+K1K:K9K3K2K/K+K$K!KK*K5K4K2K3K>K6K6K@KCK:K0K3K4K4K0K$K"K+K8K8K7K9K>K:K9K9K7K9K:K6K4K5K1K#KK%K4K5K5K4K9K6K5K8K8KKK>K>K?K8K;K*K%K$K$K$K#K!K%K'K"KVKvKsKsKsKsKsKsKtKuKtKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKsKVKKKLKKKLKKKKKLKKKJKKKLKKKJKKKIK4KKK4KFKDKFKIKKKLKJKCK>KK=K>K>K>K>K?K>KK=K@K>K>K>K>K=K=K9K+K/K4K4K3K4K6K6K4K1K.K/K/K!KKKK-K5K5K4K3K3K3K2K3K1K1K3K2K1K2K3K1K1K3K3K3K3K1KBKjKxKwKxKyKxKxKxe]qG(KWKWKWKWKXKZK[K[K[KZK[K[K[K[KZKZK[KYKWKZKZKWKXK[KYKWKZKZK[KZKWKYK[KXKWKWKXK[KZK[K[K[KZKZK[KZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZK\K]KZKZKZKZKZK\K]K\K\K]K\K]K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K_K`K`K`K`K`K`K]K\K\K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_KaKbK`K_K_K_K_K_K_KaKbKaKaK_KaKbK`K_KbKaK_KaKbKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKeKeKeKdKdKaKbKeKcKaKbKbKbK]K[K\K]K`K[KJK?KHKQKJK+KK'KIK]KhKhKcKcKaK]KTKRKYKXKWKXKXKYKVKVKRKHKPKQK\KVKNKYK`KVKaKQKQKlKWK_K\K_KqKnKXKXKZK;K#K)K(K%K!K#K)K%KKKKK K,K*K+K+K'KKK"K.K/K/K0K.K(K&K(K.K8K4K.K/K/K,K#K"K"K.K7K6K3K5K;K6K8KAKBK6K.K0K2K1K,K#K#K/K:K7K8K;KK=KDK4K*K)K*K"KK!K(K)K&K+KK?K?K7K=K2K&K#K$K$K#K K"K'K%K0KlKsKsKsKsKsKsKsKtKvKuKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKpKTKJKLKKKLKKKKKLKLKLKKKLKLKLKLKKK3KKK;KIKEKCKHKLKMKJKBK=K?K>KK>K?K>KK?K?K>K>K>K>K?K?K=K=K6K-K.K3K3K3K7K8K7K2K0K0K0K,K KKKK/K5K4K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K2K@KfKvKxKyKxKxKxe]qH(KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[KYKWKZKZKZKYKWKXKXKWKWKWKWKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZK[K[KZK[K\K\K\K[K[K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K_K_K_K_K_K^K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K_K_K_K`KaKaKaK`K`K`K`KaKaKaK`K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKdKdKdKdKdKdKcKbKcKcKbK`K]K\K_KaK[KKKAKKKOK@K%KK%KHK`KdK`K]K]K\K]K^K]KYKUKVKXKXKXKXKXKVKUKVKHKNKRK[KYKOKXK`KVK^KYKHKSKRKVK\K`KsKiKXK[KZK4K'K*K(K K K)K)K!KKKKK$K,K*K(K*K'KKK$K/K-K-K.K-K(K&K&K-K5K2K,K/K0K)K!K!K"K0K6K3K2K6K:K6K9KAK?K4K.K/K/K1K(K"K$K4K;K7K6K;K:K8K:K7K6K:K8KK?K5K=K+K'K$K#K$K#K!K%K'KKGKxKsKsKsKsKsKsKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKjKNKKKLKLKLKLKKKLKJKKKLKKKLKKKIKHK.KKK>KHKFKFKGKLKLKJKCK>K?K>K>K>K?K?K>K>K>K>K?K>K?K?K>K>K>K>K>K>K>K>K=K7K.K0K3K5K5K5K6K7K6K3K0K0K-K KKKK/K2K2K2K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K1K>KdKxKwKxKxKxe]qI(KZKZK[K[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[KYKXKZKZKZKZKXKXKXKWKWKXKXKZK[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K]K[KZK[K[K[K[K]K\K\K[KZK[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K\K\K\K\K\K\K\K]K]K]K]K]K_K_K_K_K_K`K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K_K`KbKaKaK`K_K_K`KbKaKaK`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKdKdKdKdKdKdKdKaKaK`K_K\K]K_KZKOKCKGKNKCK,K%K2KDKZK`K_K]K_KdKhKiKgKiKiKcKVKUKXKXKXKXKXKWKVKVKIKKKJKSK]KPKSK_KZKYK_KEKgKmKHK]KfKuKfKYK\KTK,K'K)K'KKK'K(KKKKKK$K+K*K(K*K%KKK%K0K-K-K-K+K%K%K&K-K3K/K*K,K.K&K K K$K4K5K3K2K7K8K5K;KAK9K3K0K0K0K.K#K K'K7K7K8K6K;K8K5K6K3K5K7K5K9K8K1K#K K&K4K5K4K2K8K3K1K0K1K9K9K/K3K2K,K"K K#K-K+K+K)K7K9K9K:KK8K;K7K'K$K#K$K$K#K#K&K%K%KdKvKsKsKsKsKsKsKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKvKfKMKKKLKLKLKKKLKJKKKLKKKLKLKLKLKHK+KK KCKHKEKDKHKKKKKJK@K>K?K>K>K>K>K>K>K?K?K>K>K>K>K?K>K>K>K>K>K>K?K=KK?K3K@K.K%K#K"K$K%K!K&K'K!K9KuKsKsKsKsKsKsKsKsKtKvKuKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuK_KIKKKLKKKKKKKKKKKKKKKKKKKLKJKJKDK#KK%KBKGKFKFKIKKKLKGK@K>K?K?K=KK?K>K?K?K?K>K>K>K>K>K>K>K>K>K>K?K=K=K6K-K/K3K5K5K4K7K8K6K3K0K.K.K KKKK-K4K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K2K3K0K7K]KvKxKxe]qK(KZK[K[K[K[K[KZKZKZK[KZKZKZKZKZKZKZKZKZKZK[KZKZKZKZKZKZKZKYKZKZKZKZKYKYKZKZKZKZKZKZKZKZKZKZKZKZKZK[KZKZKZKZKZKZKZKZK[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K^K^K\K\K\K\K\K]K^K_K_K_K_K_K]K]K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`K`K_K_K_K_K_K_K_K`KaKaKaKaK`K`KaKaK_K`KbKaK`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKaKaKbKcKcKcKcKbKcKbK^K^K`K`KbKYKKKBKHKWK_K`KdKiKlKlKlKjKiKkKiKhKgKfKgKeKeKeKfKgKaKXKTKWKXKWKXKWKWKXKWKSKJKJK7K^KWKNKZK_KUKaKUKHK~KSK\KhKuK`KYK[KJK%K'K&K%K$K%K(K#KKKKKK*K*K*K)K&K KKK*K,K*K+K+K%KK"K&K+K1K0K.K-K+K$K K!K,K4K4K3K3K4K3K3K3K3K4K/K0K/K1K+K#K"K/K9K7K7K8K;K0K1K2K2K;K8K6K8K8K.K!KK.K4K4K3K5K4K/K/K/K2K6K2K2K2K0K&K!K!K*K.K,K*K2K:K3K7K8K9K9K-K)K)K'KKK%K'K(K(K4K;K8K;K=K>K=K8K=K'K$K#K$K$K$K#K&K&K#KXKxKsKsKsKsKsKsKsKsKtKuKtKsKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKtK[KJKKKLKKKKKKKKKKKKKKKKKLKKKIKKK@K KK(KEKEKGKHKJKLKMKFK?K>K?K=K=K>K>K>K>K>K>K?K>K>K>K>K?K>K>K?K>K>K=KK?K?K?K?K?K=KK?K>K?K?K>K>K>K>K?K>KK,K$K#K$K$K$K"K%K'KKFKxKrKsKsKsKsKsKsKsKsKsKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKmKRKLKKKKKLKKKKKKKKKKKKKKKLKKKKKKK9KKK0KGKFKFKGKJKLKLKGK>K>K>K=K>KK>K>K?K?K>K=K>K@K?K>K?K>K>K=KKK?K>K>K?K>KK>K?K>K>K?K>KK6K,K/K3K3K3K6K5K5K1K0K-K,K,K KKKK/K4K3K3K3K3K3K3K3K3K3K3K3K2K2K3K3K3K3K3K3K3K2K3e]qO(KëK×K¨KvK]K\K`K_K^K\K\K\K\K\KZKZKZK[K[K[KZKZKZKZKZKZKZKZKZKZKZKZKZKZKZK[K[K[KZKZKZKZKZKZKZKZKZKZKZKZKZK[K[K[KZKZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K[K\K\K\K\K]K]K_K_K_K_K_K]K\K]K^K`K_K_K_K_K_K_K_K_K_K_K_K_K`K_K^K`K_K_K_K_K_K_K_K_K_K_K_K_K`K`KaKaKaKaKaKaKaK`K`K`K`K`K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKaKaKbKaK`K`K`K_K_K^KcK^KKKDKPKXKHK+KK1KPKbKfKeKdKdKeKbK`K_K_K]K]K_K`KaKfKjKmKnKnKnKmKlKkKeKWKTKVKXKWKVKTKNKUKWKQKIKNKOK\K]K]KXK]KUK]KWKGK]KcKrKhKZK[KWK/K'K)K'K"K K K"KKKKKK#K$K$K$K%K KKK%K)K'K'K+K$K K!K!K%K+K+K*K,K+K$KK K)K1K1K1K2K/K'K'K'K)K/K.K.K/K1K'K!K K,K6K5K4K5K2K-K.K-K/K5K5K6K8K:K)KK"K1K6K5K5K5K.K.K0K/K0K7K4K3K1K,K"K K"K)K+K+K,K3K2K2K5K6K:K8K)K(K+K#KK!K&K$K&K)K5K8K6K6K9K=K6K9K4K'K$K"K$K%K"K$K%K!K:KqKsKsKsKsKsKsKsKsKsKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKxKYKFKMKLKKKLKKKKKKKKKKKKKKKLKLKKKIK1KKKK>KK>K?K>K>K=KK?K>K>K?K>K>K=KKKEKFKFKFKLKKKIKBK>K>K=K=K=K>K?K>K>K?K>KK?K>K>K>K>K?K=K=K=K=K>K>K5K,K/K4K5K5K5K8K6K4K2K0K/K/K!KKKK*K3K3K2K2K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3K3e]qQ(KìKèKãKçKîKæKÂKŒKdK\K`K_K]K\K\K\K]K[KZKZKZK\K\KZKZKZKZKZK\K\K]K[KZKZKZK[K[K[KZKZKZKZKZKZKZKZKZK\K]K\K\K\K\K\K\K\KZKZKZK[K]K[KZK\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K\K\K\K\K\K\K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaK_K_K_KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKbKbKaK_K_K_K`KaK\KNKGKMKLKK>K?K@K=K=K?K=KK?K?K>KK>K?K@K=K3K+K/K3K5K5K5K5K5K4K3K.K0K-KKKKK,K1K3K3K3K3K3K3K3K3K3K3K4K1K3K3K3K3K3K3K3e]qR(KªKÙKîKêKãKæKìKéKËK›KlKZK[K_K^K\K\K\K[K[K[K\K\KZK[K[K[K[K\K\K\K[KZKZKZK[K[KZK[K[K[KZKZKZKZKZKZK[K\K\K\K\K\K\K\K\K[K[K[K\K]K[K[K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K\K]K]K\K\K\K\K\K]K]K]K]K\K^K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KaKaK_K`K`KaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKaKbKcKaKaKaKaK`KaKaKYKLKJKIKSKVKJKLKVK_KgKjKjKmKsKvKwKuKtKsKoKmKkKjKfKfKfKdKcKfKdKeKgKgKgKhKhKgKgKfKfK[KLKQKVKVKVKUKUKUKTKSKMKJKPKMK[K\KSK_KgKYKcKaK[KjKqK^KXK]KBK#K*K)K%KKKKKKKKKK#K#K#K$K KKKK'K(K(K)K(KKK!K K&K,K*K,K+K(K!KK#K.K0K.K/K2K'K#K"K%K,K0K.K/K,K(KKK(K3K2K3K4K2K-K.K-K.K3K8K5K4K;K.KKK1K7K4K8K7K/K-K.K-K/K:K9K5K5K0K#KK#K,K,K-K,K2K0K/K2K2K9K5K)K+K*K KKK$K&K&K*K4K4K7K8K6KK?KK=K>K?K>K>K=K=K>K>K>K>K>K>K=KK=K?KK?K?K?K?K?K?K?K?K?K>KK>KK?K?K?K>K=K=K=K=K=K=K=K=K=K>K>K>K>K>KK?K?K>KKKK>K=KK?K=K=KK?K>K=K=KK>K=KK?K?K>K?K=KK>KK?K?K=KK>KK;K=K?K=KKK>K>K=KKK?K=KKK?K>K>K>K>K>K=KK>K?K>KK=K:KK?K?K?K?K>K?K=K=K>K?K>K=KK>K=KK?K>K?K>K?K?K>KK?K=K=K?K?K?K=KK>K=K>K8K,K-K1K4K5K5K5K3K2K3K2K-K/K-K*K/K/K1K0K1K3K3K3K3K3e]q`(KMKSK[KeKqK…K•K¢K²KÁKÏK×KÓKÙKØKÐKìKçKéKéKéKèKéKìKÙKªKÚKÓKÆK°KŽKKÎKîKíKåKåKïKìKÐKŸKqK]K_K`KaK_K^K^K_K_K]K]K]K]K]K\K]K]K]K]K\K\K]K]K]K^K`K_K_K]K^K_K_K_K^K]K]K^K_K_K_K_K_K_K`K^K_K_K_K_K_K_K_K_K_K_K_K_K_K`K^K_K`K_K_K_K_K_K_K_K_K_K_K_K`K`K`KaKaKaK`KaKaKaKaKaKaKaKaKaKaKbKaKaKcKbKbKdKdKbKVKPKVKUKSKRKXK`KcKcKbKaKdKTKPKRKXK^K^KaKdKfKjKmKpKtKvKvKwKwKuKrKoKlKkKiKgKeKeKdKcKdKdKcKfKgKfKfKfKfKfKfKhKgKgKfKfKeKcKbK_K\K\K\KYKWKYKVKWK[KZKWKOKOKRKSKRKSK\K\K\K]K]KNKUKUKaKfK]KVKiK\KQK\K[K8K!K%K%KKK +KKKKK KKKKKKKKK K K +K K K +K K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK K%KKKKKKKKKKKKKK K"K)K(K,K#KKKK K!K#K%K&K,KkKtKsKsKsKsKtKtKuKuKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKwKuKvKyKxKxKxKxKwKxKxKxKxKxKxKxKxKxKxKuKZKLKMKLKLKLKKKLKKKKKKKKKKKKKLKKKLK@KKK#KCKFKFKFKFKHKJKJKBK>K?K>K=K>K>K>K>K>KK=K=K?K>K?K=KK>KK7K*K/K4K4K4K5K4K3K2K1K/K.K-K,K,K/K1K/K0K3K3K3K3K3e]qa(K\KZKXKTKOKMKKKHKGKLKRKRK¯KòKËKÝKëKèKéKéKèKèKéKïKºK[K¢KÚKªK¡KÌKºKK‘KÂKèKïKèKæKíKíKØK«KzK^K_KaK_K_K_K_K`K`K`K`K_K\K]K`K`K`K`K`K`K`K`K`K_K_K_K`K`K_K_K_K_K`K`K`K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K_K`KbK`K_K_K_KaKaKaKaKaKbKaKbKbKbKaKaKcKdKeKeKcKaKXKPKVKZKHKHKTKGKVK`KaKaKbKaKdKVKQKQK?KRKbKiKkKlKoKoKnKlKlKjKfKdKdKcKcKcKcKdKdKdKeKeKeKeKeKeKfKhKgKfKdKbK`K_K^K]K]K\KZKYKZKZK]K`KbKdKhKhKhKgKeKhKjKbKQKOKRKSKQKTKVKZK^KZKSKNKQKUKZKdK^KWKcKcKRKZKZK2K$K$K%KKKKKKKKK KKKKKKKK +K +K +K +K +KK K K KKKKKKKKK K K K K K KKKKKKKKKKKK KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK K%K&K+K KKKK K!K%K'K"KBKwKsKsKsKsKsKtKvKuKuKuKuKuKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKxKxKxKxKuKvKyKxKxKxKxKxKxKxKxKzKrKTKMKMKNKMKKKLKKKKKKKKKKKKKKKKKKKMK=KKK(KEKFKFKFKHKIKJKHKBK>K=K;KKK?K=KK=KK?K=KK=KK?K=KK>KKK>K>K>K?K=KK>K=K=K=K>K>K>K>KKZKdK]KWK]KaKaKaK_K]KaKbKbK`KaKYKNKTKFKcKcKdK_K^K^K_K_K`KbKcKeKlKnKqKsKvKyKxKxKvKvKrKqKnKlKhKfKeKdKdKeKeKdKeKfKfKfKfKfKgKfKfKgKgKgKgKhKhKhKhKhKfKeKeKYKEKFKMKNKNKPKQKNKRKSKJKIKQKEKHKfKVKNKVKZKPK>KK$K'K KK K KK K K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK%KKKKKKK$K&K$K*KiKvKsKsKsKtKtKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKuKuKuKuKuKuKuKvKvKvKvKuKuKvKvKvKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKtK[KMKNKLKKKLKLKKKMKMKKKLKKKKKLKJKKKHK&KKK>KJKGKGKEKGKJKKKGK?KK?K?K?K?K=K=K>K>KK?K?K>KK>K>K>K>K?K>K=K=KK>K?K>KKKK`KfKjKjKmKoKmKjKjKhKfKeKdKcKcKcKdKfKdKfKgKgKgKgKfKfKfKfKgKgKgKhKgKfKfKdKdKaK_K]KZKYKXKUKTKUKTKUKWKWKWKPKJKMKOKOKQKMKLKNKNKOKKKKKRKUKTKEKSK;K`K`KQKQKYKFKK#K K"KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK!K%K'K&KZKwKsKsKsKsKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKxKvKuKuKuKuKuKuKwKxKxKwKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKnKQKKKLKMKMKNKLKKKMKMKMKMKLKKKLKKKNK@KKK!KCKJKGKFKFKGKKKMKGK>K=K?K>K>K>K>K?K=KK>K?K>K>K=K=KK>K?K=K?K=KK?K>K?K?K=KK?K=KK?K?K>K?K>K=KK>K?K>K?K?K=K>K?K>K>K=KK?K>K?K>K?K>KK>K>K?K>K?K?K>K?K>KKSK˜KÌKÄK–KŒK¸KæKóKëKéKïKòKàK­KzKaK_KdKeKbKaKaKaKaKaKaKaKaK_K_K_K_K_K_K_K_K_K_K`KaK_K`KaKaKaK`K_K_K_K_K_K_KaKaKaKaKaKaKbK_K`KaKcKdKeKgKiKgKbKZK\KcK\KCK1K?K]KaK_KaKaKbKcK`K\K_KbKbKcKaK[K[K^KaKcKcK^K\K_KaK`K`K`KbKPKWKFKYKeKaKcK`K_K]K]K_KaKaKcKcKdKhKkKoKqKsKvKsKrKsKsKqKoKnKlKjKjKjKhKfKfKfKfKfKfKgKfKfKfKiKhKbK[KQKPKQKQKQKPKQKOKMKDKK>K>K>K>K>K?K>K?K>K>K?K>K?K>K=K>K>K>K=KKNKVKLKBKLKRKSKEKPK;KSK]KLKEKZKNK'K$K"KKK KKK K K KKKKKKKKKKKK"KKKKKK!K$K$K$K$K$K#K#K$K$K$K$K%K&K&K&K%K&K&K%K%K%K&K%K%K%K%K&K&K&K$K%K'K(K%K%K%K&K&K'K'K&K&K&K%K%K&K%K$K(K(K&K&K&K&K)K)K'K(K(K(K(K(K)K*K*K*K(K'K(K(K)K(K%K(K(K'K'K$K$K$K"K!K#K#K!K"K KKKKK!K(K*K$KXKvKsKsKsKsKsKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKuKuKuKwKxKwKyKxKxKvKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KnKRKMKNKMKMKMKNKMKKKLKNKMKJKKKLKLKKKHKBKAK=KDKIKJKFKDKDKGKJKDK>K>K?K>K>K>K?K>K?K>K?K>K>K>K>K>K=KK>K?K>K=K=KK=KGKLKJKDKEKFKHKHKDK?K>K?K?K?K?K?K>K>K>K>K?K?K>KK?K=K=K>K>K?K=KK>K>K>K>K?K>K?K?K>K>K=KK?KK?K>KK;KFKKKYK[KNKHKVKFK(K(K)K"K +KKKKK +KKKKKKKKKKKKKKKKKK%K&K%K&KKKK$K&K'K&K'K KKKK'K+K*K*K(K!KK K(K)K)K,K/K*K+K.K0K0K*K+K+K(K"KK#K)K)K(K+K2K0K0K0K0K.K,K.K.K.K)K'K-K1K0K1K4K2K-K)K-K0K3K=K=K9K,K"K'K0K1K.K-K-K*K)K)K)K)K(K(K&K(K'K(K#K#K&K%K)KfKwKrKtKuKuKvKtKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKvKvKyKxKtKwKyKvKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKwK]KKKKKKKKKLKKKKKLKKKLKNKNKNKMKKKMKFKCKDK@KBKJKMKIKGKFKHKKKIKAKK?K@K=KK?KK>K?K;KK;K8K;K3K/K3K1K3K/K&K"KKK K"K K&K'K"KK>K?K>K?K?K>K>K>K=K>K?K=K=K>K>K?K>KK=K;K=K8K.K/K3K3K3K3K4K3K2e]qq(KlKgKaK^K_KZKtKÛKçKÅKèKéKçKçKéKèKçKìKãKçK½KjKaKgKdKeKbK~K×KÒKuK\KcKbKeKcK€KØKËKpK\KcKcKeKhK¢KçK¦K_K`KbKcKcK‹KáKÂKhK_KeKdKhK’KÙK³KŠK¿KÏK¦KŽK­KÞKöKïKèKíKóKãK¸K‚KeK_KeKfKeKbKbKaKaKaKaKaKaKaKaKaKaKbKbKbK`K`KeKhKlKlKlKmKdK\K\KeKaKGKMKdKgKcKaKaKdKdKdKcKaKaKaKbKaKaKcKaKbKbKbKaKaKbKaKbKbKcK`K_KaKcKaKcK]KZK_KaK_K`K_KbKYKSKQKJKgKdKdKcKbKaKaK^K\K\K\K\K]K\K[K]K^K^K^KbK`KbKeKdKdKfKiKjKhKfKcKZKUKSKSKQKPKPKRKSKNKFKK>K?K?K?K?K?K>K?K>KK6K/K1K0K1K6K'KKKKKK$K)K)K&K0KkKtKsKsKsKtKtKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKvKvKxKxKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKyKxKyKyKxKxKzKiKNKMKMKKKLKLKKKLKMKMKKKLKLKLKKKMKKKDKBKIKDKGKMKLKGKFKGKHKIKFK@K>K>K=K>K?K>K>K>K>K>K>K>K>K>K>K>K?K=KK>KK3K,K4KAKCKCK,KKKVKKKMKXKIK,K*K*K(KK K KKK K K K K K K K K K K K K K KKK K$K&K%K KKK K"K!K"K$KKKKK%K+K+K)K)K!KKK(K)K&K*K)K'K+K*K.K,K)K*K-K'K!KK#K'K$K&K*K/K-K/K0K/K*K*K+K+K(K!K#K,K*K,K0K5K4K*K)K0K1K7K>KHKEK-KK2KLKIKFK@K2K/K1K/K2K0KKKKKKK%K)K)K#KIKtKrKtKsKsKsKsKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKuKuKvKvKuKuKuKuKuKxKxKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKyKxKxKxKxKxKxKzKdKNKKKKKLKLKKKLKNKMKKKKKKKKKLKKKLKIKBKGKEKAKFKMKKKGKFKHKHKIKFK@K;KK?K>K>K>K>K>K?K>K>K>K?K?K?K=KK>KKLKJKHK?K0K2K3K/K2K)KKK!K!K!KK%K)K)K+KdKwKsKsKsKsKsKsKsKuKuKuKuKsKtKvKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKvKuKxKxKuKuKuKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKwK^KKKLKKKKKKKLKMKMKKKKKKKKKKKLKKKJKIKDKCKCKDKHKMKLKFKDKGKIKHKFK@K=K>K?K>K>K?K>K?K?K>K?K>K>K>K?K=KK5K+K-K3K3K3e]qu(KdKcKaKdK]K“KïKÔKÊKêKåKçKçKçKçKèKçKîK¨K_KfK_KaK«KìK¤K^K`K`KaKeK`K’KæK¹KdK]KeKdKdKaK”KæKµKdK^KdKcKeKpKºKâKŽK\KcKbKcKdKKåK¨K_KcKeKdKfK£KçK§K^KNK7K?K~KÃKÊKžKŒKÅKðKëKîKæKáKòKæK¼K‡KhKfKmKgKeKhKvKuK™K…KlKqK[KPKbKaKGK.K8KUKhKjKhKfKcKaKbKeKfKcKcKdKdKcKeKeKcKbKbKcKeKdKdKeKeKbKbKdKbKaKbKbKdKeKbK_K\K]KbKaK]K\KaK`K^K\K_KQKKKSK7KcKfKdKdKfKeKbKdKfKeKeKfKfKeKfKgKfKfKgKgKdKdK_KVKTKRKTKVKTKSKSKQKJK>K4K1K1K6K4K6K@KMKXKUKOKMKLKMKMKLKKKKKKKIKHKIKHKHKGKGKHKDK;K0K%K'K'K$K3KCKAKFK8K4KWKLKIKNKSK:K,K,K,K#KKKKKKK K K KKKKK K K K +K K KKK!K"KKKKK!K K K"KKKKKK)K+K*K'K$KKK K'K)K'K)K'K)K(K*K.K,K)K'K'K!KKK&K&K&K&K*K,K-K-K.K-K+K*K*K+K#KK$K*K+K+K1K4K0K(K0K/K1K6K?KGK;K!K'KEKEKHKHK9K.K1K2K0K1K#KKK!K!K!KK%K*K&K;KtKsKsKtKsKsKtKtKsKuKuKuKuKtKtKvKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKwKvKwKwKvKvKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKxKyKzKzK{KtKTKJKLKLKLKLKMKMKLKLKLKLKKKKKLKMKLKIKEKCKDKEKHKMKLKFKFKHKHKHKHKAKK?K>K?K>K?K?K>K>K>K>K>K?K>K=K=K=K=K>K?K=KK=K6K,K.K3K2e]qv(KbKbKaKeKfKºKïKÆKØKêKæKçKçKçKéKêKåKãK‚K`KfKbKbKaK˜KçK·KcK_KbKbKdKcK‚KÜKÍKoK]KeKaKeK\K…KÝKÆKkK]KgKfKeKfK§KèKŸK[KbKdKgKcKŒKáK¼KhK`KfKgKeKKãKºKiKcKUK4K2KmKÜKÌK¢KðKêKïKåKáKíKçKñKïK¼K¢KÉKÄKKuK{KzKK|KmKuKPK]KBKK'KOKdKgKjKjKhKcKaKbKgKgKgKdKaKdKeKeKdKeKeKeKeKeKdKeKeKeKeKbKaKaKaKaKcKeKdK`K`K]K^KbKaKdK[KYKaK`K^K\K]KRKGKVK?KbKeKdKeKeKeKeKeKeKeKeKeKeKeKeKeKdKdKcK`K\KWKTKTKVKSKSKSKTKQKGK;K3K2K4K4K5K8KBKMKWKUKOKLKKKKKKKLKLKLKLKIKHKIKIKIKGKGKHKCK:K/K)K)K$K&K'K%K-KCKBKBK@K/KQKNKIKGKUKCK-K.K.K)KKKK"KKKKKKKKKK K K K K +K KKKKKKKKKK!K!KKKKKKK)K(K)K'K KKK#K'K)K(K(K"K%K(K+K+K)K(K)K(KKK"K&K&K%K&K)K*K+K+K/K+K*K'K)K&K K K'K+K*K+K1K1K+K(K-K0K1K2K7KAK1KK/KAKAKFKCK2K.K0K0K3K0KKKK!K!K K"K'K)K%KUKwKrKsKsKsKtKvKuKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKuKuKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxK{KzKxKxKxKzKzKzKpKPKKKNKLKLKMKNKNKNKNKLKKKLKKKKKKKLKIKDKGKDKBKIKPKLKFKFKFKHKKKFK>K:K>K?K>K?K>K>K>K>K>K>K>K>K?K?K?K?K?K?K?K=KKK?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K=K=K>K=KK?K>K>K>K?K?K?K?K?K?K>K>K>K?K>KK`KeKjKkKiKaKaKgKiKiKiKeKbKbKeKgKeKdKbKcKdKeKfKeKdKbKbKdKdKdKdKdKdKeKdKaK`KcKcKdKdKdKbKUKKKWK]K^K]K]K\K]KVKDKKKLKTKWKXK[K_K`K]KcKdKeKgKjKgK_KXKUKVKVKUKSKSKUKSKNKBK8K3K3K5K6K7K;KJKVKWKQKKKMKMKNKMKKKLKLKLKKKIKHKIKHKHKIKHK=K0K)K%K(K)K&K(K%KKKKKKKK5KDKAKFK:K3KUKOKFKEKUK=K.K/K.K)KKK!K K!K K!K$K!KKKKKKKKKKKKKKKKKKKKKKKKKK&K&K%K&K"KKK"K$K&K(K%KK K"K"K'K)K)K)K&KKK K&K$K$K(K$K#K&K)K+K+K)K(K(K#KKK$K)K)K)K/K0K)K$K0K/K*K*K*K/K)KK!K%K'K*K.K.K.K-K,K2K+KKK K K K"K#K)K+K)K]KwKsKsKsKsKsKtKuKuKuKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKwKxKxKxKvKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKyKxKzKzKzKzKzKzKzKzKzKzKyK{KyK^KKKKKLKKKKKLKMKLKKKJKMKJKLKKKLKLKIKDKGKAK7KFKOKPKIKFKFKHKIKEK@K>K>K?K?K=K=K=K=K=K>K?K>K>K=K=K>K>K>K=KK>K>K=KK>K>K=K=K?K?K?K=KKK?K>K>K?K>KKK=KK?K>K>K?K>K=K=KK?K?K?K?K?K?K=KKJKVKZKSKOKPKQKPKOKOKOKNKMKMKLKMKLKKKKKLKHK=K1K)K'K'K(K(K)K'KKKKKKKK!K!K KKKKKKKKKK(K@KBKDKCK/KPKTKLKEKTKKK4K3K0K1K&K K KKKK%K+K,K%K"K$K$K$K#K#K#K KKKKKKKKKKKKKKKKKK KKKKK!K!K"KKKKKK%K%K&K%K KKK$K%K#K%K$KKKK!K'K)K(K*K&KKK K&K&K'K*K*K(K K'K,K+K#K$K&KKKK"K%K$K&K+K,K,K-K/K+KKK!K!K"K"K%K+K.K,K\KwKrKsKtKtKtKtKuKuKuKuKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KzKyK^KLKNKNKMKNKNKMKKKLKKKLKMKLKKKLKJKKKIK-KKK3KKKOKKKFKFKFKFKHKDK=KK=K=K=K>K?K=KKK>KK>KK>e]qƒ(KÝKÛKàKèKâKÜKéKæKèKçKçKëKéKìKK_KfKfKcK[K–KéKÀKlK_KcKbKeKeKcK§KîK®KcKaKcKaKeKbKwKÏKÝK€K]KfKdKcKcKiK¸KéK”K]KeKdKgKcKhKºKæK‘K]KeKeKfK`K€KÜKÏKrK`KgKjK`K±KóK¼KëKîKïKèKèKðKñKñKõKÚKœKÄKæK§KuK‡K‚KˆKšKtKuKKcKdKYK_KeKcKfKkKjKiKdKcKdKeKfKjKjKdKdKeKeKhKhKfKeKeKeKbKbKeKdKdKeKdKdKcK_K`KdKeKdKdKcK^KXK\KcKdKcK`KYKZKVKUK[KTKRKXKRKLKVKTKIK:K4K5K5K:K:K?KKKWKZKTKOKPKSKRKPKQKPKPKPKPKOKNKMKMKNKOKJKK>KK=KK?e]q„(KÜKÙKßKæKÛKäKéKèKäKæKçKáKåK×KqKfKiKdKfKfKZKƒKâKÓKxK`KfKdKeKdK_K”KèKÁKjK_KfKeKfKcKlK½KéK“K_KcKbKcKeKeK§KìK¬KaKcKeKcKhKeK¦KìK¥KaKcKfKfK`KqKÌKÝKK_KkKfKÄKëKÁKðKíKïKæKêKñKðKïKöKÑKžKÊKáK•KwKŠK‡K“KKtKuK€KgKaK?KbKcKgKjKjKhKdKeKeKfKhKjKiKdKdKdKdKiKjKhKcKaKcKeKdKdKeKeKdKfKcKaKaKaKbKeKfKdKbK^K[K]KaKdKdKeK]KVKVKLKMKWKTKRKZKKKCKDK9K3K3K6K8K9KBKNKYKXKTKOKNKQKPKRKSKPKQKPKOKQKPKLKMKOKOKIK:K0K)K'K)K)K*K)K$KKKKKKKK$K$K!KKKKKKKKKKKKKKKKKKK!K#K$K"KKK;KGKCKEK?KDKVKPKGKLKWKAK3K5K4K0K(K$KKKKK!K$K$K#K"K'K.K3K4K.K)K&K%K$K$K$K#K$K$K!KKKKKKKKKK K KKKKKKKKK"K#K$K!KKKK K K!K"KKKKK#K'K%K'K%KKKK$K&K$K'K%K!KK$K)K'K!K!K"K KKK K!KK$K*K,K.K.K.K"KKKKK!K$K+K3K2KK?K?K>KK0KSKRKKKFKUKJK4K5K4K5K+K$KKK K!K!K!K"K&K0K5K3K.K+K+K,K+K(K%K#K"K#K$K#K#K&K"KKKKKKKKKK K KKKKKKK!K K"KKKKK!K K!KKKKKK%K&K%K'K#KKKK$K%K$K'K"KK!K&K)K$KK!K!KKKK K!KK%K.K-K/K.K.KKK KKK!K%K4K5K1KOKxKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKxKwKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKxKyKyKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|KpKVKLKKKKKLKKKLKKKLKLKMKKKKKKKLKKKHKJKGK*KKK5KLKOKLKFKDKFKGKGKCK>KK=K=K>K>KK>KKPKXKWKRKSKSKSKRKRKQKQKQKQKQKPKMKNKOKQKMKCK5K'K%K*K*K(K*K%KKKKKKK K&K(K"KKKKKKKKKKKKKKKKKKKK%K(K"KKKKKKKKK K+KCKEKBKGK0KCKXKOKEKMKTK@K5K5K5K1K+K$KK#K)K/K2K-K*K)K)K,K-K.K,K.K2K4K4K,K%K$K$K$K$K"K$K$K%K$K KKKKKKKKKKK KKKKKKKKKKKKKKKKKK$K$K$K$KKKK#K$K#K(K#KKK#K&K'K KK KKKKKKK"K+K-K.K.K1K"KKKKKKK3KK=K=KK>KK/K)K*K*K*K*K)K$KKKKKKK"K(K'K KKKKKKKKKKKKKKKKKKKK'K'K!KKK KKKK!KKK%K%K$K=KEKCKFK8K5KYKQKHKNKVKGK5K5K5K4K.K)K&K,K+K'K(K(K(K*K+K-K-K-K0K4K2K(K"K K$K$K$K$K$K"K$K$K#K$K%K#KKKKKKKKKKKKKKKKKKKKKKKKKKK"K$K#K$K!KKKK$K#K#K%K KKK#K'K KKK KKKKKKK$K(K,K/K2K0KKKKK KK$K5K=K;KJKuKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKxKyKyKxKxKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K{K_KNKNKLKKKLKKKKKKKLKJKIKKKKKLKJKHKHKIK>KK K KDKOKNKIKDKFKGKGKEKAK=KK>KKJKPKWKSKQKFKEKTKUKUKRKRKSKRKRKSKQKPKPKQKSKOKBK4K(K'K(K*K)K'K%K!KKKKKK#K)K,K'KKKKKKKKKKKKKKKKKKK#K)K)K#KKK K!K!K KK K!K(K'K"KKKKKKKK!KCKEKBKHK/K@KXKOKIKOKUKDK7K8K6K1K-K)K!K!K#K&K,K/K*K&K#K"K$K$K$K$K$K#K"K!K!K$K$K$K#K!K$K+K0K&K#K$K$K#K#K$KKKKKKKKKKKK KKKKKKKKKK!K$K#KKKKK#K$K#K$K KKKK$K!KKKKKKKKKKK$K#K'K.K/KKKKKKKK$K@K—KÔKÏKKpKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKxKzKzKxKxKxKyK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KiKPKJKLKLKKKKKLKKKKKLKLKKKKKKKKKLKKKMKIK,KKK3KJKPKKKGKFKGKGKEKBK=K=K=K=KK?KAKCKIKSKSKRKGKDKNKVKWKWKUKRKRKSKRKRKRKQKPKRKOKBK0K)K'K)K+K*K*K$K!KKKKK!K'K*K)K$KKKKK KKKKKKKKKKKKKK$K+K(K#K KK!K"K"K K!K#K%K)K$K KKKKKKKKKKK;KGKDKFK6K4KWKRKKKLKWKKK8K9K8K6K1K-K#K"K*K-K+K%K!K#K#K$K"K"K#K K K"K"K"K"K"K$K$K&K,K4K7K6K1K,K$K$K$K$K#K$K#KKKKKKKKKK K K KKKKKKKK K"K!KKKKK!K"K#K!KKKKK%KKKKKKKKKKK!K"K"K%K.K$KKKKKK K!K,KœKÓKËKÒK¹KwKvKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKwKwKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKyKxKzKzKyKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K|K|K{KzKzKzK{KzKzKdKKKKKLKMKLKKKLKKKKKKKKKKKKKKKKKLKKKIKEK(KKK8KNKPKNKFKEKGKDKDKDK=KK.K(K&K+K,K,K(K"KKKKKK K'K)K&K"KK K!K!KKKKKKKKKKKKKKK#K*K'K KK K!K!K"K$K!K$K(K(K!KKKKKKKKKKKKKK1KFKFKGK>K-KRKSKNKJKTKQK;K9K8K8K4K-K*K&K%K!K"K#K$K$K"K K K K K K!K"K K#K"K"K*K1K7KKAKFKPKXK[KYKXKSKPKVKVKUKUKVKUKSKTKTKRKRKTKRKIKK=K?K@KBKCKMKZK]K[KWKWKWKXKWKVKUKVKVKVKTKRKRKQKPKPKHK9K,K'K*K,K+K)K(K#KKKKK K%K+K*K"KKKKKK K!KKKKKKKKKKKK K&K*K'K!K K!K$K$K$K#K$K'K+K)K!KKKKKKKKKKKKKKKKKK!KCKDKCKFK7KAKYKQKIKIKWKFK9K:K9K8K4K-K!KK KKKKKKK K"K"K!K!K$K.K6K9K8K8K8K7K/K1K4K9K=K;K2K+K&K%K$K$K$K$K$K$K%K!KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK'K!KKKKKK!K!K#K)K'KxKÐKËKÎKÕK›KtKvKvKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKwKuKwKyKxKxKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKxKxKxKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KzK{K~K|KzK{K}KqKQKKKMKNKMKLKLKKKKKKKKKKKKKLKKKHKHKHKKKKFKDKFK9K2KZKRKHKFKUKKK:K;K9K8K4K3K&KKKKKKK K!KKK#K(K/K8K;K8K9K8K4K3K0K2K:K=K;K1K)K$K#K$K!K"K#K$K%K%K$K$K$K$KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK"KK KKKKK!K"K$K&K)K:K²KÏKËKÒKÂK}KwKxKuKuKuKuKuKuKvKxKwKuKuKuKuKvKyKwKuKwKyKxKxKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKzKzKzKyKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K}K}K}K~K|KzK|K}K~KjKPKKKLKLKLKLKKKKKKKKKKKKKLKKKHKHKHKJKJK4KKK(KHKOKMKHKEKGKFKGKFK@K:K=K=KKKK9K>K8K;KK:e]qš(KdKdKeKfKcK^KUKPKNKMKKKKKMKbKŒKÂKåKïKéKäKåKçKèKèKèKéKéKéKëKìKëKìKíKëKéKëKïKïKÜK·K‹KoKhKnKvKyKzKuKsK€K KÉKæKñKíKéKêKëKëKéKìKðKñKÚK³K~KdK¬KñK«KzKéKÙKÆKõKïKòKæKìKòKðKðKóKêKªK·KæK·KwKKˆKƒK›KK|K|KˆKlKdK=KhK^KYKhKmKjKiKiKiKiKgKeKaK]K^K`KcKgKiKiKgKbK`K_K^K\K\K\KZK[K\K\K\K[KZKZKYKXKWKJK9K,K(K*K+K,K*K#KK"K"K#K&K*K*K,K)K%K&K+K*K(K'KKKKKKKKKKKKK#K&K/K4K2K1K3K1K3K2K0K0K2K1K+K#K KKKKKKKKKKKKKKKKKK-K.K+K%K#K$K%K#K#K!K%K,K-K'KKKKKKKKKKKKKK'KCKCKDKEK,KEKXKPKFKJKWKHK:K:K:K9K8K7K#KKKKKKKKKKKK K"K KKK$K-K6KKe]q›(KdKeKeKdKeKeKfKaK]KUKNKMKMKIKFKRKtK¦KÖKìKìKçKåKæKèKéKéKéKìKìKìKìKëKîKîKìKéKçKëKïKêKÎK¢KzKgKkKrKwKxKuKtKuKK·KÛKîKñKìKêKëKëKêKëKðKóKçKÄKŽK§KæKÆKíKÐKÐK÷KïKòKåKíKòKïKïK÷KÝK˜K¾KèK²KtKŒK†K„KœKˆK~KK‡KiKaKVKfK_KkKlKkKiKiKjKjKgKdK_K`KbKfKjKmKnKiKeKbK_K`K_K\K]K]K\KZKZKZKZKZKZK[K\KXKHK2K)K,K-K,K,K)K%K K K!K!K%K)K.K+K'K&K%K%K%K*K+K)K)K$KKKKK K KKKKK(K0K4K2K2K3K3K3K2K2K3K4K,K&K#K K K!K!K!K!KKKKKKKKKKKK"K+K.K)K%K$K$K$K&K%K$K(K+K,K"KKKKKKKKKKKKKKKKKAKDKCKFK8K:K\KSKJKGKWKNKK>K;K7K2K5K:K9K;K?K9K2K'K#K"K&K'K&K$K!K"K#K#K&K'K&K&K$K%K,K7KAKKDKCKFK>K2KXKRKMKDKQKTK>K;KK1K&K%K%K#K$K#KKKKKKKKKKKK K KKKKKK KKKKKKKKKK K"K$K&K'K(K)K*K+K.K1K;K¨K×KÒKÕKÒKŒKtKyKxKxKxKwKxKxKvKuKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKyKxKyKyKxKxKxKyKzKzKzKzKzKzKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KwKXKIKJKJKIKKKJKIKIKIKLKKKJKIKHKIKHKHKHKIK3KKK"KDKKKOKKKFKEKFKEKDe]q(KdKdKdKdKdKdKdKdKdKdKeKfKcKZKRKJKLKKKIKFKRKoK¡KÐKêKîKéKæKæKèKêKëKìKëKëKìKëKèKêKìKëKêKçKìKóKíKÑK£K}KlKkKsKyKyKvKrKxKK¾KÞKðKïKëKìKíKíKìKíKòKïKåKæK¼KæKóKðKðKæKïKñKñKïK÷KÇKžKÏKéK•K{KŒK†K„K¡K„K|K…K€KaKnKoKoKmKkKlKlKkKeKbKbKfKjKmKmKnKmKlKhKcKaK_K`K`K_K`K^K\K^K[K\K]K[K[KRKAK0K&K)K+K,K+K)K#KKKKK!K%K*K,K'K"K&K%K(K)K&K&K KK'K+K'K)K)KKKKK K KK KKK,K3K5K5K6K8K2K+K!KKKKK"K!KKKKKKKKKKKK!K+K-K+K(K$K%K'K&K#K"K&K+K*K*K%KKKKKKKKKKKKKKKKKKK%K&K7KDKCKCKDK.KOKTKOKFKMKYKDK:K=K=K=K:K7KKKKKKKKKK"K(K-K2K4K4K6K:KK@K;K2K(K!K!K!K$K$K#K"K"K!K!K$K%K)K*K'K%K+K5KBKMKKKHKIKIKBK@K?K9K0K$K$K$K#K"K$KKKKKKKKKKKK KKKKKK KKKKKKKKK K"K$K%K&K(K)K+K*K-K0K-KgKÒKÔKÕK×K²KvKyKxKxKxKyKxKxKvKuKuKvKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKxKxKxKxKxKxKzK{KzKzKzKzKzKzKzKyKxKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KrKSKIKIKIKLKJKHKHKHKJKJKHKHKIKIKIKGKFKHKHK/KKK(KEKLKPKIKFKGKDKCe]qž(KbKcKdKdKdKdKdKeKcKaKdKeKeKeKaK_KWKMKIKIKKKGKHK[K…K·KàKïKîKçKçKèKéKéKéKéKéKèKêKìKìKìKëKëKêKëKðKòKâK½KKpKhKnKvKyKwKtKuK‚K¥KÎKêKñKïKíKîKíKíKíKðKïKÎKæKïKðKíKçKñKðKñKðKöK¼K¤KÐKåKŒK}K‹K…K‰K¢KKzKyKxKsKpKnKlKmKkKiKeKbKdKgKkKmKoKoKkKlKkKkKiKbK_K`K_K`K_K]K]K\K]K]K\K[KRK@K.K(K*K-K-K+K(K#KKKKK!K%K'K'K&K%K%K$K%K)K(K%K KK"K%K(K)K)K)K*K'KKKKK KKKKK(K0K7KK7K.K%KK"K$K!K!K!K"K"K!K$K)K)K(K(K%K(K/K=KHKIKKKKKHKFKAKAKCKFKDK5K*K$K"K"K%K$K$K%K"KKKKKKKKKK K KKK +KK KKKKKKKKK!K!K#K&K)K)K)K+K*K,K/K3K;K©KØKÕKÕKÓKKuKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKxKzKzKzKzKzKzKzKzKzKzKzKzKyKxKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K|KzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKKmKOKLKIKIKIKHKJKKKIKHKIKIKIKHKHKHKHKIKIKHK'KKK.KGKNKOKIKFKDKBe]qŸ(KfKeKdKdKdKdKdKeKdKbKcKeKdKdKdKdKdKdK\KSKLKIKJKJKHKLKgKšKÊKêKñKêKæKèKéKéKéKèKêKìKìKìKìKìKìKëKëKèKíKòKìKÐK§K~KjKiKrKuKvKtKrK{K“KºKàKñKõKìKêKíKíKíKíKçKéKëKéKâKíKòKðKðKõK²K§KÒKäK‡KKK„KK KuKuKwKtKpKoKnKlKiKfKfKgKhKmKpKrKoKmKmKkKmKmKiKdK`K_K`K_K`K^K\K[K\K]K[KPK=K-K+K+K,K,K*K%KKKKKK#K&K$K'K#K$K%K%K%K$K%K"KK K"K&K*K*K)K)K(K)K)K*K KKKK K KKKK'K3K1K)KKKKKKKKKKKKKK!KKKK K+K/K0K+K(K&K%K%K%K%K$K)K/K*K"KKKKKKKKKKKKKKKKKKK#K*K)K(K%K&K$K.KDKDKCKGK7K:K[KQKJKDKUKRK=KKBKEKAK6K,K"KK KK!K$K#K$K$K$K%K"KKKKKKKKK K +K KKK KKKKKKKKK!K!K#K&K)K(K)K+K+K/K/K5K1KdKÐKÓKÓKÛK·KvKzKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKyKzKzKzKzKzKzKzKzKzKzKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K~K|K{K|K}K}K}K}K}K}K}K}K}K}K}K}K}K|K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KfKLKJKHKIKIKKKLKIKHKIKIKHKIKIKIKIKIKHKJKDK#KKK3KHKNKNKJKFKCe]q (KgKfKeKeKdKdKdKdKdKeKbKeKeKdKdKdKdKeKfKeKaKZKRKKKJKKKGKGKTK}K±KÛKðKïKéKçKèKèKêKìKìKìKìKìKìKìKìKìKëKêKëKñKñKâK¿K“KqKgKkKuKzKyKuKtK‚KªKÓKéKóKïKìKíKíKîKîKìKãKÞKêKëKèKñKòK©K­KÔKÝK€K…K‹K„KŽKšKwKxKsKqKqKoKjKeKdKgKjKnKqKrKrKpKpKpKqKpKmKmKjKdK`K_K_K_K`K^K]K^KZKMK;K.K*K*K-K,K+K%KKKKK!K"K%K&K"K#K%K$K$K$K%K&K"KKK K&K)K)K)K'K&K*K.K)K'K)K'KKKKK KKKK$K"KKKK K KKKKKKKKK KKK K"K-K4K4K1K.K+K(K%K$K$K)K,K.K+K KKKKKKKKKKKKKKKKKK K%K*K)K'K)K&K%K%K%K)K?KEKCKEK>K.KXKSKKKFKRKWKBK:K=KK2K&K"K#K#K!K!K KK"K%K$K#K#K#K$K#KKKKKKKK K K K KK KKKKKKKK K K"K#K&K&K&K*K+K*K.K.K1K5K8K£KØKÓKÙK×KKuKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K~K}K}K~K{KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K{K_KJKHKJKLKLKLKIKHKIKIKHKJKLKIKIKIKHKHKJK?KKKK8KLKNKMKHKDe]q¡(KdKhKfKdKdKdKdKdKdKdKcKeKeKdKdKdKdKdKdKdKdKeKfK_KUKNKJKIKHKCKIKbKKÅKçKñKëKèKèKêKêKêKìKìKìKìKìKìKìKìKëKëKêKìKóKïKÖK«K€KlKlKrKvKuKsKrKyK’K»KáKôKòKíKìKíKíKåKâKìKéKèKòKîK¡K±KÙKÔKxK†K{K}KKšKzKvKpKpKnKiKgKgKkKoKrKtKrKnKmKqKrKpKpKnKlKjKdKbK`K_KaK_K_KaKYKJK6K+K,K-K.K+K*K$KKKKKK!K$K$K!KK K$K#K#K$K!KKKK K$K%K&K*K)K(K(K/K9K8K-K'K)K(K$KKKKKKKKKKKKKKKKKKKKKKKKK#K/K4K5K2K0K0K-K*K&K&K,K.K,K$KKKKKKKKKKKKKKKKKKK$K)K)K(K'K(K(K)K%K&K'K&K%K:KEKCKCKDK*KOKWKMKFKKKXKGK;K=KK=K=K%KK"K#K$K'K)K)K*K,K0K1K/K(K!KKKK!K!KK K K#K%K%K%K%K"K#K&K2K@KFKIKGKAKAKDKGKGKGKAK@K8K-K#K"K#K"K KKK K$K%K'K)K(K%K$K%K$K#K%K"KKKKKKK K +KKK KKKKKKKKK K!K#K&K(K(K+K,K,K-K0K0K4K0KdKÐKÔKÖKÜK¹KxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K|K}K}K}K{KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K}KzKUKGKJKJKJKJKIKHKIKIKHKJKLKIKHKHKJKHKHKIK9KKKK=KJKOKJKEe]q¢(KKhKbKdKhKfKeKdKdKdKdKdKdKdKdKdKdKeKeKeKeKdKdKfKfKbK[KQKIKGKFKGKFKOKsK¨KÖKîKðKêKæKèKìKìKìKìKìKìKìKìKìKìKìKëKìKíKñKôKèKÄK”KqKiKlKrKuKtKqKnKK¥KÑKíKöKïKìKãKãKíKëKëKóKèK›KµKÞKÍKsKˆK†K~K’K˜KvKsKkKgKgKgKkKnKrKrKqKpKnKnKoKnKmKnKoKmKjKeKaK_K_K_KbK`KYKIK1K*K*K-K/K.K(K"KKKKKK!K"K$KKKK K"K$K$K!KKKK!K!K#K$K$K&K)K,K3K:K=K;K8K6K-K(K'K&K!KKKKKKKKKKKKKKKKKKKKKK(K1K8K:K6K1K/K/K,K,K-K0K1K-K"KKKKKKKKKKKKKKKKKKK)K+K(K(K(K)K)K)K(K(K*K)K)K)K"K1KCKCKCKGK.KCKYKNKJKHKUKLK=KK:K:KK5KK K!K"K&K*K(K&K"K KKK KKKKK"K#K%K&K$K"K K%K0K:KEKFKDKAK=K>K=KBKFKGKDK:K.K%K#KK$K KK!K K&K)K+K-K,K*K'K*K,K-K0K.K)K&K$K#K#K!KKKKKKK K +K K K KKKKKKKK K!K#K&K)K*K,K+K,K/K0K/K0K8K5KdKÐKÔKÕKÛK»K|KzKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K}K|K}K}K}K}K}K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KlKMKHKIKIKHKHKIKIKHKIKJKIKHKHKIKHKHKHKIKGK/KKK'KEKNKLe]q¤(KëKðKïKßK¸KKmKdKeKhKiKgKeKeKdKdKdKdKdKdKdKdKdKdKeKdKdKdKfKgKcK]KRKJKFKGKHKGKLKmKŸKÑKêKïKéKèKëKëKìKìKìKëKíKîKîKîKîKîKíKìKíKðKòKçKÃK“KtKgKiKnKpKlKfKdKzK£KÒKêKîKçKìK÷KÓKœKÄKäK¤KrKŒK‹K~K˜KlKMK]KdKiKoKuKsKsKtKtKrKqKpKmKoKmKlKiKhKhKaK_KbK^KUK@K1K*K,K.K/K-K(K"KKKKKK$K$K KK KK K!K!K!K!KKKK K"K K!K K K K)K3K8K=KK>KK>K@K0K$K&K&K#KKKKKK K KKKKKKKKK#K-K7K;K9K5K5K5K3K3K6K7K7K4K)KKKKKKKKKKKKKKKKKKK'K-K.K+K(K(K(K)K*K*K)K*K,K)K&K$K%K$K!K#K#K>KEKBKDK?K,KXKTKOKJKUKWKCK9K>K=K=K=K;K$KK"K%K$K!KKKKKKKKKK"K"K$K$K"K KK(K6KCKGKFKEKDKCKK¢KÙKÔK×KÚK˜KvKyKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KeKKKHKIKIKHKHKHKIKHKHKHKIKHKHKHKHKIKIKGKCK(KKK-KEKJe]q¥(KíKèKéKîKóKìKÓK«K‚KiKbKeKgKgKgKfKfKfKfKeKdKdKdKdKdKdKdKdKdKdKdKeKgKbKYKPKHKGKGKFKDKXK‚K·KáKñKïKèKçKëKìKìKìKîKîKîKîKîKîKîKîKíKìKïKóKðK×K­K‚KlKfKfKfKaK]KUKÀK÷KëKåKíKôKÉK­KÔKèK”KvKŒK…K‚K—KVKHKaKsKŽKŒKtKyKwKuKsKtKrKpKmKlKkKlKgKbKcKdKaKTK?K/K+K-K/K-K+K&KKKKKKK"K%K KKKK!K!K!KKKKKKK!K!K K!K K!K*K4K8K:K7K:K=K=KKHKKKIKHKEKCK?K;K=KBKCK:K-K%K$K%K%K#KK!K%K&K,K,K+K*K)K)K,K1K2K3K5K4K3K0K.K+K/K1K-K+KKK$K$KKKKKKK K +K KKKKKKK K!K!K#K&K)K+K+K+K,K0K2K2K3K2K8K5KaKÏKÕKÖKÛK¾K{KyKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKxKzK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}K}KzKzKzKzKzK}K}K~K}KzK|K~K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K{K{K^KIKJKIKHKFKGKIKHKIKIKHKHKHKHKHKIKJKGKIKEK%KKK/KHe]q¦(KÕKîKôKíKéKèKïKñKæKÈKœKwKbK`KfKiKhKfKfKdKdKeKeKdKeKeKdKdKeKeKeKdKdKeKhKgK_KTKKKGKFKHKFKJKhK™KÎKëKñKîKêKêKëKîKîKíKîKîKîKîKîKîKîKíKìKìKòKôKæKÃK—KtKbK[KZK_KÐKóKíKîKîKòKÑK¸K×KàK‡K}KŠK‡K‚K–KFK9KfKŸK›K€KxKwKuKsKsKtKrKoKkKkKnKjKdKaK^KRK>K.K-K-K.K/K,K$KKKKKKK!K!KKKKKKK!K KKKKK K KK K KK"K+K1K5K8K7K:KKKKK7e]q§(K¢KžK»KÝKóKóKìKéKìKòKðKßK¹K‹KpKdKdKgKgKgKfKgKfKdKfKgKeKdKdKdKdKdKdKdKdKgKgKeKeKZKPKHKFKFKDKFKUKzK±KÞKðKïKêKêKëKìKîKîKîKîKîKîKîKîKîKíKìKìKïKôKñKØK¬K„K`KXKßKñKíKíKîKñKÝK¿KÚKÜK‡KƒK‰K†KƒK”K7KBKvKtKrKxKtKsKtKsKpKqKqKnKiKiKlKgK^KMK9K/K,K.K/K/K*K"KKKKKK"K#K!KKKKKK K"K!KKKKKKKKKKK"K(K2K6K5K5K4K8K:K9K;KAK@K8K-K,K-K+K,K-K*K'K&K%K&K%KKKKK +K KKKK(K0K4K8K8K7K6K9K=K;K3K(K#K"K$K KKKKKKKKKKKKKKK&K*K*K)K)K*K+K+K)K'K)K'K&K&K&K%K&K(K%K$KKKKKKKKK&KDKCKCKFK9K7K\KTKLKJKUKRK@K>K?K>KK:KKKKKKKKKK$K KK K K)K8KCKNKPKPKLKHK>K@KEKCK>K.K'K!KK K!K!K"KK#K(K,K/K.K*K)K*K-K2K4K6K9K8K9K9K9K8K8K:K7K3K*K KKK K KK#K$K%KKKKKKK +K +K KKKKKKK!K K#K%K&K'K)K(K.K0K0K3K3K2K4K8K8K`KÎKÙK×KÚKÀK|KxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KzKxKxKxKxKyKzKzK{KyKxKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}K~KzK{K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~KqKOKIKGKIKHKHKHKHKHKHKHKHKIKIKHKIKHKFKGKHK9KKKe]q¨(KÄKÓK·KžK¤KÆKæKôKðKéKèKíKïKíKÙK±KˆKkKcKfKiKhKgKdKdKeKeKeKdKeKeKeKdKdKeKeKeKeKdKfKgKaKWKLKEKGKGKDKFKbK’KÄKèKòKïKëKëKìKíKíKîKîKîKîKîKîKîKîKíKìKíKòKôKèK¾K•KçKðKíKîKíKðK×K¿KÜKÖK|K„K‡K‚K‹KžKrK|KvKwKxKuKtKsKsKrKqKpKpKlKkKkK_KOK8K*K+K0K.K,K(K%KKKKKK"K%K$KKKKKK K KKKKKKKKKKKK$K*K1K2K2K4K6K5K4K9K;KK=K=KAK$KKKKKKKK KKK"K.K9K@KDKDKFKIKHKHKFKHKCK1K(K"KK K"K!K"K K"K&K,K/K/K-K-K+K-K2K6K8K:K6K3K7K;KK8K-K)K&K)K-K.K)K&K$KKK#K(K'K&K'K$K&KKKKK K KKK K-K1K8K7K3K-K#KKKKKKKKKKKKKKKKKK'K/K/K+K'K(K)K)K)K(K(K(K)K(K&K#K#K$K&K'K KKKKKKKKKKK K$K(KK>K?K?K=KBK0KKKKKKKKK#K1K:K?K@K@K@K>K>K=KFKRKLKK?K;K6K5K6K8K;K:K7K7K2K(K KKKKKKKKKKKK$K%K&KKKKKKK K +K KKKKKK!K"K$K$K'K*K-K.K.K0K2K3K2K3K5K6K;K8K`KÌK×K×KÛKÅKKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KzKxKxKxKxKyKzKzKzKzKzKzKzKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K~K~K{KzKzK{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€KK}K~K~KaKIKIKIKIKIKHKHKHKHKHKIKHKIKHKHKIKHKFKGKGK0Ke]qª(KÝKtKEKRKzK²KÑKÇKªKžK´K×KïKóKëKèKëKòKòKåKÂK—KwKgKdKgKhKgKeKdKeKeKfKfKfKfKfKfKfKfKeKeKgKgKhKhKcKWKKKEKEKEK@KDK[KŠKÁKèKôKñKìKëKìKîKîKîKîKîKîKîKîKîKîKíKìKáKêKîKæKéKïKêK¼KÆKáKÕK|K†K‚KK…KŸKvKyKwKwKvKsKpKnKkKiKlKmKcKLK4K-K/K1K/K,K(K KKKKK"K&K%K!KKKKKK KKKKKKKKKKKK!K'K-K0K.K3K4K4K3K2K4K8K;K3K,K&K$K&K)K,K,K&K KK!K'K,K.K(KK%K%K$K&K$KKKKK KKKK1K2K3K'KKKKKKKKKKKK KKKKKK!K-K2K0K-K+K*K,K*K*K*K'K&K&K'K&K#K$K%K%K#K KKKKKKKKKKK%K*K'K'K&K5KEKEKFKGKBKMK[KUKJKEKTKRK?K?K=KK@K:KKKKKKK%K,KK?K7K(K#KKKKK!K#K$K'K)K#K$K*K)K+K2K;K=K>K9K;K9K;K=K>K;K8K3K-K%KKK KKKKKKKKKKKK#K'K%K#KKKKKK K K KKKKKKK!K"K#K'K(K+K-K/K0K0K3K3K3K4K6K6K;KK>K?KKKKK#K0KBK@K;K9K8K8K9K9K6K8K3K+K"KK"K#K!KKK"K$K)K+K)K)K&K)K2K9K;K=K9KKK;K6K3K4K2K.K+K+K)K'K$K$K"KK K#K#K!K KKKKKKKKKK#K'K)K)K(K'K(K(K'K%K+KCKGKFKGKDKGKXKWKRKHKPKYKKKK?K>K>K@K-KKK"K(K2K?K;K3K1K2K6K8K8K.K%KKK!K!K!K!K#K%K(K)K(K)K)K)K,K3K;K?K>K:K3K+K:K?K;K=K9K4K(KKKKKKKKKKKKKKKKKKKKKK$K$K%K%KKKKKK K K KKKKKK K!K$K'K(K)K-K0K0K/K1K3K5K3K5K8K8K;KK;K9K;K>KAKAKCKAK8K/K!KKKKKKKKKKKKKKKKKKKKKKKKK%K&K*KKKKKKK K KKKKKKK!K$K&K)K)K,K/K0K/K1K4K6K6K7K8K8K;K;K]KÍKÛKØKÜKÎKƒKxK{KzKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~K~KK~K}K}K~K€KK~K~K~K~K~K€KjKKKGKIKGKGKIKHKHKHKHKHKHKIKHKGKGKFKGKFe]q®(KgKiK_K|KÚKÒKxKaKkKiKiKcK}KÏKÑK™K°KÑKÅK©KŸK¶KÚKðKóKíKéKëKñKóKäKÁK“KqKeKfKiKjKiKiKgKfKfKfKfKfKfKfKfKfKfKfKfKfKgKhKeK]KQKEKDKDKCKBKSKzK²KàKôKòKíKìKìKðKêKßKæKïKíKíKóK¾K°KÓKâK„KlKˆKˆKtK“K‹KoKtKuKlKXK>K-K.K0K1K.K+K#KKKKK K#K$K!KKKKKKK KKKKK K"KKKKKK#K+K.K.K/K/K3K2K3K4K6K0K+K&K!K K#K$K$K%K"KKKK!K$K$K$K#K!K"K-K:K@KFKDKDKBKBKEK@K1K&K&K%K!KKKKKKKKKKKKKKKKKK-K;K@K@K=KKKKAKCKCK=K2K$KKKKKKKKKKKKKKKKKKKKKKKKKKKK*K+K,K%KKKKKK K K KKKKKK!K$K$K(K)K*K-K0K3K3K4K4K4K7K8K8K:K=KK=KK8K-K&K"K#K$K%K$K#K%K!K!KKKKKKKKKKK'K,K.K+K)K)K)K(K(K)K,K-K'K"KKKKK%KEKFKGKGKAK?KYKVKOKGKPKTKEK@KBKAK@KBKDK/KKK!K%K%K"KKKKKKKK!K%K(K(K&K(K)K,K1K8K?K=K>K=K@KBKBKCKCK>K:K*KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK$K,K*K*KKKKKKK K KKKKKK!K#K$K'K(K*K,K/K1K3K5K4K5K8K8K8K9K=K;K\KÍKÚK×KÜKÑK…KxKyKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K|K|K|K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K}K}K~K~K}K}K}K~KKK~K}K}K}K~K~KKKKKKKK~K€KzKZKJKHKIKHKGKFKGKHKHKIKIKHKHKGKGKGKGe]q°(KbKiKfKiKcKeK³KêKKcKgKgKhKdKdK±KëK˜KMKHKdK˜KÆKÎK´KžK©KÍKçKôKòKëKìKðKôKëKÑK§K~KhKfKgKjKiKfKfKfKfKfKfKfKfKfKfKfKfKfKfKfKhKiKeK^KRKIKCKCKDKBKMKtK«KÜKóKíKòKîKïKïKîKîK®K¹K×K×KoKxKK~K|K•KuKQK7K1K0K/K/K.K%KKKKKKKKKKKKKKKKKKKKKKKKKKKK%K,K.K*K-K0K.K1K3K4K5K.K&K KK K"K$K$K$K"KKKK!K$K$K$K#K"K&K/K=KEK@K:K:K>K@KDKHKKKHKKK>K?KK?KCK7KKKKKKKKKKK!K#K$K&K&K(K'K(K/K7K;KBK@K>K@KCKEKHKIKEKAK/KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK+K,K+K%KKKKKK K K KKKKK!K!K$K%K&K+K*K-K0K3K5K4K7K9K7K8K7K:K@K?K—KÞKÙKØKÞK°KwK{K{KyKxKxKxKxKxKxKxKxKxKxKxKxKxKzK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K~K~K~K~K{KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KK€K}K~K€KK}K}K}K}K}K}K}K}K}K}KK€KKKKKKKK€KK~KuKQKHKIKFKFKFKFKFKHKHKFKFKFKHKIKIKHe]q±(KKbKfKhKhKeK_KšKéK°KgKfKhKhKgK^K˜KëK¸KiKXKKKGKkK¨KÏKÉKªK KµKÔKîKôKíKéKìKóKõKèKÅKšKwKgKfKhKjKiKiKhKgKgKgKgKfKfKfKfKfKfKgKgKgKhKhKdKYKMKGKDKDKCKBK[KK§KµKíKëKëKïKêK§KÀKÛKÒKiKyK~K|K_KMKKDKEK?K:K9K=KCKGKCK8K1K.K.K0K/K*K%K&K(K"KKKK K K KKKK0K8KK?K>K>K=KAK;K)K"K"K#K#K#K$K"K!KKKKKKKKKKK$K+K,K-K,K.K-K,K+K+K-K.K)K%KKKKKKKKKKK;KHKFKFKIK,KJK\KSKIKJKYKQK@KBKAKAK?KCK?K%KKKKKKKKK K#K%K$K$K&K,K3K9KK;K@KCK?K4K+K-K0K0K1K.K&K!K%K&K&K$KKKKK K KKKK-K5K6K:KK—KÞKÙKÛKÞK±KxK{K{K{K{KzKxKxKxKxKxKxKxKxKxKxKzKzKzKzKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K{KzKzK{K}K}K}K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€K€K€K€K€KKKKKKKKKKKK€KfKIKFKHKIKGKFKFKFKGKGKIKHKHKHKIe]q³(KKáKÉKpKbKhKgKiK^KuKÓKÙK~K`KjKjKlK`KtKÒKÚK}KbKlKjKbKYK„K×KßKÇKÍK½K¥K§KÄKæKóKóKîKìKðKõKïKÖK­K…KlKdKgKkKhKhKgKiKiKgKfKfKfKfKfKfKfKgKhKhKhKiKeK[KNKGKDKJK?KcKéKåKòKÜK KÈKæK¼K_KzKtKWKKKK"KKKKK K KKKKKKKKKKKKKKKKKKKKKK K'K,K1K3K3K1K0K-K0K3K2K)K!KKKK K"K KKKKKK"K!K!K KK"K*K0K5K9K9K9K:K=K=K=K@K@K;K3K.K.K0K1K1K.K'K$K#K#K'K&K&K&K#KKKKK K KKK$K7K8K9KKAK?KDKFK?K/KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK+K.K/K)KKKKKKKK KKKKKK"K&K&K)K*K.K/K1K3K3K4K7K8K9K:K8KK[KÍKÚKÜKÝK×K‹KvK{K{KyKxKxKyKzKyKxKzKzKxKyKzKzKzKzKzKzKzKzKzKzKzKzKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K}K}K}K}K}K|KzK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}K}K}KKK}K~KKKKKKKKKK€K€K€KKKKKKKKKKKKK}K^KFKGKGKGKFKGKGKFKGKGKGKGKGKGe]q´(K[KoKÐKÜK€K`KhKgKiKaKiKÀKäKKbKjKjKjKdKiK¾KäK‘KaKhKkKkKaKKÔKÇKK›KËKÐK·K¢KªKÍKìKöKñKêKìKóKöKéKËK K|KgKeKjKlKkKiKfKfKgKgKfKgKgKfKgKiKhKfKfKgKiKiKbKUKHK7KŽKùKïKøKÖK–KÁKáK®K]K{KyK]K%KKKKKKKKKKKKKKKKKKKKKKKKKKKKKK"K.K/K+K0K1K2K3K4K3K.K'K#KK K!KKK!K KKKKK KKK K K#K(K4K6K6K5K7K8K9K;K>K@K@K6K/K,K/K0K0K0K-K$KK!K'K.K.K-K(K%K%K&K!KKKKK KKKK7K?K8K-K!KKKKK KKKKKKKKKKKK K+K1K1K.K)K,K-K,K)K.K2K-K%KKKKKKKKKKKKKKKKKKK-KFKGKFKGKDK.KTKXKPKHKKK[KOKEKDKBKAKAKHK?K)KKKKKKK$K+K.K5K6K8K;K?K?KAKCK=K5K&KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK%K/K.K0K KKKKKKK KKKKKK"K%K&K)K)K-K.K0K3K3K4K7K8K9K:K9K;K=K@K?K–KßKÚKÛKáK·KxK{K{KyKyKyKyKzKyKyKzKzKyKyK{KzKzKzKzKzKzKzKzKzKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K{KzKzK{K|K~K}K}K}K}K~K}KzK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}K~K~KKK~K~K€KKKKKKKKK€K€K€KKKKKKKKKKK€KK€KzKVKHKFKFKGKFKFKFKFKFKFKFKFKGe]qµ(KiK`KeK¾KåK“KbKfKgKhKeKbK§KêK§KeKeKhKhKgK`K¥KëK¥KdKeKjKlKcKqKËKÚKrKOKyKªKÏKÌK±K¢K³K×KïKôKïKëKíKôKóKåKÀK–KtKeKhKiKiKiKjKiKhKjKjKgKfKfKfKfKiKiKiKiKkKlKgK\KªKøKðKúKÎK’K»KÜK“K\KzKwKYK'KKKKKKKKKKKKKKKK K KKKKKKKKKKKK#K)K-K-K,K0K2K3K2K,K%K!K K"K$K"K!KKKKKKK K K KKK%K0K4K6K5K4K6K8K5K8KKCK@K4K&KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK+K/K1K)KKKKKKK K KKKK K!K$K(K)K(K+K.K1K3K3K5K4K7K:K:K9K9K;K?KK;K8K5K5K2K0K,K-K/K)KKKKKKKKKKKKKKKKKKK)K1K2K0K/K.KK_KTKNKFKRKVKEKBKDKDKEKFKLK1K#KKKK!K%K(K.K5K5K;K?K6K)KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK KKKKKKKKKKKKKK(K1K/K/K KKKKKKK KKKKK!K#K'K)K)K+K,K0K3K3K4K5K7K9K:KKBK@K“KÞKÚKÜKàK¶KyK{KzKzKzKzKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K{K|K~K{KzK|K}K}K}K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~K~KKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKKnKMKGKFKGKGKFKGKFKGKGKGKEe]q·(KhKgKgKgK\K’KèK¾KlKcKhKgKiK]K{KÜKÐKtKcKhKgKiK^K|KÜKÐKvKbKkKkKhKbKKìK³KkKaKSKDK[K”KÅKÈK­K£KªKÇKèKöKòKìKëKïKõKíKÑK§K~KkKgKiKjKkKjKhKjKjKjKiKiKiKiKiKiKlKnKÈKùKïKøKµK—KÅKáKªKqKwKyKSK+K&KKKKKKKKKKK K KK KKKKKKKKKKK K)K,K*K,K0K-K(K$K"K#K#K$K$K#K"K KKKKKKKKKKK#K-K5K7K5K5K5K4K4K8K:K6K/K)K*K*K)K+K,K)K'K%K%K+K1K1K2K/K-K/K3K=KIKOKOKNK;K$K$K&K#KKKKKKKKKKKKKKKK KK KKK)K6K@KAK@K?K;K;K9K6K4K5K-K"KKKKKKKKKKKKKKKKKK"K,K3K4K1K/K/K0K/K8KEKEKFKIK=K4K]KXKQKHKNKWKKKCKDKDKBKJKMKKCK@K>K?K=K=K>K;K:K5K)KKKKKKKKKKKKKKKKKKK(K0K2K4K5K3K2K1K/K0K3K8KEKHKFKGKFK/KXKZKQKIKJKVKNKEKFKDKZKŠK\KBK+K&KKKK&K+K)K KKKKKKKKKKKKKKKKKKKKKK"K&K,K)KKKKKKK K K K K K K KK K"K K K!K K K K KKKKKKKKKKK,K1K1K1KKKKKKKKKKKKK"K%K(K*K+K+K.K3K3K4K6K9K:K:K:KK=K?K?K>K=KK>K?K@KK@KCKAK‘KÞKÛKÝKãK¾KzK{K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}K}K~K€KK}KKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKKKKKKKK€KK€KrKOKFKGKGKFKGKGKFKFe]q»(KtKÒKÛKƒK`KhKgKjKgK_KŸKìK²KhKgKjKgKhK`KˆKâKÆKpKfKiKgKjK_KˆKåKÅKpKdKkKlKeKbK¨KéK£KdKiKkKlKcKzK×KÒKiKLKdKKÂKÒKÀK©K¬KÍKëKõKñKìKìKóKøKìKÍK¡K}KkKhKlKmKnKnK˜KóKóKòKòKÁKªKÎKáK™KpKuKpKKDKDKDKFKIKJKMKOKOKIK?K4K,K)K)K'K&K&K%K&K KKKK K KKKK"KK9K4K-KKKKKKKKKKKKKKKKKK#K-K4K5K5K2K4K4K4K5K7K7K3K(KKKKKKK*KIKFKFKIK?K5K^KYKQKHKPKXKxKÀKÍKÍKÒK¹KYKFK,K*K'KKKK KKKKKKKKKKKKKKK!K#K)K,K)K*K5KIKaKpKwKxKvKAKK#K KKK!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K!K KKKKK*K4K2K5K%KKKKKKKKKKK K"K%K(K+K+K.K/K1K4K7K9K8K8K9K:K=K=K>K@KBKAK[KÉKÞKÞKàKÛK’KxK{K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K{KzK{K{K{K{KzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€K~K}K~K~K€KK}KK€KKKKKKKKKKKKKKKKKKKK€K€K€K€KKKKKKKKKKKKƒKmKJKGKGKFKGKFKFKFe]q¼(K`KfK¾KèK–KbKhKgKgKgK]KŠKåKÇKpKdKlKjKkK]KuKÕKØK|KcKiKiKlK_KwKÕKØK}KcKlKkKjK_K”KèKºKlKfKkKlKcKlKÄKçKKZKRKKKfKžKÌKÐK±K¤K·KÔKîK÷KóKîKðKöKõKäKÁK—KwKjKkKpK¥K÷KñKôKêK¨K°KÓKàK…KoKtKjK9K1K KKKKK!KKKKKKKKKK K KKKKKKKKKKKK!KKKKKK#K$K$K$K"KKK$K+K0K,K'K*K*K)K)K)K*K+K&K!K$K$K'K'K$K$K"K"K"K&K(K*K)K(K'K*K1KK?K>K;K/K$KKKKKKKKKKKKKKKKKK'K0K4K4K4K5K2K1K5K7K9K7K/K KKKKKKKKK)KEKGKFKGKEK/KUKZKSKKKLKWKyKÏKÎKÏKÏKÌKoKIK6K*K,KKKKKKKKKKKKKKKKK$K(K,K)K&K.K?KUKkKsKuKtKrKrKtK[K#K!K KKK K!K K K K K K K!K!K!K K#K$K K!K$K"K K!K!K K K!K KKK#K2K3K3K.KKKKKKKKKKKK!K%K&K(K+K*K.K1K1K5K8K:K9K8K;K=K=K>K=K?KFKCK‘KáKÛKÝKäK·KxK{K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K|KzK}K}K~K|KzKzKzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€K~K}KKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKKKK~KaKFKFKGKFKGKFKFe]q½(KkKeK`K§KëK«KeKeKiKhKkK_KvK×KÛKKbKjKjKkKcKjKÂKäKKcKkKiKlKdKiKÁKäKŽKaKkKjKlK`KKÞKÍKvKeKlKkKhKbK­KêK¡KiKmK_KHKUK…KÀKÚKÄK±K¨K»KßKõK÷KñKîKòK÷KôKÛKºKKwK°KûKñKûKÕKŽKºKÖKØK{KoKtK_K4K2KKKKKK K KK KKKKKKKK KKKKKKKKKKKKKKKK!K"K$K"K"K KK'K,K0K0K-K)K'K*K*K(K&K%K#K$K#K#K!K!K#K"K K"K$K'K'K)K)K&K'K+K-K7KAKBKBKBKBKDKFKFKCKK=K?KKHKGKGKIK1KIK_KWKPKJKVKeKÁKÒKÏKÏKÐK«KªK‚K(K.K'KKKKKKKKKKKKK"K'K+K)K%K)K5KNKeKsKvKtKsKqKsKsKsKrKnK0K!K$K#KK K"K"K"K"K"K"K"K!K K"K"K#K$K"K"K$K#K"K!K K"K"K!K KK!KK,K6K3K5K$KKKKKKKKKKKK%K'K(K+K,K/K0K1K4K6K9K:K9K;KK@K>K?KDKBKYKÇKÝKÝKßK×KKxK{K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K|K{K}K}K}K}K{K{KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~KK€K~K~KKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKK€KK€K{KYKEKFKGKFKFKFe]q¾(KjKiKgK^KŽKçKÂKnKdKlKiKlKaKiKÃKæKKbKiKiKkKdKbKªKìK¦KcKhKjKlKgKaK«KêK£KeKjKkKkKaKpKÊKÜKƒKbKjKkKiK_K™KêKµKjKlKqKhK]KsKËKèKÌKÎKÉK­K©KÆKãKòKóKïKñKóKìKôKœKºKýKóKýKÆK‘K¿K×KÅKpKpKrKRK3K3KKKKKKKKKK KKKKKKKKKKKKKKKKKKKKKKKKKKKKK(K/K.K-K-K,K)K(K)K&K#K#K!K!K$K$K!KKKK!K"K&K&K&K&K#K$K(K/K4K6KGKOKCK>K@KCKCK@K;K1K.K/K.K1K/K)KK K K%K.K-K%K%K%K&K%K!KKKK K KKK,K=KKHKIKHKJK7K>K`KXKRKIKVKZK¬KÖKÎKÐKÍKÜKúKÕK:K)K,KKKKKKKKKK K$K(K*K&K&K.KEK`KpKvKsKpKsKsKtKtKsKsKsKsKwKGKK%K#KKK#K$K$K$K$K$K$K"K K#K$K$K$K$K$K$K$K$K#K#K$K#K K!K!KKK'K4K4K8K-KKKKKKKKKKKK"K'K)K(K,K-K-K1K4K4K9K:K:K:K=K=K?K?K?KAKCKCKKàKÜKÞKäK¼KzK|KzKyK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K~K~K~K~K}K}K~K|KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KK€KKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKKK€KKKwKSKFKGKGKGKFe]q¿(KjKiKjKjK\K{KÚKÕK{KcKlKiKlKfK`K¬KëK¦KcKgKiKjKiK_K•KêKºKlKfKkKkKgK^K”KçK¹KkKfKjKkKfKeK¶KçK™KdKjKlKmKaK„KáKÍKtKfKmKpKgKmKÀKÒKK’KÇKÓKµKµKÇKáKïKïKéKâKðK•KÉKúKòKýK¹K”KÁK×K·KjKqKqKJK2K0KKK KKKKK K!K KKKKKKKKKKKKKKKK KKKKKKKKK!K!KK$K(K*K-K-K-K-K&K#K$K#K K"K KK K KKK K!K#K&K%K%K#K#K'K1K5K4K3K:KHKFK@K>K?K=K3K.K.K0K0K.K+K%KKK"K+K0K-K.K)K$K-K(K#K$K#KKKKKKKK$K*K#KKKKKKKKKKKKKKKKK(K1KKDKGKHKIKHK=K5K^KYKRKIKSKWKKÖKÎKÐKÎK×KöKõKdK%K.K%KKKKKKK%K(K)K*K'K+K=KUKhKtKwKtKrKrKrKsKsKsKsKsKsKsKsKwKaK$K#K#K"KK#K$K$K$K$K$K$K#K"K#K$K$K$K"K"K$K$K$K$K%K$K#K#K"K!KKK#K1K5K6K4K"KKKKKKKKKKK K$K'K(K*K+K-K1K4K4K8K:K:K:KK?K?K?K>KAKEKXKÈKÞKÜKßKÝK—KyK}K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K}K~K|K{K{K|K}K}K}K}K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KK~K}K~KK~K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKKKK€K€KKKKK€K€KKK‚KrKLKGKFKFKGe]qÀ(KgKhKjKjKmK_KnKÉKäKKbKjKjKkKgK[K–KêKºKkKfKkKjKlK`K€KßKÏKvKdKkKkKlK^K€KàKÍKsKdKkKlKgK`KŸKêK¯KkKjKnKqKeKtKÏKÙKƒKfKhKmKoK{KÐKáK©KÈKòKþKòKÖKÒKðKíKéKæKéK‘KØKøKóKûK«K˜KÄKÙK¬KiKpKnKFK6K0KKK +K +K KKKK K KKKKKKKKKKKKK +K +K K KKKKKKKK#K*K&KK$K#K'K*K,K%K!K K$K#KKK!KKKKKK K"K!K K!K!K%K*K/K3K4K5K5K7K=KAK@K=K7K-K)K-K1K4K5K0K'K#K!K%K-K0K3K.K'K+K5K@KNKEK$K#K$K KKKKKKKKKKKKKKKKKKK KKKKK-K>KKKDK;K8K;KKAKHKHKIKGKEK/KUK\KTKMKMKXKvKÏKÐKÐKÏKÒKïKÿK˜K(K.K+KKKK#K&K*K+K(K(K8KLKaKrKxKrKqKsKsKsKsKtKsKsKsKsKsKsKsKsKsKtK4KK'K'K!K!K$K$K$K$K$K$K$K$K$K$K$K$K$K$K$K$K$K$K#K$K$K$K"K K!K!K K+K6K5K8K,KKKKKKKKKKK K#K&K)K,K,K/K1K5K4K7K;K7K6K;K?K?K?K?K@KDKFKBKŒKßKÜKÝKãKÅK}K~K|KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K}K~K|KzKzKzK}K}K}K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKK}K~K€K~K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKKK€K€K€K€KKKKK€K€K€K€K€KhKKKIKFKGe]qÁ(K¿KnKgKkKjKkKeKcK´KìK¡KcKjKiKiKlK_K‚KÞKÏKvKbKkKjKlKcKpKËKàK†KdKlKkKlKcKnKÌKßK„KcKkKlKmKaK‹KäKÄKrKeKeKkKhKrKÉKßK¨K¸KÍKáKíKðKöKõKëKÍK°KÓKÚKÖK÷KïKèKçKàK’KäKöKôK÷K KKÆKÌKKdKqKjKBK7K/KKK K KKKKKK#K K"K KKKKKKKK K K K K K KKKKKKKKK#K$KK K K"K&K&K!K"K$K$K#K K KKKKK"K"K"KKK K#K(K0K3K5K5K4K4K6K;K>K:K3K,K)K+K1K4K2K.K&K"K$K)K/K/K.K*K-K,K8KMKUKKKGKNK6K K$K%KKKKKKKKKKKKKKKK K"KKKK&K6KBKNKNKIKFKK>KFKIKHKHKJK5KLK^KWKOKJKZKbK¼KÓKÎKÐKÍKèKÿKÉK5K0K/K'K%K*K+K)K'K.KCKZKnKvKsKrKrKpKqKtKsKsKsKsKsKsKsKsKsKsKsKtKrKvKMK!K'K&K"KK#K&K%K%K%K%K%K%K%K%K%K%K%K$K#K$K%K%K%K%K%K#K#K#K!K K K#K2K6K9K3K KKKKKKKKKKK#K&K)K+K,K/K.K4K5K7K8K8K9KK?K?K?KAKCKEKEKYKÇKàKÝKÞKàKœKxK|K}K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K}K}K}K{K{K{KzKzKzKzK{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKKK€K€K€K€KKKK€K€K€K€KK€KK`KKKGKIe]qÂ(KßKÓKzKcKkKjKkKhK^KœKêKµKiKeKkKhKlKaKmKÍKßKƒKaKkKiKkKdKeK¸KëK™KcKjKkKmKeKcK¹KêK˜KgKhKgKiK^KxKØKÏK“K¡K¹KÍKÝKæKöKõKòKèKÛKÊK·K›KŒKÒKÅKmKÍKÛKÙKøKñKçKîKÓK•KîKôKöKòK™K K°K†KVKeKmKfK>K7K*KKK K KKKKK"K K K!K"KKKKKKKKK K +K +K K KKKKK K"K#K K!K%K KKK#K&K&K"K#K$K$K"K KKK K K!K"K KKKK&K+K/K4K6K4K4K5K6K7K4K*K#K!K#K)K0K0K(K"K K%K,K0K0K/K-K,K3K?KEKNKYKVKHKK=K/K KKKKKKKK!K$K"K!K"K&K.K7K=K>K>K;KK>K@KBKEKHKHKIKIKJKOK_K[KSKMKXKZK¢K×KÏKÐKÎKàKúKîKTK(K3K.K.K)K-K;KTKjKsKuKrKpKpKsKsKqKrKsKsKsKsKsKsKsKsKsKsKsKsKtKsKtKgK,K%K%K#KK#K&K&K&K&K&K&K&K&K&K&K&K'K&K$K%K&K&K&K&K%K$K$K$K"K!K!K K-K8K7K8K*KKKKKKKKKKK K&K(K+K,K/K.K3K4K6K8K9K:K=K=K>K?K?KAKAKAKGKDKŒKàKÝKÝKãKÉK}K|K~K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K}K}K{K{K{K{K{K{K{K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~KK€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKKKK€K€K€KKKK€K€K€K€K€KKK}KZKHKGe]qÃ(KrKÏKàKŠKcKjKjKkKjKZK‡KãKÊKvKfKlKhKkK`KbK¹KëKšKdKhKiKkKiK`K¢KîK±KlKgKhKiKdK[K›KäK¬KK•K¥K·KÄKÝKöKðKñKðKíKÞKÊK±KKÖKÉKvKfKhKhKaKxKÕK×KäKÒKáKõKòKéKòKÅKšKôKñK÷KëKK“K}KXKNKhKlKaK:K5K)KKK K KKKKKKKK K!K"KKKKKKKKK +K +K KKKKKK#K%K%K&K%K$K#K!K"K(K'K$K$K#K"K KKK!K"K KKKKKK"K$K'K,K/K2K4K3K5K3K.K'K KK KKK K$K KK$K*K0K0K0K.K.K6KEKPKUKSKPKSKTKVKOKMKIK/K"K$K$K#KKKKK K K KKKKKKK-K:KIKPKOKKKJKFKAKJKMKEK5K%KKKKKKKKK K K"K!K"K*K/K7KAK>K?KBK@K?K?K@K@K@K8K'K/KJKHKIKHKMKNK_K\KTKNKVKXKˆKÓKÎKÐKÎKÖKóKýKƒK&K1K0K8KNKdKrKwKuKsKrKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsK:K"K'K)K$K#K%K%K%K%K%K'K%K&K(K&K%K&K&K%K&K&K%K%K%K%K&K%K#K$K#K$K#K)K8K8K8K2KKKKKKKKKKKK$K&K)K,K/K0K/K2K5K9K9K:K=K=KK?KAKAK@KEKFKWKÇKáKßKâKâKœKzKK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€KKKKK}K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKKKKKKKKKKKKKK€KƒKK~K‚KxKPKFe]qÄ(KeKgK·KìK KdKiKkKjKlK^KsKÖKÞK‚KeKlKjKkKiK\K¡KíK°KkKhKjKjKkK[KˆKÞK¿KwKwK†K•K¨K²KÝKóKçKïK÷K÷KíKÜKÄK´KàKÁK{KpKlKfK^K~KÚKÔK{KhKoKpKgKnK·KèKËKåKòKñKéKôK·K¢KùKòKùKâKKpK[KOKPKeKiK\K8K5K(KKKKKKKKKKKKK K!K!KKKKKKKKK +K K KKKKK%K)K(K%K"K#K%K(K)K(K#K!K!KKK!K%K#K!K KKKK!K'K(K(K'K'K+K0K3K2K/K*K%K!KK K K"KKKK K&K,K+K-K-K-K3KK3K/K+K(K$K"K%KKKKK K +K KKKKK-K@KMKQKQKLKIKIKLKIKHK>K1K KKKKKKKKK!K!K"K#K'K-K6K;K>K?K@KAKAKAK=K?K@K;K.KKKK%KGKIKIKHKIKLKYK]KUKOKSKWKmKÈKÑKÏKÏKÑKïKÿK¸K4KIK_KnKwKuKsKsKsKsKsKqKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKrKwKTK"K'K+K(K!K'K'K'K'K%K'K'K%K"K&K'K&K&K'K&K&K&K'K'K&K&K%K$K$K%K#K"K!K1K9K7K8K(KKKKKKKKKKK$K&K(K+K-K/K/K2K5K8K9K:K=K=KK?KAKBKAKEKJKFKŒKáKßKàKåKÉK€K}K|KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K{K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K}K}K}K}K}K}K~KKKKKK~K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKKKKKKKKKKK€KKKKKKK€K‚KpKMe]qÅ(KkKgK`K¢KêK¶KkKfKkKiKmKeKiK¿KèK–KcKiKkKkKkKZK…KÞKÃKtKfKoKxKˆKK¸KïKÚKÜKíKõK÷KóKäKÐKÍKäK¯K†KKuKlK^K‘KäK·KlKjKnKoKdKnKËKãK‡KfKoKqKgKƒKìKÉKëKïKðKéKôK§K¬KøKëKéK»KjK^KWKOKOKcKhKXK6K6K&KKKKKKKKKKKKKK"K!K KKKKKKKKK K KKKKK$K'K#K#K#K'K&K&K%KKKK!K!K!K$K$K!KKKK#K)K+K)K)K(K)K)K'K*K+K(K#K K K!K!KKKKK#K&K*K,K-K+K-K1K=KGKMKNKOKKKNKSKUKSKIK:K0K/K,K-K*K%K#K$K#K"KKKKK K +K KK"KCKGKMKLKKKJKLKMKIKBK4K(KKKKKKKKKKK K"K$K*K1K8KK?KAKBKAKBKGKIKWKÄKáKßKäKåK¤K{K|KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K{KzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K€KK}K}K}K}K}K}K}K}K~K€KKKKKKKK~K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKKKKKKKKKKK‚KƒKƒK‚KKKKKKKge]qÆ(KkKkKiK_KKåKÉKtKeKlKjKnKiK`KªKëKªKiKdKeKiKrKkK•KéKÏK¹KÒKãKîK÷KóKéKÝKæKÔK¬KœK‰K|KnKlK¾KÝK‰KaKlKmKmK`K€KãKÎKtKfKlKnKhKeK³KêKKgKqKkK›KïKÇKïKîKïKêKóK™K“K¯K‘K~KaK^KZKSKLKQKfKgKTK6K5K!KKKKKKKKKKKKKKK!KK"KKKKKKKK K +KKKKKKK!K%K&K'K%KKKK!K%K$K"K!K!KKKK#K&K+K)K(K*K*K*K(K&K$K#K"K#K!KKKKKK!K#K%K)K(K&K)K/K4K;KCKEKGKLKLKMKLKQKQKCK5K.K-K-K1K.K'K!KKK$K"K#K"KKKKK KKK KCKGKLKJKIKLKHK=K/K!KKKKKKKK K!K"K K K$K+K5K9K;K>KK=KDKHKIKIKFK>K3K.K.K1K2K.K'K!KKK K'K&K"K#K$KKKKKKKKK6KIKKKHKDK7K(KKKKKKKKK!K!K K#K$K)K/K5K;K=KKAK>KK?KAKBKBKDKEKGKGKYKÈKäKâKãKäK¢KyKK~K|KzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K}K}K~K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€KKKKKKKKKKK€KKKKKKKKKK€K€K€KKKKKKKK€K€K€K€K€K€K€KKKKKKKKKƒK€KKKKƒKƒKƒK€KKKKƒKKK‚KƒKƒKƒKƒKƒKƒK€K€e]qÈ(KfKlKlKjKjK_KhK¾KàK™KKK¡KµKÆKÐKéKòKêKíKêKäKÒKÀK¬KK£KãK¨KdKfKhKiKhKaKšKìK»KoKjKmKmKkK\K›KðK¸KkKiKmKmKeKfKºKêK—KeKlKmKmKbK‰KæKÉKnK¾KæKÍKóKðKëKíKèK‰KZKUKVKPKBKWKTKQKGKTKdKdKIK6K7KKKKKKKKKKKKKKKK+K'KK"K KKKKKKKKKKKKKKKKKKK$K&K'K%K!KKKK"KKK K!K'K(K(K$K$K!K K!K KKKKKKK$K%K'K'KK K'K(K-K8K;K;K9KK?K=K>K>KAKBK?K8K(KKKKKKKKKKKKKKK)KHKIKHKFKJKBKTK\KWKPKTK[KhKÄKÓKÏKÑKÐKêKýKÑKuKvKuKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKtKsKtKtKsKsKsKsKuKlK2K(K*K+K&K'K+K+K)K)K)K*K+K+K*K*K*K*K*K*K)K)K)K)K)K)K)K)K'K%K&K&K#K*K9K9K9K8K#KKKKKKKKKKK$K(K+K-K1K3K3K3K7K8K;K:K;K?K?K@KCKBKBKDKDKHKGKŽKäKßKàKçKÑK€K{K~K|KzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}KKKKKK~K~KKKKKKKKKKKKKKKKK€K€K€KKKKKKKK€K€K€K€K€K€K€KKKKKKKKKƒKK€K‚K‚KƒK‚K‚K€KKKKƒK‚K‚KƒKƒKƒKƒKƒKƒKƒK€Ke]qÉ(K¦KlKoKxK†K˜K¡K¶KèKéKàKëKõKõKíKáKÎK´K¼KãK§KsKoKkKgKaK]K™KìK¼KlKiKlKlKiK_K†KßKÎKvKgKmKjKkK`K‡KæKÍKrKfKlKkKiKaK£KðK®KgKiKmKnKdKwK×KÕKØKÚK×KôKòKéKñKàKKYKQKQKHK@KXKSKPKFKUKcKbKGK9K2KKKKK KKKKKKKKK#K/K;K=K&KK K KKKKKKKKKKKKK KKKKKK%K#K!K!K$K'K'K&K"KKK"K#K$K!KKKKK K#KKKKK K$K%K&K&K&K"K#K)K1K6K8K9K:K:KK6K1K-K/K0K0K-K)K%K KK$K)K.K.K.K*K)K/K:K(K!K#K!KKKKKKKK#KKKKKKKKKKKK K"K&K+K7K=KAK@K@K?KK@KCKAKBKDKDKHKLKYKÆKãKßKäKéK¢KyKK|KzKzKzK{K{K{K{KzKzKzKzKzK{K{KzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K~KKKKKK~K~KKKKKKKKKKKKKKKKK€K€K€KKKKKKKK€K€K€K€K€K€K€KKKKKKKKK‚K€K€K‚K‚KƒK‚K‚K€KK€KKƒKƒKƒKƒKƒKƒK‚K‚K‚KƒK€K€e]qÊ(KêKÇKÉKÞKìKóKöKòKäKÐKÖKßK¬KŽK†KwKlKdKfKµKèKžKeKjKnKmKlK\K€KâKÏKyKfKkKjKlK_KsKÓKàK…KdKmKlKnKbKwKØKÞKKcKmKlKjKbKKêKÄKpKhKmKmKgKlK¸KæKÐKßKöKóKçKñKÔKxKVKPKPKEKBKYKRKNKGKXKaK^KCK7K0KKKKK KKKKKKKKK)K5K?KIKAK&K!K!K KKKKKKKKK K +K KKKKKK K#K,K0K.K*K)K)K&K&K&K$K!KKKKKK K KKKKK K#K$K$K#K"K"K$K%K&K'K.K5K9K:KK!K$K$K KKKKKKKKKKKKKKKKK K$K+K1K6K:KDKEKDKBK>K>K?K9K2K#KKKKKKKKKKKKKKKKKKKK#K=KJKHKHKKK:K:K`KYKRKHKQKWK“KÖKÎKÐKÎKÖKöKûK¤KnKuKvKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKuKvKtKrKwK[K,K-K*K+K&K*K+K+K+K+K+K*K+K&K(K)K+K+K+K*K*K+K+K+K*K(K)K)K)K(K%K%K#K*K8K:K:K6K KKKKKKKKKK K$K'K*K.K0K2K3K3K6K:K;K=K>K?KAKAK@KDKDKDKGKLKFKŽKæKáKâKçKÎKK}K}KzKzKzK}K}K~K|KzKzKzKzK{K}K|KzKzKzK}K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKKKK€K€K€K€K€K€K€KKK‚K‚KKKƒKƒKƒK€K€KƒKƒKƒK‚K‚K‚K‚KƒKKKKƒKƒK‚e]qË(KåKèKèKÙKÆK·K¡K‘K‚KlK|K×KÍKxKbKjKjKlKhK^K¢KïK·KiKiKmKlKkK]KpKÓKáK„KcKlKkKkKeKiK¿KìK–KdKkKlKnKfKhKÀKêK“KcKkKkKmKaKzKÜK×KzKfKmKoKhKvKèKÍKåKôKóKåKîKÈKqKSKQKPKKKKKVKRKMKKK]K`K\K=K7K0KKKKKKKKKKKKK'K1K;KGKKKJK.K K!K!KKKKKKKKKKK KKKKKKK2KAK:K0K)K(K*K%K$K%K"KKKKKKKKKKK!K"K K"K#K"K#K%K%K$K%K&K'K+K0K6K8K3K,K)K,K-K.K/K1K)K KK$K*K.K0K-K-K-K3K=KGKPKPKMKMKJK,K"K#K#KKKKK K KKKKKKKKK"K'K,K4K:K?KCKEKDKDKDKCK?K4K'KKKKKKKKKKKKKKKKKKK K!K$K'K'K3KJKHKHKJKDK0KZKZKSKMKKKZKxKÑKÑKÑKÑKÐKîKKÉKsKvKvKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKtKtKsKsKuKuKuKtKsKtKoK9K)K,K+K(K(K+K,K+K*K+K,K+K(K)K*K+K*K)K+K,K+K+K+K*K)K)K)K)K(K'K$K!K$K5K:K:KK4K*K&K!K#K#KKKKKKKKKK!K,K4K7K=KEKCKDKFKGKGKBK7K'KKKKKKKKKKKKKKKKKKK K"K#K&K'K&K*K:KRKhKqKQKGKIKHKKK3KDKbKZKSKJKVK\K¥K×KÏKÑKÏKÝKùKöK–KqKwKuKuKuKtKsKsKsKsKsKsKsKsKtKuKtKsKsKsKtKuKuKuKuKuKtKuKuKuKuKuKtKwKbK,K-K.K*K%K*K.K.K.K0K,K+K-K,K,K,K-K.K+K*K+K+K+K+K+K*K*K*K*K)K(K)K'K'K8K:K;K=K'KKKKKKKKKK K#K%K)K.K/K1K2K5K9K;K;KK2K*K'K%KKK%K!K!KKKKKKKKK(K1K=KCKEKCKAKBKCKK:KaK[KSKJKRKWK‡KÕKÎKÐKÐKÕKóKÿK³KpKwKvKuKvKuKsKsKsKsKsKsKsKsKtKvKtKsKsKtKuKvKuKuKuKuKvKuKuKvKuKuKuKuKrK:K+K-K+K'K(K.K-K-K/K-K-K.K.K.K.K.K.K+K*K+K+K+K+K+K+K+K+K*K)K)K)K'K$K2KK>KBKBKDKCKDKDKBKKKHKKäKáKæKêKÕK†K|K}K~K}K}KzKzKzKzKzK}K}KzK{K~K~K~K}K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€K~K}K}K}K}K~K€KKKKKKK€KKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKKK€KƒK‚KK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒK‚KKKƒKƒKƒKƒKƒKƒKƒKƒKKK‚Kƒe]qÏ(KçKæKìKÏKpK‘KéKÈKwKeKmKkKmKmK_KŒKæKÌKuKeKkKkKnKgKaK¯KðK¨KhKjKmKkKkK_K{KÜKÖKzKeKmKjKlKcKlKÊKçK‹KbKkKjKlKbKkKËKæK‹KbKkKjKmK]KKåK¿KœK²KnKkKmKkKoKuKxK^KKKNKJKIKPKRKNKKKQK[K^KQK9K8K1KKKKKK +K KKKKKKKKKKKKKKKK!K!K"K"KKKKKKKKK KKKKKKKK K$K!K#K#K!KK!K%K%K$K#K!KKKKK!K!K K#K&K%K'K'K$K$K$K$K%K$K%K%K$K KK K%K,K.K.K.K,K.K4KAKKKOKIKIKHKEKMKHKCK:K3K,K'K,K'K KKK K#K$K#KKKKKKKK'K1K=KDKEKBK;K1K#KKKKKKKKKKKKKKKKKKKK!K%K)K'K'K-K=KWKhKsKtKqKpKpKrK`KFKIKHKJKCK1KYK]KWKMKMKYKnKÍKÒKÏKÏKÏKëKýKÓKvKvKvKuKtKtKsKsKsKsKsKsKsKsKsKtKsKsKsKsKtKtKtKtKtKtKtKuKuKsKtKuKuKuKwKQK*K/K0K.K'K,K/K/K/K-K-K.K.K.K.K.K.K-K-K-K-K-K,K*K+K+K+K*K(K)K)K)K'K+K;K=K=K:K#KKKKKKKKKKK#K&K(K-K1K1K4K4K7K8K9K>K>K?KBKBKBKCKDKDKGKJKKKYKÈKæKãKæKéK«K{KK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKK}K}K}K~KKKKKKKKKKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKKKK€KK‚KK€K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒK‚K‚KƒKƒe]qÐ(KçKæKåKíKÒKsK|KÝKÛKƒKfKmKlKlKnK`KxKÕKÝK„KdKlKkKjKjK_K–KìK¿KnKhKlKiKnKaKkKÉKçKKeKkKkKmKdK_K²KîK¡KeKiKjKmKeK^K¶KñK¢KiKiKjKmK`KhK€KeK\KgKrKqKkKoKrKwKYKKKNKIK=KPKQKNKDKJK]K]KKK8K8K0KKKKKK KKKKKKKKKKKKKKKKKKK K!K KKKKKKKK KKKKKKKK#K$KKKK#K$K KK#K"KKK"K$K#K"K!K!K!K#K%K%K%K$K#K#K#K%K'K$K!KKK!K)K,K+K,K-K-K-K.K7KCKFKEKCKEKGKJKDK;K7K/K,K,K.K)K$KKK!KKK#K#K KKKKKKKK K6K@KAK7K&KKKKKKKKKKKKKKKKKKKKK%K&K(K&K(K3KMKdKrKsKqKnKpKpKpKpKqKkKKKHKIKIKJK/KOK`KXKPKKKZK_K¶KÖKÏKÏKÎKàKúKîKˆKrKvKuKtKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKsKsKtKtKtKsKtKuKuKsKtKuKuKuKuKgK2K.K0K/K)K*K/K0K/K.K.K.K.K-K-K.K.K.K.K.K.K.K,K+K+K+K+K+K)K)K)K)K*K(K5K>K=K=K.KKKKKKKKKKK"K&K)K-K0K1K3K4K7K7K9K=K?K?KAKAKAKCKCKDKGKGKLKIKŽKçKãKæKêKÖKˆK}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKK~K~K}K~KKKKKKKKKKKKKKKKKKKK€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKKK€K€KKƒKK€K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÑ(KçKçKçKåKëKÑKtKlKÉKèK–KfKlKlKiKlKcKjKÃKêK˜KdKjKlKkKkK\K€KàKÔKyKeKmKiKmKdKcKµKðK¤KfKjKlKmKhK\K›KïKºKjKgKjKlKgKZK˜KÈKvKgKjKiKnKcKIKaKbKgKpKoKjKnKsKvKSKJKNKGK;KSKQKOKDKKK\K]KJK8K:K/KKKKKKKKKKKKKKKKKKKKKKKK*K*K K!K!KKKKKKKKKKKKKKKKKKK$K&K%KKK#K&K$K(K(K%K&K%K"K!K!K"K!K K#K'K&K'K&K#KKK!K"K(K*K*K)K)K)K(K-K2K7K9KKAKDKDKDKDKHKKKLK\KÌKéKçKèKíK­KyK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKKKKKKKKKKKKKK€K€K€K€K€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKKKKKKKKKK€KƒKƒKƒK‚K‚KK€KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÒ(KæKçKçKåKåKëKÒKxKaK±KîK­KhKjKkKjKnKfK`KªKðK«KhKkKlKjKlK`KqKÏKäK‰KeKlKiKmKjK[KšKðKºKlKgKlKkKlK[KKæKÌKmKhKkKlKlKYKOKbKjKiKkKkKmK\KcK`KiKqKpKlKoKtKrKPKJKNKFK@KUKPKOKDKMK\K^KGK8K9K.K"KKKKKKKKKKKKKKKKKKKK K2KCKNKDK(KK#K!KKKKKKKKKKKKK K KKKK"K"K!K$K-K8K6K-K+K+K'K&K%K!KK KK K!K"K&K&K"KKK$K*K,K*K)K(K&K%K&K'K-K0K3K5K6K9KK=K=K-KKKKKKKKKKK K%K)K-K0K3K5K5K6K9K:K>K>K?K?KAKCKCKCKDKGKHKLKKKŽKéKçKçKìKÕK†K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~K~KKKKKKKKKKKKKKK€K€K€K€K€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKK€K€KKKKKK€KKƒKƒKƒK‚K‚KKKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÓ(KçKæKçKçKçKåKêKÏKyK]KKìKÀKqKgKlKkKmKhK^K˜KîKÄKqKgKmKlKnKeKeKºKïK KeKlKlKkKjKZK„KçKÑKyKhKiKkKlK[KfK‹KoKiKlKiKkKkK_KLK[KiKjKjKkK[KeK_KdKhKiKgKkKtKoKNKKKNKDKCKVKPKNKBKRK]K]KEK8K6K,K&KKKKKKKKKKKKKKKKKK"K9KMKSKRKNKLKCK&KKKKKKKKKKKK K +K K KKKKKK#K-K:KAK@K8K0K-K,K'K"K K K K K!K!K!KKKKK&K*K,K,K,K+K&K!K"K#K%K*K-K/K2K5K5K5K3K1K.K/K2K3K*K$K$K!K K"K#K"K%K,K3K;KAKCKEK:K&K"K$K"KKKK KKK;KKKKKKKKKKKKKKKK#K(K'K'K'K0KEK[KmKtKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKaKFKLKLKJKEK0KXK\KUKMKMK[KjKÈKÕKÒKÓKÐKçKüKäKKtKvKuKuKvKuKsKsKsKuKuKsKsKsKtKvKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKwKkK6K1K4K1K*K,K0K/K0K0K0K0K0K0K0K0K0K0K0K/K-K.K-K.K.K-K-K.K,K+K)K(K)K'K/K>K?K?K8K!KKKKKKKKKKK#K(K,K.K1K6K3K4K9K:KK@KBKAKBKCKDKFKGKLKMK]KËKëKçKçKïK®KzKK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€KKKKKKKKKKKKKKKKK€K€K€K€K€K€K€K€K€K€K€KKKKKKKKKKKKKKKKKKKK‚K‚KKKKKK‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÔ(KìKèKåKåKâKÞK×KÖK®KoK^K…KáKÕKKhKmKkKmKmK_K‚KãK×K~KfKlKjKkKhK]K KñK¶KhKgKkKiKnK]KnKÑK¾KhKiKjKiKlKaKEKSKdKhKiKiKiKkKdKPKYKhKjKiKZKbKjK‘K­K­K KK…KjKKKKKLK?KGKVKPKLKCKVK\K\KCK9K6K)K)KKKKKKKKKKKKKKKK&K:KOKVKTKUKSKSKPKGK/K!K K"KKKKKKKKKK +K KKKKKK$K/K5K;K=KAK=K5K.K&K"K K K"K"K$K!KKKK K(K*K)K,K,K(K#K$K"K"K%K%K&K(K*K+K/K1K.K0K2K4K5K/K)K%K KK K!KK"K*K/K5KKAKAKBKBKEKEKCKFKJKNKJKKäKßKâKæKÒKƒK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}K}K~KKKK~K~KKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKK€KKKKK€K€K€KKK‚K‚KKKKKK‚KƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒe]qÕ(K…KÛKÙKÍKÁK´K£K‘KKiKjKbKuKÐKåKŽKcKmKlKjKlKbKoKÐKæKKeKlKiKkKmK[K‹KèKÌKvKgKjKjKlKaKSK_KeKgKjKjKjKjKiKPKNKbKhKiKjKiKlKgKQKSKgKdKfKK¬KùKùKöKìKõK¦K_KLKLKMK>KJKVKQKLKDKXK\KWK>K9K6K'K)KKKKKKKKKKKKKKK-KEKMKSKVKYKYKXKHK3K"K K KK!K KKKKKKKK K +K +K KKKKK'K+K0K8K?K=K5K*K!KK K!K!K!K!KKKK K&K%K(K(K(K$K#K KK#K$K$K%K&K%K%K)K-K,K.K1K3K4K.K'K"K K K K K"K%K*K1K7K;KK@K5K"KKKKKKKKKK!K%K)K+K/K1K4K5K7K6K9K9K>K@KK:K5K)K'KKKKKKKKKKKKKKK7KLKQKVK^K]KHK3KKKKKKK K K!KKKKKKKK K +K KKKKK$K+K2K6K3K'KK"K!K K"K KKKKK#K'K'K&K$K%K%K KKKK"K$K$K#K$K'K(K(K,K/K.K/K0K,K&KKKK!K K$K(K.K0K3K7K8K=K@K@K?K>KK8KaK\KUKKKQKYKxKÏKÐKÏKÐKÏKêKüKÕKxKwKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKmK9K1K2K3K0K,K2K1K2K2K0K/K0K/K2K2K1K0K0K0K0K0K/K/K/K.K-K/K.K.K,K*K+K)K/K>K?K?K=K'K KKKKKKKKKK!K&K+K,K/K2K3K4K4K5K9K=KK;K4K(K&KKKKKKKKKKKKKK$KCKSK\KTKEK.KKKKKKKKKK!K KKKKKKKKK K KKKKK$K)K)K#KK K K$K$K!KKKK K!K$K(K'K%K"K"K"KKKKKK"K#K$K$K&K*K-K-K/K.K-K'K KKKK K"K&K,K1K5K5K3K6K8K;K?K@K;K3K$KKKKKKKK#K$K#KKKKKKKKKKK$K'K(K(K*K6KMKdKqKsKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKpKpKqKqKpKsKaKGKIKHKJKGK1KXK_KXKPKLKYKdKÀKÓKÏKÐKÎKâKùKìKˆKuKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKyKLK.K3K3K0K+K3K3K3K3K0K0K0K0K-K.K/K0K0K0K0K0K0K0K0K/K-K/K.K/K,K+K+K+K*K:K@K>KAK0KKKKKKKKKKK K%K*K+K/K1K2K1K7K:K=K=K=K@KBKBKAKAKFKHKFKGKLKWKcKÉKâKÚKØKßK¦KzKK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K}K}K}K}K~K}K}K}K~K€K~K}KK€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€KK€K€K€K€K€K€K€KKK€K€K€KKƒK€KK‚K‚K€K€KK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒe]qØ(KeKMK3K;KPKRKQKQKPKPKPKSK¡KéKÊKšK¥KâKÉK|KjKlKkKmKlKZKvKŒKgKhKjKiKiKjKeKOKOK_KhKhKiKiKjKlKYKEKVKeKiKjKiKiKlKaKLKœKÉK}KgKlKlKoKbKÚKßKàKKùKïKõKçKKWKLKNKKK:KQKSKOKEKFK[K\KSK;K;K4K&K'K KKKKK KKKKKKKK3KRKQK>K(KKKKKKKKKKKKKKKKKKKKKKK +KKKKKK!K KK K K"K!KKKK%K)K)K&K%K&K$K%K%K$K#KKKKKK"K$K%K)K*K,K*K'K'K#KKK KK!K$K)K+K1K4K3K5K5K5K6K7K9K7K*KKKKKKKKKKK K$K#K!KKKKKKK"K'K(K'K)K0KDK[KlKtKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKqKpKsKsKsKtKjKJKHKIKHKIK1KNK`KYKSKHKWKZK¦KØKÑKÐKÎKØKõKùK¢KrKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKtKzK`K/K2K3K2K,K/K3K3K3K3K3K3K1K-K2K2K0K/K/K0K0K0K/K/K/K/K/K0K.K-K+K)K&K(K1K?K?K@K9K#KKKKKKKKKKK$K(K+K,K+K.K3K:KAK=K8K=K?K?KBKBKEKGKFKFKGKLKUKRK“KáKÜKàKãKÐK„KKK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKK}K}K}K~K€K~K}K}K~KKKKKKKKK~K}KKKKKKKKKKKKKKKKKKKKKKKKK€KƒKKKKKKKKKKKK‚K‚KƒKKKKKK€K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÙ(K/KMKFK0K9KOKQKPKQKQKQKRKQKKðKìKØKÕKäKÃKsKkKlKlKjKlKZKDKUKeKhKjKiKhKkKhKPKKK\KeKiKjKiKiKkK^KEKPKcKiKjKjKiKlKhKXKhKqKcKeKmKmKmKÍKºKK·KÎKÊKÑKÌKzKSKMKNKIK;KSKSKOKDKGK\K]KRKKBKAKBKEKGKGKFKGKNKRKTKfKËKåKâKâKåK«K|K€K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK}K}K}K~KK~K~K~K~KKKKKKKKKK~KKKKKKKKKKKKKKKKKKKKKKKKK€K‚K€KKKK€K€KK€K€K€KK‚K‚K‚KK€KKK€KK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÚ(KK4KEK;K1K5KMKQKQKTKRKTKUKVKwK{K€K‹KxKlK^KcKiKjKjKiKlKbKLKQKbKiKiKkKkKiKjKVKIKWKbKhKjKiKiKlKcKHKJKbKiKdKkKlKlKkKTKTKƒK„KkKmKcKhKuK‹K€KwKtKsKxKvKPKMKOKGK;KTKRKPKCKKK]K_KOKKVKhKrKtKpKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKrKqKpKpKqKtKrKqKrKrKsKsKtKaKFKIKHKIKEK/KYK^KYKQKKKWK`K¼KÖKÒKÓKÐKÝK÷KñK•KtKyKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKxKdK5K5K4K0K-K1K3K2K3K3K3K3K4K3K3K3K3K3K3K4K2K1K3K2K1K0K0K/K/K.K-K*K,K*K.K=K@K?K@K+KKKKKKKKKKKK(K8K@K@K-KKK,K9KK?KAKBKEKGKFKFKFKNKQKRKWKcKËKåKáKâKçK­KzKKKK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKKKKKK~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€KKK‚KƒK€KKKKKK‚K‚K‚K‚K‚KƒKƒK‚KƒKƒKƒKƒKƒKƒKƒKƒK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qÜ(KjKVKEK:KHKFK/K:KXKbKoK€K‘K¢K³K½K«KtKdKfKeKdK`K\K]K`KbKcKhKiKPKKK_KfKgKkKkKiKlKdKOKNK]KfKjKkKkKmKkKTKEKÁKÑKqKgKmKlKoK^KwKàKØKºKöKÏKõKôKôKíKÿKºKdKLKMKPKBKDKVKPKMKBKQK\K^KGK:K@KBK'K&K&KKKKKK KKKKKKKKKKKKKKKKKK#K1K@KMKSKMKGKGK>K'KKKKKKKKKK K K K +K KKKKK!K$K(K/K0K.K.K+K*K(K)K)K&K%K&K&K*K'K%K KKK K!K#K%K%K)K+K+K+K)K+K-K.K/K/K+K#KKKKKKKKKKKKKKKKKKKKK"K'K(K*K*K4KIKbKqKsKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKrKtKqKpKpKqKtKqKpKpKqKsKsKuKiKJKIKIKHKIK:KRK`KYKQKIKTKWK KÙKÒKÓKÒKÖKòKúK²KrKyKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKsK@K3K5K7K3K.K3K2K3K3K2K4K5K3K3K3K3K3K2K3K0K/K3K2K/K/K0K0K0K.K-K+K+K+K+K8K?K>KBK8K KKKKKKKKKK&K;KAK;K+KKK&K4K9KK2K"KKKK$K-K6K6K9KKNK0K'K*K KKKKKKKKKKKKKKKKKK*K6KK%KKKKKK1K?K=K-KKKKKK&K2K7K8K8K:K=KAK@KCKCKFKGKGKGKGKKKPKTKTKbKËKåKáKáKæKªKzK€KKKKK€K~K}KKK}K}K}K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KK€K‚K‚K‚KKKKK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚KƒKƒKƒKƒe]qà(K{KªKKSK_K@KKuKðKÁKLKŠKíKêKçKéKéKéKæKëKÙKzK|KÐKéKïKïKíKíKÊK‡K_K€KÈKîKðKçKæKÜK´KsKiKkKlK`KEKOKbKiKlKlKlKnKkKTKPKdKeKbKkKqKgK¦K£KsKŒK£K¨K¦K°K|KYKKKMKJKBKQKUKPKJKOKZK[KXKAKK:K'KKKKKK"K*K3K6K4K5K:K;K=K?KCKCKEKGKGKGKGKIKLKRKTKQK•KæKßKÝKßKÌK†K€K€KKKKK~K}KKK~K~K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KK€KK‚K‚KK€K€K€K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒe]qá(KÀKäK€KK7KOK@KKzKïKÆKSKŠKíKêKèKéKéKéKåKëKÚK~KcK‚K¦KËKÏK™KfKsKµKèKðKëKéKïKîKÉKšKdKaKeKhKlKdKGKIK_KhKfKjKlKlKnK`KSKŽK¤KzKnKjKkKwK­KœK…K|KKvKxKUKJKLKGKEKSKSKLKLKTK\K\KUK?K=KDKPK;K#K&K'KKKKKK KKKKKKKKKKK!K+K5KKAKBKDKEKFKGKHKIKHKKKSKVKUK–KåKÞKßKáKÒKŠK~K€K€KKK~K}K~KK~KKKKK~K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€KK€KKKKKKKK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK„KƒKƒKƒKƒKƒKƒK‚KƒK…K„K„KƒKƒe]qã(KÝKÆK;KKKKKK®K&KvKïKÈKSKKáKæKçKçKéKêKçKíKÞK†KbKdKbKcKfKyK›KÄKãKâK¬KjKeK¦KìKªKSK\KZKYKWK[K_KLKNKËKÐKyKjKqKpKqKdKbK½KêKÉKòKÏKòKñKóKîKüKÆKlKQKNKLKKKLKWKRKMKKKUKZK^KPK;K=KHKOKDK&K%K'KKKKKK K K KKKKKKKKKKKKKKKKKKKKKKKK K!K"K#K)K-K%KKKKKKKKKKKKKKKKKK K&K$K!K#K&K'K+K,K.K/K.K,K)K$KKKKKKKKKKKKKKKKKKKKKK"K$K(K)K*K4KJKaKpKrKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKrKpKsKtKsKtKtKsKtKqKpKsKtKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKvKaKHKIKHKHKJKEKXK_KWKQKIKYK[K©KÕKÎKÐKÎKÖKðKúK³KrKxKyKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKyKwKuKxKyKyKxKyKwKuKxKxKzK^K6K9K8K7K/K2K8K8K8K8K5K4K5K5K5K5K5K5K4K4K5K6K4K2K3K3K3K2K0K/K-K.K.K+K*K:KCKCKDK8K"K#KKKKKKKKKKK"K*K1K2K4K6K;KKDKGKFKGKIKHKIKJKMKQKcKÎKäKáKßKäK®K~K€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KKK‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK…K„KƒKƒKƒKƒKƒK…K…K…K…K…KƒKƒe]qæ(K¼KWK>KAK9K)KKK1KaKiKpKqKgK‡KkK2KJKK‚K|KK‚K‰KKK¡K®K˜KuKpKmKiKjKdK[KQKGKJKUKIKHKPKRKUKVKWKWKYKYK’K¸K¦K§K±K°K£K‡KpKrKoKÛKçKÂKñK÷KôKñKýK™KYKJKLKNK:KDKWKOKMK>KRK\K]KIK=K?KLKNKJK3K"K&K#KKKKK K +KKKKKKKKKKKKKKKKKKKKKK&K(K*K)K)K)K+K(K'K$K K!KKKKKKKKKKKKKKKKKK"K$K&K%K!KKKKKKKKKKKKKKKKKKKKKK"K$K'K(K'K/K@KZKmKtKtKpKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKrKtKqKpKsKsKpKpKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKRKFKIKHKJK=K3K^K^KYKOKPK[KdK¿KÓKÏKÐKÍKÚKóKöK KtKzKxKxKvKuKuKuKuKuKuKuKvKxKxKuKwKyKvKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxK{K`K8K9K:K:K2K3K8K8K7K8K8K8K7K5K6K6K7K8K5K5K4K5K5K5K5K3K2K0K0K0K-K+K%K$K2K>KCKCKEK?K$K K KKKKK KKKK#K'K*K0K4K8K:K:K:K:K>K@KDKCKEKGKEKHKIKHKHKMKQKSKQK—KäKßKÞKáKÒK‰K}KK€K€K€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK‚KƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚KƒK‚K„K…KƒKƒK‚KƒK…KƒK‚K„K…K…K…K…K…K…K…K…e]qç(KÎKNKKŠK|K=KeKÁK¼K°K£K—K‹KK}K©K¼KjKfK‚K{KlKkKjKdK\KNK>K;K8K8K>KCKMKSKWKYK\KÇKüKòKëKãKÖKÌK¼KK}KgKŒK’KiKxKŠK“KŠK KKXKIKLKKK8KKKTKNKKKAKWK[K\KGK=K?KLKMKJK9K$K&K%KKKKK K KKKKKKKKKKKKKKKKKKKK!K$K(K)K&K'K'K(K&K$K$K#K"K$K"KKKKKKKKKKKKKKKKK%K%KKKKKKKKKKKKKKKKKKKKKKK!K)K)K%K+K:KPKfKqKsKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKqKpKqKsKqKpKsKsKpKpKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKvK]KGKJKHKIKHK.KVK_KYKPKMK[KYK¥K×KÎKÐKÐKÔKíKùKÉKuKyKyKxKvKuKvKvKuKvKvKuKvKxKwKuKvKxKvKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKpK@K8K9K;K5K/K7K8K9K8K8K8K8K9K9K9K8K7K5K5K6K5K5K4K4K3K2K0K0K/K.K*K(K5K?K>K?KCKCKDK/KK KKKKK K +KKK"K(K+K/K3K7K9K:K9K:K>K@KBKDKFKGKEKGKIKIKHKIKQKSKVKcKÈKßKÝKÞKâK¬K~K‚K€K€K€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€K€KK‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒK‚K„K„KƒKƒKƒK„K…K„KƒK„K…K„K„K…K…K…K…K…e]qè(K½KNKDKGKGK=KKHKOKcKÛKõKëKìKïKóK÷K÷KõKæKÇK—KK¸K®K•K†KKzKuKYKKKLKJK7KOKSKOKJKBKXK[K[KFK=K@KLKLKJK>K$K#K#KKKKKKKKKKKKKKKKKKKKKKKKK K!K!K%K&K'K$K!K"K!K&K%K#K"KKKKKKKKKKKKKKKKK K$K$KKKKKKKKKKKKKKKKKKKKK!K&K(K(K&K/KCK\KnKrKqKpKpKpKqKpKnKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKtKsKpKpKpKpKpKsKsKpKpKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKvKeKJKIKHKHKKK0KHKaK[KRKNKYKXKŠKÕKÐKÏKÐKÒKæKõKçK‚KwKyKxKvKuKyKxKuKwKyKvKuKuKuKuKuKuKuKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKxKzKOK8K:K9K4K/K5K7K7K7K8K8K8K8K8K8K8K8K7K7K8K6K5K3K2K3K2K/K0K-K)K/K;K?K=K'K4KDKCKCK>K#KKKKKKKKKKK%K+K/K1K4K7K:K9K:K>K>K?KDKGKGKGKGKHKIKHKHKLKSKYKRK–KáKÝKÞKáKÓKŠKK€K€K€KKKKKK~K}KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKƒKƒK‚KK€KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒK‚K‚K‚K‚KƒKƒKƒK…K„K‚K‚K‚K‚KƒK…K…K…K…K…K…K„K‚KƒK…K…K…K…K…e]qé(K†K,KSKCKBKBKK?KVK€K®KØKðKõKòKñKîKîKïKòKðKîKîKáKèKÈKqKQKKKLKHK9KVKTKNKDKEK]K]KZKAK>KAKLKJKFK@K'K K"KKKKKKKKKKKKKKKKKKKKKKKKK K KKKKKK"K#KKKKKKKKK K#KKK!KKKKKKKKKKKIKKKKKKKKKKKKKKKK!K$K%K$K&K3KGK^KmKrKoKnKmKnKnKoKpKpKpKpKpKnKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKrKpKsKtKsKsKtKtKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKrKSKHKMKIKJK@K4K\K\KYKQKSK[K`KºKÖKÎKÐKÎK×KñK÷K´KsKzKxKyKxKuKuKuKuKuKxKyKyKxKuKwKyKvKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKtKBK8K:K;K7K/K9K:K:K:K8K7K8K8K8K8K8K8K7K4K4K4K6K4K3K2K/K/K7K?KCK6K KKKK;KGKFKHK:K"K!K KKKKKKKK#K(K,K1K4K7K:K:KKBKCKDKGKFKFKHKIKIKIKLKRKTKUKiKÎKàKÝKÜKáK¬K|KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€K€K€KKKKKK€KƒK‚KKKƒK‚KƒKƒKƒKƒKƒKƒK‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K„K„KƒKƒKƒKƒKƒK‚KƒK…K„K„K„K…K…K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…e]qì(K;K=K4KdKŽKcKEKIKIK=K–KðKæKˆKDKeKKnKKuKîKÔK_KƒKëKêKçKéKìKìKëKíKÙKK·KîKïKïKÎK\KQKRKOKOKTK[KbKkKqKnKmKjKbK\KVKQKVKhK†K­KÖKîK÷K÷KôKðKãKîK­KgKMKMKMKCK@KWKPKOKCKJK]K^KVK>KKAKXKQKMKAKMK]K^KSK?K?KDKJKGKEKAK0K!K KKKKKK K K KKKKKK K"K#K$K$K!KKKKKKKKKKKK K-K)K K!K(K+K/K1K0K2K3K3K2K.K"K KKKKKKKKKKqK!KKKKKKK!K#K(K'K'K.K>KVKjKsKsKoKmKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKpKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKuKuKuKsKuKuKuKvKmKJKHKIKHKLK7KK=K5K1KKrKìKÒK^KƒKëKïKëKëKëKìKëKìKëKéKïKèKKOKSKRKQKQKPKPKQKQK]KÑKóK×K¸K—K|KrKnKnKmKhKcK]K\KaK{KK|K™K‰K_KIKJKIK:KEKXKQKMK@KNK^K^KQK@K@KEKJKFKBK@K7K!KKKKKKK KK K KKKKK!K&K'K KKKKKKKKKKKKKKK,K,K)K)K-K1K1K0K/K1K0K,K!KKKK!KKKKKKKKKrK#KKKKK!K&K'K'K)K5KMKcKoKrKpKpKpKoKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKqKpKpKpKpKpKpKpKpKpKpKpKpKsKsKqKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKuKuKuKuKtKuKuKuKuKtKTKGKIKHKLKBK1K\K^KZKQKJKZK^K³KÖKÏKÐKÐKÔKíKøK¹KuK|KyKxKxKxKxKxKxKxKxKxKxKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKwK{KYK9K:K:K;K4K6K:K:K:K:K:K8K9K9K7K8K8K8K7K5K3K7K>K@K/KKKKK K$K'K!KK"K.KCKEKDKEK1K#K%K!KKKKKKK!K%K*K0K2K5K8K:K:K>K>K>KAKDKEKBKEKHKHKIKJKKKJKLKSKXKQK˜KâKÚKÝKáKÑKŠK‚KK€KKKKKKKKKKKKKKKKKKKKKKKKKKKK€K‚K‚KK€K€K€KK‚KƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒKƒK„K„KƒKƒK„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qï(KšKÅK›K±KƒKvK´K·KfKiKÛKêKyKNKÆKÍKnKgK\KPK>K%KzKÕKÎKcKKëKïKêKìKìKìKëKêKîKÑKyKTKRKQKQKQKPKMKOKRKPKiKÞKðKðKõKñKÞK¾K™K~KpKnKnKlKhK\KMKQKtKmKwKYKFKHKKKK@KHKJKFKDKBK:K!K KKKKKK KK K KKKKK KKKKKKKKKKKKKKKKK%K*K+K.K-K,K/K.K/K-K'K KKKKKKKKKKKKKKKrK$KK K%K'K'K'K/KCKZKmKrKqKnKmKnKoKqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKpKpKpKpKpKpKpKpKpKpKpKpKsKsKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKvKuKuKuKuKuKuKuKuKuKxK]KHKKKHKHKHK.KSK_KZKTKIKWKWK—KÙKÏKÐKÓKÓKèK÷KÖK{KzKyKxKxKxKxKxKxKxKxKxKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxK{KkKK7K3K4K;K9K:K:K:K9K7K9K:K8K8K8K7K4K4K>K=K'KKK"K&K(K*K(K*K,K(K)K*K=KGKFKIK=K%K&K"K KKKKKKK#K*K.K2K6K8K:K9K;K>K>KCKDKCKCKEKHKIKIKIKHKHKJKTKWKTKiKÌKÞKÜKÜKàK¬K~KƒK‚KKKKKKKKKKKKKKKKKKKKKKKKKKKK€KƒK‚KKKƒKƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚KƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K„K…KƒKƒK…K„K‚KƒKƒK‚KƒK…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qð(K§K”K±K K[KK¬KãK¿K…K»K»K`KCKYKÉKÏK~KnKqKnKQK’KÁKßKÚK]KsKØKåKçKêKêKêKéKìKÚKKNKQKOKOKMKMKMKNKPKNKzKëKñKîKîKðKôKöKñKàKÁKKKuKmKpKXKxKîKÌKtKQKHKHKKK;KMKVKOKHK?KXK_K^KKK?KAKGKHKFKBK@K;K"KK KKKKKKK KKKKKKKKKKKKKKKKKKKKK'K+K,K+K*K-K-K-K,K'K#KKKKKKKKKKK"K#KKKKKKDK(K%K*K(K*K8KPKeKrKrKpKoKoKoKoKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKpKpKpKpKpKpKpKpKpKpKqKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKsKsKtKtKtKtKtKuKuKuKuKuKuKtKuKuKwKfKIKIKHKIKLK1KGKaK[KTKLKSKXKzKÓKÐKÏKÑKÏKàKóKêKKvKzKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKwKGK9K=K7K6K2K:K:K:K:K:K9K7K9K:K8K8K8K8K5K7K:K#KK%K*K,K/K2K2K1K.K/K,K,K*K3KFKGKFKEK/K#K#K KKKKKKK K&K-K2K5K8K9K:K:K=K>KAKCKCKCKEKHKGKGKGKHKIKKKOKSKWKVKKáKÚKÝKàKÓKŠKKKKKKKKKKKKKKKKKK€KK€KKKKKKK€KK€K€KKKK€KK‚KƒKƒKƒK‚K‚K‚KƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„K…K„K„K…K„K‚KƒKƒK„K„K…K„KƒK„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qñ(KŒKfK¡KXKTKKµKÕKÙK‘KsKpKJKSKFK[KËKËKqKnKqKmK»KÛK—KÎKËKSKcK²KÃKÉKÐKÖKÜKßKêKáKyKJKOKMKNKNKNKMKOKMKKñKíKïKïKðKïKïKðKóKöKôKäKÉK£K‹K[K†KùKÌKqKRKGKIKIK:KRKVKMKHKAKWK]K_KIK>KAKGKGKEK@K;K9K'KK!KKKKKK K KKKKKKKKKKKKKKKKKK%K,K+K+K*K*K+K*K+K+K&K KKKKKKKKKKKKK#K%K$K$KKK'K&K'K*K0KCK]KoKtKsKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKpKpKpKpKpKpKpKpKpKpKsKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKvKtKtKuKuKvKtKsKuKuKuKuKuKtKsKuKuKtKnKLKHKIKKKOK9K;K^K\KWKNKNK[KfKÄKÓKÏKÐKÎK×KðKõK«KuKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKwK{KZK9K>K=K>K7K7K:K:K:K:K:K:K:K9K8K7K8K8K7K;K5K)K2K2K4K3K5K5K3K2K0K0K-K+K)K,KBKGKEKJK;K%K%K!K!K KKKKK K#K*K/K2K5K8K;K9K=K?K@KBKCKCKEKHKFKHKIKHKIKKKMKSKVKUKiKÉKÚKÛKÛKßK©K{K€K€KKKKKKKKKKKK€K€KK€KƒKKK‚KƒKƒK‚KKKƒK€KKKKKKK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒKƒK‚K„K…K…K…K…K„K‚KƒKƒK„K…K„KƒK‚K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qò(KvKjK`K.KUK{KÁKÕKÎK¥K¦K|KBKJKTKAKYKºK—KiKpKmKŽK®KQK?K©K–KBKLKyKK‚KŒK—K¤K²KÀKµKbKKKOKLKLKMKMKQKMKžKüKöK÷KõKóKñKïKïKïKðKñKôK÷KöKëKÁKÀKôK½KmKSKJKKKGK:KTKRKMKEKAKYK\K]KIK?K@KHKHKHKDK=K;K,KKKKKKKK KKK K KKKKKKKKKKKK K%K/K1K1K-K*K+K-K+K,K#KKKKKKKKKKKKKKKKK&K&K'K&K)K)K,KK;K=K=K8K3K:K:K:K:K:K;K9K8K9K9K9K8K7K8K8K7K5K2K5K5K6K7K4K3K0K.K.K-K/K-K9KIKGKHKCK+K%K$K K KKKKKK#K(K-K0K3K8K:K:K:K=K@KDKDKDKFKGKFKHKIKHKIKKKMKQKRKWKVKœKÜKÕKÙKÝKÍKˆK}K€KKKKKKKKKKKK€K€KK€KƒK‚K‚K‚KƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K„K„KƒKƒKƒKƒK‚K„K…KƒKƒK…K„K„K„K„K…K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qó(KoKMKEK0KLK„KÄKÏKÂKÐKÞKÇKjKDKNKPKAKOK—KqKnKoKvKuKRKK.KmKjK9KHK‘K•K„K}KyKtKsKyKnKGKFKNKLKJKJKMKNKeKŒK£KºKÒKãKðKøKùKùKùKõKòKïKîKñKöKãKèKµKhKOKKKLKDK:KWKPKMKEKAK\K\K\KFK>KAKUKYKYKXKWKYK>KK KKKKKK K K K K KKKKKKKKKK#K,K/K.K/K/K1K/K,K)K%KCK*KKKKKKKKKKKKKKKKK!K&K*K%K'K3KFK]KpKsKpKnKpKpKnKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKpKpKsKsKqKpKqKqKpKsKtKtKsKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKsKsKsKsKsKtKvKtKsKsKtKuKuKuKuKuKtKtKuKuKuKuKuKuKuKuKwKZKHKLKIKHKHK.KSK^KYKTKHKTKXKKÖKÎKÐKÐKÐKæKõKãK†KyK{KyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KzKxKxKxKLK9K=KK@KCKDKFKFKFKHKHKIKIKLKKKQKSKWKWKkKÍKÜKÙKÙKßKªK|KK€KKKKKKKKK€KKK€K€KKƒK‚KƒK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K„K…KƒKƒKƒKƒK‚K„K…KƒKƒK„K…K…K…K…K…K…K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qô(KVK=KK7K7K:K9K9K:K:K:K:K5K6K:K9K:K8K8K8K8K6K5K5K2K4K4K5K5K4K3K1K/K0K/K@KHKFKJKCK(K%K#K!KKKKKK!K$K(K-K1K5K9K:K9KK?KCKDKEKGKGKEKHKIKLKJKLKSKTKWKVKžKßKØKÙKÜKÎKŠKK‚KKKKKK€K€KKKKK‚KƒKK‚K‰K„K„K…KƒKƒK‚KK‚K‚K‚K‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„K…K…K„K‚KƒK‚K„K…K…K„K‚KƒK„K„K…K…K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qõ(K:KAK6KKAKYKÛKòKÚKÆK°K˜KƒKqKdK\K[KdKuKŠK£K»KÈK²KÇK—K`KIKKKLK@K?KZKPKMKAKHK_K^KZKAK?K9KKKKKKKKKKKK K +K K K K K KKKKKKK"K(K*K+K-K/K/K*K+K#KKKKK.KxKKKKKKKKKKK KK"K&K)K'K'K3KKKbKnKrKqKoKnKoKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKqKpKqKsKrKqKqKqKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKtKtKsKsKtKtKvKtKsKtKtKtKtKuKuKuKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKnKLKKKMKLKLK:KKCKYKPKMK>KHK^K_KWK>K?K7K*K%KKKKKKKKKKKKK K K K KKKKKKK#K$K(K)K+K+K$KKKKKKKK0KuKKKKKKKKK"K#K%K&K&K&K+KK?KAKBKDKDKCKCKHKHKIKLKLKLKLKNKQKZKUKŸKàK×KÖKÚKËKŠK€KƒKKK‚KƒK€KKKŽKªK¢K‘K“KœK©KÁKÅK©KžK”K†K‰K™KŽK€K‡K…KKKƒK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒK…KƒK‚K„K…K…K„K‚K„K…K…K…K„K„K„K…K…K…K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]q÷(K/K9K:KJK{K¦K£KÀKÛKìKáKÛKÛKÛKàKÍKmKFKMKGK_KÜKóK£KhKpKmKoKWK!KhKéKâKiKwKãKëKèKêKëKëKêKïKéK‰KJK@K2K,K3KQKK°KÚKóKúKùK÷KöK÷KôKìKßKÐK³K¹K¦KyK[KHKIKIKFKNKWKOKKKDKSK]K`KTK>KAK=K2K+K%KKKKKKKKK KRK#KK K K K KKKKK K'K)K)K#KKKKKKKKKKK/KjKK K KK KKK"K'K&K(K(K2KHKbKpKrKqKnKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKrKrKrKrKrKrKsKsKsKsKpKqKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKsKtKtKtKtKsKtKtKuKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvK]KHKJKJKJKJK-KRK`KZKTKJKTKXK‰KÕKÒKÓKÓKÐKãKõKíKKwK{KzKxKyKyKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKyKxKxKxKyKyKyKzKzKzKyK{KdK;K>KK?K@K@KCKCKEKGKFKHKIKKKLKLKJKMKTKWKUKnKÒKÜKÚKÚKáK®KKƒK‚KK€K‚K€KK„K·KÎK¬KŸK­K¼KÁKÐKÍKÂK¾KÌK­K‹K¥K KpKKK—K‰K‚K„KƒK‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒKƒKƒKƒKƒKƒK‚KƒKƒK„K…K„K„K…K…K…K„K‚K„K…K…K…K„K„K„K…K…K…K…K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qø(K)K4K=KJK{KKªKÈKâKèKÜKÙKÞKßKÚKáKËKmKHKEKxKêKéK‹KjKoKoKnKrKXK"KgKêKçKmKtKàKëKêKìKìKìKêKîKìKKiKcKQK>K1K-K2KLKuK¦KÓKïKöKõKñKíKïKùKëKêKÜKxKTKHKIKIKGKPKWKNKIKKKZK\K_KRK?KCK>K4K.K)K$K!KKKKKKK K9KKK K K K K KKKK!K"KKKKKKKKKKKKKK(K[KK!K K K#K%K'K)K&K.K@KWKjKrKsKpKpKpKqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKrKtKqKpKsKtKtKsKsKsKsKpKqKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKuKsKsKsKsKsKsKsKsKtKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKxKfKIKIKHKLKMK3KGK_K[KUKMKPKYKrKÌKÓKÒKÓKÐKÚKòK÷K­KuK|KzKxKzK{KyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKxKxKxKzK{K{KzKzKzKzK{KtKFK;KKK>K:K9K6K5K7K8K7K9K:K:K9K8K8K8K8K8K8K8K8K6K4K3K2K3K2K1K6KFKIKIKHK;K(K&K#K K!K KKKK K'K,K0K4K6K;K=K>K?K>K?KAKBKGKHKFKHKHKJKMKLKJKKKRKWKWKTK¥KäKÛKÜKßKÏK‹KKƒKƒKK„K€KƒK“K«K¯K£K™K®KÁK¯KÖKÞKÏK´KËK©KšK°KºKK„K‘K¥K¥KŠKƒKƒK‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒK…K…K„K…K„K‚KƒK…K…K…K…K…K…K„K„KƒK‚K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qù(K%K3K@KGKgKˆKÁKÉKåKæKÑKÇKÁK¾KÅKÄKÛKÌKiKCK–KóKÛK\KcKrKmKoKoKrKYK"KfKÝKÔKoKsKäKîKçKëKìKìKêKíKæK™KqKxKoKdKUKDK5K,K0KCKnKžKÎKíKøKõKñKàKìKÈKpKOKGKIKHKGKTKVKOKIKMKZK\K^KNK?KBK=K5K2K/K*K&K"KKKK KKKKKK K KKK KKKKKKKKKKKKKKKKKKK*KSKKK"K%K'K%K&K5KMKdKpKsKqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKrKsKpKpKpKpKpKpKpKpKpKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKtKsKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKuKuKuKuKuKuKuKuKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKkKIKHKIKIKKK9K9K_K]KVKOKLK[K`K»K×KÒKÓKÒKÔKïKùKÉKxK{KzKzKzKzKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKyKyKzKzKzKzKzKyKzKzKzKzKzK}KVK;K>K>K?K2K8K;K7K5K4K9K;K=KK?K?K?KAKCKDKFKGKGKGKIKIKKKLKKKNKTKUKUKpKÓKÜKÜKÛKÞK­K~K…K‚K„K„KKŒK€KˆK€KnKqKˆK‰KK¥K¿KÊK¯K›KuK›K¦K°KªK…K|KŽKœKŽKƒK‚K‚K‚K‚KƒKƒKƒK‚K‚K‚K‚K‚KƒK„KƒK‚K„K„KƒK„K„K„K„K‚KƒK…K…K…KƒKƒK„K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qú(KK$K:KEK;KwK±K¸KæKÐKKnKfK[KgKlKKÞK²KaK°KúKÈKIKBKfKqKnKnKnKrKXK4K–KÛKäKrKuKåKìKéKëKëKëKêKîKæK™KmKtKsKuKrKiKYKIK8K.K0K@KcK“KÂKãKÜKïKÃKgKLKHKIKGKHKVKUKOKHKMK[K]K^KJK?KBK=K6K3K0K*K(K&K!KKKKKKK KK KKKKKK KKKKKKKKKKKKKKKKK"K5K#K$K%K&K,K>KWKkKrKqKnKnKpKpKqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKpKpKpKpKpKpKqKpKpKpKrKtKsKsKsKsKsKsKsKsKsKsKsKsKtKrKrKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKuKuKuKuKuKuKvKuKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKsKPKGKIKHKKKBK7KZK]KWKOKIKYKXKŸKÙKÑKÓKÒKÒKéK÷KãK„KyK{KzKzKzKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKxKyKzKzKzKzKzKxKyKzKzKzKzK}KgK@K>K>K?K8K0K5K6K:K;KK?K>K>K@KCKDKFKGKFKGKHKHKKKMKKKLKRKTKYKWK£KÞKÚKÜKÝKÖKKK‡KK•K”KqKnKdK`K`K`KoKbKzK¢KµKÔK±KžK„KKÊKÍK¹KKKŒK›K”K„K„K‚KƒKƒKƒKƒKƒK‚K‚K‚K‚K‚KƒK…KƒK‚K„K„K‚KƒK„K„K„KƒKƒK…K…K…KƒKƒK„K…K„K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K…e]qû(KKK0K>K!KUK}K™KÂKK7K:KK?K:K0K:K=K=K=K=KK:KTK®K¿KÃKáK…K=KRKFK@KfKrKoKrKlK‡KìKàK‚KàKëKqKqKÝKìKèKèKëKíKëKîKçKœKnKqKqKpKpKpKrKsKsKlK`KOK;K)KK#KhKiKFKGKGKGKHKPKPKKKBKOK]K`K_KIK?KBKK>K5K:KK=K=KAK@KAKEKFKFKGKJKJKKKKKLKLKNKSKWKXKWK§KÞK×KÙKØKÉK®K¤K—KnKXKIK/K?KAK2K.K2KUKJK?KNK{K‰K•K…K K·K¯K´K¨K¬KÇKÈKÑKÈKŒKƒK†K„KƒKƒKƒK‚K‚K‚K‚K‚K‚K‚KƒK„K‚K‚K‚KƒK„K„K„K„K„K…K…K…K„K„K„K„K„K„K…KƒKƒK„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…e]qý(KKKK)K>K5KdK¬KšKIK5K:K8K9K9KK>KKKAKBKDKGKFKFKHKHKJKLKLKKKNKTKVKUKtKÏKÕKÖKÑKÁK¦KKnKJKHK:K%K2K*K"K"K1K0K"K%K8K>KBKGKK"K"K K)K4K=K;K7KƒK KwKtKmKTK?KJKLK=KK>K?K>K>K=KKIKIKKKHK-K&K%K%K!K KKKKK$K+K/K5K7K9K;K=K=K?K>KAKCKDKGKEKAKHKHKJKLKLKKKLKPKQKZKYK­KÞKÓKÉK¬KžKeKRK7K3K+K+K/K)K"K"K#KKK$K*KKK&KK5KQKwKlKKuKgK•K´KÈKÐK•K‚K…K„K„K…KƒK‚KƒKƒK‚KƒKƒKƒKƒKƒKƒKƒKƒKƒKƒK„K„K…K…K…K…K…K„K„K„K„K„K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K…K†K…K…K…K…K…K…K…K…K…K…K…e]qÿ(K/K&KKK=KFK½KöK·KKKK K K!K6K?K7KvK´KÌK¦KgKmKSKBKFKGK?K>KfKnKhKqKsKtK\K%K7KK|KK;K6K9K@K?K?K?K?K?K>KKAKDKDKFKGKGKGKHKJKLKKKKKMKNKOKWKVKyKÕKÙKÀK¥KyK5K.K(K(K-K4K4K)K%KKKKK!KKKKKK#K7K\KgK”K›KyK“K½K´KÑK®K…K†K…K…K…KƒK‚K„K„K‚KƒK…K…K…K„K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K†KˆK†K„K…K…K„K„K„K…K…K„K…e]r(K-K-K&KK6KXKÕKõK K*K4K2K9KHKYKmKKMKXKÉKòK¥KRKsKqKVKCKEKCK?K@KaK™K§KKnKsK]K&K*KnK|KHKMK©K¶K¥KšKK†K}KsKoKpKoKqKoKoKpKpKpKoKoKpKZKXKrKUKDKGKHK8KCKWKOKKK?KKK`K`KZKKKKKFK5K0K0K/K-K+K'K$K"K.K-K)KK +KK K K KKKKKKKKKKKKKKK!K!K"K$K&K%K6KJK]KqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKsKsKsKrKqKpKqKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKtKsKuKuKsKtKuKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKvKuKvKvKuKuKuKvKxKaKHKIKIKHKIKLKRK\K[KVKLKMKXKfKÅKÖKÒKÓKÒKÖKïK÷KÆKwK{K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}KkK>K?K?K@KK>K>K>K=KK?K?K?KBKDKDKEKGKFKHKJKLKKKKKLKLKRKVKXK]K°KÞKºKˆKBK&K&K#K(K.K1K2K*K%KKKKKKKKKKK KHKXKvK›KÂK±K¼K×KËKÎKÊK‰K„K…K…K…K„K„K„K„K„K„K„KƒKƒK„K„K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K…K‡K‡K‡K…K„K…K…e]r(K(K)K)K)K0KuKæKïKK9KQKgK„KŸK°K¼KÃK KwKÙKöKKAKpKpKnKVKAKCKJKKOK_K`KZKKKIKBK4K0K0K.K-K+K'K$K"K.K.K.KK +KK K K KKKKKKKKKKKK!K"K#K%K%K%K%K&K(K7KKK^KqKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKsKsKqKpKpKqKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKvKtKsKuKuKsKtKvKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKwKuKuKuKvKvKvKuKxKjKKKIKIKIKHKLKOKYK\KVKNKHKYKYK¯KÙKÑKÓKÒKÒKèK÷KàK‚KzK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KyKMK>K?K>K?K6KK?K?K?K?K?K?K?K=KK?K?K>KBKDKCKDKFKGKHKJKKKKKKKLKJKOKUKYKWKyKÔK£KRK4K&K)K)K,K(K)K-K+K!K KKK KKK!KKKK#K:KPKoKK¥K¢KÀK×KßKßKàKœKƒK…K…K…K…K„K„K„K„K„K„KƒK‚K„K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K…K…K…K…KˆKˆKˆK†K„K…K…e]r(K+K+K*K*K&K’KðKãKjKdKK¯K¼KÃKÆKÄKÍKÇK«KäKïKsK9KiKqKnKnKRKFKIKAK{KíKêKKoKsKrKtK`K%KQKÜKåKwKjKÝKîKèKëKêKèKèKèKàKŸKqKtKqKpKpKoKnKnKVK]KmKJKDKCKHK5KLKTKMKJK=KQK`KaKZKLKJK@K3K1K.K+K-K+K'K$K$K1K0K/KK +KK K K KKKKKKKKKKK#K$K$K%K'K(K)K(K+K(K8KKK^KpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKsKsKtKrKpKpKpKpKqKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKuKuKtKsKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKxKyKxKxKxKxKxKxKxKvKvKqKNKHKIKHKHKKKEKUK]KWKPKIKVKWK“KÙKÑKÓKÓKÑKâKôKñK˜KxK|KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K\KK9K9K?K>K>K>K>K>K?K>K9K;K=K?K>K=K=K=K=K=K=K=K=K;K9K9K:K8K4K4K5K4K4KEKLKKKKKBK*K)K&K#K#K KKKK!K*K2K3K4K8K9K;K?K>K>KBKAKBKEKEKHKIKIKIKKKLKLKKKLKQKVKWKVK§K„K4K3K%K+K'K'K&K)K)K&K$KKKKKKKKKKK#KK>K?K@KCKBKDKEKHKIKHKHKKKLKKKLKIKMKVKWKRKnKaK4K3K,K*K$K'KK K"KK#KKKKKKKKKK$K3KJKYKmKŸK²K–K«K¬K£K²K×KÆKK…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K‡K‡K…K…K…K…K…K…K†e]r(K$K#K!K5KVKÍKñKÏK¶KÌKÉKÎK×KØKÔKÕKÓK¾KÁKòKÍKCK4KQKrKpKpKrKkKSKJK®KóKçKäKåKÙK˜KpKrKwKdK+KdKÖKãK…KmKÞKòKéKëKíKíKïKóKàK‰KnKpKqKpKqKiKdKŠK^KFKFKGKDK6KPKSKMKGK=KYK_K_KTKMKLK;K-K-K.K+K(K&K&K#K$K0K2K3KK K KK KKKKKKKK$K&K#K&K(K'K+K*K*K*K*K,K-K.K=KMK`KsKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKqKpKpKpKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKxKxKyKwKuKwKyKxKxKxKxKxKxKxK{KaKFKIKHKIKKK/KBK]K[KUKMKMK[KdKÀKÕKÒKÓKÒKÖKïK÷KÐK}K~K~K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KzKPK@KBKAKBK:K>K?K>K?KBK@K>K@K>K>K?K?K=K;KKZK^K^KRKMKNK:K-K-K,K*K(K'K&K#K%K2K2K1KKK K K KKKKKKK"K'K)K(K*K,K,K,K-K/K.K.K/K0K0KAKNKaKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKrKrKrKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKtKsKtKtKtKtKtKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKwKwKwKwKxKxKxKxKxKxKwKxKxKxKxKxKxKxKxKxKzKhKFKIKJKIKKK7K6K^K[KXKPKIKZKZK§KØKÑKÓKÓKÒKèKöKèKŠKzK~K{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}KbK>KBKBK@K9K9K=K?K@KBK@K>K?K>K>K?K?K?K?K=K=K?K>K=K=K=K=K=K:K:K:K8K8K4K/K5K4KDKNKKKLKHK.K&K&K%K#K"K KK K!K(K0K3K5K7K:KK?K?K>KAKBKEKEKHKGKIKLKKKKKKKLKKKNKTKXK\KPKAK7K7K4K*K-K1K"KK"KKKKKKKKKKKK*KcKKŒK|K™K¯KªK·KÂKÆKÑKÃK„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K†K†K…K…KˆKˆKˆK‡K†K‡KˆKˆKˆKˆKˆKˆKˆKˆe]r(K,K+K4KKK€KÎKÐKŽKtK~K‚K‚K€K¡KÄKÏKÌK§KÖKøKŽK K/K6KbKqKpKqKpKqKwKØKòKíKíKîKíKïKëK¢KqKvKqK¥KõK¼KÙKùK‡KjKÛKîKæKëKíKïKÛK‘KVKgKrKoKrKeKVKhKZKEKGKHK>K7KVKQKJKBK@K[K^K]KRKMKMK6K,K-K*K*K)K'K&K"K&K4K2K/KKK K +K KKKKKK#K%K)K)K)K+K.K.K.K.K0K0K0K.K1K3KCKPKbKrKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKpKqKtKsKtKtKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKvKtKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKxKyKyKyKyKxKxKxKxKxKxKyKxKxKxKxKxKxKxKxKxKyKqKKKIKLKIKJKAK/KWK\KXKQKHKVKUK‰KÖKÑKÓKÓKÑKàKôKôK¢KxKK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{KpKEKBKCK>K7K7K?KBKBKBK@K>K>K?K?K>K>K?K?K=KKKAKBK?K@KAK?K>K>K>K>K?K?K>K>K?K?K>K>K>K=K=KKAKBKDKEKGKGKEKGKHKIKJKLKKKJKOKQKYKPKDK>K:K/K-K9K7KMK4K%K&K(K#KKKKKKKKK KMKLKtKK›KŸK«K¬KK¥K¤KºK K~KK„K†K†K‡K†K…K…K„K‚KƒK„K„K„K„K…K…K…K…K…K…K…K…K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K‡K‡K„K…K‡K†K…K‡K‡KˆKˆKˆK†K…K‡KˆKˆKˆKˆKˆKˆKˆKˆe]r(KKK@KBK@K>K?K?K>K?K?K?K?K?K?K?K?K?K=K=K=K=K=K;K9K9K6K4K5K3K>KLKKKLKLK6K'K(K'K%K$K#KKK!K&K-K0K7K8K9K;K?K@K>KBKBKCKEKGKFKGKHKIKHKIKLKLKLKLKJKUKTKIKKAKAKAKBKAKAKAKAK?K?K?K?K>K?K?K?K>K=K=K=K=K=K=K;K8K9K6K4K5K4K7KIKKKKKMK?K(K(K&K$K#K$K#KKK$K,K/K2K6K9K;KKAKBKCKEKGKGKGKHKIKKKLKKKKKLKKKOK\K^KGK7K8K-KK/KAKDKMK$KK$K(K(K%KKKKKK8K‘KÃKêKKÿK÷KóKïKèKîKôKãKÒKÑKØKÎK”K}KiK\KWKVK^KcKfKjKtKwKtK|K†K…K„K„K„K„K„K„K‡K†K‡K…KƒKƒK„K…K…K„K„K…K…K…K…K…K‡KˆKˆK†K„K†KˆKˆK‡K„K†KˆK‡K‡K…K…KˆKˆKˆK‡K‡KˆKˆKˆKˆKˆKˆKˆKˆKˆe]r +(K2K;KPKˆKàKáKÑKÈKÏKËK¼K±K˜KK]KpKjK•KµKwK+K1K0K2K1K^KtKpKtKrKpKxK»KóKíKíKíKíKîKìKõKšK[KÑKãK’KpKfK'KFKÈKíKzKIKžK²KŠK[KLKNKHKDKHKLKRKYKIKCKCKFK5KEKSKMKIKK>K?K?K?K?K?K?K>K=K=K=K=K=K=KKK?K?K?K?K?K=K=K=K>KK)K)K(K%K"K"K!KK#K(K+K.K1K6K:K;KCK@KAKEKDKDKCKEKGKHKIKJKKKKKMKNKLKJKQK^KLK8K=K.KK/KOKIKQK>KK,K4K/K"KK"K1K†KÍKõKäKäKßKËKÁKÄKÌKÓKØKÖKÖKÜKáKîKõKóK‹KtKËKËKÃKàK½KŠK„KK_KK +KKYKŠK‡K„KxKhK^KMKCKUK^KnKxK~K‡K‰K‡K‡K‡K„K…K…K„K„K„K…KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆK‡K‡KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆe]r (K¹KÖKÐKÍKìKåKÏKÒKÒKÐK×KÔKÐK¿KK3KlKêKíKmK$K/K5K7K3KMKsKqKsKtKÄKÙKÂK¾KÈKÑKÉK¨KÍKàKàKgK`K{KoKrKrKpKsKcK%K KVK`K:K.KGKPKMKLKHKFKKKEKCKIKIKEKCKEK4KLKRKMKJK:KMK^K[K]K^K[KOK2K(K$K$K'K%K#K$K!K-K5K5K,KK K KKKKKK K%K)K.K1K1K3K5K7K7K4K6K9K8K7K9K9K;KLKTKeKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKtKsKsKsKtKuKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKwKxKxKxKxKxKwKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK|K[KGKKKJKGKJK/KCK^K[KUKMKLKYK]KºKØKÑKÓKÓKÑKéKóKãK†K|K~K}K}K|K|K|K{KzKzKzKzKzKzKzKzK|K{KzK{K|K|K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KvKFKAKDKCKCK;K@KBKBKBKBKBKAKBK@K@K@KAKBK@K@K?K>K?K?K?K>K=K;KKKMKLKKKLK:K)K'K%K&K%K$K#K K K'K+K.K0K5K:KK?K?K?K?K?K>KKCK>K@K;K@KCKAKBKBKBKBKAKCKAK@KBKBK@KBKAK?K?K?K?K?K?K>K=K=K=K:K9K8K8K8K5K@KMKLKNKMK5K(K)K&K%K$K#K K!K$K'K.K1K5K:KK?K?K>K?K?K=K=K;K8K8K6K5K5K9KLKMKKKMK?K)K)K)K&K%K&K#KK!K'K+K/K3K8K:K=K>KDKGKCKBKBKDKGKGKGKDKFKMKKKMKMKMKQKKKIKSKiK˜KÄKûKÎK¥K´K¾KÎKåKóKöKòKüKéKÜKéKøKûKúKæK¯K KµK¾K¾KÂKÇKØKöKóKâKßKåKøKKKAK:K)K K K#K)K7KGKfKK”KkKIK%KKKKKKKKK6KKKVKeK€K‘K“KK”KŽKŠK†K„K„KˆK…KˆK‹K…KˆKŠK‰K‰K‡K‡K‡K‡KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆe]r(KwK‡K¿KéKÚK¼KÅKËKÇKÂK°KdKK KKmKêKóKpK!K/K.K/K2K3K6KgKuKvKÑKðKíKïKëKíKíKìKìKéKóK†K[KÐKÀKWK9KBK/KUKsKoKpKqKlKIKBK'K-KCK0K$K3KIKDKGKAKDKCKCK?KDKNKLKGKBKOKXKZKZK[K\KbKXKRKaK^K]K^K`K_K_K_K_K^K^K[KKK/KKKKKK!K%K*K,K0K3K5K5K9K8K7K:K:K:K:K:K=K;KIKrKSKfKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKtKtKsKsKsKtKtKsKsKtKtKtKuKuKtKtKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKuKuKuKvKxKvKuKvKvKvKvKvKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKxKxKxKxK{KbKGKIKGKGKJK7K5KZK[KYKRKGKUKTK•KÚKÑKÒKÐKÎKßKóKöK«KyKK~K}K}K}K}K}K{K{KzKzKzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K|K€KjKBKDKCKEK@K8KBKCKBKBKBKBKAKBKBKAKAKAKBKBKBKBK@K?K?K?K?K?K?K=K=KKDKHKDKBKBKDKFKFKGKGKJKLKKKLKMKOKIKGKaK‘KÔKÍKÑKüKëKšK¤K³K²K°K·KÍKåK÷KõKçKäKùKýKìKõKäK§K˜K­K½K½K¼KÆKÕKõKèKÖKáKïKK¢KK0K;K3K,K&K&K"KKK'KgK›K«K¥KƒK'KK KKK K K +KK"K,KKKcKzKK¤KœKK‡K‚KxKzK}KmKmK‰KKKK„KŠKŒK‹KˆK‡KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆe]r(K¡KšK¹KÒK·KŸK¯K¶KÁK¤KUKKK KK‡KïKâKJKK*K-K0K2K6K9KbKsKKÝKóK¾KÖKñKêKëKëKëKëKðKtK[K…K^K>KK?K=KK0K#K1KGK>KBKDKCK>KEKNKJKFKDKPKXKZKWKEKPK`KQKVK_K]K^K^K^K_K`K`K`K`K_K^K^K\K]KaK`K\KOK@K1K+K,K0K4K6K9K:K;K;K=K=K=K=K=K>K=KJKqKTKhKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKtKtKtKtKuKuKtKtKtKuKuKtKtKuKuKuKuKuKuKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKwKuKuKuKvKwKwKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KzKyKyKyKyK{KvKOKHKHKIKJKJK+KMK\K[KWKKKMKWKgKÇKÕKÒKÐKÐKÑKìKöKàK†KKK}K}K}K}K}K}K}K|K|K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K€K[K@KDKDKDK=K=KCKCKBKDKCKBKCK@K9K>KBKAKBKBKBKBKBK@KAKBK?K?K>K=KKBKGKHKEKCKCKCKDKGKFKHKKKLKJKJKKK`KK–K”K‘K“K®KçKþKöK®KŒKžK®K±K´K²K¨K®KËKÚKåKïKýKïKÍK´KàKÉKœK§K±K¯K»KÃKßKòKÙKåKüK·K(K K KKK%K'K(K'K&K$KKKKBK†K«K KpKLK4KKKKKKKK K +K KK4K‹K¹K£K“KK‰KtKaK}K·K¸KKfKQKcKƒKyK€K‰K‰KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆKˆe]r(K KUK}KrK_KKKQKRKK KKKKK"K}K¡KxKKK"K#K*K-K0K2KYKpK“KâKÛK„KnKŠKÕKíKäKÞK×KªKIKRKHK\KpKHK2K2K0K7K*KJKtK^KAKCKkKcK!KK2KJK8K!K#K>KGKDKBK3KCKNKIKGK>KJKZKXKSKK*K8K=KXKdKaK]K\K\K_K`K`K`K`K`K`K^K\K\K[K\K]K_KaK[KQKDK;K6K5K8K:K=K=K=K=K=K=KKIKlKSKhKrKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKvKvKvKvKuKuKuKvKvKuKuKuKuKuKuKuKuKuKuKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzK{K{KzK{KzKxKXKHKHKJKLKNK0KBK]K[KYKOKNKXKYK®KØKÑKÐKÐKÎKãKóKñKšK{K€K}K~K}K}K}K}K}K~K~K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKkKCKCKDKCKAKK?K?K=K;K9K:K:K9K9K4K?KNKOKNKMK6K)K+K)K&K&K&K"K!K%K)K,K2K6K8K=K@KEKHKFKCKDKDKDKGKFKHKKKLKKKQKŠKK€K’KœKšKšKšK¼KìKýKöKÏK¡K”KŸK£K­K²K¥K¢KÃKßKäKôKÿKèK±K¼KéKÍKKžK¦K«KÀKÀKêKëKãKüK¼K1KK KKKKKK"K$K"KKKKK2KbK¦K•KVKHKRKEK$K KKKKKK0K6K&KGK¨K·K­K°K©K–KoKcKK·K©KœK–K‡K¥K­K„K„K‡K‡KˆKˆKˆKˆK‡KˆKˆKˆKˆKˆKˆe]r(KKŒKÉK KOKEKLK'KKKKKKK3KmKlKBKK!KK K$K'K0K1KWKrK…K±K£KvKtKqK‚KµK¾K£KƒK\KBKOKFK_KuKlKFK2K'K(K5K%KMKZKAKHKkKvKaK$KK[KgKKKCKEKBKAK-KDKPKIKFK9KHKVKYKQKKFKHK@KCKIKSK[K^K_K^K_K_K`K`K_K]K]K]K_K_K_K^K\K\K]K^K_K\KVKIK>K;KK@KCKDKBKBKDKCKCKCK@KAKBKBK@KBKBKBKBKBKBK@K>K?K?K>K>KK>KHKhKSKiKvKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKtKuKuKuKsKsKuKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKxKxKyKxKuKwKyKxKxKuKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KyKxKzKzKzKyK{KlKFKHKIKHKJKAK0KXK\KYKRKKKUKUKuKÒKÓKÐKÐKÎK×KïKõKÒK~KK~K|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K|K€K^KBKDKCKK?K?K?K>K=K;K:K6K5K9K7KFKNKNKMKKK5K)K)K(K%K$K$K!K K$K*K-K3K9K;K=KAKHKIKIKGKDKDKGKFKIKJKIKgK‚KxK|K‚K‡K•K—KK—KœKÖKõKóKðKôKîKŸKKƒK†K”K§K§K¤KÐKßKÜKûKÙK£K¸K¶KäKÃK€KœKµK¿KµKÞKæKKwK@K K K +K KKK KKKKKKKKK +KK^K›KEKK K KKK&K9KŠKÀKªKŠK'KKCKžK˜K‰KžKªK§K¢K­K±K®K¬K”KsK‘K–K{K‰K¥K—K…KˆKˆKˆKŠK‰KˆKˆKˆKˆKˆe]r(KrKÝKõK†KKKKKKKKKKK}KçKØKLKK%K$K!K#K%K'K,KHKqKOKBKaKvKsKsKsKsKeKHKGKAK@KJKFKgKvKpKrKoKHK0K)K/K.KJKvK‹KuKpKoKtKdK1K4K&K;KEKBKBK>K.KMKNKIKEK8KLKWK[KMKK+K@KRK\K\KXKRKHKAKCKKKVK\KaK]K\K\K]K]K]K`K`K_K_K_K_K_K_K^K\K]K]K^K\KUKOKFK>K:K;K=KHKfKSKjKuKtKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKsKuKuKsKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKxKuKvKxKwKuKxKxKxKxKuKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzK{KuKMKHKHKIKIKHK.KPK\KZKWKNKOKWKcKÃKÕKÒKÒKÏKÐKëKöKçKK~K~K|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K€KqKDKCKEKAK@KK>K?K?K>K=K;K9K;K:K8K6K=KNKNKMKOK?K)K+K*K(K%K%K$K"K$K'K,K0K8K;K=K@KDKHKIKIKEKEKGKFKIKHK[KwK}K{K{KƒK„KŒK“K—K˜K›K¿KóKõKîKíKåK«K†K…K~K|KŒK¤KªK§KÓKÚKÙKõK¸K®K¾KµKÞK·K~K›K³K¸K·KîKÀKKDK+KKK +KKKKK KKKKKKK K +KKlK}KK KK KKK K+KwK¬K³KfK +KK`K¢KKK¦K¦KKšK«K¨K§K©K‡KqK–KKrKlKœK˜K‡KˆKˆKŠKŠK‰K‰K‰K‰K‰e]r(K¶KâKðKfK KKKKKKKKK!K¥KôKÔK6KK$K#K%K&K&K)K*KDKkKIKGKhKtKrKsKsKrKuKfKJK:K@KHKIKnKuKrKpKtKmKEK-K+K0K„KßK¸KoKsKpKpKuKcKGK5KGKCKBKBKKEKcKSKjKuKsKsKsKsKsKsKsKsKsKsKsKsKtKtKsKsKtKtKsKsKsKuKuKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKxKxKvKvKyKwKuKwKxKxKxKvKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKyKyKzKzKzKzKzKzKzKzK|KVKGKJKMKOKTK4KBK\K[KXKOKNKYKVKªKÙKÑKÒKÐKÍKàKôKôK¦KzKK}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K|KQKAKEKEKEK=K@KDKCKDKDKDKCKCKDKDKCKBKBKBKBKBKBKAKAKBK?K?K?K?K>K=KK@KBKDKHKIKIKHKFKGKEKSKzK‚KK{K{K„K‚KˆK‘K”KœKŸK£KÇKãKîKñKãK K•KK„K|K|KˆK£KªK¦KÊKÑKÝKîK¹K·KÂKºKÛK»K€KK¯K©KÎKëKŒKGK0KKK +KKKKKK K KKKKK KKKK^K7KK K K KKKKK^K¢K¤KMKKK}K KK˜K©K™K“K¤K¤K¥K¦K¡K‚K‰K›KK‰K¥K§K’K‡KˆKŠKŠKŠKŠKŠKŠKŠe]r(KÊKéKâKCKKKKKKKKKK/KÀKôK´K$K$K$K$K%K(K)K'K)K?KaKDKIKkKrKoKsKsKpKpKsKiK>K@KFKNKqKtKsKtKpKrKmKBK-K7K¶KK§K@KuKqKpKrK_KEKEKIKAKAK?K8K4KPKKKGKCK9KPKVKXKDK*K+K(K&K"K K&K5KJKXKXKZKXKQKFKCKDKNKYK^K_K]K]K_K`K`K`K_K`K`K`K^K\K_K`K_K_K`K^K^KZKUKUK`KUKkKwKtKsKsKsKsKsKsKsKsKsKsKsKuKvKtKsKvKuKsKsKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKyKxKxKyKyKyKwKuKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKzKzKzKzKzKzKzKzKzKzK|KbKJKRKSKQKXK=K5K[K[KVKRKNKXKTKŒKØKÒKÒKÐKÎKØKïKøKÂKzKK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKaKAKCKBKFKAKKAKBKJKLKKKGKEKFKPKvK}KK„K~K{KƒKƒK‡KK–K›KžKžK®KÅKÐKàKéK¹KžK K™KŒKƒKKˆK¦K¦K˜K²KÆKàKóKÅK¼KÃK¹KÏKÈK‡KˆK¡K³KïK™KHK7K"KK KKKKKKKK KKK KKKKKKK +K K KK-KWK7K!K5KvK‘K™KLKK2KŽK„KvKžK¡K“K˜K“K¡K¤K¥KK‰KKUKdK`KYK•K“KˆKŠKŠKŠKŠKŠKŠKŠe]r(KÍKíKÈK)KKKKKKKKKK@KÊKàK‚KK%K"K"K$K%K'K)K)K;KUKEKLKoKrKrKsKsKrKrKrKuKhKNKCKSKtKsKtKsKrKpKsKnKAK>KÍKþK–KKHKsKtKqK[K@KNKIK@KAK@K4K9KRKJKGKAK:KSKVKYKFK0K1K,K(K'K&K!KK!K.KIKRKYK^K]KZKRKHKAKEKQK\K`KbK`K^K`KaK`K`K`K_K^K_K`K`K`K`K`K^K]K]K]K^K[KeKoKrKtKtKsKtKtKsKsKsKsKsKsKuKuKtKsKtKtKtKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKwKwKwKwKwKwKxKxKwKwKxKxKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKzKzKzKzKzKzKzKzKzKzK}KmKOKTKTKSKUKHK-KVK[KXKSKMKTKWKtKÑKÔKÑKÐKÏKÓKíKôKÞK†KKK~K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K~K~K~K~K~K~K~KKrKEKCKDKCKCK;KDKDKCKDKCKCKDKCKCKDKDKCKDKCKCKCKBKBKBKBKBKBK?K>K?K=K=K;K9K7K8K7K:KJKNKMKOKHK/K)K)K'K'K&K%K"K!K%K,K1K6K:K>KAKCKHKKKJKGKFKFKoKƒKwK}K†K€K{KK…K‡KŒK‘K˜KšK›KŸK³KÀK¾KÌKéKÛK¶K¡K™K•K‹K…KK©KœK‰KœK¬KÖKøKÏK¿KÅK´KÊKÑK¢K¡KºKÛKvKEK>K&KK KKKKKKKKK +KKK K KK KKK K +KKKKJK•K†KYKvK–KKK‰KyK‰K¢K’K—K™K—KKŽKKK—KKwKvKSKKK0K;K„KŸK‹K‡K‰KŠKŠKŠKŠKŠe]r(KÔKñK¨K!KKKKKKKK KKNK±K›KEKK%K!K K"K%K%K)K*K6KNKEKSKqKrKtKsKsKtKsKsKsKqKQKJKfKvKsKsKsKsKtKsKuKnK^KÍKäKpK3K,KEKrKqKWK@KHKFKAK@KAK4K=KTKIKGK?K9KVKVKYKDK4K2K)K&K&K&K%K#K#K'KSKK@KDKDKBKAKDKCKBKBKBKBKBK@K=K?K>K=K;K9K:K:K8K8KCKNKMKOKMK8K+K+K*K)K&K&K$K"K$K*K-K5K9K;K@KDKEKJKIKIKIKSK‚K„K}KK†K|KwK}K€K†KŠKŽK’K•K˜KœK¢K¯K¶K¶KÆKéKôKÚK²K™KŒKŠK…K’K©K“KŠKŠK•KËKëKÐKÁKÂK·K¹KÁK´K¥KšKXKKTKTKUK@K5K4K!KKK$K%K%K#K)K[KAKK$K%K2KDKUK]K_KNKJKMKCK@KHKQK]KbKaK_K\K]K]K^K`K_K]K^K]K\K]K_K^K\K\K\K_K^K_KbKgKmKqKuKuKtKtKtKuKuKuKuKuKuKuKtKtKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKwKxKwKwKwKwKwKxKxKxKxKvKwKxKxKxKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKxKyKzKzKzKzKzKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K\KQKVKUKSKPKHKPKZK[KUKOKKKWKUK¥KÚKÐKÐKÐKÌKÞKðKôK²KyKKK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KK~K}K}K}K}K~KKKKKK~KK€K~KKcKAKDKDKDKAKK@KCKDKBKBKCKCKBKBKBK@K?KAK@K?K>K>K=KKLKNKNKOKBK-K*K)K(K&K%K$K"K#K'K+K1K5K8K=KBKDKHKFKIKLKsKK‡K{KyKƒK{KsKyK|K~KƒK‡K‰KŽK”K—K˜K£K©K§KªKºKÚKóKêKÍK™K…KK‰K KKKK‰K”K©K©KÄK½K½K²K KK~KiKYK;K-KK KK K +KKKKKKKK +K K K KK +KK KK KK KK KKAK5KEKbKsK{K„K‘KK“KžK¢K§K¥K¢KK¡KªKªK·KÇKÅK±KœK¡K£KK”KšK“K‡K‰KŠKŠKŠKŠe]r(KßKæKwKKKKKKKKKK$KGKCKK3K3KKKKK K"K!K,KXKAK+K;K8K)KKK1KGKUKZK]KZKSKIKDKBKHKSK\K`K^K\K]K`K_K\K\K]K]K]K`K_K\K]K]K_K`K`K_K_K^KaKgKmKsKuKwKuKuKuKuKuKuKuKtKsKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKxKyKxKyKyKyKyKxKxKxKxKuKwKyKxKxKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzK{KzKzKxKyK{KzKzK{KzKxKyK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|KbKQKVKTKSKPKNKLKWK[KXKQKHKRKSK‰KØKÑKÐKÐKÏK×KîKõKÌK€K€KK~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K€K~K}K}K}K}K~KKKKKK}K~K€K}KKtKGKCKDKCKEK=KBKDKDKDKCKDKCKCKGKEKDKDKBKBKCKCKBKBKBK@K>KAKAK?K?K?K>K=K:K9K7K7K9KHKOKNKMKKK3K)K)K)K&K%K$K"K#K#K(K0K5K8K=KAKDKGKFKEKaK‹KŠKKuKsKK€KtKsKyKyK~K‚K€K†KŒK‘K–K›K£K¢KKK¥KÊKÎKÎKÌK…K{K…K—K K’KKK•K°KŒK­KÂK´KµK¦K–KŽKsK\KBK(KK K K KKKKKKKKKK K K K K KKKK KK +KK KKKK"K8KAKGKPKZKqK€KK†K‰KK˜KšK›K K¢K§K¹KÀKšKrKwKwKoKgKhK€K‹KK‰K‰KŠKŠe]r(KÖKÉKSKKKKKKKKKK%KIKFK7KKKKKK!K#K%K'K&KK>K-KGKPKHKFK9K?KWKVKUK=K5K2KKKKKK$K+K8KWKBK+K2K8K-KKKKKMKIKFKVK^K_K[KPKFKBKAKIKSK_KbKaK`K\K]K]K\K]K]K]K\K^K`K`K`K`K`K`K`K_K\K\K^KdKkKsKvKvKuKuKuKvKvKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKxKwKuKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKxKxKxKzKzKzKzKxKxKxKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}KjKPKTKSKSKRKNKNKVK[KZKTKIKOKVKlKÎKÔKÏKÐKÐKÑKèKñKãK‰K|K€K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKKKKKKK~K~KKKKKKKTKDKDKCKCK=K?KFKDKDKCKCKDKDKDKDKDKDKDKCKBKBKBKBKBKAKAKBKAK>K?K?K=KK>K=K,KIKOKHKFK8KCKVKUKPK9K4K1K0K(KKKK!K/KEKXKAK,K(K*K&KK KKKZK@KK!K7KLKXK`K]KYKNK1K7KBKLKXK`K`K^K]K]K]K]K]K]K^K_K_K_K_K_K`K`K`K]K\K[K[KZK^KfKmKqKuKwKuKuKuKuKuKuKuKuKuKuKuKuKuKuKvKvKwKxKxKxKxKwKvKuKuKuKuKuKuKuKuKuKuKuKvKyKwKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzKzKxKxKxKzK{KzKzKyKyKyKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|KtKTKRKSKSKSKOKOKTKZK[KXKNKKKXKYK»K×KÏKÐKÐKÎKâKïKðK K{K€K~K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKKKKKKKK~K~KKKKKKKfKDKEKEK?K;K=KCKCKCKCKCKCKCKCKCKCKCKCKDKBKBKBKBKBKBKBKBKAK?K?K?K>K=KK?KK?K?K>K:K:K:K7K5KCKNKMKMKNK:K*K+K)K(K&K$K"K K$K)K-K4K7K=KBKEKEKFKWKKK{KsKqKtK}KKwKsKvK~KKK€K~K|KK‹K”K˜KK¢KK”K¤KçK¹KK‰KKK~K–K”KŽKƒK˜K·K„KŽKÇK§K‘KK‹KKkKTK6K"KK KKKKKKKKKKKKKK +K K KKKK K K K +K +KKKKKÿKÿKKK K KKRKrKpKtKtKrKjKaKpK…KXK#K(KPKxK“K¤K¸KÁKÅK®K¦K—K‰KŠe]r!(K?K#KKKKKKKKKKKK>K@KKFKEKCKDKDKCKDKEKEKEKDKCKDKDKDKCKBKCKDKBKBKBKAK@K@K>K>KK"KKKKK KKK"K"K$KAKDK=K'K'K!K!KKKK K$K!K3K¤KÚK²KpKuKsKsKsKsKsKsKtKnKZKNK\KuKsKsKsKsKsKsKsKuKhKFK@KaKtKsKtKuKNK$K)KDKCK=K?K?K8K4KSKKKDK@K6KKKSKTKMK2K0K-K'K&K&K&KK K!K=KWK2K#K?KTKXKWKOK?KCKZKEK/K'K)K+K1K8K8K0KAKSKKSK\K^K^KWKLKEK@KAKOK[K`K_K`K`K`K_K\K\K\K]K]K]K]K]K]K]K]K]K]K\KZKYKZK^KdKmKvKyKxKvKuKuKtKiKWKPKIKIKBK=K;K5K9K7KBKWKjKvKwKuKuKuKvKyKxKtKwKyKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKzK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K~K}K~KjKPKRKQKRKOKOKLKTK[KXKVKKKOKUKiKËKÔKÒKÓKÐKÏKåKïKèK‘K{K€K€K€KK}K}K}K}K}KKK}K}K}K}K}KKK}K~K€KKKKKKKKKKKKKKKKKK‚KhKCKGKGKGKDK9KDKEKCKCKCKCKDKGKEKCKDKCKCKDKCKDKDKDKDKBKAKAKBKBKAK=K>K>K:K9K8K8K9KHKNKQKQKLK4K,K+K*K)K(K%K$K#K&K*K.K2K:K?KBKGKGKEKIKkKƒKuKtKsKwKzKKyKsK~K†KƒKƒK}KxKzK}K…KŽK•KšK KŸK–K›KæKÃKvKwK‚KƒKxKŽKK‰KxK¤K©KkK|K~KnKxKwKvKrK^KAK(KK +K K KKKKK +KKKKKKKK K K +KK +KKKK K K KK +KKAKdKyKˆK{KgKKKKK7KtKŠKŠK‡K‹KŠKˆKƒKxK•KuK.KKKK KK K#K2K|K‰e]r#(K8KKKKKKKKKKK&KDKDK3KKK%K'K&K&K$K"K"K KJKÔKïK¬KmKuKsKsKsKsKsKsKuKlKGKCKaKvKsKsKsKsKsKsKsKuKdKEKAKfKvKsKsKsKsKCK.KIKDK=K?K?K4K4KSKKKEK@K5KMKTKTKGK/K/K-K'K&K%K%K$K"KKAKYK0K%KBKUKWKXKYKZKXKZKDK5K:K.K,K.K1K7K9KIK_K+KK&K2KGKVK^K_K]KQK7K>K?KDKPK[K`K_K]K\K\K]K]K]K]K]K]K]K]K]K]K]K\K\K\K]K[KXKYK]KdKlKrKvKvKpK]KMKFK?K?K8K6K=K9K4K0K,K:KIKZKoKxKvKvKuKxKxKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K|K{K{K{K~KrKSKRKOKRKOKNKPKWKYKXKVKLKKKXK[K¶K×KÒKÓKÑKÎKßKíKðK«KyK€K€KKK}K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€KxKJKEKEKEKFK:KCKDKCKEKFKDKDKGKEKCKCKCKDKCKDKCKDKCKBKCKCKCKBKBKAK@K@K=KK6K6K9K2K6K9K4K-K0K/K7K9KGKPKhKwKtKuKxKvKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K~K|KzKzKzK|KyKXKQKOKRKOKNKPKQKYK\KXKOKHKWKSKšKÚKÒKÓKÑKÎKÙKêKðKÆK}K€K€KKK}K~K€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK€KYKBKDKCKGK@K=KGKCKFKGKDKDKGKFK@K=KGKCKCKDKCKDKBKAKCKDKDKCKAKBKBK@K=K=KKBKEKGKHKJKwKKoKqKtKwKyK|KwK{K‚K„K€KK{K{KzKyK}K…KŽK”KœK K—K”KÞKâK€KwK€KqKiK‚KˆK„KpK KŠK^KmK[K_KhKjKkK`KKK-KK K K K K K K KK KKKKKK K K K KK K K K K K K K K K K K KKK K'KRKˆK¢K„KDK8KbKzK€K†KŠK“KqK`KiK`KKŸK›K£K¯K®KwKtKKŠe]r%(K#KKKKKKKKKKK0KEKIK-KK KKKKKK#K(K"KyKåKÍK‚KrKtKsKsKsKsKtKsKvK`KBKEKkKuKsKsKsKsKsKsKsKuK[K?KGKoKuKsKsKtKnKPKCKEK@K>K?K>K0K;KQKHKCK>K9KPKRKTKCK3K4K.K&K&K&K$K"K$K!KGKUK*K(KEKQKUKXKYK[KXKXKBK-K1KFKVKRK5K+K)KGK\K=K5K?KAK?K:K2K/K1KFKSKYK^K\KVKOKFK=K?KEKSK^K]K\K[K[K]K]K]K]K\K[K[K[K[K[K[K[K[K[K[K[KZKYKZKZKSKHK@K;KK=K;K9K9K8K7KEKNKOKPKOK;K,K-K+K)K&K&K%K#K#K'K,K2K8K:K?KDKGKGKJKvKƒKpKpKrKuKvK{K{KwK}K…K„K|K{K{KyKyKzK}K‡KŽK–KœKžKŒK®K÷K¿KsK|KrKdKoK…KƒKuKuKqKOKgKeK^KaKfKaK\KNK1KK KK K +K +K K K KK +KKKKKK K K KK KKK K K K K K K +K K K K K +KKKKOK‰K¡K†KmKoKtKiKlKƒK–K¦K³K¼K¿KÂK½K²K«K°K£K—K„Kˆe]r&(K%KKKKKKKKKKK=KnK‡K=KKKK KKK +KKK"K€K¹KKuKuKsKsKsKsKsKsKsKtKZKCKJKpKtKsKsKsKsKsKsKsKtKTK?KLKrKtKtKsKuKkKNK@KFK?K>K>K>K.K@KOKGKDK=K>KTKQKTKBK4K8K0K&K&K&K%K"K$K"KIKTK*K+KIKTKWKWKYKZKXKWK>K(KKK'K4K0K+K7KPKYK>K0K6K=K>K=K?K@K9KDKTKK@KHKUK[K^K^K\K\K\K\KZK[K[K[K[K[K[K[K[K[K[K[K[K[K\K\KYKVKPKDK?K2K.K1K7K6K5K5K:K3K0K0K0K7K)K.KHKdKwK|KyKwKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKyKzKzKzKzKzKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K{KzKzKzKzKzKzK{K~K}K{K|K}K{K{K}K}K}K}K}K{K}KhKQKSKSKRKQKNK@KVK\KZKSKJKPKXKfKÆKÔKÒKÐKÐKÏKäKïKêK—K|K€KKKKKKKKKK}KKKKKKKKKKKKKKKKKKKKKKKKKKKK‚K|KMKEKGKFKFK=K@KEKEKGKGKGKGKFKDKDKDKDKDKDKDKDKDKDKDKCKBKBKBKBKBK?K>K=KKMKPKQKQKEK.K,K+K*K*K'K%K$K$K&K+K2K7K:K?KDKFKGKHK`KKrKpKrKsKsKwK}K{KzK„K…K|K{KzK{K|K{KzK€K‡KK”KK˜K”KÝKöK–KoKoKhKcK{KƒK|KlKWKJKXKmKiKaK^KWKUKPK3KK +K K K K +K K K K KK KKKKK K K KK KKK +K K +K +K +K +K +K +K +K +K +K K K KKKKOK†K“KƒKyKkK]KiK‚K¥K¸KºK®K²K¶K¸K¸K¹K½K­K‚K†e]r'(K$KKKKKKKKK KKkK½K¾KKKSKRKSK@K7K9K0K(K(K%K"K K$K$KOKRK)K+KJKUKWKXKWKWKXKXK=K+K0K%KKKKK0KSKXK=K9K7K,K2K:K=K=K8KLK^K/KK2K1KAKRKYK\K\KXKOK4K3KAKJKTK]K`K\KZKZK[K]K\KZK[K[K[K[K[K[K[K[K[K[KZK[KYKYK[KVKPKK>K5K1K;K9KGKQKPKPKNK6K+K*K*K(K&K&K$K#K%K)K.K2K:KKZKvKsKtKtKtKtKsKsKtKpKMK?KVKuKsKsKsKtKtKtKsKuKpKMK?KTKvKsKuKuKuKcKEK@KEK>K>KK;KKAKKKTK]K]K]K\KZKZK[K[K[K[K[K[K[K[KZKZKZK[KYKXKYKZKXKYKWKIK1KK KKKK +K +KK K K KKKKKKKxKzKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKyKxKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK{K|K}K}KzKzKzKzKzK{K|K}K}K|K|K|K}K}K}K}K}K}K}K}K~KwKUKRKRKQKPKOK.KDK\KZKUKOKIKVKSK”K×KÎKÐKÐKÏKÔKêKóKËK|K€K€KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK‚KmKFKHKFKBK@K;KDKGKFKFKFKFKFKGKFKEKEKEKGKEKCKDKDKDKDKDKDKDKBKAKCKBK?K>K=K9K8K:K7K?KQKQKPKRKBK.K,K,K)K&K%K$K$K#K'K*K/K6K:K@KBKEKGKMK|KwKpKpKqKsKuKxK|K{K}K†KKxK{KwK|K‚K|K{KKK‹K“K›K—K‘KÙKûK§KaKjKgKeKzK}KvKcKSKHKZKjKkKeK\KSKUK>KK K K K K K K +K K K K +K K KK K K K K K K K K +K K +K K +K +K K +K K K K K K K K K K K K K4KqK‚KwKqKkKmKsK{K†KK™K K K§K§K‡KOKwe]r)(KK K"K"K%K$KKKKK:KÌKòK­KK#K%KKKKKKKK$KGK@KaKvKsKvKuKvKtKsKsKuKmKJK?K\KwKsKsKsKtKvKtKsKvKmKIK@K[KvKsKvKuKtK_KEKAKEK>K>KK-K$K&K&K#KKK%KSKLK'K/KKKYKDK)KHKZKWKWK:K'K!K!K(K.K2K5K1KHKYK7K;KWKhKsKXK.K%K'KCK\KAKBKwK{KzKqK_KGK:K8KHKWKYKYKYKSKJKAKKAKHKFKGKFKFKFKGKDKCKFKGKGKEKCKDKCKDKDKDKDKDKBKAKBKAK?K>K=K;K:K8K6K8KLKQKPKQKLK3K-K-K+K)K$K%K%K!K&K*K0K6K:K=K@KEKFKHKuKyKpKpKpKsKuKuK{KK~K‚K‚KvKyKwKxK‚KƒKK~KK…KŒK”K›K˜KÈKòKìKsKOKjKYKoK{KoKfKXKJKRKbKgKiKbKZKUKBKK +K K K K K K KK +K K +K +K +K K K K +K +K +K +K +K +K +K +K +K +K K K KKKKKKKKKKKK K +KKK:KPK^KeKmKqKrKuKzK†K’K•K—KKjK?Kje]r*(K)K)K(K(K#KKKKKKQKÛKéK‚KK&K$K"KKKKKKKGKBKCKjKuKsKvKuKtKuKuKsKuKiKEKAKbKxKrKtKuKuKuKuKtKuKhKEK@K`KvKsKtKsKsK^KBKBKDKK:KKKMKFKAKCKMKPKSKOK?K>KK>KK-K,K+K*K&K&K$K#K%K)K.K4K8K=K@KDKGKGKqK}KqKqKoKsKtKvKxK~KK‚KKwKsKuKwKK†K„KK~KK…K‹K“K“K©KèKüK·KCK`KXKiKtKnKcKYKLKJKZKaKfKgK`KYKHKK K K K K +K K KKK K K +K +K +KKK K +K +K +K K K K K K K K K KKKKKKKKKKKK KK KK KK)K8KHKZKfKkKtK{K„KŽK‘K€K\K:KSe]r+(K)K*K*K#KKK KK KKaKÑK¿KPKK'K$K#K KK"KK"KjKVK>KHKpKtKtKvKtKsKuKuKsKuKbKAKBKhKuKsKtKvKuKuKuKuKvKeKDK?KeKvKsKsKtKtKZK@KCKCKK=K:K:K7K=KOKQKQKNKJK1K-K/K,K'K'K$K#K$K(K+K/K5KKCKCKKOKIKEKAKDKOKQKQKLK>K?K9K(K%K%K"K!K!KK-KZKCK%K4KOKUKXKYKXKXKYKUK7K)K%K*K.K0K4K3K5KRKXK6K8K?K9K4K4K0K,K,KIK[K;KOKqKUKKKFKAKK?K8K'K%K%K"K!K"KK1KZKAK&K6KPKUKWKWKXKWKXKTK7K)K%K*K.K0K4K6K7KRKXK5K8K>KKDKCKDKGKGKDKCKDKDKDKDKDKDKCKBKAK?K=K=K;K:K:K8K@KPKQKPKRKGK0K-K.K+K'K&K&K%K%K'K)K0K4K8K?KDKEK^KKtKoKmKoKtKvKyK|K{KK‡KzKtKsKpKpKsKxKKˆK‹K‹K‰KŠK‹K}KK×KíKõKtK>KBK K(K8KAKHKIKGKSK[KcKfKgKSKAKKK K K K K K K KKKKKK +K +K K +K K K +K K K K K K K K +KKKKKKKK K +KKKKKKKKKK KK K K KKKKK%K1K?KMKEe]r.(K0K+K(K$K K K!K"K#K,K@KCK5KK!K$K$K"K K"K"KVKxKeKCKAK]KyKuKuKuKuKuKuKuKtKrKOK?KPKvKvKuKuKuKuKuKuKuKuKRKK>K6K'K%K$K$K!K!KK4K\KAK'K:KSKUKVKXKXKWKVKRK8K(K%K)K/K1K4K6K9KQKWK2K7K@KK;K;KLKXKAK2K:KJKbKiKNK5KDKCK@K[KNKBKpK{KyKyK{KtKaKJKHKKKMKVKZKYKXKSKKKBK=K>KGKQKWKZKYKWKWKWKWKXKXKXKXKXKXKXKXKXKWKXKXKXKWKTKUKXKZKTKGK7K"K KPK‚KwKxKxKzKzKzKzKzKzKzKxKxKxKxKxKxKxKxKxKxKzK{KzKzK{KyKxKzK{KzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K€KbKPKSKPKPKTKBK/KWKXKYKRKHKKKTK^KÁK×KÒKÓKÔKÏKÞKêKîK«K}K„KƒKƒKƒK€KKKKKKKKKKKKKKKKKKKKKKƒKƒKƒK‚K‚KƒK€KK‚K‚K‚K‚K‚K„KoKGKGKGKGKEK?KCKGKGKGKGKFKFKGKEKBKGKGKGKGKFKDKCKCKDKDKDKDKDKCKBKBKBK@K>K=KKUKxKuKuKuKuKuKuKuKvKsKNKKAKQKPKQKHK=K=K4K&K%K%K#KK KK5K[K>K'K;KTKVKWKXKWKVKWKQK8K)K&K*K/K1K3K6K9KSKVK4K7K>KK7K@K1K6K@KDK?KGKbKcKYKPK;K8KJKdKuK|K{KzKzK^KQK)K#K6KIKWKYKYKUKPKIK?K8K:KFKRKWKZKYKXKVKWKWKWKWKWKWKWKWKXKWKWKXKWKUKUKUKTKUKVKXKVKFKTKpKwKzKzK{KyKyKyKzKzKzKyKyKxKyKyKxKyKyKyKyKzKzKzKzKzKzKyKzKzKzKzKzKzKzKzKzK{K{KzKzKzKzKzK{K|K|K|K|K|K|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKiKPKSKQKPKRKLK,KSKYKYKTKKKGKWKRK¨K×KÐKÒKÓKÑKÙKéKðKÄK~K‚KƒK‚KK€KKKKKKKKKKKKKKKKK€KK€KK‚K‚KKK‚K‚K‚KKK‚K‚K‚K‚K‚K‚KKSKEKHKIKIK@KBKGKFKGKGKFKFKFKGKGKFKGKFKFKFKEKEKDKDKDKDKDKDKCKBKAKBK@K>K=K;K8K9K8KEKQKPKQKSKCK.K-K,K*K(K'K&K&K%K(K*K0K6K9K=KAKTKKyKrKoKnKqKwKzK}K}K~K…KƒKxKsKnKoKqKnKsKyK~K†K‹KŒK‹K„KyK®KÙKïK¦KKK KKK(K4K6KCKOKYK[KaKdKQKLKKK +KKK K +K K +K +K K +K K K K K K K K +K K K +K K K K K K KKKK K K K KKKKKKKKKKKKKKKKK +K K KKK#K-K/KAe]r0(K,K,K(K KKKKK!K3K?K@K)KK"KK K#K KK(KkKzKXK>KBKlKvKuKuKuKuKuKuKuKwKjKCKK?K>KKRKHKCK;K6KOKPKRKHKK?K>KLKZK9KEKuKfKTK=K2K1K1KKGKTKYKXKVKUKWKWKUKUKUKWKXKXKXKXKWKUKVKVKVKUKUKTKQKWKVKSK[KbKnKvK{KzKyKxKzKzK{KzKxKzK{KxKyK{KzKzKzKzKzKzKzKzK{KzKzKzKzKzKzKzKzKzK}K}KzKzKzKzKzK}K~K~K~K~K~K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}KKtKRKSKRKOKPKRK0KHK[KYKWKNKEKUKRKˆKÕKÎKÓKÓKÓKÕKèKíKÝKŠK€KƒKKKKKKKKKKKKKKKKKKKƒK‚KKKƒK‚K‚KK€K‚K‚K‚K‚KƒK‚K‚K‚K‚K‚K‚K…KcKDKIKHKDK;K?KGKFKFKFKGKFKGKIKHKFKGKFKFKFKGKFKCKCKCKCKDKDKCKAKCKAK>K?K>K;K2K4K:KK&K!K$K%KKKKK*KnKvKOK>KGKrKuKuKuKuKuKuKuKuKxKdK@KAKbKxKuKuKuKuKuKuKuKvKmKGK=KYKxKuKuKuKwKcKDK=KCKK=K;K:K8K8KIKQKQKQKQK>K.K-K+K*K)K&K&K%K&K&K-K2K6K=KAKLK}K{KtKpKpKnKmKxK}K~KK‚KƒKKxKtKpKpKnKnKtKwKxK|KK‡K†K|K…KÈK»KhKSKKKKKKKKKKKKK/K5K/K +KKK K +K +K +K +K +K +K +K +K +K +K +K +K K K KK K K K K K K KK K +K K +K +KKKKKKKKKK K K KKKKKKKKKKKK KKKKe]r2(KK#K%KKKKKKKKMKuKvKuKuKuKuKuKuKuKyK]K@KCKjKxKuKuKuKuKuKuKuKwKgKCK>K]KxKuKuKuKwK`K@K>KDK;KKRKPKRKCKKHKSKVKVKVKUKUKUKUKUKUKVKVKUKUKUKUKUKVKTKRKRKSKSKRKQKQKRKXKbKlKvKzKzKyKyKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzKzK|K~K{KzK}K}KzKzKzK|K~K}K}KzKzKzK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K`KPKQKQKPKSKAK0KVKWKXKTKKKKKTK\K¾KÔKÏKÏKÐKÏKÝKìKñK¶K}K„KƒKƒKƒK‚K€KKKKKKKKKKKK‚KƒKK€KƒK‚K‚K‚K‚KƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KKUKGKHKGKHK?K=KGKFKFKGKGKFKFKFKGKGKFKFKFKGKGKGKGKGKEKCKDKDKDKCKBK@K>K?K?K=K=K;K9KAKQKQKPKQKIK0K-K+K+K)K&K%K&K%K%K+K0K4KKAK2KKKKK K#K!KKBKxKkKBK@KUKxKuKuKuKuKuKuKuKuKwKVK=KEKpKwKuKuKuKuKuKuKuKxKbK>K?KeKxKuKuKuKwK\K>K?KCKKHKUKWKWKWKUKUKVKUKUKVKUKVKVKVKVKTKRKSKSKSKRKSKSKRKQKPKQKVKbKmKuK|K}KyKxKzKzKzKzKzKzKzKzKzKzKzKzKzK{K}K|KzK|K}K}K}K}K|KzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKiKTKQKOKQKQKKK,KPKWKXKVKLKHKVKQK KÕKÎKÐKÐKÏK×KêKñKÒKƒKƒKƒK‚KƒK‚K‚KKKKKK‚KK€K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„KdKFKJKHKHKDK;KEKGKGKGKGKFKHKHKFKGKGKFKGKGKGKFKFKGKEKCKDKDKDKDKCKBKAK?K?K=K:K:K9K:KLKRKRKRKOK8K.K-K-K+K(K(K'K%K(K+K+K3K9K=KAKpKKuKrKpKoKmKrKxK{K~KK‚K‚KK{KvKoKnKnKnKpKqKtKvKyK€KK€K‘KkKaK[K9KKKKKKKKKKKKKKKKKK +K +KKKK K KKK K K KKKKKKK K K K K K K +KKKKKKKKK K +K K K K K K K K +K +K +K +KK KKKKKKK K K K e]r4(K%KKKKKKKK)K@K@K,KK K"K!KK!K(K"KVK|KcKBK@K^KxKuKuKuKuKuKuKuKuKuKPKKAK?KJKSKTKDK@K9K/K:KRKjKtK|KzK4KHKWK$KK!K7KJKSKTKTKSKQKIK?K4K5K>KHKTKWKWKUKUKUKUKUKUKUKUKUKTKRKSKRKRKSKSKRKSKSKSKSKQKPKQKWK_KlKvK{K}K{KzKzK{KzKzKzKzKzKzKzKzK{K}K|KzK|K~K}K}K~K|K{K}K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~K~K}K}K}K~K~K}K~KKrKSKQKPKQKPKQK.KEKXKWKUKNKHKUKPKƒKÔKÎKÐKÐKÐKÑKçKîKäK‘K€KƒKƒKƒKƒKƒK‚K€K€KKK‚KK€KƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„KuKJKIKIKHKFK=KAKGKGKGKGKFKHKHKFKGKFKGKFKFKGKGKFKGKEKCKDKDKDKDKDKBKBK?K?K>K:K:K9K9KEKQKRKRKQKDK/K.K.K+K)K)K'K%K%K'K+K2K5K:K>KoK€KvKsKqKpKmKrKyK{K~KK€K}KK|KzKrKnKnKnKpKpKpKqKuKyKzKsKfKaK^KUKGK KKKKK KKKKKKKKKKKK +K +KKKKKKKKKKKKKKKKKKKKKK +K KK K KKKKKK K +KKK +K KKKK K +K K +K K K K K KKKK K +K K +e]r5(K!KKKKKK!KK+KBK=K)KKKK#KKKK&K_K{K[K=K@KdKxKuKuKuKuKuKuKuKvKqKKK>KPKwKuKuKuKuKuKuKuKuKxKYKKJKwKyKxKxKxKxKxKzKnKYKOKDKyKzKpK]KGK2K.K3KIKVKBKRKsK]KEK-K/KAK]KIK KJKWK7KK +KKK-K=KMKSKUKSKPK:K>K@K8K7K?KIKTKWKWKVKUKUKSKRKRKRKRKRKRKRKRKSKRKRKSKRKSKRKQKQKPKOKQKTK_KmKwK|K~K|KzKzKzKzKzKzKzKzKzKzKzKzK|K~K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKK}K}K}KKK}K}K~KzKUKQKRKQKOKQK4K;KVKVKWKPKGKNKSKjKÊKÑKÏKÐKÐKÎKàKêKìK¥K~KƒKƒKƒKƒK‚K‚KƒKKKKKK€K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒK‚KUKGKIKGKGK@K=KGKGKIKGKGKFKFKFKHKHKGKFKFKGKGKFKGKEKCKDKDKDKDKDKBKAK?K?K@KKTKyKvKwKuKvKwKvKuKuKvKSKKQKYK@KLKwKyKxKxKxKxKxKzKpK[KOKCKtKwKzK}K{KlKRK=KHKVKBKEKdKnKqKVK3K+K+K%K$KMKWKBKKK +K +K KK#K4KAKMKQKMKQKQKPKIK=K6K:KCKMKTKWKVKSKRKRKRKRKRKRKRKSKRKSKRKRKRKRKQKQKQKRKSKQKOKNKPKTK^KkKuK{K}K{K{K{KzKzK{K|K{K|K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKK~K~K~KKK~K~K~K€K]KPKSKQKPKTKBK0KUKXKYKRKHKJKVKYK¶KÔKÏKÐKÐKÎKÙKêKïK½KK…KƒKƒKƒK‚K‚KƒKKK€KK€KK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K…KfKGKIKHKHKEK;KGKGKIKGKFKGKGKGKFK@KAKHKGKFKGKFKGKEKCKDKDKDKDKDKBKBK@K@K?K=K;K:K:K8KGKSKPKQKRK?K-K/K,K+K(K&K%K%K&K'K+K1K6K8KfKKxKvKsKrKnKrKwKxK}KK€K}K~K|K{KtKrKoKoKkKkKjKpKuKzKxKoKeK]KSKMKFK0K@K1K2KIKLKIKKKDK9K0K(KKKKKK K +K +K +K +K +K K K K K K K K KKKKK K K K KKKKK K KKKKKKKKKKKKKKKKKKKKKKKKKKK K +K Ke]r7(KKKKK%KKKK8KAK:K KKKK#K$K%K K&KkKvKNK>KIKrKvKuKuKuKuKwKyKvKwKhKCK?K\KyKxKyKuKvKyKwKuKuKuKNK>KMKuKuKuKuKyKnKIK;KDK?KKXKQK=K:K:K=K=K=K;K=K>KOKZKCKMKwKyKxKxKxKxKxKzKrK^KPKCKuKyKxKwKxKzK{KxK_KQKCK1K8KFKVK]KMK=KGKMKAKQKVKDK#K KKKKKK KK%K>KIKLKRKTKQKNKMKEK?K8KKBKHKIKGKFKHKHKFKFKCKCKGKGKFKFKGKGKEKCKCKCKDKDKDKBKAKBKAK?K>K=K;K9K8K@KQKQKPKQKKK2K.K/K*K)K'K%K&K%K'K*K/K6K7KaKKxKvKsKqKpKsKwKwK{KKK|K}K~KzKtKpKoKqKoKnKkKkKoKvKvKlKbK[KQKIKBK1K?K&K:KJKPKRKKKDK@K@KBK9K,K6KKKKK K K +K +K +K +K +K +K K K KKKKK K K K K K K +K KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKe]r8(K#KK%K$KKKK#K>K=K4KKKKK#K%K%K!K.KrKtKFK=KOKwKxKwKwKwKwKxKxKuKxKaKAKAKcKzKvKwKwKxKxKxKwKwKsKIKKK.K6KQKFKBK>K4KJKPKRKJK:K;K6K)K%K#K"K KKK&KRKOK8K6K7K3KKKKK2KYKGK4K#K&K(K+K0K4K3K>KXKOK>K:K:K:K;K=K=K;K=KOKZKCKMKwKyKxKxKxKxKxKzKrK]KPKDKtKyKxKxKxKxKwKyKfKTKCK?KFK6K5K?KGKCKGK]KfK[KTKFK5K)KKK KKKKKK0KQK?K,K?KPKUKTKQKQKNKEK;K5K6KBKMKSKUKTKRKRKRKRKSKRKRKRKQKQKRKQKQKQKPKPKPKQKPKOKPKOKLKMKPKZKhKsKzKK~K|K|K}K|K{K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKKK~K}K~KKKKKKKKKKKKKKKKKrKQKSKQKPKPKRK-KFKWKWKUKNKFKTKPK~KÓKÏKÏKÐKÐKÎKãKíKçK–KKƒKƒKƒK‚K‚K‚K‚KKK€K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„KƒK‚KXKFKIKIKKKDK>KHKGKGKFKHKHKFKGKIKHKHKGKFKGKGKGKFKEKFKEKDKDKDKCKCKBKAK?K>K>K=KK/KKKKK#K&K'K$K5KtKnKAK=KXKyKxKyKyKyKyKxKxKuKxK[K@KBKhKyKuKvKxKyKxKxKxKyKmKEK=KVKxKuKuKtKzKeKBK:KDK=KK,K9KOKFKCKK:K:K9K;K=KKOKZKCKLKwKyKxKxKxKxKxKzKrK\KQKDKtKyKxKxKxKxKxKzKhKUKBKOK}KnKXKBK4K1K8KAKOKWKUKDKFKJK6K-K%KKK KKK'KXKEKKK#K6KGKQKSKRKPKOKIKAK7K.K:KEKLKSKUKSKRKRKRKRKRKQKQKSKRKPKPKQKPKPKQKOKMKMKMKNKNKMKLKNKQKYKfKrKzK€KK{KzK|K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K}K~KKKKKK€KK}K~K€KKKKKKKKKKKKKKK€K{KVKRKQKPKPKTK6K8KWKWKVKNKFKOKSKdKÆKÐKÏKÐKÐKÌKÝKìKðK®K~K„KƒKƒK‚K‚K‚K‚KƒK€KK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„K„K…KhKGKIKIKIK@K>KGKJKGKFKHKHKFKGKIKIKIKGKFKGKGKGKGKGKGKFKDKDKDKDKDKBKAK?K?K?K>K6K9K9KCKRKSKTKTKDK.K.K.K+K)K)K&K%K%K%K,K1K1KXK…KyK{KwKrKpKsKwKwK{K€KK|KzKzKzKtKpKoKqKrKpKpKqKrKrKqKhK`KVKJK@K:K?K=K4KKK[KUKNKJK;K3K4K;KBKAK9K:K'K KKK K K +K +K +K +K +K +K +K K K K +K +K +K KKKKKKKK +K K K K K K K +KK K K KKKKKKKKKKKKKKKK KK KKe]r:(KCK=KKKKKK-KCK>K*KK!KKK"K$K%K#KK^KyKuKvKuKvKyKwKuKvKvKRK=KCKmKwKwKxKxKxKxKxKxKyKjKAK=K[K{KwKxKwKyKcK?K:KCK=KK-K>KNKEKCKKWKNKKQKVKCKMKlK`KMK5K*K'K KK K"KSKJK*KK +KKK+KK/KUKVKUKRKFKHKUKUK±KÓKÏKÐKÐKÍKÓKéKîKÇKK…KƒK‚K‚K‚K‚K‚K‚KK~K~KK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚KƒK„KƒK‚K‚K‚K‚K‚K‚K‚K‚K„K„K„KƒK„KyKKKIKIKGKEKCKEKKKGKFKGKGKHKHKIKGKGKGKFKFKGKGKFKFKGKFKCKCKDKDKDKCKCKAK@K?K=K1K7K;K=KPKQKRKTKNK6K-K-K*K*K'K(K(K&K%K(K/K/KUK„K{KzKyKtKsKsKtKvK{K€KƒK‚K~KxKvKrKqKpKoKrKrKmKlKpKtKqKfK`KUKIK9K9KDK;KGKYKTKNKTKAK:K=K>K@K?KKcKzKxKxKxKxK]K>K=KCK=K=KK*KAKNKEKCK;K5KKKMKOKEK;K:K3K'K%K!K!K KKK/KUKHK:K8K7K0KKKKK8KYKDK/K#K&K(K/K1K4K2K?KXKMK;K9K:K=KKOKxKxKxKxKxKxKxKxKxKyK\K>K@KjK{KxKxKxKwKYK>K>KCK>K?K=KK7K4K-K"KK KKKKKK K K KKKKKKKKKK KKKKKKKKKKKKKKKKK +K K K KKKKKKKKKKKKKKe]r=(KHKEKBKEK?K&K!K:KBK8K!KKKKKK#K%K!KSK{KJK>KHKtKyKxKxKxKxKxKxKxKzKkKAK>KVKyKxKxKxKxKxKxKxKxKyKWK=KCKnKyKxKxKyKvKSK=K?KAK=K>K=K:K)KHKKKDKBK6K:KLKMKNKBK(KIKIKCK@KCK9K,K:KAK4K KKKKKK K"K"KZKvKDK=KRKyKxKxKxKxKxKxKxKxKzKeK@K>K\K{KxKxKxKxKxKxKxKyKzKQK>KGKqKxKxKxKyKrKOK;KAK>K;KKSKDK8K8K8K1K(K)K.K/KJKSK?K7K6K7K6K6K5K5K.K;K[KKK:K9K:K9K9K:K9K:K=KPKWKCKSKyKyKxKyKzKzKzK|KqK[KQKKKvK{KzKzKzKzKzK}KkKUKMKOK{KzKzKzKzKyK~KTKK/KYKJK*KK KK,K9K=K>KBKHKWKUKNK;KEK?K2K-K$KKK +KK.KGKMKQK2KK)K+K;KJKNKPKPKPKMKEK=K3K/K:KFKNKPKOKQKPKQKNKMKMKMKMKMKNKMKMKMKNKSKSKSKPKPKPKQKQKRKQKPKRKVK`KoK{K~KK~KK€KK€KK€K€KKKKKKKKKKKKKKKKKKKKKKKKKKKK€KKZKOKQKPKPKTK?K0KTKUKVKQKIKJKUKUK°KÕKÐKÏKÑKÍKÖKìKíKÎK…K…K…KƒK‚KƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„K…K„K„K„K„K„K„K„K‚KƒK„K„K…K…K…K„K„K„K„KƒKcKOKQKPKSKHK=KIKHKIKHKFKGKIKIKIKGKGKFKFKFKFKFKGKGKGKGKGKEKCKDKDKDKCKBK@K>K=KK=K>K,KKKKKKK K$K#K`KnK?KKKMKLKLK>K:K8K1K*K)K)K'K&K&K"KK4K4K?KLKQKOKNKLK9K3K9K5K5K;KGKNKQKQKNKMKMKNKPKOKMKOKOKNKQKRKSKSKNKMKPKQKPKQKSKSKNKOKNKOKWKaKqKzKK€KK~KK~K~KKKKKKKKKKKKKKKKKKKKKKKKKKKKKƒKeKPKQKQKPKOKGK,KQKVKUKRKLKGKUKOK”K×KÎKÐKÓKÏKÑKçKíKãK‘K‚K…K„KƒKƒK‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K‚K„KƒK‚KƒK„K„K„K„K„K„K„K„K„K„K„K„K„K„K…K…K…K„K„K„K„K†KqKPKQKPKQKOKK=KK?KAK=K%KKKKKKKK!K&KgKcK;K=K_K|KxKxKxKxKxKxKxKxK{KZK>KAKjKzKxKxKxKxKxKxKxKzKsKGK;KOKzKxKxKxKzKoKLK8K@K=K=KKSKYKEKSKyKyKxKyKzKzKzK|KsKYKTKKKuK{KzKzKzKzKzK|KlKTKMKMKwK{KzKzKzKyKKLKÿK*KYKLK/KKKKKKKKK K1KLKRK=K?KWKcKaKFK1K4K3K/K)K(KDKVKEKCKeKgKjKnK\KCK7K6KAKJKOKIKIKLKIKAK;K5K6KKHKIKIKIKIKGKGKGKGKGKHKEKCKDKDKCKBKAK>KK[K{KyKxKxKzKhKCK8KCK=K=KK/K2KMKGKEK?K2KDKMKKKIK;K9K6K#KKKKK K K K?KUKK>KMK[K\KQKQKLK:K8KJK[KgKtKrKuK{KzKpKXKIKEK=K@KMKPKNKKKKKHKAK9K4K5K;KIKNKSKWKUKTKVKUKSKTKTKSKSKRKRKSKSKSKRKSKRKRKSKSKSKRKQKQKPKOKTKaKlKzKK‚KKK~KKKKKKKKKKKKKKKKKKKKKK‚KKYKOKNKMKMKOK>K;KWKUKUKPKGKIKUKTK±KÚKÎKÎKÏKÏKÒKèKîK×K‡K„K…K„K…K„KƒKƒKƒK„K„KƒKƒKƒK„K…K„K„K„K„K…K…K…K…K…K…K„K„K„K„K…K…K…K…K…K…K…K…K…K…K…K„KˆKrKOKQKQKPKMKAKDKJKIKHKIKIKIKIKIKIKHKIKHKHKHKIKHKGKGKGKGKGKGKFKDKDKDKCKBK@K=KKAK3K K K!K!K!K!KK7KtKFKKK=KEKVKYKQKMK=K5K-K1K?KVKkKvKzKvK|K|KRKNK,KK*K0KCKLKOKLKJKHKEK?K8K-K2KAKQKXKWKVKVKUKRKSKRKRKOKQKSKRKRKRKRKRKRKRKRKRKQKPKQKQKQKPKNKMKUK`KmKxKK‚KKKKKKKKKKKKKKKKKKKKKKK„K_KMKNKMKNKMKNKSKTKVKVKRKHKEKTKPK’KÝK×KÕKÒKÐKÒKäKêKçK”K}KƒK…K…K…K„K„K„K„K„K„K„K„K„K„K„K„K„K„K…K…K…K…K…K…K„K„K„K„K…K…K…K…K…K…K…K…K…K„K…K„K†K€KXKPKQKPKDKAKCKLKKKHKIKIKIKIKIKHKIKHKHKHKHKIKHKGKGKGKGKGKGKGKGKFKCKDK@K?K>K;K5K9K;KEKTKRKRKTKIK2K/K+K+K)K&K&K$K#K.KK‹K„K„K„K„KKzKzK{K~KK€K~KuKrKwKvKuKqKqKnKjKjKkKlKfK\KSKCKDKXKLKNK\K`KdKeKeKcKaK`K_K`K_K\K\K[KZKVKTKTKVKYKYKSKOKKKTKOK@K?K@KDKBK>K;K:K8K5K6K8K3K-K&K"KKKKKKK1K2K)K"KKKKKKKKKKKK!K%K'K*K,K1K>KGKAK`KÙe]rD(KHKIKHKGKGKHKHKHKDKAK@K7K!KK K K KK7KkKBKKhK|KxKxKxKyK_K?KK4K5K:K;KOKSKRKTKSK9K-K,K*K)K&K&K#K K,KK‹K„K…K‡K‡KƒK~K|K{K|K}KK|KrKmKqKuKvKuKuKsKoKnKlKiKeKZKOKAKIKSKIKXKaKdKdKeKeKcKaKaK`K`K_K^K\KZKYKWKWKXK[K[KXKQKOKRKVKLKDKFKEKHKGKDKAK>K>K>K?KAK7K3K.K.K-K,K+K,K'K#K,K?KK@KDKKKSK{K´Kée]rE(KIKHKFKFKFKFKGKIKIKDK@K@K6K KKKK!K)KK;K]K|KyK{KzKzK{KzKxKwK|KXKK;K@K;K;K=KKIKNKMK?KMKUKRKCK5K*K&K,K9KKKiKYKOK?KTK‚K‚KzKgKNK:K3K;KFKMKIKEKJKHKCK=K6K3K;KDKNKWKXKVKRKRKRKRKSKSKRKRKSKRKRKRKSKRKPKPKPKQKPKNKRKQKQKPKMKMKSK]KjKwKKƒKK€KKKK€KKKK€K‚KƒKƒKƒKƒK‚K„KvKRKQKOKMKMKNKRKUKUKTKRKOKGKKKRKPKQK[KbKuK–K»KÙKçKäKäKàKÎK»K¨K—K‡K‚KK‚K„K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K…K„K…KˆK†K„K…K†KsKRKQKOKRKOKAKFKKKHKIKHKIKHKHKIKHKIKIKIKIKIKHKFKFKGKGKGKGKGKGKFKCKBKAK@K=K=K:K:K:K8KGKSKRKSKUKFK.K,K)K)K&K&K%K"K(K|K‹KƒK‡K‰KˆK‡KƒKK~K}K|K}K{KrKkKiKnKqKtKvKvKuKpKlKiKcKZKNK@KPKLKQK_KdKeKdKeKeKcKaKbKaK_K`K`K\KYKWKXKZK[K]K[KWKRKTKZKUKMKLKKKKKKKIKHKCKBKCKFKFKCK?KKAK:K#KK!K)K:KEK=KhK}KwKxKyKzKxKxKxKyKzKWK=K?KiK{KyKzKzKzKzKzKxKxKxKJK7KHKxK{KyKxKzKvKUK;K>K@KK:K:KKEKJKHKJKAK;K=K5K#K!KKKKKK!KOKJK9K8K8K1KKKKK"KTKLK9K%K#K&K*K.K/K0K0KHKVKGK8K7K8K7K7K7K8K:K>KSKWKDKSKzK{KzKzKzKzKzK}KuKWKQKHKsK{KzKzK|K~K|KuKbKUKRKIK>K8K8K8K?KNKjKSKKKRKQKEKKKKK KK-K5K$KK:KTKMK@K KK)K-K-K1K5K4K3KKIKMKPKJKBKDKIKKKJKGKGKGKHKNKOKbK¯KÕKäKïKòKêKíKñKìe]rH(KGKHKIKIKIKHKEKFKEKDKDKGKDK@KAK7K"K K-K8K>K;KJKrK|K~K~K|KzKyKyKyKzKPK=KEKqK|KzKzKzKzKzKzKzK{KuKFK9KJKxK{KzKzK}KtKOK8K?K?KKFKHKHKJK?K9K:K3K%K#K KKKKK$KQKJK8K7K8K1KKKKK$KVKLK8K&K"K%K*K.K/K1K2KJKWKDK:K6K8K6K9K7K8K:K;KRKWKDKVKzK{KzK{K}K|KzK}KtKWKRKIKsK~K}K|KrKbKTKDKAKSKSKIK@K9K;K=K=K:KKBKNKPK=KBKOKJKIKGKBK@K;K@KKKQKQKNKJK8K/K7KIKcKxK€K~KK}K„KfKIKEKK#K.K@KGKOKLKJKJKJKAK7K1K3K=KKKPKSKPKQKQKRKSKRKRKRKRKRKQKPKPKPKPKQKQKRKRKQKPKQKPKQKQKPKMKOKPKYKiKsKK„KK€K€K‚K‚KƒKƒK‚KƒKiKPKQKQKOKLKOKMKSKSKSKPKLKEKNKQKRKNKXKIKVKOKOKPKOKOKMKMKOK^KxK™K¼KÔKÝKáKàKÝKÒK¿K«KšK‹KƒK‚KƒK…K†KˆKˆK‡K†K„K…K…K‡K‡K‡K†K„K†K‡K…K„K…K„K‡K†K„K‡KuKQKQKPKPKRKCKEKIKIKIKHKIKIKIKHKIKIKHKIKIKHKGKGKIKGKFKGKGKFKEKCKCKDKCK@K?K>K=K;K:K8KDKSKSKUKTKNK4K,K)K&K&K"K!K$K{KŽK‡K‡KˆK†KˆK‰K…K‚KƒK‚K‚K}KuKkKiKjKhKfKiKqKwKwKqKjKdKZK?KBKOK[KdKhKiKfKgKeKdKdKdKfKgKeKaKaK`K\K^KcKaK]KZKYKXKXK\K]K\KXKTKRKOKNKSKPKPKSKTKNKFKGKKKLKKKIKIKIKHKFKEKBKEKNKNKRKRKJKHKKKOKOKKKKKJKKKSKPKšKöKñKïKéKëKîKìKîKîe]rI(KGKGKIKHKIKHKEKGKFKCKAKCKGKDK?K?K9K%K-K8K;KKKEKHKHKJK@K9K:K2K&K$K!KKKKK%KRKEK5K6K8K2KKKKK&KUKKK8K&K"K%K*K.K.K2K3KKKWKCK:K5K8K6K9K7K7K:K;KRKWKDKWK{K{KzK{K}K|KzK|KuKXKRKIKpKoK^KMK?K;K:K=KCKSKSKJK>K7K=KKK-K)K'K&K"KK(KKK‡KˆK‰K†KˆKŠK†KƒK‚K‚K‚K€KzKqKhKjKiKfKfKlKrKwKrKjKdKWK;KDKSKaKhKlKmKjKgKdKdKeKeKfKgKfKbKbKcK`K_KbKaK\KZK[K[K\K`K]K[KXKSKRKRKSKTKRKSKVKSKIKHKKKNKLKLKMKMKMKKKIKHKFKIKQKRKSKSKRKLKKKOKTKPKOKQKPKTK]KÃKìKêKïKìKëKëKîKîKîe]rJ(KGKGKGKGKGKGKGKGKEKCKDKCKFKGKDK>KK:KXK}KzK{KzK{KmKHK7K@K=KKRKnKmKKKKK@KsK„K~KmKQK;K2K7KBKMKLKHKGK8K;KAK8K3K5K=KJKRKRKQKSKRKSKQKPKPKPKPKPKPKPKPKPKPKPKPKPKPKQKRKNKMKPKRKQKOKNKOKWKdKrK}K„K„K…K„K{KOKNKMKNKMKLKPKSK[KWKQKNKIKIKMKQKUKQKJKQKTKMKNKNKNKNKPKPKNKOKOKOKMKKKQK^KwK—K·KÐKßKáKÝKØKÓKÆKµK¥K“K‰K…K†K…K†KˆKˆKˆKˆKˆKˆKˆKˆKˆKˆK†KƒK‚KKƒKˆKcKLKQKPKQKNKAKIKIKHKHKHKHKHKIKHK?KEKIKHKIKIKIKIKIKIKGKGKGKGKGKEKCKDKCK?K=K;K9K:K7K6KFKUKRKSKTKIK1K-K(KK K0KIK‚KŒKˆKŠKŠK†K‰KŠK„K„KKKKK|KvKkKiKjKfKbKgKmKsKuKlKaKRK9KIK\KeKjKoKqKqKeKaKcKfKfKfKfKdKdKdKeKcKaKbKaK\K[K[K[K^K`K\KXKVKPKQKUKUKTKWKWKWKPKJKNKPKOKMKNKOKQKOKJKJKJKJKNKUKTKUKVKSKOKOKQKWKXKUKVKWKRK‚KãKçKãKëKóKìKìKîKîKîe]rK(KGKGKGKGKGKGKGKGKFKCKDKEKGKFKHKCK?K?KK=K;KJKsKyK}K~K|KzKzKyKyK}KeK;KKKKEKCK?KBKJKJKHKIK>K:K:K1K%K$K!KKKKK-KPKCK7K6K6K/KKKKK0KYKGK7K$K#K%K*K.K/K1K2KLKWKBK7K4K5K7K7K8K6K0K7KUKWKCKVK{K{K{K}K}K}KvKhKWKWKRKDK=K=K?K@K=KK>K:K:K:K6K;KSKSKRKSKSK8K0K/K)K3KKKSK‚KKˆKŠKŠK†KˆKŠK…K…KƒK‚KKK|KyKnKiKgKgKcKaKhKqKvKkKaKNK:KRKcKjKlKmKpKqKfKbKeKgKhKhKgKfKeKeKfKfKbKaK`K^K_K_K_K`K`K\KXKUKTKVKWKVKTKXKZKUKNKMKPKRKSKOKQKSKRKOKNKNKMKNKTKYKUKVKWKVKRKSKSKVKXKTKVKeKyKÆKíKéKäKãKìKòKíKíKíKíe]rL(KGKGKGKGKGKGKGKGKFKBKFKGKGKGKFKGKDK?K?K=KKdK~KzK{KzK|KbK>K8KAKKTKWKCKWK€K~KzKqKcKRKEK;K@KXKSKBK=K=KK?K@KRKTKJK-K+K8K9K8K:K9K0KK KHKQKMK$KKKKKK#K*K +KKKPKNKEK-K#K%K)K(K)K/K2K6K8KKK?KAK8K5K6K5K6K7K7K7K7K8K8K7K:KKKKK>KKVKTKUKVKQK5K0K7KDKHKCK}K‘KŒK‹KŠKˆKˆKŠKˆK†K‡K…K€KKzKvKtKlKkKfK`KcKcKfKqKpKaK=KBKaKeKjKkKkKpKpKhKdKfKjKkKjKhKgKfKfKfKfKdK`K_K`KaK`K_KbK`K[KYKYKYKWKXKYK[K^KWKRKQKTKUKTKRKRKSKSKQKPKPKQKTKWK[KWKXKYKVKUK[KYKeK“KÍKñKñKêKìKæKÞKåKêKßKÚKèKïKìKìKíe]rN(KGKGKGKGKGKGKGKGKDKCKCKGKGKGKIKIKIKIKDK6K8K?K3K0K9K;K:K9K8K7K7K7K6K8K:K6K7K9K8K7K7K6K4K2K4K9K;K:KK=K4K*K#KK"K/KPKOKJK:K5K3K%K(K)K-K6KKKEKVKOK*KKKKKKKKKKKLKQKKK9K/K2K3K9K=K=K?K>KKHKOKNKHKIKPKPKRKVKZK\K_KbKeKiKUKNKCKYK€KtKhK]KUKMKAK;K?KIKLKLKHK;K3K(K*K;KQKiK|K‚K€K~KK}KMKNK2KK&K)K8KEKJKNKIKEKFKBK;K2K1K7K@KKKQKTKQKPKPKPKQKQKPKQKNKNKKKJKPKRKQKQKPKMKNKLKPKQKQKDKK+K:KKKDKAK:K2KFKHKIKEK9K;K9K-K%K"KKKKKK9KRK>K6K4K6K)KKKKK9KWKDK2K#K$K&K)K,K.K.K2KQKTK?K7K4K5K5K5K5K4K5K:KRKSKCK;K5K5K;K:KKEK;K8K/K*K.K>KVKnKK„KKSKKK;KQKyKWK=K-K/K;KFKJKJKGKGKFK?K8K/K+K2KAKLKRKRKOKMKMKOKMKMKNKPKOKPKQKQKOKNKMKNKKKKKOKPKQKNKRKFK>KPKOKMKMKPKEK*KPKRKRKMKHKFKNKQKRKNKPKFKRKOKQKPKPKPKPKNKNKMKNKMKNKNKNKNKNKNKNKNKNKNKNKMKPKQKOKPKNKJKKKTKmK‰K°KÐKäKêKéKèKæKäKÙKÉK´KŸKK‰K…K†K€K[KTKTKSKRKKKCKLKKKLKKKKKLKJKHKJKKKKKKKKKJKHKIKIKHKHKHKHKGKFKFKDKCKBKAK?KK:K6K8K4K.K1K0K1K.K:KK(K>KGKCKAK:K0KFKGKIKEK:KKRK>K6K4K5K(KKKKK;KTKCK2K#K$K&K)K+K-K.K2KQKSK?K7K4K4K4K4K5K3K4K:KRKSKCKKFKJKHKDKGK>K/K4K/K1K9KCKLKNKPKQKMKKKPKRKOKKKNKQKNKMKNKNKKKJKNKPKQKPKQKLKKK?KCKEKFK=K8K6K:K7K/K+K5KGKKKFKFKKK~KK…KƒKqKXK=K-K2K=KFKIKBK=KDKFKAK:K3K2K6KBKJKPKPKPKNKIKFKNKQKNKNKPKPKNKKKNKNKMKAKIKQK>KLKOKNKMKMKSK-K@KWKQKOKLKBKFKOKSKUKWKKKQKSKQKQKQKQKQKQKQKQKNKMKNKNKNKNKMKMKMKMKMKNKNKMKNKNKMKNKNKNKNKNKNKOKNKKKJKHKRKkKK²KÍKÙKâKæKæKåKäKÙKÍK¬K€KhKZKOKPKHKIKPKMKNKMKKKLKKKKKLKLKKKHKJKLKJKHKIKIKIKGKGKGKGKDKDKBK?K=K7K7K9KBKMKOKOKSKUKUKUKTKCK.K.K+K"KnKšKKŽKŽKŒKŠKŠKˆK…K‡KŠK‡KK~KzKvKpKhKeKeKcK^K`KgKmK[KCKTK^KaKbKfKiKoKmKkKlKkKkKkKkKkKlKkKjKhKcKcKgKgKfKgKeKaK]K\KbKaK`K`KbKbK]K[KXKWKYK[KYKVKWKWKVKUKTKTKXKZK`KKÀKÅKÅKÑKÕKÎKØKãKÛKàKèKÖKÕKÞKäKíKÝKäKæKâKßKáKèKåKëKëKëe]rR(KDKDKAKDKEKFKFKGKFKCKCKDKCKEKGKGKGKGKGKGKGKGKCK?K=K:K8KAKEKFKFK=K7K;K/KKKKK#K*K/K4K8K8K8K:KKGKGKIKAK;K>K6K'K$K!K KKKKK?KOK=K6K4K4K$KKKKK?KSKAK0K"K$K%K*K+K-K-K1KPKRKAK5K2K3K4K4K4K3K3K;KTKRKCK;K4K0K1K&KKK%K.KAKUKPKEKLKEK9K,K KKKK,KQKQKIKQKHK/K*K;KKKJKEK,KKKK=KBKNKSKRKUKNKK´K;KýK K +KK KKK5KVKNK;KKKKKKK)K$K K$K0KLKNKMKAK;K?KAKFKPKLKOKVKYK[KXKPKNKGKmK…K€K€KKKKKK€K€KVKLKEKZK†K‚K~KsKjKcKVKIKDKAKFKIKKKIK?K-K+K*K+K;KSKpKK†KƒKK~K†K€KQKIK6KK"K2KAKIKKKFKDKEKBK=K8K2K1K8KDKJKLKOKPKMKLKLKMKOKPKFKMKLK>KNKMKMKMKMKIK%KHKSKQKMKIKBKHKMKLK(K+KJKLKJKJKHKGKIKNKOKOKOKOKNKMKNKNKMKNKNKNKNKNKNKNKMKLKNKMKMKLKKKLKLKLKLKLKLKLKMKNKMKLKNKOKLKNKLKIKMK^K~K¥KÆKßKìKëKéKæKåKäKÞKÈK¦K„KhKSKKKKKJKFKMKNKLKLKJKHKJKJKJKHKEKCKAK?KAKIKRKSKUKTKFK)KKKK5KTKSKRKUKJK/K/K&K\K™K“K‘KŽKŒK‰KŠKŒK‰K…KK„K†K€KxKsKtKoKfKeKiKaK`K^KcKTK>KMKTKVKYKaKnKpKmKlKkKkKmKoKlKkKlKkKiKiKiKiKiKiKiKeKdKaK\KaKbKeKcKdKdKaK^K\K[K\K[KZKYK[KZKYKWKYKYK[K‰KšKžK²K²KÄKÒKÒKÓKÖKØKØKßKÙKÛKåKÜKÒK×KàKçKäKßKáKÞKÜKÝKåKéKêKíe]rU(K4K@KBKAKBKBKBKDKDKCKDKDKGKGKGKGKGKGKFKFKGKGKGKGKGKDK>K=K=KIKAK4K=KK7K5K:KK4K,KIKDKAK?K5KK8KK4K2K3K3K3K1K.K2K:KSKSKBKBKEK>K6K-K$KKKK)KUKQKGKfK}KK€KK‚KHK*KdKaKPKHK`K‚KzK-K,KpK€KjKK@KKKNKLKBK=KAKCKIKNKMKMKSKUKTKSKNKNKFKcK…K‚KKKKKKKKK]KLKGKSK‚K‚KƒK„K‚KzKsKeKTKKKGKDKIKKKFK'K*K2K3K+K(K-K=K[KtK‚K„KƒK‚KUKGKK\K9K*K)K6KDKGKEKDKEKFKBK>K5K-K2K9KCKOKPKNKJKLKOKLK:KHKOK=KKKNKMKNKKKHK*K>KSKRKMKIKCKFKOKNK3K'K?KOKLKKKPKOKJKCKDKJKLKMKNKNKMKNKNKMKNKNKNKNKNKNKLKKKMKMKKKKKKKKKKKKKKKKKKKKKMKNKNKNKNKMKKKMKNKNKNKKKHKKKTKlKK¸KÕKçKìKéKæKæKçKèKÝKÁK›K{K^KMKIKLKQKRKOKKKNKOKOKMKGKBKAKGKPKTKSKVKMK3KKKKKK$KQKUKRKSKTK;K/K&KWK˜K”K‘KŽK‹K‰KŠK‹KˆK‰K‚K‚K†K€KsKoKuKpKcK_KeKgKbK^K`KOK?KJKQKTKYKcKnKnKnKlKlKkKmKoKlKkKlKkKiKiKiKiKiKiKiKcKcKeKbKdKdKdKeKfKdK`K_K]K]K]K\KZK[KZK[KZKWKXKZKtK™K–K•K¸KÁKÂKÍKÐKÏKÕKÚKÒKÙKÚKÓKßKäKÆKÌKÜKäKãKÜKÜKÞKÙKÜKßKßKåKíe]rV(K(K6KAK@K?KAKBKBKDKDKDKDKDKEKGKGKGKGKGKGKGKGKFKDKEKDKAK?K@KSKvKHK9K:K(K%KKKKK!K'K-K3K6K7K:K:K6K5K-K'KKK +KK7K=KKHKFKFKKK0K-K4K9K9K7K2K,K,KRKRKEK KKKKAKfKwK€K…KyKWKRKIKrK€K}K~K|KƒKGK"K^KcKMKIK_KK}K:K/KjKKƒK^KK7KTKMKGK#K7KK KKKK +KK K&KSKMKDKKKKK K KKK K KKBKPKKKHKFKEKNKSKSKQKTKRKSKUKSKNKNKGKUK}KƒKKƒK‚K‚K‚K‚KK‚KkKKKIKIK{K„K‚K‚K‚K‚K‚K‚KƒK‚KKwK[KHKHK-K%K1K;K@KDKDKBK;K0K)K*K5KLKTKHKCKAKxK‚K„K‡K…KtKYK>K1K0K:KGKKKGK;KCKEKBKK@KDKDKDKDKDKDKDKEKGKGKGKGKGKGKGKGKEKDKDKDKAK?K>K=K=K2KNK…K€KKK|KtKiKHKK!K5KK;K9K;K9K;KK*K3KJKDK@KK0K#K"KKKKKK$KMKGK9K1K2K0K'K"K"K"K+KMKNKAK2K*K+K,K.K.K0K/K6KQKMK>K5K1K2K/K&KKKK KQKRKDK>K`KAK0KhK…K~K|K}KtKWKRKHKsK‚KKK}KƒKIK"K^KeKOKKK_K€K~K?K.KfK€K‚K`KK2KTKPKIK+KKUK;KüKK KK +KK!KSKMKFKKKKKKKKKKKKAKPKNKAK,K.K2KBKKKMKSK[K_K^K]KSKNKHKOKuK‚K€KƒK‚K‚KK€K‚K„KrKKKKKIKvK„K‚K‚K‚K‚K‚K‚K‚K‚KƒK‡KnKIKKK2K$K0K;K@KCKDKHKGKCKAK;K3K)K3KGKGK@KnKŠK†KKK„K‰K…KrKUK>K1K5K@KFKJKGKCKCKDKCK:K3K.K,K0K:KGKGK>KNKNKMKKKKKLK*KIKPKRKMKHKBKGKNKMK;K/K]KÉKÍKÏK×KÕK¦KhKPKSKRKOKMKHKHKFKEKJKMKOKNKNKNKMKNKNKMKMKMKNKLKKKLKLKLKKKKKMKNKNKMKKKLKLKLKLKKKKKLKKKLKKKKKMKNKNKOKOKNKJKHKNKaKK¢KÅKàKêKêKåKäKêKëKèKÛKÁKŸKyKdKXKRKTKLK3K K#K*K,K-K,K&K'K&K&K&K,KNKTKRKSKSKBK+KEKK•K”K’K’KK‰K‡K‰K‡K‰K†K‚K~KoKiKjKlKlKjK`KWKVK]K^KLK4K?KCKLK[KnKoKnKoKoKoKnKnKnKoKnKlKkKkKkKlKjKiKkKkKjKhKfKgKdKdKdKhKeKdKbKaKcK`K`K^K\K]K\K[K[K[KXK[K]KgKƒK|KƒKˆK‹K®KÄKÁKÂK»KÐKÏKÄKÎKÃKßKáKÊK¿KÐKåK×KÎKÈKÏKÕKÕKÆK¨K°e]rY(KKK(K+K4K?K?KAKCKDKDKDKDKDKDKDKFKFKGKGKGKEKFKGKEKCKDKEKEKAK=K?K@K-KWK‚KzKzK{K|K~K…K]KK@K?K9K@KAK0K"KKKKK*K9K;K:KK(KKKKKKKK%KRKRKCKUK…KGK-KbK€K}K~KKvKWKRKHKsK‚KKK}KƒKMK%K^KeKPKKK^K€K€KDK/KfKK‚KhKK3KTKPKJK5K%KKK-KK K KKKK&KRKNKGK"KKKKK KK KK+K/KDKOKLKHK;K5K0K0K0K6K?KNK[KcKdKVKLKIKMKfKKKƒK‚K‚K€KK‚KƒKwKNKLKIKoK…K‚K‚K‚K‚K‚K‚K‚K‚K‚K…KwKKKKK7K%K1K:K?KCKDKFKEKFKFKFKDK@K;KFKIKAK;KUKrK‚K‡K„KK‚K†K‰K…KpKRKBKKBKFKIKFKDKAKAK@K:K4K-K*K$K5KPKMKMKLKKKPK-K=KQKRKQKJKCKEKMKOK@K:K¡KÐKÉKÉKÍKèKøK­KCKFKNKJKLKPKPKDKKDKEKFKHK?K7K2K9KLK\KTKLKIKJKcKwKƒK‚K‚K‚KƒKƒK‚K„K|KSKLKIKjK†K‚K‚K‚K‚K‚K‚K‚K‚K‚K„K{KNKKK>K$K.K7K>KBKEKGKGKGKFKFKDKDKBKGKJKDK/K$K-K>K[KuKƒKˆK†KƒK„K†KŠKqKEKDK0KK+K=KIKGKDKDKEKEK>K7KK&KRKMKNKNKLKPK4K0KRKRKQKLKDKBKNKSK@KeKÌKÊKÊKÊKÊKÜKëKÎKUK*K,KiKeKIKNKGKBKLKIKEKDKDKDKJKNKNKNKNKMKMKNKNKLKKKKKMKNKNKNKKKKKLKLKLKKKKKKKKKKKLKKKKKKKKKKKKKKKKKKKKKMKNKNKOKOKNKKKHKNK`K€K¨KËKáKëKéKåKâKåKéKêKÝKÁKKtKTK=K6K7K7K8K8K5K5K1K1K8KPKTKRKSKUK;K3K~K–K“K’K’KK‹K…K„KˆK‡KˆKK}KzKmKfKdKdKfKgK\KVKRKRKMK2K3K@KLKaKkKoKoKnKkKlKoKnKoKnKoKoKoKoKmKkKlKlKlKkKiKiKjKgKfKgKfKdKdKeKbKaKbKaK_K`K_K`K^K\K\K]K[KZK[K[KoK~KeKK“K…KŽK§K¶K¡K³KÇK¶K¯K½KÃKÚKØKÃKÉKÍKÜKÎKÈKÎKÓKÑKÍK·K‡e]r[(K$KKKK(K'K5KBKBKDKBKCKDKDKDKDKDKDKEKEKEKHKGKGKEKCKFKGKEKFKFK@K6K>KMKsK‚KK}K}K}KKBKKGK;K:KYKK~KKK„KlK5K)K9KK9K1KEKFKGKCK;K=K;KKKKKKKKK.KQKCK2KKKKKKKK"KNKJKK+K&K%K"K"KKKK&KPKRKDKTKƒKAK$KcKƒKKKKxKXKRKHKsK‚KKK~K„KXK-KXKeKOKKKWK~K‚KPK+K[K‚KK€KWK1KPKQKLK(KjKYKK!K!KKK&K'K-KLKNKKK4K'K)K&K(K&K&K'K'K#KK/KNKNKHK$KKKK#K,K9KEK?KPKNKHKKKKKFK[KeKtK„K…K‚KK‚KƒKKK]KJKIK\K…KK‚K‚K‚K‚K‚K‚K‚K‚KƒK„K\KHKFK(K*K3KK6K1KEKFKGK@K:K=K8K'K!KKKKKKK1KPKCK3K KK KKKKK'KQKIK;K$K K"K%K&K&K)K&K6KTKIKK:KHKpKK~KuK,K2KHK8K;KnK€KKKK€KXK-K+K;K;K=K;K:K5K'KEKGKAK?K6K6KFKFKFK@K9K=K8K'K!KKKKKKK2KOKCK1KKKKKKKK(KRKHK:K#K K K"K%K&K$K"K6KTKHK=K%KKKKKKKK'KRKRKDKWK„KBK$KcKƒKKK‚KxKTKPKJKrK‚KKK~K…KYK*KXKiKQKMKUKK…KXK*KWK‚KKKKyKSKOKKK.KKK K"K%K'K&K&K&K+KJKNKJK7K'K)K+K+K*K'K K$K+K+K3KLKMKKK2K%K%K%K'K$K#KKKKK2KLKKKFKLKPK`KNK(KBK_KzK‡K…K†KiKJKKKOK}K‚K‚KƒKƒKƒKƒK‚K‚KƒK‚K†KkKEKJK1K$K2K;K>KDKGKEKFKGKFKFKFKDKBKFKJK?KKK K"K%K1KK4K6KFKGKBKXKyK†KŠK†K‚KƒK†KŠK…KuK|KwKGKFKGKEKCKGK8K'KPKQKOKJKFKBKNKLKxKÐKÍKËKËKÌKÈKÀKéKìK|K“KÏKÊK¸K‰K…K‹KnKHK-KKÖKœKqKaKPKJKKKLKLKLKLKHKDKDKEKGKJKNKLKLKKKKKLKLKKKKKKKKKKKKKLKLKKKKKLKKKLKLKKKKKKKLKJKHKHKHKKKLKLKJKHKIKIKKKLKKKLKLKLKMKMKLKKKHKNKZKuK›KÁKÜKêKëKéKäKäKèKêKëKáKÆK©K†KjKEKKBK8KDKxK€KKK~K}KNK,K1K:K:KK2K8KEKCKDK>K:K>K5K!KKKKKKKKK8KIK~K€KKK€K|KKK-K2K:K9K9K;K?K2K-KEKDKBK>K2K8KDKCKDKK/K K"KKKKKK/KTKIK9KKKKK!K K!KK7KUKHK;K!K K!K K K K!K#K0KSKNKAKXK„KIK-KeKƒKKK‚KxKSKRKJKrK‚KKK~K„KbK*KTKkKOKLKQKzK†KcK+KNK€K~K…KTK'KMKRKMK5K K&K&K$K#K"K"K$K(K*KEKOKKK>K!KKK+K0K2K.K/K/K.K2KIKNKJKKEKDKDKDKBKDKDKCKDKCKCKHKCKFKrKK€KuKgKZKPKGK>K;K;K=KAKGKGKFK7K(K#K&K3KJKgK~K‰K‰K„KƒK†K\KCKGKFKGKDKFK&K@KPKOKMKIKCKIKQKQK°KÔKÍKÍKÔKˆKLKÎKòKÁKbK½KÑK—K[K„K–K—KUKKÌKÇK½KŠK‡K‘K‰KTK>K3KDKGKJKLKKKMKKK9K>KEKCKEKJKJKKKLKKKKKLKLKKKKKLKKKKKLKKKKKKKLKKKKKKKLKLKLKLKLKKKHKHKIKHKIKHKHKHKJKLKLKLKLKLKKKKKLKLKLKOKMKGKGKNK_K|K£KÅKàKíKìKæKáKáKåKêKîKåK×KÃK®KŸK“KŠK†K‚K‚K…KƒKsKsKyKmK`KeK_K]KVKPKOK2KK?KZKbKfKjKlKnKoKqKqKqKpKnKoKnKlKkKlKkKkKkKkKnKnKiKhKjKgKfKgKeKgKhKcKbKfKdKhKcKdKfKaK`K_K_K`K^KXK_K^K\KbK[KWK^K\KYKbKcKnK{KKxK|K‚KƒKƒK‘KºK¹KÈK¬K·K©K¿K¾KÁKÊKÂK~e]rb(K)K*K+K*K(K%KKK K)K1K5K4K:K>KAKCKBKBKBKBKCKCKEKEKEKFKGKDKDKFKEKEKDKDKDKCKDKCK>K;K7K,KKKKBKDKCKFK1K3KBKCKCKCKCKIKIKDKzK…K„K‡K…K€KrKcKYKNKGKAK=KDKFKFK7K;K3K.K'K"K+K8KQKmKƒK‰KŒKiKDKGKFKGKCKGK-K4KQKOKMKJKDKCKPKLK“KÕKÊKÎK¼KWKAK¬KñKÜKhK¨KÏKWK5KUK\KsKXKvKÊKÆKËKšK†KˆK‡KcKDK%K"KxKƒKVKLKJKJK7KBKKKGKBKBKDKGKJKLKLKKKKKKKKKLKKKKKLKKKKKLKKKLKKKKKKKKKKKKKLKKKJKJKHKIKHKJKJKHKIKJKJKJKJKJKLKKKJKIKHKIKJKKKMKLKKKHKJKSKkKŽK¶K×KçKìKèKâKàKâKçKéKèKáKÎKºK¦KKKyK‚KzKqKxKtKaKdK_KZKVKPKQK/KKKK[KcKfKiKlKnKoKoKoKoKoKnKoKnKkKkKlKlKlKlKnKoKmKkKiKhKfKeKgKhKgKgKdK`KcKhKgKdKbKcK_K]KaK_K[K[KXK`KaK\KbK]KVK^K]KWKWKVK_KqKtKrKjKiKqK|KgK›K²K¶K¶K¤K©K­KÇK¸KÁKÉKƒe]rc(K+K+K+K)K$KKK K&KKK3K7K7K8KBKDKBKAKAKBKCKCKCKCKCKFKGKDKEKHKEKCKDKDKCKDKCKDKAK=K>K>KIK9K7KVK‚KKKK‚KpKAK.K6K>K=K=K;K;K*K3KGKAK?K=K1K=KFKDKCK;K;K?K/KKKKKKKKKAKKK;K.K(K)KKKKKK1KQKGK8KKKKK K!K!KK9KRKIK;K"K#K$K$K$K&K&K%K1KQKNKAKXK…KHK-KdKƒKKK‚KxKTKQKIKrK‚KKKK‡KfK+KOKmKRKMKPK{K„KhK*KHK|KƒKQK$K%KHKRKKK;K$K&K&K&K'K)K)K(K)K&K=KQKLKBK1K2K0K0K0K0K0K3K2K1K3KEKNKKK@K1K2K-K!K!K)K$K$K!KKK2KNKJK=KK'KK'K,K&K*K*K*K-K/KFKMKLKBK3K:KOKkKK†K‡K…K„K„K„K…KaKEKHK+K)K5K=K@KDKCK3KKK9KBKCKCKBKHKIKBKnK†K‚K„K„K†KˆK…K}KpK`KVKNKFKDKDK9K;K=K6K3K3K1K*K&K*K:KSKsKsKHKFKGKGKDKFK5K*KQKPKMKJKGKBKNKKKuKÍKÉKÑK†KAKBK†KìKîKKK¤K4K2KLKTKPKNK]K¼KÉKÌK«KˆK‹KŒKtKNK1KBKÀK»K{KnKcKQKDKIKLKLKKKGKGKEKDKGKFKFKLKLKKKKKKKKKKKLKLKKKLKKKKKKKKKKKKKKKKKKKLKJKHKHKHKKKKKHKHKHKHKHKHKIKLKJKHKHKIKHKIKLKLKLKKKKKNKLKHKEKMK_KK¥KËKãKìKêKåKáKáKäKçKèKåKÙKÅK¨K’K†KmKmKzKdKcKbKXKVKOKPK,K(KPK]KcKfKiKlKoKoKnKnKnKnKnKoKnKlKlKlKlKkKlKpKpKkKhKhKfKgKgKhKjKfKfKeK`KbKfKgKeKaKbK^K\KcK_KZK[KZK^KeK^KaKbKYK]K^KXKYKWK[KhKyKpKkKjKhKhKYKsK¢K©K´K™K®K®KÆK¹K£KÁK–e]rd(K*K,K*K&K!KKK#K!KKKK/K8K8K;KAKCKAKBKAKCKEKDKEKGKEKDKFKFKDKDKDKDKDKCKCKCKDKDKBK=K>K:K6K7K]KƒK~KKK„KkK>K.K6K;K:K=KK*K8KGKAK?KK(K;KGKAK?K;K0K@KDKDKBK;K=K>K+KKKKKKKKKFKHK;K.K(K'KKK KKK6KRKFK2KKKKKKK K K=KRKHK;K&K&K%K%K(K)K)K'K4KTKPKDK[K†KHK-KeKƒK€KƒKƒKwKTKQKIKsK…K‚K‚K‚K†KkK*KIKmKQKOKNKzK‡KqK-KCKvKAK$K(K$KEKRKMKKAKBKEKBK>K@KAKDKDKBKGKJKBKYK‰K„K…K„K„K„K…K…K„K…K‡K‰KKOKFKCK?KIK>K8K5K6K=KCKBKAK=K/K(K?KEKCKDKCKCKDK&K@KPKQKNKJKAKGKQKPK¨KÖK„KK*KKKKKKKKKGKGK9K-K(K'KKK KKK9KRKCK0KKKKK!K K"K"K@KSKIK:K'K&K%K'K)K(K*K)K3KOKMKDK[K†KHK.KdK…K‚K‚KƒKwKTKQKIKsK…K‚K‚K‚K†KmK+KIKpKSKOKMKzK‡KrK/KAKMK(K(K$K$KCKPKKK=K(K&K$KKKKK$K+K,K;KOKLKEK1K1K3K2K5K4K3K3K4K5K5KCKMKLKBK"K&K'K"K"K KKKKKK*KOKIKIKKKKKKKK&K&K'K'K9KJKGKEK6K1K4K5K8K8K9K8K:KEKZKvK{KJKIKK:K;K;KBKJKLKCKCKGKGKGKDKCKGK-K6KQKMKMKIKDKEKQKJK“KÃKOK?KCKEK=KŸKðKâKrK9K2K.K1KFKLKMKLKgKÅKËKÉKºKŽK‹KKoKVKºKÈKÏK¥K;KCKbKmK\KKK5K&K8KUKQKKKKKMKLKJK7K=KBKAKBKFKLKLKLKLKKKLKLKKKKKKKKKKKKKKKLKLKLKKKLKKKIKIKHKIKHKHKHKHKHKIKHKHKHKHKIKIKIKIKHKIKIKIKIKIKHKHKIKIKJKKKLKIKHKJKYKxKžKÃKßKêKìKèKâKáKåKæKèKêKåKÓKµK’KjK6K4KKKYKaKhKjKjKjKfKgKkKmKqKmKmKoKmKjKiKjKkKpKqKmKiKfKgKeKiKjKiKjKfK`KaKfKkKgKfKgK]KZKaK^K]KaK[KVK[K]K`KdKeKeKaK\K\KXK\KYK]K[KUKUKVKWKPKPKWK\KZK}K˜KK‘KKÆKËK®K½KÙe]rg(K-K&K!KKK&K KKKKKKK K&K6K5K6K:KCKDKCK@KBKDKDKDKDKCKCKCKDKEKDKDKCKCKDKCKCKBKAKAKAK1K,KDKnKƒK~K€KƒK\K5K+K6K:K;K=K;K:K*K?KDKBK?K;K:KCKDKDKAK8K>K=K*KKKKKKKKKHKGK9K-K(K'KKKKKK:KQKBK/KKKKK K!K#K#K@KRKHK:K'K&K'K(K)K)K)K)K3KOKNKCK[K†KHK-KdK†K‚K‚KƒKwKTKQKIKsK…K‚K‚K‚K†KoK,KHKpKRKNKMKyK†KrK3K6K-K(K(K%K%KBKPKKK>K#KKKK K(K+K,K,K*K9KOKLKFK6K1K3K4K6K7K7K7K7K5K5KBKLKLKEKKKKKKKKKKKK!KJKIKIK%KKK +KKKKKK$K&K4KIKHKEK8K2K4K5K6K7K9K:K;K9K6KK6K8KDKmK„K€K~KVK4K+K6K;K>K=K;K9K7K@KFKBK?K=K?KCKDKDKAK;K>K;K&KKKKKKKKKIKGK:K-K(K%KKKKKK=KPK@K/KKKKKK!K%K%KAKQKEK9K'K&K*K)K(K)K'K'K4KPKOKAK[K‡KHK*KcK†K‚K‚KƒKwKTKQKIKsK…K‚K‚K‚K†KqK,KEKpKQKPKJKvK†KwK6K/K)K(K&K&K!K>KQKLK?KKK"K)K,K+K*K*K+K'K5KNKLKFK8K4K7K7K8K8K8K8K7K9K6KKMKIK1KKKKKK"K%K'K&K K!KEKJKHK;K&K.K2K2K1K4K5K6K6K6K9K8K>KGKGK-K&K0K:K@KCKBKEKGKGKGKGKGKCKAKDKIKAK]K‰K‡K‡KˆKˆKˆKˆKˆKˆKˆK‡K‰K†KSKDKAKZKŠK‡K‡K‡K‡K‰KˆK…KKtKhK^KJKEKGKDKCKCKFK*K6KPKMKMKHKBKAKKKLKEK?K>K?KBKCK@K¨KðKåK{K;K1K/K0KBKHKKKLKaK¾KËKÇK¿K„K…K’KKOK¥KÎKÈK¾K{KiK[KkKwKMKeKÃKÅKÉK£KoKdKZKYKaKQKDKFKHKKKJKJKJKJKGKGKDKBKAKBKFKLKMKLKLKLKLKKKLKKKHKHKHKHKHKIKHKHKHKIKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKIKIKIKHKIKIKIKIKIKHKHKIKIKLKLKIKFKFKLK`K‚KªKËKãKîKëKåKâKàKáKäKéKìKêKÝKÇK«KKwKnKiKiKjKjKmKrKrKkKcKfKjKjKlKlKgKbK^K^KcKhKlKkKjKbK[K`K]KZKbK`KcKaK[KWKVK_KbKeKfK`KXK]KdK_K[KUK[K`K_KTKQKMKLKYK\K_K]K`K_K}KzKpKºKÁKƒKe]rk(KKK#K%KKKKKKK +K%K8K5K4K0K/KKK!K)K(K1KAKCKBKBKBKDKCKAKBKBKBKBKBKBKBKBKBKBKAKBKAKBK@K?K=K8K7K?K^KGK-K-K9K=K=K>K=K:K7KBKBKAK=K;K?KCKDKFKKBKCKDKDKDKDKDKDKDKAKEKIKCKUKˆK‡K‡KˆKˆKˆKˆKˆKˆKˆKˆKˆKŠK]KCKCKLK„K‡KˆK‰K‰K‰KˆK‰K‰K‹K†K~KaKEKGKFKFKCKFK4K.KOKLKMKIKFK@KHKMKHK?K?K?KAKAKSKÂKçKìKŸKBK5K1K-K=KFKHKMKQK§KÌKÌK‰KbKzKrK^KKK…KÏKÇKÇK KKK€KrKWKbK¿KÇKÆK¹K…KxKtKlKfK]KLK=K'K8KCKEKIKLKIKHKGKGKCK9KAK@KCKHKIKKKJKLKLKKKKKKKKKKKKKIKIKKKJKHKIKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKIKIKIKHKGKHKIKIKHKGKGKIKIKIKGKGKHKHKHKJKLKKKHKDKFKVKrKšK¿KÝKêKíKèKåKãKáKãKåKéKêKáKÐKºKœKKlKiKkKqKrKjKfKgKiKkKlKlKgK[K`KcKfKlKnKjKgKaKZK\KaKZK_KdKdK`K[K[KVK^KbKcKhKbK[KZKaKbK]KVK[K^KdKXKSKRKOKZKaKcKbKbK_KtKƒKhK¦KÙK†Kne]rl(KKK%KKKKKKK KK7K4K4K3K1K'KKKKK%K*K3KAKBKAKBKCKCKAKBKBKBKAKAKAKAKBKBKAKAKBKAKBK@K?K?KKAKDKCKCKCKCKCKCKDKCKDKFKEKMKKˆK‡KˆKˆKˆKˆKˆKˆKˆKˆK‡K‹KjKBKDKAK|KŠK‡KŠKŠKŠKŠKŠKˆK‡K‡KK~KIKFKGKFKDKDK=K&KJKMKMKJKGK>KDKNKJK?K>K>KBK?K†KÐKßKíKÁKOK8K2K-K6KFKHKNKLK‰KÐK¼KRK=KHK;K>KLKhKÇKÈKÉK¬K‰KKŽK‘KqKKK£KÌKÄKÅK†KbKdK`KaKfKQKGK&KK?K”KdKGKHKHKJKJKAK1K@KDK@K@K@KCKHKLKMKKKLKKKLKLKLKIKIKLKKKIKIKIKIKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKFKHKHKHKHKFKGKHKHKHKGKFKHKHKIKHKGKGKHKHKIKHKDKDKMKbK…K­KÏKåKêKéKåKâKàKáKãKäKèKçKßKÇK®K”K~KnKaKbKgKkKlKlKjKcKZK_KeKgKlKmKkKfKaK[KXKbK[K]KeKdK`K[K[KUKZKaKcKiKbK\KZKbKeK`KZK]K^KhK]KZKZKQKWKdKfKeKaK_KbKKiKvKÄK«Kle]rm(KK$K$KKKKKKKK5K:K7K1K0K&K,KKKKKK'K/K7KAKDKCKDKCKAKBKBK@K>KBKAKAKBKBKCKDKBK@KBKAKBK?K?K=K:K7K8K0K,K7K:K:KK=K:K9K5KKKK%K"K'KFKMKJKKVKKKJKHKzK‰K†KGK0K(KKKKKK3KLKHKGK-K%K&K"KKKK(K1K5K7K5K9KGKJK>K+K/K7K>KBKDKCKDKDKCKCKCKDKCKCKGKFKFKyK‰KˆK‡KˆKˆKˆKˆKˆKˆK‡K‡K‹KwKEKHKAKpK‹K‡KŠKŠKŠKŠKŠKŠK‰K‰K‰K…KRKCKDKDKCKDKCK#KDKOKNKLKHK@KCKOKLKBK>K?K?KSK»KÊKÛKêKÝKfK9K3K.K1KFKKKLKLKkKÍKK5K;KDKSKxKqKRK³KÌKÇK¼KŽKKŒKK‚KKKKÎKÄKÊKªK…KƒKrKhKFKCKNK:K#KuKÔK—KVKVKQKJKGKGK6KBKJKIKGKEKAK?KAKEKGKJKKKLKKKKKKKKKLKKKLKJKHKIKIKHKHKHKHKHKHKHKHKHKHKHKIKGKFKFKGKIKGKFKHKHKGKGKGKGKGKGKFKGKGKGKGKGKFKFKFKGKGKIKJKIKFKEKGKWKuKKÁKÝKëKìKæKâKáKáKâKäKèKéKåK×K¿KŸK€KmKhKhKkKhKaK\K]KcKgKnKmKjKfKbK^KWKaK`KZKeKbK_K^K]KXKYK`KdKlKgK_K^KfKhKfK_KbK`KjKcK[K\KTKUKaKhKfKaK_KbKpKdK^KvK¢Kte]rn(K"K"KKKKKKK K,K>K;K:K2K(K'K>KKK%K&K$K K(K.K9KBKDKCKCKBKBK@K?K>KAKAKAKBKBKCKCKBK@KBKBKBK@K?K;K?K9K3K3K,K6K9K;K=KK;K:K6KKK%K&K$K$K,KFKMKKKAK/K0K/K/K0K4K8K2K1K8KKwKHKKKFKvK‡KˆKEK$KSK\K4KKKK(KLKIKFK2K,K-K*K&K$KKKK#K.K3K7KEKJKCK8K8K8K=KAKDKDKBKCKDKDKDKDKBKDKGKGKCKoKŠK‡K‡KˆK‡KˆKˆKˆKˆKˆK‡K‰K‚KJKFK>KdKK‡KŠKŠKŠKŠKŠKŠKŠKŠK‰KŠK[KAKDKCKCKCKDK9KCKMKMKLKIKCKAKJKKKDK=KAK?K†KÐKÇKÕKçKëKˆK=K6K0K-K@KIKHKJKUK®K]K2K:KvKKKƒKPK’KÍKÄKÅK™K‹KKŽKŽKZK`KÃKÇKÈK¸KKKŠKKwKIKLKDK7K©KËK´KcKVK[K^K[KOKFKHKHKGKGKHKFKDKBK@K@KCKHKJKLKMKLKKKKKKKLKJKIKIKHKIKIKHKHKHKHKHKHKHKHKHKIKGKGKFKGKHKGKFKHKHKGKFKGKFKFKFKGKGKFKGKFKDKFKGKGKGKFKGKHKGKGKIKHKFKCKBKNKdK‰K³KÐKçKìKéKäKãKáKãKäKæKêKéKâKÍK±K”KzKdKWKZK^KfKkKqKnKkKfKbK_KWK`KeKZKaKfK`K^K^K\K]KaKdKnKnKcK`KfKlKkKdKbK`KkKeK^K^KUKUK\KeKfK`K\K`K]KaKzKŒK˜Kˆe]ro(K%KKKKKKK K K7K9K=K;K1K!KK>K>K@KBKBKBKBKBKBKBKBKBKAKBKBK:K>K=K9K1K%K4K9KK:K7K>KCKDKDK2K.K?KGK@K1KKKKKKK2KNK?K1K)K)KKKKKKKGKJK>K'KKKK K#K$K!K%KIKOKCK4K'K)K)K(K)K)K)K'K3KOKMKCK^KŠKJK,KbK…K‚K‚K†KyKQKPKGKqK…KK‚K„K†K|K2K9KoKVKKKJKBK.K+K(K$K$K$K'K)K'K8KQKMKHKeKeKQKDK?KBK@K:K5K8K:KJKNKJKGK>K:K9K#KK K$K#K%K)K,KEKMKJKCK1K0K0K0K3K6K8K5K3K?KuK{KJKJKEKqK‡KˆKQKKUK‹K€KhKGK%K'KJKIKIK2K)K.K+K,K+K&K%K"KKK K-KCKJKFK:K8K7K9K=K?KBKAKCKDKGKFKCKCKDKFKHKCKdKŒK‡K‡K‡KˆKˆKˆK‡K‰KŠKˆK‡KˆKSKAKAKTKŒK‰K‰KŠKŠKŠKŠKŠKŠKŠKˆKŒKjKBKDKDKCKDKCKGKEKKKLKLKJKGK?KHKKKHK@K@KQK¸KÌKÉKÑKäKïK­KFK5K2K-K:KFK@K9KMKbK?K8K5KoKK‹KŒK[KhKÃKÅKÇK¨KŠKKŽK’KoKLKªKËKÄKÅKšK‡KˆKˆKˆK{KQKDKhKÈKÅKÈKƒK`K[KYKiKtKbKJKJKJKIKGKFKHKJKGKEKCKAK?KBKIKJKIKHKIKLKKKLKIKHKHKHKIKHKHKHKHKHKHKHKHKHKIKHKGKFKFKFKGKFKFKFKFKFKFKGKFKGKGKDKGKGKGKGKFKFKFKGKFKFKHKEKFKGKGKHKHKHKDKCKHKXKzK¢KÆKßKëKêKæKãKáKáKâKäKçKèKåK×K¿KK€KiKfKjKnKnKlKhKbK`K[K`KgK]K_KiKdKaK_KaKaKdKiKnKpKeKbKhKlKlKhKbK^KfKfK`K^KYKYK[K]KdK_K_K_K\K‰KžK¯K«KŒe]rp(K"KKKKKK KK9K9K;KK=K=K3K"K4K:K;K=K;K%K7KEKBK?K:K,KK(KKKK!K!K$K!K&KIKNKCK4K'K'K'K)K(K'K(K'K3KOKMKCK^KŠKJK,KbK…K‚KƒK†KzKRKOKHKrK…K‚KƒK„K†K}K3K6KnKXKNKKK9K,K+K)K'K(K*K+K,K.K=KOKMKIKNK:K KKKKKKK'K/KFKPKKKFKK5K4K5K7K9KK@KBKBKBKBKBKBKBKAKAK@K;K=K=K;K8K0K1K:K:K=K;K!K:KCKBKAK9K1KAKCKAKCKDK?K=KDKHKGKIKKK=K%KKK7KOK>K1K&K'KKKKKKKKKHK>K&KKKK!K K$K"K'KHKNKCK4K'K&K&K)K'K%K(K'K3KPKMKCK^KŠKKK,KbK…KƒK…K…KzKSKNKJKsK…KƒK…K„K†K~K6K5KnKYKPKLK:K)K+K+K,K)K"KKKK5KMKLKHKZK^KjKZK#K"KKKKKK?KQKLKEKK?KCKDKDKCKGKFKDKAKDKNKbKwK…KŒK‰K‡K‡K‡K‰K‰K‹KnKBKDKAKyKK‰KŠKŠKŠKŠKŠKŠKŠK‰K‹KƒKMKBKDKDKCKCKDKDKGKMKNKLKGK@KCKLKMKCKNK·KÎKÊKËKÉKÛKéKáKrK;K2K.K/K5K$K"K7KNKK:K0KCKBKAKBKFKFKCKDK>KBKHKIKKKHK7KK7KMKK@KBKFKIKIKIKHKIKHKHKIKHKHKHKHKHKIKHKHKHKGKGKFKHKHKGKGKGKGKFKGKGKGKFKFKFKFKFKFKFKFKFKGKGKGKFKGKGKFKGKGKEKDKDKEKGKEKDKFKHKHKFKBKCKDKTKqK–K½KÛKéKéKåKáKáKàKàKáKâKæKèKâKÔK·KK‚KkKjKiKgKnKkKdKaKfKkKhKdKmKlKeKhKgKeKdKgKgK_KhK_KbKcKfKYKXK_KfKcK_KYK\KgKoK€K§e]rs(KKKKK +KKK;K2K+K%KKKK&K(K/K?KBKAKAKBKAK?K?K?K>K?KAKBKBKBKBK@KK@K8K5KK9K1KBKAKBKBKDKCKFKDK;K?K?KGKHKJKMKBKCKIK;K/K%K'KKKKKK!KMKIK:K"KKKK!K#K$K K(KLKNKCK2K$K&K&K(K'K&K%K K4KOKLKFK^K‰KJK,KbK…KƒK„K‡KyKRKOKIKpKˆK„K„K„K…KK9K5KlK[KNKLKKAK4K>KpK¥KtKK@KCKBKAKAK?K>K>KAKBKBKBK@K>K>K=K;K;K=K4K5K:K:K?K5K&KBKAK?K?K6K1KAKCKCKCKEK9K>KCK?KHKFKCKDKHKKKKKKKIK?K/K%K'KKKKKK$KNKHK>K#KKKK!K"K$K#K*KLKMKCK2K$K&K%K%K'K%K(K'K5KNKLKDK^KŠKKK)K`K…KƒK„K‡KyKQKPKIKqKˆK„K„K„K…K€K;K3KkK^KLKKK9K%K(K+K,K,K.K'K%K!K%KMKPKKK[K~KK—K¦K¼KßKÜK¶KKVK;KPKNKHKKKKK$K*K'K'K*K,K4K^KOKKKOKŠKfKDK›KãKäKßKíK¯K*KTKŠK`KJKJKSKƒKˆKK6K.KqK‰K‡K‡K†K‰KjKFKJKAKEK‚KŒKK`K?K'KK"K*K2K9K;KEKJKEK8K1K0K+K&K K!K)K1K6K8K;K=KK8KFKFKFKGKDK@K?K?K@KDKGKIKGKHKHKHKHKIKHKHKIKHKFKFKFKIKHKFKFKFKFKGKFKFKFKFKFKFKFKFKFKFKFKGKEKCKFKFKCKDKGKEKCKDKDKDKDKDKDKDKDKDKDKDKDKDKCKFKHKIKHKCK?KDKYKzK¡KÆKÝKéKçKãKàKáKáKàKáKâKãKäKàKÏK¼KžKKoKeKeKgKiKnKpKlKcKeKhKjKgKcKgKbKhK^KaKaKgK`K_KgKeKcK_K[KXKMK?K0e]ru(KKK K K,K=KK=K>K5K6K;K;K>K1K(KCKAK?K>K6K2KBKCKCKCKEKDKFKAKAKJKNKQKJKBKEKIKCKFKMKDK3K&KKKKKK%KMKGK=K"KKKK!K"K$K"K+KLKMKCK2K%K&K%K%K&K%K'K'K6KNKLKEK_KŠKKK)K`K†KƒK„K‡KyKQKPKFKoKˆK„K„K„K…K„K>K1KkK_KLKLK=K+K/K0K0K.K*K&K"KK%KJKOKGK‰KÁK¶K³K¬K­K·KÆKÔKßKÒKˆKLKNKIKKKKK K-K0K=K5K-K4KOKQKKKLK­K·KKKHK´KéKåKíK€K!KMK‰KfKIKKKNK€KˆK‡K@K*KhKŠK‡K‡K‡K‰KqKJKMKEKAKyK‰KˆKK‡KqKKK.K!K&K*K3KDKHKFK>K7K3K2K1K-K$K#K!K%K0K6K;K:K>KEKEKCKAKAKCKDKDKDKDKFKGKDKDKKK[KsK]KCKCKEK‚K‹K‰KŠKŠKŠKŠKŠKŠKŠK‰KKƒKJKBKDKDKCKCKGK?KHKOKMKJKGKCKFKNKLK¥KÑKÊKËKËKËKÉKÚKéKèK|KK4K#KAKCK+K"K1K7K7K8K9K8K2K.K/K0K3K3K(K#K#KKK+K-K0K=KBKAKAKBKBKBKBKBKBKBKBKBK@K9K@KCKBKAK=K5K6KK5K4KDKCKCKCKDKJKJK@KAKKKOKQKRKPKIKBK7KDKNKLKKK?K KKKKK(KOKFK;K"KKKK!K"K$K!K,KMKLKEK2K%K&K&K&K%K%K'K&K8KPKLKFKaK‹KJK)K`KˆK„K„K‡KyKRKOKHKoKˆK„K„K„K„K„K?K.KjK`KLKOK?K.K/K/K.K(K$K"KK K,KIKMKIKsK£K¡K¡K¦K¬KµKºKÀKÄKÖK¸KOKNKMKKKKKK&K3K›KÉK\K,KFKNKNKIK¡K×K‰K6KkKÒKåKØKnK#KEK†KkKIKIKJK~K‰K‹KIK&K_KŠK‡KˆK‡KŠKyKKKJKFK=KrK‹K†K†K‡K‹K‰KxKXK3K'K$KKBKBKBKDKDKCKEKGKGKFKEKGKHKDKDK@KxKŽK‰KŒKKKŠK‰KKŒK‰K‹K‰KUKCKFKFKDKDKCKDKGKNKNKKKIKEKCKOKJK‹KÐKÉKËKËKËKÈKÒKæKðKŸKCK4K/K*K8KFKFKHKNK?K5K7K5KlK“KŽKKcKFKK@KBKBKBK?K;KBKAK8K8K:K7K9KKLK]KlK}KK˜K¦K³KÂK±KUKNKHK¦K¶KPK"K&K*K%K&KnKÛKlKEKMKOKHKˆKÆK¾KZK@KKÆK’KwK.K:K}KwKHKJKEKrKŠKŒK_K'KQK†KˆK‡K‡KˆK…KRKIKJK?KaK‹K‡KŠKŠKŠKŠKˆKŠKTK'KRKiKGKIKEK;KIKPKGK>K:K7K7K5K4K3K5K2K)K6KEKBK>K;K=K?K?KAKBKCKCKCKCKCKGKGKGKEKDKAK?KOKgK~K‹KŒKŽKŒK‹KŒKKŒK‘KqKBKDKCKCKDKCKHKDKLKOKNKKKFKCKIKMKVK»KÎKÊKËKËKËKÊKÞKèK×KeK8K1K-K,KAKGKIKMKLK:K7K=K™KžK‹KK€KNKBK8K6KAK‚KKŽKKKaKVKµKÆKXKFKŒK~KƒKŽK‹K‚KWKQK²KÉKÄKÇK¨KˆKWKLKNKNKNKMKNK§KÍKÃKÍK¢KFKOK\KjKiKbKYKVKKKIK6K&K8KFKCKDKIKIKIKGKGKFKCKAK@K?K?K@KDKIKIKIKIKHKHKIKHKFKFKFKHKIKFKFKGKFKFKFKFKFKFKFKFKFKFKFKFKGKFKGKGKDKCKDKCKCKCKDKCKDKEKBKCKDKCKCKCKCKDKDKDKDKCKDKDKBKCKEKGKGKHKFKDKCKBKNKdK‰K®KÏKáKçKæKâKàKáKáKáKáKâKåKæKãKØKÄKŸKaK.KKKKK K +KKKKKKKKKKKe]ry(K K)K=K;K9KK>K(K)K6K8K:K;KKBKBK@K?K>K@KBKBKCK?K:KBK@KK1K:KEKBKBKCKDK;KFK@KDKPKQKPKPKQKRKRKSKRKQKIKFKGKHKKKNKMK?K:KLKEK9KKKKK!K"K$K!K-KMKKK@K,K$K&K%K%K%K%K&K#K6KPKMKDKbKŠKKK)K`KˆK„K„K†KzKQKOKGKmK‹K…K„K„K…KˆKDK.KfKbKLKMKFK1K/K1K1K0K0K0K1K2K3KIKMKMKDK4K4K3K2K6KIKhK~K™KÀK§KVKNKMKmKªKÆKK@K,K2K)K,KšK¬KNKLKPKHK|K½K¯KYKK@KBKAKBKCKDKDKDKDKDKDK>KCKDKIKZKnKƒKŽKŽKKŒK‹KKKEKCKDKCKDKCKFKDKKKOKLKKKHKBKGKNKKK£KÒKÉKËKËKÉKÈKÓKÙKØKzK;K2K/K*K?KGKGKJKMK@K5KaKÃK£K‹KŠK‹KYKCK7K9K6KlK”KŽKŽK“KuKHK¡KªK:K:KxKŽK{K„K–KŒKhKGK‘KÊKÃKÇK±K”KgKLKNKLKLKMKFKKÌKÆKÂK¬KYKDKDKJKWKfKlKeKOKHKAK KK"KgKnKIKEKFKIKHKGKFKFKEKEK>K8K=K=K@KDKHKIKHKIKHKHKGKFKGKGKHKHKFKGKFKFKFKFKGKFKFKFKFKFKFKFKGKEKDKDKCKCKCKCKCKCKCKDKDKCKCKCKCKDKDKDKCKBKBKBKBKBKDKDKDKCKDKDKDKCKEKGKGKGKCKAKHKZKwKKÁKÚKçKåKàKÞKÞKàKàKàKàKâKæKçKâKÎK§KsK?KKKKK K +KKKKKKKKe]rz(K"K9K:K9K;K2K K;KAK*K$K3K5K9K9K:K9K1K%KKKKK!K8K8K5K/K)K)K$K K K%K1K3K3K5K>KBK?K?K>K?KBK@K@K>K;KDK=KK°K—KPKNKGKyKÓK³KUK@K“KžK‡K…K7K-KrK„KNKLKDKdKŠK‹KsK(K@K€K‰K‰KŠK‡K‹K_KEKKKBKRKˆK‹KŠKŠKŠKŠKˆKŽKqK*K?K}KTKEKDKXKkKDK.K7KLKSKMKFKBK;K8K7K8K>KGKFKCK4K'K'K.K9KKAKBK@K@KCKCKCKCKDKDK?KEKHKHKGKGKPKcKxK‰K‘KŽKK‡KNKAKDKDKCKCKEK@KFKPKKKKKHKDKCKNKJK‡KÏKÉKËKÊKÈKÈKËKÑKÁK}KFK4K/K)K6KDKGKIKMKFK9K—KÍK­KŒKŽKKnKHK;K:K5KUK‘KŽKŽKK†KMKvKpK3K6KeKKK‘K—K’K|KIKoKÅKÄKÈK¸K‹KyKMKMKLKLKLKJK_K¿KÇKÁKÈK‚KAKHKHKGKEKNKbK]KEKFK1K K,K®KÂKnK]KRKFKFKGKGKGKEKDKK;K=KBKGKIKIKHKGKFKFKGKHKHKFKGKFKFKFKGKFKGKFKFKFKFKFKFKGKEKCKDKDKDKDKDKDKDKDKDKCKDKCKCKDKCKCKDKCKAKAKAKAKBKCKDKDKBKCKCKCKDKCKBKCKEKFKFKDKEKBKBKNKjKK³KÔKäKæKáKÝKÜKàKáKáKßKßKäKéKêKÛK¼K’K_K0KKKKK +K +K KKKe]r{(K6KK>K>K?KBKAK>KKBKAKAKDKGKFKJK=KGKPKPKQKPKQKSKRKRKSKRKPKRKSKMKIKEKHKJKKKKKIK@K$KKKK K"K$K#K0KMKIK@K-K#K&K%K%K%K&K$KK7KPKKKBKbK‹KJK)K`KˆK„K„K†KzKRKOKHKjKˆK…K„K‡K‡K‰KIK)KeKgKOKLKWK‡KUK-K2K2K3K3K2K0K0KCKMKKKDK*K7KaKK¦K­K²K¯K­K¿KÂKaKLKHK‘KçKÇK‘K¯K·KRK8K3K(KYKËKtKIKGKyKáK¸KXKEKK“KˆKŒKCK)KiK‰KSKKKEKaKŠKŠK{K0KK:K7KKK‡K“KKK’K‹KVKUKµKÈKÅKÈKhKsK`KIKMKLKLKLKJK KÊKÂKÆKŸKJKHKGKGKGKEKCKHKIKIK=K!KZKÅKÆK‹KdKyKkKSKHKEKFKFKGK=K,KK=KKBKDKGKGKHKHKGKGKFKFKFKFKGKGKEKGKFKFKFKFKFKFKGKFKFKFKFKDKCKCKCKCKCKCKCKCKCKCKDKBKAKCKCKAKAKAKCKDKCKDKDKCKDKDKDKDKDK@KBKDKCKCKEKFKIKHKFKBK@KIK]KƒKªKËKàKæKæKàKÝKÞKáKàKßKßKáKäKêKæKÕK¬KzKIKKKKKK +K e]r|(K9K=K:K;K%K)K?K6K$K.K4K6K:K9K9K7K*K!KKKKK2K>K7K4K-K(K'K"K"K#K4K9K)K&K.K2K3K8K=K?K?K@KAK@K>KKCKAKAKEKFKDKJK=KHKQKQKQKPKQKSKRKRKRKRKQKRKRKSKQKNKJKEKBK;KJKMKGK3K!KK!K#K$K#K1KMKHK?K,K#K&K%K&K%K%K$K!K7KPKJKBKbKŒKKK)K`K‡K„K…K‡KzKQKPKIKjK‰K…K…K‡K‡K‰KIK)KeKhKPKLKVK…K‚KKK,K2K2K2K4K5K3KCKMKKKEK1KK2KsKfKCKFKLK…K‹KŒKKdK2K1K3K@KOKQKIKCKAKDKEKDK@K8K8K8K5K.K*K)K1K:K?K@K?KCKDKCKGKCKAKGKFKGKHKIKIKHKGKEKLK]KyKeK@KDKCKEKCKDK2K+KMKLKNKKKEK@KIKLKVK¸KÍKÈKÉKÉKÇKÌK¬KqKeKUKK8K7K;KK•K‹K‚KŠK”KhKGK”KËKÂKÐK}K>KdKHKIKIKKKLKFKxKÉKÃKÃK»KbKCKHKFKGKGKGKGKIKIKGK,KˆKËKÄK­K^K_KoKxKpK^KMKFKGKEK:KCKFKEKDKCKBKAK>KK;K'K'K1K3K7K9K:K7K/K"KKKKK-K@K:K6K.K)K'K#K!K K,K9K+K&K(K$K)K2K6K:K>KBKAK>K@K?K9K=KDK6K.K=K9K7K;K=K=K8K#KK8K.KAKDKBKBKFKGKHKIK=KIKPKSKRKPKQKSKSKSKPKQKSKRKSKSKSKSKSKOKDKK1KnK‹KˆKŠK‰KŒKxKHKIKFKCKxKK‰KŠKŠKŠK‰KŠKŠKGK/KkKpKGKIKEK|KŒK‡KŽKrK1K>K[KFK1K=KLKRKNKGKEKDKBK8K6K7K8K:K9K2K+K(K*K5K=K>KBKEKEKAK?KFKGKGKFKFKGKHKIKJKHKEKFKIKCKDKDKCKDKCK>K KFKLKLKKKFKBKFKNKMK£KÐKÈKÈKÉKÈKÍK°KfKaKVKBK0K0K,K=KIKIKLKLKœKËKÄKÆK©KK‘KKgKFK:K;K:K^K‘K‘K‘K”K€KNKDK5K7K4KiK–KK†KŒK–K}KJKsKÅKÃKÊKwKK@KMKHKIKHKJKLKZK¹KÆKÅKÌK‡KBKHKFKGKFKGKFKFKIKGKJK°KÆKÃKÄK~KZKYKbKoKwKmK\KMKEKGKGKFKGKEKCKDKDKDKCK=KK>K>K8K?KBK;K:KK8K0KBKDKCKBKEKIKKKHK=KFKMKRKQKPKQKRKQKQKQKRKRKRKRKRKRKRKRKUKPKIKFKFKJKLKNKKKAK0K"K K1KOKIK>K+K$K%K&K%K&K$K%K$K6KQKNKDKaKŽKMK)K`K‰K†K‡K‰KyKPKQKEKfK‹K‡K‡KˆK†KŒKPK(KaKkKNKNKVK…KŠK|K5K/K/K0K3K5K4KBKLKLKJK9K7K7K7K7K5K5K5K0K+K-KEKQKIKcK¶KÆKÐKÕKÙKàKàK¨KgK?K,KFKPKJK\KºKŸKkKnKKˆKˆKŽK[K#KPK‹KcKHKKKOK„KŠK‹KJK,KgKK‰K‰K‰KŒKKLKHKHKAKpKK‰KŠKŠKŠKŠK‰KKTK-K]KyKFKHKBKsKŽKŠKK|K5K8K|KKuKVK?K8KDKNKGKEKCK@K;K8K6K8K9K9K:K5K,K(K)K0K9KBKDKBK=KDKEKEKFKFKEKIKHKGKIKKKHKFKDKCKDKCKDKBKBK!K=KNKLKKKGKCKEKLKHK†KÏKÉKÊKÉKÉKÊKÀKnK`KWKJK5K1K.K6KEKJKMKJK~KÊKÄKÆK·K“KK’KxKMK?KK;K;K?KCKFKHKGKFKFKFKFKGKFKFKFKFKFKFKFKFKGKFKEKEKGKFKEKCKBKCKDKCKCKCKCKCKDKCKCKBKAKCKDKCKCKBKCKDKBKAKBKCKBKBKBKCKDKCKCKDKDKDKCKCKDKCKCKDKDKEKFKDKAK>KDKPK[KiKqKzK„K‰KK—K K¨K¯K¶K¹KÀKÉKÕKÜKØe]r(K8K5KK0KBK0K!K.K0K5K;K=K9K6K)KKKKK$K9K:K7K2K*K*K%K!K K'K:K2K*K)K$KKKKK#K3K:K:K=K?K=K=K9K?KAK;K=KK4K%K>KAKAK>K8K2KCKDKDKCKFK>K?KHK=KFKMKQKPKQKPKPKPKPKRKSKSKSKRKRKRKRKRKRKSKQKOKJKGKHKJKMKNKLK>K)K2KMKIKAK+K$K&K&K%K'K&K%K#K7KPKMKCKaKŽKMK*K`KŠK‡K‡K‰KyKPKQKIKfK‹KˆK‡KˆK†KŒKOK'K_KkKOKNKTK…KŠK~K2K3K7K.K4K6K4K@KLKLKKK8K3K4K4K4K0K,K(K6KeKyK`KMKLK\K›K³KÎKÐKÐKÐKÄKÂKÊK•K:K>KPKKKQKžK K|K}KK‰K‰KŽKeK%KJK‹KkKHKKKMK€K‹KKTK,K_KKŠK‰K‰K‹K…KRKGKGKCKgKŽK‰KŠK‰K‰K‰KˆKKaK/KTK}KIKFKBKhKKŒKŒK‡K@K2KmKKKŽKKcKAK=KHKGKAKFKGK@K=K9K8K9K9K8K9K9K-K'K&K8KEKDK=K?KAK@KCKGKGKFKFKFKGKHKGKGKDKBKDKDKDKAKEK)K2KOKLKLKIKDKCKKKKKkKÈKÊKËKÉKÉKÈKÉK„K[K\KPK:K2K.KPKaKHKJKMKbKÀKÇKÄKÀK™KKK‡KUKDK>K:K’K¨KŒK’KKKkKIK?K5K6K=KuK‹K‹K“K–K•KgKDK’KÏK‘K4KEKGKAKJKIKHKJKMKEKrKÇKÄKÄKÄKfKBKHKGKGK>K;KDKFKIKOK¬KÊKÃKÆK¸KZKVKgKcKaK_K]KcKeK^KGKAKCKFKJKFKCKCKDKDKDKDKBKBK@K=K=KK1K&K>KBK@K>K8K3KBKBKCKDKCKBKFKFK=KGKMKOKQKQKPKQKQKQKRKRKQKRKSKRKRKRKRKRKSKRKSKRKMKHKGKIKKKKKOKHK?KDKEK>K,K$K%K&K&K%K$K%K#K7KPKKKDKdKKMK'K_KŠK‡K‡KŠK{KPKQKIKfK‰K†KˆK‡K‡KKRK&K]KmKOKMKQK€KŠK€K2K4KfKTK0K3K5KCKNKJKKK8K4K1K-K+K*K*K1KCKcKžKwKIKMKUKK–K KµKÁKÈKÉKÏKãKóK”K:KRKOKTK‡KbK[K~KK‰K‰KKoK(KBK‡KsKEKIKJKyKŠKK\K)KUKŠKŠK‰K‰KŠK‰KVKDKEKBK_KK‰KŠKŒKŒKŒK‹K‘KlK2KLK€KOKFKBK`KKŒK‹KŒKMK3KbKK‹KŠKŽK‘KŒKnKIKFKDK@KGKKKLKGKBK;K;K7K6K8K7K7K3K7KDKDK=K=KAK@KAKDKDKCKDKFKDKDKFKFKEKBKBKCKDKAKEK2K&KLKKKLKIKDKDKIKKKUKºKÎKÊKÉKÉKÇKÎK™KYK]KTK>K1K/K„K™KwKZKLKQK«KÊKÄKÆK¦KŒK‘K’KbKGK;KSK½K·K˜K“KK”KyKMKDK6K8K8KFKKKAKLKlKjKWKGKoKÈKbK1KKEKHKIKIKJKJKVK´KÈKÁKËKŽKBKHKEKDKCKCKCKEKJKFK‚KËKÂKÂKÉKwK6KBKVKjKlKeK_K[K]KOKCKCK5K-K=KGKGKCKEKDKCKDKDKCKCKBK@KKKK2K7KCK?KK,K'K3K2K9K>KK-K,KCKCK@K?K5K2KDKCKCKDKFKFKGKDK:KIKHKIKNKOKPKQKPKQKQKQKSKRKRKRKRKRKRKRKSKSKSKRKRKSKTKSKMKGKEKIKJKHKKKHK5K%K$K&K&K&K&K&K$K7KPKKKAKdK‘KLK&K^KˆKˆK‡KŠK|KPKQKGKcKŒK‡K‡K‡K‡KŒKVK&KZKlKKKMKPK€KŠK„K9K4KpK‹KŠKvKCK;KMKKKJK9K6K:K9K9K9K8K6K3K3K3K=KKKIKHK8KEKvKK¡K±KÂKÀKÀKÑKÝK°KRKNKGKŠKgKRK‰KŠK‰K‰KŒK}K2K8KzKKHKIKDKmKŒKKpK.KFK…KŒK‰K‰K‰KKeKEKJKBKNKˆKKŒKKKKŒKŽKK>K=K{KdKCKEKMK‡KK‹K‘KhK4KNK‰KKŒKKŒKŒKK`KBKFKBK@KEK:K?KLKOKLKLKDK>K;K:K7K6KBKDKBK8K/K*K,K3KK9K9K;K:K@KGKIKGKGKFKFKGKGKFKCKEKGKGKGKGKFKCKDKCKCKCKCKCKCKDKDKEKCKCKCKCKBKAKBKBKBKAKBKBKAKBKBKAKAKBKBKBKBKBKBKBKAKAKBKAKBKBKBKBKBKBKBKBKBKAKAKAKAKAKAKBKAK>K>K?K@KDKBKCe]rƒ(K1KCK2K&K0K/K6K>K?KK)K/KBKBK?K>K5K7KEKCKCKCKFKFKGKBKK1KmK‹K†KŠK‚K]KJKLKLK5K/K3K5K6K6K7K8K7K5K4K>KKKIKHK9K;KEKZK|K‘KjKBK‚KÒKíKàK]KKKKKoKoKfKKŠKŠK‰K‹KƒK8K4KtK„KMKHKDKgKŒKŠK{K2K>K€KŒK‰KŠKŠKKlKHKKKCKGKKKŒKKKKŒKK‡KEK6KtKnKBKGKEK€KK‹K‘KuK8KFKKKŒKKKŒKKkKAKFK@KKK†KsKSK?K=KIKSKQKMKJK@K7K9K@KDKAK:K;K;K4K-K)K-K9K>KBKBKBKAKCKDKDKCKAKAKAKFK(K1KOKKKKKHKDKEKLKJKhKÈKÉKÈKÉKÈKÆK¿KxKUKZKNKSK©KbK\K”KK•KyKXK·KÉKÅKÃK£K’KKuKQKhKÄKÄKÉKŸKKŒKqKKKFKKK?K6K9K9KAKJKJKIKGKHKIKLKBK3K2K4K8KGK?KEKGKGKHKHKIKSK²KÉKÃKÊK—KDKEKDKCKBKBKBKDKIKDKtKÉKÄKÅKÉK˜KeKeKWKDK6K0K.K6KIKJKEKHK=K$K!K{KÌKµK|KsK[KKKEKDKCKDKDKCKDKBK?K-K7K@K;K:K=K@KDKFKGKGKEKFKEKCKEKFKFKFKFKEKCKDKCKCKCKDKDKCKCKCKDKCKCKDKDKCKBKBKAKBKAKAKAKAKAKBKBKBKAKAKAKAKAKAKBKBKBKAKBKAKAKAKAKAKAKAKAKAKBKBKBKBKAKAK@KAK?K?K?K>K@K?K?e]r„(K?K5K$K0K2K3KKK;K7K3K8K;K9KK?K>K>K>K?K>K?K>e]r…(K:K&K*K4K8K=KBK>K?K6K#KKKK!K=K9K4K8K/K*K&K!K"K*K;K2K+K+K&K KKKKKK(K'K#KKK K"K%K'K,K0K3K3K,K1K9K4K4K9K:K:K:K$K5KBKAK?K=K/K:KDKCKBKDKEK>KEK@K:KGKKKPKQKPKPKPKPKPKPKQKPKQKSKRKRKRKRKSKRKQKSKRKRKSKRKSKRKRKSKRKSKNKEKFKIKHKMKOKJK>K+K#K"K5KNKKK@KeK‘KLK&K^K‰KˆKˆK‹K|KPKNKFKbK‹KˆKŠKŠKˆKŒK^K%KWKqKPKOKNK}K‹K‹KFK-KhKŒKˆK‰KŒKyKLKJKMK=K3K6K0K-K+K+K-K/K1K1K9KLKIKIK:K2KCK5K(K,K]K~K›K´KÅK¬KUKHKJKPKdKaKlK‡K‰K‹KŠKKJK,KeK‹KTKHKFKZKŒK‹K‡K?K5KsKŽKŠKŒKŒKK}KIKHKGKBKqKKŒKKKKŒKŒKKZK0K\K~KFKIK?KlK‘K‹KKˆKJK:KnKKŒKŽKKKK„KIKEKCK?KuK’KŒKK‘K…KlKLK>KEKVK^KVKKKCKCKBK9K8K8K7K;K8K1K2K,K*K-K7K>KCKDKBKAKAKAKCKK?K>K>K?K>K>K?K>K>e]r†(K)K#K1K5KK=K7K)KKKKK6KAK8K9K3K+K%K#K"K'K=K7K.K,K(K!KKKKKK'K&K#KKKK#K%K(K)K*K-K2K4K8K+K.K3K5K:K9K;K7K#K8KCK@K>KK:K9K9KK>K?K>K?K>K>K>K>K>K>K>e]r‡(K%K/K4K8K=K;K:K7K*K KKKK1KAK:K;K3K,K&K"K"K'K;K7K.K-K)K"KKKKKK(K)K&KKKK!K#K%K(K*K+K-K/K0K3K8KK K5K:K9K:K8K"K;KCK@K>KK_K’KKŽKKKKŽK‘K•KaK6K8K=KBKDKCK>KNKJKDK@K:K8K5K6K=KK;K=K>KK?K>K>K?K>K>K>K>K>K>K>e]rˆ(K.K5K9K:K=K=K7K.K"KKKK,KAKK/K+K)K%KKKKKK(K'K$KKKK K"K&K)K+K*K-K2K0K(K*K&KK&K6K9K9K:K6K#K=KBK@K>K=K0K@KDKCKFK&K KK+K:K@KJKLKMKNKQKPKPKPKPKPKPKQKPKPKRKSKRKRKRKRKSKRKSKSKSKSKSKRKRKRKSKSKSKRKOKNKPKNKFKBKFKLKLKMKMKJKHK>KfK‘KLK%K[KˆK‰K‰K‹K|KMKNKFK^KK‰KŠKŠK‰KKeK%KPKtKPKQKJKwKŒKŒKPK)K^KŒK‰K‰K‹KKMKKKKKNK„K‹KiKDK7K1K,K,K)K'K.KHKHKKK?K(K KKK#K6KIK^KZKuKK^KGKMKGK9KHKMKaKfKvK—K‘KfK+KNK‹KiKGKIKJKKKK\K.KZKKKŒKŒKKŒKYKEKFKAKWKŒKKŒKKKKKK}K=KBKK_KDKFKMKˆKKŽK“KlK:KPK‡KŽKŽKKKŽK’KgKAKEKAKTKŒKŽKKKŽKKKK“KqK3KCKgKOKBKDK@KTKVKOKJKFKAK9K3K4K6K8K;K9K?KCK@K@KBKAKEK1K(KNKLKKKJKFKDKKKMKUKµKÌKÈKÈKÉKÄK¤KjKSKVKSKGK;K;KFKoKhK[KTKKKKÊKÆK¯K[KKKOKKKMKQK§KËKÅK¾K`KDKIKIKKKKKJK9KKËK¿K^KCKIKHKFKCKGKKK=K3K6K9K'KK5KGKCKDKCKHKGK^KÇK‡K0K3K?KNKRKYKaK_KOKCK;KHKFKuKÉKÃKÃKÈK|K8K>K>K;KK>K>K?K=K>K?K>K>K>K?K?K>K>e]r‰(K6K9KK:K0KAKCKCKDK$KK KKK8KNKMKMKNKQKPKPKPKPKPKPKPKQKPKRKSKQKQKQKQKSKRKRKSKSKSKSKRKRKRKSKSKSKQKNKOKOKSKSKLKEKCKGKLKOKMKMKEKdK’KNK%K\K‹KŠK‰KŒK|KJKNKFK^KK‰K‰K‰K‰KKhK%KNKvKQKOKGKvKŒKKTK(KZK‹KŠK‰KK„KOKIKJKNK~KŒKKˆKyKeKOK>K5K1K0KFKHKIKAK$KKKKKLKiKfKuK…K…K_KGKMKIK;K;KFKQK\K]KƒK“KnK.KHK‰KpKGKIKHK{KŽKKfK,KSK‹KKŒKŒKŒKKaKCKHKCKQKˆKŽKŒKŽKKŽKŽKŽK„KAK=KyKjKCKGKGKK‘KŽK“KyK>KGKK‘KŽKKKŽK’KqKCKHKDKKK…KKŽKKKKŽKŽKK}K;KKDK?K>KLKYKZKSKMKJKDK;K6K4K5K9K?KCK@KAKBKAKCK9K"KHKLKKKJKFKBKIKNKKK›KÏKÇKÉKÉKÄK­K|KVKTKSKIK:K=KK>K:K;KIKLK K]K-K2K@K\KYKVKMK>K2K-K3KCKGKXK¶KÇKÂKÈK§KDK;K=K=K:K:K:K9K7K:KGKIKNK¨KÆKÃKÂKÃKnK@KNKPKUKVK]K]K\KZKWKXKJK>K?K@KBKEKFKCKCKDKCKDKCKBKBKBK?KK>K>K?K>K=K>K?K>K>K?K>K>K>K>e]rŠ(K/K9KK5K0K,K%KKKK KK%K*K&KK KK%K"K#K'K*K+K+K/K2K.K"K K"K'K7K8K8K:K9KK9K2KAKCKDKCK$KKK K +KK1KOKPKNKPKPKPKPKPKPKPKPKQKPKRKRKQKPKPKQKSKRKRKSKSKSKSKRKRKRKSKSKSKRKRKRKRKRKRKRKRKJKDKGKGK;KIKQKOKhKHK&KZKŠKŠK‰KŒK|KHKKKEK]KKŠKŠKŠK‰KKjK%KLKuKQKOKGKuKŒKŽKWK'KXKŠK‹K‰KŠK…KRKIKJKLK}KŽKˆK‹KKKKfK/K=KAKGKIKKK@KKKKK.KK5K=KIK/KlK–KuK/KDK…KwKGKJKEKuKKKrK0KIK†KŽKKKŒK‘KkKDKHKFKKKƒKŽKŒKŽKKKŽKKŒKKK7KpKuKCKHKDKwK’KKKƒKDKCKzK’KŽKKKŽK‘K|KGKGKDKEK|K’KŽKKKKKŽKK‰KHK7KoKKBKCK=KJKKK@KIKYK\KWKQKKKDK?K8K6K=KDK@KAKBKAKAK?KK@KMKKKJKHKCKCKKKHK€KÏKÈKÈKÉKÄK³KŒK\KSKQKMK=K:KKDKIKHKXK>K1K2K7KIKBK8K1K*K-K3K>KBKIKGK•KËKÁKÄKÄKdK5K=K=K:K9K9K9K7K8KBKJKCK‚KÇKÂKÀKÆKKHKHKHKJKIKGKSK]K\KXKWKQKDKDKCK0K'K8KBKGKDKDKEKCKBKBKBKAKAK?K?K=K9K9KK?K@K?K>K?K?K>K?K?K?K>e]r‹(K5KK5K3K.K'K!KKKKK#K(K#KKKK&K&K$K%K)K,K/K/K3K.K$K!K K"K,K>K;K9K:K9KKZKKŠKˆKŒK{KLKJKDKZKKŒKKŠK‰KŽKmK%KHKsKQKQKJKrKŒKKZK'KWKŠK‹K‰KŠK‡KTKHKKKKKzKKŒKŒKŒK‹K‘KqK(K@KxKXKGKHKMKSKK +KKKKKDKoK‚KrKQKHKIKIKKnK’KŽKKKŽK‘K…KLKDKDKAKsK“KKKKKKŽKK‘KUK7KbK‹KJKCK=K\K’KuKSKCKGKXKXKXKTKOKJKCK?KBKAKBKAKAKAKDK$K4KOKKKMKHKDK?KIKHKeKÆKÊKÈKÈKÇK¹K•K^KQKQKOKEK7K:K@KJKLKLKOKMKKÉK·K{KJKLKJKHKMKVK°KÉKÇK¹KWKHKEK?K=KGK[K¸KÇKÆK»KQK:KAK@KBKAKFKKK=K5K8K7KK@K=KKAKBKBKBKBK@K>K>K>K>K>K>K?K>K?K?K?K>e]rŒ(K9K=K=K9K+K KKKK4KAK7K7K0K*K&K#K!K*KAK9K1K/K*K"KKK KK!K+K'KKKK"K%K%K'K*K*K-K1K1K+K"K"K#K"K#K0K@K;K9K:K9K;K9K:K@KBK@K=K9K@KCKCKEK@K#KKKKKKKK)KK‚KaKEKIKJKbK=K4KK%KOKfKxK‡KjKJKJKIKHKIK;KGK9K/K5K2KhKŽK…K;K7KxK„KIKIKDKfKKŽKK7KKAK?K?K=KBKLKCK6K8K9K?KVKWKRKOKNKLKJKIKHK8K1K3K3K0K/K7KK@K@K@K@K@K@K@K@K@K?K>K?K>K?K>K=K>K>e]r(K:K8K8K-K!KKKK.K@K6K7K3K,K'KK!K(KK:K?KDKCKEK>K#KKK KKKK-K:K;K>KHKOKOKMKPKQKPKPKPKPKPKPKPKQKPKPKPKPKRKSKSKSKRKRKRKRKSKSKSKRKRKRKSKSKSKSKSKQKSKTKTKKKDKBKGKLKLKNKKKYKtK‹K€KKKKKAKYKK‹KKK‹KKrK$KEKuKOKMKDKpKKKcK$KNKŠKKŒKK‰KYKIKKKKKuKKŒKŒKKŒKKzK,K:K}KdKEKHKCK#KQK_K!K3K:K]KƒKoKQKZKSKIKHKKK7K0K$K0K,KK=KK>K>K>K>K>K@KBKBKBK?K>K?K>K>K?K?K?K?e]rŽ(K8K7K0K$KKKK'K?K6K8K3K,K'K!K K$K9K:K3K/K)K$KKK K KK'K%KKKK$K#K$K(K)K*K+K,K1K-K%K#K$K"K&KK K1KDK9K9K9K:K;K6K9KAKBK?K;K:K@KDKCKEKKFK>KvK•KKKŠKFK6K7K3K3K=KKK^KUKAKBKAKBKAKBK?K!KCKMKKKKKGKAKCKOKGK~KÎKÇKÈKÈKÄK²K’K`KQKQKMK?K7K7K?KIKHKIKJKQK¯K¿KKDK=K8K2K.KDK]K·KÅKÇK±KLKBKBKAKBKGKaK½KÄKÅK¹KYKUKfKjKjKfKPKIK>K:K5KzK¡K6K0K0K-K/K,K;KIKDK6K1K2K3K7K:K:K9K9K:K:K9K;KHKGKbKÀKÄKÃK½KYK9K?K?K?KKBKCKBKAKAKBK=K+K5K>K:K7K6K;KAKCKDKCKCKCKCKCKCKCKDKCKCKBKBKAKBKCKBKAKAKAKAKAKAKAKAKBKAKAKAKAKAK@K>K?K?K?K?K>K?K?K>K>K>K>K=K=e]r(K8K0K#KKKK%K>K;K6K6K/K*K"KK K5K=K3K1K+K#KKKK KK)K$KKKKK#K$K(K+K,K-K/K2K/K#K#K$K#K#KK KK;KBK9K9K9K:K;K6K=KCKAK?K:K=KDKDKCKEK;K$KKKKK K-K=KIKIKBK6K$KK4KKKRKOKPKPKPKPKPKPKPKPKPKPKQKRKRKRKRKRKRKRKSKRKQKRKSKRKRKRKRKRKRKRKTKRKRKRKSKRKSKQKJKBKDKIKKKMKJKKKHKGK@KXKŒKŒKŒKKŒKKvK(KAKuKQKMKHKlKKKkK%KHK…KKŒK‹KK^KJKLKGKmKKŒKKKŒKŽKƒK5K0KxKoKEKHKGK"KKIKJKeK~KyK^KfKgKcKKKGKIKJK>K1KK;K|KKKŽKKOK,KaKKYKJKFKSKŒKŒKKSK2KeKKŽKŽKŽKKŽKSKDKEK?KYKKKŽKKKKŽK‘KƒKCK@KKgKBKFKGK…K‘KK’K{KAKHKƒK‘K‘K‘KKŽK“KtKBKEKBKHKƒK”K‘K’K’K’K’K‘K“KŒKPK?KrKƒKDKEKKK>K=K=K=K;K9K:KDKJKDK€KÇKÀK¿KÆK KLK0KKKKKKKKKKK?KDKEK;K!K}KÇK½KÀK}KbKzKxKkK[KLKAKK>K>K=K@K?K>K?K>K>K=K=e]r(K1K%KKKKK8K>K8K7K/K(K"K K K2KK=K8K:K9K9K9K6K>KBKAKAK=KKHKFKYK¼KÃK¿KÀK¿KYKKKKKKKKKKKK1KEKDKAK4KœKÆK¾KÃKžKWKXKeKnKqKhKUKHKEKFKBKDKBKAK9K0K%K?KBKAK@K=K=K9K8K7K:KKAKAKAK@K>K?K?K>K>K?K>K?K=KK6K6K-K)K$KK K2K>K4K0K-K%KKKKKK,K*K KKK"K"K!K(K,K,K.K.K2K/K$K%K$K%K"K"K)K-K(K'K>K>K8K:K9K9K9K5K>KBKAK@KKWKKYK@KAKHKŽK’KK—KyKK;K9K7K:K=K?KAKDKBKAKAKAKBKBKAKAKAKAKAKAKAKAKAKAKAKAKBK@K?KAKAKBKAK?K?K>K?K?K>K>K?K>K=K=K=e]r’(K"KKKK/K=K1K4K.K(K$K KK,K=K3K0K.K)KKKKKK)K)K%KKKK$K%K(K)K,K/K0K4K.K#K$K'K#K$K*K-K-K,K'K)KEK@K9K:K9K:K9K5K?KAKBK?K:K=KAKCKCKEK7K#K"KKK K K K K KKKKKKKKKKK9KOKQKLKNKQKPKQKPKPKPKPKPKQKSKQKPKRKSKSKSKRKSKSKQKQKSKSKSKOKQKSKRKRKRKRKRKRKRKRKTKSKNKDKAK5K?KKKMKKKXKsKŠKKKK+K6KtKSKJKGKcKK‘KxK(K>K€KŽKŒKŒK‘KeKGKIKFKeKK‹KŒKKKŽKKBK+KiK{KIKIKFKbK5KPK\KEK;KK^KK‘K’K’K’K‘K‘K‘K”KuKDKPKKhK>KCK?KK•KK”K‡KIK?K=K:K9K8K9KdKTK?KBKAKAKAKBKK>K>KKAKAK>K>K>K?K?K?K>e]r“(KKKK)K=K1K,K0K+K$KKK'K;K2K*K*K'K!KK K KK(K)K"KKKK"K$K&K,K+K+K/K5K2K%K#K%K%K%K!KK"K!K KK.KHK=K9K:K9K:K8K6K?KAKAK?K:KK0KDKJKBK-K,KJKLKHKiKÓKêKîK¿KKKK’KvK4KDK‡KvKDKIKEKwK‘KKxK4KFKƒK‘KŽKKŽK“KuKEKHKFKDKvK’KKKKK’KK•KiK8KVK‡KNKFKCKZK’K‘K‘K”KeK;KYKK’K‘K’K‘K‘K“K`K@KEK>KRKK’K‘K’K’K“K’K‘K“KKKKHKKvK=KDK=KrK—KK’K’KUK@KCK@K=K:K@KgK`KAKAKAKBKAK@KAK$K8KKKHKIKHKDKAKIKIKaKÀKÈKÇKÆKÆKÄKÌK–KIKMKNKCK9K9KKBKEKzK‹KCKKGKAKrKK.K2K0K6K=K=K=KK-K@KQK^KcK]KVKWK[KYKVKPKKKGKAKCKAKBKBKAKAKAK@K@KAKAK?K?K=K8K7K5K9K=K@KCKDKBKAKAKAKBKAKAKAKAKAKAKAKBKAK@K@K@K@K@K@K?K>KAKAK>K>K>K>K>K?K>e]r”(KKK'KK;K2KAKDKDKEK5K%K"KKKKKK KKKKK +KKKKKKKKKK1KIKOKNKLKPKQKPKQKSKSKSKSKSKQKPKPKQKSKQKPKQKPKPKPKPKPKPKRKSKRKRKRKRKRKSKRKOKRKSKQKQKOKEK@KBKHKLKKKIKOKeKrK,K3KrKWKHKFK]KŽKK}K)K3KzK‘KŒKŒK‘KmKIKIKGK]KKKKKKŽK’KNK&K`K€KKKHKLK6K%K*K(K&K0K9K*K/K)K!KaK_KIKJK[K¾KÕKëKÊKŒKKŽK’K{K3K@K‚K|KFKJKDKqK‘K‘KK:K@KyK‘KŽKŽKŽK’KKGKFKGKCKnK”K‘K’K’K’K’K‘K—KvK:KLK†KWKDKEKQKK’K‘K–KoK?KQKˆK“K‘K’K’K‘K•KnK@KEK@KKK…K“K‘K’K’K”K“K‘K’KŒKQKBKsK„KDKDKKEKCK@K=K@KNKXKDKAKBKAKAK?KAK+K.KLKHKHKIKFK?KGKLKPK¬KÊKÄKÆKÆKÅKÈK±KPKIKOKJK:K9K;K@KCKKKRKLK_KŠKLK:KNK^K\KQKSKKKmKÆKÄKÈKKJK\KoK„KˆKOKiKÃKÄKÅK½K˜K•KK•KKKbKEK—KÉKÁKÊKK1KJK9K:K9K:K@KGKGK8K3K5K4K7KK@K?KK>K>K>K>K>K>K>KAKAK>K>K>K>K>K>K?e]r•(KK!K;K3K(K,K*K%KKK!K3K+KKKKKKKK K"K)K"KK KKK#K&K+K*K+K.K4K5K(K$K%K&K&KKK KKKKKK0KIK=K9K:K9K;K.K)KAKAKBK=K8K+K@KDKCKCK2K'K$K KKKKK K K +K K K K KKKKKKKKKKK;KNKPKMKNKNKNKPKRKQKQKQKQKQKRKRKSKQKPKPKQKRKRKRKRKRKRKSKRKRKRKRKRKRKSKRKQKQKQKQKQKSKNKEKAKEKGKKKLKIKNK>K:KtKYKGKFKZKŽKK€K.K1KvK’KKŒK‘KpKHKJKGK\KŽKKŽKKŽKŽK“KRK$K\K…KMKGKJK6KK&K(K&K!K%K/K,K"K!KPK[KJKLKTK´KÉKÛKÊKKKK’KK6K:K|K…KHKJKDKiK‘KK‰KBK9KsK‘KŽK‘KK‘K„KJKFKFKAKcK’K‘K‘K’K’K’K‘K•K€K?KEK‚KbKBKFKJK‰K“KK•K|K@KHKK”K‘K’K’K‘K•KyKCKGKCKEK|K”K‘K’K’K’K’K‘K’K“K^KAKhKŽKMKBK?KRK“K“K“K–KrK@KFKEKCK?K>K@KGKCKAKBKAKAKAKCK5K$KKKHKHKIKFK?KDKKKGK‘KÍKÄKÆKÅKÄKÅK®KVKEKLKLKKK>K>K=K=K>K;K?KHKGK9K.K0K0K/K9K>KKOK^K\KUKOKQKTKQKAK?K:K8K;KAKAKAKAKAKAKAK@K?K>K?K?K?KK@KAKAKAK>K>K>K>K>K>K>e]r–(KK6K6K%K&K'K&K KKK/K.KKKKKK K K +KK)K"KKKKK!K&K*K*K+K/K1K3K)K&K&K%K&K#KKKKKK KKK8KEK:K8K:K9KKXKKK’K’K’K’K‘K”KˆKFKCK|KoKBKHKEK}K•KK”K†KGKDKwK•K‘K’K’K‘K“K„KHKGKDK@KqK•K‘K’K’K’K’K’KK–KlKBK[K“KZK?KCKEKŠK•K“K”KKFKFKGKBK@K?K?KCKAKBKBKBKBKAKCKK>K=KKEKGKAK0K/K0K/K3K=K=K=K=K=K=K:K9K8K7KCKHKCK—KÇK¿K¿KÇK€KKKKKKKKKKKKKBKHKDKjKÀK¿K¾K¾KÀKaKK#KKKK!K)K9KLK[K_KYKOKGKBKCKAKK>K?K=K;K;K;K:K5K2K7K>K?KBKCKBK?KAKAKAKBKBKBKAK>K?K>K@KBKAKAK>K>K>K>K>K>K>e]r—(K0K9K K!K#K"KKKK.K0KKKKKK KK KK,K%KKKK!K#K$K'K*K+K.K0K4K)K$K'K%K&K"KKKKKKKKKK;KEK:K:K:K9KK6K/KBKDKCK?K/K)K&K%KKKKKK K K +K K K KK K KKKKKKKKKK%KK>KK>K>K?K;K;K=K9K@KIKCKmKÂK¿K½KÂK±K0KKKKKKKKKKKK7KIKFKJK¦KÄK½K½KÃK›K$K"K KKKKKK!K3KFKZKaKZKNK@KAKCK9KKKK(K;KAK>KBKBKBKAKAKAK=K?K>KK>K>K@KBK?K?K>K>K>K>K>K>K>e]r˜(K:K KKKKKKK(K2KKKKKK +K KKK,K(KKKK!K$K%K%K'K+K.K2K0K(K%K&K%K&K#KKKKKKKKKKKAKEK:K:K:K9KK>K6K0KCKDKCK?K/K)K'K$K"KKKKK K K +K +K +K K K K K K K K KKKK K%KKK K@KOKMKOKQKPKQKRKRKPKPKPKPKPKPKPKPKQKQKRKRKQKQKRKRKSKRKRKQKQKRKRKPKQKQKPKPKQKPKOKQKRKLKEK@KBKGKGKIKKKJKEKSK‰K’KŠK4K*KlK“KŽKŽK’KzKJKLKHKRK‰KKŽKKKŽK”KcK"KJKPK@KIKJK:KK!KK K#K(K)K"K%KžKåKzKHKMKJK¬K×KÙKÎKK‘K’KKKKK2KcK’KWKFKCKTKKŽK’KZK4K_KKK’K‘KŽK’K_KCKGKCKOK‡K“K‘K’K’K’K‘K‘K“KYK9KfK„KGKHK@KgK–KK‘K“KXK@KfK”K‘K’K’K‘K“K“KZKAKCK=KXKK’K“K”K”K”K”K’K•K„KHKIK‚K|K@KCK@KoK™K“K“K•KaKCKGKBKAKVK]KLKIKAKAKBKAKAKAKDK(K/KKKHKIKFKCK?KFKJKNK«KÊKÅK·KvKAK;K=KFKEKIKIKK>K=KK@K?K=K=K>K>K=K:K9K5K4K7K:K?KAKBKAK@KAK@K>K?K?KAKBK?K>K?K>K>K>K>K>K>e]r™(K'KKKKKKK!K-KKKKK K KKKK(K&KKKK"K#K&K)K)K)K-K/K/K+K%K&K&K&K#KKKKKKKKKKK"KBKCK8K:K9K9K;K%K2K@K?K>KK9K:K7KDKŠKœKyKIK}KcK8KQK’K‘K—KwKIKMKŸKÊKÂKÃK£K—K™K—KœKvKHK™KÉKÁKÆK®K˜K™K™K˜K˜KˆKMKYK´KÅKÁKÊKeK,KBK@KAKBK@KAKHKBK7KKBKDKCKBKBKBKBKEKGKEK2K-K-K0K5K>K@KBK@K>K>K?K=K:K:KBKEKDK‚KÄK¼K¾K½KPKKKKKKKKKKKKK;KHKCKTK¬KÁK¾K¼KÂK†K"K!KKKKKKKKKKK%K4K@KAKAKCKK?K>K?K=K;KK>K@KBKBKAK?K>K?K>K>K>K>K>K>e]rš(KKKKKKKK/KKKKK K KKKK&K'K!KKK"K!K%K'K)K)K+K1K2K(K%K'K%K'K"KKKKKKKKKKKKKEKCK8K:K;K:K;K#K4KAK@K>K;K1K4KEKCKDK@K-K(K%K#K$K KKKK K K K KK K K +K K K K KKKK K"KKKKKKKK;KPKRKQKQKPKRKQKPKPKPKPKPKPKQKRKQKPKQKRKRKRKSKQKPKQKQKPKQKQKQKQKSKTKQKQKRKQKPKQKRKRKQKLKDKAK7K7KGKJKHKNK`K;K'KgK’KKŽK’KKHKJKFKMK…K‘KŽKKKK”KqK&K=K)K;KMKFKCKKKK-K,K!K(K'K!K9KºKÐKRKHKIKHK›KâKÐK‘K’K’KŽK”KaK-KVKKdKEKGKJK„KK•KnK4KPK‰K“K‘K’K‘K–KuKDKFKCKDKxK–K‘K’K’K’K’K‘K—KoK:KSK‹KWKCKCKRK’K’K’K–KrK?KUKŒK”K’K’K’K’K–KqKAKEK>KDKƒK–K“K”K”K”K”K“K“K•K]K@KeK“KPKAK@KOK”K•K’K˜KKHKDKDKTK^KZKHKLKMK@KBKBKAK@K@K;K KDKIKHKGKDK@KAKIKEKjKKpKGKKK>K>K?K>K=K=K;K8K5K4K5K9KK?K@K@KAKAK?K>K>K>K>K>K>K>K>e]r›(KKKKKKK)KKKKK KKKKK#K%K KKKK!K#K'K)K*K*K0K1K'K#K'K&K&K K KK K K K KKKKKKK KHKCK8K:K9K:K:K"K6KBKBK>K=K1K6KEKCKCK=K*K&K#K$K$K#KKKK K K K K KKKKKKKKKKKK#KKKKKKKKKKKK‡KbKAKEKJKŠK”K“K—K}KCKNK…K•K“K”K”K“K—K}KCKFK@K@KwK•K’K”K”K”K”K“K“K—KmKCKXK’K^K>KBKBK‹K–K’K•KKSKHKGK\K^K]K\K^KPKAKBKBK@K>K>K@K"KKFKHKKKPKAK:K=KKzKÇKÁKÂKeKAKHKFKDKDKDKDKDKGKGK?K/K0K0K/K9KBKBKBKBKBKBK@K?K:K&K=KHKEK”KÁKÁK‰K.K"KKKKKKKKKKKKK>KFKBK_K¶K¼K¾K½KÅK|KKKKKKKKKKKKKKK.KAKAKCK:K"K)K—K¿K·K®KvKqKlKbKWKLKDKBKAKAK?K>K?K?K>K?K?K=KK?K?K>K>K>K>K>e]rœ(K K K KKK$KK K KK K KKK +KK!KKKKK K$K(K)K*K,K-K0K'K"K%K&K%K&KKKK!K"K!K"K%K%K&K(K(K%K.KIKBK9K9K9K8K7K!K9KBKAK>KKEKBK€K–K’K•K†KHKFK{K–K“K”K”K“K–K‰KIKDKAK?KlK–K“K“K”K”K”K”K’K–KzKEKNKKnK;KBK>K|K˜K’K•K”K^KGKCKLKYK^K_K_KNKAK@KBKAKAK>KAK&K0KLKHKHKFKBK>KBKHKGK=K;KK>K=K=K?K?K>K>K>K6K1K"K1K=K8K6K4K5K6K9K?KAK>K=K=K>K>K?K?K>e]r(K K K KK KKKK +KKKKKKKKKKK!K!K#K'K)K)K+K.K.K'K#K(K&K&K#K'K+K-K+K+K-K)K(K*K*K)K*K'K"K5KKKAK9K:K:K9K5KKK;K1K:KCKCKBK9K*K'K%K!K K KKKK K K K K +K +K +K K K K KKKKKK"K9KBKLKMKUKWKTKUKTKRKIKMKOKMKOKPKPKPKPKPKPKPKPKPKPKRKSKRKSKPKOKQKRKRKSKRKRKRKRKRKRKSKRKPKQKPKPKPKPKQKQKPKPKRKRKOKHKAKAKEKGKHKKKGKSKqKŒK†KMKHKHKHKzK’K‘K’K’K‘K•K‚K+K1KyKiKCKGKHK6K;K/K*K*K,K‘KÏKÚKâKªK€K^KJKKKRKSKNK±KœKK’K‘K–KzK4KBK…K{KEKJKAKqK–K’K†KAK>KuK•K‘K’K‘K“KŠKOKFKEK?K\K‘K’K“K”K”K“K‘K“KŠKKK>KvKxK@KEK@KuK–K’K“KKQKBKnK—K“K”K”K“K”K’KRKAKDKKIKVK\K8K=KCKAKBKBK?KAK0K&KLKIKIKFKBK=KAKGKHK@K;K=K=KK>K?K>K@K1K+K)K&KK?K>K>K>K>e]rž(K K KKKKKKKKKKKKKKKKKKK"K)K'K&K*K.K/K%K$K'K'K'K'K#K"K K K$K#K$K#K#K$K$K%K#K!KK5KLK>K9K:K:K;K3K!K>K?K@K?K;K.K=KEKCKDK9K+K*K&KKKK KKKKK K K +KKK K +K +K K K K K KKAKSKUKXKYKZK[K[KXK[KXKVKWKTKLKIKNKPKPKQKQKPKPKPKPKPKRKRKQKQKPKPKPKQKQKQKQKQKQKQKQKQKQKQKPKPKPKQKPKOKRKSKQKPKQKQKQKQKNKFKAKAKDKHKGKGKHKZKnKLKGKHKDKuK”KK’K’KKK†K0K.KxKtKFKIKCKtK„K6K)K/K/K‚KÃKÕKÝKÒK‘KXKJKGKdKªKZKKªKK’K‘K”KƒK8K?KK‚KFKKKAKjK–K‘KKGK:KnK“K“K“K“K”K‘KUKFKEK@KVKK•K”K“K”K“K“K’K‘KUK?KmKKDKEK?KlK˜K’K”K”K]K@KdK–K“K”K”K“K“K•K\KCKGKK=K:K/K>K@K>K@KBKAKCK;K!KEKIKJKHKDKAKEKHKHKCK:K:K:K:K:K8K7K=KBKAKIKAK8K:K9K;KqK˜K”KUKeKƒKHKK„K¢K1K-K-K&K(K2K-K KKKKKKKKK3KFKDKMKªKÄK¿K½KÃK£K&KKKKKKKKKKKKKKK@KCKEKK@K=K5K*K*K=K=KK?K?K>e]rŸ(KK KKK KKKKKKKKKKKK KKK K#K)K(K)K,K.K%K K&K%K%K!KKKKKKKKKKKKKKKKK5KIK:K9K9K9K;K2K#K>K>K?K>K;K-K=KEKCKDK8K+K*K&K KKKKKKKK K K +KKK +K K K K K KK KKIKXK[K\K[K]K_K_K_KcK_KVKMKKKKFKHKEK@KK=K=K=K;K9K;K:K9K8K3K2K1K5K:K>K?e]r (K KKKKKKKKKKKKKKK KKK!K%K&K(K)K,K0K'K!K'K&K'K KK K KKKKKKKKKKKKKKKK>KKDKCKEK8K,K*K&K!K!K KKKKK K K K K K +K +K K K K KKKKKKKYKZKZK\K`KbK`KVKGK6K&KKKKKK(KDKOKOKPKPKPKPKPKPKPKPKQKQKQKQKPKPKPKQKPKPKPKPKPKPKPKPKPKPKPKPKQKPKPKPKPKPKPKQKPKMKKKNKPKKKDK@KDKJKJKIKIKIKGKCKsK—KK‘K‘K‘K’KŽK7K)KnK~KEKJKDKpK—KQK+K1K2KDKžKÓKÞKÓKËK{KHKIKXKÓKÐK¤K¹K¤KK’K’K‹KAK5KpKKLKEKFKZK“K‘K“KYK2K_K“K”K“K”K“K—KdKCKEK@KIKK–K“K”K”K”K”K’K˜KjK;KXKŽKSKBKAKRK’K”K“KšKrK?KRKŒK•K“K“K“K’KšKvKAKHK?KAK{K˜K“K—K—K—K—K—K”K–KlKCKWK’K_K>KBKBK‡K™K–K—K”KVKDKIKHKHKGKFKEKBK?KBKAKBK?K>K@K"K2KKKHKHKEKAK9KCKIKFK=K7K:K:K:K9K7K:KAKCKEKIKKBK>K>K>K?K?K=K;K;K;K;K;K9K8K6K4K3K5K7e]r¡(KKK KKKKKKKK KKKKKKKK$K'K'K'K*K0K*K$K'K'K%K"KKKKKKKKKKKKKKKKKKKAKHK:K9K:K;KK>KKCKBKDK6K+K*K&KK KKK KKK K K K K K +K +K K K KKKKKKQK[K]K]KUKEK3K&KKKKKKKKKKKK2KLKSKQKQKQKPKPKPKPKPKOKNKPKPKQKQKPKQKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKQKQKMKOKQKRKRKJKAK?KEKHKEK?KGKGK\K†K“K’K‘K’K‘K’KKNKŠK\KAKCKIKŒK•K’K˜KKDKKK‚K–K“K•K•K”K™K‚KEKGKCK@KpK˜K”K–K–K–K–K—K•K˜KzKGKLKKqK=KCK:KyKœK•K–K˜KcKK@K7K8KIKHKHKEKBK>KBKHKFK?K8K9K9K:K9K7K:KAKEKCKHK=K6K7K;KEKK›KKNKsK‡KGK>K†KšKšKKPKGKxKÇKÂKÅK´K˜KšKšKšK“KTKaKÁKÄKÅK·KwK—KšK›K–KKrKGKyKÆKÁKÁK¾K>KKGKFKGKFKGKJKBKsKÆK¿K¾KÆKxKAKHKEKCKBKDKEKEKFKHKEK4K2K5K2KGKMKAKCK@KAK8K(K+K3K8K?KGKFK=K.K-K.K-K1KEKGKDKDKFK*KKKKKKK*KDKEKBK‰KÄK½K½K½K¹K@KKKKKKKKKKK KKKK3KDKBK?KkK»K¹K¹K¸K½K™KK +KK(K9KKKZK]KVKRKSKWK^K`K^K[KTKMKBK@KAK@K>K>K>K?K?K=K>K>KK>KKRKQKPKPKQKQKQKPKMKKKNKPKQKQKNKQKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKQKQKPKPKPKQKQKNKHK>K@K:K4KEKIKGKPKjK‰K•K“KK”KCK"KdK†KHKJKBKbK˜KwK3K5K2K6KƒK³KÙKÝKÙKƒKGKPKRKÀKòKÙKÉK¼K‘K•K“K—KSK0K_K‘KZKCKCKNK‹K’K–KlK2KOKK•K“K”K“K˜KxKBKHKFKBKrK˜K“K”K”K”K”K“K—K€KBKEKƒKgK?KDKCK„K–K’K–KŠKLKEKwK—K”K—K—K—K˜KKMKEKEK>KcK—K—K–K–K–K–K–K–K™K‡KKKIK€KK@KDK6KdKšK”K–KšKvKBKJKuKeKNKHKFKHKDKAKAKBK?K>K>KAK@KGKIKHKEKBK>K;KEKGKCK7K7K8K:K9K7K8K>KDKCKGKBK8K8K;KAKoKšK˜K\K_K‘KSK8KpK™K”K›KdKDK[K¸KÅKÄK½KK›K›K˜KœKfKLK©KÈKÂKÄK‡K‘K›KœK˜K˜K„KMKYK¸KÂK¾KÉKdKK=KHKFKFKGKIKFKSK³KÄK¿KÆKžKEKGKEKCKEKDKCKFKGKEKHK:K0K5K.K}K|K>KEKDKAKBKCK@K>K=KK=KK>K=K;K9K:K:K9K:e]r£(K KKKKKKKK KKKK KKKK!K#K%K'K)K.K'K#K'K%K&K"KKKKKKKKKKKKKKKKKKKKKGKEK8K9K:K:K;K$K.KAK>K>KK}KuKAKEK@KyK˜K’K”K’KSK@KkK—K•K–K–K—K•K“KUKEKEKK>K@K?K>K>K@K=KCKIKGKFKDK?K;KEKGKDK7K7K8K8K8K8K7K=KCKDKHKGK:K9K:K>K^K—KšKnKOKKfK9KZK–K‘KžKyKHKMKŸKÉKÂKÃK¥K™K›KœKKMKGK†KÈKÂKÆK«K•KœK™K˜K—KŒKXKJKœKÇK½KÈK˜KK/KJKFKFKGKIKJKGK‘KÈK¿KÁKºKZKCKGKEKFK=K8KDKGKEKHKAK3K4K7K¡K¤KBKEKGKCKAK@K=K;KK&KKKKKKK1KBKBKEK˜KÁK»K½KÀK°K2KKKKKK KKKKKKKKK8KDKCK?KrK¼K¸KºK·K¾K“KKK KKK +KK.K@KRKZK]KVKRKTKWK\KZKBK:K8K8K;K@K?K=K=K>K>K=KK>KKrKKBKEK?KlK™K’K“K–K]KAKaK•K•K–K—K—K“K—KcK@KFK=KNKˆK˜K–K—K—K—K–K–K–K–K`KAKcK–KSK>K?KHK’K—K–K™K“KSKBKnK™K—K™KKsKRK@K@K>K?K?K>K?K?KBKJKGKGKEKBK=KCKGKFKKOKKœK…KIKK„KIKFKK˜K›KŒKQKEKKÇKÂKÄK±KšKœKžKsK'KGKhK¿K¿KÂK¾KžK™KK›K—K“KiKFKyKÈK¿KÂK½K4KKGKGKFKGKIKJKFKlKÃKÀK¿KÆKKAKIKFKFKDK>KEKGKFKGKEK9K0KPK¹K½KbKBKGKBK@K>K@KKDKDK@K+K,K.K.K.K?KHKFKFKDK2KKKKKKKK?KEKAKnK¾K»K¾K¾KÅKkKKK KKKKKKKKKKKK!KCKBKAKKK¥K½K¹KºK¹K»KGKKKKKKKKK(K4KDKVK^KYKOKNKWKJK;K=K8K8K5K-K7K?KAK>KK>KK=KyK–K”K–K”K”KKNKBKDKAKVK‘K—K–K–K–K–K–K–K–KXK=KhK†KDKBK?K`K—K”K’K˜KhKAKVKK—K–K—K—K•K›KnK?KEK?KGKK™K–K—K—K—K–K—K•K™KnKAKXK•KaK=K@K>K†KšK•K–K™K^K@K_K—K•K–K˜KK…KCK?KBKAKAK?K?K>KBKIKGKGKGKCK>KAKIKFK?K7K8K8K7K8K8K7K?KCKBKGK?K7K8KKyK¿K¹K¹K¸K¾KK KKKKKKKK +KgKzKMKBKPK]KZKPKIK=K>K?K=K:K"KK$K0KK>K=K3K5KCKAKDK@K-K+K+K"KKKKKKKKKKK K K K K +K K K K K K K KKK KKKKKKKKKKKKKKKKKKKKKKKKK.KIKRKNKOKQKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKPKQKPKPKPKQKPKPKPKPKPKPKQKPKOKOKQKPKPKPKPKPKQKNKGK>K=KBKIKIKHKGKFK@KNKŒKYKFKEKRKK•K†K;K3K-K}KËKÊKßKèKÖKZKHKHK~KÙKßKìKÏKšK“K“K—KvK2KCK‹KyKAKHKBKqK˜K“KKEK8KpK˜K”K—K•K”K”KVKAKCKBKOKŠK™K–K—K—K—K–K–KšKcK:K]KKNKDK@KTK–K•K“K™KtKBKRK‹K—K–K—K—K–K›KyKBKEKAKAKtKšK–K—K—K—K–K—K•K›K}KFKMKKrK;KBK9KuK›K•K–K›KoKAKTK’K˜K–K–K˜K•KPK>KBKAKAK?K?K=K@KFKFKGKGKDK?K>KEKEK@K7K7K8K7K8K7K7K:K?KAKGKEK8K7K;KEKkK˜K›KiKYKªKˆKJKbKK˜KŸKpKFKPK©KÅKÀKÂKšKK KYKK6KKKŒKÆK¿KÃKµK™KœKœK›K›K˜K\KJKœKÆK¾KÇKšKwKsKBKGKGKGKDKGKGKKÈK¿KÃKÀKcKBKHKDKCKDKDKCKFKFKEKBK7K–KÃKÀK®KQKAKDKDKBK?K?K;K:K8K?KCKCK>K*K*K-K-K/KEKGKEKHK6KKKKKKK KKAKEK>K{KÁK¼K¼K¿KšKKKKKKKKKKKKKKKK&KCKCKBKRKªK¼K¹K¹K¹K¹K>KK KKKKK KgK¹K½K®K‰K]KDKIKZK\KJK=K?K=K=K6KKKKK.KAK=KK>K=e]r§(KKKKKKKKKK KKKKK$K(K,K0K+K%K&K&K&K KKK KKKKKKKKKKKK K K K KK"K K"KK5KMK>K>K;K9K:K8K"K8KAK?K=K>K1K6KCKAKDK?K/K,K*K"KKKKKKKKKK K K K K K K K K +K K K K K K K K K KKKKKKKKKKKKKKKKKKKKK KKKK:KPKSKPKPKQKQKQKPKPKPKPKPKPKPKPKPKPKPKPKPKQKOKQKOKQKPKPKPKPKPKPKPKPKPKPKPKPKPKPKQKQKOKMKOKNKGK@KCKFKHKHKFKIKIKbKPKEKDKMKŽK—K‹K?K4K0KMK^KPKKÈKÞKeKFKHKrKÔKÍKÒKÊK—K“K“K—K€K2K>K…K€KCKHKBKgK˜K“K“KLK3KiK—K•K–K—K–K˜KbK@KAK@KKK„K™K–K—K—K—K—K•KšKpK:KRKKXKBKBKJKK˜K–K™KKDKLK„K™K–K–K–K–K™K„KEKDKDK?KjKšK–K–K–K–K–K–K–K™KŠKLKHK€KƒK?KCK;KdKœK•K—KœK}KGKKK…KšK—K™K˜K›K`KK>K?K>K>KFKGKFKGKFKCKK=KKGKQKEK?K>K>K?K(KKKKKwKŠKSK>KAK?e]r¨(KKKKKKKKKKKKKK#K'K*K1K.K#K%K&K&K&K$K#K$K"KKKKKKKKKKKKKKKKKKKKK6KKKOKXKGK;K:K4K#KK4K5KK +KKKKKKŒKcK@KFKCK†K™K•K˜K‹KKKEK{K™K–K–K–K–K˜KKKKBKDK?K^K”K—K—K—K—K—K—K—K˜K’KXKFKpK’KIK@K?KVK—K—K—K›KŒKMKEKwKK˜K˜K˜KœKrK=KBK@K@K?K?K>K?KCKGKGKGKFKBKK@KGKKK=K@K@K?K7KKKK$K•K»K™KYKKKBe]r©(KKKKKKKKKKKKK K&K*K-K+K$K&K&K&K#KKK"K$K!K#K'K'K'K$K#KKK KKKKKKKK KK K +K9KNKmKsKSK;K:K3K$K>K@K>K=K:K/K8KAKBKBK=K-K*K,KK KKK KKKKKKKK K K KKK K K K +K +K +K K K K K KKKKKKK K K K K K K +K K K +K +KK KKKKK%KKKK0KKKQKMKNKQKQKQKPKPKQKQKQKQKPKPKPKQKOKMKOKQKPKPKPKQKQKQKPKPKPKPKPKPKPKPKPKPKQKQKQKQKQKNKNKQKMKCK=K@KGKFKGKHKGKEKGK€K˜KK>K2K2KKK +KK0K/KCKJKGKWKŸKÂKâK¼KeKŒK¢K“KŽK>K2KqKŽKKKDK@KZK•K’K›K`K4KZK”K—K–K—K–K›KtKBKEKDKEKuK™K–K—K—K—K—K–KšKƒKDKDKƒKpK?KFK?K{K›K•K˜K’KRKAKnK™K–K–K–K–K—K–KVK?KDK>KRKŽK˜K—K™K™K™K™K˜K–K™KbKCKbK•KUK=KAKHKK›K˜K™K”KYKBKkKœK˜K˜K˜KœKƒKBKBKBKAK?K>K?K?K@KHKIKGKFKBKKFKGK=K5K:K9K7K8K8K5K:K?K>KFKAK7K8K=KHKxK›KšK\KjK¿KŸKcKsK¡KšK›KfKDKVK³KÃKÀK¾K¡KŽK+KKK7KLK“KÇK¿KÅK©K‘KKœK˜K™KRKAKLK›KÈK¾KÇKšKTKeKFKEKGKEKFKKKDK†KÇK¿KÀK¾KiKCKHKGKHKDKDKDKCKDKFKVK´KÄK¿KÀK·KZK@KDKBKAK>K=KKCKDK?K-K-K-K,K1K?KDKCKCKEK5K"KKKK K KK>KCK@K\K¶K½K°KIK)KKKKKKKKKKKKKKKKK>K@KBK>K…K¾K¸K¹K·K½K}K +K K +K-KGKBKCK”K¿K¸KºKºK·K½KžKLKXKŒKQK?KAK>K?K+KKK5K§K³K±KKbKZe]rª(KKKKKKKKKKKKK%K)K-K,K$K&K%K&K$KKKKKKKKKK K!K"K!K#K'K(K&K&K KKK K +K +KK K=KTKŒKKaK=K;K1K"K>K@K?KKEKIKHKGKwK½K¶K¨KOKZK—K•K’KDK/KjK”KOKCKAKSK”K•KšKkK3KRKK—K–K—K–K™K}KCKDKBKAKkK™K–K—K—K—K—K–K˜KKJK>KzK}K@KFK>KnKšK•K–K˜K\K?KdK—K–K–K—K˜K—KšKdK@KFKAKJK†KšK—K˜K˜K™K™K˜K—KœKpKCKVK•KdKKBKAK?K>K>K@K>KDKHKGKEKDK=KK=KKKK>K?K9KAKHKGKDKEK?K:KEKGKAK6K7K7K8K8K5K7K9KK=KKCK>KhKÂK‚K)K*K,KKKKKKKKKKKKKKKKK>K?K?KAK‹K¾K¹K¹K·KÂKsKKKK!KFKDKDK•KÂK·KºKºK¸K¼K™KFK_K®KXK?KCK@K>K.KKVK¶K´K´K²K€Kie]r¬(KKKKKKKKKKKK&K)K)K&K%K%K'K#KK KKKKKKKKKKKKKKKKKKKKKK K K K KKCKfKÀK®KpK:K9K,K)K@K?K?K;K7K-K>KDKCKCK8K+K,K+KKKKK K KKKKKKK K K KKKKKKKKKKKKKKKKKKK +K K K +K K KK +K K +K K K KKKKKK#KKKKKKKKK3KLKNKPKQKPKOKMKNKQKQKPKQKPKNKQKPKQKQKQKQKPKPKPKPKPKPKQKQKQKPKPKPKPKPKQKOKMKPKQKQKPKPKPKPKOKNKGKKDKFKHKDKEK?KDKKKKK&K;KDKHKFKFKxKnKxK‰K–K•KK•K›KWK,KYK•K]KCKFKFK‰K˜K™K€K6KDK‚K™K–K—K–K˜KKLKDKCK?KUK•K—K–K—K—K–K–K–K™K]K:KdKKKKFKBKVK—K˜K–K›KvKBKSKK›K˜K˜K™K˜K›K|K@KEKDKBKmK›K™K˜K™K™K™K™K˜K›KŠKJKFK~K…K?KCK=K`KK—K˜KžK†KJKIK€KœK˜K˜K—KKlKK?K>K=KBKEKFKFKDK@K:K@KFKCK9K7K8K7K7K7K5K5K:KK7K7KK>K>K=KKKKKKK:KHKEKDKFKbKbKQKvKªK«K”KœK`K+KPK”KdKBKFKDK„K™K˜KŠK;KK?K?K>K?K>K>K>K?KFKFKFKDK@K;K?KEKEK?K7K8K7K7K7K5K5K8K;KK?K?K=K;K9K9K@KCKEK:K-K.K.K/K4KAKEKDKFK@K-K&KKKKK K K@KCK?KgKMK&K,K)K'KKKKKKKKKKKKKKKKK?KBKDKBK“K¾K¸KºK¶KÀKmKKKKKBKAKBK,KvK¶K°K³K³K°Kye]r®(KKKKKKKKKKK"K+K&K%K%K&K"KKKKKKKKKKKKKKKKKKKKKKKKK KKKK K!KHK‰KÛK±KbK7K9K&K.KDKAKK?KK=KDKDKBK6K5K8K7K6K8K7K6K;KK;KK-K*K+K)K*KK KKKKKKKKKKKKKKK5KDKBK=KhK¸K¸KºK¹K½K¨K!KKK%KEKDK@KdKºK»K¶K¸KºK¹K·KjKDKžKŽK=KBKBKAKKEKRKcK‰KžKtK*KBKKwK>KDK=KqK›K—K—KIK3KiK™K–K—K—K–KœKfK?KFKBKDK}KšK–K˜K™K™K˜K–KœK~K@KHKˆKnK>KEK@K}KžK—K™K”KSKDKpK›K˜K˜K™K˜K˜KœK\K@KDK?KMKŒKK˜K™K˜K™K™K˜K—KKrKAKUK—KiK=KDKK=K=KK‰KŸK›K˜KWKEKdK¾KÀKÀKÂKPK KKKK9KMKžKÆK¿KÆKŠKKK;K@KDKDKCKEKDK@K6K?KBKBK2KK3KFKPK…K¡K}K—K}K/K;K…KK?KEK=KiK›K”KšKQK0KaK˜K–K˜K™K˜KKoK>KGKGKBKuK›K˜K™K™K™K˜K˜K›KˆKEKCKKzK?KEKK>K*K;KHKFKGKEKAK;KAKCKDK9K6K8K7K7K8K7K7K9K9K=KDK?K8K7K;KJK‚KKœKZKZKlK@K8KqK¡KšKŸKjKHKSKªKÄK¾KÈKfK KKKK*KFK}KÂK¾KÃK²K5K KKKKK8KJKxKÃKÀK¿K¼K˜KuKDKEKGKGKGKHKHKZK·KÃK¿KÆK KHKDKCKDKCK9K9KBKBKHKDKxKÀK½K½KÃK›K@K@K>KKAK4KKK+KK`KšK”KœK[K.KYK•K˜K˜K™K—KKyKAKEKDK?KlKšK˜K˜K™K™K™K˜KšK“KMK>KvK‡KAKEK=KeKK˜K—KKkK?KYK’K™K˜K˜K˜K—KKwK@KEK@KBKsKKšK™K˜KšKšK™K˜K›K‹KLKGK{K‹KBKBKK?K=K?K&K.KHKGKGKDKAK;K>KEKHK=K3K6K7K8K6K5K5K7K:K:KAKCK9K7K9KBKpKžKžKpKGKJK=K8KYKŸKœK¢KKIKFKŽKÆK¾KÊK‚KKKKKKDKaK¹KÁKÀKÁKCKK)KKKKDKMKWK·KÃK½KÂKŸKZKCKGKEKEKGKGKIKHK˜KÄK½KÀK½K^KBKFKDKCK;K;KDKCKGKGKVK´KÀK½K¿KºK[K=KAK=K=K=KKAKMK•K™K›KœK˜KYK?KhKœK›K›K›KŸKŠKCKAK?K>K?K=K@K+KKGKHKGKCKAK;KKBK=K=K=KK[K—KœK›K›K›K›K›K›K›KKdKDK`KšK\KK@K>K?K=K>K5KKCKIKFKDKCK>K;KEKCKBK7K4K5K5K7K7K4K5K8K:K=KFK;K7K7KK;K}K¢KœKŸKcKEKWK±KÄKÁK½K;K KKKK.KHK‚KÇK½KÇK£KMKLK0K0K=KK9KFKyKÃK¾K¿K¼K§KKGKGKEKEK>KAKKKVK±KÁK½KÃK¦KGKDKDKBKDKCK?KAKBKHKDKkK½K¾K¾KÂK¨KHK>K>K>K=KKEKCKCK3K)K,K&KKKKK4KDK>K?K.K(K)K(K)K KKKKKKKKKKKKKKKK(KDKBK?KLK¦K¼K¹K¸K¶K¾KSKÿK KK+KFKAKJK KÀK¾K¸K¶KµK½K•KDKiK½K_K=KAKAKKJKK™KK~K1K@K…KœK˜K˜K˜K™K’KPKCKDK?KNKŽKšK˜K™K™K™K™K—KŸKnK;KTK“K^KAKBKBKŒK›K˜K›KKKKEKwKŸK›K™K™KœKœK—KRKAKDK>KRKKžK›KœKœKœKœKœK›K KqKCKQK•KlK:KCK;KzK¡K›K›K KxKDKOKŽKžK›K›K›KŸK_K:K@K>K?K=KKK:KKKFKEKDK?K:KBKFKEK9K4K5K4K7K7K4K5K7K7K9KFKAK6K7K:KBK|K¡KžKfKCK:KKEKDKDKCK@KAKBKGKGKMK§KÂK¾K¿KÀKjK9K@K>K=KKAK8K'K)K)K(K'KKKKKKKKKKKKKKKKK?KAKDK=KzK¾K¸K¸KµK¼K˜KKKKK=KEK=KsK¼K¿K»K¶K¶K·K³KeKEK£KšK?K>K=K?KGKšK·K²K°e]rµ(K—K–K–K•K•K•K–K–K—K˜K™KšKšK›KœK›K—KK‹K‚KyKqKcKVKKKAK8K0K+K'K"KKKKKKKKKKKKKKKKGKlKÑKÃK}K?K9K7K7KAKBKAK?K6K5K@KFKCKDK>K,K*K+KKKK K K +K K +KKKK KKKKK KKKKKKKKK K K K KKKKKKKKKKKKKKKKKKKKKKKK&K,KƒKŸK˜K—K–K–K–K•K–KšK›KˆKcK5K#K%K(K$KKKK$K;KLKNKJKIKMKKKKKNKNKMKMKMKMKNKMKMKNKNKLKNKMKNKMKMKMKMKNKMKMKNKMKMKMKNKLKNKNKMKNKMKMKMKNKMKIKKKMKIKBK4K4KBKDKEKBKCKBKLK%K=KVK‚KQK'KYK™KXKBKCKDKK›K›K‡K6K9K|KžK˜K˜K˜K™K™KWK?KEK>KIK‰K›K˜K˜K˜K˜K˜K—KKxK?KKKKiK=KCK?KKŸKšK™K–KTKAKmKŸK›K›K›KœKšK›K`K?KDK?KHK„KŸKšKœKœKœK›K›K›K K‚KDKHKŠK€K=KDK;KiK K›KšKŸK‡KHKHKKŸK›KœKšK¡KqK;K@K>K?K=KKkK K¡K|KEK=K;K:KNK•KžK KKLKEKxKÄK¾KÇK“KKKK KK=KOK©KÂK½KÉKoKK,K`K~KWKQKGKIK›KÃK¼KÄK®KyKaKDKEKCKDKDKFKDKmKÁK¾K½KÅKŠK@KDKDKCKBKBKBKBKCKGKBK„KÂK½K¼KÃK“K=K=K=K=KKkKµK³K°e]r¶(K—K—K—K—K—K—K—K–K–K–K–K–K–K–K—K—K–K—K™K™KšKKžKšK—K•KK‡K~KsKeK[KPKFK>K6K.K'K#KKKKKKKKHKtKØK¼KwK=KK)K*K)K&KKKK*K?KLKKKLKKKLKMKNKMKMKNKNKMKNKMKNKNKLKMKNKMKMKMKMKMKMKNKMKMKNKMKMKNKMKNKNKMKMKMKMKMKNKMKKKLKLKLKMKHK>K;K?KAKAKCKEKDKAK>K>KqK_K#KOK˜KbK?KGKBK‚K›KšKKKFK?KEK€KK™KšKšKšKšK™KžK…KBKCKˆKvK=KEK=KsK KšK™KœK`K@KaK›KœK›K›KœKšK KmK=KEK@KDKzK K›K›KœKœKœKœK›KžKKKKBK|KKCKBKK?K>K?K>K=KAK*KKGKFKFKDKDK>K=KBKDK@K3K3K5K4K4K4K4K6K8K9KAKDK8K5K7KK‡K KžKK[KEK[K¸KÂKÀK¶K2K KKKK0KEKˆKÄK½KÇKšK!KAKYKGKbKZK?KDKyKÃK½K¿K¹KuKdKHKDKCKDKCKEKHKRK«KÁK½KÂK¬KLKBKDKCKBKBKBKBKCKHKDK]K»K¿K½KÀK³KPKK=KKCKCKCKEK:K)K+K,KKKK K K K K +K K +KKKKKKK KKKKKKKK K K +K K KKKKKKKKKKKKKKKKKKKKKKK$K5K@K†K›K˜K™K™K™K™K™K™K™K™K˜K—K›KK”KqKIK0K-K,K(KKK K2KIKOKKKKKKKMKNKMKNKNKLKNKMKMKNKMKMKOKMKNKNKNKNKMKMKMKNKMKMKMKMKNKMKMKMKMKNKNKNKNKLKKKNKMKKKKKLKLKEK=K;K=KCKDKDKDKFK=KbK`K#KGK“KiK=KGK>K{KœK˜K˜KDK0KkKœK˜K˜K˜K˜KŸKhK=KDK@K@KxK K›KœKœKœKœKœKŸKŽKGKAK|K‚K?KFK>KeKŸK›K›K KnKAKVK–KK›KœK›K›K K{K@KDK@KBKlKžKœK›K›K›KœK›K›KœK–KWKBKjK˜KNK?K@KIK•KK›K›K›K]K?KcKKœK›K›KžK‘KGK=K?K>K?K>K@K3KKCKGKFKGKFK>K;KCKDKBK4K4K5K4K4K4K5K4K7K7K9KEK>K7K8K:KJK‹K¡K›K[K@K=K>K9KsKŸK™K¢KoKBKJK¡KÆK½KÅKcKKKKK$KCKhK¾K¿KÂKºKCKjKŽKTK:K4KEKIKZK¸KÀK½KÁK©KhKCKEKCKDKCKEKIKDKŠKÆK½K¾KÀKlK@KEKDKBKBKBKAK@KEKGKGKKÄK½K¾KÂKvK:K?K=KK?KKsKžK—K™KNK.KbK™K™K›KšKšKŸKuK>KBK?K=KmKžK™K›K›K›K›K›KœK˜KNK?KpKKDKDK>KWKK›KšK KyKAKLKK KœK›K›K›KŸKŠKCKBKAK?K^K™KœK›KKKœKœK›K›KžKeKAKYKK]K;KAK>KˆKŸK›KœK¡KoKAKVK—KKœKœK›KKVK;K?K?K>K?K?K:KK:KFKEKGKDK?K9KAKDKCK6K2K5K5K4K4K4K4K5K5K7KCK@K5K8K8K@KxK£K¢KpKAK;K:K8KXKK›K£K…KGKDKƒKÆK½KÃK¥K-KKKKKAKRK¬KÃK¾KÄK{KvKœKšKOK$KPKKKIKœKÄK¼KÀK¶KKiKAKDKDKCKDKHKFKgK¾K¿K½KÅK’KCKDKBKBKBKBKAK@KCKFKCKvKÂK½K½KÃKŸKDK>K=KKFK>KhKK—KœKYK,KVK—K›KœKœK›K KK@KAK>K:KcK›K›KœK›KœKœK›K›KžKYKK>K>K=KK/KGKDKGKDK@K:K>KDKEKKDK6K8K7K9KeKŸK¡K†KGK=K:K9KCK“K›KžK˜KSKBKfK¿KÀKÀKÀKYKKKKK6KHKKÅK½KÄK£K‰K¡K¥K†K5KEKHKEKxKÂK¾K¾K½K–KoKDKCKDKCKCKEKGKNK¡KÂK½KÀK°KQK?KBKBKBKBKBKBKBKEKEKUK±KÀK½K¿K»K_K;K>KK9K8K=KCKDKCKDK7K*K+K)KKKKKK K K K K K +K KKKKK KKKKKKKK +K K KKKKKKKKKKKKKKKKKKKKKKKKK(K:KBK…K›K˜K˜K˜K˜K˜K˜K™K™K™K™K™K™K˜K˜K˜K˜K—K—KœKœKŠKdK@K,K*K'KKK3KJKOKLKMKMKMKNKMKMKMKMKMKLKKKMKMKLKLKNKMKMKMKMKNKNKMKMKMKNKNKLKLKLKMKMKMKMKLKLKLKLKKKKKKKKKKKLKLKEKAK=K=KAKAKBKCKDKGKPK;KAK;K^KK™KŸKbK,KOK“KœK›K›K›K KˆKCKDKCK;KYK—KœK›K›KœK›K›KšK KgK:KXK–KWK?KAKDKKžKšKžK‘KKKCKtKŸKœKK›K›KœK›KVK?KBK?KKKˆK KKKKKKKœK¢KƒKDKFK‰KƒKK=KK:K=K=KeK‚KœK¢KgKEKQK¨KÁK½KÄKeKKKKK(KFKoKÃK¾KÂKºKKK¡K KzK\KVKEK\K·KÀK¼KÆK…KHKLKCKDKDKCKEKHKCK€KÃK½K¾KÃKtK>KCKBKBKBKAK?K?KBKHKEKKÄK½K¼KÂK…K:K@K>KK{K»K¼K¹K¶K¶K·K²KcKCK˜KŠKK@K>KEK•e]r»(K™K™K™K™K™K™K™K™K™K™K™K™K™K™K˜K™K™K™K™K™K™K™K™K™K™K™K™K™K™K™K™K™K˜K™K™K™K™K™K™K™K˜KšKKNK*K4KSK¯K×K¡KUK9KK@KBKBKAKBK?K9KSKKšKŸKoK+KFKKK›K›K›KžK’KJKCKDKK:KOK›KžKKŸKšKVK@KhKŸKKžKK¡KŽKCK=K?K=KK2KKCKGKFKEKCK;K:KCKCKDK8K4K5K4K4K4K5K3K5K6K8KCK>K6K6K6KDK…KžKœK_K>KK?KBKGKDKmK¿K¾K½K¿K«KHKK=K;K9K8K8K8K6KK6K'K'K*K*K+KK K K K +KKKK K KKKKKK +K6K@K@K>K]K³K¹K]K%K*K#KKKKKK>K?KPKªK¿K¹K¶K·KµK»KKDKbK¬KXK9K@K?K=Kce]r¼(K˜K˜K˜K˜K™K˜K˜K˜K˜K™K™K™K˜K˜K™K˜K˜K˜K˜K˜K˜K˜K˜K™K™K™K™K™K™K™K˜K˜K™K˜K˜K˜K˜K˜K™K™K˜K›K‹KKK*K:KWK¹KÓK›KOK9KKEKˆK›K˜K›KœKœK›KœKšK˜K˜K˜K˜K™KœK›KœKœK›K˜K˜K˜K˜K—KšKžK”KxKBKKKKK%K@KOKOKMKNKNKNKMKKKMKNKMKMKKKLKNKMKMKMKNKLKJKNKMKNKMKJKKKLKNKMKKKMKNKLKKKLKKKKKKKKKKKKKKKLKLKKKLKIKEK?KK‡KžK›K›K›KœK™KRK>KCK=KJKŒKžK›KœK›KKžKK¢KK=KEKŒKtK>K?K-KvK¡KšK›KK]KKhKžKPK=K?KBK“K KKœKŸKeK?KYK˜KžKKKK™KPK;K?K>KK=K;K:K8K7K8K7K8KBKFK@KK¿K¹K»K½K²KWKAKDKDKBK0K(K*K+K)K)K$K K:K@K?K=K-K(K)K*K*K"KK K K +K KKK K +KKKKKKK!K@K@KBKAK”KµKIK&K*K'KK +K K +KK"KCK>K€K¿K¹K¶K·K³K´K°KdKBK˜KKK@K@KAe]r½(KšKšKšK™K˜K™KšKšK™K˜K™K™K™KšK˜K™KšKšKšKšKšKšK™K˜K™K™K™K™K™K™KšK™K˜KšKšKšK™K˜K™K™K˜KœK‡KHK(K=K[KÁKÎK“KIK9K;K9K;K@K@K=K6K9K?KBKBKDKCK1K*K+K)KKKKKKK K K K K KKKKKK K +K KKKK +K +K +K K KKKKKKKKKKKKKKKKKKKKKKKKK,K>KEKŠKœK™K›KœKœK›KœKšKšKšKšKšKšKœK›K›KœK›KšKšKšKšKšK™K™K™K¤KyKKKKK KK.KJKPKMKMKNKMKLKMKNKMKMKLKMKNKMKMKMKNKMKKKNKMKMKMKJKKKLKMKLKKKMKLKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLKJKIKEK=K;K>KAK@K>KBKBKMKpK—KˆK/K8K}KŸK›K›K›K›KKYK?KCK@KDK„K¡K›KœKœKKžKK K‰KAKAKƒK€KAKCK.KgK¡K›KœKžKjK>KTK•KŸKKKKK¡K€K@KCK@K=KbKKžKKžKžKžKKžKK¡KbK?KZK K`KKKDKDKKBK5K5K7K8K\K™K£KKIKAKK?K3K'K*K+K)K*KK +K K K K K K K K KKKKKKK6KAKAK;KhK£K9K'K*K)K"K KK K +K K5KAKSK¬KºK¶K¶K´K³KºKKCKgK»K]K8K?K?K;e]r¾(KœKœKœKšK˜K›KœKœK›K˜K˜K˜K›K›K˜K™KœKœKœKœKœKœK›K˜K™K™K™K™K˜KšKœKšK˜K›KœKœK›K˜K˜K˜K—KœKKDK%KAKbKËKËKŒKCK8K:K4K:KAK?KKFK‹KžK›KœK›K›KœKœKœKœKœKœKœKœK›KœKœK›KœKœKœKœKœKœKœKœKšK KyKKKKKKKKK9KOKOKMKMKNKNKMKMKMKNKNKMKNKNKNKNKNKNKNKLKKKKKLKLKKKKKKKKKMKIKKKLKKKKKKKKKKKKKKKKKLKLKLKLKLKKKHKKKHKAK;K:K5K.K>KBK@K@KTKkK5K1KtKŸKšK›K›K›KŸKbK>KEKAK@KzK KšKKžKKKKžK’KHK=KtKŒKDKCK+KVKŸKKK KxKAKNKK KKKžKK¡KŽKGKBKCK=KUK—KŸKKžKžKžKKžKK¢KsK?KLK˜KtK9KBK7KpK¤KœKK¢K†KGKEK‚K¢KœKKœK£KyKKK;K9K:K:K8K6K7K:KDKDKDK“K¿KºK¹K½K¥KLKBKCKBK>K,K)K+K*K&K%K$K)K>K>KAK:K)K*K+K+K*K;KK K K +K K KKK K KKKK K K%K@K>K>KHKnK1K'K)K)K*KKKK KKK?K?K‚KºK¶KµK´K´KµK±KcKEK¢KœK>K>K>K?e]r¿(K›K›KœK›KšK›K›KœK›KšKšKšK›K›KšK›KœK›K›K›K›KœK›KšK™K˜K™K™K˜K™KšK™K˜K›KœK›K›KšKšKšK™KŸKxK?K'KDKjKÑKÆK„K>K:K5K$K:KAK@KKCK?KLKKŸKKKžKžKKžKœK¡KƒKCKCKˆK†K?KCK:K]K£KœKK K–KNKAKsK£KK KK¢K‹K@K>K>K>K=KK+KKEKGKCKBKBK=KK4K5K7KAK…K¢K“KhKAK>K;K5KUKŸK‰K’KpKFKCKxKÆK¿KÃK¨KUKKKKK:KIK™KÄK½K¿K´K K¢K¡KKŸK¦KlK@K{KÃK½K¾K¼KªKƒKGKBKDKCK?K@KHKFK›KÃK¼KÁK¼K]K>KBKBKBKAK?K?K@KDKFKGKŸKÁKºKºKÀK{K8K>K;K9K:K:K8K6K8K6K>KDK?KjK»K»K»KºK½KiK?KFKCKBK2K)K+K)K(K(K&K%K7K@K?K@K/K(K+K+K&K„KKKK K +K +K +K K +K K KKKK K KK:K>K?K?K;K*K&K'K&K'K!KKKKKK*K?KTK¯K¸K¶K¶K¶KµKºKŽKEKjK¾K`K:K@KAe]rÀ(KœKœK›KœKœKœKœK›KœKœKœKœKœKœKœKœK›KœKœKœKœK›KœKœKšK˜K™K™K™K˜K˜K˜K˜K›KœK›KœKœKœKœK›K KsK>K(KEKrKÖK¿K}K>K;K1K"KKEKKKNKMKMKMKMKMKMKNKLKKKKKKKMKMKKKKKKKKKKKKKKKKKKKLKKKLKLKIKLKKKKKKKKKJKJKLKJKHKHKHKHKIKLKKKHKFKGKIKEKKCK@K9K`KžKžKKKžKKKœKžK\K7K]K˜KSK>KBKGKKŸKœK K’KGKAKvK¢KKžKžKKžKŸK[K=KCKAKFK‚K KœKžKžKžKžKKK KKKKAKxK˜KHKAK?KMKœKžKKKŸK\K?KbK K K¡KžKŸK—KKKK=KDKDKCK:K4K4K4K4K4K5K5K5K5K3K>K@K4K5K6K9KjK•KœKKCK?K9K7KCKaKrK¢K‘KPKDK]K·K¿KÀK³KrK3KKKK.KFKyKÀK¼K¿KºK¤K¤K¡K K¢K¥KˆKEK[K¶KÀK½K¾K°K¢K[K@KDKDK?K7KEKAKsK¿K½K½KÃKƒKK?KCKHKAKwKÁKºKºKÁK¢KCKK>K@K:K*K+K*K1K K‰K K +K K +K +K K K K KKKK +K KK*K?K>K?K=K+K$K&K%K&K(KKKKK +KK5KAK…K¸K³K·K·K¶K·K°KbKDK KœK>K=K?e]rÁ(KœKœKœK›K›KœKœKœK›K›K›K›KœKœK›K›KœKœKœKœKœKœK›K›K›K›K›K›K›K›K›K›K›K›KœKœK›K›K›K›KœKKlK>K*KJK}KÚK»KtKK:K9K.K9KFKCKCK=K-K*K+K&KKKKKKK K K K K +KKKKKK K KKK +K K +K K KKKKKKKKKKKKKKKKKKKKKKKKKKK1K@KFK„KžK›K›K›KœK›K–K™KœKœKœK›KœKK›KœK›K›KœK›K›K›K›K›K›KšK¢KKK K,K5K1K=KHKUKUKWKNK?K?KGKHKLKMKMKLKLKNKMKMKLKKKLKLKKKKKKKKKKKKKKKLKJKIKKKLKLKKKKKKKKKLKKKHKIKLKKKKKIKHKGKHKIKIKHKHKHKIKHKHKEK=K7K:KAKAKCKCKBKCK_K‰KŸKŸK KƒKAKBK?K8KWKšKžKKžKžKKKœK KhK5KRK™KaK=KBK@K„K¡KœKžKšKRK>KgKŸKžKKKKœK¢KjK;KCK@KAKtK¢KŸK K K K K K KŸK›KUKKBKBKK£KŸKŸK¢KlK@KSKšK¢K K KŸK¡K]K:K>K=K=KK7K:K9KXK†KžKœKdKCKKK¢KÃK¼KÁK€KKKKKK"KCK\KµK¾K¾KÀK«K¢K¢K¢K¢K¥KšKVKHKœKÃK¾KÀK¶K˜KkK?KDKCKAK@KDKEKVK²K¾K½KÀK¦KGK@KBK@KBK@K>KAKBKEKAKVK´K¿K»K¼K»K`K:K>KKEKCK@K0K*K*K*K)K)K(K'K;KBKAK>K0K-K*KDK­KµK4KK K K K K +KKKKKKK K KK;K?K>K@K3K%K&K%K%K'K K KKK +K KK;KYK¯KµK¶K¶KµK´KºKŒKEKhK½K^K:K@e]rÂ(KœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœK›K›KœKœKcK9K,KKK‰KÝK³KlK;K=K*K&K>K@K=K:K8K,K;KEKCKCKKKAKAKCKEKDK’KÃKºKºKÃK‰K;K>KK>K?K;K*K&K%K%K%K&KKKKK KK0KCK‡K»KµKµK´K´K¶K¯K`KEK¢KK@K@e]rÃ(KœKœKœKœKœKœKœKœKœKœKœKœK›K›K›K›KœKœKœKœKœKœKœKœK›K›K›K›K›K›K›K›K›KœKœKœKœKœK›K›KK™K]K7K/KLK”KÛK­KfK;K=K*K*K>K?K>K:K6K+KKAK;KDKK KKžKžKKKœK¢K„KKCK:KiK£KœKœK£KlK;KRK”K K K KKžK¦KƒK>KBKAK=KZK›K¡K K K K K K KŸK¦KrK>KMK˜KxK=KDK8KoK¤KžK K¥KKIKBK|K£K K KŸK£KKK?KDKDK@K5K2K5K4K5K4K1K2K3K2K5KBK>K6K5K5K=K{KŸKRKK?K?KBKHKBKlK½K»K»KÀK­KKK9KK2K#K#K%K%K%KKKKKKK#KAK[K±K¸K´KµKµK´KºKŒKEKiK¼KaK9e]rÄ(KœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœK›KœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœKœK›K›KK–KXK4K4KOK KÙK¨K^K9KKBKEKEK@KJKBK;K?K;K?K…K£KKKžKžKŸKK KK@K7KzKŒKAKCK=K\K KKK¤KyK>KHKŠK¢K K KžKŸK¤K’KFKAK@K;KNK”K£K K K¡K¡K¡K K K¤K„KCKDK‰KK>KBKKCKCKAK7K3K4K4K4K4K1K2K3K2K2K>KCK6K5K5K8K^K‹K…K]KFK=K:K9K8KdKpKJK{KXKAKPK¬KÂK¾KÃK^KIK3KKK#KDKcK¼K¾K¾K¾K©K™K˜KœKžKŸK“KSKIKKÃK½K¾K¸K—K^KAKCKBKCK@KEKEKRK¯K¿K»K¿K®KMK@KBKBK@K>K?K?KBKDKEKNK¨K¿KºK»KÀKoK9K?K;K9K8K8K8K6K4K5K>KCK@KiK¼KºK¹K¹K¼KlK>KDKAK@K4K+K)K)K)K)K&K#K3KAK?K@K4K+K‹K½K´K¿KeKK K K K +K K +K KKK KKKK +K0K?KK:K9K7K+K>KDKCKBK7K)K,K,K!KKKKKKKKKKKKKKKKK K KKK +K K K KKKKKKKKKKKKKKKKKKKKKKKKK!K!K K5K@KGKKžKœKœK›K–K–K•K™KtKCKuK›K˜K—KžKžKKžKžKžKžKžKžKKK KŠKgKmKiKfKgKfKcKaK_K_K]K[KTKLK=K2K%KKKK*KBKNKKKMKNKLKKKKKKKLKIKHKKKKKKKLKKKKKKKKKKKLKJKHKHKHKKKKKHKIKHKHKHKHKHKHKHKHKHKHKHKHKHKIKIKGKFKFKGKHKGKAK;KKIK›K¢K K K¤KcK>KZKžK¡K K K¡K¡KTK:K=KK:K;K9KJKyKcK{K`KDKEKKÆK½KÄKŒK\KDKKKK@KOK¥KÀK½KÁK°KK†KƒKŠK“KžKfKAKzKÃK½K½K¾K”KxKIKBKBKBKBKBKFKBKŽKÄK»K»K¾KjKK?K?KBKBKGKCK„KÂKºKºKÁK™K?K;K:K:K8K8K8K6K5K3K:KDKDKLK£K¾K¹K¸K¾K”KBKBKAKBK=K+K)K)K)K)K'K$K)K>KBKCK;K8KœK½K·K¼K KK K K K +K K KKKK K +KKKKK;K:K=K=K0K$K#K&K&K'KKKKKKK,K@K\KµK¹K²K®K³K³K¹K‰KAKjK½Kbe]rÆ(K›KœKKKKKKKKKKKKKžKKKKKœK›KœKœKœKœK›KœKKKKKœK›KœKœKKœK›KœKœKŸK‰KOK-KK;K9K5K-KAKCKCKCK7K)K*K*KKKKKKKKKKKKKKKKKK K K K K +K K K KKKKKKKKKKKKKKKKKKKK K KKKK K!K K5KBKGKKŸKœKKŸKžKKœK¢K|K:KJK†K‘K™KKKžKœKKžKœKœKžKKK K‹KdKbKdKeKcK_KaKbKgKsK{K[K/K#K!K!KKKKKKK2KHKNKKKKKKKKKKKLKIKHKJKLKKKKKKKKKKKKKKKLKKKJKJKJKLKKKHKHKHKHKHKHKHKHKHKHKHKHKHKHKIKHKGKHKHKHKHKGKGKHKFK>K8K:K>KDKHKGKDKDKCK:KpK¤KžKœKŸK K¡K KŸKžKQK5KbKœKQK>K@KGK”K¡KŸK¢K”KFKK@KxK¥K K K¡K¡K¡K¡K K¢KKUK>KfK¡KQK:K@K?KŒK£K KŸK¦KvK?KOK•K¤K¡K¢KŸK¥KfK7K?K=KKBKBKBKBKGKEKiK½K»KºKÂK‘K>KAK@K?K?K?K?K@KAKHKCK`K¹K»K»K½K·KWK7K:K:K8K7K6K5K5K2K4KAKEK?K}KÀK¸K¹KºKµK[K@KCKBKAK1K*K)K)K)K'K%K%K:KBKAK>KQK­K»K¹K¸K¾KPKK K K +K K +K KKKK K K +K +K +K/K9K;K?K8K$K%K&K%K$K%KKK KKKKAK@KŽK¼K²K²K³K´K¶K­K_KDK Ke]rÇ(K›KœKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKœK›KœK›KœKœK›KKžKžKžKžKœK›K›KœKžKK›KKK¢KƒKIK-K?KYKÁKÏK–KKK8K7K"K5K?K>K;K8K3K-K@KCKCKCK7K)K+K(KKKKKKKKKKKKKKKKKK K K K K +K K K KKKKKKKKKKKKKK KKKKKK K KKKKK!K K6KDKHKK KKžKKKžKžK¡KŒK[K"KPKƒK™KKœK K—KšK˜K›KžKKžKK K‹K`K]K_KkKtK|K†KK˜KK¡KK‚KXK3K K!K$K"KKKKK"KKiK£K K K¡K K¡K¡K K K¢KeK=KUK KbK8KAK8K{K¥KŸKŸK¥KˆKDKGK„K¥K¡K£KŸK¦K}K;K@K=KK3K1K4K2K4K5K3K2K/K/K0K>K>K4K5K5K;KSK€K|KdKCKKCKBKBKBKEKEKNKªKÀKºK¿K°KNKK>KCKFKHKœK¾KºKºKÃK}K6K;K:K8K8K8K6K4K3K2K:KCKAKYK³K»K¹K¸KÀK„K?KEKBKBK:K*K)K)K)K&K&K&K/K>K@K=K[K´KºK¹K¸K¿KKK +K K +K +K K KKKKKKK KKK7K8K?K=K.K$K%K$K#K&KKKKKK K1KAKaK±KµKµKµKµK³K¸KˆKCKhK¼e]rÈ(KKKKKKKKKKKKKžKžKžKKKKKKKKKKKKKKKKžKKKKKKKKKœK¡K|KGK/KBK^KÊKÌKŽKGK9K7K!K7K@K>K;K9K1K.KCKAKAKAK6K)K*K)KKKKKKKKKKKKKKKKKK K K K K K KKKKKKKKKKKKKKKKKKKK K K K K KKK!K!K"K7KCKJKK KKžKK K–KvK€KgK9K%KXKoKvK¤K£K“K–K˜KŽK›KžKKKKŸK”KzK„KŽK—KžK K K KŸKKKžK K¡KKgK;K%K K%K$K KKKK,KBKMKKKJKLKIKHKIKIKIKIKIKKKLKIKIKLKJKHKKKLKJKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKHKGKGKGKGKFKGKFKFKGKHKGKBK8K8K;K2K4KEKIKFKHKbK‰K¤K£K K KŸK¨KlK2KIK™KiK=KEK=K|K¥KŸK K¡K[K9KZKœK¡K K K¡KŸK¦K{KKsK¤K K£K¡K¦KŽKBK>K>K>K=KK4KK@KGKCKDKAK>K>KAKBKAK6K2K3K2K4K1K2K2K0K/K.K9KAK7K5K4K7K_K¡KkK{KMK>K:K:K9KHKQKeK†KdKCKGKšKÄK»KÂKŒK]KJKKKK=KOK©KÂK½KÀK£K†KšK“K–KŸK¡KeK=K}KÃK»K¼K»K«KKIK?KAKBKBKBKDKAKˆKÃKºKºKÀKqK9K@K?K?K=K=K=K=KAKEKAKvK½KºK»KÀK¥KCK:K9K7K8K:K7K4K4K4K9K?KBKAKK¿K¹K¹K½K©KMK@KAKBKK6K%K$K%K%K&K%KKKK KK KCKDKK»K´K´KµK´K¶K¬K]KEK¢e]rÉ(KžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKKK¡KvKEK+KDKhKÒKÅK†KBK9K4K!K7K?K>K:K9K0K/KAKAKAKBK2K)K,K(KKKKKKKKKKKKKKKKKK K K K K K KKKKKKKKKKKKKKKKKKKK K!K K K!K K"K%K%K#K8KCKJKK KKKžKšKvKKKEKIK.K7KtK|KK˜KKvK‡KŽKŠK›KžKžKžKžKžKžKŸK K¢KžKžKžKKKžKžKKKžKžKŸK¡K–KuKKK.K#K&K#KKKKK2KGKMKKKIKHKHKHKIKHKHKJKKKHKIKKKJKHKJKKKIKGKHKIKIKHKHKHKHKHKIKIKIKHKHKHKHKHKIKGKGKFKFKFKFKFKFKFKFKEKGKHK@K5K-K5KBKDKEKHKCKGKeKŽK¤K¢KžK¥KzK2KBKKyKK?K=KK?K?K=K=KKoKºKµK¶KµK¿K~K K K K K KK +K +KKKKKKKK!K>KKIKkKK¤K¥KˆK7K:K„K‰K;KAK8K]K¤K K K¦KzK9KHKŽK£K K£K¡K K¢K”KHK?K?KKuK›KGK=K=KFK˜K¢K¡K¢K§KkK=KUKœK¤K¢K¢K¡K¤KaK9K?K?KK4K3K3K2K2K2K2K0K.K-K/KBK=K5K8K7K?KƒK¦KˆKbKBK;K9K:K3K5KIKeK~KLK@K_K»K¾K¿KºKsKNKKKGK.K$KEKiK½K»K¼K¹K‡KŽK•KžK¤K§KšKSKGKžKÀKºK¾KµK¬K|K=KCKBK?K?KCKDKJK¥KÂK¹K½K¶KUKKK?KAKEKCKK½K¹KºKÁKŒK9K;K:K9K8K6K4K5K5K0K9KCKCKJK K¼KµKµK¼K˜KBKAKBKAK9K(K(K)K&K%K&K$K)K@KBK?KJK¥K¹K¶K¶K¸K¯K+KK K K K KKKKK K KKKKK8K=K=K=K4K$K&K&K%K&K$KKKKKK#KAKEK‘K¹K´KµKµK´K¶K«K^KEe]rË(KžKžKžKžKKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKžKKŸKiKAK,KIKzKÚK¼KwK=KK:K9K/K3KAKBKBK@K0K*K+K)KKKKKKKKKKKKKKKKKK K K +K +K K KKKKKKKKKKKKKKKKK K K!K K K K!K K!K!K#K$K#K7KDKEKuKŸKKžKžK™K‘K›K—K£K¢KKfKmKxKzKtKkKKžK”KŸK K¡KŸKŸK¡K KžK K¡KŸKŸK K¡K¡K¡K¡KŸKŸK¡K KžKŸKžKžKŸK£K¢KŽKjK>K$K#K'K(KKK)KBKJKHKIKJKIKHKIKJKIKHKHKIKKKJKIKIKHKHKIKJKIKHKHKHKIKHKFKHKIKHKHKIKHKHKFKEKFKGKFKFKFKFKFKFKFKGKFKFKGKGKCK:K8K9KKQK¡K¢K K¥KˆKK@KK¦K¢K¢K£K£K£K£K¢K¢KKVK;KaK£KVK:K@K;KŠK¦K¢K¡K©K}K?KHKŽK¦K¢K£K¡K¦KwK9K?K>KK9K9K:K?KlK‘K…KOKCKMK¦KÄK½KÀKŒKZKJK_K{K:KKK?KFKCKjK»K¼K»K¾K¯KMK7K9K8K8K6K4K5K4K1K3K?KDK?K{K½K·K·KºK¶K]K>KBK@K?K/K'K)K'K'K&K%K#K6KDKAKK;K9K-K5KCKCKDKAK/K*K,K)KKKKKKKKKKKKKKKKKK K K K K K KKKKKKKKKKKKKKKKK!K!K K K K!K!K K"K$K$K#K#K8KDKFKyK›KžKžKžK›K™K–KxK^K‚K™K–KK{KŠKvKrK•KK˜K¢K K K¡K¡K K¡K¡K¡K K¡K¡K¡K¡K¡K¡K K¡K¡K¡K¡K¡K¡K¡K¡K KŸKžK K¤K˜KyKMK-K#K+K-KKK0KCKJKFKGKHKKKLKIKHKIKHKHKKKLKIKHKHKIKIKIKIKIKIKIKHKFKHKIKIKIKIKGKFKGKGKFKFKFKFKFKFKFKFKFKFKFKFKFKGKCKDKDK=K:K=K?KBKFKHKFKCKTKpKEK0KfKœKKK?KAKEK–K¥K¡K¢K—KFK:KoK¨K¢K¢K£K£K¢K¦KbKK=KqK§K¢K¢K£K¢K¢K¢K¢K¢K¦KeKK=K=KK@KBKBK?K7K3K2K4K5K3K2K3K0K.K-K8KEK8K4K5K5KVKœK{KSKHK@K7K9K9K@KXKpKmKPKBKEK‰KÅK¼KÁK¦KyKEKAKdKaK>KHKKÁK¹K¿K©KoKyKK¢K¥KªK‚KBK\K¶K½KºKÀKžKkKLK?KBK?K?K@KEKBK]K¸K¼KºKÀKŸKAK>K?K>K:K3K6K=KK@K>K9K8K-K5KCKBKCK?K.K(K*K'KKKKKKKKKKKKKK KKKK K K +K K K KKKKKKKKKKKKKKKKK K K K K!K K!K"K"K#K$K#K#K7KBKMK‘KšKžK KŸK K¡K˜K…KK†KŠKK~KfK€K‰K}K‘KKœK¡K K¡K K K¡K K K K¡K K K¡K¡K¡K¡K¡K K K¡K K K K K K K¡K¡K KŸK K¦K¡K†K\K7K*K'K'K"K"K5KEKHKHKHKJKIKHKHKIKHKIKJKIKHKIKHKGKGKGKGKHKIKHKFKHKIKGKHKIKHKHKGKFKFKFKFKFKFKFKFKFKGKGKGKGKGKGKEKEKFKDKAK>K;KK?KBKBKAK:K1K3K3K3K3K2K3K0K,K-K4KCK;K4K5K7KEKK™KPKDKBK:K:K9K;KGKVKVKUKDKCKgKÀK¾K¿K·K…K]K[KgKˆKcK>KqK¾KºK½K·KwKcKsK›K¦K©K›KQKHKŸKÁKºK¼K·KžK`K>KBK?K?KK@K=K8K5K,K7KCKBKBK>K,K(K)K&KKKKKKKKKKKKKK!K KKK K +K K +K KKKKKKKKKKKKKKKKKK!K K!K K K K!K$K"K#K%K#K#K7KBKNK‹K”KœK¡K¡K¡K KK–KŒK—KdKYK‹KKKKK‚KKœK¡K K K¡K K K¡K¡K¡K¡K¡K¡K K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K K¡K¡K K KŸK K£K•KmKXKK9K;KBKAK=K2K2K2K2K2K2K3K0K,K.K.K>K>K4K5K7K9K~K—KFKNKDK;K8K:K7K;KFK9K0KBKEKLK«KÂK½K¾KœK^KjK{KjK…KHKTK³K¾KºKÀK†KpKbKwK«K¦K§KfK=K}KÁKºK¼K¼K³KKDKAK?K?KKGKCK^K¶KºK¹KºK·KXK2K8K8K6K5K3K2K3K2K1K?KCK?KgK¸K·K¶KµK»KqK:KCKAK?K5K(K)K)K&K%K$K"K/K?K>K>KaK³KµK¶KµK¼K–KKKKKKKKK K K K +K +K KKKK;K8K5K+K8KCKCKDK>K-K*K)K$KKKKKKKKKKKKK!K!K KKK K +K K K K KKKKKKKKKKKKKKK K K K!K K"K#K#K#K$K"K#K$K#K&K8KBKMKK‘KœK K K K¡K’KnKKKrKuKkKvKKtKKxKrK€KœK£K K K K K KŸK K¡K K K¡K¡K K K K K K K K K K K K K¡K¢K¢K¢K¢K K K K•KƒKnKrK‡KuKHK&K$K#K#K3KIKLKHKHKIKHKHKIKIKHKHKIKHKGKGKFKFKGKGKGKHKGKGKFKDKIKHKGKGKFKFKFKFKGKFKFKFKFKFKGKFKFKGKFKFKFKFKFKGKEKBKBK>K:K8KK?KAKAK?KBKCK7KKK?K@KDK—K»KµK¶K¶KºKDKþKKKKKKKKKK +K K K K +K*KK:K8K4K+K:KCKCKDK>K-K+K)K#KKKKKKKKKKKKK!K!K KKK K +K K K K KKKKKKKKKKKKKKK K K K"K!K#K$K$K$K$K"K#K%K#K&K8KBKLKŒKK›K K K¡KŸK˜K{KdK_KhK]KIKnKƒK|KoK~KšK˜KžK¢K£K¢K¢K£K KžK¡K¡K¡K K K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¢K£KK™K¡K K¡KžK„KƒK…KK–KKIK\K4K/K,K-K;KJKJKHKHKIKHKHKHKHKIKHKFKGKGKGKFKFKGKIKGKGKHKFKIKHKFKFKGKGKGKGKFKFKFKFKFKFKGKEKFKGKFKGKFKFKFKGKDKFKGKEKEK?K8K6K:K=K=KBKAK=K@K>K4K\K©K¢K K©K}K5K?K‰K¨K¡K£K£K¢K¥K™KJK@K?K;KAK„K§K¢K¦K¦K¦K£K£K¥K¥K¡KWK:KcK¦K\K:K?K8K†KªK¤K¢K§K†K@KCK‡KªK¤K¦K¥K«K‡KK9K?KCKCK6K.K2K3K3K2K3K2K/K.K,K7KDK7K4K6K6KPK¢KŠKJKGK@K9K9KKyK¼KµK¶K·K·K_K>KBK>K?K.K(K)K'K$K&K%K"K3KAK@K=KoKºK¶K·K´K¿K…KKKKKKKKKKK K +K +K +K KK:KK>K;K9K5K*K:KBKBKBK;K+K*K*K#KKKKKKKKKKKKK!K K!KKK K +K K +K K KKKKKKKKKKKKKK!K K!K K"K$K#K#K#K#K$K"K!K!K$K'K8KBKLKŽKtK‘K¤KŸK KŸKˆK‘KtKeKkKbKnK…K…KƒKfKK–KK’KzKqKšK•K‡K–K¡KŸK¡K£K K›K£K¢K¢K¢K¢K¢K¢K¢K¢K¢K¢K£K¢K K¢K™K‰K¡K¦K K¡KžK K–KKˆKsK|K¡KqKKKKK(K@KJKIKHKIKIKHKIKIKIKIKIKHKGKFKGKFKFKFKGKGKGKIKHKGKGKFKGKGKGKFKGKFKFKFKGKGKGKGKGKFKFKFKFKFKFKFKGKGKFKGKGKCK;K8K8KK?KK=K9K:K:KK7KCKCKBKBKAK9K=KCKCK:K/K2K3K2K2K3K2K/K.K,K0KBK:K3K5K3K@KtK‡K_KDKBK;K9KK?K?K>K>KDKAKwKÀKºKºK¿K…K:K=K=K=K=K=K;K9KK@K>K@K5K(K)K&K%K#K$K#K(KKK9K&K#K&K%K$K&KK KKKKK K K K–K¶K²KµKµK³e]rÒ(K¡K¡K¡K¡K¡K¡K¡K K¡K¡K¡K K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K¡K K K¥K{KKK-KDK_KÉKÊKKGK9K7K!K4K?K=K:K9K4K*K>KBKBKBK:K+K*K*K#KKKKKKKKKKKKK!K K"KKK K +K K +K K KKKKKKKKKKKK K K!K!K!K"K"K$K#K#K#K#K$K#KK K%K&K9KCKKKŠKˆK‹K£KœK–KŒKUKXKBKSKbKQKSK|KhK„KˆK“K‡KK“K|KLKyK—KyKpK™KŸKK¡K¡KœK£K¢K£K£K£K£K£K£K£K£K£K£K¢K¡K KšKŸK•K‰KœK¢K£KKKŸKŸKvKqKlKgKKKKKKK,KDKLKHKGKIKHKHKHKHKHKHKGKFKFKFKFKFKFKFKGKIKHKGKGKFKEKDKDKFKFKGKFKFKGKGKGKGKGKFKFKFKFKFKFKFKFKFKFKFKFKFKGKCK=K7K:K=K>KAKAK@K?KJKpK™K¨K—KCK6KmK§K£K¥K¦K¤K¢K¨KeK:K@K=K8KdK¦K£K¦K¥K¦K¦K¦K¦K¤K«KvK;KHKšKƒK;KAK8K\KªK¥K¥K¥K¤KYK=KbK¥K¦K¥K¥K¦K¢KTK5K=K=K=K:K9K>KK+KFKCKCKAK@K9K9K@KCK;K1K2K2K2K2K3K2K/K.K-K.K>K=K4K5K5K;KLKyKHK4KEK;K:KK>K=KBKCKUK²K½K¹K»K©KIK;K=KKEK@KK¿K¸K¹KÀK‘K9K8K6K4K5K4K3K1K.K/K4KBKCKAKK¼KµK¶KºK¬KRK;K@K>K;K,K'K&K%K$K$K$K K3KAKBK?K~K»KµK¶K´K¼KsKKKKKKKKKKKKKK KKK=KKMKvK—KMK1K`K¦K¦K¥K¥K¦K¤K©KrK:K@K?K9KSK¡K¥K¥K¦K¦K¦K¦K¥K¤K«KˆKK=K=K;K9K;K&K!KCKCKDK@K>K:K9K@KBK?K1K1K3K2K2K3K1K/K.K.K-K:KCK5K4K4K4K^KKBK7KAK@K:K9KKhK»K¹K¹K»K²KOK3K5K5K5K4K3K2K/K0K1K>KDK=KcK¶K¶K¶KµKºKuK:K@K=K>K3K%K&K&K&K%K$K K(K@K>K>KVK®K·K¶K¶K¸K¦K$KKKKKKKKKKKKK K +K K2KK=K;K9K2K+KBKAKAKBK6K)K+K*K!KKKKKKKKKKKKK#K"K#KKK K K +K +K K KKKKKKKKKKKK K K!K"K"KK K$K#K$K#K$K%K%K&K&K%K&K:KCKJKƒK“KqKnK‹K‰KuKMKmK‚K…K}KŽKsKK¢K‰K‚K†K˜K•K|K8KFK{K“K~KiK†K“K“K£K“K”K¤K¢K¢K£K£K£K£K£K£K£K£K£K¢K¤K›KyK{K”K€K‡KqK}K€KkK•K‡K}KK^KfK#KKKKKKKKK(K?KJKIKGKHKHKHKHKHKGKFKFKFKFKFKFKGKGKGKGKGKFKFKFKGKFKFKGKFKFKFKGKGKGKGKFKFKFKGKFKDKFKGKFKFKFKFKFKGKFKDKDKAKBKDK6K(K/K>KCKDKAK>KRKFK0KSK¡K¥K¥K¥K¦K¤K¨K‚K>K@K?K9KHKšK¨K¥K¦K¦K¦K¦K§K¦K¨K–KGK:KsK¢KLKKBKBK7K0K1K2K2K1K0K0K-K,K+K6KCK8K4K5K5KHKuKCKIKQK?K9K9KK=KKEK@KoK¾K¸K¸KÀK‘K:K>KK>K=K8K)K&K&K&K%K#K#K#K8KCKBK?K‹K»KµK¶K´K¼KbKKKKKKKKKKKKK K KK K>KK1K$K&K(K+KŽK¬K%KK K KKK +K KKŽK¸K´K´e]rÕ(K K K K K K¢K£K£K£K¢K£K£K£K£K£K£K£K£K£K£K¢K K¡K£K£K£K£K£K£K£K£K¡K K¢K£K£K£K£K¢K KdK@K.KIK}KÙKºKzK=K8K0K"K7K=K=K=K:K1K-K@KBKAKBK5K(K,K*KKKKKKKKKKKKKK$K$K$KK K K K K +K K KKKKKKKKKKKK!K K!K#K#K!K"K$K#K#K#K$K&K&K%K&K%K%K;KCKJKdKƒKhKRKˆK„KKaKOKmKžKKeKxKtKKyK‡KKvK•KvKPKvK‘KwKRKlK|K‰K‹K£KK›K£K£K£K£K¢K¢K£K£K¢K¢K¢K£K¢K£K¡KuKvK‚KlKXKrKˆKMKxK–KqKbKK}KƒK'KKKKKKKKKKK-KEKIKHKGKHKIKIKHKFKFKFKFKFKFKFKFKFKFKFKFKFKFKFKGKFKFKFKFKFKFKFKFKFKFKFKFKGKEKCKEKGKFKFKFKFKFKGKGKDKBK?KDKEK@K9K:K;K=K?KAKBK>K=K:KFK•K­K¥K¥K¦K¥K§K‘KDKAK?K;K>K‹K«K¥K¥K¦K¥K¦K¨K§K¦K¢KSK9K`K§K_K9K?K8K‚K­K¤K¤KªKKCKAKK«K¥K¨K§K¨K“KCKK8KK=K=KCKDKRK®K»K¸K»K°KKK8K>K:K:K:K:K:K9K?KDK@K‚K¼K·K¹K¼K¡K=K5K5K4K5K3K1K3K3K.K2K=KDK>KwK»KµK¶K·K¸KdKKK7K&K$K'K9K›KºKiKK KKKKK K KK2KKK‡KÚK´KpK9K7K-K!K;K=K=K;K7K/K.KBKAKAKBK4K)K)K*KKKKKKKKKKKKKK#K#K$KKK K K K +KKKKKKKKKKKKKK!K!K K#K$K#K$K%K%K%K%K%K%K%K&K%K%K%K:KCKIKdKvKcKtK{KuKcKSKZK†K§KxKOKQK>KXKtKKxKjKxKrKwKˆK‰K|KrK‰K_KwKˆKŸK›KŸK¤KŸK¢K¢K¤K¥K¢K£K¥K¥K¥K£K£K£K¡KKK¢K›K‘KšKšK[KvKuKHK[KK‰K{K)KKKKKKK!K&K-K1K5KBKEKHKIKGKGKIKHKFKGKFKFKFKFKFKGKGKFKFKFKFKFKGKGKGKGKFKFKFKFKFKFKFKFKFKFKGKFKFKFKGKGKGKFKFKFKGKGKFKFKEKFKFKEKEKBKAK=KKAK?KYK‰K¦K©K¤K¤K§KKLK?K?K;K6KxK«K¤K¥K¥K§K§K¨K§K¥K©KbK8KOK¤KqK:KAK6KoK¬K¦K§K©KŸKOK=KkK©K¥K¨K§K¨K¢KOK:KKAK3K3K5K6KeKžK•KqKDKK=K=K?KEKCKŽK¿K¸K¹K¾KpK5K>K:K:K:K:K:K9K:KAKAK^K³K¹K¹K¹KºK]K1K6K5K5K4K0K0K0K/K.K9KBK@KSK¯K¸KµKµK½KŽK;K=KK8K7KAKBK@K3K/K0K/K0K/K.K/K,K*K)K8KDK7K5K5K4KOKKšK‡KPK?K:K9KK>K=K=K>KEKBKkK»K¹K¹K¿K—K=K>K:K:K:K9K:K9K9K@KBKDK›K¾K¸K¸KÀK‡K3K5K5K5K4K0K0K0K0K.K3K@KCKBKKºKµK¶K¸K­KQK9K=K=K;K*K&K&K$K$K"K!K!K2K@K?K;KiK¶K´K´K³KºKŒK KKKKKKKKKKKKKKKK6K>KK=KFKiK—K©K­KeK9K@KK‡K—K?KKBKAK4K.K0K/K0K/K/K/K,K)K(K1KCK;K4K4K5KBK‰K•K”KgK?KK\K´K»K»K¼K´K¡KTKKEKAKtK»K¶K¹K»K©KFK2K5K5K3K1K3K1K/K0K1K;KBK=KeKµK¶K¶K³KºKyK9K=K=K=K1K%K&K$K$K$K#K"K)K?K@K@KIK K¸K´K´K´K³K:KþK +KKKKKKKKKKKK +KK$K=KK=K;K9K8K,K3KBKAKBK?K/K(K)K*KKKKKKKKKKKKK!K#K$K"KKK K +K K KKKKKKKKKKKKK K K"K$K#K$K#K$K%K%K&K%K&K&K$K&K&K%K&K9KAKOKiKiK\KpK„K—KŽK^KkK°KšK{KrKTKmKZK`KJKhK‘KfK|KKfK{KzK’KdKAK…K–K…K¡K¤K¢KžK¥K¦K¥K¦K¦K¦K¦K¦K¦K¦K¦K¦K¥K¥K¤K¤K”KoKK—KšKKLKbK–KjKkKQKQKRK[KXKVKZK]K[KYKUKMKLKJKFKEK?KAK@KAKGKGKGKFKFKGKFKFKFKFKFKGKGKGKFKCKDKCKEKGKFKGKGKFKFKFKGKFKFKGKFKFKEKDKEKEKEKEKEKFKEKEKGKFKEKCKDKCKFKFKCKDKEKFKHKEKK?K„K¬K§K§K¦K¬KK=K:K=K;K9K9K:K5KK9KBKAK@K=K:K5K=KDKBK8K,K/K0K/K0K/K/K,K)K(K-K@K=K4K4K4K7K~K‡K\KbKBK=K8K9KK;K;KKGKAKŠKÀK¸K¸KÁKyK7KKyK¸K´K´K²K¼K}KKK KKKKKKKKKKK +K KK9KK;K(KvK´K¯K¯K·K^KK KKKKK +K KKK=K:K9K6K+K6KCKAK@K>K-K'K+K(KKKKKKKKKKKKK!K#K$K#KKK K +K +K +KKKKKKKKKKKKK!K K"K$K#K#K$K#K#K%K&K%K%K%K&K%K%K%K%K:KBKKK‚K|KFKwK’K’KKœK}KœK‘KgKJKUKpKmKvK…KnKŠKwKhKoK„K†KeK†K{KdKpKzK’K¦K¦K£KžK¦K¦K¥K¦K¦K¦K¦K¦K¦K¦K¥K¦K¥K¥K¤K¥K“K‹K¡K›KK K›K KK›K€KPKSKWK]K\K\K]K`K^K\K[KVKUKMKKKJKFKHKGKDKK;K9K:K9K9KK0KDKAK?K>K;K6K:KBKBK>K/K/K0K/K0K/K0K+K)K(K)K9K?K4K5K6K5KhK‰KSKgKLK=K9K:K8KGK'K&KK,KBK?KqKÁKºK½K¹K«K¨KŸKwK’KnKAKfK¼K»KºK½KKK KK2KMK;KEKGK?K|K¿K¸K¹K¹K´K˜KBK;K:K:K9KK?K>KRK¨K¶K´K²K²K¬K*KKKKKKKKKKKKKK K K,K>K=K=KK?KAK>K=K=K8K7K5K5K‚K¬K§K§K¨K¨K¨K¨K§K¨K­KaK6KRK¦KwK7K?K5KgK®K¦K§KªK¤KSK8K`K§K§K¨K©K¨KªK[K5KKKK…K¸K³K´K±KºKiKKKKKKKKKKKKKKKKK:KK=KKAKOK“K„KhKfKKŽKªKžK’KˆKkK‘K_KaK[K_KmKRK|KK„KVKMKeKK?K?KAK@K=K:K4KpK«K¦K§K¨K¨K¨K¨K§K§K®KtK6KCK—K‹K;K>K7KSK¨K©K§K§K¬KhK8KNKŸK©K©K«K§K­KsK4K:K9K:K8K7K:K)KKAKBK?K>K>K:K7K?KBK@K3K.K0K0K.K-K-K.K*K'K(K0K?K7K5K5K4K;KhK†KOK:KDK;K9K:K>K+KKK K;KCKEKKÀKºK½K³KŸK¤K§K¥KžKhK>KŒKÁK·K½K£K"K&K,K'K KK.KDKJK K¾KºK¼K¹K°KmK7K:K:K:K2K5KDK?K‚K¿K¸K¸KÀK€K5K;K9K7K8K8K8K7K6K@KCKJK¢K½K¸KµK¾K|K0K6K3K2K0K1K/K-K.K,K5K?KCKCKŒKºK³KµKµK®KTK;K;K:K9K*K"K$K$K$K!K"K!K,K?K?K>K\K±KµKµK´K¶K¢KKKKKKKKKKKKKKKK +K*KK2K2K/K'K$KKKKK#K6KFKEKCKDKDKCKFKGKFKFKFKFKFKGKFKDKDKCKDKDKFKFKDKEKFKFKFKGKFKCKCKCKDKDKDKDKDKDKDKEKCKCKDKCKCKCKCKCKDKCKAKAK@KBKKKMK>K7K9K>K?K?K=K?K=K[K§K¬K§K§K§K§K¨KªK§K­KˆKK:K6K;K@KCK7K-K.K0K/K/K.K-K+K)K(K+KK7K9K;K-KKKK1K>K?KKÃKºK¼K¶K¤K¦K§KK‚KxKAKmK¼K¹K»K¼KGKK@K(KKKKAKCK€KÀK¹K»K»K°KfK:K=K;K:K8K8KCK?K_K¹K¹K·K¾K¥KDK8K9K8K8K8K8K6K5K;KDK?KK¾K·K¶K»K¢K;K1K3K2K/K0K0K.K.K.K.KKgK´K´KµKµKºKyK9KK_KvKšKcK‘K¬K‡KtKWK9K'K/K5K+K KKKK+K=KCKDKDKCKFKFKFKGKGKGKGKGKFKDKDKCKDKDKFKFKCKEKFKFKFKFKFKCKCKCKCKCKCKDKDKDKDKEKCKCKDKCKCKCKCKCKCKCKBKAKBKAK?KIKLKCK9K;K=K:K6KK|K®K§KªKªK¬KšKEK8K:K:K:K9K7K9K;K8KBKBKAK>K:K6K9K?KAK:K-K.K0K/K0K.K-K,K)K(K'K7KBK7K4K5K5KKKuKtK„KRK=KKaKºK¼K»K¼K®K¨K©K–K—KƒKIKRK­K¼K¹KÃKwKK;K=K0K+K*KAKDK`K¸K¼K»K»KµKKJK;K;K9K8K8K>KCKFK¡K¿K¹K¹K¸KaK4K9K8K8K8K7K7K2K7KEKAK\K´K¹K¶K·KºKaK,K4K2K0K0K0K.K.K/K*K5KCKBKGKžK¸K´K¶K·K¡KDK9K:K:K5K&K$K#K K!K K KK-KBKCK=KiK¶K´KµKµK·KšK!K KKKKKKKKKKKKKK K/K?KK=KKDKdK”K¬K¬K¨K§K©K«K¤KPK3KZK«KcK4KK@K>K/K.K0K/K0K/K,K+K(K%K&K0K>K8K4K5K5K?KfKZKhKTK?K=K:K:K8K KK KK8KCKMK¥K¿KºK¿K³K¦K­K˜K€KŸKaKBK•K¿K·K¿KK,K4K9K?K>K-K/KDKJK¡K¿K»K¾K¯KxKZK7K:K:K:K9K=KFK@K}KÀK¹K¸K¿KˆK4K7K8K8K8K5K5K4K6K?KEKEK˜K½KµK¶K½KŒK1K4K0K0K0K0K/K,K.K-K-K?KCK=KvK¸K²K´K´K¹KfK2K;K9K8K.K$K!K!K!K!K!KK#K=KAK@KGKžK¸K´K´K´KµK`K#KKKKKKKKKKKKKKKK=K=K=K:KiK°K®K¯K¯K¯K³KVKK KKKKKe]rà(K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¥K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¦K¥K§KœKYK:K2KKK„K×K´KrK;K8K/K!K8K?K=K;K8K0K/K@K?KBKAK7K)K(K)K#KKKKKKKKKKKKK$K$K&K"KK K K +K K KKKKKKKKKKKK K!K#K#K$K$K%K%K%K&K&K%K&K&K&K%K&K(K(K*K:K?KDKBK9K;KŽK–KXKyK°K¥KœK¤K¢K§KzK`KoKrKRKYKVKIK‚K˜K©K§K£K£K™K™K¢K–K¨K§K¨K¨K¨K¨K§KªKˆK|K«K¨K“K•K©K§K¥K‰KqKŸK¢K©K©K¨K¨K¨K¨K¨K¨K¨K§K§K§K§K§K¦K§K KK¤K¨KžK¦K†KzKˆKxKtK¦K¦K¨K«K K€KUK;K+K1K7K)KKK K7KDKDKDKCKEKFKEKFKFKEKFKEKCKEKFKFKEKCKDKCKEKFKDKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKDKCKCKCKCKBKCKBKBKBKAK@KAKBK?KAK=K2K+K0K9K>K=K@KAK=KGKlK™K­K©K§K¨K­K`K2KIK¥KyK4K>K3K`K¯K©KªKªKªK[K5KVK¥K¬K¨K¡KŸK©KgK6K>K;K9K9K9K8K8K8K@KBKAK@KK>KAK4K-K0K/K/K/K,K,K*K&K%K-K=K9K4K5K5K:KOKOKWKTK?K=K9K:K8K!KKK$K6K?KBK‡KÁK»K½K¶K«K«K«KŽKKxK?KuK½K¹KºKºKCKK KGK>K6K.KAK@K€K¿KºK¼K·KŽK„K=K8K:K9K9K;KAKAK^K³KºK¸K¼KªKBK4K8K7K6K5K5K5K4K;KEKAKrK¼K¶K·K¹K¬KGK/K1K0K/K/K/K,K-K,K)K9KDK?KTKªKµK´KµKºK“K;K9K:K:K3K#K!K!K!K K KKK3K?K@KK=K:K6K/K6K?KAKAKAK5K*K+K)K"KKKKKKKKKKKKK$K$K&K"KKK K +K +K KKKKKKKKKKKK!KK K#K$K%K&K&K&K&K&K%K)K)K&K$K)K)K(K*K;K@KFKHKgKHK…KŒK¢KpK•K€KlK“K¤K¢KˆKˆK…KƒK>K=KLKpKKŒK°K¥K¨K¤KœKœK K™K¥K¦K¨K§K¨K¦K¥K©K¢K}K›K«K¢K‰K”KŒK…KœK’K”K˜K£K¦K¨K§K¨K¨K¨K¨K¨K¨K¨K§K§K§K¨K¨K¨K©KªK‡KK–K…KTKbKRK“K©K¦K¤K¢K¨K­KªK’KkKGK3K+K.K/K#KK(K@KGKCKDKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKCKDKCKDKDKDKCKCKCKDKCKAKBKBKBKEKDKCKAKAK@KAKAKBKAKCKAK9K0K1K9K=K@K>K@K>K;KFKqKœK¬K¨K®KuK2K>K“KK;K>K8KKK©K«KªK©K®KpK6KFK™K®K§K¡K¢K¥KsK9K=K9K9K:K7K8K:K9KAKBKAK@K=K:K4K:K@K?K:K-K/K0K-K-K.K.K-K&K%K*K9K=K5K4K4K6KDKBKQKjKDK=K8K9K;K&KKKK)KK`K¶KºK¹K¼K¥K¢KWK5K;K8K8K8K=KDKFK˜K¾K¹KºK»KgK3K9K5K4K5K5K5K4K8KBKCKQK«K¹K¶KµK»KnK,K1K0K/K-K/K,K*K+K)K1K?KBK>KŽKºK³K´KµK±KUK6K:K8K7K(K!K!K!K KKKK&K>KAK@KPK¨K³K³K´K³K±KQK&K+K)K'K#KKK KKKK KKKKK;K9K>K:KoK´K®K¯K¯K­K¯KRKKKK%K'Ke]râ(K¦K¦K¥K¦K§K§K§K§K§K¨K§K§K§K§K§K§K§K§K§K§K§K§K§K§K§K¨K§K¦K§K§K§K¦K¥K¦K¦K§K¦K©KKSK3K6KNKKÙK©KbK7K6K4K5K9KKMKwKŸK³K‡K3K4K€K£KBK8K:K;K™K®KªK©K°K†K9K:K†K¯K«K¤KK”K€K=K:K:K:K9K8K9K9K:K;KAKAK?K>KK@KKvK½K¹K¸K¿KŽK4K6K5K5K5K5K5K3K3K?KEK?K‹K¼K¶KµK»K™K9K1K0K.K.K-K+K+K+K+K+K;KBK>KeK¶K´K´K³K¹K~K5K:K8K8K.K!K K K K KKKK7KAKAK>K…K·K±K³K±K¸K…K;KDKLKPKWKiKjKhKGKK K$K(KKKK0KKKBK?K=KQKK’K>K2KlK¬KTK6KK:K9K;K9K9K:K8K;K7KAKAK?K>K:K7K5KK0K-K-K-K.K-K+K*K%K%K$K.K?K7K2K5K4K>K‚KmKVKRK>K:K9K:K8KKKKK1KBKAK’KÁKºK¼K¹K¬K¯K¥K£K®K{KKK¿KºK»K¹K¨K’K=K5K9K8K8K8KBKCKXK°KºK¸K¼K¯KJK3K5K5K5K5K5K2K2K9KCK?KcK¶K¶K¶K¶KµKUK+K1K/K.K+K*K+K+K+K)K4KAKAKFKŸK¹K´K´K¶K¤KEK7K9K7K1K$KKKKKK KK-K?K?K>K[K°K³K±K±K²K­K{KqKpKcKPKWKUKQKHKFKNKFK+K1K)KK&K>K=K>K:KvK´K®K°K°K¯K®KPKK!K1K&Ke]rä(K§K§K§K§K¨K¨K¨K§K¨K¨K¨K§K§K§K§K§K§K§K§K¨K¨K§K§K§K¨K¨K§K§K§K§K¨K§K§K§K§K¨K¦K«KKKK/KAKQK³KÓKŸKWK6K7K5K4K9KK:K5K4K;K?K?K?K>K/K'K(K(KKKKKKKKKKKKKK&K%K&K!KKK K +K KKKKKKKKKKKK K K!K#K$K%K%K&K%K&K%K&K(K)K)K)K(K)K)K(K*K;K>KNKcKoKK“K¢KŸK=K'K0K9KMKXK}KžKKyKoK/KdK‚K}KK¡K«K©K¦K§K§K¨K©K¨K¦K§K¨K§K¨K¥KK®K|KjKŸKmK3KK…K‡KˆKKVKeKzKpK‹K¨K©K§K©KªKªKªK¨K§K§K©KªK¨K§K©KaKQK|K€K+KYK¤KŸKmK€K©K£K¥K›K”KKœK¨K©K«K¥K£K¨K­K¢K}KVK7K'K$K*K8KCKDKDKCKDKDKDKDKCKEKGKDKCKCKDKCKCKDKCKCKCKCKDKEKBKDKCKAKCKDKBKBKBKBKAKAKAKAKBKDKCKBKBKBKAKAKAKAKBK@K?KAKAKCKAKK?K>K=KK;K7K5KK>KuKÁKºK¼KºK®K°K¬K¥K°K‘K@K\K¶KºK¹K¿KwKYK‰K…KSKhK‹KfK?K`K¶K»K¹K»K¯K¥KZK1K9K8K5K4KKBKIK KºK¶K´K½KK,K1K0K.K,K*K+K)K*K'K,KK/K'K(K'KKKKKKKKKKKKK K&K%K&K!KK K K +K KKKKKKKKKKKKK K"K$K%K&K%K%K%K&K&K&K)K)K(K)K(K(K)K(K*K;K?KKKgKtKaKƒK¬K˜KSKVKjKSKIKSK˜KŠK}K KrK7KVKTKcK“K¨KaKsK«K©K¨K§K§K§K¨K¨K§K§K¨K¨K£K®K•KnK®KŽK,K\K”KšK£K€KYKyKƒK|KvKŒK£K¨K©K«K«KªK¨K¨K¨K©K«K¨K¨K¦K—KXKSKrKZKoK‰K{KuK£K£KžKK›KŠK’KpKK¥KKšK¢KœK¨K­K¯KªK”KiK@K)K*K7K>KDKDKDKCKDKDKCKDKGKDKCKCKEKCKCKDKCKCKCKCKDKDKCKCKCKAKCKCKAKAKAKAKAKAKAKAKBKCKCKAKAKAKBKBKBKAKAK@K?KAKBKAKAK@KBKKKBK?K?K>K;K6K;K@KBK7K,K-K-K-K-K+K+K+K&K&K%K7K>K1K3K2K6K7KKZK†KGKKoK»K¶K·K½K•K6K5K5K2K3K3K/K0K/K9KEK?K}K½KµK¶KºK§K=K+K-K,K+K-K-K)K(K(K(K8KBK?KRK«KµK´K³K»K‘KKKKKKK9KsKoKiKUKnKZK?K?K@KKKKCKDKCKCKDKDKDKCKCKCKDKCKCKCKCKCKCKCKCKDKCKCKCKDKBKAK@K@KAKAKAKAKAKAKAKBKBKAKBKBKBKBK@K?K?K@KBK@K>K?K?K>K@KCK@K=K8K6K8K9K8KKK9KKKaK¥K³KŒK9K9K:K9K:K9K7K8K7K;KBK>K?K?K=K6K7K@KBK:K+K,K.K.K-K+K+K,K'K%K%K2K?K5K4K4K3K=KKK`KZKK>K?K>K?KAK?K>K?K;K4K2K5K6KK?K=K@K9K1K4K7K“K¯K«KªKUK+K:K:K5KKKK¯K®K¡KKGK7K;K9K9K8K7K9K8K7K?K?K@K?KK?K=K.K-K-K-K-K+K+K+K(K%K%K,KKcK´K´KµK²K»KvKKKKKCKyK|KmKoKmKrKsKVK@K>KAK>KsK¶K±K±K±K´K¤KvKwKKKKyKqKhKdKdKDK.K!K.K8K'K2KK,KIKnKÓK¾K„KBK4K5K1K7K=KK?KK>K>K?K>K>K?K>K>K?K>K?K=K7K5K2K5K9KK?K>KK>K?K4K*K*K-K-K+K*K+K(K%K$K&KK?K^K¹K¼K»K»K|K7K'K K9KKKBKHK£K½K·K¿K”KGKdKlKYKYKfKeKCKGK¡K½K¸K»K±KqKDK3K6K4K5K5K9KFK?KiK¼K¸KµK»KžK/KKKKKK K KK%KEKKAK?KNK¦K´K±K±K²K²K†KyKKzKzK|KzKqKgKiK]K>K-K&K4K*K(K=K=K=K:KUK¦K­K¬K°K­K²K€K'K,K7e]ré(K§K¨K©K¨K§K©K©K©K©K©K©K©K©K©K©K©K§K©K©K¨K§K§K¨K©K©K©K©K©K©K©K§K¨K§K©K©K©K«K K\K;K.KHKvKÖK¹K}K>K5K6K/K5KK?K:K)K(K)K(KKKKKKKKKKKKK#K&K&K&KKKK K +K KKKKKKKKKKK K!K"K#K%K%K%K&K$K#K'K)K'K)K)K(K)K(K&K)K*K.KK?KAK>K=K>K?K>K?K?K>K?K?K>K>K>K?K@K>K9K4K3K7K:KK=KK;K9K8K6K9K3K;KAK@K?KKJK¥K¾KºKÀK‰KFK>K*K7KTKLK>K…KÀK¸K½K¯KLKGKQKOKVKvKpKHK>K‚K¿K¸KºK¼KlK9K1K,K)K'K#K K6KBKOK¨K¼KµK¶K¹K;KK K KKKKKKK?KAKQK«K¹K¶K¶K¸K—KqKRKKKKKKKKKK=KEK>KvK¸K³K´K²KºK_KKKKJKjKqKyK}KqKfKsKoKHK9KBKBK>K‚K¶K±K²K±KµKžKvK€KwKnKnKfKVKWKQKTKOK>K=KK=K>KK?K9K*K(K)K)KKKKKKKKKKKKK#K&K&K&KKK K K +K KKKKKKKKKKK!K K K"K&K&K%K(K"K K'K)K)K(K(K(K(K)K,K+K*K.KK[K©K¦K¤KªK—K‚K K¬K˜KPKRKOK'KdK7KKcKSK„KŸK›K§K“KrKtKhK‹K–KK¢K«KªK¬K‚K…K•K}K„KKZK`KbKrKaKjKŒK~KcKˆKkKcKxKoK›KK¡K­KªK«K«K«KªK«KªKªKªK¬K¬KªK©K²KeK9KvK–K“K¡K¡KhK„K§K1KqK±K©KªKªK©KœKK­K¬K¬KªK¬K­K­K­K­K¬KªKªK­K›K#KKKKKK%K?KFKDKCKDKCKCKCKCKCKCKDKCKDKCKAKBKDKBKAKCKCKBKBKBKBKBKBKBKBKBKBKBKBKAKBKBKBKBK@K?K?K>K>K>K?K=K?K?K>K?K>K>K>K?K?KKK?K=K9K5K8K?K?K5K(K+K*K*K+K*K(K)K$K&K$K.K@K5K1K3K1KKJKNK?KgK¹K¹K¹K¿KvKKK8K3KNKMK>KCK@K^K·KºK¶KÂKƒKKKKKK K K#KFKAK†K¼KµK¶KÂKrKKKK K K K K K K1KCK>KˆK½KµK¶K¹K§KlKAKK KKKKKK K K-KAK?KSK«KµK´K³KºK“KKK,KUKnKlKgKpK{KkKmKvKUK4KBKCK?KZK­K±K²K±K²K°KzKlKeKUKTKSKCK:K8KCK5K9KBK;K&KKK:K;K=K:K\K©K¬K¯K°K¯K´K‚KK?K7K'K(K)K&KKKKKKKKKKKKK%K&K%K&KKKK K +K KKKKKKKKKKK!K!K#K$K&K%K%K&K%K(K)K(K)K*K*K*K(K)K*K+K*K-K=K>K[K«KªK«KªK«K®K©K¨K­K‰K]KFKK+KK+KK_K…KvK–K«K’KŒKœK•KŠKhK~K¤K«K«K¬K¤K¦KŸKxKƒKgKUKYKXKnKCK`K“KyK^KoKfKbKKKvK­K›K¦KªK«K¬K¦KªK¬K«K¬KªKªK«K«KªK¬KŸKZKTK}KKK¨K KZKKwKAK«K¬K¬K¬K¬K­K¥KœK¬K­K­K¬K¬K­K¬K¬K­K¬K¬K¬K­K¦K2KKKKKKKK/KDKDKCKCKDKCKCKCKCKCKCKDKCKCKCKBKCKCKBKBKCKCKBKBKBKBKBKBKBKBK@K?KBKBKBKBKAKBKBKAKAKAK@K>K>K?K>K>K>K>K?K>K=K>K?K@K=K7K3K1K6K6K/K8K>K:K=K>K KkK‰K1K5K„K²K«K¨KKªK–KDK>K?KK@K:K&K)K+K+K)K)K*K(K"K%K%K)K>K6K1K3K2K:K6KKQKrK?K;K9K9KKcK·K¶K·K¶K¶KvK(KKKKKK K K K KKAKBK?KKºK´K´KµKµKCKK4KYK]KTKQKVK[KbKDKQKCK$K8KAK?K?KŽK¶K°K²K±K´K”KbK\K]KKKIKSKKKIK>K.KK@K6K&K(K)K%KKKKKKKKKKKKK&K&K%K&KKKK K +K KKKKKKKKKKK!K!K#K$K%K%K&K&K&K)K(K(K*K+K+K*K(K)K+K+K*K-K=K>K\K¬K«K«KªKªK«K©K£K«KYK]KK"KKK,KwKdK„KgKK©K˜K„KžK¨K°K–K|K‰K«K§K©KšKtKoKsK9K6KUKCK(KEKDKCKtKtKƒKTKYK‰KEKgK˜KK­K­K«K¨K£KªK­K­K£K§K®KªKªK¬K§KžKjK>K|K¦K©K«K¤K\K”KOKvK³KªK­K­K­K¬K«K™K¤K«K«K­K¬K¬K¬K¬K­K­K­K¬K¬K®K@KKKKKKKKKK8KDKEKCKDKCKCKCKCKCKCKCKDKCKAKCKDKBKBKDKCKBKBKBKBKBKBKBKBK@K>KAKAKAKAKAKAKAKBKBKBKAK?K?K>K?K?K>K>K?K>K=K>K?K>K>KK=K:K6K4K>K?K=K*K(K+K*K(K(K'K&K"K$K&K$K9KKdKµK´K´K²K¹KxK K%K@KFKBKGKNKKKfKUKK>K@K4K%K(K)K%KKKKKKKKKKKKK%K%K%K'KKKK K K KKKKKKKKKKK K K"K%K#K%K&K(K(K(K)K(K*K+K+K*K(K)K+K+K*K.KKAKBKAKBKAKAKAKAKAKBKBKBK@K>K>K>K>K>K>K>K>K>K>K?K>K>K>K=K=K4K.K3K8K9KK?KKDK—K´K±K±K¯K¶KrKKKKKKK3K8K*K KKK"K1KK%K8K:KK>K@K3K&K)K(K$KKKKKKKKKKKKK&K&K&K&KKKK K K KKKKKKKKKKK K!K#K$K#K%K&K(K)K(K)K(K*K+K*K*K(K)K+K+K+K.K=K=K_K­K«K¯KœKXKK>K>K>K>K?K>K>K>K?K?K>K=K>K>K=K9K6K5K8K:KK?KK4K'K(K#K'K%K K*KBK7K1K2K2KKKKK)KBK;K=KKrKÀK¹K¾K­K KK KKKK>KOK­KºK·KÁK}K K K K +K KKKCKIK¢K¼K·K¹KªK'K +K K K KK KK>KAK]K·K¸KµK¹K¨K KK K KKKK KKKDK>K_KµK¶KµK³K¼K[KK +KKKKKKK KKK:K@K=KxK·K²K²K±K¸KkKAKOK'K!KEKOK3K K-K1K$KKK0K@K?KK8KdK¯K¯K®K¯K®K¯KŽe]rï(K«KªKªKªKªKªKªKªKªKªKªKªKªKªKªKªKªKªKªK«K«KªKªK«KªKªKªKªK«KªKªKªK«KªKªKªK­KvKIK+KBKUKºKÎKœKTK4K6K#K'K9K9K9K7K4K*K.K@K>K>K@K2K'K*K&K"KKKKKKKKKKKKK(K)K(K&KKK K K K KKKKKKKKKKK!K!K$K#K#K%K%K(K)K(K)K(K*K+K)K(K(K)K*K-K.K1K?K=K_K­K«K®K KWKKKYK«K«KŽK^K’K¬K†K(K_KaK{KiKnK•K~K”K‰K~KK¯K©KªKŽKjK’K§K KwK‘K¨K„KKK4K?KcK§K’K€K§K–K‰KŒKVK_KŽK|KqK_K}KuKzKˆK‡KšK`KiKtK]K|KlKNKbK†KŒKbKbKqKUKK‹KuKxK|KK—K­K¬K­K­K®K«K«K¦K¥K©K®K¬K¨K¨K«K­K¬K¬K¬K«K¶KnK KKK(K,KK%K+K2K9K>KBK?K:K>KBKDKCKDKCKCKCKCKCKDKDKBKAKAKAKAKAKAKAKAKAKAKBK@K?K>K>K@KBKAKAKAKBKBKBKAK>K@KBK?K?K?K>K>K>K>K>K>K>K>K>K?K?K>K>K?K?KK>K;K9K5K2K=K?K;K%K&K(K;K>K.K$K#K'K*KKK;K9K0K1K1KKKKKK?K?K=KK=K>K?K;K=K=K=KCK–K±K«K¬K¬K®K§e]rð(KªK«K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K¬K«K«K¬K«KªK«K¬K¬K¬K«K«K¬K«KªK«K«KªK¬KlKEK)KDK[KÅKÈK—KNK4K6K!K)K:K;K:K7K5K+K/K@K>K?K@K3K&K)K(K"KKKKKKKKKKKKK'K(K(K&KKK K K K KKKKKKKKKKK K!K#K$K$K&K'K(K)K(K)K(K)K)K*K)K(K)K+K+K+K/K=KKFKLKLKJKHKGKHKCK:K7K@KEKCKCKCKCKCKCKCKCKBKAKBKAKAKAKAKBKAK@K@KBK?K=K@K@KAKAKAKAKBK@K@KBKAK@K@K@K?K>K?K>K>K>K>K>K>K>K>K>K>K>K>K>K>K?K?K?KK?K=K9K4K2K=K?K>K)K"K'K7KK0K0K2K#KKKKK7K@KK2KKKKKK2KHKKÀK·KÂKwKK +KKKK&K@KnK¾K¸K¸K¼KFKK K KKKK1KAK`KµK·K´K¾K„K K KKK K KKKFK@K|K»KµKµK¾K†KKKKKKKKKK'KFK=KsKºK´K´KµK´K6KKKKKKKKK KKKAK?K;K‰KºK²K³K±K³KRKK*K,K0K2K4K5K5K4K5K6K7K6KK:KiK®K¬K­K¬K¬K°e]rñ(KªK«K­K­K­K­K­K­K­K­K­K­K­K­K­K­K­K­K­K«K«K­K¬KªK¬K­K­K¬KªK«K­K«KªK¬K¬K«K©KgKAK)KFKdKÏKÅKŽKIK3K5KK+K;K=K;K6K5K*K1K@K>K?K@K1K'K)K)K"KKKKKKKKKKKKK'K(K(K'KKK K K K KKKKKKKKKKK K!K#K$K&K(K)K(K(K)K(K(K(K(K*K*K(K)K+K*K*K-KK_KVKŠKŽKXKMKtK}K¬K®K¶KcKuK·K©K˜KKoKeK“KŒKKjK(K[K[KtK|KzKlKƒKkKwKuK„KlKwKsK\K)KKKYKYKzKcK[KHK‹KKNKxK¢KK„KoKhK}KQK\K]KOKvK”KxKK‡K­K±K¬K­K­K¯K°K°K°K¯K°K°K­K®K°K°K¯K³KKXKPKLKJKOKPKPKMKOKNKOKNKJKIKKKHKBKKBKEKCKCKCKDKDKDKBKAKAKAKAKAKAKAKAKBKBKBK@K>KAKBKBKBKBKBKBK?K>KBKBKBK@K>K>K>K>K>K>K>K>K>K>K>K?K?K?K>K>K>K>K>K>K>K?K=K:K6K1K4K7K7K7K;K;K:KQK…K°K[K5K;K9K8K5K4K7K'KK?K>K?K?K:K6K4K;K?K>K3K%K$K/K?K@K7KKKK(KK$K?K3K0K0K*KKKKK-K@K;K=K?KKKÁK¹K¾K KKKKKKK?KTK¯K¼K¶K¿KvKK K +KKKKKDKIK¡KºKµK¹KªK#KKKKKKK +K;KBKYK²K·KµK¸KªK'KKKKKKKKKK@K?KRK«K¶K´K²K½KoKK +K +K K KKKKKK%K:K@KK?K@K.K&K)K)K!KKKKKKKKKKKKK'K&K&K%KK K K K KKKKKKKKKKK!K!K!K#K$K%K'K)K)K(K'K*K*K*K*K*K*K*K*K+K+K*K0K?K>KcK®K¬K¬K¬K®KŸK…KŽK\KKUKLKxK{K³KKK KoK¬K«K˜K‰K‚KŒK‘KK­K±K‘KWK¢K¬K¢KšKžKŸKœK£KKgKFKVKvK‡K]KIK\KqK[KjK_KLKyKmKPK=KjKVK>KCK†KZK.KK‘K£K«K K­KªKƒK(KEKPK:KUK#KXK}KsK}KŽK–K™KšK«K¨K§K±K¯K¯K¯K°K°K°K°K°K°K°K¯K³KˆKJKMKPKTKUKWKTKQKQKOKQKQKKKIKKKHKEKHKFK@K9K;KCKEKCKBKBKBKBKAKBKBKAKAKAKBKBKAKAKBKAKAK?K?K?K?K?KAKBKAKAK?K@KBKAKAK?K?KAK@K>K?K>K>K>K?K>K=K>K?K>K>K?K?K?K>K?KK;K7K4K7K?K>K8K)K"K(K=K@K>K1KKK K&K-K;K6K0K2K0KKKKKK@K:K>KEKSK1KKKKKK;KbK¸KºKºK¹K6KK KKK +K9KCK–K¿K¶K½K¡KKK K +K KKK?K?K€K½K´KµK½KOKK +KKKKKK)KEKCK˜K¼KµKµK¼KUKÿKKKKKKKK K3KEKAKŒKºK³K³K·K¤K-KK!K!K#K&K&K'K(K)K+K3K?K@KGKšKµK±K²K³K«KMK6K:K9K;K=KK?K?K?K?K?K>K‰K³K¯K²K±K´KŸK}KtK_K'K-K'KKKKKKKKKKK+K;K9KK?K@K.K%K)K)K!KKKKKKKKKKKK K'K%K&K$KK K K +K KKKKKKKKKKK"K!K!K#K$K%K'K)K(K)K(K(K+K*K+K*K*K*K*K)K+K*K0K@K>KcK¯K­K­K­K¬K°K‘KTKcKsK`K.KUKK³K—K2KK‹K³K¬K­K¯KªK“KzKqKžK­K¦K‚K§K­K®K’KK¯K›KzKDK>KIKrK K„KKKGKmKgKnKVKNKRKVKQK:KK^K9K(KgK?KIK§KnK“K°K®K¬K¨K–KLK0K5K?KYK+KDKIKjK–K¢K—K“K†K K©KªK°K°K°K°K°K°K°K°K°K°K°K¯K´K”KTKTKTKSKUKXKTKSKTKOKQKPKMKLKOKLKJKJKDKEK=K0K3K>KCKBKAKBKBKAKAKAKAKAKAKAKAKAKAKAKBKBK?K>K?K?K>K@KAKBKAK>K?KBKAKBK?K?KAKAK>K?K>K>K>K?K>KK?K>K>K>K>K>K>K>K=K=K>K=K5K*K(K0K2K2K4K6K-K,KgK9K9K9K7K6K4K7K7KK0KDK?K>K=K:K4K6K?K@K;K1K.K/K9K?K>K?K/KKKK*K=K9K1K2K4KKKKKK;KCKYKhK|KkK KKKK K5KLK§K¾K¸KÂKfKK +KKKK+KAKuK¾K¹K¹K¸K=KK K K KK K2KAK_K¶K¶KµK¾K…K K +K KKKKKKBK>KuK»KµKµK¾KKKKKKKKKKK*KCK>KdK¶K´K´K´K·K^K"K*K)K)K*K)K)K,K,K.K3K>K@K>KtK¶K±K²K°K·KyK4K9K9K:KK?K=K-K&K(K)K!KKKKKKKKKKKK K'K%K'K%KK K K K K KKKKKKKKKK"K!K!K#K#K&K(K)K&K'K)K'K)K*K+K+K*K)K(K"K*K*K0K?K;KeK²K®K°K­K¬K«K‘KxK]K1KiKQKcKhKŒKšK0K(K¡K¯K¬K©KK†K˜KTKeKwK¤K K®K¯K§K±K›K_K}K£KsK.K$KCKmK†K¥K…KWK5K-KSKŠKjKgK?K6K5K^K—KKaK;KyKOKrK¯KšK˜K¬K©K§KªK€K_K>K-K6KLKMK=KLKgKšK‚K€KKKK®K±K¯K°K°K°K°K°K°K°K°K°K°K¯K²KKWKUKVKUKUKXKWKVKVKQKPKSKPKRKPKKKIKEKAKK@KBKBKBK?K?KAKAKAKAKAKAKAKAKAKBK@K>KAKBKAKAKAKBKBK?K>K?K?K>K>K>K?K?K?K?K>K?K>K?K>K=K=K=K=K=K>K?K=K>K>K9K/K&K)K/K1K0K2KK,KK>K>K;K5K4K;K=K;K4K5K/K.K9K?K>K?K)KKKK6K?K1K/K3K%KKKKK0KHKzKK–K¡K*KKKKK+KCKŒKÁK·KÁK–K KKKKKKAKWK³K»K·KÁKoKK +KKK KKKCKHK¡KºKµK¹K«K$KK K +K K +K KK9KAKTK¯K¸K¶K¸K±KKIKŸK¸K´K´K¹KŽK-K+K.K-K.K,K,K/K0K3K1K8K?KKBK’K´K¯K°K±K¯KµK¦K@K(K3K2K0K4K4K2K0K+KK K#KKK/K=KK?K=K,K'K(K(K KKKKKKKKKKKK K'K&K'K$KK K K K K KKKKKKKKKK!K!K!K$K$K%K(K)K'K$K&K*K(K*K+K*K)K)K)K(K+K+K0K?K;KeK²K®K°K®K­K¯K¢KmK;K%K;KlKzKhK„KœK,K2K¢K¯K¯K¨KJKlK{KeKdKiK•K«K¯K®K©K¯K€K:KCKŒKoKKNKhKuKžK®KgKMKKKBKWKjK_KKiKbKUKVKšK‘KuKNK|KŠK¥K¤K±K©K´K“KK™KJKOKEK4K2KBKKŒKaK7KeK]K“KK‘KƒK§K±K°K°K°K°K°K°K°K°K°K°K°K°K²K¢KWKRKVKWKVKXKWKSKPKLKPKQKQKVK]K`KGK+K*K,K)K"KKKKK5KAKBKAK?K@KBKAKBK@K?KAKAKAKAKAKBKBKBKAKBK@K?KAKBKBKAKAKAKAK?K>K>K>K>K>K?K>K>K?K?K>K?K>K>K>K=K=K=K=K=K>K>K=K=K=K:K;K8K,K%K*K-K0KK K:K:K:KK>K>K;K7K3K7KK>K>K(KKK+K?K3K.K/K,K +KKKK%KAK†KªK¬K½K^KýKKKKKAKkK¾K¸K»K´K,KK KKK K:KDKœK¾K·K¿K›KKKKKKKK=K?KK¼KµK´K½KZKKKKKKKK0KFKAK“K¼KµK´K¾KnK K%K$K$K"K#K&K'K)K9KDK?K}K»K´K´KµK¯KHK(K.K-K-K/K0K0K1K3K1K8K?K?K>K„K¶K±K±K±K²K»KºKºK»KºK­K†KUKCKDKDKEKDKDK@KK?K>K+K(K)K(KKKKKKKKKKKKK"K)K)K)K%KKKK K K KKKKKKKKKKK K!K&K&K%K'K(K(K#K$K(K(K*K+K*K*K+K+K+K-K-K1K?KK?K>K>K>K>K>K>K>K>K?K?K?K?K?K=KKK@K=KK>K>K;K9K4K5K>K>K?K:K2K1K)K0K>K>K?K?K#KK K>K9K.K/K1KKKKKK;KyK¼K¸KÁKKKK KK K9KRK­K»K·KÁKYKþKKKKK-K@KyK¾K¸K¸K·KKoK¹K´K³K¹KœK0K%K(K(K%K&K)K'K$K/KDK>KWK¯K¶K´K³K»KtK*K0K/K/K2K3K2K2K2K2K7K>K@KK>K;K+K'K'K'KKKKKKKKKKKKK$K)K(K(K#KKK K K K KKKKKKKKKK K K"K%K$K%K(K(K'K(K'K(K*K*K+K,K,K*K+K*K-K-K1K?K=KfK³K¯K¯K²K«K®K”K—K\KVKhK~KiK±K®KŠK!K]K®K¯K¨K¡KtKYK@KeK|KMKK°K²K±K­K­KZK"K#KiKFKCKZKcK“K­KœKyKnKfKKKRKdKYKdKsKrKdK/KiK›K‚K¢K¯K®K°K®K«K¦KKlKXKmKbKMKK5KRKnKzKK‡KlKOKSK˜K“KvKŽK§K²K­K±K²K²K²K²K²K²K²K²K²K±K°K­K_KQK^KgKvK…K‘KžK¨K±K´KµKµK³K±K²K´K·K±K—KnKDK+K%K+K(K"KKK2KAKBK@K@KBKBKAKAKAKAKAKAKAKAKAKAKAKBKBK@K@KBKAK@K?K>K?K>K>K>K>K>K>K@K@K?K?K?K?K?K=KK=KKK>K;K9K3K1K>K@K>K@K9K0K0K,K1KKKBKAK’K»K³K³K¹KK9K0K3K2K3K4K3K4K3K4K8KKBKAK>K>K>K>K>K>K>K>K?K?K>K>K>K>K>K>K?K=KK8K&K K4K8K9K;K9K5K4K5KK'KAK>K>K;K8K5K1KK>K@KK8KK*K?K0K-K.K&KKKKK.KNK©K½K·K¿KNKKK K K)K;KtKÀK¸K¹K¬K3KK KKK$K>KHKŸK¼K·K¿KœK(K#K$K$K$K#K)KAK>KK¼KµKµK»KgKK'K&K%K%K%K$K6KEK;KŠK»K³K³K½K{K&K*K)K+K+K(K8KK^K7KCK=KlK¸K´K´K´K´K[K+K3K3K4K5K5K5K4K6K8K8KK?K;KOK£K±K¯K¯K®K²K_K'K/K0K8KHKDK/K1K"K3KKKPKSKSKRKQK@K8K:KK?K>K?K>K=K=K=K>K?K>K>K?K=KK?K=K:K7K3K8KK?K=K>K3K6K2K+K6K?K>K@K4K$K>K4K-K.K-KKK +K K%KAKK¿K¶KÃKKKKKK&K;KXK·K»K¸K¾K]KK%K!K!K#K:K?KK½K·KºK·KIK"K)K(K%K%K(KKLK¤KµK³K³KºK‡K.K/K3K4K4K4K5K7K7K6K?KGKAK?KOK§K³K±K±K±K²KµKµKµKµK¯KKyKRKHKHKJKKKLKKKCK>K?K=KƒK´K­K°K­K±K‘K6K1K5KK=K?K?K7K(K(K&K%KKKKKKKKKKKKK$K'K(K)K KKK K +K KKKKKKKKKKKK K!K$K$K%K'K)K)K(K(K)K+K*K*K*K*K+K*K+K-K-K1K?K:KiK¶K¡KKuKwKŒKNK K$K)KRKK“K§K“KXK&KƒK³K¯K¯K®K£K—KlKbKxKfKfK~K¡K²K±K°K®K°KŸK”K’K K‹KˆK¤KŒK|K¢K«K‘K˜KK–K†KlKDK'K.KKLK™KQK9K„K—KzK K³K¬K—K}KAK—K‡KWKQKEKpK^KoK†K K´K±K²K³K³K´K¨K K©K¦K´K±K²K²K²K²K²K²K²K²K²K²K²K±K±K±K±K±K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K±K±K±K²K¶K¸K°K˜KpKDK,KKK%K5KCKCKBKAK?KAKAK?K>KAK@K>K>K>KAKAK>K?KBK@KBK@K>K?K>K>K=KK>K>K>K>K=K=K=K=K=K=KK=KK;K9K4K6K=K>K?K=K9K7K0K>K2K+K7K>K>K@K4K4K8K-K-K,KKKKK"K;KpK¿K·K¾K¦K)KK#KK!K:KFKK½K·KÁK…K$K(K%K$K#K2K@K^KµK¹K¸K¿KrK!K+K)K'K(K'K6KDKIK¢K¸K³K¶K°KEK&K)K)K)K'K&K&K;K?KKK¦K·K´K³K¹K_K%K,K+K*K)K0KXK@K+K=KBK>K‚K·K²K´KµKªKDK.K3K5K4K5K5K8K8K5KFKcKAKCK>K†K¶K¯K²K±K²KµK´K´K³K²K¨KKcKJKHKKKLKKKMKHKK>K?K4K'K(K&K$KKKKKKKKKKKKK(K)K(K*K!KKK K KKKKKKKKKKK!K KK#K&K%K%K'K)K'K)K+K+K+K+K*K*K+K*K+K.K,K*K0K@KK>K?K?K>K=K=K?K?K?K?K?K?K?K?K?K?K?K>K?K>KK?K>K>KK=K>K?K>K>K?K=KK?K>K9K4K5K;K>K?K8K1K:K.K=K;K0K,K6K>K>K;K6K2K-K)K+K'KKKKK9KWKµK½K»K»KKKK%K"K!K3K>KKÀK¸K¼K§K2K#K'K#K'K,K?KIK¤K»KµK½KšK.K)K+K*K+K)K-KCKBKK¼KµK¶K¼KhK&K+K(K)K(K'K%K6KCK>K†K»K³K³K¹K‡K*K,K+K*K+K*K>K5K+K5KAK@K_K²KµK´K³K¹KnK-K3K5K5K7K7K7K:K8KNKKRK?KK=K>K@KK³K«K®K¯K³K…K2K;KQKBK*K>KMKLKNKPKNKTKRKQKMK8K,K7K:KK>K?K3K'K(K'K$KKKKKKKKKKKKK(K)K(K*K KKK K KKKKKKKKKKK K!K K"K%K&K&K(K(K&K+K*K*K*K*K+K*K+K*K,K.K,K*K0K@KK=K=K>K>K?K>K>K?K>K>K>K>K>K>K>K>KK?K?K>K=K=K?K>K=K>K?K?K?K>K=KK>K:K6K2K9K?K>K9K3K=K1K:K?KK@KaK¶K·KµK½K‘K.K*K)K)K)K)K'K.K@K=KaKµK³K´K¶K©K?K(K,K+K+K+K.K.K(K/K?K@KEKšK¸K³K´K¹K–K6K2K4K5K7K8K8K9KKK>K?K2K(K(K(K#KKKKKKKKKKKKK(K)K(K)KKKK +K K KKKKKKKKKKK!K!K!K#K&K)K)K(K)K(K(K(K(K*K+K*K+K*K,K.K.K-K1K?KK?K>KK?K>K>K?K>KK>K>KK?K>K>K?K?K?K>K=KK=K=K9K1K8K>KK>K@K2K(K(K%K KKKKKKKKKKKKK)K(K(K)KKKK K K KKKKKKKKKK K!K"K#K$K&K'K(K)K(K)K(K)K*K*K+K*K+K*K,K.K-K-K1K?K;KlK¸KcK%KCKK'K5KRK¥K«K©K›K›K¬K¥K KK˜K´K³K±K°K¥K¥K¸K€K\KnK¢KŠK„KuKCKK¯K±KµK¢K¢K‘K‡KfKjK`K€K¨K¬K¶K·KtKWKyKƒK‡K\K5K(K'KdK—KbK›K³KiKZKyK)KK@K(KUKoKvKŸK²K¯K¯K¤K²K³K³K³K³K³K³K³K³K´KµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµK´K´K³K³K·K»K¯K“KaK=K:K>K?K>K>KK?K>K>K?K=KK=K=K=K>K?K>K>K?K>K=K=K=K=K=K;K;K=KK5K$K6K7K8K6K6K4K7K+KK8K>K>K=KK>K?K7K0K?K>K?K;K.K1K;K7K2K=K0K#K!KK'K+KK%K9KbK¼K¹K¼K´K>K!K'K&K%K8K>K‰K¿K¸K¾K K3K)K*K*K(K.K@KPKªKºK´K½K”K,K*K,K*K+K*K0KDKBKƒK¸K±K³K»KjK'K,K+K*K)K)K(K3KBK>KK»K³K³K¹K“K.K,K,K+K)K'K+K-K,K3K@K>KVK¬K´K²K²K¹K}K1K5K5K7K8K9K8KBKwK£K±KgK>K@KOK§K³K±K±K±K³K²K°K²K³K²K¡K€KXKLKNKJKLKTKPKAK:K=K;KoK°K®K¬K­K¯K KLKEKIKDKHKGKAKCKIKGK=K8K-KKKKK0K9K9KK>K>K/K'K(K%K KKKKKKKKKKKKK)K(K(K*KKKK K K KKKKKKKKKK!K K#K$K&K%K%K'K)K(K(K(K)K+K*K*K*K*K*K+K(K-K-K1K>K:KoKµK¨K„KJKEK[KfKmK‹KªK§K¥KaK“KªKK+KoK‰K®K¸KœK}K®KžKqK0KDKŒKNKxK„KUK—K²K’K«K¦K¨KšK–KK©K˜K‰K­K·K•K]K5KkKzKtK~KWKAKK>K>K?K=K;K?K>K>K>KK>K?K>KK;K"K0K8K7K5K4K4K5K3KK2K@K>K=KK>K@K:K-K=K?K>K@KKK?KŒK¾K´K¸K­KCK(K-K)K*K+K,K=K@KcKµKµK´K¼K“K-K+K+K,K)K)K(K,K?K?K\K³KµK´K¶K°KGK&K+K*K+K+K-K.K,K.KK:KCK@K8K2K*KKKKKK*K:K9K;K9e]r(K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K°K·K‡KNK.K:KJK™K×K®KjK6K5K/KK3K:K9K7K4K1K1K9K>K?K?K=K,K'K(K%K KKKKKKKKKKKKK)K(K(K)KKKK K KKKKKKKKKKK K!K#K$K%K&K(K(K(K(K+K(K(K+K*K*K*K*K+K(K'K/K-K3K@K=KcK±K¥K‰KqKŠKK˜K“K•KŸK–K…KUKzKjK KIKLKyK›K¸K KfKŒK‘K{KzK{KbKVK˜K—KŽK‡K«KŽK˜KªK´K·K¶K¶K¶K®K’K¬KµK£KeKKKLKCK9KrKcKNK1K!K2KvKœK‰KKšK“K!KZKvKBK1KGKSKKK™K´K®K¥K´KµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµK¶KµKµK¶K¶KµKµK¶KµKµKµKµKµKµKµK¶K¶K¶K³KµK³K³KµK¡K©KK@K:K@KAKAK?K>K?K>KK>K>K>K>K?K>K=K>K?K?K>KK>K>K=KK>K=K:K4K1K;K=K>K>K>K?K0K9K@K>K?K@K8K,K0K3K?K>K>K(KKKK+K*K3KAKŽKÀK¸KÁK‡K"K'K&K$K,K?KSK¯K¼K·K¿KpK$K+K+K*K(K8K>KmK¼KµKµK¼KjK%K*K)K*K+K)K5KCKHK K¹K³KµK¯KGK'K+K+K*K(K)K+K:KBKDK›K»K´K³KºKqK$K,K*K+K,K-K.K.K,K6KBK=KfK³K±K±K°K·KdK-K4K5K4K9K;KWKK¬K°KªKUK?K>K\K¯K²K±K²K±K²K±K²K°K±K®K™KyKUKOKMKQKWKLKDK=KK:KyK²K«K®K®K°K™KMKFKFK=K0K4K9K,K KKKKKKK.KK1K8K9K9e]r(K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K²K±K¶K}KHK*K=KMK¤KÒK§KdK3K5K*KK5K:K:K8K4K1K2K:K>K@K?K=K,K'K(K%K KKKKKKKKKKKKK)K(K(K(KKKK +K KKKKKKKKKKK K!K#K$K%K'K)K(K)K(K%K(K*K*K*K*K*K+K*K+K+K.K-K4K@K:K]K²K®K K¢K~K‘K£K™K¨K³KªKƒKSK6KKK]K~K©K K±K°KxKrK¦K˜K…KKBKvK•K“K–KKšK·K¥K«K¶K´K´K´K´K³K³K°K³K¸K²KŽKnKMKZKKŒK‘KWK/K'K@KXKWK…K˜K]KKTKqKNKCKPKnKFK~K¶KžKŽK¹KµK´KµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµKµK·KµKµK·K·KµKµK·KµKµKµKµKµKµKµK¶K·K¶K³K´K´K¯K”K‰K¶KºK9KK4KBKBK?K>K?K>KK?K>K>K?K?K?K=KK?K?K>KK?K?K>K=KK>K?K,K)K7K8K8K8K5K5K7K KK@K>K?K>K:K7K0K9K=K>K?K>K?K3K6KAK?K?K?K>K3K)K6K?K>K?K;KKKKK-K5K:KoKÀKºK¼K¤K5K$K&K%K&K;KCK—K¾K·K½K“K-K'K+K*K*K2K?KQK­K¹K´K½KK.K,K,K+K+K)K0KCK?K„K»K³K³K»KlK%K,K+K*K)K(K)K2KBKKK0 : convergence to tolerance not achieved, number of iterations + <0 : parameter breakdown + + Examples + -------- + >>> import numpy as np + >>> from scipy.sparse import csc_matrix + >>> from scipy.sparse.linalg import bicg + >>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1.]]) + >>> b = np.array([2., 4., -1.]) + >>> x, exitCode = bicg(A, b, atol=1e-5) + >>> print(exitCode) # 0 indicates successful convergence + 0 + >>> np.allclose(A.dot(x), b) + True + + """ + A, M, x, b, postprocess = make_system(A, M, x0, b) + bnrm2 = np.linalg.norm(b) + + atol, _ = _get_atol_rtol('bicg', bnrm2, tol, atol, rtol) + + if bnrm2 == 0: + return postprocess(b), 0 + + n = len(b) + dotprod = np.vdot if np.iscomplexobj(x) else np.dot + + if maxiter is None: + maxiter = n*10 + + matvec, rmatvec = A.matvec, A.rmatvec + psolve, rpsolve = M.matvec, M.rmatvec + + rhotol = np.finfo(x.dtype.char).eps**2 + + # Dummy values to initialize vars, silence linter warnings + rho_prev, p, ptilde = None, None, None + + r = b - matvec(x) if x.any() else b.copy() + rtilde = r.copy() + + for iteration in range(maxiter): + if np.linalg.norm(r) < atol: # Are we done? + return postprocess(x), 0 + + z = psolve(r) + ztilde = rpsolve(rtilde) + # order matters in this dot product + rho_cur = dotprod(rtilde, z) + + if np.abs(rho_cur) < rhotol: # Breakdown case + return postprocess, -10 + + if iteration > 0: + beta = rho_cur / rho_prev + p *= beta + p += z + ptilde *= beta.conj() + ptilde += ztilde + else: # First spin + p = z.copy() + ptilde = ztilde.copy() + + q = matvec(p) + qtilde = rmatvec(ptilde) + rv = dotprod(ptilde, q) + + if rv == 0: + return postprocess(x), -11 + + alpha = rho_cur / rv + x += alpha*p + r -= alpha*q + rtilde -= alpha.conj()*qtilde + rho_prev = rho_cur + + if callback: + callback(x) + + else: # for loop exhausted + # Return incomplete progress + return postprocess(x), maxiter + + +@_deprecate_positional_args(version="1.14") +def bicgstab(A, b, *, x0=None, tol=_NoValue, maxiter=None, M=None, + callback=None, atol=0., rtol=1e-5): + """Use BIConjugate Gradient STABilized iteration to solve ``Ax = b``. + + Parameters + ---------- + A : {sparse matrix, ndarray, LinearOperator} + The real or complex N-by-N matrix of the linear system. + Alternatively, ``A`` can be a linear operator which can + produce ``Ax`` and ``A^T x`` using, e.g., + ``scipy.sparse.linalg.LinearOperator``. + b : ndarray + Right hand side of the linear system. Has shape (N,) or (N,1). + x0 : ndarray + Starting guess for the solution. + rtol, atol : float, optional + Parameters for the convergence test. For convergence, + ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. + The default is ``atol=0.`` and ``rtol=1e-5``. + maxiter : integer + Maximum number of iterations. Iteration will stop after maxiter + steps even if the specified tolerance has not been achieved. + M : {sparse matrix, ndarray, LinearOperator} + Preconditioner for A. The preconditioner should approximate the + inverse of A. Effective preconditioning dramatically improves the + rate of convergence, which implies that fewer iterations are needed + to reach a given error tolerance. + callback : function + User-supplied function to call after each iteration. It is called + as callback(xk), where xk is the current solution vector. + tol : float, optional, deprecated + + .. deprecated:: 1.12.0 + `bicgstab` keyword argument ``tol`` is deprecated in favor of + ``rtol`` and will be removed in SciPy 1.14.0. + + Returns + ------- + x : ndarray + The converged solution. + info : integer + Provides convergence information: + 0 : successful exit + >0 : convergence to tolerance not achieved, number of iterations + <0 : parameter breakdown + + Examples + -------- + >>> import numpy as np + >>> from scipy.sparse import csc_matrix + >>> from scipy.sparse.linalg import bicgstab + >>> R = np.array([[4, 2, 0, 1], + ... [3, 0, 0, 2], + ... [0, 1, 1, 1], + ... [0, 2, 1, 0]]) + >>> A = csc_matrix(R) + >>> b = np.array([-1, -0.5, -1, 2]) + >>> x, exit_code = bicgstab(A, b, atol=1e-5) + >>> print(exit_code) # 0 indicates successful convergence + 0 + >>> np.allclose(A.dot(x), b) + True + + """ + A, M, x, b, postprocess = make_system(A, M, x0, b) + bnrm2 = np.linalg.norm(b) + + atol, _ = _get_atol_rtol('bicgstab', bnrm2, tol, atol, rtol) + + if bnrm2 == 0: + return postprocess(b), 0 + + n = len(b) + + dotprod = np.vdot if np.iscomplexobj(x) else np.dot + + if maxiter is None: + maxiter = n*10 + + matvec = A.matvec + psolve = M.matvec + + # These values make no sense but coming from original Fortran code + # sqrt might have been meant instead. + rhotol = np.finfo(x.dtype.char).eps**2 + omegatol = rhotol + + # Dummy values to initialize vars, silence linter warnings + rho_prev, omega, alpha, p, v = None, None, None, None, None + + r = b - matvec(x) if x.any() else b.copy() + rtilde = r.copy() + + for iteration in range(maxiter): + if np.linalg.norm(r) < atol: # Are we done? + return postprocess(x), 0 + + rho = dotprod(rtilde, r) + if np.abs(rho) < rhotol: # rho breakdown + return postprocess(x), -10 + + if iteration > 0: + if np.abs(omega) < omegatol: # omega breakdown + return postprocess(x), -11 + + beta = (rho / rho_prev) * (alpha / omega) + p -= omega*v + p *= beta + p += r + else: # First spin + s = np.empty_like(r) + p = r.copy() + + phat = psolve(p) + v = matvec(phat) + rv = dotprod(rtilde, v) + if rv == 0: + return postprocess(x), -11 + alpha = rho / rv + r -= alpha*v + s[:] = r[:] + + if np.linalg.norm(s) < atol: + x += alpha*phat + return postprocess(x), 0 + + shat = psolve(s) + t = matvec(shat) + omega = dotprod(t, s) / dotprod(t, t) + x += alpha*phat + x += omega*shat + r -= omega*t + rho_prev = rho + + if callback: + callback(x) + + else: # for loop exhausted + # Return incomplete progress + return postprocess(x), maxiter + + +@_deprecate_positional_args(version="1.14") +def cg(A, b, x0=None, *, tol=_NoValue, maxiter=None, M=None, callback=None, + atol=0., rtol=1e-5): + """Use Conjugate Gradient iteration to solve ``Ax = b``. + + Parameters + ---------- + A : {sparse matrix, ndarray, LinearOperator} + The real or complex N-by-N matrix of the linear system. + ``A`` must represent a hermitian, positive definite matrix. + Alternatively, ``A`` can be a linear operator which can + produce ``Ax`` using, e.g., + ``scipy.sparse.linalg.LinearOperator``. + b : ndarray + Right hand side of the linear system. Has shape (N,) or (N,1). + x0 : ndarray + Starting guess for the solution. + rtol, atol : float, optional + Parameters for the convergence test. For convergence, + ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. + The default is ``atol=0.`` and ``rtol=1e-5``. + maxiter : integer + Maximum number of iterations. Iteration will stop after maxiter + steps even if the specified tolerance has not been achieved. + M : {sparse matrix, ndarray, LinearOperator} + Preconditioner for A. The preconditioner should approximate the + inverse of A. Effective preconditioning dramatically improves the + rate of convergence, which implies that fewer iterations are needed + to reach a given error tolerance. + callback : function + User-supplied function to call after each iteration. It is called + as callback(xk), where xk is the current solution vector. + tol : float, optional, deprecated + + .. deprecated:: 1.12.0 + `cg` keyword argument ``tol`` is deprecated in favor of ``rtol`` and + will be removed in SciPy 1.14.0. + + Returns + ------- + x : ndarray + The converged solution. + info : integer + Provides convergence information: + 0 : successful exit + >0 : convergence to tolerance not achieved, number of iterations + + Examples + -------- + >>> import numpy as np + >>> from scipy.sparse import csc_matrix + >>> from scipy.sparse.linalg import cg + >>> P = np.array([[4, 0, 1, 0], + ... [0, 5, 0, 0], + ... [1, 0, 3, 2], + ... [0, 0, 2, 4]]) + >>> A = csc_matrix(P) + >>> b = np.array([-1, -0.5, -1, 2]) + >>> x, exit_code = cg(A, b, atol=1e-5) + >>> print(exit_code) # 0 indicates successful convergence + 0 + >>> np.allclose(A.dot(x), b) + True + + """ + A, M, x, b, postprocess = make_system(A, M, x0, b) + bnrm2 = np.linalg.norm(b) + + atol, _ = _get_atol_rtol('cg', bnrm2, tol, atol, rtol) + + if bnrm2 == 0: + return postprocess(b), 0 + + n = len(b) + + if maxiter is None: + maxiter = n*10 + + dotprod = np.vdot if np.iscomplexobj(x) else np.dot + + matvec = A.matvec + psolve = M.matvec + r = b - matvec(x) if x.any() else b.copy() + + # Dummy value to initialize var, silences warnings + rho_prev, p = None, None + + for iteration in range(maxiter): + if np.linalg.norm(r) < atol: # Are we done? + return postprocess(x), 0 + + z = psolve(r) + rho_cur = dotprod(r, z) + if iteration > 0: + beta = rho_cur / rho_prev + p *= beta + p += z + else: # First spin + p = np.empty_like(r) + p[:] = z[:] + + q = matvec(p) + alpha = rho_cur / dotprod(p, q) + x += alpha*p + r -= alpha*q + rho_prev = rho_cur + + if callback: + callback(x) + + else: # for loop exhausted + # Return incomplete progress + return postprocess(x), maxiter + + +@_deprecate_positional_args(version="1.14") +def cgs(A, b, x0=None, *, tol=_NoValue, maxiter=None, M=None, callback=None, + atol=0., rtol=1e-5): + """Use Conjugate Gradient Squared iteration to solve ``Ax = b``. + + Parameters + ---------- + A : {sparse matrix, ndarray, LinearOperator} + The real-valued N-by-N matrix of the linear system. + Alternatively, ``A`` can be a linear operator which can + produce ``Ax`` using, e.g., + ``scipy.sparse.linalg.LinearOperator``. + b : ndarray + Right hand side of the linear system. Has shape (N,) or (N,1). + x0 : ndarray + Starting guess for the solution. + rtol, atol : float, optional + Parameters for the convergence test. For convergence, + ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. + The default is ``atol=0.`` and ``rtol=1e-5``. + maxiter : integer + Maximum number of iterations. Iteration will stop after maxiter + steps even if the specified tolerance has not been achieved. + M : {sparse matrix, ndarray, LinearOperator} + Preconditioner for A. The preconditioner should approximate the + inverse of A. Effective preconditioning dramatically improves the + rate of convergence, which implies that fewer iterations are needed + to reach a given error tolerance. + callback : function + User-supplied function to call after each iteration. It is called + as callback(xk), where xk is the current solution vector. + tol : float, optional, deprecated + + .. deprecated:: 1.12.0 + `cgs` keyword argument ``tol`` is deprecated in favor of ``rtol`` + and will be removed in SciPy 1.14.0. + + Returns + ------- + x : ndarray + The converged solution. + info : integer + Provides convergence information: + 0 : successful exit + >0 : convergence to tolerance not achieved, number of iterations + <0 : parameter breakdown + + Examples + -------- + >>> import numpy as np + >>> from scipy.sparse import csc_matrix + >>> from scipy.sparse.linalg import cgs + >>> R = np.array([[4, 2, 0, 1], + ... [3, 0, 0, 2], + ... [0, 1, 1, 1], + ... [0, 2, 1, 0]]) + >>> A = csc_matrix(R) + >>> b = np.array([-1, -0.5, -1, 2]) + >>> x, exit_code = cgs(A, b) + >>> print(exit_code) # 0 indicates successful convergence + 0 + >>> np.allclose(A.dot(x), b) + True + + """ + A, M, x, b, postprocess = make_system(A, M, x0, b) + bnrm2 = np.linalg.norm(b) + + atol, _ = _get_atol_rtol('cgs', bnrm2, tol, atol, rtol) + + if bnrm2 == 0: + return postprocess(b), 0 + + n = len(b) + + dotprod = np.vdot if np.iscomplexobj(x) else np.dot + + if maxiter is None: + maxiter = n*10 + + matvec = A.matvec + psolve = M.matvec + + rhotol = np.finfo(x.dtype.char).eps**2 + + r = b - matvec(x) if x.any() else b.copy() + + rtilde = r.copy() + bnorm = np.linalg.norm(b) + if bnorm == 0: + bnorm = 1 + + # Dummy values to initialize vars, silence linter warnings + rho_prev, p, u, q = None, None, None, None + + for iteration in range(maxiter): + rnorm = np.linalg.norm(r) + if rnorm < atol: # Are we done? + return postprocess(x), 0 + + rho_cur = dotprod(rtilde, r) + if np.abs(rho_cur) < rhotol: # Breakdown case + return postprocess, -10 + + if iteration > 0: + beta = rho_cur / rho_prev + + # u = r + beta * q + # p = u + beta * (q + beta * p); + u[:] = r[:] + u += beta*q + + p *= beta + p += q + p *= beta + p += u + + else: # First spin + p = r.copy() + u = r.copy() + q = np.empty_like(r) + + phat = psolve(p) + vhat = matvec(phat) + rv = dotprod(rtilde, vhat) + + if rv == 0: # Dot product breakdown + return postprocess(x), -11 + + alpha = rho_cur / rv + q[:] = u[:] + q -= alpha*vhat + uhat = psolve(u + q) + x += alpha*uhat + + # Due to numerical error build-up the actual residual is computed + # instead of the following two lines that were in the original + # FORTRAN templates, still using a single matvec. + + # qhat = matvec(uhat) + # r -= alpha*qhat + r = b - matvec(x) + + rho_prev = rho_cur + + if callback: + callback(x) + + else: # for loop exhausted + # Return incomplete progress + return postprocess(x), maxiter + + +@_deprecate_positional_args(version="1.14") +def gmres(A, b, x0=None, *, tol=_NoValue, restart=None, maxiter=None, M=None, + callback=None, restrt=_NoValue, atol=0., callback_type=None, + rtol=1e-5): + """ + Use Generalized Minimal RESidual iteration to solve ``Ax = b``. + + Parameters + ---------- + A : {sparse matrix, ndarray, LinearOperator} + The real or complex N-by-N matrix of the linear system. + Alternatively, ``A`` can be a linear operator which can + produce ``Ax`` using, e.g., + ``scipy.sparse.linalg.LinearOperator``. + b : ndarray + Right hand side of the linear system. Has shape (N,) or (N,1). + x0 : ndarray + Starting guess for the solution (a vector of zeros by default). + atol, rtol : float + Parameters for the convergence test. For convergence, + ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. + The default is ``atol=0.`` and ``rtol=1e-5``. + restart : int, optional + Number of iterations between restarts. Larger values increase + iteration cost, but may be necessary for convergence. + If omitted, ``min(20, n)`` is used. + maxiter : int, optional + Maximum number of iterations (restart cycles). Iteration will stop + after maxiter steps even if the specified tolerance has not been + achieved. See `callback_type`. + M : {sparse matrix, ndarray, LinearOperator} + Inverse of the preconditioner of A. M should approximate the + inverse of A and be easy to solve for (see Notes). Effective + preconditioning dramatically improves the rate of convergence, + which implies that fewer iterations are needed to reach a given + error tolerance. By default, no preconditioner is used. + In this implementation, left preconditioning is used, + and the preconditioned residual is minimized. However, the final + convergence is tested with respect to the ``b - A @ x`` residual. + callback : function + User-supplied function to call after each iteration. It is called + as `callback(args)`, where `args` are selected by `callback_type`. + callback_type : {'x', 'pr_norm', 'legacy'}, optional + Callback function argument requested: + - ``x``: current iterate (ndarray), called on every restart + - ``pr_norm``: relative (preconditioned) residual norm (float), + called on every inner iteration + - ``legacy`` (default): same as ``pr_norm``, but also changes the + meaning of `maxiter` to count inner iterations instead of restart + cycles. + + This keyword has no effect if `callback` is not set. + restrt : int, optional, deprecated + + .. deprecated:: 0.11.0 + `gmres` keyword argument ``restrt`` is deprecated in favor of + ``restart`` and will be removed in SciPy 1.14.0. + tol : float, optional, deprecated + + .. deprecated:: 1.12.0 + `gmres` keyword argument ``tol`` is deprecated in favor of ``rtol`` + and will be removed in SciPy 1.14.0 + + Returns + ------- + x : ndarray + The converged solution. + info : int + Provides convergence information: + 0 : successful exit + >0 : convergence to tolerance not achieved, number of iterations + + See Also + -------- + LinearOperator + + Notes + ----- + A preconditioner, P, is chosen such that P is close to A but easy to solve + for. The preconditioner parameter required by this routine is + ``M = P^-1``. The inverse should preferably not be calculated + explicitly. Rather, use the following template to produce M:: + + # Construct a linear operator that computes P^-1 @ x. + import scipy.sparse.linalg as spla + M_x = lambda x: spla.spsolve(P, x) + M = spla.LinearOperator((n, n), M_x) + + Examples + -------- + >>> import numpy as np + >>> from scipy.sparse import csc_matrix + >>> from scipy.sparse.linalg import gmres + >>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float) + >>> b = np.array([2, 4, -1], dtype=float) + >>> x, exitCode = gmres(A, b, atol=1e-5) + >>> print(exitCode) # 0 indicates successful convergence + 0 + >>> np.allclose(A.dot(x), b) + True + """ + + # Handle the deprecation frenzy + if restrt not in (None, _NoValue) and restart: + raise ValueError("Cannot specify both 'restart' and 'restrt'" + " keywords. Also 'rstrt' is deprecated." + " and will be removed in SciPy 1.14.0. Use " + "'restart' instead.") + if restrt is not _NoValue: + msg = ("'gmres' keyword argument 'restrt' is deprecated " + "in favor of 'restart' and will be removed in SciPy" + " 1.14.0. Until then, if set, 'rstrt' will override 'restart'." + ) + warnings.warn(msg, DeprecationWarning, stacklevel=3) + restart = restrt + + if callback is not None and callback_type is None: + # Warn about 'callback_type' semantic changes. + # Probably should be removed only in far future, Scipy 2.0 or so. + msg = ("scipy.sparse.linalg.gmres called without specifying " + "`callback_type`. The default value will be changed in" + " a future release. For compatibility, specify a value " + "for `callback_type` explicitly, e.g., " + "``gmres(..., callback_type='pr_norm')``, or to retain the " + "old behavior ``gmres(..., callback_type='legacy')``" + ) + warnings.warn(msg, category=DeprecationWarning, stacklevel=3) + + if callback_type is None: + callback_type = 'legacy' + + if callback_type not in ('x', 'pr_norm', 'legacy'): + raise ValueError(f"Unknown callback_type: {callback_type!r}") + + if callback is None: + callback_type = None + + A, M, x, b, postprocess = make_system(A, M, x0, b) + matvec = A.matvec + psolve = M.matvec + n = len(b) + bnrm2 = np.linalg.norm(b) + + atol, _ = _get_atol_rtol('gmres', bnrm2, tol, atol, rtol) + + if bnrm2 == 0: + return postprocess(b), 0 + + eps = np.finfo(x.dtype.char).eps + + dotprod = np.vdot if np.iscomplexobj(x) else np.dot + + if maxiter is None: + maxiter = n*10 + + if restart is None: + restart = 20 + restart = min(restart, n) + + Mb_nrm2 = np.linalg.norm(psolve(b)) + + # ==================================================== + # =========== Tolerance control from gh-8400 ========= + # ==================================================== + # Tolerance passed to GMRESREVCOM applies to the inner + # iteration and deals with the left-preconditioned + # residual. + ptol_max_factor = 1. + ptol = Mb_nrm2 * min(ptol_max_factor, atol / bnrm2) + presid = 0. + # ==================================================== + lartg = get_lapack_funcs('lartg', dtype=x.dtype) + + # allocate internal variables + v = np.empty([restart+1, n], dtype=x.dtype) + h = np.zeros([restart, restart+1], dtype=x.dtype) + givens = np.zeros([restart, 2], dtype=x.dtype) + + # legacy iteration count + inner_iter = 0 + + for iteration in range(maxiter): + if iteration == 0: + r = b - matvec(x) if x.any() else b.copy() + if np.linalg.norm(r) < atol: # Are we done? + return postprocess(x), 0 + + v[0, :] = psolve(r) + tmp = np.linalg.norm(v[0, :]) + v[0, :] *= (1 / tmp) + # RHS of the Hessenberg problem + S = np.zeros(restart+1, dtype=x.dtype) + S[0] = tmp + + breakdown = False + for col in range(restart): + av = matvec(v[col, :]) + w = psolve(av) + + # Modified Gram-Schmidt + h0 = np.linalg.norm(w) + for k in range(col+1): + tmp = dotprod(v[k, :], w) + h[col, k] = tmp + w -= tmp*v[k, :] + + h1 = np.linalg.norm(w) + h[col, col + 1] = h1 + v[col + 1, :] = w[:] + + # Exact solution indicator + if h1 <= eps*h0: + h[col, col + 1] = 0 + breakdown = True + else: + v[col + 1, :] *= (1 / h1) + + # apply past Givens rotations to current h column + for k in range(col): + c, s = givens[k, 0], givens[k, 1] + n0, n1 = h[col, [k, k+1]] + h[col, [k, k + 1]] = [c*n0 + s*n1, -s.conj()*n0 + c*n1] + + # get and apply current rotation to h and S + c, s, mag = lartg(h[col, col], h[col, col+1]) + givens[col, :] = [c, s] + h[col, [col, col+1]] = mag, 0 + + # S[col+1] component is always 0 + tmp = -np.conjugate(s)*S[col] + S[[col, col + 1]] = [c*S[col], tmp] + presid = np.abs(tmp) + inner_iter += 1 + + if callback_type in ('legacy', 'pr_norm'): + callback(presid / bnrm2) + # Legacy behavior + if callback_type == 'legacy' and inner_iter == maxiter: + break + if presid <= ptol or breakdown: + break + + # Solve h(col, col) upper triangular system and allow pseudo-solve + # singular cases as in (but without the f2py copies): + # y = trsv(h[:col+1, :col+1].T, S[:col+1]) + + if h[col, col] == 0: + S[col] = 0 + + y = np.zeros([col+1], dtype=x.dtype) + y[:] = S[:col+1] + for k in range(col, 0, -1): + if y[k] != 0: + y[k] /= h[k, k] + tmp = y[k] + y[:k] -= tmp*h[k, :k] + if y[0] != 0: + y[0] /= h[0, 0] + + x += y @ v[:col+1, :] + + r = b - matvec(x) + rnorm = np.linalg.norm(r) + + # Legacy exit + if callback_type == 'legacy' and inner_iter == maxiter: + return postprocess(x), 0 if rnorm <= atol else maxiter + + if callback_type == 'x': + callback(x) + + if rnorm <= atol: + break + elif breakdown: + # Reached breakdown (= exact solution), but the external + # tolerance check failed. Bail out with failure. + break + elif presid <= ptol: + # Inner loop passed but outer didn't + ptol_max_factor = max(eps, 0.25 * ptol_max_factor) + else: + ptol_max_factor = min(1.0, 1.5 * ptol_max_factor) + + ptol = presid * min(ptol_max_factor, atol / rnorm) + + info = 0 if (rnorm <= atol) else maxiter + return postprocess(x), info + + +@_deprecate_positional_args(version="1.14") +def qmr(A, b, x0=None, *, tol=_NoValue, maxiter=None, M1=None, M2=None, + callback=None, atol=0., rtol=1e-5): + """Use Quasi-Minimal Residual iteration to solve ``Ax = b``. + + Parameters + ---------- + A : {sparse matrix, ndarray, LinearOperator} + The real-valued N-by-N matrix of the linear system. + Alternatively, ``A`` can be a linear operator which can + produce ``Ax`` and ``A^T x`` using, e.g., + ``scipy.sparse.linalg.LinearOperator``. + b : ndarray + Right hand side of the linear system. Has shape (N,) or (N,1). + x0 : ndarray + Starting guess for the solution. + atol, rtol : float, optional + Parameters for the convergence test. For convergence, + ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. + The default is ``atol=0.`` and ``rtol=1e-5``. + maxiter : integer + Maximum number of iterations. Iteration will stop after maxiter + steps even if the specified tolerance has not been achieved. + M1 : {sparse matrix, ndarray, LinearOperator} + Left preconditioner for A. + M2 : {sparse matrix, ndarray, LinearOperator} + Right preconditioner for A. Used together with the left + preconditioner M1. The matrix M1@A@M2 should have better + conditioned than A alone. + callback : function + User-supplied function to call after each iteration. It is called + as callback(xk), where xk is the current solution vector. + tol : float, optional, deprecated + + .. deprecated:: 1.12.0 + `qmr` keyword argument ``tol`` is deprecated in favor of ``rtol`` + and will be removed in SciPy 1.14.0. + + Returns + ------- + x : ndarray + The converged solution. + info : integer + Provides convergence information: + 0 : successful exit + >0 : convergence to tolerance not achieved, number of iterations + <0 : parameter breakdown + + See Also + -------- + LinearOperator + + Examples + -------- + >>> import numpy as np + >>> from scipy.sparse import csc_matrix + >>> from scipy.sparse.linalg import qmr + >>> A = csc_matrix([[3., 2., 0.], [1., -1., 0.], [0., 5., 1.]]) + >>> b = np.array([2., 4., -1.]) + >>> x, exitCode = qmr(A, b, atol=1e-5) + >>> print(exitCode) # 0 indicates successful convergence + 0 + >>> np.allclose(A.dot(x), b) + True + """ + A_ = A + A, M, x, b, postprocess = make_system(A, None, x0, b) + bnrm2 = np.linalg.norm(b) + + atol, _ = _get_atol_rtol('qmr', bnrm2, tol, atol, rtol) + + if bnrm2 == 0: + return postprocess(b), 0 + + if M1 is None and M2 is None: + if hasattr(A_, 'psolve'): + def left_psolve(b): + return A_.psolve(b, 'left') + + def right_psolve(b): + return A_.psolve(b, 'right') + + def left_rpsolve(b): + return A_.rpsolve(b, 'left') + + def right_rpsolve(b): + return A_.rpsolve(b, 'right') + M1 = LinearOperator(A.shape, + matvec=left_psolve, + rmatvec=left_rpsolve) + M2 = LinearOperator(A.shape, + matvec=right_psolve, + rmatvec=right_rpsolve) + else: + def id(b): + return b + M1 = LinearOperator(A.shape, matvec=id, rmatvec=id) + M2 = LinearOperator(A.shape, matvec=id, rmatvec=id) + + n = len(b) + if maxiter is None: + maxiter = n*10 + + dotprod = np.vdot if np.iscomplexobj(x) else np.dot + + rhotol = np.finfo(x.dtype.char).eps + betatol = rhotol + gammatol = rhotol + deltatol = rhotol + epsilontol = rhotol + xitol = rhotol + + r = b - A.matvec(x) if x.any() else b.copy() + + vtilde = r.copy() + y = M1.matvec(vtilde) + rho = np.linalg.norm(y) + wtilde = r.copy() + z = M2.rmatvec(wtilde) + xi = np.linalg.norm(z) + gamma, eta, theta = 1, -1, 0 + v = np.empty_like(vtilde) + w = np.empty_like(wtilde) + + # Dummy values to initialize vars, silence linter warnings + epsilon, q, d, p, s = None, None, None, None, None + + for iteration in range(maxiter): + if np.linalg.norm(r) < atol: # Are we done? + return postprocess(x), 0 + if np.abs(rho) < rhotol: # rho breakdown + return postprocess(x), -10 + if np.abs(xi) < xitol: # xi breakdown + return postprocess(x), -15 + + v[:] = vtilde[:] + v *= (1 / rho) + y *= (1 / rho) + w[:] = wtilde[:] + w *= (1 / xi) + z *= (1 / xi) + delta = dotprod(z, y) + + if np.abs(delta) < deltatol: # delta breakdown + return postprocess(x), -13 + + ytilde = M2.matvec(y) + ztilde = M1.rmatvec(z) + + if iteration > 0: + ytilde -= (xi * delta / epsilon) * p + p[:] = ytilde[:] + ztilde -= (rho * (delta / epsilon).conj()) * q + q[:] = ztilde[:] + else: # First spin + p = ytilde.copy() + q = ztilde.copy() + + ptilde = A.matvec(p) + epsilon = dotprod(q, ptilde) + if np.abs(epsilon) < epsilontol: # epsilon breakdown + return postprocess(x), -14 + + beta = epsilon / delta + if np.abs(beta) < betatol: # beta breakdown + return postprocess(x), -11 + + vtilde[:] = ptilde[:] + vtilde -= beta*v + y = M1.matvec(vtilde) + + rho_prev = rho + rho = np.linalg.norm(y) + wtilde[:] = w[:] + wtilde *= - beta.conj() + wtilde += A.rmatvec(q) + z = M2.rmatvec(wtilde) + xi = np.linalg.norm(z) + gamma_prev = gamma + theta_prev = theta + theta = rho / (gamma_prev * np.abs(beta)) + gamma = 1 / np.sqrt(1 + theta**2) + + if np.abs(gamma) < gammatol: # gamma breakdown + return postprocess(x), -12 + + eta *= -(rho_prev / beta) * (gamma / gamma_prev)**2 + + if iteration > 0: + d *= (theta_prev * gamma) ** 2 + d += eta*p + s *= (theta_prev * gamma) ** 2 + s += eta*ptilde + else: + d = p.copy() + d *= eta + s = ptilde.copy() + s *= eta + + x += d + r -= s + + if callback: + callback(x) + + else: # for loop exhausted + # Return incomplete progress + return postprocess(x), maxiter diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/lgmres.py b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/lgmres.py new file mode 100644 index 0000000000000000000000000000000000000000..012479576def42c2daf3670270717c039da0d39c --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/lgmres.py @@ -0,0 +1,242 @@ +# Copyright (C) 2009, Pauli Virtanen +# Distributed under the same license as SciPy. + +import numpy as np +from numpy.linalg import LinAlgError +from scipy.linalg import get_blas_funcs +from .iterative import _get_atol_rtol +from .utils import make_system +from scipy._lib.deprecation import _NoValue, _deprecate_positional_args + +from ._gcrotmk import _fgmres + +__all__ = ['lgmres'] + + +@_deprecate_positional_args(version="1.14.0") +def lgmres(A, b, x0=None, *, tol=_NoValue, maxiter=1000, M=None, callback=None, + inner_m=30, outer_k=3, outer_v=None, store_outer_Av=True, + prepend_outer_v=False, atol=None, rtol=1e-5): + """ + Solve a matrix equation using the LGMRES algorithm. + + The LGMRES algorithm [1]_ [2]_ is designed to avoid some problems + in the convergence in restarted GMRES, and often converges in fewer + iterations. + + Parameters + ---------- + A : {sparse matrix, ndarray, LinearOperator} + The real or complex N-by-N matrix of the linear system. + Alternatively, ``A`` can be a linear operator which can + produce ``Ax`` using, e.g., + ``scipy.sparse.linalg.LinearOperator``. + b : ndarray + Right hand side of the linear system. Has shape (N,) or (N,1). + x0 : ndarray + Starting guess for the solution. + rtol, atol : float, optional + Parameters for the convergence test. For convergence, + ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. + The default is ``rtol=1e-5``, the default for ``atol`` is ``rtol``. + + .. warning:: + + The default value for ``atol`` will be changed to ``0.0`` in + SciPy 1.14.0. + maxiter : int, optional + Maximum number of iterations. Iteration will stop after maxiter + steps even if the specified tolerance has not been achieved. + M : {sparse matrix, ndarray, LinearOperator}, optional + Preconditioner for A. The preconditioner should approximate the + inverse of A. Effective preconditioning dramatically improves the + rate of convergence, which implies that fewer iterations are needed + to reach a given error tolerance. + callback : function, optional + User-supplied function to call after each iteration. It is called + as callback(xk), where xk is the current solution vector. + inner_m : int, optional + Number of inner GMRES iterations per each outer iteration. + outer_k : int, optional + Number of vectors to carry between inner GMRES iterations. + According to [1]_, good values are in the range of 1...3. + However, note that if you want to use the additional vectors to + accelerate solving multiple similar problems, larger values may + be beneficial. + outer_v : list of tuples, optional + List containing tuples ``(v, Av)`` of vectors and corresponding + matrix-vector products, used to augment the Krylov subspace, and + carried between inner GMRES iterations. The element ``Av`` can + be `None` if the matrix-vector product should be re-evaluated. + This parameter is modified in-place by `lgmres`, and can be used + to pass "guess" vectors in and out of the algorithm when solving + similar problems. + store_outer_Av : bool, optional + Whether LGMRES should store also A@v in addition to vectors `v` + in the `outer_v` list. Default is True. + prepend_outer_v : bool, optional + Whether to put outer_v augmentation vectors before Krylov iterates. + In standard LGMRES, prepend_outer_v=False. + tol : float, optional, deprecated + + .. deprecated:: 1.12.0 + `lgmres` keyword argument ``tol`` is deprecated in favor of ``rtol`` + and will be removed in SciPy 1.14.0. + + Returns + ------- + x : ndarray + The converged solution. + info : int + Provides convergence information: + + - 0 : successful exit + - >0 : convergence to tolerance not achieved, number of iterations + - <0 : illegal input or breakdown + + Notes + ----- + The LGMRES algorithm [1]_ [2]_ is designed to avoid the + slowing of convergence in restarted GMRES, due to alternating + residual vectors. Typically, it often outperforms GMRES(m) of + comparable memory requirements by some measure, or at least is not + much worse. + + Another advantage in this algorithm is that you can supply it with + 'guess' vectors in the `outer_v` argument that augment the Krylov + subspace. If the solution lies close to the span of these vectors, + the algorithm converges faster. This can be useful if several very + similar matrices need to be inverted one after another, such as in + Newton-Krylov iteration where the Jacobian matrix often changes + little in the nonlinear steps. + + References + ---------- + .. [1] A.H. Baker and E.R. Jessup and T. Manteuffel, "A Technique for + Accelerating the Convergence of Restarted GMRES", SIAM J. Matrix + Anal. Appl. 26, 962 (2005). + .. [2] A.H. Baker, "On Improving the Performance of the Linear Solver + restarted GMRES", PhD thesis, University of Colorado (2003). + + Examples + -------- + >>> import numpy as np + >>> from scipy.sparse import csc_matrix + >>> from scipy.sparse.linalg import lgmres + >>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float) + >>> b = np.array([2, 4, -1], dtype=float) + >>> x, exitCode = lgmres(A, b, atol=1e-5) + >>> print(exitCode) # 0 indicates successful convergence + 0 + >>> np.allclose(A.dot(x), b) + True + """ + A,M,x,b,postprocess = make_system(A,M,x0,b) + + if not np.isfinite(b).all(): + raise ValueError("RHS must contain only finite numbers") + + matvec = A.matvec + psolve = M.matvec + + if outer_v is None: + outer_v = [] + + axpy, dot, scal = None, None, None + nrm2 = get_blas_funcs('nrm2', [b]) + + b_norm = nrm2(b) + + # we call this to get the right atol/rtol and raise warnings as necessary + atol, rtol = _get_atol_rtol('lgmres', b_norm, tol, atol, rtol) + + if b_norm == 0: + x = b + return (postprocess(x), 0) + + ptol_max_factor = 1.0 + + for k_outer in range(maxiter): + r_outer = matvec(x) - b + + # -- callback + if callback is not None: + callback(x) + + # -- determine input type routines + if axpy is None: + if np.iscomplexobj(r_outer) and not np.iscomplexobj(x): + x = x.astype(r_outer.dtype) + axpy, dot, scal, nrm2 = get_blas_funcs(['axpy', 'dot', 'scal', 'nrm2'], + (x, r_outer)) + + # -- check stopping condition + r_norm = nrm2(r_outer) + if r_norm <= max(atol, rtol * b_norm): + break + + # -- inner LGMRES iteration + v0 = -psolve(r_outer) + inner_res_0 = nrm2(v0) + + if inner_res_0 == 0: + rnorm = nrm2(r_outer) + raise RuntimeError("Preconditioner returned a zero vector; " + "|v| ~ %.1g, |M v| = 0" % rnorm) + + v0 = scal(1.0/inner_res_0, v0) + + ptol = min(ptol_max_factor, max(atol, rtol*b_norm)/r_norm) + + try: + Q, R, B, vs, zs, y, pres = _fgmres(matvec, + v0, + inner_m, + lpsolve=psolve, + atol=ptol, + outer_v=outer_v, + prepend_outer_v=prepend_outer_v) + y *= inner_res_0 + if not np.isfinite(y).all(): + # Overflow etc. in computation. There's no way to + # recover from this, so we have to bail out. + raise LinAlgError() + except LinAlgError: + # Floating point over/underflow, non-finite result from + # matmul etc. -- report failure. + return postprocess(x), k_outer + 1 + + # Inner loop tolerance control + if pres > ptol: + ptol_max_factor = min(1.0, 1.5 * ptol_max_factor) + else: + ptol_max_factor = max(1e-16, 0.25 * ptol_max_factor) + + # -- GMRES terminated: eval solution + dx = zs[0]*y[0] + for w, yc in zip(zs[1:], y[1:]): + dx = axpy(w, dx, dx.shape[0], yc) # dx += w*yc + + # -- Store LGMRES augmentation vectors + nx = nrm2(dx) + if nx > 0: + if store_outer_Av: + q = Q.dot(R.dot(y)) + ax = vs[0]*q[0] + for v, qc in zip(vs[1:], q[1:]): + ax = axpy(v, ax, ax.shape[0], qc) + outer_v.append((dx/nx, ax/nx)) + else: + outer_v.append((dx/nx, None)) + + # -- Retain only a finite number of augmentation vectors + while len(outer_v) > outer_k: + del outer_v[0] + + # -- Apply step + x += dx + else: + # didn't converge ... + return postprocess(x), maxiter + + return postprocess(x), 0 diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/lsqr.py b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/lsqr.py new file mode 100644 index 0000000000000000000000000000000000000000..010f61bc5412f96a31ef5303f09b5167556e80ce --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/lsqr.py @@ -0,0 +1,587 @@ +"""Sparse Equations and Least Squares. + +The original Fortran code was written by C. C. Paige and M. A. Saunders as +described in + +C. C. Paige and M. A. Saunders, LSQR: An algorithm for sparse linear +equations and sparse least squares, TOMS 8(1), 43--71 (1982). + +C. C. Paige and M. A. Saunders, Algorithm 583; LSQR: Sparse linear +equations and least-squares problems, TOMS 8(2), 195--209 (1982). + +It is licensed under the following BSD license: + +Copyright (c) 2006, Systems Optimization Laboratory +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Stanford University nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The Fortran code was translated to Python for use in CVXOPT by Jeffery +Kline with contributions by Mridul Aanjaneya and Bob Myhill. + +Adapted for SciPy by Stefan van der Walt. + +""" + +__all__ = ['lsqr'] + +import numpy as np +from math import sqrt +from scipy.sparse.linalg._interface import aslinearoperator + +eps = np.finfo(np.float64).eps + + +def _sym_ortho(a, b): + """ + Stable implementation of Givens rotation. + + Notes + ----- + The routine 'SymOrtho' was added for numerical stability. This is + recommended by S.-C. Choi in [1]_. It removes the unpleasant potential of + ``1/eps`` in some important places (see, for example text following + "Compute the next plane rotation Qk" in minres.py). + + References + ---------- + .. [1] S.-C. Choi, "Iterative Methods for Singular Linear Equations + and Least-Squares Problems", Dissertation, + http://www.stanford.edu/group/SOL/dissertations/sou-cheng-choi-thesis.pdf + + """ + if b == 0: + return np.sign(a), 0, abs(a) + elif a == 0: + return 0, np.sign(b), abs(b) + elif abs(b) > abs(a): + tau = a / b + s = np.sign(b) / sqrt(1 + tau * tau) + c = s * tau + r = b / s + else: + tau = b / a + c = np.sign(a) / sqrt(1+tau*tau) + s = c * tau + r = a / c + return c, s, r + + +def lsqr(A, b, damp=0.0, atol=1e-6, btol=1e-6, conlim=1e8, + iter_lim=None, show=False, calc_var=False, x0=None): + """Find the least-squares solution to a large, sparse, linear system + of equations. + + The function solves ``Ax = b`` or ``min ||Ax - b||^2`` or + ``min ||Ax - b||^2 + d^2 ||x - x0||^2``. + + The matrix A may be square or rectangular (over-determined or + under-determined), and may have any rank. + + :: + + 1. Unsymmetric equations -- solve Ax = b + + 2. Linear least squares -- solve Ax = b + in the least-squares sense + + 3. Damped least squares -- solve ( A )*x = ( b ) + ( damp*I ) ( damp*x0 ) + in the least-squares sense + + Parameters + ---------- + A : {sparse matrix, ndarray, LinearOperator} + Representation of an m-by-n matrix. + Alternatively, ``A`` can be a linear operator which can + produce ``Ax`` and ``A^T x`` using, e.g., + ``scipy.sparse.linalg.LinearOperator``. + b : array_like, shape (m,) + Right-hand side vector ``b``. + damp : float + Damping coefficient. Default is 0. + atol, btol : float, optional + Stopping tolerances. `lsqr` continues iterations until a + certain backward error estimate is smaller than some quantity + depending on atol and btol. Let ``r = b - Ax`` be the + residual vector for the current approximate solution ``x``. + If ``Ax = b`` seems to be consistent, `lsqr` terminates + when ``norm(r) <= atol * norm(A) * norm(x) + btol * norm(b)``. + Otherwise, `lsqr` terminates when ``norm(A^H r) <= + atol * norm(A) * norm(r)``. If both tolerances are 1.0e-6 (default), + the final ``norm(r)`` should be accurate to about 6 + digits. (The final ``x`` will usually have fewer correct digits, + depending on ``cond(A)`` and the size of LAMBDA.) If `atol` + or `btol` is None, a default value of 1.0e-6 will be used. + Ideally, they should be estimates of the relative error in the + entries of ``A`` and ``b`` respectively. For example, if the entries + of ``A`` have 7 correct digits, set ``atol = 1e-7``. This prevents + the algorithm from doing unnecessary work beyond the + uncertainty of the input data. + conlim : float, optional + Another stopping tolerance. lsqr terminates if an estimate of + ``cond(A)`` exceeds `conlim`. For compatible systems ``Ax = + b``, `conlim` could be as large as 1.0e+12 (say). For + least-squares problems, conlim should be less than 1.0e+8. + Maximum precision can be obtained by setting ``atol = btol = + conlim = zero``, but the number of iterations may then be + excessive. Default is 1e8. + iter_lim : int, optional + Explicit limitation on number of iterations (for safety). + show : bool, optional + Display an iteration log. Default is False. + calc_var : bool, optional + Whether to estimate diagonals of ``(A'A + damp^2*I)^{-1}``. + x0 : array_like, shape (n,), optional + Initial guess of x, if None zeros are used. Default is None. + + .. versionadded:: 1.0.0 + + Returns + ------- + x : ndarray of float + The final solution. + istop : int + Gives the reason for termination. + 1 means x is an approximate solution to Ax = b. + 2 means x approximately solves the least-squares problem. + itn : int + Iteration number upon termination. + r1norm : float + ``norm(r)``, where ``r = b - Ax``. + r2norm : float + ``sqrt( norm(r)^2 + damp^2 * norm(x - x0)^2 )``. Equal to `r1norm` + if ``damp == 0``. + anorm : float + Estimate of Frobenius norm of ``Abar = [[A]; [damp*I]]``. + acond : float + Estimate of ``cond(Abar)``. + arnorm : float + Estimate of ``norm(A'@r - damp^2*(x - x0))``. + xnorm : float + ``norm(x)`` + var : ndarray of float + If ``calc_var`` is True, estimates all diagonals of + ``(A'A)^{-1}`` (if ``damp == 0``) or more generally ``(A'A + + damp^2*I)^{-1}``. This is well defined if A has full column + rank or ``damp > 0``. (Not sure what var means if ``rank(A) + < n`` and ``damp = 0.``) + + Notes + ----- + LSQR uses an iterative method to approximate the solution. The + number of iterations required to reach a certain accuracy depends + strongly on the scaling of the problem. Poor scaling of the rows + or columns of A should therefore be avoided where possible. + + For example, in problem 1 the solution is unaltered by + row-scaling. If a row of A is very small or large compared to + the other rows of A, the corresponding row of ( A b ) should be + scaled up or down. + + In problems 1 and 2, the solution x is easily recovered + following column-scaling. Unless better information is known, + the nonzero columns of A should be scaled so that they all have + the same Euclidean norm (e.g., 1.0). + + In problem 3, there is no freedom to re-scale if damp is + nonzero. However, the value of damp should be assigned only + after attention has been paid to the scaling of A. + + The parameter damp is intended to help regularize + ill-conditioned systems, by preventing the true solution from + being very large. Another aid to regularization is provided by + the parameter acond, which may be used to terminate iterations + before the computed solution becomes very large. + + If some initial estimate ``x0`` is known and if ``damp == 0``, + one could proceed as follows: + + 1. Compute a residual vector ``r0 = b - A@x0``. + 2. Use LSQR to solve the system ``A@dx = r0``. + 3. Add the correction dx to obtain a final solution ``x = x0 + dx``. + + This requires that ``x0`` be available before and after the call + to LSQR. To judge the benefits, suppose LSQR takes k1 iterations + to solve A@x = b and k2 iterations to solve A@dx = r0. + If x0 is "good", norm(r0) will be smaller than norm(b). + If the same stopping tolerances atol and btol are used for each + system, k1 and k2 will be similar, but the final solution x0 + dx + should be more accurate. The only way to reduce the total work + is to use a larger stopping tolerance for the second system. + If some value btol is suitable for A@x = b, the larger value + btol*norm(b)/norm(r0) should be suitable for A@dx = r0. + + Preconditioning is another way to reduce the number of iterations. + If it is possible to solve a related system ``M@x = b`` + efficiently, where M approximates A in some helpful way (e.g. M - + A has low rank or its elements are small relative to those of A), + LSQR may converge more rapidly on the system ``A@M(inverse)@z = + b``, after which x can be recovered by solving M@x = z. + + If A is symmetric, LSQR should not be used! + + Alternatives are the symmetric conjugate-gradient method (cg) + and/or SYMMLQ. SYMMLQ is an implementation of symmetric cg that + applies to any symmetric A and will converge more rapidly than + LSQR. If A is positive definite, there are other implementations + of symmetric cg that require slightly less work per iteration than + SYMMLQ (but will take the same number of iterations). + + References + ---------- + .. [1] C. C. Paige and M. A. Saunders (1982a). + "LSQR: An algorithm for sparse linear equations and + sparse least squares", ACM TOMS 8(1), 43-71. + .. [2] C. C. Paige and M. A. Saunders (1982b). + "Algorithm 583. LSQR: Sparse linear equations and least + squares problems", ACM TOMS 8(2), 195-209. + .. [3] M. A. Saunders (1995). "Solution of sparse rectangular + systems using LSQR and CRAIG", BIT 35, 588-604. + + Examples + -------- + >>> import numpy as np + >>> from scipy.sparse import csc_matrix + >>> from scipy.sparse.linalg import lsqr + >>> A = csc_matrix([[1., 0.], [1., 1.], [0., 1.]], dtype=float) + + The first example has the trivial solution ``[0, 0]`` + + >>> b = np.array([0., 0., 0.], dtype=float) + >>> x, istop, itn, normr = lsqr(A, b)[:4] + >>> istop + 0 + >>> x + array([ 0., 0.]) + + The stopping code `istop=0` returned indicates that a vector of zeros was + found as a solution. The returned solution `x` indeed contains + ``[0., 0.]``. The next example has a non-trivial solution: + + >>> b = np.array([1., 0., -1.], dtype=float) + >>> x, istop, itn, r1norm = lsqr(A, b)[:4] + >>> istop + 1 + >>> x + array([ 1., -1.]) + >>> itn + 1 + >>> r1norm + 4.440892098500627e-16 + + As indicated by `istop=1`, `lsqr` found a solution obeying the tolerance + limits. The given solution ``[1., -1.]`` obviously solves the equation. The + remaining return values include information about the number of iterations + (`itn=1`) and the remaining difference of left and right side of the solved + equation. + The final example demonstrates the behavior in the case where there is no + solution for the equation: + + >>> b = np.array([1., 0.01, -1.], dtype=float) + >>> x, istop, itn, r1norm = lsqr(A, b)[:4] + >>> istop + 2 + >>> x + array([ 1.00333333, -0.99666667]) + >>> A.dot(x)-b + array([ 0.00333333, -0.00333333, 0.00333333]) + >>> r1norm + 0.005773502691896255 + + `istop` indicates that the system is inconsistent and thus `x` is rather an + approximate solution to the corresponding least-squares problem. `r1norm` + contains the norm of the minimal residual that was found. + """ + A = aslinearoperator(A) + b = np.atleast_1d(b) + if b.ndim > 1: + b = b.squeeze() + + m, n = A.shape + if iter_lim is None: + iter_lim = 2 * n + var = np.zeros(n) + + msg = ('The exact solution is x = 0 ', + 'Ax - b is small enough, given atol, btol ', + 'The least-squares solution is good enough, given atol ', + 'The estimate of cond(Abar) has exceeded conlim ', + 'Ax - b is small enough for this machine ', + 'The least-squares solution is good enough for this machine', + 'Cond(Abar) seems to be too large for this machine ', + 'The iteration limit has been reached ') + + if show: + print(' ') + print('LSQR Least-squares solution of Ax = b') + str1 = f'The matrix A has {m} rows and {n} columns' + str2 = f'damp = {damp:20.14e} calc_var = {calc_var:8g}' + str3 = f'atol = {atol:8.2e} conlim = {conlim:8.2e}' + str4 = f'btol = {btol:8.2e} iter_lim = {iter_lim:8g}' + print(str1) + print(str2) + print(str3) + print(str4) + + itn = 0 + istop = 0 + ctol = 0 + if conlim > 0: + ctol = 1/conlim + anorm = 0 + acond = 0 + dampsq = damp**2 + ddnorm = 0 + res2 = 0 + xnorm = 0 + xxnorm = 0 + z = 0 + cs2 = -1 + sn2 = 0 + + # Set up the first vectors u and v for the bidiagonalization. + # These satisfy beta*u = b - A@x, alfa*v = A'@u. + u = b + bnorm = np.linalg.norm(b) + + if x0 is None: + x = np.zeros(n) + beta = bnorm.copy() + else: + x = np.asarray(x0) + u = u - A.matvec(x) + beta = np.linalg.norm(u) + + if beta > 0: + u = (1/beta) * u + v = A.rmatvec(u) + alfa = np.linalg.norm(v) + else: + v = x.copy() + alfa = 0 + + if alfa > 0: + v = (1/alfa) * v + w = v.copy() + + rhobar = alfa + phibar = beta + rnorm = beta + r1norm = rnorm + r2norm = rnorm + + # Reverse the order here from the original matlab code because + # there was an error on return when arnorm==0 + arnorm = alfa * beta + if arnorm == 0: + if show: + print(msg[0]) + return x, istop, itn, r1norm, r2norm, anorm, acond, arnorm, xnorm, var + + head1 = ' Itn x[0] r1norm r2norm ' + head2 = ' Compatible LS Norm A Cond A' + + if show: + print(' ') + print(head1, head2) + test1 = 1 + test2 = alfa / beta + str1 = f'{itn:6g} {x[0]:12.5e}' + str2 = f' {r1norm:10.3e} {r2norm:10.3e}' + str3 = f' {test1:8.1e} {test2:8.1e}' + print(str1, str2, str3) + + # Main iteration loop. + while itn < iter_lim: + itn = itn + 1 + # Perform the next step of the bidiagonalization to obtain the + # next beta, u, alfa, v. These satisfy the relations + # beta*u = a@v - alfa*u, + # alfa*v = A'@u - beta*v. + u = A.matvec(v) - alfa * u + beta = np.linalg.norm(u) + + if beta > 0: + u = (1/beta) * u + anorm = sqrt(anorm**2 + alfa**2 + beta**2 + dampsq) + v = A.rmatvec(u) - beta * v + alfa = np.linalg.norm(v) + if alfa > 0: + v = (1 / alfa) * v + + # Use a plane rotation to eliminate the damping parameter. + # This alters the diagonal (rhobar) of the lower-bidiagonal matrix. + if damp > 0: + rhobar1 = sqrt(rhobar**2 + dampsq) + cs1 = rhobar / rhobar1 + sn1 = damp / rhobar1 + psi = sn1 * phibar + phibar = cs1 * phibar + else: + # cs1 = 1 and sn1 = 0 + rhobar1 = rhobar + psi = 0. + + # Use a plane rotation to eliminate the subdiagonal element (beta) + # of the lower-bidiagonal matrix, giving an upper-bidiagonal matrix. + cs, sn, rho = _sym_ortho(rhobar1, beta) + + theta = sn * alfa + rhobar = -cs * alfa + phi = cs * phibar + phibar = sn * phibar + tau = sn * phi + + # Update x and w. + t1 = phi / rho + t2 = -theta / rho + dk = (1 / rho) * w + + x = x + t1 * w + w = v + t2 * w + ddnorm = ddnorm + np.linalg.norm(dk)**2 + + if calc_var: + var = var + dk**2 + + # Use a plane rotation on the right to eliminate the + # super-diagonal element (theta) of the upper-bidiagonal matrix. + # Then use the result to estimate norm(x). + delta = sn2 * rho + gambar = -cs2 * rho + rhs = phi - delta * z + zbar = rhs / gambar + xnorm = sqrt(xxnorm + zbar**2) + gamma = sqrt(gambar**2 + theta**2) + cs2 = gambar / gamma + sn2 = theta / gamma + z = rhs / gamma + xxnorm = xxnorm + z**2 + + # Test for convergence. + # First, estimate the condition of the matrix Abar, + # and the norms of rbar and Abar'rbar. + acond = anorm * sqrt(ddnorm) + res1 = phibar**2 + res2 = res2 + psi**2 + rnorm = sqrt(res1 + res2) + arnorm = alfa * abs(tau) + + # Distinguish between + # r1norm = ||b - Ax|| and + # r2norm = rnorm in current code + # = sqrt(r1norm^2 + damp^2*||x - x0||^2). + # Estimate r1norm from + # r1norm = sqrt(r2norm^2 - damp^2*||x - x0||^2). + # Although there is cancellation, it might be accurate enough. + if damp > 0: + r1sq = rnorm**2 - dampsq * xxnorm + r1norm = sqrt(abs(r1sq)) + if r1sq < 0: + r1norm = -r1norm + else: + r1norm = rnorm + r2norm = rnorm + + # Now use these norms to estimate certain other quantities, + # some of which will be small near a solution. + test1 = rnorm / bnorm + test2 = arnorm / (anorm * rnorm + eps) + test3 = 1 / (acond + eps) + t1 = test1 / (1 + anorm * xnorm / bnorm) + rtol = btol + atol * anorm * xnorm / bnorm + + # The following tests guard against extremely small values of + # atol, btol or ctol. (The user may have set any or all of + # the parameters atol, btol, conlim to 0.) + # The effect is equivalent to the normal tests using + # atol = eps, btol = eps, conlim = 1/eps. + if itn >= iter_lim: + istop = 7 + if 1 + test3 <= 1: + istop = 6 + if 1 + test2 <= 1: + istop = 5 + if 1 + t1 <= 1: + istop = 4 + + # Allow for tolerances set by the user. + if test3 <= ctol: + istop = 3 + if test2 <= atol: + istop = 2 + if test1 <= rtol: + istop = 1 + + if show: + # See if it is time to print something. + prnt = False + if n <= 40: + prnt = True + if itn <= 10: + prnt = True + if itn >= iter_lim-10: + prnt = True + # if itn%10 == 0: prnt = True + if test3 <= 2*ctol: + prnt = True + if test2 <= 10*atol: + prnt = True + if test1 <= 10*rtol: + prnt = True + if istop != 0: + prnt = True + + if prnt: + str1 = f'{itn:6g} {x[0]:12.5e}' + str2 = f' {r1norm:10.3e} {r2norm:10.3e}' + str3 = f' {test1:8.1e} {test2:8.1e}' + str4 = f' {anorm:8.1e} {acond:8.1e}' + print(str1, str2, str3, str4) + + if istop != 0: + break + + # End of iteration loop. + # Print the stopping condition. + if show: + print(' ') + print('LSQR finished') + print(msg[istop]) + print(' ') + str1 = f'istop ={istop:8g} r1norm ={r1norm:8.1e}' + str2 = f'anorm ={anorm:8.1e} arnorm ={arnorm:8.1e}' + str3 = f'itn ={itn:8g} r2norm ={r2norm:8.1e}' + str4 = f'acond ={acond:8.1e} xnorm ={xnorm:8.1e}' + print(str1 + ' ' + str2) + print(str3 + ' ' + str4) + print(' ') + + return x, istop, itn, r1norm, r2norm, anorm, acond, arnorm, xnorm, var diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/minres.py b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/minres.py new file mode 100644 index 0000000000000000000000000000000000000000..daea59e920ff8dabb28cab98a058c049c764f959 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/minres.py @@ -0,0 +1,387 @@ +import warnings +from numpy import inner, zeros, inf, finfo +from numpy.linalg import norm +from math import sqrt + +from .utils import make_system +from scipy._lib.deprecation import _NoValue, _deprecate_positional_args + +__all__ = ['minres'] + + +@_deprecate_positional_args(version="1.14.0") +def minres(A, b, x0=None, *, shift=0.0, tol=_NoValue, maxiter=None, + M=None, callback=None, show=False, check=False, rtol=1e-5): + """ + Use MINimum RESidual iteration to solve Ax=b + + MINRES minimizes norm(Ax - b) for a real symmetric matrix A. Unlike + the Conjugate Gradient method, A can be indefinite or singular. + + If shift != 0 then the method solves (A - shift*I)x = b + + Parameters + ---------- + A : {sparse matrix, ndarray, LinearOperator} + The real symmetric N-by-N matrix of the linear system + Alternatively, ``A`` can be a linear operator which can + produce ``Ax`` using, e.g., + ``scipy.sparse.linalg.LinearOperator``. + b : ndarray + Right hand side of the linear system. Has shape (N,) or (N,1). + + Returns + ------- + x : ndarray + The converged solution. + info : integer + Provides convergence information: + 0 : successful exit + >0 : convergence to tolerance not achieved, number of iterations + <0 : illegal input or breakdown + + Other Parameters + ---------------- + x0 : ndarray + Starting guess for the solution. + shift : float + Value to apply to the system ``(A - shift * I)x = b``. Default is 0. + rtol : float + Tolerance to achieve. The algorithm terminates when the relative + residual is below ``rtol``. + maxiter : integer + Maximum number of iterations. Iteration will stop after maxiter + steps even if the specified tolerance has not been achieved. + M : {sparse matrix, ndarray, LinearOperator} + Preconditioner for A. The preconditioner should approximate the + inverse of A. Effective preconditioning dramatically improves the + rate of convergence, which implies that fewer iterations are needed + to reach a given error tolerance. + callback : function + User-supplied function to call after each iteration. It is called + as callback(xk), where xk is the current solution vector. + show : bool + If ``True``, print out a summary and metrics related to the solution + during iterations. Default is ``False``. + check : bool + If ``True``, run additional input validation to check that `A` and + `M` (if specified) are symmetric. Default is ``False``. + tol : float, optional, deprecated + + .. deprecated:: 1.12.0 + `minres` keyword argument ``tol`` is deprecated in favor of ``rtol`` + and will be removed in SciPy 1.14.0. + + Examples + -------- + >>> import numpy as np + >>> from scipy.sparse import csc_matrix + >>> from scipy.sparse.linalg import minres + >>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float) + >>> A = A + A.T + >>> b = np.array([2, 4, -1], dtype=float) + >>> x, exitCode = minres(A, b) + >>> print(exitCode) # 0 indicates successful convergence + 0 + >>> np.allclose(A.dot(x), b) + True + + References + ---------- + Solution of sparse indefinite systems of linear equations, + C. C. Paige and M. A. Saunders (1975), + SIAM J. Numer. Anal. 12(4), pp. 617-629. + https://web.stanford.edu/group/SOL/software/minres/ + + This file is a translation of the following MATLAB implementation: + https://web.stanford.edu/group/SOL/software/minres/minres-matlab.zip + + """ + A, M, x, b, postprocess = make_system(A, M, x0, b) + + if tol is not _NoValue: + msg = ("'scipy.sparse.linalg.minres' keyword argument `tol` is " + "deprecated in favor of `rtol` and will be removed in SciPy " + "v1.14. Until then, if set, it will override `rtol`.") + warnings.warn(msg, category=DeprecationWarning, stacklevel=4) + rtol = float(tol) if tol is not None else rtol + + matvec = A.matvec + psolve = M.matvec + + first = 'Enter minres. ' + last = 'Exit minres. ' + + n = A.shape[0] + + if maxiter is None: + maxiter = 5 * n + + msg = [' beta2 = 0. If M = I, b and x are eigenvectors ', # -1 + ' beta1 = 0. The exact solution is x0 ', # 0 + ' A solution to Ax = b was found, given rtol ', # 1 + ' A least-squares solution was found, given rtol ', # 2 + ' Reasonable accuracy achieved, given eps ', # 3 + ' x has converged to an eigenvector ', # 4 + ' acond has exceeded 0.1/eps ', # 5 + ' The iteration limit was reached ', # 6 + ' A does not define a symmetric matrix ', # 7 + ' M does not define a symmetric matrix ', # 8 + ' M does not define a pos-def preconditioner '] # 9 + + if show: + print(first + 'Solution of symmetric Ax = b') + print(first + f'n = {n:3g} shift = {shift:23.14e}') + print(first + f'itnlim = {maxiter:3g} rtol = {rtol:11.2e}') + print() + + istop = 0 + itn = 0 + Anorm = 0 + Acond = 0 + rnorm = 0 + ynorm = 0 + + xtype = x.dtype + + eps = finfo(xtype).eps + + # Set up y and v for the first Lanczos vector v1. + # y = beta1 P' v1, where P = C**(-1). + # v is really P' v1. + + if x0 is None: + r1 = b.copy() + else: + r1 = b - A@x + y = psolve(r1) + + beta1 = inner(r1, y) + + if beta1 < 0: + raise ValueError('indefinite preconditioner') + elif beta1 == 0: + return (postprocess(x), 0) + + bnorm = norm(b) + if bnorm == 0: + x = b + return (postprocess(x), 0) + + beta1 = sqrt(beta1) + + if check: + # are these too strict? + + # see if A is symmetric + w = matvec(y) + r2 = matvec(w) + s = inner(w,w) + t = inner(y,r2) + z = abs(s - t) + epsa = (s + eps) * eps**(1.0/3.0) + if z > epsa: + raise ValueError('non-symmetric matrix') + + # see if M is symmetric + r2 = psolve(y) + s = inner(y,y) + t = inner(r1,r2) + z = abs(s - t) + epsa = (s + eps) * eps**(1.0/3.0) + if z > epsa: + raise ValueError('non-symmetric preconditioner') + + # Initialize other quantities + oldb = 0 + beta = beta1 + dbar = 0 + epsln = 0 + qrnorm = beta1 + phibar = beta1 + rhs1 = beta1 + rhs2 = 0 + tnorm2 = 0 + gmax = 0 + gmin = finfo(xtype).max + cs = -1 + sn = 0 + w = zeros(n, dtype=xtype) + w2 = zeros(n, dtype=xtype) + r2 = r1 + + if show: + print() + print() + print(' Itn x(1) Compatible LS norm(A) cond(A) gbar/|A|') + + while itn < maxiter: + itn += 1 + + s = 1.0/beta + v = s*y + + y = matvec(v) + y = y - shift * v + + if itn >= 2: + y = y - (beta/oldb)*r1 + + alfa = inner(v,y) + y = y - (alfa/beta)*r2 + r1 = r2 + r2 = y + y = psolve(r2) + oldb = beta + beta = inner(r2,y) + if beta < 0: + raise ValueError('non-symmetric matrix') + beta = sqrt(beta) + tnorm2 += alfa**2 + oldb**2 + beta**2 + + if itn == 1: + if beta/beta1 <= 10*eps: + istop = -1 # Terminate later + + # Apply previous rotation Qk-1 to get + # [deltak epslnk+1] = [cs sn][dbark 0 ] + # [gbar k dbar k+1] [sn -cs][alfak betak+1]. + + oldeps = epsln + delta = cs * dbar + sn * alfa # delta1 = 0 deltak + gbar = sn * dbar - cs * alfa # gbar 1 = alfa1 gbar k + epsln = sn * beta # epsln2 = 0 epslnk+1 + dbar = - cs * beta # dbar 2 = beta2 dbar k+1 + root = norm([gbar, dbar]) + Arnorm = phibar * root + + # Compute the next plane rotation Qk + + gamma = norm([gbar, beta]) # gammak + gamma = max(gamma, eps) + cs = gbar / gamma # ck + sn = beta / gamma # sk + phi = cs * phibar # phik + phibar = sn * phibar # phibark+1 + + # Update x. + + denom = 1.0/gamma + w1 = w2 + w2 = w + w = (v - oldeps*w1 - delta*w2) * denom + x = x + phi*w + + # Go round again. + + gmax = max(gmax, gamma) + gmin = min(gmin, gamma) + z = rhs1 / gamma + rhs1 = rhs2 - delta*z + rhs2 = - epsln*z + + # Estimate various norms and test for convergence. + + Anorm = sqrt(tnorm2) + ynorm = norm(x) + epsa = Anorm * eps + epsx = Anorm * ynorm * eps + epsr = Anorm * ynorm * rtol + diag = gbar + + if diag == 0: + diag = epsa + + qrnorm = phibar + rnorm = qrnorm + if ynorm == 0 or Anorm == 0: + test1 = inf + else: + test1 = rnorm / (Anorm*ynorm) # ||r|| / (||A|| ||x||) + if Anorm == 0: + test2 = inf + else: + test2 = root / Anorm # ||Ar|| / (||A|| ||r||) + + # Estimate cond(A). + # In this version we look at the diagonals of R in the + # factorization of the lower Hessenberg matrix, Q @ H = R, + # where H is the tridiagonal matrix from Lanczos with one + # extra row, beta(k+1) e_k^T. + + Acond = gmax/gmin + + # See if any of the stopping criteria are satisfied. + # In rare cases, istop is already -1 from above (Abar = const*I). + + if istop == 0: + t1 = 1 + test1 # These tests work if rtol < eps + t2 = 1 + test2 + if t2 <= 1: + istop = 2 + if t1 <= 1: + istop = 1 + + if itn >= maxiter: + istop = 6 + if Acond >= 0.1/eps: + istop = 4 + if epsx >= beta1: + istop = 3 + # if rnorm <= epsx : istop = 2 + # if rnorm <= epsr : istop = 1 + if test2 <= rtol: + istop = 2 + if test1 <= rtol: + istop = 1 + + # See if it is time to print something. + + prnt = False + if n <= 40: + prnt = True + if itn <= 10: + prnt = True + if itn >= maxiter-10: + prnt = True + if itn % 10 == 0: + prnt = True + if qrnorm <= 10*epsx: + prnt = True + if qrnorm <= 10*epsr: + prnt = True + if Acond <= 1e-2/eps: + prnt = True + if istop != 0: + prnt = True + + if show and prnt: + str1 = f'{itn:6g} {x[0]:12.5e} {test1:10.3e}' + str2 = f' {test2:10.3e}' + str3 = f' {Anorm:8.1e} {Acond:8.1e} {gbar/Anorm:8.1e}' + + print(str1 + str2 + str3) + + if itn % 10 == 0: + print() + + if callback is not None: + callback(x) + + if istop != 0: + break # TODO check this + + if show: + print() + print(last + f' istop = {istop:3g} itn ={itn:5g}') + print(last + f' Anorm = {Anorm:12.4e} Acond = {Acond:12.4e}') + print(last + f' rnorm = {rnorm:12.4e} ynorm = {ynorm:12.4e}') + print(last + f' Arnorm = {Arnorm:12.4e}') + print(last + msg[istop+1]) + + if istop == 6: + info = maxiter + else: + info = 0 + + return (postprocess(x),info) diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/utils.py b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..80f37fc1cf63fa0352fd93d62be758f87c065db5 --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/_isolve/utils.py @@ -0,0 +1,127 @@ +__docformat__ = "restructuredtext en" + +__all__ = [] + + +from numpy import asanyarray, asarray, array, zeros + +from scipy.sparse.linalg._interface import aslinearoperator, LinearOperator, \ + IdentityOperator + +_coerce_rules = {('f','f'):'f', ('f','d'):'d', ('f','F'):'F', + ('f','D'):'D', ('d','f'):'d', ('d','d'):'d', + ('d','F'):'D', ('d','D'):'D', ('F','f'):'F', + ('F','d'):'D', ('F','F'):'F', ('F','D'):'D', + ('D','f'):'D', ('D','d'):'D', ('D','F'):'D', + ('D','D'):'D'} + + +def coerce(x,y): + if x not in 'fdFD': + x = 'd' + if y not in 'fdFD': + y = 'd' + return _coerce_rules[x,y] + + +def id(x): + return x + + +def make_system(A, M, x0, b): + """Make a linear system Ax=b + + Parameters + ---------- + A : LinearOperator + sparse or dense matrix (or any valid input to aslinearoperator) + M : {LinearOperator, Nones} + preconditioner + sparse or dense matrix (or any valid input to aslinearoperator) + x0 : {array_like, str, None} + initial guess to iterative method. + ``x0 = 'Mb'`` means using the nonzero initial guess ``M @ b``. + Default is `None`, which means using the zero initial guess. + b : array_like + right hand side + + Returns + ------- + (A, M, x, b, postprocess) + A : LinearOperator + matrix of the linear system + M : LinearOperator + preconditioner + x : rank 1 ndarray + initial guess + b : rank 1 ndarray + right hand side + postprocess : function + converts the solution vector to the appropriate + type and dimensions (e.g. (N,1) matrix) + + """ + A_ = A + A = aslinearoperator(A) + + if A.shape[0] != A.shape[1]: + raise ValueError(f'expected square matrix, but got shape={(A.shape,)}') + + N = A.shape[0] + + b = asanyarray(b) + + if not (b.shape == (N,1) or b.shape == (N,)): + raise ValueError(f'shapes of A {A.shape} and b {b.shape} are ' + 'incompatible') + + if b.dtype.char not in 'fdFD': + b = b.astype('d') # upcast non-FP types to double + + def postprocess(x): + return x + + if hasattr(A,'dtype'): + xtype = A.dtype.char + else: + xtype = A.matvec(b).dtype.char + xtype = coerce(xtype, b.dtype.char) + + b = asarray(b,dtype=xtype) # make b the same type as x + b = b.ravel() + + # process preconditioner + if M is None: + if hasattr(A_,'psolve'): + psolve = A_.psolve + else: + psolve = id + if hasattr(A_,'rpsolve'): + rpsolve = A_.rpsolve + else: + rpsolve = id + if psolve is id and rpsolve is id: + M = IdentityOperator(shape=A.shape, dtype=A.dtype) + else: + M = LinearOperator(A.shape, matvec=psolve, rmatvec=rpsolve, + dtype=A.dtype) + else: + M = aslinearoperator(M) + if A.shape != M.shape: + raise ValueError('matrix and preconditioner have different shapes') + + # set initial guess + if x0 is None: + x = zeros(N, dtype=xtype) + elif isinstance(x0, str): + if x0 == 'Mb': # use nonzero initial guess ``M @ b`` + bCopy = b.copy() + x = M.matvec(bCopy) + else: + x = array(x0, dtype=xtype) + if not (x.shape == (N, 1) or x.shape == (N,)): + raise ValueError(f'shapes of A {A.shape} and ' + f'x0 {x.shape} are incompatible') + x = x.ravel() + + return A, M, x, b, postprocess diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_matfuncs.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_matfuncs.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..94806c75e34a1761dbacd1255beb4e81ce8c2a0e Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_matfuncs.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_norm.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_norm.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c1809785c66288d4e2922c4c1e2040fe3b458687 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_norm.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_onenormest.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_onenormest.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c21aea5d4002c4b34264d913d9ec8db2b9582fe Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_onenormest.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_propack.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_propack.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3be2b354455e28e778553275e32c681b90c62bf7 Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/__pycache__/test_propack.cpython-310.pyc differ diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/propack_test_data.npz b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/propack_test_data.npz new file mode 100644 index 0000000000000000000000000000000000000000..0bf01015610346655c749ead87a47d5575e2b67b --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/linalg/tests/propack_test_data.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bfe34d9a92353e08f400f3837136e553a8e91d441186913d39b59bf8a627bba3 +size 600350 diff --git a/env-llmeval/lib/python3.10/site-packages/scipy/sparse/tests/data/csc_py2.npz b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/tests/data/csc_py2.npz new file mode 100644 index 0000000000000000000000000000000000000000..d4459ff2786fabe4bcf4653d880cbf0afd4bfdcf --- /dev/null +++ b/env-llmeval/lib/python3.10/site-packages/scipy/sparse/tests/data/csc_py2.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bac27f1a3eb1fdd102dae39b7dd61ce83e82f096388e344e14285071984d01fa +size 846