# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _gslwrap
else:
    import _gslwrap

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class Permutation(object):
    r"""Proxy of C gsl_permutation_struct struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    size = property(_gslwrap.Permutation_size_get, doc=r"""size : size_t""")
    data = property(_gslwrap.Permutation_data_get, doc=r"""data : p.size_t""")

    def __init__(self, n):
        r"""
        __init__(Permutation self, size_t n) -> Permutation

        Parameters
        ----------
        n: size_t

        """
        _gslwrap.Permutation_swiginit(self, _gslwrap.new_Permutation(n))
    __swig_destroy__ = _gslwrap.delete_Permutation

    def inversions(self):
        r"""inversions(Permutation self) -> size_t"""
        return _gslwrap.Permutation_inversions(self)

    def __getitem__(self, i):
        r"""
        __getitem__(Permutation self, size_t const i) -> size_t

        Parameters
        ----------
        i: size_t const

        """
        return _gslwrap.Permutation___getitem__(self, i)

    def swap(self, i, j):
        r"""
        swap(Permutation self, size_t const i, size_t const j) -> gsl_error_flag_drop

        Parameters
        ----------
        i: size_t const
        j: size_t const

        """
        return _gslwrap.Permutation_swap(self, i, j)

    def __len__(self):
        r"""__len__(Permutation self) -> size_t"""
        return _gslwrap.Permutation___len__(self)

    def valid(self):
        r"""valid(Permutation self) -> gsl_error_flag_drop"""
        return _gslwrap.Permutation_valid(self)

    def reverse(self):
        r"""reverse(Permutation self)"""
        return _gslwrap.Permutation_reverse(self)

    def next(self):
        r"""next(Permutation self) -> int"""
        return _gslwrap.Permutation_next(self)

    def prev(self):
        r"""prev(Permutation self) -> int"""
        return _gslwrap.Permutation_prev(self)

    def __str__(self):
        r"""__str__(Permutation self) -> char *"""
        return _gslwrap.Permutation___str__(self)

    def tolist(self):
        r"""tolist(Permutation self) -> PyObject *"""
        return _gslwrap.Permutation_tolist(self)

    def toarray(self):
        r"""toarray(Permutation self) -> PyObject *"""
        return _gslwrap.Permutation_toarray(self)

    def _linear_to_canonical(self, q):
        r"""
        _linear_to_canonical(Permutation self, Permutation q) -> gsl_error_flag_drop

        Parameters
        ----------
        q: struct gsl_permutation_struct *

        """
        return _gslwrap.Permutation__linear_to_canonical(self, q)

    def _canonical_to_linear(self, q):
        r"""
        _canonical_to_linear(Permutation self, Permutation q) -> gsl_error_flag_drop

        Parameters
        ----------
        q: struct gsl_permutation_struct *

        """
        return _gslwrap.Permutation__canonical_to_linear(self, q)

    def _mul(self, res, m2):
        r"""
        _mul(Permutation self, Permutation res, Permutation m2) -> gsl_error_flag_drop

        Parameters
        ----------
        res: struct gsl_permutation_struct *
        m2: struct gsl_permutation_struct *

        """
        return _gslwrap.Permutation__mul(self, res, m2)

    def _inverse(self, inv):
        r"""
        _inverse(Permutation self, Permutation inv) -> gsl_error_flag_drop

        Parameters
        ----------
        inv: struct gsl_permutation_struct *

        """
        return _gslwrap.Permutation__inverse(self, inv)

    def linear_cycles(self):
        r"""linear_cycles(Permutation self) -> size_t"""
        return _gslwrap.Permutation_linear_cycles(self)

    def canonical_cycles(self):
        r"""canonical_cycles(Permutation self) -> size_t"""
        return _gslwrap.Permutation_canonical_cycles(self)

# Register Permutation in _gslwrap:
_gslwrap.Permutation_swigregister(Permutation)


def gsl_permutation_alloc(n):
    r"""
    gsl_permutation_alloc(size_t const n) -> Permutation

    Parameters
    ----------
    n: size_t const

    """
    return _gslwrap.gsl_permutation_alloc(n)

def gsl_permutation_calloc(n):
    r"""
    gsl_permutation_calloc(size_t const n) -> Permutation

    Parameters
    ----------
    n: size_t const

    """
    return _gslwrap.gsl_permutation_calloc(n)

def gsl_permutation_init(p):
    r"""
    gsl_permutation_init(Permutation p)

    Parameters
    ----------
    p: gsl_permutation *

    """
    return _gslwrap.gsl_permutation_init(p)

def gsl_permutation_free(p):
    r"""
    gsl_permutation_free(Permutation p)

    Parameters
    ----------
    p: gsl_permutation *

    """
    return _gslwrap.gsl_permutation_free(p)

def gsl_permutation_fread(stream, p):
    r"""
    gsl_permutation_fread(FILE * stream, Permutation p) -> int

    Parameters
    ----------
    stream: FILE *
    p: gsl_permutation *

    """
    return _gslwrap.gsl_permutation_fread(stream, p)

def gsl_permutation_fwrite(stream, p):
    r"""
    gsl_permutation_fwrite(FILE * stream, Permutation p) -> int

    Parameters
    ----------
    stream: FILE *
    p: gsl_permutation const *

    """
    return _gslwrap.gsl_permutation_fwrite(stream, p)

def gsl_permutation_fscanf(stream, p):
    r"""
    gsl_permutation_fscanf(FILE * stream, Permutation p) -> int

    Parameters
    ----------
    stream: FILE *
    p: gsl_permutation *

    """
    return _gslwrap.gsl_permutation_fscanf(stream, p)

def gsl_permutation_fprintf(stream, p, format):
    r"""
    gsl_permutation_fprintf(FILE * stream, Permutation p, char const * format) -> int

    Parameters
    ----------
    stream: FILE *
    p: gsl_permutation const *
    format: char const *

    """
    return _gslwrap.gsl_permutation_fprintf(stream, p, format)

def gsl_permutation_size(p):
    r"""
    gsl_permutation_size(Permutation p) -> size_t

    Parameters
    ----------
    p: gsl_permutation const *

    """
    return _gslwrap.gsl_permutation_size(p)

def gsl_permutation_data(p):
    r"""
    gsl_permutation_data(Permutation p) -> size_t *

    Parameters
    ----------
    p: gsl_permutation const *

    """
    return _gslwrap.gsl_permutation_data(p)

def gsl_permutation_swap(p, i, j):
    r"""
    gsl_permutation_swap(Permutation p, size_t const i, size_t const j) -> int

    Parameters
    ----------
    p: gsl_permutation *
    i: size_t const
    j: size_t const

    """
    return _gslwrap.gsl_permutation_swap(p, i, j)

def gsl_permutation_valid(p):
    r"""
    gsl_permutation_valid(Permutation p) -> int

    Parameters
    ----------
    p: gsl_permutation const *

    """
    return _gslwrap.gsl_permutation_valid(p)

def gsl_permutation_reverse(p):
    r"""
    gsl_permutation_reverse(Permutation p)

    Parameters
    ----------
    p: gsl_permutation *

    """
    return _gslwrap.gsl_permutation_reverse(p)

def gsl_permutation_inverse(inv, p):
    r"""
    gsl_permutation_inverse(Permutation inv, Permutation p) -> int

    Parameters
    ----------
    inv: gsl_permutation *
    p: gsl_permutation const *

    """
    return _gslwrap.gsl_permutation_inverse(inv, p)

def gsl_permutation_next(p):
    r"""
    gsl_permutation_next(Permutation p) -> int

    Parameters
    ----------
    p: gsl_permutation *

    """
    return _gslwrap.gsl_permutation_next(p)

def gsl_permutation_prev(p):
    r"""
    gsl_permutation_prev(Permutation p) -> int

    Parameters
    ----------
    p: gsl_permutation *

    """
    return _gslwrap.gsl_permutation_prev(p)

def gsl_permutation_linear_to_canonical(q, p):
    r"""
    gsl_permutation_linear_to_canonical(Permutation q, Permutation p) -> int

    Parameters
    ----------
    q: gsl_permutation *
    p: gsl_permutation const *

    """
    return _gslwrap.gsl_permutation_linear_to_canonical(q, p)

def gsl_permutation_canonical_to_linear(p, q):
    r"""
    gsl_permutation_canonical_to_linear(Permutation p, Permutation q) -> int

    Parameters
    ----------
    p: gsl_permutation *
    q: gsl_permutation const *

    """
    return _gslwrap.gsl_permutation_canonical_to_linear(p, q)

def gsl_permutation_get(p, i):
    r"""
    gsl_permutation_get(Permutation p, size_t const i) -> size_t

    Parameters
    ----------
    p: gsl_permutation const *
    i: size_t const

    """
    return _gslwrap.gsl_permutation_get(p, i)

def pygsl_linalg_complex_householder_mh(tau, v, OUTPUT):
    r"""
    pygsl_linalg_complex_householder_mh(gsl_complex tau, gsl_vector_complex const * v, gsl_matrix_complex * OUTPUT) -> int

    Parameters
    ----------
    tau: gsl_complex
    v: gsl_vector_complex const *
    OUTPUT: gsl_matrix_complex * (output)

    """
    return _gslwrap.pygsl_linalg_complex_householder_mh(tau, v, OUTPUT)

def pygsl_linalg_hessenberg_decomp(A, tau):
    r"""
    pygsl_linalg_hessenberg_decomp(gsl_matrix * A, gsl_vector * tau) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau: gsl_vector *

    """
    return _gslwrap.pygsl_linalg_hessenberg_decomp(A, tau)

def pygsl_linalg_complex_cholesky_invert(cholesky):
    r"""
    pygsl_linalg_complex_cholesky_invert(gsl_matrix_complex * cholesky) -> int

    Parameters
    ----------
    cholesky: gsl_matrix_complex *

    """
    return _gslwrap.pygsl_linalg_complex_cholesky_invert(cholesky)
GSL_LINALG_MOD_NONE = _gslwrap.GSL_LINALG_MOD_NONE

GSL_LINALG_MOD_TRANSPOSE = _gslwrap.GSL_LINALG_MOD_TRANSPOSE

GSL_LINALG_MOD_CONJUGATE = _gslwrap.GSL_LINALG_MOD_CONJUGATE


def gsl_linalg_matmult(A, B, C):
    r"""
    gsl_linalg_matmult(gsl_matrix const * A, gsl_matrix const * B, gsl_matrix * C) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    B: gsl_matrix const *
    C: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_matmult(A, B, C)

def gsl_linalg_matmult_mod(A, modA, B, modB, C):
    r"""
    gsl_linalg_matmult_mod(gsl_matrix const * A, gsl_linalg_matrix_mod_t modA, gsl_matrix const * B, gsl_linalg_matrix_mod_t modB, gsl_matrix * C) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    modA: enum gsl_linalg_matrix_mod_t
    B: gsl_matrix const *
    modB: enum gsl_linalg_matrix_mod_t
    C: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_matmult_mod(A, modA, B, modB, C)

def gsl_linalg_exponential_ss(A, eA, mode):
    r"""
    gsl_linalg_exponential_ss(gsl_matrix const * A, gsl_matrix * eA, gsl_mode_t mode) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    eA: gsl_matrix *
    mode: gsl_mode_t

    """
    return _gslwrap.gsl_linalg_exponential_ss(A, eA, mode)

def gsl_linalg_householder_transform(v):
    r"""
    gsl_linalg_householder_transform(gsl_vector * v) -> double

    Parameters
    ----------
    v: gsl_vector *

    """
    return _gslwrap.gsl_linalg_householder_transform(v)

def gsl_linalg_householder_transform2(alpha, v):
    r"""
    gsl_linalg_householder_transform2(double * alpha, gsl_vector * v) -> double

    Parameters
    ----------
    alpha: double *
    v: gsl_vector *

    """
    return _gslwrap.gsl_linalg_householder_transform2(alpha, v)

def gsl_linalg_complex_householder_transform(v):
    r"""
    gsl_linalg_complex_householder_transform(gsl_vector_complex * v) -> gsl_complex

    Parameters
    ----------
    v: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_householder_transform(v)

def gsl_linalg_householder_hm(tau, v, A):
    r"""
    gsl_linalg_householder_hm(double tau, gsl_vector const * v, gsl_matrix * A) -> int

    Parameters
    ----------
    tau: double
    v: gsl_vector const *
    A: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_householder_hm(tau, v, A)

def gsl_linalg_householder_mh(tau, v, A):
    r"""
    gsl_linalg_householder_mh(double tau, gsl_vector const * v, gsl_matrix * A) -> int

    Parameters
    ----------
    tau: double
    v: gsl_vector const *
    A: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_householder_mh(tau, v, A)

def gsl_linalg_householder_hv(tau, v, w):
    r"""
    gsl_linalg_householder_hv(double tau, gsl_vector const * v, gsl_vector * w) -> int

    Parameters
    ----------
    tau: double
    v: gsl_vector const *
    w: gsl_vector *

    """
    return _gslwrap.gsl_linalg_householder_hv(tau, v, w)

def gsl_linalg_householder_left(tau, v, A, work):
    r"""
    gsl_linalg_householder_left(double const tau, gsl_vector const * v, gsl_matrix * A, gsl_vector * work) -> int

    Parameters
    ----------
    tau: double const
    v: gsl_vector const *
    A: gsl_matrix *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_householder_left(tau, v, A, work)

def gsl_linalg_householder_right(tau, v, A, work):
    r"""
    gsl_linalg_householder_right(double const tau, gsl_vector const * v, gsl_matrix * A, gsl_vector * work) -> int

    Parameters
    ----------
    tau: double const
    v: gsl_vector const *
    A: gsl_matrix *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_householder_right(tau, v, A, work)

def gsl_linalg_householder_hm1(tau, A):
    r"""
    gsl_linalg_householder_hm1(double tau, gsl_matrix * A) -> int

    Parameters
    ----------
    tau: double
    A: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_householder_hm1(tau, A)

def gsl_linalg_complex_householder_hm(tau, v, A):
    r"""
    gsl_linalg_complex_householder_hm(gsl_complex tau, gsl_vector_complex const * v, gsl_matrix_complex * A) -> int

    Parameters
    ----------
    tau: gsl_complex
    v: gsl_vector_complex const *
    A: gsl_matrix_complex *

    """
    return _gslwrap.gsl_linalg_complex_householder_hm(tau, v, A)

def gsl_linalg_complex_householder_hv(tau, v, w):
    r"""
    gsl_linalg_complex_householder_hv(gsl_complex tau, gsl_vector_complex const * v, gsl_vector_complex * w) -> int

    Parameters
    ----------
    tau: gsl_complex
    v: gsl_vector_complex const *
    w: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_householder_hv(tau, v, w)

def gsl_linalg_complex_householder_left(tau, v, A, work):
    r"""
    gsl_linalg_complex_householder_left(gsl_complex const tau, gsl_vector_complex const * v, gsl_matrix_complex * A, gsl_vector_complex * work) -> int

    Parameters
    ----------
    tau: gsl_complex const
    v: gsl_vector_complex const *
    A: gsl_matrix_complex *
    work: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_householder_left(tau, v, A, work)

def gsl_linalg_hessenberg_unpack(H, tau, U):
    r"""
    gsl_linalg_hessenberg_unpack(gsl_matrix * H, gsl_vector * tau, gsl_matrix * U) -> int

    Parameters
    ----------
    H: gsl_matrix *
    tau: gsl_vector *
    U: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_hessenberg_unpack(H, tau, U)

def gsl_linalg_hessenberg_unpack_accum(H, tau, U):
    r"""
    gsl_linalg_hessenberg_unpack_accum(gsl_matrix * H, gsl_vector * tau, gsl_matrix * U) -> int

    Parameters
    ----------
    H: gsl_matrix *
    tau: gsl_vector *
    U: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_hessenberg_unpack_accum(H, tau, U)

def gsl_linalg_hessenberg_set_zero(H):
    r"""
    gsl_linalg_hessenberg_set_zero(gsl_matrix * H) -> int

    Parameters
    ----------
    H: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_hessenberg_set_zero(H)

def gsl_linalg_hessenberg_submatrix(M, A, top, tau):
    r"""
    gsl_linalg_hessenberg_submatrix(gsl_matrix * M, gsl_matrix * A, size_t top, gsl_vector * tau) -> int

    Parameters
    ----------
    M: gsl_matrix *
    A: gsl_matrix *
    top: size_t
    tau: gsl_vector *

    """
    return _gslwrap.gsl_linalg_hessenberg_submatrix(M, A, top, tau)

def gsl_linalg_hesstri_decomp(A, B, U, V, work):
    r"""
    gsl_linalg_hesstri_decomp(gsl_matrix * A, gsl_matrix * B, gsl_matrix * U, gsl_matrix * V, gsl_vector * work) -> int

    Parameters
    ----------
    A: gsl_matrix *
    B: gsl_matrix *
    U: gsl_matrix *
    V: gsl_matrix *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_hesstri_decomp(A, B, U, V, work)

def gsl_linalg_SV_decomp(A, V, S, work):
    r"""
    gsl_linalg_SV_decomp(gsl_matrix * A, gsl_matrix * V, gsl_vector * S, gsl_vector * work) -> int

    Parameters
    ----------
    A: gsl_matrix *
    V: gsl_matrix *
    S: gsl_vector *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_SV_decomp(A, V, S, work)

def gsl_linalg_SV_decomp_mod(A, X, V, S, work):
    r"""
    gsl_linalg_SV_decomp_mod(gsl_matrix * A, gsl_matrix * X, gsl_matrix * V, gsl_vector * S, gsl_vector * work) -> int

    Parameters
    ----------
    A: gsl_matrix *
    X: gsl_matrix *
    V: gsl_matrix *
    S: gsl_vector *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_SV_decomp_mod(A, X, V, S, work)

def gsl_linalg_SV_decomp_jacobi(A, Q, S):
    r"""
    gsl_linalg_SV_decomp_jacobi(gsl_matrix * A, gsl_matrix * Q, gsl_vector * S) -> int

    Parameters
    ----------
    A: gsl_matrix *
    Q: gsl_matrix *
    S: gsl_vector *

    """
    return _gslwrap.gsl_linalg_SV_decomp_jacobi(A, Q, S)

def gsl_linalg_SV_solve(U, Q, S, b, x):
    r"""
    gsl_linalg_SV_solve(gsl_matrix const * U, gsl_matrix const * Q, gsl_vector const * S, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    U: gsl_matrix const *
    Q: gsl_matrix const *
    S: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_SV_solve(U, Q, S, b, x)

def gsl_linalg_LU_solve(LU, p, b, x):
    r"""
    gsl_linalg_LU_solve(gsl_matrix const * LU, Permutation p, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    LU: gsl_matrix const *
    p: gsl_permutation const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LU_solve(LU, p, b, x)

def gsl_linalg_LU_svx(LU, p, x):
    r"""
    gsl_linalg_LU_svx(gsl_matrix const * LU, Permutation p, gsl_vector * x) -> int

    Parameters
    ----------
    LU: gsl_matrix const *
    p: gsl_permutation const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LU_svx(LU, p, x)

def gsl_linalg_LU_refine(A, LU, p, b, x, work):
    r"""
    gsl_linalg_LU_refine(gsl_matrix const * A, gsl_matrix const * LU, Permutation p, gsl_vector const * b, gsl_vector * x, gsl_vector * work) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    LU: gsl_matrix const *
    p: gsl_permutation const *
    b: gsl_vector const *
    x: gsl_vector *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LU_refine(A, LU, p, b, x, work)

def gsl_linalg_LU_invert(LU, p, inverse):
    r"""
    gsl_linalg_LU_invert(gsl_matrix const * LU, Permutation p, gsl_matrix * inverse) -> int

    Parameters
    ----------
    LU: gsl_matrix const *
    p: gsl_permutation const *
    inverse: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_LU_invert(LU, p, inverse)

def gsl_linalg_LU_invx(LU, p):
    r"""
    gsl_linalg_LU_invx(gsl_matrix * LU, Permutation p) -> int

    Parameters
    ----------
    LU: gsl_matrix *
    p: gsl_permutation const *

    """
    return _gslwrap.gsl_linalg_LU_invx(LU, p)

def gsl_linalg_LU_det(LU, signum):
    r"""
    gsl_linalg_LU_det(gsl_matrix * LU, int signum) -> double

    Parameters
    ----------
    LU: gsl_matrix *
    signum: int

    """
    return _gslwrap.gsl_linalg_LU_det(LU, signum)

def gsl_linalg_LU_lndet(LU):
    r"""
    gsl_linalg_LU_lndet(gsl_matrix * LU) -> double

    Parameters
    ----------
    LU: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_LU_lndet(LU)

def gsl_linalg_LU_sgndet(lu, signum):
    r"""
    gsl_linalg_LU_sgndet(gsl_matrix * lu, int signum) -> int

    Parameters
    ----------
    lu: gsl_matrix *
    signum: int

    """
    return _gslwrap.gsl_linalg_LU_sgndet(lu, signum)

def gsl_linalg_LU_band_decomp(M, lb, ub, AB, piv):
    r"""
    gsl_linalg_LU_band_decomp(size_t const M, size_t const lb, size_t const ub, gsl_matrix * AB, gsl_vector_uint * piv) -> int

    Parameters
    ----------
    M: size_t const
    lb: size_t const
    ub: size_t const
    AB: gsl_matrix *
    piv: gsl_vector_uint *

    """
    return _gslwrap.gsl_linalg_LU_band_decomp(M, lb, ub, AB, piv)

def gsl_linalg_LU_band_solve(lb, ub, LUB, piv, b, x):
    r"""
    gsl_linalg_LU_band_solve(size_t const lb, size_t const ub, gsl_matrix const * LUB, gsl_vector_uint const * piv, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    lb: size_t const
    ub: size_t const
    LUB: gsl_matrix const *
    piv: gsl_vector_uint const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LU_band_solve(lb, ub, LUB, piv, b, x)

def gsl_linalg_LU_band_svx(lb, ub, LUB, piv, x):
    r"""
    gsl_linalg_LU_band_svx(size_t const lb, size_t const ub, gsl_matrix const * LUB, gsl_vector_uint const * piv, gsl_vector * x) -> int

    Parameters
    ----------
    lb: size_t const
    ub: size_t const
    LUB: gsl_matrix const *
    piv: gsl_vector_uint const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LU_band_svx(lb, ub, LUB, piv, x)

def gsl_linalg_LU_band_unpack(M, lb, ub, LUB, piv, L, U):
    r"""
    gsl_linalg_LU_band_unpack(size_t const M, size_t const lb, size_t const ub, gsl_matrix const * LUB, gsl_vector_uint const * piv, gsl_matrix * L, gsl_matrix * U) -> int

    Parameters
    ----------
    M: size_t const
    lb: size_t const
    ub: size_t const
    LUB: gsl_matrix const *
    piv: gsl_vector_uint const *
    L: gsl_matrix *
    U: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_LU_band_unpack(M, lb, ub, LUB, piv, L, U)

def gsl_linalg_complex_LU_solve(LU, p, b, x):
    r"""
    gsl_linalg_complex_LU_solve(gsl_matrix_complex const * LU, Permutation p, gsl_vector_complex const * b, gsl_vector_complex * x) -> int

    Parameters
    ----------
    LU: gsl_matrix_complex const *
    p: gsl_permutation const *
    b: gsl_vector_complex const *
    x: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_LU_solve(LU, p, b, x)

def gsl_linalg_complex_LU_svx(LU, p, x):
    r"""
    gsl_linalg_complex_LU_svx(gsl_matrix_complex const * LU, Permutation p, gsl_vector_complex * x) -> int

    Parameters
    ----------
    LU: gsl_matrix_complex const *
    p: gsl_permutation const *
    x: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_LU_svx(LU, p, x)

def gsl_linalg_complex_LU_refine(A, LU, p, b, x, work):
    r"""
    gsl_linalg_complex_LU_refine(gsl_matrix_complex const * A, gsl_matrix_complex const * LU, Permutation p, gsl_vector_complex const * b, gsl_vector_complex * x, gsl_vector_complex * work) -> int

    Parameters
    ----------
    A: gsl_matrix_complex const *
    LU: gsl_matrix_complex const *
    p: gsl_permutation const *
    b: gsl_vector_complex const *
    x: gsl_vector_complex *
    work: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_LU_refine(A, LU, p, b, x, work)

def gsl_linalg_complex_LU_invert(LU, p, inverse):
    r"""
    gsl_linalg_complex_LU_invert(gsl_matrix_complex const * LU, Permutation p, gsl_matrix_complex * inverse) -> int

    Parameters
    ----------
    LU: gsl_matrix_complex const *
    p: gsl_permutation const *
    inverse: gsl_matrix_complex *

    """
    return _gslwrap.gsl_linalg_complex_LU_invert(LU, p, inverse)

def gsl_linalg_complex_LU_invx(LU, p):
    r"""
    gsl_linalg_complex_LU_invx(gsl_matrix_complex * LU, Permutation p) -> int

    Parameters
    ----------
    LU: gsl_matrix_complex *
    p: gsl_permutation const *

    """
    return _gslwrap.gsl_linalg_complex_LU_invx(LU, p)

def gsl_linalg_complex_LU_det(LU, signum):
    r"""
    gsl_linalg_complex_LU_det(gsl_matrix_complex * LU, int signum) -> gsl_complex

    Parameters
    ----------
    LU: gsl_matrix_complex *
    signum: int

    """
    return _gslwrap.gsl_linalg_complex_LU_det(LU, signum)

def gsl_linalg_complex_LU_lndet(LU):
    r"""
    gsl_linalg_complex_LU_lndet(gsl_matrix_complex * LU) -> double

    Parameters
    ----------
    LU: gsl_matrix_complex *

    """
    return _gslwrap.gsl_linalg_complex_LU_lndet(LU)

def gsl_linalg_complex_LU_sgndet(LU, signum):
    r"""
    gsl_linalg_complex_LU_sgndet(gsl_matrix_complex * LU, int signum) -> gsl_complex

    Parameters
    ----------
    LU: gsl_matrix_complex *
    signum: int

    """
    return _gslwrap.gsl_linalg_complex_LU_sgndet(LU, signum)

def gsl_linalg_QR_decomp(A, tau):
    r"""
    gsl_linalg_QR_decomp(gsl_matrix * A, gsl_vector * tau) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_decomp(A, tau)

def gsl_linalg_QR_decomp_old(A, tau):
    r"""
    gsl_linalg_QR_decomp_old(gsl_matrix * A, gsl_vector * tau) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_decomp_old(A, tau)

def gsl_linalg_QR_decomp_r(A, T):
    r"""
    gsl_linalg_QR_decomp_r(gsl_matrix * A, gsl_matrix * T) -> int

    Parameters
    ----------
    A: gsl_matrix *
    T: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_QR_decomp_r(A, T)

def gsl_linalg_QR_solve(QR, tau, b, x):
    r"""
    gsl_linalg_QR_solve(gsl_matrix const * QR, gsl_vector const * tau, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_solve(QR, tau, b, x)

def gsl_linalg_QR_solve_r(QR, T, b, x):
    r"""
    gsl_linalg_QR_solve_r(gsl_matrix const * QR, gsl_matrix const * T, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    T: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_solve_r(QR, T, b, x)

def gsl_linalg_QR_svx(QR, tau, x):
    r"""
    gsl_linalg_QR_svx(gsl_matrix const * QR, gsl_vector const * tau, gsl_vector * x) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_svx(QR, tau, x)

def gsl_linalg_QR_lssolve(QR, tau, b, x, residual):
    r"""
    gsl_linalg_QR_lssolve(gsl_matrix const * QR, gsl_vector const * tau, gsl_vector const * b, gsl_vector * x, gsl_vector * residual) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *
    residual: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_lssolve(QR, tau, b, x, residual)

def gsl_linalg_QR_lssolve_r(QR, T, b, x, work):
    r"""
    gsl_linalg_QR_lssolve_r(gsl_matrix const * QR, gsl_matrix const * T, gsl_vector const * b, gsl_vector * x, gsl_vector * work) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    T: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_lssolve_r(QR, T, b, x, work)

def gsl_linalg_QR_QRsolve(Q, R, b, x):
    r"""
    gsl_linalg_QR_QRsolve(gsl_matrix * Q, gsl_matrix * R, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    Q: gsl_matrix *
    R: gsl_matrix *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_QRsolve(Q, R, b, x)

def gsl_linalg_QR_Rsolve(QR, b, x):
    r"""
    gsl_linalg_QR_Rsolve(gsl_matrix const * QR, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_Rsolve(QR, b, x)

def gsl_linalg_QR_Rsvx(QR, x):
    r"""
    gsl_linalg_QR_Rsvx(gsl_matrix const * QR, gsl_vector * x) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_Rsvx(QR, x)

def gsl_linalg_QR_update(Q, R, w, v):
    r"""
    gsl_linalg_QR_update(gsl_matrix * Q, gsl_matrix * R, gsl_vector * w, gsl_vector const * v) -> int

    Parameters
    ----------
    Q: gsl_matrix *
    R: gsl_matrix *
    w: gsl_vector *
    v: gsl_vector const *

    """
    return _gslwrap.gsl_linalg_QR_update(Q, R, w, v)

def gsl_linalg_QR_QTvec(QR, tau, v):
    r"""
    gsl_linalg_QR_QTvec(gsl_matrix const * QR, gsl_vector const * tau, gsl_vector * v) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    v: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_QTvec(QR, tau, v)

def gsl_linalg_QR_QTvec_r(QR, T, b, work):
    r"""
    gsl_linalg_QR_QTvec_r(gsl_matrix const * QR, gsl_matrix const * T, gsl_vector * b, gsl_vector * work) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    T: gsl_matrix const *
    b: gsl_vector *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_QTvec_r(QR, T, b, work)

def gsl_linalg_QR_Qvec(QR, tau, v):
    r"""
    gsl_linalg_QR_Qvec(gsl_matrix const * QR, gsl_vector const * tau, gsl_vector * v) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    v: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_Qvec(QR, tau, v)

def gsl_linalg_QR_QTmat(QR, tau, A):
    r"""
    gsl_linalg_QR_QTmat(gsl_matrix const * QR, gsl_vector const * tau, gsl_matrix * A) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    A: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_QR_QTmat(QR, tau, A)

def gsl_linalg_QR_QTmat_r(QR, T, B, work):
    r"""
    gsl_linalg_QR_QTmat_r(gsl_matrix const * QR, gsl_matrix const * T, gsl_matrix * B, gsl_matrix * work) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    T: gsl_matrix const *
    B: gsl_matrix *
    work: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_QR_QTmat_r(QR, T, B, work)

def gsl_linalg_QR_unpack(QR, tau, Q, R):
    r"""
    gsl_linalg_QR_unpack(gsl_matrix const * QR, gsl_vector const * tau, gsl_matrix * Q, gsl_matrix * R) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    Q: gsl_matrix *
    R: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_QR_unpack(QR, tau, Q, R)

def gsl_linalg_QR_unpack_r(QR, T, Q, R):
    r"""
    gsl_linalg_QR_unpack_r(gsl_matrix const * QR, gsl_matrix const * T, gsl_matrix * Q, gsl_matrix * R) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    T: gsl_matrix const *
    Q: gsl_matrix *
    R: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_QR_unpack_r(QR, T, Q, R)

def gsl_linalg_R_solve(R, b, x):
    r"""
    gsl_linalg_R_solve(gsl_matrix const * R, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    R: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_R_solve(R, b, x)

def gsl_linalg_R_svx(R, x):
    r"""
    gsl_linalg_R_svx(gsl_matrix const * R, gsl_vector * x) -> int

    Parameters
    ----------
    R: gsl_matrix const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_R_svx(R, x)

def gsl_linalg_QR_rcond(QR, rcond, work):
    r"""
    gsl_linalg_QR_rcond(gsl_matrix const * QR, double * rcond, gsl_vector * work) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    rcond: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_rcond(QR, rcond, work)

def gsl_linalg_complex_QR_decomp(A, tau):
    r"""
    gsl_linalg_complex_QR_decomp(gsl_matrix_complex * A, gsl_vector_complex * tau) -> int

    Parameters
    ----------
    A: gsl_matrix_complex *
    tau: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_decomp(A, tau)

def gsl_linalg_complex_QR_decomp_r(A, T):
    r"""
    gsl_linalg_complex_QR_decomp_r(gsl_matrix_complex * A, gsl_matrix_complex * T) -> int

    Parameters
    ----------
    A: gsl_matrix_complex *
    T: gsl_matrix_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_decomp_r(A, T)

def gsl_linalg_complex_QR_solve(QR, tau, b, x):
    r"""
    gsl_linalg_complex_QR_solve(gsl_matrix_complex const * QR, gsl_vector_complex const * tau, gsl_vector_complex const * b, gsl_vector_complex * x) -> int

    Parameters
    ----------
    QR: gsl_matrix_complex const *
    tau: gsl_vector_complex const *
    b: gsl_vector_complex const *
    x: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_solve(QR, tau, b, x)

def gsl_linalg_complex_QR_solve_r(QR, T, b, x):
    r"""
    gsl_linalg_complex_QR_solve_r(gsl_matrix_complex const * QR, gsl_matrix_complex const * T, gsl_vector_complex const * b, gsl_vector_complex * x) -> int

    Parameters
    ----------
    QR: gsl_matrix_complex const *
    T: gsl_matrix_complex const *
    b: gsl_vector_complex const *
    x: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_solve_r(QR, T, b, x)

def gsl_linalg_complex_QR_svx(QR, tau, x):
    r"""
    gsl_linalg_complex_QR_svx(gsl_matrix_complex const * QR, gsl_vector_complex const * tau, gsl_vector_complex * x) -> int

    Parameters
    ----------
    QR: gsl_matrix_complex const *
    tau: gsl_vector_complex const *
    x: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_svx(QR, tau, x)

def gsl_linalg_complex_QR_lssolve(QR, tau, b, x, residual):
    r"""
    gsl_linalg_complex_QR_lssolve(gsl_matrix_complex const * QR, gsl_vector_complex const * tau, gsl_vector_complex const * b, gsl_vector_complex * x, gsl_vector_complex * residual) -> int

    Parameters
    ----------
    QR: gsl_matrix_complex const *
    tau: gsl_vector_complex const *
    b: gsl_vector_complex const *
    x: gsl_vector_complex *
    residual: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_lssolve(QR, tau, b, x, residual)

def gsl_linalg_complex_QR_lssolve_r(QR, T, b, x, work):
    r"""
    gsl_linalg_complex_QR_lssolve_r(gsl_matrix_complex const * QR, gsl_matrix_complex const * T, gsl_vector_complex const * b, gsl_vector_complex * x, gsl_vector_complex * work) -> int

    Parameters
    ----------
    QR: gsl_matrix_complex const *
    T: gsl_matrix_complex const *
    b: gsl_vector_complex const *
    x: gsl_vector_complex *
    work: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_lssolve_r(QR, T, b, x, work)

def gsl_linalg_complex_QR_QHvec(QR, tau, v):
    r"""
    gsl_linalg_complex_QR_QHvec(gsl_matrix_complex const * QR, gsl_vector_complex const * tau, gsl_vector_complex * v) -> int

    Parameters
    ----------
    QR: gsl_matrix_complex const *
    tau: gsl_vector_complex const *
    v: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_QHvec(QR, tau, v)

def gsl_linalg_complex_QR_QHvec_r(QR, T, b, work):
    r"""
    gsl_linalg_complex_QR_QHvec_r(gsl_matrix_complex const * QR, gsl_matrix_complex const * T, gsl_vector_complex * b, gsl_vector_complex * work) -> int

    Parameters
    ----------
    QR: gsl_matrix_complex const *
    T: gsl_matrix_complex const *
    b: gsl_vector_complex *
    work: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_QHvec_r(QR, T, b, work)

def gsl_linalg_complex_QR_Qvec(QR, tau, v):
    r"""
    gsl_linalg_complex_QR_Qvec(gsl_matrix_complex const * QR, gsl_vector_complex const * tau, gsl_vector_complex * v) -> int

    Parameters
    ----------
    QR: gsl_matrix_complex const *
    tau: gsl_vector_complex const *
    v: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_Qvec(QR, tau, v)

def gsl_linalg_complex_QR_unpack(QR, tau, Q, R):
    r"""
    gsl_linalg_complex_QR_unpack(gsl_matrix_complex const * QR, gsl_vector_complex const * tau, gsl_matrix_complex * Q, gsl_matrix_complex * R) -> int

    Parameters
    ----------
    QR: gsl_matrix_complex const *
    tau: gsl_vector_complex const *
    Q: gsl_matrix_complex *
    R: gsl_matrix_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_unpack(QR, tau, Q, R)

def gsl_linalg_complex_QR_unpack_r(QR, T, Q, R):
    r"""
    gsl_linalg_complex_QR_unpack_r(gsl_matrix_complex const * QR, gsl_matrix_complex const * T, gsl_matrix_complex * Q, gsl_matrix_complex * R) -> int

    Parameters
    ----------
    QR: gsl_matrix_complex const *
    T: gsl_matrix_complex const *
    Q: gsl_matrix_complex *
    R: gsl_matrix_complex *

    """
    return _gslwrap.gsl_linalg_complex_QR_unpack_r(QR, T, Q, R)

def gsl_linalg_QR_band_decomp_L2(M, p, q, AB, tau):
    r"""
    gsl_linalg_QR_band_decomp_L2(size_t const M, size_t const p, size_t const q, gsl_matrix * AB, gsl_vector * tau) -> int

    Parameters
    ----------
    M: size_t const
    p: size_t const
    q: size_t const
    AB: gsl_matrix *
    tau: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_band_decomp_L2(M, p, q, AB, tau)

def gsl_linalg_QR_band_unpack_L2(p, q, QRB, tau, Q, R):
    r"""
    gsl_linalg_QR_band_unpack_L2(size_t const p, size_t const q, gsl_matrix const * QRB, gsl_vector const * tau, gsl_matrix * Q, gsl_matrix * R) -> int

    Parameters
    ----------
    p: size_t const
    q: size_t const
    QRB: gsl_matrix const *
    tau: gsl_vector const *
    Q: gsl_matrix *
    R: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_QR_band_unpack_L2(p, q, QRB, tau, Q, R)

def gsl_linalg_QRPT_decomp(A, tau, p, norm):
    r"""
    gsl_linalg_QRPT_decomp(gsl_matrix * A, gsl_vector * tau, Permutation p, gsl_vector * norm) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau: gsl_vector *
    p: gsl_permutation *
    norm: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QRPT_decomp(A, tau, p, norm)

def gsl_linalg_QRPT_decomp2(A, q, r, tau, p, norm):
    r"""
    gsl_linalg_QRPT_decomp2(gsl_matrix const * A, gsl_matrix * q, gsl_matrix * r, gsl_vector * tau, Permutation p, gsl_vector * norm) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    q: gsl_matrix *
    r: gsl_matrix *
    tau: gsl_vector *
    p: gsl_permutation *
    norm: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QRPT_decomp2(A, q, r, tau, p, norm)

def gsl_linalg_QRPT_solve(QR, tau, p, b, x):
    r"""
    gsl_linalg_QRPT_solve(gsl_matrix const * QR, gsl_vector const * tau, Permutation p, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    p: gsl_permutation const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QRPT_solve(QR, tau, p, b, x)

def gsl_linalg_QRPT_lssolve(QR, tau, p, b, x, residual):
    r"""
    gsl_linalg_QRPT_lssolve(gsl_matrix const * QR, gsl_vector const * tau, Permutation p, gsl_vector const * b, gsl_vector * x, gsl_vector * residual) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    p: gsl_permutation const *
    b: gsl_vector const *
    x: gsl_vector *
    residual: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QRPT_lssolve(QR, tau, p, b, x, residual)

def gsl_linalg_QRPT_lssolve2(QR, tau, p, b, rank, x, residual):
    r"""
    gsl_linalg_QRPT_lssolve2(gsl_matrix const * QR, gsl_vector const * tau, Permutation p, gsl_vector const * b, size_t const rank, gsl_vector * x, gsl_vector * residual) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    p: gsl_permutation const *
    b: gsl_vector const *
    rank: size_t const
    x: gsl_vector *
    residual: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QRPT_lssolve2(QR, tau, p, b, rank, x, residual)

def gsl_linalg_QRPT_svx(QR, tau, p, x):
    r"""
    gsl_linalg_QRPT_svx(gsl_matrix const * QR, gsl_vector const * tau, Permutation p, gsl_vector * x) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    p: gsl_permutation const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QRPT_svx(QR, tau, p, x)

def gsl_linalg_QRPT_QRsolve(Q, R, p, b, x):
    r"""
    gsl_linalg_QRPT_QRsolve(gsl_matrix const * Q, gsl_matrix const * R, Permutation p, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    Q: gsl_matrix const *
    R: gsl_matrix const *
    p: gsl_permutation const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QRPT_QRsolve(Q, R, p, b, x)

def gsl_linalg_QRPT_Rsolve(QR, p, b, x):
    r"""
    gsl_linalg_QRPT_Rsolve(gsl_matrix const * QR, Permutation p, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    p: gsl_permutation const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QRPT_Rsolve(QR, p, b, x)

def gsl_linalg_QRPT_Rsvx(QR, p, x):
    r"""
    gsl_linalg_QRPT_Rsvx(gsl_matrix const * QR, Permutation p, gsl_vector * x) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    p: gsl_permutation const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QRPT_Rsvx(QR, p, x)

def gsl_linalg_QRPT_update(Q, R, p, u, v):
    r"""
    gsl_linalg_QRPT_update(gsl_matrix * Q, gsl_matrix * R, Permutation p, gsl_vector * u, gsl_vector const * v) -> int

    Parameters
    ----------
    Q: gsl_matrix *
    R: gsl_matrix *
    p: gsl_permutation const *
    u: gsl_vector *
    v: gsl_vector const *

    """
    return _gslwrap.gsl_linalg_QRPT_update(Q, R, p, u, v)

def gsl_linalg_QRPT_rank(QR, tol):
    r"""
    gsl_linalg_QRPT_rank(gsl_matrix const * QR, double const tol) -> size_t

    Parameters
    ----------
    QR: gsl_matrix const *
    tol: double const

    """
    return _gslwrap.gsl_linalg_QRPT_rank(QR, tol)

def gsl_linalg_QRPT_rcond(QR, rcond, work):
    r"""
    gsl_linalg_QRPT_rcond(gsl_matrix const * QR, double * rcond, gsl_vector * work) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    rcond: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QRPT_rcond(QR, rcond, work)

def gsl_linalg_QR_UD_decomp(U, D, Y, T):
    r"""
    gsl_linalg_QR_UD_decomp(gsl_matrix * U, gsl_vector const * D, gsl_matrix * Y, gsl_matrix * T) -> int

    Parameters
    ----------
    U: gsl_matrix *
    D: gsl_vector const *
    Y: gsl_matrix *
    T: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_QR_UD_decomp(U, D, Y, T)

def gsl_linalg_QR_UD_lssolve(R, Y, T, b, x, work):
    r"""
    gsl_linalg_QR_UD_lssolve(gsl_matrix const * R, gsl_matrix const * Y, gsl_matrix const * T, gsl_vector const * b, gsl_vector * x, gsl_vector * work) -> int

    Parameters
    ----------
    R: gsl_matrix const *
    Y: gsl_matrix const *
    T: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_UD_lssolve(R, Y, T, b, x, work)

def gsl_linalg_QR_UR_decomp(S, A, T):
    r"""
    gsl_linalg_QR_UR_decomp(gsl_matrix * S, gsl_matrix * A, gsl_matrix * T) -> int

    Parameters
    ----------
    S: gsl_matrix *
    A: gsl_matrix *
    T: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_QR_UR_decomp(S, A, T)

def gsl_linalg_QR_UU_decomp(U, S, T):
    r"""
    gsl_linalg_QR_UU_decomp(gsl_matrix * U, gsl_matrix * S, gsl_matrix * T) -> int

    Parameters
    ----------
    U: gsl_matrix *
    S: gsl_matrix *
    T: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_QR_UU_decomp(U, S, T)

def gsl_linalg_QR_UU_lssolve(R, Y, T, b, x, work):
    r"""
    gsl_linalg_QR_UU_lssolve(gsl_matrix const * R, gsl_matrix const * Y, gsl_matrix const * T, gsl_vector const * b, gsl_vector * x, gsl_vector * work) -> int

    Parameters
    ----------
    R: gsl_matrix const *
    Y: gsl_matrix const *
    T: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_UU_lssolve(R, Y, T, b, x, work)

def gsl_linalg_QR_UU_QTvec(Y, T, b, work):
    r"""
    gsl_linalg_QR_UU_QTvec(gsl_matrix const * Y, gsl_matrix const * T, gsl_vector * b, gsl_vector * work) -> int

    Parameters
    ----------
    Y: gsl_matrix const *
    T: gsl_matrix const *
    b: gsl_vector *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QR_UU_QTvec(Y, T, b, work)

def gsl_linalg_QR_UZ_decomp(S, A, T):
    r"""
    gsl_linalg_QR_UZ_decomp(gsl_matrix * S, gsl_matrix * A, gsl_matrix * T) -> int

    Parameters
    ----------
    S: gsl_matrix *
    A: gsl_matrix *
    T: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_QR_UZ_decomp(S, A, T)

def gsl_linalg_QL_decomp(A, tau):
    r"""
    gsl_linalg_QL_decomp(gsl_matrix * A, gsl_vector * tau) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau: gsl_vector *

    """
    return _gslwrap.gsl_linalg_QL_decomp(A, tau)

def gsl_linalg_QL_unpack(QL, tau, Q, L):
    r"""
    gsl_linalg_QL_unpack(gsl_matrix const * QL, gsl_vector const * tau, gsl_matrix * Q, gsl_matrix * L) -> int

    Parameters
    ----------
    QL: gsl_matrix const *
    tau: gsl_vector const *
    Q: gsl_matrix *
    L: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_QL_unpack(QL, tau, Q, L)

def gsl_linalg_COD_decomp(A, tau_Q, tau_Z, p, rank, work):
    r"""
    gsl_linalg_COD_decomp(gsl_matrix * A, gsl_vector * tau_Q, gsl_vector * tau_Z, Permutation p, size_t * rank, gsl_vector * work) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau_Q: gsl_vector *
    tau_Z: gsl_vector *
    p: gsl_permutation *
    rank: size_t *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_COD_decomp(A, tau_Q, tau_Z, p, rank, work)

def gsl_linalg_COD_decomp_e(A, tau_Q, tau_Z, p, tol, rank, work):
    r"""
    gsl_linalg_COD_decomp_e(gsl_matrix * A, gsl_vector * tau_Q, gsl_vector * tau_Z, Permutation p, double tol, size_t * rank, gsl_vector * work) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau_Q: gsl_vector *
    tau_Z: gsl_vector *
    p: gsl_permutation *
    tol: double
    rank: size_t *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_COD_decomp_e(A, tau_Q, tau_Z, p, tol, rank, work)

def gsl_linalg_COD_lssolve(QRZT, tau_Q, tau_Z, perm, rank, b, x, residual):
    r"""
    gsl_linalg_COD_lssolve(gsl_matrix const * QRZT, gsl_vector const * tau_Q, gsl_vector const * tau_Z, Permutation perm, size_t const rank, gsl_vector const * b, gsl_vector * x, gsl_vector * residual) -> int

    Parameters
    ----------
    QRZT: gsl_matrix const *
    tau_Q: gsl_vector const *
    tau_Z: gsl_vector const *
    perm: gsl_permutation const *
    rank: size_t const
    b: gsl_vector const *
    x: gsl_vector *
    residual: gsl_vector *

    """
    return _gslwrap.gsl_linalg_COD_lssolve(QRZT, tau_Q, tau_Z, perm, rank, b, x, residual)

def gsl_linalg_COD_lssolve2(_lambda, QRZT, tau_Q, tau_Z, perm, rank, b, x, residual, S, work):
    r"""
    gsl_linalg_COD_lssolve2(double const _lambda, gsl_matrix const * QRZT, gsl_vector const * tau_Q, gsl_vector const * tau_Z, Permutation perm, size_t const rank, gsl_vector const * b, gsl_vector * x, gsl_vector * residual, gsl_matrix * S, gsl_vector * work) -> int

    Parameters
    ----------
    lambda: double const
    QRZT: gsl_matrix const *
    tau_Q: gsl_vector const *
    tau_Z: gsl_vector const *
    perm: gsl_permutation const *
    rank: size_t const
    b: gsl_vector const *
    x: gsl_vector *
    residual: gsl_vector *
    S: gsl_matrix *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_COD_lssolve2(_lambda, QRZT, tau_Q, tau_Z, perm, rank, b, x, residual, S, work)

def gsl_linalg_COD_unpack(QRZT, tau_Q, tau_Z, rank, Q, R, Z):
    r"""
    gsl_linalg_COD_unpack(gsl_matrix const * QRZT, gsl_vector const * tau_Q, gsl_vector const * tau_Z, size_t const rank, gsl_matrix * Q, gsl_matrix * R, gsl_matrix * Z) -> int

    Parameters
    ----------
    QRZT: gsl_matrix const *
    tau_Q: gsl_vector const *
    tau_Z: gsl_vector const *
    rank: size_t const
    Q: gsl_matrix *
    R: gsl_matrix *
    Z: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_COD_unpack(QRZT, tau_Q, tau_Z, rank, Q, R, Z)

def gsl_linalg_COD_matZ(QRZT, tau_Z, rank, A, work):
    r"""
    gsl_linalg_COD_matZ(gsl_matrix const * QRZT, gsl_vector const * tau_Z, size_t const rank, gsl_matrix * A, gsl_vector * work) -> int

    Parameters
    ----------
    QRZT: gsl_matrix const *
    tau_Z: gsl_vector const *
    rank: size_t const
    A: gsl_matrix *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_COD_matZ(QRZT, tau_Z, rank, A, work)

def gsl_linalg_LQ_decomp(A, tau):
    r"""
    gsl_linalg_LQ_decomp(gsl_matrix * A, gsl_vector * tau) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_decomp(A, tau)

def gsl_linalg_LQ_lssolve(LQ, tau, b, x, residual):
    r"""
    gsl_linalg_LQ_lssolve(gsl_matrix const * LQ, gsl_vector const * tau, gsl_vector const * b, gsl_vector * x, gsl_vector * residual) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    tau: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *
    residual: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_lssolve(LQ, tau, b, x, residual)

def gsl_linalg_LQ_QTvec(LQ, tau, v):
    r"""
    gsl_linalg_LQ_QTvec(gsl_matrix const * LQ, gsl_vector const * tau, gsl_vector * v) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    tau: gsl_vector const *
    v: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_QTvec(LQ, tau, v)

def gsl_linalg_LQ_solve_T(LQ, tau, b, x):
    r"""
    gsl_linalg_LQ_solve_T(gsl_matrix const * LQ, gsl_vector const * tau, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    tau: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_solve_T(LQ, tau, b, x)

def gsl_linalg_LQ_svx_T(LQ, tau, x):
    r"""
    gsl_linalg_LQ_svx_T(gsl_matrix const * LQ, gsl_vector const * tau, gsl_vector * x) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    tau: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_svx_T(LQ, tau, x)

def gsl_linalg_LQ_lssolve_T(LQ, tau, b, x, residual):
    r"""
    gsl_linalg_LQ_lssolve_T(gsl_matrix const * LQ, gsl_vector const * tau, gsl_vector const * b, gsl_vector * x, gsl_vector * residual) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    tau: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *
    residual: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_lssolve_T(LQ, tau, b, x, residual)

def gsl_linalg_LQ_Lsolve_T(LQ, b, x):
    r"""
    gsl_linalg_LQ_Lsolve_T(gsl_matrix const * LQ, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_Lsolve_T(LQ, b, x)

def gsl_linalg_LQ_Lsvx_T(LQ, x):
    r"""
    gsl_linalg_LQ_Lsvx_T(gsl_matrix const * LQ, gsl_vector * x) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_Lsvx_T(LQ, x)

def gsl_linalg_L_solve_T(L, b, x):
    r"""
    gsl_linalg_L_solve_T(gsl_matrix const * L, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    L: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_L_solve_T(L, b, x)

def gsl_linalg_LQ_vecQ(LQ, tau, v):
    r"""
    gsl_linalg_LQ_vecQ(gsl_matrix const * LQ, gsl_vector const * tau, gsl_vector * v) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    tau: gsl_vector const *
    v: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_vecQ(LQ, tau, v)

def gsl_linalg_LQ_vecQT(LQ, tau, v):
    r"""
    gsl_linalg_LQ_vecQT(gsl_matrix const * LQ, gsl_vector const * tau, gsl_vector * v) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    tau: gsl_vector const *
    v: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_vecQT(LQ, tau, v)

def gsl_linalg_LQ_unpack(LQ, tau, Q, L):
    r"""
    gsl_linalg_LQ_unpack(gsl_matrix const * LQ, gsl_vector const * tau, gsl_matrix * Q, gsl_matrix * L) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    tau: gsl_vector const *
    Q: gsl_matrix *
    L: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_LQ_unpack(LQ, tau, Q, L)

def gsl_linalg_LQ_update(Q, R, v, w):
    r"""
    gsl_linalg_LQ_update(gsl_matrix * Q, gsl_matrix * R, gsl_vector const * v, gsl_vector * w) -> int

    Parameters
    ----------
    Q: gsl_matrix *
    R: gsl_matrix *
    v: gsl_vector const *
    w: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_update(Q, R, v, w)

def gsl_linalg_LQ_LQsolve(Q, L, b, x):
    r"""
    gsl_linalg_LQ_LQsolve(gsl_matrix * Q, gsl_matrix * L, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    Q: gsl_matrix *
    L: gsl_matrix *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_LQ_LQsolve(Q, L, b, x)

def gsl_linalg_PTLQ_decomp(A, tau, p, norm):
    r"""
    gsl_linalg_PTLQ_decomp(gsl_matrix * A, gsl_vector * tau, Permutation p, gsl_vector * norm) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau: gsl_vector *
    p: gsl_permutation *
    norm: gsl_vector *

    """
    return _gslwrap.gsl_linalg_PTLQ_decomp(A, tau, p, norm)

def gsl_linalg_PTLQ_decomp2(A, q, r, tau, p, norm):
    r"""
    gsl_linalg_PTLQ_decomp2(gsl_matrix const * A, gsl_matrix * q, gsl_matrix * r, gsl_vector * tau, Permutation p, gsl_vector * norm) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    q: gsl_matrix *
    r: gsl_matrix *
    tau: gsl_vector *
    p: gsl_permutation *
    norm: gsl_vector *

    """
    return _gslwrap.gsl_linalg_PTLQ_decomp2(A, q, r, tau, p, norm)

def gsl_linalg_PTLQ_solve_T(QR, tau, p, b, x):
    r"""
    gsl_linalg_PTLQ_solve_T(gsl_matrix const * QR, gsl_vector const * tau, Permutation p, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    QR: gsl_matrix const *
    tau: gsl_vector const *
    p: gsl_permutation const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_PTLQ_solve_T(QR, tau, p, b, x)

def gsl_linalg_PTLQ_svx_T(LQ, tau, p, x):
    r"""
    gsl_linalg_PTLQ_svx_T(gsl_matrix const * LQ, gsl_vector const * tau, Permutation p, gsl_vector * x) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    tau: gsl_vector const *
    p: gsl_permutation const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_PTLQ_svx_T(LQ, tau, p, x)

def gsl_linalg_PTLQ_LQsolve_T(Q, L, p, b, x):
    r"""
    gsl_linalg_PTLQ_LQsolve_T(gsl_matrix const * Q, gsl_matrix const * L, Permutation p, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    Q: gsl_matrix const *
    L: gsl_matrix const *
    p: gsl_permutation const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_PTLQ_LQsolve_T(Q, L, p, b, x)

def gsl_linalg_PTLQ_Lsolve_T(LQ, p, b, x):
    r"""
    gsl_linalg_PTLQ_Lsolve_T(gsl_matrix const * LQ, Permutation p, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    p: gsl_permutation const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_PTLQ_Lsolve_T(LQ, p, b, x)

def gsl_linalg_PTLQ_Lsvx_T(LQ, p, x):
    r"""
    gsl_linalg_PTLQ_Lsvx_T(gsl_matrix const * LQ, Permutation p, gsl_vector * x) -> int

    Parameters
    ----------
    LQ: gsl_matrix const *
    p: gsl_permutation const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_PTLQ_Lsvx_T(LQ, p, x)

def gsl_linalg_PTLQ_update(Q, L, p, v, w):
    r"""
    gsl_linalg_PTLQ_update(gsl_matrix * Q, gsl_matrix * L, Permutation p, gsl_vector const * v, gsl_vector * w) -> int

    Parameters
    ----------
    Q: gsl_matrix *
    L: gsl_matrix *
    p: gsl_permutation const *
    v: gsl_vector const *
    w: gsl_vector *

    """
    return _gslwrap.gsl_linalg_PTLQ_update(Q, L, p, v, w)

def gsl_linalg_cholesky_decomp(A):
    r"""
    gsl_linalg_cholesky_decomp(gsl_matrix * A) -> int

    Parameters
    ----------
    A: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_cholesky_decomp(A)

def gsl_linalg_cholesky_decomp1(A):
    r"""
    gsl_linalg_cholesky_decomp1(gsl_matrix * A) -> int

    Parameters
    ----------
    A: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_cholesky_decomp1(A)

def gsl_linalg_cholesky_solve(cholesky, b, x):
    r"""
    gsl_linalg_cholesky_solve(gsl_matrix const * cholesky, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    cholesky: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_solve(cholesky, b, x)

def gsl_linalg_cholesky_solve_mat(cholesky, B, X):
    r"""
    gsl_linalg_cholesky_solve_mat(gsl_matrix const * cholesky, gsl_matrix const * B, gsl_matrix * X) -> int

    Parameters
    ----------
    cholesky: gsl_matrix const *
    B: gsl_matrix const *
    X: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_cholesky_solve_mat(cholesky, B, X)

def gsl_linalg_cholesky_svx(cholesky, x):
    r"""
    gsl_linalg_cholesky_svx(gsl_matrix const * cholesky, gsl_vector * x) -> int

    Parameters
    ----------
    cholesky: gsl_matrix const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_svx(cholesky, x)

def gsl_linalg_cholesky_svx_mat(cholesky, X):
    r"""
    gsl_linalg_cholesky_svx_mat(gsl_matrix const * cholesky, gsl_matrix * X) -> int

    Parameters
    ----------
    cholesky: gsl_matrix const *
    X: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_cholesky_svx_mat(cholesky, X)

def gsl_linalg_cholesky_invert(cholesky):
    r"""
    gsl_linalg_cholesky_invert(gsl_matrix * cholesky) -> int

    Parameters
    ----------
    cholesky: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_cholesky_invert(cholesky)

def gsl_linalg_cholesky_decomp_unit(A, D):
    r"""
    gsl_linalg_cholesky_decomp_unit(gsl_matrix * A, gsl_vector * D) -> int

    Parameters
    ----------
    A: gsl_matrix *
    D: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_decomp_unit(A, D)

def gsl_linalg_cholesky_scale(A, S):
    r"""
    gsl_linalg_cholesky_scale(gsl_matrix const * A, gsl_vector * S) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    S: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_scale(A, S)

def gsl_linalg_cholesky_scale_apply(A, S):
    r"""
    gsl_linalg_cholesky_scale_apply(gsl_matrix * A, gsl_vector const * S) -> int

    Parameters
    ----------
    A: gsl_matrix *
    S: gsl_vector const *

    """
    return _gslwrap.gsl_linalg_cholesky_scale_apply(A, S)

def gsl_linalg_cholesky_decomp2(A, S):
    r"""
    gsl_linalg_cholesky_decomp2(gsl_matrix * A, gsl_vector * S) -> int

    Parameters
    ----------
    A: gsl_matrix *
    S: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_decomp2(A, S)

def gsl_linalg_cholesky_svx2(LLT, S, x):
    r"""
    gsl_linalg_cholesky_svx2(gsl_matrix const * LLT, gsl_vector const * S, gsl_vector * x) -> int

    Parameters
    ----------
    LLT: gsl_matrix const *
    S: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_svx2(LLT, S, x)

def gsl_linalg_cholesky_solve2(LLT, S, b, x):
    r"""
    gsl_linalg_cholesky_solve2(gsl_matrix const * LLT, gsl_vector const * S, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    LLT: gsl_matrix const *
    S: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_solve2(LLT, S, b, x)

def gsl_linalg_cholesky_rcond(LLT, rcond, work):
    r"""
    gsl_linalg_cholesky_rcond(gsl_matrix const * LLT, double * rcond, gsl_vector * work) -> int

    Parameters
    ----------
    LLT: gsl_matrix const *
    rcond: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_rcond(LLT, rcond, work)

def gsl_linalg_complex_cholesky_decomp(A):
    r"""
    gsl_linalg_complex_cholesky_decomp(gsl_matrix_complex * A) -> int

    Parameters
    ----------
    A: gsl_matrix_complex *

    """
    return _gslwrap.gsl_linalg_complex_cholesky_decomp(A)

def gsl_linalg_complex_cholesky_solve(cholesky, b, x):
    r"""
    gsl_linalg_complex_cholesky_solve(gsl_matrix_complex const * cholesky, gsl_vector_complex const * b, gsl_vector_complex * x) -> int

    Parameters
    ----------
    cholesky: gsl_matrix_complex const *
    b: gsl_vector_complex const *
    x: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_cholesky_solve(cholesky, b, x)

def gsl_linalg_complex_cholesky_svx(cholesky, x):
    r"""
    gsl_linalg_complex_cholesky_svx(gsl_matrix_complex const * cholesky, gsl_vector_complex * x) -> int

    Parameters
    ----------
    cholesky: gsl_matrix_complex const *
    x: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_complex_cholesky_svx(cholesky, x)

def gsl_linalg_pcholesky_decomp(A, p):
    r"""
    gsl_linalg_pcholesky_decomp(gsl_matrix * A, Permutation p) -> int

    Parameters
    ----------
    A: gsl_matrix *
    p: gsl_permutation *

    """
    return _gslwrap.gsl_linalg_pcholesky_decomp(A, p)

def gsl_linalg_pcholesky_solve(LDLT, p, b, x):
    r"""
    gsl_linalg_pcholesky_solve(gsl_matrix const * LDLT, Permutation p, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    p: gsl_permutation const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_pcholesky_solve(LDLT, p, b, x)

def gsl_linalg_pcholesky_svx(LDLT, p, x):
    r"""
    gsl_linalg_pcholesky_svx(gsl_matrix const * LDLT, Permutation p, gsl_vector * x) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    p: gsl_permutation const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_pcholesky_svx(LDLT, p, x)

def gsl_linalg_pcholesky_decomp2(A, p, S):
    r"""
    gsl_linalg_pcholesky_decomp2(gsl_matrix * A, Permutation p, gsl_vector * S) -> int

    Parameters
    ----------
    A: gsl_matrix *
    p: gsl_permutation *
    S: gsl_vector *

    """
    return _gslwrap.gsl_linalg_pcholesky_decomp2(A, p, S)

def gsl_linalg_pcholesky_solve2(LDLT, p, S, b, x):
    r"""
    gsl_linalg_pcholesky_solve2(gsl_matrix const * LDLT, Permutation p, gsl_vector const * S, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    p: gsl_permutation const *
    S: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_pcholesky_solve2(LDLT, p, S, b, x)

def gsl_linalg_pcholesky_svx2(LDLT, p, S, x):
    r"""
    gsl_linalg_pcholesky_svx2(gsl_matrix const * LDLT, Permutation p, gsl_vector const * S, gsl_vector * x) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    p: gsl_permutation const *
    S: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_pcholesky_svx2(LDLT, p, S, x)

def gsl_linalg_pcholesky_invert(LDLT, p, Ainv):
    r"""
    gsl_linalg_pcholesky_invert(gsl_matrix const * LDLT, Permutation p, gsl_matrix * Ainv) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    p: gsl_permutation const *
    Ainv: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_pcholesky_invert(LDLT, p, Ainv)

def gsl_linalg_pcholesky_rcond(LDLT, p, rcond, work):
    r"""
    gsl_linalg_pcholesky_rcond(gsl_matrix const * LDLT, Permutation p, double * rcond, gsl_vector * work) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    p: gsl_permutation const *
    rcond: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_pcholesky_rcond(LDLT, p, rcond, work)

def gsl_linalg_mcholesky_decomp(A, p, E):
    r"""
    gsl_linalg_mcholesky_decomp(gsl_matrix * A, Permutation p, gsl_vector * E) -> int

    Parameters
    ----------
    A: gsl_matrix *
    p: gsl_permutation *
    E: gsl_vector *

    """
    return _gslwrap.gsl_linalg_mcholesky_decomp(A, p, E)

def gsl_linalg_mcholesky_solve(LDLT, p, b, x):
    r"""
    gsl_linalg_mcholesky_solve(gsl_matrix const * LDLT, Permutation p, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    p: gsl_permutation const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_mcholesky_solve(LDLT, p, b, x)

def gsl_linalg_mcholesky_svx(LDLT, p, x):
    r"""
    gsl_linalg_mcholesky_svx(gsl_matrix const * LDLT, Permutation p, gsl_vector * x) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    p: gsl_permutation const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_mcholesky_svx(LDLT, p, x)

def gsl_linalg_mcholesky_rcond(LDLT, p, rcond, work):
    r"""
    gsl_linalg_mcholesky_rcond(gsl_matrix const * LDLT, Permutation p, double * rcond, gsl_vector * work) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    p: gsl_permutation const *
    rcond: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_mcholesky_rcond(LDLT, p, rcond, work)

def gsl_linalg_mcholesky_invert(LDLT, p, Ainv):
    r"""
    gsl_linalg_mcholesky_invert(gsl_matrix const * LDLT, Permutation p, gsl_matrix * Ainv) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    p: gsl_permutation const *
    Ainv: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_mcholesky_invert(LDLT, p, Ainv)

def gsl_linalg_cholesky_band_decomp(A):
    r"""
    gsl_linalg_cholesky_band_decomp(gsl_matrix * A) -> int

    Parameters
    ----------
    A: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_cholesky_band_decomp(A)

def gsl_linalg_cholesky_band_solve(LLT, b, x):
    r"""
    gsl_linalg_cholesky_band_solve(gsl_matrix const * LLT, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    LLT: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_band_solve(LLT, b, x)

def gsl_linalg_cholesky_band_svx(LLT, x):
    r"""
    gsl_linalg_cholesky_band_svx(gsl_matrix const * LLT, gsl_vector * x) -> int

    Parameters
    ----------
    LLT: gsl_matrix const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_band_svx(LLT, x)

def gsl_linalg_cholesky_band_solvem(LLT, B, X):
    r"""
    gsl_linalg_cholesky_band_solvem(gsl_matrix const * LLT, gsl_matrix const * B, gsl_matrix * X) -> int

    Parameters
    ----------
    LLT: gsl_matrix const *
    B: gsl_matrix const *
    X: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_cholesky_band_solvem(LLT, B, X)

def gsl_linalg_cholesky_band_svxm(LLT, X):
    r"""
    gsl_linalg_cholesky_band_svxm(gsl_matrix const * LLT, gsl_matrix * X) -> int

    Parameters
    ----------
    LLT: gsl_matrix const *
    X: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_cholesky_band_svxm(LLT, X)

def gsl_linalg_cholesky_band_invert(LLT, Ainv):
    r"""
    gsl_linalg_cholesky_band_invert(gsl_matrix const * LLT, gsl_matrix * Ainv) -> int

    Parameters
    ----------
    LLT: gsl_matrix const *
    Ainv: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_cholesky_band_invert(LLT, Ainv)

def gsl_linalg_cholesky_band_unpack(LLT, L):
    r"""
    gsl_linalg_cholesky_band_unpack(gsl_matrix const * LLT, gsl_matrix * L) -> int

    Parameters
    ----------
    LLT: gsl_matrix const *
    L: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_cholesky_band_unpack(LLT, L)

def gsl_linalg_cholesky_band_scale(A, S):
    r"""
    gsl_linalg_cholesky_band_scale(gsl_matrix const * A, gsl_vector * S) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    S: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_band_scale(A, S)

def gsl_linalg_cholesky_band_scale_apply(A, S):
    r"""
    gsl_linalg_cholesky_band_scale_apply(gsl_matrix * A, gsl_vector const * S) -> int

    Parameters
    ----------
    A: gsl_matrix *
    S: gsl_vector const *

    """
    return _gslwrap.gsl_linalg_cholesky_band_scale_apply(A, S)

def gsl_linalg_cholesky_band_rcond(LLT, rcond, work):
    r"""
    gsl_linalg_cholesky_band_rcond(gsl_matrix const * LLT, double * rcond, gsl_vector * work) -> int

    Parameters
    ----------
    LLT: gsl_matrix const *
    rcond: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_cholesky_band_rcond(LLT, rcond, work)

def gsl_linalg_ldlt_decomp(A):
    r"""
    gsl_linalg_ldlt_decomp(gsl_matrix * A) -> int

    Parameters
    ----------
    A: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_ldlt_decomp(A)

def gsl_linalg_ldlt_solve(LDLT, b, x):
    r"""
    gsl_linalg_ldlt_solve(gsl_matrix const * LDLT, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_ldlt_solve(LDLT, b, x)

def gsl_linalg_ldlt_svx(LDLT, x):
    r"""
    gsl_linalg_ldlt_svx(gsl_matrix const * LDLT, gsl_vector * x) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_ldlt_svx(LDLT, x)

def gsl_linalg_ldlt_rcond(LDLT, rcond, work):
    r"""
    gsl_linalg_ldlt_rcond(gsl_matrix const * LDLT, double * rcond, gsl_vector * work) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    rcond: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_ldlt_rcond(LDLT, rcond, work)

def gsl_linalg_ldlt_band_decomp(A):
    r"""
    gsl_linalg_ldlt_band_decomp(gsl_matrix * A) -> int

    Parameters
    ----------
    A: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_ldlt_band_decomp(A)

def gsl_linalg_ldlt_band_solve(LDLT, b, x):
    r"""
    gsl_linalg_ldlt_band_solve(gsl_matrix const * LDLT, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_ldlt_band_solve(LDLT, b, x)

def gsl_linalg_ldlt_band_svx(LDLT, x):
    r"""
    gsl_linalg_ldlt_band_svx(gsl_matrix const * LDLT, gsl_vector * x) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_ldlt_band_svx(LDLT, x)

def gsl_linalg_ldlt_band_unpack(LDLT, L, D):
    r"""
    gsl_linalg_ldlt_band_unpack(gsl_matrix const * LDLT, gsl_matrix * L, gsl_vector * D) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    L: gsl_matrix *
    D: gsl_vector *

    """
    return _gslwrap.gsl_linalg_ldlt_band_unpack(LDLT, L, D)

def gsl_linalg_ldlt_band_rcond(LDLT, rcond, work):
    r"""
    gsl_linalg_ldlt_band_rcond(gsl_matrix const * LDLT, double * rcond, gsl_vector * work) -> int

    Parameters
    ----------
    LDLT: gsl_matrix const *
    rcond: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_ldlt_band_rcond(LDLT, rcond, work)

def gsl_linalg_symmtd_decomp(A, tau):
    r"""
    gsl_linalg_symmtd_decomp(gsl_matrix * A, gsl_vector * tau) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau: gsl_vector *

    """
    return _gslwrap.gsl_linalg_symmtd_decomp(A, tau)

def gsl_linalg_symmtd_unpack(A, tau, Q, diag, subdiag):
    r"""
    gsl_linalg_symmtd_unpack(gsl_matrix const * A, gsl_vector const * tau, gsl_matrix * Q, gsl_vector * diag, gsl_vector * subdiag) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    tau: gsl_vector const *
    Q: gsl_matrix *
    diag: gsl_vector *
    subdiag: gsl_vector *

    """
    return _gslwrap.gsl_linalg_symmtd_unpack(A, tau, Q, diag, subdiag)

def gsl_linalg_symmtd_unpack_T(A, diag, subdiag):
    r"""
    gsl_linalg_symmtd_unpack_T(gsl_matrix const * A, gsl_vector * diag, gsl_vector * subdiag) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    diag: gsl_vector *
    subdiag: gsl_vector *

    """
    return _gslwrap.gsl_linalg_symmtd_unpack_T(A, diag, subdiag)

def gsl_linalg_hermtd_decomp(A, tau):
    r"""
    gsl_linalg_hermtd_decomp(gsl_matrix_complex * A, gsl_vector_complex * tau) -> int

    Parameters
    ----------
    A: gsl_matrix_complex *
    tau: gsl_vector_complex *

    """
    return _gslwrap.gsl_linalg_hermtd_decomp(A, tau)

def gsl_linalg_hermtd_unpack(A, tau, U, diag, sudiag):
    r"""
    gsl_linalg_hermtd_unpack(gsl_matrix_complex const * A, gsl_vector_complex const * tau, gsl_matrix_complex * U, gsl_vector * diag, gsl_vector * sudiag) -> int

    Parameters
    ----------
    A: gsl_matrix_complex const *
    tau: gsl_vector_complex const *
    U: gsl_matrix_complex *
    diag: gsl_vector *
    sudiag: gsl_vector *

    """
    return _gslwrap.gsl_linalg_hermtd_unpack(A, tau, U, diag, sudiag)

def gsl_linalg_hermtd_unpack_T(A, diag, subdiag):
    r"""
    gsl_linalg_hermtd_unpack_T(gsl_matrix_complex const * A, gsl_vector * diag, gsl_vector * subdiag) -> int

    Parameters
    ----------
    A: gsl_matrix_complex const *
    diag: gsl_vector *
    subdiag: gsl_vector *

    """
    return _gslwrap.gsl_linalg_hermtd_unpack_T(A, diag, subdiag)

def gsl_linalg_HH_solve(A, b, x):
    r"""
    gsl_linalg_HH_solve(gsl_matrix * A, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    A: gsl_matrix *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_HH_solve(A, b, x)

def gsl_linalg_HH_svx(A, x):
    r"""
    gsl_linalg_HH_svx(gsl_matrix * A, gsl_vector * x) -> int

    Parameters
    ----------
    A: gsl_matrix *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_HH_svx(A, x)

def gsl_linalg_solve_symm_tridiag(diag, offdiag, b, x):
    r"""
    gsl_linalg_solve_symm_tridiag(gsl_vector const * diag, gsl_vector const * offdiag, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    diag: gsl_vector const *
    offdiag: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_solve_symm_tridiag(diag, offdiag, b, x)

def gsl_linalg_solve_tridiag(diag, abovediag, belowdiag, b, x):
    r"""
    gsl_linalg_solve_tridiag(gsl_vector const * diag, gsl_vector const * abovediag, gsl_vector const * belowdiag, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    diag: gsl_vector const *
    abovediag: gsl_vector const *
    belowdiag: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_solve_tridiag(diag, abovediag, belowdiag, b, x)

def gsl_linalg_solve_symm_cyc_tridiag(diag, offdiag, b, x):
    r"""
    gsl_linalg_solve_symm_cyc_tridiag(gsl_vector const * diag, gsl_vector const * offdiag, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    diag: gsl_vector const *
    offdiag: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_solve_symm_cyc_tridiag(diag, offdiag, b, x)

def gsl_linalg_solve_cyc_tridiag(diag, abovediag, belowdiag, b, x):
    r"""
    gsl_linalg_solve_cyc_tridiag(gsl_vector const * diag, gsl_vector const * abovediag, gsl_vector const * belowdiag, gsl_vector const * b, gsl_vector * x) -> int

    Parameters
    ----------
    diag: gsl_vector const *
    abovediag: gsl_vector const *
    belowdiag: gsl_vector const *
    b: gsl_vector const *
    x: gsl_vector *

    """
    return _gslwrap.gsl_linalg_solve_cyc_tridiag(diag, abovediag, belowdiag, b, x)

def gsl_linalg_bidiag_decomp(A, tau_U, tau_V):
    r"""
    gsl_linalg_bidiag_decomp(gsl_matrix * A, gsl_vector * tau_U, gsl_vector * tau_V) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau_U: gsl_vector *
    tau_V: gsl_vector *

    """
    return _gslwrap.gsl_linalg_bidiag_decomp(A, tau_U, tau_V)

def gsl_linalg_bidiag_unpack(A, tau_U, U, tau_V, V, diag, superdiag):
    r"""
    gsl_linalg_bidiag_unpack(gsl_matrix const * A, gsl_vector const * tau_U, gsl_matrix * U, gsl_vector const * tau_V, gsl_matrix * V, gsl_vector * diag, gsl_vector * superdiag) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    tau_U: gsl_vector const *
    U: gsl_matrix *
    tau_V: gsl_vector const *
    V: gsl_matrix *
    diag: gsl_vector *
    superdiag: gsl_vector *

    """
    return _gslwrap.gsl_linalg_bidiag_unpack(A, tau_U, U, tau_V, V, diag, superdiag)

def gsl_linalg_bidiag_unpack2(A, tau_U, tau_V, V):
    r"""
    gsl_linalg_bidiag_unpack2(gsl_matrix * A, gsl_vector * tau_U, gsl_vector * tau_V, gsl_matrix * V) -> int

    Parameters
    ----------
    A: gsl_matrix *
    tau_U: gsl_vector *
    tau_V: gsl_vector *
    V: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_bidiag_unpack2(A, tau_U, tau_V, V)

def gsl_linalg_bidiag_unpack_B(A, diag, superdiag):
    r"""
    gsl_linalg_bidiag_unpack_B(gsl_matrix const * A, gsl_vector * diag, gsl_vector * superdiag) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    diag: gsl_vector *
    superdiag: gsl_vector *

    """
    return _gslwrap.gsl_linalg_bidiag_unpack_B(A, diag, superdiag)

def gsl_linalg_balance_matrix(A, D):
    r"""
    gsl_linalg_balance_matrix(gsl_matrix * A, gsl_vector * D) -> int

    Parameters
    ----------
    A: gsl_matrix *
    D: gsl_vector *

    """
    return _gslwrap.gsl_linalg_balance_matrix(A, D)

def gsl_linalg_balance_accum(A, D):
    r"""
    gsl_linalg_balance_accum(gsl_matrix * A, gsl_vector * D) -> int

    Parameters
    ----------
    A: gsl_matrix *
    D: gsl_vector *

    """
    return _gslwrap.gsl_linalg_balance_accum(A, D)

def gsl_linalg_balance_columns(A, D):
    r"""
    gsl_linalg_balance_columns(gsl_matrix * A, gsl_vector * D) -> int

    Parameters
    ----------
    A: gsl_matrix *
    D: gsl_vector *

    """
    return _gslwrap.gsl_linalg_balance_columns(A, D)

def gsl_linalg_tri_rcond(Uplo, A, rcond, work):
    r"""
    gsl_linalg_tri_rcond(CBLAS_UPLO_t Uplo, gsl_matrix const * A, double * rcond, gsl_vector * work) -> int

    Parameters
    ----------
    Uplo: enum CBLAS_UPLO_t
    A: gsl_matrix const *
    rcond: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_tri_rcond(Uplo, A, rcond, work)

def gsl_linalg_tri_upper_rcond(A, rcond, work):
    r"""
    gsl_linalg_tri_upper_rcond(gsl_matrix const * A, double * rcond, gsl_vector * work) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    rcond: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_tri_upper_rcond(A, rcond, work)

def gsl_linalg_tri_lower_rcond(A, rcond, work):
    r"""
    gsl_linalg_tri_lower_rcond(gsl_matrix const * A, double * rcond, gsl_vector * work) -> int

    Parameters
    ----------
    A: gsl_matrix const *
    rcond: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_tri_lower_rcond(A, rcond, work)

def gsl_linalg_invnorm1(N, Ainvx, params, Ainvnorm, work):
    r"""
    gsl_linalg_invnorm1(size_t const N, int (*)(CBLAS_TRANSPOSE_t,gsl_vector *,void *) Ainvx, void * params, double * Ainvnorm, gsl_vector * work) -> int

    Parameters
    ----------
    N: size_t const
    Ainvx: int (*)(CBLAS_TRANSPOSE_t,gsl_vector *,void *)
    params: void *
    Ainvnorm: double *
    work: gsl_vector *

    """
    return _gslwrap.gsl_linalg_invnorm1(N, Ainvx, params, Ainvnorm, work)

def gsl_linalg_tri_upper_invert(T):
    r"""
    gsl_linalg_tri_upper_invert(gsl_matrix * T) -> int

    Parameters
    ----------
    T: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_tri_upper_invert(T)

def gsl_linalg_tri_lower_invert(T):
    r"""
    gsl_linalg_tri_lower_invert(gsl_matrix * T) -> int

    Parameters
    ----------
    T: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_tri_lower_invert(T)

def gsl_linalg_tri_upper_unit_invert(T):
    r"""
    gsl_linalg_tri_upper_unit_invert(gsl_matrix * T) -> int

    Parameters
    ----------
    T: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_tri_upper_unit_invert(T)

def gsl_linalg_tri_lower_unit_invert(T):
    r"""
    gsl_linalg_tri_lower_unit_invert(gsl_matrix * T) -> int

    Parameters
    ----------
    T: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_tri_lower_unit_invert(T)

def gsl_linalg_tri_invert(Uplo, Diag, T):
    r"""
    gsl_linalg_tri_invert(CBLAS_UPLO_t Uplo, CBLAS_DIAG_t Diag, gsl_matrix * T) -> int

    Parameters
    ----------
    Uplo: enum CBLAS_UPLO_t
    Diag: enum CBLAS_DIAG_t
    T: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_tri_invert(Uplo, Diag, T)

def gsl_linalg_complex_tri_invert(Uplo, Diag, T):
    r"""
    gsl_linalg_complex_tri_invert(CBLAS_UPLO_t Uplo, CBLAS_DIAG_t Diag, gsl_matrix_complex * T) -> int

    Parameters
    ----------
    Uplo: enum CBLAS_UPLO_t
    Diag: enum CBLAS_DIAG_t
    T: gsl_matrix_complex *

    """
    return _gslwrap.gsl_linalg_complex_tri_invert(Uplo, Diag, T)

def gsl_linalg_tri_LTL(L):
    r"""
    gsl_linalg_tri_LTL(gsl_matrix * L) -> int

    Parameters
    ----------
    L: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_tri_LTL(L)

def gsl_linalg_tri_UL(LU):
    r"""
    gsl_linalg_tri_UL(gsl_matrix * LU) -> int

    Parameters
    ----------
    LU: gsl_matrix *

    """
    return _gslwrap.gsl_linalg_tri_UL(LU)

def gsl_linalg_complex_tri_LHL(L):
    r"""
    gsl_linalg_complex_tri_LHL(gsl_matrix_complex * L) -> int

    Parameters
    ----------
    L: gsl_matrix_complex *

    """
    return _gslwrap.gsl_linalg_complex_tri_LHL(L)

def gsl_linalg_complex_tri_UL(LU):
    r"""
    gsl_linalg_complex_tri_UL(gsl_matrix_complex * LU) -> int

    Parameters
    ----------
    LU: gsl_matrix_complex *

    """
    return _gslwrap.gsl_linalg_complex_tri_UL(LU)

def pygsl_linalg_LU_decomp(A, p):
    r"""
    pygsl_linalg_LU_decomp(gsl_matrix * A, Permutation p) -> gsl_error_flag_drop

    Parameters
    ----------
    A: gsl_matrix *
    p: gsl_permutation *

    """
    return _gslwrap.pygsl_linalg_LU_decomp(A, p)

def pygsl_linalg_complex_LU_decomp(A, p):
    r"""
    pygsl_linalg_complex_LU_decomp(gsl_matrix_complex * A, Permutation p) -> gsl_error_flag_drop

    Parameters
    ----------
    A: gsl_matrix_complex *
    p: gsl_permutation *

    """
    return _gslwrap.pygsl_linalg_complex_LU_decomp(A, p)
class Combination(object):
    r"""Proxy of C gsl_combination_struct struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n, k):
        r"""bla blamore blah blah"""
        _gslwrap.Combination_swiginit(self, _gslwrap.new_Combination(n, k))
    __swig_destroy__ = _gslwrap.delete_Combination

    def __getitem__(self, i):
        r"""__getitem__(Combination self, size_t const i) -> size_t"""
        return _gslwrap.Combination___getitem__(self, i)

    def k(self):
        r"""k(Combination self) -> size_t"""
        return _gslwrap.Combination_k(self)

    def n(self):
        r"""n(Combination self) -> size_t"""
        return _gslwrap.Combination_n(self)

    def init_first(self):
        r"""init_first(Combination self)"""
        return _gslwrap.Combination_init_first(self)

    def init_last(self):
        r"""init_last(Combination self)"""
        return _gslwrap.Combination_init_last(self)

    def valid(self):
        r"""valid(Combination self) -> int"""
        return _gslwrap.Combination_valid(self)

    def next(self):
        r"""next(Combination self) -> int"""
        return _gslwrap.Combination_next(self)

    def prev(self):
        r"""prev(Combination self) -> int"""
        return _gslwrap.Combination_prev(self)

    def tolist(self):
        r"""tolist(Combination self) -> PyObject *"""
        return _gslwrap.Combination_tolist(self)

    def toarray(self):
        r"""toarray(Combination self) -> PyObject *"""
        return _gslwrap.Combination_toarray(self)

# Register Combination in _gslwrap:
_gslwrap.Combination_swigregister(Combination)

M_E = _gslwrap.M_E

M_LOG2E = _gslwrap.M_LOG2E

M_LOG10E = _gslwrap.M_LOG10E

M_SQRT2 = _gslwrap.M_SQRT2

M_SQRT1_2 = _gslwrap.M_SQRT1_2

M_SQRT3 = _gslwrap.M_SQRT3

M_PI = _gslwrap.M_PI

M_PI_2 = _gslwrap.M_PI_2

M_PI_4 = _gslwrap.M_PI_4

M_SQRTPI = _gslwrap.M_SQRTPI

M_2_SQRTPI = _gslwrap.M_2_SQRTPI

M_1_PI = _gslwrap.M_1_PI

M_2_PI = _gslwrap.M_2_PI

M_LN10 = _gslwrap.M_LN10

M_LN2 = _gslwrap.M_LN2

M_LNPI = _gslwrap.M_LNPI

M_EULER = _gslwrap.M_EULER

GSL_POSZERO = _gslwrap.GSL_POSZERO

GSL_NEGZERO = _gslwrap.GSL_NEGZERO


def gsl_log1p(x):
    r"""gsl_log1p(double const x) -> double"""
    return _gslwrap.gsl_log1p(x)

def gsl_expm1(x):
    r"""gsl_expm1(double const x) -> double"""
    return _gslwrap.gsl_expm1(x)

def gsl_hypot(x, y):
    r"""gsl_hypot(double const x, double const y) -> double"""
    return _gslwrap.gsl_hypot(x, y)

def gsl_hypot3(x, y, z):
    r"""gsl_hypot3(double const x, double const y, double const z) -> double"""
    return _gslwrap.gsl_hypot3(x, y, z)

def gsl_acosh(x):
    r"""gsl_acosh(double const x) -> double"""
    return _gslwrap.gsl_acosh(x)

def gsl_asinh(x):
    r"""gsl_asinh(double const x) -> double"""
    return _gslwrap.gsl_asinh(x)

def gsl_atanh(x):
    r"""gsl_atanh(double const x) -> double"""
    return _gslwrap.gsl_atanh(x)

def gsl_isnan(x):
    r"""gsl_isnan(double const x) -> int"""
    return _gslwrap.gsl_isnan(x)

def gsl_isinf(x):
    r"""gsl_isinf(double const x) -> int"""
    return _gslwrap.gsl_isinf(x)

def gsl_finite(x):
    r"""gsl_finite(double const x) -> int"""
    return _gslwrap.gsl_finite(x)

def gsl_nan():
    r"""gsl_nan() -> double"""
    return _gslwrap.gsl_nan()

def gsl_posinf():
    r"""gsl_posinf() -> double"""
    return _gslwrap.gsl_posinf()

def gsl_neginf():
    r"""gsl_neginf() -> double"""
    return _gslwrap.gsl_neginf()

def gsl_fdiv(x, y):
    r"""gsl_fdiv(double const x, double const y) -> double"""
    return _gslwrap.gsl_fdiv(x, y)

def gsl_coerce_double(x):
    r"""gsl_coerce_double(double const x) -> double"""
    return _gslwrap.gsl_coerce_double(x)

def gsl_coerce_float(x):
    r"""gsl_coerce_float(float const x) -> float"""
    return _gslwrap.gsl_coerce_float(x)

def gsl_coerce_long_double(x):
    r"""gsl_coerce_long_double(long double const x) -> long double"""
    return _gslwrap.gsl_coerce_long_double(x)

def gsl_ldexp(x, e):
    r"""gsl_ldexp(double const x, int const e) -> double"""
    return _gslwrap.gsl_ldexp(x, e)

def gsl_frexp(x, e):
    r"""gsl_frexp(double const x, int * e) -> double"""
    return _gslwrap.gsl_frexp(x, e)

def gsl_fcmp(x1, x2, epsilon):
    r"""gsl_fcmp(double const x1, double const x2, double const epsilon) -> int"""
    return _gslwrap.gsl_fcmp(x1, x2, epsilon)
CblasRowMajor = _gslwrap.CblasRowMajor

CblasColMajor = _gslwrap.CblasColMajor

CblasNoTrans = _gslwrap.CblasNoTrans

CblasTrans = _gslwrap.CblasTrans

CblasConjTrans = _gslwrap.CblasConjTrans

CblasUpper = _gslwrap.CblasUpper

CblasLower = _gslwrap.CblasLower

CblasNonUnit = _gslwrap.CblasNonUnit

CblasUnit = _gslwrap.CblasUnit

CblasLeft = _gslwrap.CblasLeft

CblasRight = _gslwrap.CblasRight


def gsl_blas_sdsdot(alpha, X, Y, result):
    r"""gsl_blas_sdsdot(float alpha, gsl_vector_float const * X, gsl_vector_float const * Y, float * result) -> int"""
    return _gslwrap.gsl_blas_sdsdot(alpha, X, Y, result)

def gsl_blas_dsdot(X, Y):
    r"""gsl_blas_dsdot(gsl_vector_float const * X, gsl_vector_float const * Y) -> int"""
    return _gslwrap.gsl_blas_dsdot(X, Y)

def gsl_blas_sdot(X, Y, result):
    r"""gsl_blas_sdot(gsl_vector_float const * X, gsl_vector_float const * Y, float * result) -> int"""
    return _gslwrap.gsl_blas_sdot(X, Y, result)

def gsl_blas_ddot(X, Y):
    r"""gsl_blas_ddot(gsl_vector const * X, gsl_vector const * Y) -> int"""
    return _gslwrap.gsl_blas_ddot(X, Y)

def gsl_blas_cdotu(X, Y, dotu):
    r"""gsl_blas_cdotu(gsl_vector_complex_float const * X, gsl_vector_complex_float const * Y, gsl_complex_float * dotu) -> int"""
    return _gslwrap.gsl_blas_cdotu(X, Y, dotu)

def gsl_blas_cdotc(X, Y, dotc):
    r"""gsl_blas_cdotc(gsl_vector_complex_float const * X, gsl_vector_complex_float const * Y, gsl_complex_float * dotc) -> int"""
    return _gslwrap.gsl_blas_cdotc(X, Y, dotc)

def gsl_blas_zdotu(X, Y, dotu):
    r"""gsl_blas_zdotu(gsl_vector_complex const * X, gsl_vector_complex const * Y, gsl_complex * dotu) -> int"""
    return _gslwrap.gsl_blas_zdotu(X, Y, dotu)

def gsl_blas_zdotc(X, Y, dotc):
    r"""gsl_blas_zdotc(gsl_vector_complex const * X, gsl_vector_complex const * Y, gsl_complex * dotc) -> int"""
    return _gslwrap.gsl_blas_zdotc(X, Y, dotc)

def gsl_blas_snrm2(X):
    r"""gsl_blas_snrm2(gsl_vector_float const * X) -> float"""
    return _gslwrap.gsl_blas_snrm2(X)

def gsl_blas_sasum(X):
    r"""gsl_blas_sasum(gsl_vector_float const * X) -> float"""
    return _gslwrap.gsl_blas_sasum(X)

def gsl_blas_dnrm2(X):
    r"""gsl_blas_dnrm2(gsl_vector const * X) -> double"""
    return _gslwrap.gsl_blas_dnrm2(X)

def gsl_blas_dasum(X):
    r"""gsl_blas_dasum(gsl_vector const * X) -> double"""
    return _gslwrap.gsl_blas_dasum(X)

def gsl_blas_scnrm2(X):
    r"""gsl_blas_scnrm2(gsl_vector_complex_float const * X) -> float"""
    return _gslwrap.gsl_blas_scnrm2(X)

def gsl_blas_scasum(X):
    r"""gsl_blas_scasum(gsl_vector_complex_float const * X) -> float"""
    return _gslwrap.gsl_blas_scasum(X)

def gsl_blas_dznrm2(X):
    r"""gsl_blas_dznrm2(gsl_vector_complex const * X) -> double"""
    return _gslwrap.gsl_blas_dznrm2(X)

def gsl_blas_dzasum(X):
    r"""gsl_blas_dzasum(gsl_vector_complex const * X) -> double"""
    return _gslwrap.gsl_blas_dzasum(X)

def gsl_blas_isamax(X):
    r"""gsl_blas_isamax(gsl_vector_float const * X) -> CBLAS_INDEX_t"""
    return _gslwrap.gsl_blas_isamax(X)

def gsl_blas_idamax(X):
    r"""gsl_blas_idamax(gsl_vector const * X) -> CBLAS_INDEX_t"""
    return _gslwrap.gsl_blas_idamax(X)

def gsl_blas_icamax(X):
    r"""gsl_blas_icamax(gsl_vector_complex_float const * X) -> CBLAS_INDEX_t"""
    return _gslwrap.gsl_blas_icamax(X)

def gsl_blas_izamax(X):
    r"""gsl_blas_izamax(gsl_vector_complex const * X) -> CBLAS_INDEX_t"""
    return _gslwrap.gsl_blas_izamax(X)

def gsl_blas_sswap(X, Y):
    r"""gsl_blas_sswap(gsl_vector_float * X, gsl_vector_float * Y) -> int"""
    return _gslwrap.gsl_blas_sswap(X, Y)

def gsl_blas_scopy(X, Y):
    r"""gsl_blas_scopy(gsl_vector_float const * X, gsl_vector_float * Y) -> int"""
    return _gslwrap.gsl_blas_scopy(X, Y)

def gsl_blas_saxpy(alpha, X, Y):
    r"""gsl_blas_saxpy(float alpha, gsl_vector_float const * X, gsl_vector_float * Y) -> int"""
    return _gslwrap.gsl_blas_saxpy(alpha, X, Y)

def gsl_blas_dswap(X, Y):
    r"""gsl_blas_dswap(gsl_vector * X, gsl_vector * Y) -> int"""
    return _gslwrap.gsl_blas_dswap(X, Y)

def gsl_blas_dcopy(X, Y):
    r"""gsl_blas_dcopy(gsl_vector const * X, gsl_vector * Y) -> int"""
    return _gslwrap.gsl_blas_dcopy(X, Y)

def gsl_blas_daxpy(alpha, X, Y):
    r"""gsl_blas_daxpy(double alpha, gsl_vector const * X, gsl_vector * Y) -> int"""
    return _gslwrap.gsl_blas_daxpy(alpha, X, Y)

def gsl_blas_cswap(X, Y):
    r"""gsl_blas_cswap(gsl_vector_complex_float * X, gsl_vector_complex_float * Y) -> int"""
    return _gslwrap.gsl_blas_cswap(X, Y)

def gsl_blas_ccopy(X, Y):
    r"""gsl_blas_ccopy(gsl_vector_complex_float const * X, gsl_vector_complex_float * Y) -> int"""
    return _gslwrap.gsl_blas_ccopy(X, Y)

def gsl_blas_caxpy(alpha, X, Y):
    r"""gsl_blas_caxpy(gsl_complex_float const alpha, gsl_vector_complex_float const * X, gsl_vector_complex_float * Y) -> int"""
    return _gslwrap.gsl_blas_caxpy(alpha, X, Y)

def gsl_blas_zswap(X, Y):
    r"""gsl_blas_zswap(gsl_vector_complex * X, gsl_vector_complex * Y) -> int"""
    return _gslwrap.gsl_blas_zswap(X, Y)

def gsl_blas_zcopy(X, Y):
    r"""gsl_blas_zcopy(gsl_vector_complex const * X, gsl_vector_complex * Y) -> int"""
    return _gslwrap.gsl_blas_zcopy(X, Y)

def gsl_blas_zaxpy(alpha, X, Y):
    r"""gsl_blas_zaxpy(gsl_complex const alpha, gsl_vector_complex const * X, gsl_vector_complex * Y) -> int"""
    return _gslwrap.gsl_blas_zaxpy(alpha, X, Y)

def gsl_blas_srotg(a, b, c, s):
    r"""gsl_blas_srotg(float [] a, float [] b, float [] c, float [] s) -> int"""
    return _gslwrap.gsl_blas_srotg(a, b, c, s)

def gsl_blas_srotmg(d1, d2, b1, b2, P):
    r"""gsl_blas_srotmg(float [] d1, float [] d2, float [] b1, float b2, float [] P) -> int"""
    return _gslwrap.gsl_blas_srotmg(d1, d2, b1, b2, P)

def gsl_blas_srot(X, Y, c, s):
    r"""gsl_blas_srot(gsl_vector_float * X, gsl_vector_float * Y, float c, float s) -> int"""
    return _gslwrap.gsl_blas_srot(X, Y, c, s)

def gsl_blas_srotm(X, Y, P):
    r"""gsl_blas_srotm(gsl_vector_float * X, gsl_vector_float * Y, float const [] P) -> int"""
    return _gslwrap.gsl_blas_srotm(X, Y, P)

def gsl_blas_drotg(a, b, c, s):
    r"""gsl_blas_drotg(double [] a, double [] b, double [] c, double [] s) -> int"""
    return _gslwrap.gsl_blas_drotg(a, b, c, s)

def gsl_blas_drotmg(d1, d2, b1, b2, P):
    r"""gsl_blas_drotmg(double [] d1, double [] d2, double [] b1, double b2, double [] P) -> int"""
    return _gslwrap.gsl_blas_drotmg(d1, d2, b1, b2, P)

def gsl_blas_drot(X, Y, c, s):
    r"""gsl_blas_drot(gsl_vector * X, gsl_vector * Y, double const c, double const s) -> int"""
    return _gslwrap.gsl_blas_drot(X, Y, c, s)

def gsl_blas_drotm(X, Y, P):
    r"""gsl_blas_drotm(gsl_vector * X, gsl_vector * Y, double const [] P) -> int"""
    return _gslwrap.gsl_blas_drotm(X, Y, P)

def gsl_blas_sscal(alpha, X):
    r"""gsl_blas_sscal(float alpha, gsl_vector_float * X)"""
    return _gslwrap.gsl_blas_sscal(alpha, X)

def gsl_blas_dscal(alpha, X):
    r"""gsl_blas_dscal(double alpha, gsl_vector * X)"""
    return _gslwrap.gsl_blas_dscal(alpha, X)

def gsl_blas_cscal(alpha, X):
    r"""gsl_blas_cscal(gsl_complex_float const alpha, gsl_vector_complex_float * X)"""
    return _gslwrap.gsl_blas_cscal(alpha, X)

def gsl_blas_zscal(alpha, X):
    r"""gsl_blas_zscal(gsl_complex const alpha, gsl_vector_complex * X)"""
    return _gslwrap.gsl_blas_zscal(alpha, X)

def gsl_blas_csscal(alpha, X):
    r"""gsl_blas_csscal(float alpha, gsl_vector_complex_float * X)"""
    return _gslwrap.gsl_blas_csscal(alpha, X)

def gsl_blas_zdscal(alpha, X):
    r"""gsl_blas_zdscal(double alpha, gsl_vector_complex * X)"""
    return _gslwrap.gsl_blas_zdscal(alpha, X)

def gsl_blas_sgemv(TransA, alpha, A, X, beta, Y):
    r"""gsl_blas_sgemv(CBLAS_TRANSPOSE_t TransA, float alpha, gsl_matrix_float const * A, gsl_vector_float const * X, float beta, gsl_vector_float * Y) -> int"""
    return _gslwrap.gsl_blas_sgemv(TransA, alpha, A, X, beta, Y)

def gsl_blas_strmv(Uplo, TransA, Diag, A, X):
    r"""gsl_blas_strmv(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_matrix_float const * A, gsl_vector_float * X) -> int"""
    return _gslwrap.gsl_blas_strmv(Uplo, TransA, Diag, A, X)

def gsl_blas_strsv(Uplo, TransA, Diag, A, X):
    r"""gsl_blas_strsv(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_matrix_float const * A, gsl_vector_float * X) -> int"""
    return _gslwrap.gsl_blas_strsv(Uplo, TransA, Diag, A, X)

def gsl_blas_dgemv(TransA, alpha, A, X, beta, Y):
    r"""gsl_blas_dgemv(CBLAS_TRANSPOSE_t TransA, double alpha, gsl_matrix const * A, gsl_vector const * X, double beta, gsl_vector * Y) -> int"""
    return _gslwrap.gsl_blas_dgemv(TransA, alpha, A, X, beta, Y)

def gsl_blas_dtrmv(Uplo, TransA, Diag, A, X):
    r"""gsl_blas_dtrmv(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_matrix const * A, gsl_vector * X) -> int"""
    return _gslwrap.gsl_blas_dtrmv(Uplo, TransA, Diag, A, X)

def gsl_blas_dtrsv(Uplo, TransA, Diag, A, X):
    r"""gsl_blas_dtrsv(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_matrix const * A, gsl_vector * X) -> int"""
    return _gslwrap.gsl_blas_dtrsv(Uplo, TransA, Diag, A, X)

def gsl_blas_cgemv(TransA, alpha, A, X, beta, Y):
    r"""gsl_blas_cgemv(CBLAS_TRANSPOSE_t TransA, gsl_complex_float const alpha, gsl_matrix_complex_float const * A, gsl_vector_complex_float const * X, gsl_complex_float const beta, gsl_vector_complex_float * Y) -> int"""
    return _gslwrap.gsl_blas_cgemv(TransA, alpha, A, X, beta, Y)

def gsl_blas_ctrmv(Uplo, TransA, Diag, A, X):
    r"""gsl_blas_ctrmv(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_matrix_complex_float const * A, gsl_vector_complex_float * X) -> int"""
    return _gslwrap.gsl_blas_ctrmv(Uplo, TransA, Diag, A, X)

def gsl_blas_ctrsv(Uplo, TransA, Diag, A, X):
    r"""gsl_blas_ctrsv(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_matrix_complex_float const * A, gsl_vector_complex_float * X) -> int"""
    return _gslwrap.gsl_blas_ctrsv(Uplo, TransA, Diag, A, X)

def gsl_blas_zgemv(TransA, alpha, A, X, beta, Y):
    r"""gsl_blas_zgemv(CBLAS_TRANSPOSE_t TransA, gsl_complex const alpha, gsl_matrix_complex const * A, gsl_vector_complex const * X, gsl_complex const beta, gsl_vector_complex * Y) -> int"""
    return _gslwrap.gsl_blas_zgemv(TransA, alpha, A, X, beta, Y)

def gsl_blas_ztrmv(Uplo, TransA, Diag, A, X):
    r"""gsl_blas_ztrmv(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_matrix_complex const * A, gsl_vector_complex * X) -> int"""
    return _gslwrap.gsl_blas_ztrmv(Uplo, TransA, Diag, A, X)

def gsl_blas_ztrsv(Uplo, TransA, Diag, A, X):
    r"""gsl_blas_ztrsv(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_matrix_complex const * A, gsl_vector_complex * X) -> int"""
    return _gslwrap.gsl_blas_ztrsv(Uplo, TransA, Diag, A, X)

def gsl_blas_ssymv(Uplo, alpha, A, X, beta, Y):
    r"""gsl_blas_ssymv(CBLAS_UPLO_t Uplo, float alpha, gsl_matrix_float const * A, gsl_vector_float const * X, float beta, gsl_vector_float * Y) -> int"""
    return _gslwrap.gsl_blas_ssymv(Uplo, alpha, A, X, beta, Y)

def gsl_blas_sger(alpha, X, Y, A):
    r"""gsl_blas_sger(float alpha, gsl_vector_float const * X, gsl_vector_float const * Y, gsl_matrix_float * A) -> int"""
    return _gslwrap.gsl_blas_sger(alpha, X, Y, A)

def gsl_blas_ssyr(Uplo, alpha, X, A):
    r"""gsl_blas_ssyr(CBLAS_UPLO_t Uplo, float alpha, gsl_vector_float const * X, gsl_matrix_float * A) -> int"""
    return _gslwrap.gsl_blas_ssyr(Uplo, alpha, X, A)

def gsl_blas_ssyr2(Uplo, alpha, X, Y, A):
    r"""gsl_blas_ssyr2(CBLAS_UPLO_t Uplo, float alpha, gsl_vector_float const * X, gsl_vector_float const * Y, gsl_matrix_float * A) -> int"""
    return _gslwrap.gsl_blas_ssyr2(Uplo, alpha, X, Y, A)

def gsl_blas_dsymv(Uplo, alpha, A, X, beta, Y):
    r"""gsl_blas_dsymv(CBLAS_UPLO_t Uplo, double alpha, gsl_matrix const * A, gsl_vector const * X, double beta, gsl_vector * Y) -> int"""
    return _gslwrap.gsl_blas_dsymv(Uplo, alpha, A, X, beta, Y)

def gsl_blas_dger(alpha, X, Y, A):
    r"""gsl_blas_dger(double alpha, gsl_vector const * X, gsl_vector const * Y, gsl_matrix * A) -> int"""
    return _gslwrap.gsl_blas_dger(alpha, X, Y, A)

def gsl_blas_dsyr(Uplo, alpha, X, A):
    r"""gsl_blas_dsyr(CBLAS_UPLO_t Uplo, double alpha, gsl_vector const * X, gsl_matrix * A) -> int"""
    return _gslwrap.gsl_blas_dsyr(Uplo, alpha, X, A)

def gsl_blas_dsyr2(Uplo, alpha, X, Y, A):
    r"""gsl_blas_dsyr2(CBLAS_UPLO_t Uplo, double alpha, gsl_vector const * X, gsl_vector const * Y, gsl_matrix * A) -> int"""
    return _gslwrap.gsl_blas_dsyr2(Uplo, alpha, X, Y, A)

def gsl_blas_chemv(Uplo, alpha, A, X, beta, Y):
    r"""gsl_blas_chemv(CBLAS_UPLO_t Uplo, gsl_complex_float const alpha, gsl_matrix_complex_float const * A, gsl_vector_complex_float const * X, gsl_complex_float const beta, gsl_vector_complex_float * Y) -> int"""
    return _gslwrap.gsl_blas_chemv(Uplo, alpha, A, X, beta, Y)

def gsl_blas_cgeru(alpha, X, Y, A):
    r"""gsl_blas_cgeru(gsl_complex_float const alpha, gsl_vector_complex_float const * X, gsl_vector_complex_float const * Y, gsl_matrix_complex_float * A) -> int"""
    return _gslwrap.gsl_blas_cgeru(alpha, X, Y, A)

def gsl_blas_cgerc(alpha, X, Y, A):
    r"""gsl_blas_cgerc(gsl_complex_float const alpha, gsl_vector_complex_float const * X, gsl_vector_complex_float const * Y, gsl_matrix_complex_float * A) -> int"""
    return _gslwrap.gsl_blas_cgerc(alpha, X, Y, A)

def gsl_blas_cher(Uplo, alpha, X, A):
    r"""gsl_blas_cher(CBLAS_UPLO_t Uplo, float alpha, gsl_vector_complex_float const * X, gsl_matrix_complex_float * A) -> int"""
    return _gslwrap.gsl_blas_cher(Uplo, alpha, X, A)

def gsl_blas_cher2(Uplo, alpha, X, Y, A):
    r"""gsl_blas_cher2(CBLAS_UPLO_t Uplo, gsl_complex_float const alpha, gsl_vector_complex_float const * X, gsl_vector_complex_float const * Y, gsl_matrix_complex_float * A) -> int"""
    return _gslwrap.gsl_blas_cher2(Uplo, alpha, X, Y, A)

def gsl_blas_zhemv(Uplo, alpha, A, X, beta, Y):
    r"""gsl_blas_zhemv(CBLAS_UPLO_t Uplo, gsl_complex const alpha, gsl_matrix_complex const * A, gsl_vector_complex const * X, gsl_complex const beta, gsl_vector_complex * Y) -> int"""
    return _gslwrap.gsl_blas_zhemv(Uplo, alpha, A, X, beta, Y)

def gsl_blas_zgeru(alpha, X, Y, A):
    r"""gsl_blas_zgeru(gsl_complex const alpha, gsl_vector_complex const * X, gsl_vector_complex const * Y, gsl_matrix_complex * A) -> int"""
    return _gslwrap.gsl_blas_zgeru(alpha, X, Y, A)

def gsl_blas_zgerc(alpha, X, Y, A):
    r"""gsl_blas_zgerc(gsl_complex const alpha, gsl_vector_complex const * X, gsl_vector_complex const * Y, gsl_matrix_complex * A) -> int"""
    return _gslwrap.gsl_blas_zgerc(alpha, X, Y, A)

def gsl_blas_zher(Uplo, alpha, X, A):
    r"""gsl_blas_zher(CBLAS_UPLO_t Uplo, double alpha, gsl_vector_complex const * X, gsl_matrix_complex * A) -> int"""
    return _gslwrap.gsl_blas_zher(Uplo, alpha, X, A)

def gsl_blas_zher2(Uplo, alpha, X, Y, A):
    r"""gsl_blas_zher2(CBLAS_UPLO_t Uplo, gsl_complex const alpha, gsl_vector_complex const * X, gsl_vector_complex const * Y, gsl_matrix_complex * A) -> int"""
    return _gslwrap.gsl_blas_zher2(Uplo, alpha, X, Y, A)

def gsl_blas_sgemm(TransA, TransB, alpha, A, B, beta, C):
    r"""gsl_blas_sgemm(CBLAS_TRANSPOSE_t TransA, CBLAS_TRANSPOSE_t TransB, float alpha, gsl_matrix_float const * A, gsl_matrix_float const * B, float beta, gsl_matrix_float * C) -> int"""
    return _gslwrap.gsl_blas_sgemm(TransA, TransB, alpha, A, B, beta, C)

def gsl_blas_ssymm(Side, Uplo, alpha, A, B, beta, C):
    r"""gsl_blas_ssymm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, float alpha, gsl_matrix_float const * A, gsl_matrix_float const * B, float beta, gsl_matrix_float * C) -> int"""
    return _gslwrap.gsl_blas_ssymm(Side, Uplo, alpha, A, B, beta, C)

def gsl_blas_ssyrk(Uplo, Trans, alpha, A, beta, C):
    r"""gsl_blas_ssyrk(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, float alpha, gsl_matrix_float const * A, float beta, gsl_matrix_float * C) -> int"""
    return _gslwrap.gsl_blas_ssyrk(Uplo, Trans, alpha, A, beta, C)

def gsl_blas_ssyr2k(Uplo, Trans, alpha, A, B, beta, C):
    r"""gsl_blas_ssyr2k(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, float alpha, gsl_matrix_float const * A, gsl_matrix_float const * B, float beta, gsl_matrix_float * C) -> int"""
    return _gslwrap.gsl_blas_ssyr2k(Uplo, Trans, alpha, A, B, beta, C)

def gsl_blas_strmm(Side, Uplo, TransA, Diag, alpha, A, B):
    r"""gsl_blas_strmm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, float alpha, gsl_matrix_float const * A, gsl_matrix_float * B) -> int"""
    return _gslwrap.gsl_blas_strmm(Side, Uplo, TransA, Diag, alpha, A, B)

def gsl_blas_strsm(Side, Uplo, TransA, Diag, alpha, A, B):
    r"""gsl_blas_strsm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, float alpha, gsl_matrix_float const * A, gsl_matrix_float * B) -> int"""
    return _gslwrap.gsl_blas_strsm(Side, Uplo, TransA, Diag, alpha, A, B)

def gsl_blas_dgemm(TransA, TransB, alpha, A, B, beta, C):
    r"""gsl_blas_dgemm(CBLAS_TRANSPOSE_t TransA, CBLAS_TRANSPOSE_t TransB, double alpha, gsl_matrix const * A, gsl_matrix const * B, double beta, gsl_matrix * C) -> int"""
    return _gslwrap.gsl_blas_dgemm(TransA, TransB, alpha, A, B, beta, C)

def gsl_blas_dsymm(Side, Uplo, alpha, A, B, beta, C):
    r"""gsl_blas_dsymm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, double alpha, gsl_matrix const * A, gsl_matrix const * B, double beta, gsl_matrix * C) -> int"""
    return _gslwrap.gsl_blas_dsymm(Side, Uplo, alpha, A, B, beta, C)

def gsl_blas_dsyrk(Uplo, Trans, alpha, A, beta, C):
    r"""gsl_blas_dsyrk(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, double alpha, gsl_matrix const * A, double beta, gsl_matrix * C) -> int"""
    return _gslwrap.gsl_blas_dsyrk(Uplo, Trans, alpha, A, beta, C)

def gsl_blas_dsyr2k(Uplo, Trans, alpha, A, B, beta, C):
    r"""gsl_blas_dsyr2k(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, double alpha, gsl_matrix const * A, gsl_matrix const * B, double beta, gsl_matrix * C) -> int"""
    return _gslwrap.gsl_blas_dsyr2k(Uplo, Trans, alpha, A, B, beta, C)

def gsl_blas_dtrmm(Side, Uplo, TransA, Diag, alpha, A, B):
    r"""gsl_blas_dtrmm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, double alpha, gsl_matrix const * A, gsl_matrix * B) -> int"""
    return _gslwrap.gsl_blas_dtrmm(Side, Uplo, TransA, Diag, alpha, A, B)

def gsl_blas_dtrsm(Side, Uplo, TransA, Diag, alpha, A, B):
    r"""gsl_blas_dtrsm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, double alpha, gsl_matrix const * A, gsl_matrix * B) -> int"""
    return _gslwrap.gsl_blas_dtrsm(Side, Uplo, TransA, Diag, alpha, A, B)

def gsl_blas_cgemm(TransA, TransB, alpha, A, B, beta, C):
    r"""gsl_blas_cgemm(CBLAS_TRANSPOSE_t TransA, CBLAS_TRANSPOSE_t TransB, gsl_complex_float const alpha, gsl_matrix_complex_float const * A, gsl_matrix_complex_float const * B, gsl_complex_float const beta, gsl_matrix_complex_float * C) -> int"""
    return _gslwrap.gsl_blas_cgemm(TransA, TransB, alpha, A, B, beta, C)

def gsl_blas_csymm(Side, Uplo, alpha, A, B, beta, C):
    r"""gsl_blas_csymm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, gsl_complex_float const alpha, gsl_matrix_complex_float const * A, gsl_matrix_complex_float const * B, gsl_complex_float const beta, gsl_matrix_complex_float * C) -> int"""
    return _gslwrap.gsl_blas_csymm(Side, Uplo, alpha, A, B, beta, C)

def gsl_blas_csyrk(Uplo, Trans, alpha, A, beta, C):
    r"""gsl_blas_csyrk(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, gsl_complex_float const alpha, gsl_matrix_complex_float const * A, gsl_complex_float const beta, gsl_matrix_complex_float * C) -> int"""
    return _gslwrap.gsl_blas_csyrk(Uplo, Trans, alpha, A, beta, C)

def gsl_blas_csyr2k(Uplo, Trans, alpha, A, B, beta, C):
    r"""gsl_blas_csyr2k(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, gsl_complex_float const alpha, gsl_matrix_complex_float const * A, gsl_matrix_complex_float const * B, gsl_complex_float const beta, gsl_matrix_complex_float * C) -> int"""
    return _gslwrap.gsl_blas_csyr2k(Uplo, Trans, alpha, A, B, beta, C)

def gsl_blas_ctrmm(Side, Uplo, TransA, Diag, alpha, A, B):
    r"""gsl_blas_ctrmm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_complex_float const alpha, gsl_matrix_complex_float const * A, gsl_matrix_complex_float * B) -> int"""
    return _gslwrap.gsl_blas_ctrmm(Side, Uplo, TransA, Diag, alpha, A, B)

def gsl_blas_ctrsm(Side, Uplo, TransA, Diag, alpha, A, B):
    r"""gsl_blas_ctrsm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_complex_float const alpha, gsl_matrix_complex_float const * A, gsl_matrix_complex_float * B) -> int"""
    return _gslwrap.gsl_blas_ctrsm(Side, Uplo, TransA, Diag, alpha, A, B)

def gsl_blas_zgemm(TransA, TransB, alpha, A, B, beta, C):
    r"""gsl_blas_zgemm(CBLAS_TRANSPOSE_t TransA, CBLAS_TRANSPOSE_t TransB, gsl_complex const alpha, gsl_matrix_complex const * A, gsl_matrix_complex const * B, gsl_complex const beta, gsl_matrix_complex * C) -> int"""
    return _gslwrap.gsl_blas_zgemm(TransA, TransB, alpha, A, B, beta, C)

def gsl_blas_zsymm(Side, Uplo, alpha, A, B, beta, C):
    r"""gsl_blas_zsymm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, gsl_complex const alpha, gsl_matrix_complex const * A, gsl_matrix_complex const * B, gsl_complex const beta, gsl_matrix_complex * C) -> int"""
    return _gslwrap.gsl_blas_zsymm(Side, Uplo, alpha, A, B, beta, C)

def gsl_blas_zsyrk(Uplo, Trans, alpha, A, beta, C):
    r"""gsl_blas_zsyrk(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, gsl_complex const alpha, gsl_matrix_complex const * A, gsl_complex const beta, gsl_matrix_complex * C) -> int"""
    return _gslwrap.gsl_blas_zsyrk(Uplo, Trans, alpha, A, beta, C)

def gsl_blas_zsyr2k(Uplo, Trans, alpha, A, B, beta, C):
    r"""gsl_blas_zsyr2k(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, gsl_complex const alpha, gsl_matrix_complex const * A, gsl_matrix_complex const * B, gsl_complex const beta, gsl_matrix_complex * C) -> int"""
    return _gslwrap.gsl_blas_zsyr2k(Uplo, Trans, alpha, A, B, beta, C)

def gsl_blas_ztrmm(Side, Uplo, TransA, Diag, alpha, A, B):
    r"""gsl_blas_ztrmm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_complex const alpha, gsl_matrix_complex const * A, gsl_matrix_complex * B) -> int"""
    return _gslwrap.gsl_blas_ztrmm(Side, Uplo, TransA, Diag, alpha, A, B)

def gsl_blas_ztrsm(Side, Uplo, TransA, Diag, alpha, A, B):
    r"""gsl_blas_ztrsm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t TransA, CBLAS_DIAG_t Diag, gsl_complex const alpha, gsl_matrix_complex const * A, gsl_matrix_complex * B) -> int"""
    return _gslwrap.gsl_blas_ztrsm(Side, Uplo, TransA, Diag, alpha, A, B)

def gsl_blas_chemm(Side, Uplo, alpha, A, B, beta, C):
    r"""gsl_blas_chemm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, gsl_complex_float const alpha, gsl_matrix_complex_float const * A, gsl_matrix_complex_float const * B, gsl_complex_float const beta, gsl_matrix_complex_float * C) -> int"""
    return _gslwrap.gsl_blas_chemm(Side, Uplo, alpha, A, B, beta, C)

def gsl_blas_cherk(Uplo, Trans, alpha, A, beta, C):
    r"""gsl_blas_cherk(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, float alpha, gsl_matrix_complex_float const * A, float beta, gsl_matrix_complex_float * C) -> int"""
    return _gslwrap.gsl_blas_cherk(Uplo, Trans, alpha, A, beta, C)

def gsl_blas_cher2k(Uplo, Trans, alpha, A, B, beta, C):
    r"""gsl_blas_cher2k(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, gsl_complex_float const alpha, gsl_matrix_complex_float const * A, gsl_matrix_complex_float const * B, float beta, gsl_matrix_complex_float * C) -> int"""
    return _gslwrap.gsl_blas_cher2k(Uplo, Trans, alpha, A, B, beta, C)

def gsl_blas_zhemm(Side, Uplo, alpha, A, B, beta, C):
    r"""gsl_blas_zhemm(CBLAS_SIDE_t Side, CBLAS_UPLO_t Uplo, gsl_complex const alpha, gsl_matrix_complex const * A, gsl_matrix_complex const * B, gsl_complex const beta, gsl_matrix_complex * C) -> int"""
    return _gslwrap.gsl_blas_zhemm(Side, Uplo, alpha, A, B, beta, C)

def gsl_blas_zherk(Uplo, Trans, alpha, A, beta, C):
    r"""gsl_blas_zherk(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, double alpha, gsl_matrix_complex const * A, double beta, gsl_matrix_complex * C) -> int"""
    return _gslwrap.gsl_blas_zherk(Uplo, Trans, alpha, A, beta, C)

def gsl_blas_zher2k(Uplo, Trans, alpha, A, B, beta, C):
    r"""gsl_blas_zher2k(CBLAS_UPLO_t Uplo, CBLAS_TRANSPOSE_t Trans, gsl_complex const alpha, gsl_matrix_complex const * A, gsl_matrix_complex const * B, double beta, gsl_matrix_complex * C) -> int"""
    return _gslwrap.gsl_blas_zher2k(Uplo, Trans, alpha, A, B, beta, C)
class gsl_eigen_symm_workspace(object):
    r"""Proxy of C gsl_eigen_symm_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(gsl_eigen_symm_workspace self, size_t const n) -> gsl_eigen_symm_workspace"""
        _gslwrap.gsl_eigen_symm_workspace_swiginit(self, _gslwrap.new_gsl_eigen_symm_workspace(n))
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_symm_workspace
    size = property(_gslwrap.gsl_eigen_symm_workspace_size_get, doc=r"""size : size_t""")
    d = property(_gslwrap.gsl_eigen_symm_workspace_d_get, doc=r"""d : p.double""")
    sd = property(_gslwrap.gsl_eigen_symm_workspace_sd_get, doc=r"""sd : p.double""")

# Register gsl_eigen_symm_workspace in _gslwrap:
_gslwrap.gsl_eigen_symm_workspace_swigregister(gsl_eigen_symm_workspace)


def gsl_eigen_symm_alloc(n):
    r"""gsl_eigen_symm_alloc(size_t const n) -> gsl_eigen_symm_workspace"""
    return _gslwrap.gsl_eigen_symm_alloc(n)

def gsl_eigen_symm_free(w):
    r"""gsl_eigen_symm_free(gsl_eigen_symm_workspace w)"""
    return _gslwrap.gsl_eigen_symm_free(w)

def gsl_eigen_symm(A, eval, w):
    r"""gsl_eigen_symm(gsl_matrix * A, gsl_vector * eval, gsl_eigen_symm_workspace w) -> int"""
    return _gslwrap.gsl_eigen_symm(A, eval, w)
class gsl_eigen_symmv_workspace(object):
    r"""Proxy of C gsl_eigen_symmv_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(gsl_eigen_symmv_workspace self, size_t const n) -> gsl_eigen_symmv_workspace"""
        _gslwrap.gsl_eigen_symmv_workspace_swiginit(self, _gslwrap.new_gsl_eigen_symmv_workspace(n))
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_symmv_workspace
    size = property(_gslwrap.gsl_eigen_symmv_workspace_size_get, doc=r"""size : size_t""")
    d = property(_gslwrap.gsl_eigen_symmv_workspace_d_get, doc=r"""d : p.double""")
    sd = property(_gslwrap.gsl_eigen_symmv_workspace_sd_get, doc=r"""sd : p.double""")
    gc = property(_gslwrap.gsl_eigen_symmv_workspace_gc_get, doc=r"""gc : p.double""")
    gs = property(_gslwrap.gsl_eigen_symmv_workspace_gs_get, doc=r"""gs : p.double""")

# Register gsl_eigen_symmv_workspace in _gslwrap:
_gslwrap.gsl_eigen_symmv_workspace_swigregister(gsl_eigen_symmv_workspace)


def gsl_eigen_symmv_alloc(n):
    r"""gsl_eigen_symmv_alloc(size_t const n) -> gsl_eigen_symmv_workspace"""
    return _gslwrap.gsl_eigen_symmv_alloc(n)

def gsl_eigen_symmv_free(w):
    r"""gsl_eigen_symmv_free(gsl_eigen_symmv_workspace w)"""
    return _gslwrap.gsl_eigen_symmv_free(w)

def gsl_eigen_symmv(A, eval, evec, w):
    r"""gsl_eigen_symmv(gsl_matrix * A, gsl_vector * eval, gsl_matrix * evec, gsl_eigen_symmv_workspace w) -> int"""
    return _gslwrap.gsl_eigen_symmv(A, eval, evec, w)
class gsl_eigen_herm_workspace(object):
    r"""Proxy of C gsl_eigen_herm_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(gsl_eigen_herm_workspace self, size_t const n) -> gsl_eigen_herm_workspace"""
        _gslwrap.gsl_eigen_herm_workspace_swiginit(self, _gslwrap.new_gsl_eigen_herm_workspace(n))
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_herm_workspace
    size = property(_gslwrap.gsl_eigen_herm_workspace_size_get, doc=r"""size : size_t""")
    d = property(_gslwrap.gsl_eigen_herm_workspace_d_get, doc=r"""d : p.double""")
    sd = property(_gslwrap.gsl_eigen_herm_workspace_sd_get, doc=r"""sd : p.double""")
    tau = property(_gslwrap.gsl_eigen_herm_workspace_tau_get, doc=r"""tau : p.double""")

# Register gsl_eigen_herm_workspace in _gslwrap:
_gslwrap.gsl_eigen_herm_workspace_swigregister(gsl_eigen_herm_workspace)


def gsl_eigen_herm_alloc(n):
    r"""gsl_eigen_herm_alloc(size_t const n) -> gsl_eigen_herm_workspace"""
    return _gslwrap.gsl_eigen_herm_alloc(n)

def gsl_eigen_herm_free(w):
    r"""gsl_eigen_herm_free(gsl_eigen_herm_workspace w)"""
    return _gslwrap.gsl_eigen_herm_free(w)

def gsl_eigen_herm(A, eval, w):
    r"""gsl_eigen_herm(gsl_matrix_complex * A, gsl_vector * eval, gsl_eigen_herm_workspace w) -> int"""
    return _gslwrap.gsl_eigen_herm(A, eval, w)
class gsl_eigen_hermv_workspace(object):
    r"""Proxy of C gsl_eigen_hermv_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(gsl_eigen_hermv_workspace self, size_t const n) -> gsl_eigen_hermv_workspace"""
        _gslwrap.gsl_eigen_hermv_workspace_swiginit(self, _gslwrap.new_gsl_eigen_hermv_workspace(n))
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_hermv_workspace
    size = property(_gslwrap.gsl_eigen_hermv_workspace_size_get, doc=r"""size : size_t""")
    d = property(_gslwrap.gsl_eigen_hermv_workspace_d_get, doc=r"""d : p.double""")
    sd = property(_gslwrap.gsl_eigen_hermv_workspace_sd_get, doc=r"""sd : p.double""")
    tau = property(_gslwrap.gsl_eigen_hermv_workspace_tau_get, doc=r"""tau : p.double""")
    gc = property(_gslwrap.gsl_eigen_hermv_workspace_gc_get, doc=r"""gc : p.double""")
    gs = property(_gslwrap.gsl_eigen_hermv_workspace_gs_get, doc=r"""gs : p.double""")

# Register gsl_eigen_hermv_workspace in _gslwrap:
_gslwrap.gsl_eigen_hermv_workspace_swigregister(gsl_eigen_hermv_workspace)


def gsl_eigen_hermv_alloc(n):
    r"""gsl_eigen_hermv_alloc(size_t const n) -> gsl_eigen_hermv_workspace"""
    return _gslwrap.gsl_eigen_hermv_alloc(n)

def gsl_eigen_hermv_free(w):
    r"""gsl_eigen_hermv_free(gsl_eigen_hermv_workspace w)"""
    return _gslwrap.gsl_eigen_hermv_free(w)

def gsl_eigen_hermv(A, eval, evec, w):
    r"""gsl_eigen_hermv(gsl_matrix_complex * A, gsl_vector * eval, gsl_matrix_complex * evec, gsl_eigen_hermv_workspace w) -> int"""
    return _gslwrap.gsl_eigen_hermv(A, eval, evec, w)
class gsl_eigen_francis_workspace(object):
    r"""Proxy of C gsl_eigen_francis_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(gsl_eigen_francis_workspace self) -> gsl_eigen_francis_workspace"""
        _gslwrap.gsl_eigen_francis_workspace_swiginit(self, _gslwrap.new_gsl_eigen_francis_workspace())
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_francis_workspace
    size = property(_gslwrap.gsl_eigen_francis_workspace_size_get, doc=r"""size : size_t""")
    max_iterations = property(_gslwrap.gsl_eigen_francis_workspace_max_iterations_get, doc=r"""max_iterations : size_t""")
    n_iter = property(_gslwrap.gsl_eigen_francis_workspace_n_iter_get, doc=r"""n_iter : size_t""")
    n_evals = property(_gslwrap.gsl_eigen_francis_workspace_n_evals_get, doc=r"""n_evals : size_t""")
    compute_t = property(_gslwrap.gsl_eigen_francis_workspace_compute_t_get, doc=r"""compute_t : int""")
    H = property(_gslwrap.gsl_eigen_francis_workspace_H_get, doc=r"""H : p.gsl_matrix""")
    Z = property(_gslwrap.gsl_eigen_francis_workspace_Z_get, doc=r"""Z : p.gsl_matrix""")

# Register gsl_eigen_francis_workspace in _gslwrap:
_gslwrap.gsl_eigen_francis_workspace_swigregister(gsl_eigen_francis_workspace)


def gsl_eigen_francis_alloc():
    r"""gsl_eigen_francis_alloc() -> gsl_eigen_francis_workspace"""
    return _gslwrap.gsl_eigen_francis_alloc()

def gsl_eigen_francis_free(w):
    r"""gsl_eigen_francis_free(gsl_eigen_francis_workspace w)"""
    return _gslwrap.gsl_eigen_francis_free(w)

def gsl_eigen_francis_T(compute_t, w):
    r"""gsl_eigen_francis_T(int const compute_t, gsl_eigen_francis_workspace w)"""
    return _gslwrap.gsl_eigen_francis_T(compute_t, w)

def gsl_eigen_francis(H, eval, w):
    r"""gsl_eigen_francis(gsl_matrix * H, gsl_vector_complex * eval, gsl_eigen_francis_workspace w) -> int"""
    return _gslwrap.gsl_eigen_francis(H, eval, w)

def gsl_eigen_francis_Z(H, eval, Z, w):
    r"""gsl_eigen_francis_Z(gsl_matrix * H, gsl_vector_complex * eval, gsl_matrix * Z, gsl_eigen_francis_workspace w) -> int"""
    return _gslwrap.gsl_eigen_francis_Z(H, eval, Z, w)
class gsl_eigen_nonsymm_workspace(object):
    r"""Proxy of C gsl_eigen_nonsymm_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(gsl_eigen_nonsymm_workspace self, size_t const n) -> gsl_eigen_nonsymm_workspace"""
        _gslwrap.gsl_eigen_nonsymm_workspace_swiginit(self, _gslwrap.new_gsl_eigen_nonsymm_workspace(n))
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_nonsymm_workspace

    def params(self, compute_t, balance):
        r"""params(gsl_eigen_nonsymm_workspace self, int const compute_t, int const balance) -> gsl_error_flag_drop"""
        return _gslwrap.gsl_eigen_nonsymm_workspace_params(self, compute_t, balance)
    size = property(_gslwrap.gsl_eigen_nonsymm_workspace_size_get, doc=r"""size : size_t""")
    diag = property(_gslwrap.gsl_eigen_nonsymm_workspace_diag_get, doc=r"""diag : p.gsl_vector""")
    tau = property(_gslwrap.gsl_eigen_nonsymm_workspace_tau_get, doc=r"""tau : p.gsl_vector""")
    Z = property(_gslwrap.gsl_eigen_nonsymm_workspace_Z_get, doc=r"""Z : p.gsl_matrix""")
    do_balance = property(_gslwrap.gsl_eigen_nonsymm_workspace_do_balance_get, doc=r"""do_balance : int""")
    n_evals = property(_gslwrap.gsl_eigen_nonsymm_workspace_n_evals_get, doc=r"""n_evals : size_t""")
    francis_workspace_p = property(_gslwrap.gsl_eigen_nonsymm_workspace_francis_workspace_p_get, doc=r"""francis_workspace_p : p.gsl_eigen_francis_workspace""")

# Register gsl_eigen_nonsymm_workspace in _gslwrap:
_gslwrap.gsl_eigen_nonsymm_workspace_swigregister(gsl_eigen_nonsymm_workspace)


def gsl_eigen_nonsymm_alloc(n):
    r"""gsl_eigen_nonsymm_alloc(size_t const n) -> gsl_eigen_nonsymm_workspace"""
    return _gslwrap.gsl_eigen_nonsymm_alloc(n)

def gsl_eigen_nonsymm_free(w):
    r"""gsl_eigen_nonsymm_free(gsl_eigen_nonsymm_workspace w)"""
    return _gslwrap.gsl_eigen_nonsymm_free(w)

def gsl_eigen_nonsymm_params(compute_t, balance, w):
    r"""gsl_eigen_nonsymm_params(int const compute_t, int const balance, gsl_eigen_nonsymm_workspace w)"""
    return _gslwrap.gsl_eigen_nonsymm_params(compute_t, balance, w)

def gsl_eigen_nonsymm(A, eval, w):
    r"""gsl_eigen_nonsymm(gsl_matrix * A, gsl_vector_complex * eval, gsl_eigen_nonsymm_workspace w) -> int"""
    return _gslwrap.gsl_eigen_nonsymm(A, eval, w)

def gsl_eigen_nonsymm_Z(A, eval, Z, w):
    r"""gsl_eigen_nonsymm_Z(gsl_matrix * A, gsl_vector_complex * eval, gsl_matrix * Z, gsl_eigen_nonsymm_workspace w) -> int"""
    return _gslwrap.gsl_eigen_nonsymm_Z(A, eval, Z, w)
class gsl_eigen_nonsymmv_workspace(object):
    r"""Proxy of C gsl_eigen_nonsymmv_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    size = property(_gslwrap.gsl_eigen_nonsymmv_workspace_size_get, doc=r"""size : size_t""")
    work = property(_gslwrap.gsl_eigen_nonsymmv_workspace_work_get, doc=r"""work : p.gsl_vector""")
    work2 = property(_gslwrap.gsl_eigen_nonsymmv_workspace_work2_get, doc=r"""work2 : p.gsl_vector""")
    work3 = property(_gslwrap.gsl_eigen_nonsymmv_workspace_work3_get, doc=r"""work3 : p.gsl_vector""")
    Z = property(_gslwrap.gsl_eigen_nonsymmv_workspace_Z_get, doc=r"""Z : p.gsl_matrix""")
    nonsymm_workspace_p = property(_gslwrap.gsl_eigen_nonsymmv_workspace_nonsymm_workspace_p_get, doc=r"""nonsymm_workspace_p : p.gsl_eigen_nonsymm_workspace""")

    def __init__(self):
        r"""__init__(gsl_eigen_nonsymmv_workspace self) -> gsl_eigen_nonsymmv_workspace"""
        _gslwrap.gsl_eigen_nonsymmv_workspace_swiginit(self, _gslwrap.new_gsl_eigen_nonsymmv_workspace())
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_nonsymmv_workspace

# Register gsl_eigen_nonsymmv_workspace in _gslwrap:
_gslwrap.gsl_eigen_nonsymmv_workspace_swigregister(gsl_eigen_nonsymmv_workspace)


def gsl_eigen_nonsymmv_alloc(n):
    r"""gsl_eigen_nonsymmv_alloc(size_t const n) -> gsl_eigen_nonsymmv_workspace"""
    return _gslwrap.gsl_eigen_nonsymmv_alloc(n)

def gsl_eigen_nonsymmv_free(w):
    r"""gsl_eigen_nonsymmv_free(gsl_eigen_nonsymmv_workspace w)"""
    return _gslwrap.gsl_eigen_nonsymmv_free(w)

def gsl_eigen_nonsymmv(A, eval, evec, w):
    r"""gsl_eigen_nonsymmv(gsl_matrix * A, gsl_vector_complex * eval, gsl_matrix_complex * evec, gsl_eigen_nonsymmv_workspace w) -> int"""
    return _gslwrap.gsl_eigen_nonsymmv(A, eval, evec, w)

def gsl_eigen_nonsymmv_Z(A, eval, evec, Z, w):
    r"""gsl_eigen_nonsymmv_Z(gsl_matrix * A, gsl_vector_complex * eval, gsl_matrix_complex * evec, gsl_matrix * Z, gsl_eigen_nonsymmv_workspace w) -> int"""
    return _gslwrap.gsl_eigen_nonsymmv_Z(A, eval, evec, Z, w)
class gsl_eigen_gensymm_workspace(object):
    r"""Proxy of C gsl_eigen_gensymm_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    size = property(_gslwrap.gsl_eigen_gensymm_workspace_size_get, doc=r"""size : size_t""")
    symm_workspace_p = property(_gslwrap.gsl_eigen_gensymm_workspace_symm_workspace_p_get, doc=r"""symm_workspace_p : p.gsl_eigen_symm_workspace""")

    def __init__(self):
        r"""__init__(gsl_eigen_gensymm_workspace self) -> gsl_eigen_gensymm_workspace"""
        _gslwrap.gsl_eigen_gensymm_workspace_swiginit(self, _gslwrap.new_gsl_eigen_gensymm_workspace())
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_gensymm_workspace

# Register gsl_eigen_gensymm_workspace in _gslwrap:
_gslwrap.gsl_eigen_gensymm_workspace_swigregister(gsl_eigen_gensymm_workspace)


def gsl_eigen_gensymm_alloc(n):
    r"""gsl_eigen_gensymm_alloc(size_t const n) -> gsl_eigen_gensymm_workspace"""
    return _gslwrap.gsl_eigen_gensymm_alloc(n)

def gsl_eigen_gensymm_free(w):
    r"""gsl_eigen_gensymm_free(gsl_eigen_gensymm_workspace w)"""
    return _gslwrap.gsl_eigen_gensymm_free(w)

def gsl_eigen_gensymm(A, B, eval, w):
    r"""gsl_eigen_gensymm(gsl_matrix * A, gsl_matrix * B, gsl_vector * eval, gsl_eigen_gensymm_workspace w) -> int"""
    return _gslwrap.gsl_eigen_gensymm(A, B, eval, w)

def gsl_eigen_gensymm_standardize(A, B):
    r"""gsl_eigen_gensymm_standardize(gsl_matrix * A, gsl_matrix const * B) -> int"""
    return _gslwrap.gsl_eigen_gensymm_standardize(A, B)
class gsl_eigen_gensymmv_workspace(object):
    r"""Proxy of C gsl_eigen_gensymmv_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    size = property(_gslwrap.gsl_eigen_gensymmv_workspace_size_get, doc=r"""size : size_t""")
    symmv_workspace_p = property(_gslwrap.gsl_eigen_gensymmv_workspace_symmv_workspace_p_get, doc=r"""symmv_workspace_p : p.gsl_eigen_symmv_workspace""")

    def __init__(self):
        r"""__init__(gsl_eigen_gensymmv_workspace self) -> gsl_eigen_gensymmv_workspace"""
        _gslwrap.gsl_eigen_gensymmv_workspace_swiginit(self, _gslwrap.new_gsl_eigen_gensymmv_workspace())
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_gensymmv_workspace

# Register gsl_eigen_gensymmv_workspace in _gslwrap:
_gslwrap.gsl_eigen_gensymmv_workspace_swigregister(gsl_eigen_gensymmv_workspace)


def gsl_eigen_gensymmv_alloc(n):
    r"""gsl_eigen_gensymmv_alloc(size_t const n) -> gsl_eigen_gensymmv_workspace"""
    return _gslwrap.gsl_eigen_gensymmv_alloc(n)

def gsl_eigen_gensymmv_free(w):
    r"""gsl_eigen_gensymmv_free(gsl_eigen_gensymmv_workspace w)"""
    return _gslwrap.gsl_eigen_gensymmv_free(w)

def gsl_eigen_gensymmv(A, B, eval, evec, w):
    r"""gsl_eigen_gensymmv(gsl_matrix * A, gsl_matrix * B, gsl_vector * eval, gsl_matrix * evec, gsl_eigen_gensymmv_workspace w) -> int"""
    return _gslwrap.gsl_eigen_gensymmv(A, B, eval, evec, w)
class gsl_eigen_genherm_workspace(object):
    r"""Proxy of C gsl_eigen_genherm_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(gsl_eigen_genherm_workspace self, size_t const n) -> gsl_eigen_genherm_workspace"""
        _gslwrap.gsl_eigen_genherm_workspace_swiginit(self, _gslwrap.new_gsl_eigen_genherm_workspace(n))
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_genherm_workspace
    size = property(_gslwrap.gsl_eigen_genherm_workspace_size_get, doc=r"""size : size_t""")
    herm_workspace_p = property(_gslwrap.gsl_eigen_genherm_workspace_herm_workspace_p_get, doc=r"""herm_workspace_p : p.gsl_eigen_herm_workspace""")

# Register gsl_eigen_genherm_workspace in _gslwrap:
_gslwrap.gsl_eigen_genherm_workspace_swigregister(gsl_eigen_genherm_workspace)


def gsl_eigen_genherm_alloc(n):
    r"""gsl_eigen_genherm_alloc(size_t const n) -> gsl_eigen_genherm_workspace"""
    return _gslwrap.gsl_eigen_genherm_alloc(n)

def gsl_eigen_genherm_free(w):
    r"""gsl_eigen_genherm_free(gsl_eigen_genherm_workspace w)"""
    return _gslwrap.gsl_eigen_genherm_free(w)

def gsl_eigen_genherm(A, B, eval, w):
    r"""gsl_eigen_genherm(gsl_matrix_complex * A, gsl_matrix_complex * B, gsl_vector * eval, gsl_eigen_genherm_workspace w) -> int"""
    return _gslwrap.gsl_eigen_genherm(A, B, eval, w)

def gsl_eigen_genherm_standardize(A, B):
    r"""gsl_eigen_genherm_standardize(gsl_matrix_complex * A, gsl_matrix_complex const * B) -> int"""
    return _gslwrap.gsl_eigen_genherm_standardize(A, B)
class gsl_eigen_genhermv_workspace(object):
    r"""Proxy of C gsl_eigen_genhermv_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(gsl_eigen_genhermv_workspace self, size_t const n) -> gsl_eigen_genhermv_workspace"""
        _gslwrap.gsl_eigen_genhermv_workspace_swiginit(self, _gslwrap.new_gsl_eigen_genhermv_workspace(n))
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_genhermv_workspace
    size = property(_gslwrap.gsl_eigen_genhermv_workspace_size_get, doc=r"""size : size_t""")
    hermv_workspace_p = property(_gslwrap.gsl_eigen_genhermv_workspace_hermv_workspace_p_get, doc=r"""hermv_workspace_p : p.gsl_eigen_hermv_workspace""")

# Register gsl_eigen_genhermv_workspace in _gslwrap:
_gslwrap.gsl_eigen_genhermv_workspace_swigregister(gsl_eigen_genhermv_workspace)


def gsl_eigen_genhermv_alloc(n):
    r"""gsl_eigen_genhermv_alloc(size_t const n) -> gsl_eigen_genhermv_workspace"""
    return _gslwrap.gsl_eigen_genhermv_alloc(n)

def gsl_eigen_genhermv_free(w):
    r"""gsl_eigen_genhermv_free(gsl_eigen_genhermv_workspace w)"""
    return _gslwrap.gsl_eigen_genhermv_free(w)

def gsl_eigen_genhermv(A, B, eval, evec, w):
    r"""gsl_eigen_genhermv(gsl_matrix_complex * A, gsl_matrix_complex * B, gsl_vector * eval, gsl_matrix_complex * evec, gsl_eigen_genhermv_workspace w) -> int"""
    return _gslwrap.gsl_eigen_genhermv(A, B, eval, evec, w)
class gsl_eigen_gen_workspace(object):
    r"""Proxy of C gsl_eigen_gen_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(gsl_eigen_gen_workspace self, size_t const n) -> gsl_eigen_gen_workspace"""
        _gslwrap.gsl_eigen_gen_workspace_swiginit(self, _gslwrap.new_gsl_eigen_gen_workspace(n))
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_gen_workspace
    size = property(_gslwrap.gsl_eigen_gen_workspace_size_get, doc=r"""size : size_t""")
    work = property(_gslwrap.gsl_eigen_gen_workspace_work_get, doc=r"""work : p.gsl_vector""")
    n_evals = property(_gslwrap.gsl_eigen_gen_workspace_n_evals_get, doc=r"""n_evals : size_t""")
    max_iterations = property(_gslwrap.gsl_eigen_gen_workspace_max_iterations_get, doc=r"""max_iterations : size_t""")
    n_iter = property(_gslwrap.gsl_eigen_gen_workspace_n_iter_get, doc=r"""n_iter : size_t""")
    eshift = property(_gslwrap.gsl_eigen_gen_workspace_eshift_get, doc=r"""eshift : double""")
    needtop = property(_gslwrap.gsl_eigen_gen_workspace_needtop_get, doc=r"""needtop : int""")
    atol = property(_gslwrap.gsl_eigen_gen_workspace_atol_get, doc=r"""atol : double""")
    btol = property(_gslwrap.gsl_eigen_gen_workspace_btol_get, doc=r"""btol : double""")
    ascale = property(_gslwrap.gsl_eigen_gen_workspace_ascale_get, doc=r"""ascale : double""")
    bscale = property(_gslwrap.gsl_eigen_gen_workspace_bscale_get, doc=r"""bscale : double""")
    H = property(_gslwrap.gsl_eigen_gen_workspace_H_get, doc=r"""H : p.gsl_matrix""")
    R = property(_gslwrap.gsl_eigen_gen_workspace_R_get, doc=r"""R : p.gsl_matrix""")
    compute_s = property(_gslwrap.gsl_eigen_gen_workspace_compute_s_get, doc=r"""compute_s : int""")
    compute_t = property(_gslwrap.gsl_eigen_gen_workspace_compute_t_get, doc=r"""compute_t : int""")
    Q = property(_gslwrap.gsl_eigen_gen_workspace_Q_get, doc=r"""Q : p.gsl_matrix""")
    Z = property(_gslwrap.gsl_eigen_gen_workspace_Z_get, doc=r"""Z : p.gsl_matrix""")

# Register gsl_eigen_gen_workspace in _gslwrap:
_gslwrap.gsl_eigen_gen_workspace_swigregister(gsl_eigen_gen_workspace)


def gsl_eigen_gen_alloc(n):
    r"""gsl_eigen_gen_alloc(size_t const n) -> gsl_eigen_gen_workspace"""
    return _gslwrap.gsl_eigen_gen_alloc(n)

def gsl_eigen_gen_free(w):
    r"""gsl_eigen_gen_free(gsl_eigen_gen_workspace w)"""
    return _gslwrap.gsl_eigen_gen_free(w)

def gsl_eigen_gen_params(compute_s, compute_t, balance, w):
    r"""gsl_eigen_gen_params(int const compute_s, int const compute_t, int const balance, gsl_eigen_gen_workspace w)"""
    return _gslwrap.gsl_eigen_gen_params(compute_s, compute_t, balance, w)

def gsl_eigen_gen(A, B, alpha, beta, w):
    r"""gsl_eigen_gen(gsl_matrix * A, gsl_matrix * B, gsl_vector_complex * alpha, gsl_vector * beta, gsl_eigen_gen_workspace w) -> int"""
    return _gslwrap.gsl_eigen_gen(A, B, alpha, beta, w)

def gsl_eigen_gen_QZ(A, B, alpha, beta, Q, Z, w):
    r"""gsl_eigen_gen_QZ(gsl_matrix * A, gsl_matrix * B, gsl_vector_complex * alpha, gsl_vector * beta, gsl_matrix * Q, gsl_matrix * Z, gsl_eigen_gen_workspace w) -> int"""
    return _gslwrap.gsl_eigen_gen_QZ(A, B, alpha, beta, Q, Z, w)
class gsl_eigen_genv_workspace(object):
    r"""Proxy of C gsl_eigen_genv_workspace struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        r"""__init__(gsl_eigen_genv_workspace self, size_t const n) -> gsl_eigen_genv_workspace"""
        _gslwrap.gsl_eigen_genv_workspace_swiginit(self, _gslwrap.new_gsl_eigen_genv_workspace(n))
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_genv_workspace
    size = property(_gslwrap.gsl_eigen_genv_workspace_size_get, doc=r"""size : size_t""")
    work1 = property(_gslwrap.gsl_eigen_genv_workspace_work1_get, doc=r"""work1 : p.gsl_vector""")
    work2 = property(_gslwrap.gsl_eigen_genv_workspace_work2_get, doc=r"""work2 : p.gsl_vector""")
    work3 = property(_gslwrap.gsl_eigen_genv_workspace_work3_get, doc=r"""work3 : p.gsl_vector""")
    work4 = property(_gslwrap.gsl_eigen_genv_workspace_work4_get, doc=r"""work4 : p.gsl_vector""")
    work5 = property(_gslwrap.gsl_eigen_genv_workspace_work5_get, doc=r"""work5 : p.gsl_vector""")
    work6 = property(_gslwrap.gsl_eigen_genv_workspace_work6_get, doc=r"""work6 : p.gsl_vector""")
    Q = property(_gslwrap.gsl_eigen_genv_workspace_Q_get, doc=r"""Q : p.gsl_matrix""")
    Z = property(_gslwrap.gsl_eigen_genv_workspace_Z_get, doc=r"""Z : p.gsl_matrix""")
    gen_workspace_p = property(_gslwrap.gsl_eigen_genv_workspace_gen_workspace_p_get, doc=r"""gen_workspace_p : p.gsl_eigen_gen_workspace""")

# Register gsl_eigen_genv_workspace in _gslwrap:
_gslwrap.gsl_eigen_genv_workspace_swigregister(gsl_eigen_genv_workspace)


def gsl_eigen_genv_alloc(n):
    r"""gsl_eigen_genv_alloc(size_t const n) -> gsl_eigen_genv_workspace"""
    return _gslwrap.gsl_eigen_genv_alloc(n)

def gsl_eigen_genv_free(w):
    r"""gsl_eigen_genv_free(gsl_eigen_genv_workspace w)"""
    return _gslwrap.gsl_eigen_genv_free(w)

def gsl_eigen_genv(A, B, alpha, beta, evec, w):
    r"""gsl_eigen_genv(gsl_matrix * A, gsl_matrix * B, gsl_vector_complex * alpha, gsl_vector * beta, gsl_matrix_complex * evec, gsl_eigen_genv_workspace w) -> int"""
    return _gslwrap.gsl_eigen_genv(A, B, alpha, beta, evec, w)

def gsl_eigen_genv_QZ(A, B, alpha, beta, evec, Q, Z, w):
    r"""gsl_eigen_genv_QZ(gsl_matrix * A, gsl_matrix * B, gsl_vector_complex * alpha, gsl_vector * beta, gsl_matrix_complex * evec, gsl_matrix * Q, gsl_matrix * Z, gsl_eigen_genv_workspace w) -> int"""
    return _gslwrap.gsl_eigen_genv_QZ(A, B, alpha, beta, evec, Q, Z, w)
GSL_EIGEN_SORT_VAL_ASC = _gslwrap.GSL_EIGEN_SORT_VAL_ASC

GSL_EIGEN_SORT_VAL_DESC = _gslwrap.GSL_EIGEN_SORT_VAL_DESC

GSL_EIGEN_SORT_ABS_ASC = _gslwrap.GSL_EIGEN_SORT_ABS_ASC

GSL_EIGEN_SORT_ABS_DESC = _gslwrap.GSL_EIGEN_SORT_ABS_DESC


def gsl_eigen_symmv_sort(eval, evec, sort_type):
    r"""gsl_eigen_symmv_sort(gsl_vector * eval, gsl_matrix * evec, gsl_eigen_sort_t sort_type) -> int"""
    return _gslwrap.gsl_eigen_symmv_sort(eval, evec, sort_type)

def gsl_eigen_hermv_sort(eval, evec, sort_type):
    r"""gsl_eigen_hermv_sort(gsl_vector * eval, gsl_matrix_complex * evec, gsl_eigen_sort_t sort_type) -> int"""
    return _gslwrap.gsl_eigen_hermv_sort(eval, evec, sort_type)

def gsl_eigen_nonsymmv_sort(eval, evec, sort_type):
    r"""gsl_eigen_nonsymmv_sort(gsl_vector_complex * eval, gsl_matrix_complex * evec, gsl_eigen_sort_t sort_type) -> int"""
    return _gslwrap.gsl_eigen_nonsymmv_sort(eval, evec, sort_type)

def gsl_eigen_gensymmv_sort(eval, evec, sort_type):
    r"""gsl_eigen_gensymmv_sort(gsl_vector * eval, gsl_matrix * evec, gsl_eigen_sort_t sort_type) -> int"""
    return _gslwrap.gsl_eigen_gensymmv_sort(eval, evec, sort_type)

def gsl_eigen_genhermv_sort(eval, evec, sort_type):
    r"""gsl_eigen_genhermv_sort(gsl_vector * eval, gsl_matrix_complex * evec, gsl_eigen_sort_t sort_type) -> int"""
    return _gslwrap.gsl_eigen_genhermv_sort(eval, evec, sort_type)

def gsl_eigen_genv_sort(alpha, beta, evec, sort_type):
    r"""gsl_eigen_genv_sort(gsl_vector_complex * alpha, gsl_vector * beta, gsl_matrix_complex * evec, gsl_eigen_sort_t sort_type) -> int"""
    return _gslwrap.gsl_eigen_genv_sort(alpha, beta, evec, sort_type)

def gsl_schur_gen_eigvals(A, B, wr1, wr2, wi, scale1, scale2):
    r"""gsl_schur_gen_eigvals(gsl_matrix const * A, gsl_matrix const * B, double * wr1, double * wr2, double * wi, double * scale1, double * scale2) -> int"""
    return _gslwrap.gsl_schur_gen_eigvals(A, B, wr1, wr2, wi, scale1, scale2)

def gsl_schur_solve_equation(ca, A, z, d1, d2, b, x, s, xnorm, smin):
    r"""gsl_schur_solve_equation(double ca, gsl_matrix const * A, double z, double d1, double d2, gsl_vector const * b, gsl_vector * x, double * s, double * xnorm, double smin) -> int"""
    return _gslwrap.gsl_schur_solve_equation(ca, A, z, d1, d2, b, x, s, xnorm, smin)

def gsl_schur_solve_equation_z(ca, A, z, d1, d2, b, x, s, xnorm, smin):
    r"""gsl_schur_solve_equation_z(double ca, gsl_matrix const * A, gsl_complex * z, double d1, double d2, gsl_vector_complex const * b, gsl_vector_complex * x, double * s, double * xnorm, double smin) -> int"""
    return _gslwrap.gsl_schur_solve_equation_z(ca, A, z, d1, d2, b, x, s, xnorm, smin)

def gsl_eigen_jacobi(matrix, eval, evec, max_rot, nrot):
    r"""gsl_eigen_jacobi(gsl_matrix * matrix, gsl_vector * eval, gsl_matrix * evec, unsigned int max_rot, unsigned int * nrot) -> int"""
    return _gslwrap.gsl_eigen_jacobi(matrix, eval, evec, max_rot, nrot)

def gsl_eigen_invert_jacobi(matrix, ainv, max_rot):
    r"""gsl_eigen_invert_jacobi(gsl_matrix const * matrix, gsl_matrix * ainv, unsigned int max_rot) -> int"""
    return _gslwrap.gsl_eigen_invert_jacobi(matrix, ainv, max_rot)
class gsl_interp_accel(object):
    r"""Proxy of C gsl_interp_accel struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(gsl_interp_accel self) -> gsl_interp_accel"""
        _gslwrap.gsl_interp_accel_swiginit(self, _gslwrap.new_gsl_interp_accel())
    __swig_destroy__ = _gslwrap.delete_gsl_interp_accel

    def reset(self):
        r"""reset(gsl_interp_accel self) -> gsl_error_flag_drop"""
        return _gslwrap.gsl_interp_accel_reset(self)

    def find(self, x_array, x):
        r"""find(gsl_interp_accel self, double const [] x_array, double x) -> size_t"""
        return _gslwrap.gsl_interp_accel_find(self, x_array, x)

    def tocobject(self):
        r"""tocobject(gsl_interp_accel self) -> PyObject *"""
        return _gslwrap.gsl_interp_accel_tocobject(self)

# Register gsl_interp_accel in _gslwrap:
_gslwrap.gsl_interp_accel_swigregister(gsl_interp_accel)

class pygsl_spline(object):
    r"""Proxy of C pygsl_spline struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, T, n):
        r"""__init__(pygsl_spline self, gsl_interp_type const * T, size_t n) -> pygsl_spline"""
        _gslwrap.pygsl_spline_swiginit(self, _gslwrap.new_pygsl_spline(T, n))
    __swig_destroy__ = _gslwrap.delete_pygsl_spline

    def accel_reset(self):
        r"""accel_reset(pygsl_spline self) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_spline_accel_reset(self)

    def accel_find(self, x):
        r"""accel_find(pygsl_spline self, double x) -> size_t"""
        return _gslwrap.pygsl_spline_accel_find(self, x)

    def tocobject(self):
        r"""tocobject(pygsl_spline self) -> PyObject *"""
        return _gslwrap.pygsl_spline_tocobject(self)

    def init(self, xa):
        r"""init(pygsl_spline self, double const [] xa) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_spline_init(self, xa)

    def eval(self, IN):
        r"""eval(pygsl_spline self, double IN) -> double"""
        return _gslwrap.pygsl_spline_eval(self, IN)

    def eval_deriv_e(self, IN):
        r"""eval_deriv_e(pygsl_spline self, double IN) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_spline_eval_deriv_e(self, IN)

    def eval_deriv(self, IN):
        r"""eval_deriv(pygsl_spline self, double IN) -> double"""
        return _gslwrap.pygsl_spline_eval_deriv(self, IN)

    def eval_deriv2_e(self, IN):
        r"""eval_deriv2_e(pygsl_spline self, double IN) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_spline_eval_deriv2_e(self, IN)

    def eval_deriv2(self, IN):
        r"""eval_deriv2(pygsl_spline self, double IN) -> double"""
        return _gslwrap.pygsl_spline_eval_deriv2(self, IN)

    def eval_integ(self, a, b):
        r"""eval_integ(pygsl_spline self, double a, double b) -> double"""
        return _gslwrap.pygsl_spline_eval_integ(self, a, b)

    def eval_integ_e(self, a, b):
        r"""eval_integ_e(pygsl_spline self, double a, double b) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_spline_eval_integ_e(self, a, b)

    def eval_e(self, IN):
        r"""eval_e(pygsl_spline self, double IN) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_spline_eval_e(self, IN)

    def eval_vector(self, IN):
        r"""eval_vector(pygsl_spline self, gsl_vector const * IN) -> PyObject *"""
        return _gslwrap.pygsl_spline_eval_vector(self, IN)

    def eval_e_vector(self, IN):
        r"""eval_e_vector(pygsl_spline self, gsl_vector const * IN) -> PyObject *"""
        return _gslwrap.pygsl_spline_eval_e_vector(self, IN)

    def eval_deriv_vector(self, IN):
        r"""eval_deriv_vector(pygsl_spline self, gsl_vector const * IN) -> PyObject *"""
        return _gslwrap.pygsl_spline_eval_deriv_vector(self, IN)

    def eval_deriv2_vector(self, IN):
        r"""eval_deriv2_vector(pygsl_spline self, gsl_vector const * IN) -> PyObject *"""
        return _gslwrap.pygsl_spline_eval_deriv2_vector(self, IN)

    def eval_deriv_e_vector(self, IN):
        r"""eval_deriv_e_vector(pygsl_spline self, gsl_vector const * IN) -> PyObject *"""
        return _gslwrap.pygsl_spline_eval_deriv_e_vector(self, IN)

    def eval_deriv2_e_vector(self, IN):
        r"""eval_deriv2_e_vector(pygsl_spline self, gsl_vector const * IN) -> PyObject *"""
        return _gslwrap.pygsl_spline_eval_deriv2_e_vector(self, IN)

    def eval_integ_vector(self, IN, IN2):
        r"""eval_integ_vector(pygsl_spline self, gsl_vector const * IN, gsl_vector const * IN2) -> PyObject *"""
        return _gslwrap.pygsl_spline_eval_integ_vector(self, IN, IN2)

    def eval_integ_e_vector(self, IN, IN2):
        r"""eval_integ_e_vector(pygsl_spline self, gsl_vector const * IN, gsl_vector const * IN2) -> PyObject *"""
        return _gslwrap.pygsl_spline_eval_integ_e_vector(self, IN, IN2)

    def name(self):
        r"""name(pygsl_spline self) -> char const *"""
        return _gslwrap.pygsl_spline_name(self)

    def min_size(self):
        r"""min_size(pygsl_spline self) -> unsigned int"""
        return _gslwrap.pygsl_spline_min_size(self)

# Register pygsl_spline in _gslwrap:
_gslwrap.pygsl_spline_swigregister(pygsl_spline)

class pygsl_interp(object):
    r"""Proxy of C pygsl_interp struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, T, n):
        r"""__init__(pygsl_interp self, gsl_interp_type const * T, size_t n) -> pygsl_interp"""
        _gslwrap.pygsl_interp_swiginit(self, _gslwrap.new_pygsl_interp(T, n))
    __swig_destroy__ = _gslwrap.delete_pygsl_interp

    def init(self, x, y):
        r"""init(pygsl_interp self, PyObject * x, PyObject * y) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_interp_init(self, x, y)

    def name(self):
        r"""name(pygsl_interp self) -> char const *"""
        return _gslwrap.pygsl_interp_name(self)

    def min_size(self):
        r"""min_size(pygsl_interp self) -> unsigned int"""
        return _gslwrap.pygsl_interp_min_size(self)

    def eval_e(self, x):
        r"""eval_e(pygsl_interp self, double x) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_interp_eval_e(self, x)

    def eval(self, x):
        r"""eval(pygsl_interp self, double x) -> double"""
        return _gslwrap.pygsl_interp_eval(self, x)

    def eval_deriv_e(self, x):
        r"""eval_deriv_e(pygsl_interp self, double x) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_interp_eval_deriv_e(self, x)

    def eval_deriv(self, x):
        r"""eval_deriv(pygsl_interp self, double x) -> double"""
        return _gslwrap.pygsl_interp_eval_deriv(self, x)

    def eval_deriv2_e(self, x):
        r"""eval_deriv2_e(pygsl_interp self, double x) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_interp_eval_deriv2_e(self, x)

    def eval_deriv2(self, x):
        r"""eval_deriv2(pygsl_interp self, double x) -> double"""
        return _gslwrap.pygsl_interp_eval_deriv2(self, x)

    def eval_integ_e(self, a, b):
        r"""eval_integ_e(pygsl_interp self, double a, double b) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_interp_eval_integ_e(self, a, b)

    def eval_integ(self, a, b):
        r"""eval_integ(pygsl_interp self, double a, double b) -> double"""
        return _gslwrap.pygsl_interp_eval_integ(self, a, b)

    def accel_reset(self):
        r"""accel_reset(pygsl_interp self) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_interp_accel_reset(self)

    def accel_find(self, x):
        r"""accel_find(pygsl_interp self, double x) -> size_t"""
        return _gslwrap.pygsl_interp_accel_find(self, x)

# Register pygsl_interp in _gslwrap:
_gslwrap.pygsl_interp_swigregister(pygsl_interp)
cvar = _gslwrap.cvar
gsl_interp_linear = cvar.gsl_interp_linear
gsl_interp_polynomial = cvar.gsl_interp_polynomial
gsl_interp_cspline = cvar.gsl_interp_cspline
gsl_interp_cspline_periodic = cvar.gsl_interp_cspline_periodic
gsl_interp_akima = cvar.gsl_interp_akima
gsl_interp_akima_periodic = cvar.gsl_interp_akima_periodic


def gsl_interp_bsearch(x_array, x, index_lo, index_hi):
    r"""gsl_interp_bsearch(double const [] x_array, double x, size_t index_lo, size_t index_hi) -> size_t"""
    return _gslwrap.gsl_interp_bsearch(x_array, x, index_lo, index_hi)


