# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.6
#
# 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
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_gslwrap', [dirname(__file__)])
        except ImportError:
            import _gslwrap
            return _gslwrap
        if fp is not None:
            try:
                _mod = imp.load_module('_gslwrap', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _gslwrap = swig_import_helper()
    del swig_import_helper
else:
    import _gslwrap
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


class Permutation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Permutation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Permutation, name)
    __repr__ = _swig_repr
    __swig_getmethods__["size"] = _gslwrap.Permutation_size_get
    if _newclass:
        size = _swig_property(_gslwrap.Permutation_size_get)
    __swig_getmethods__["data"] = _gslwrap.Permutation_data_get
    if _newclass:
        data = _swig_property(_gslwrap.Permutation_data_get)

    def __init__(self, n):
        this = _gslwrap.new_Permutation(n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_Permutation
    __del__ = lambda self: None

    def inversions(self):
        return _gslwrap.Permutation_inversions(self)

    def __getitem__(self, i):
        return _gslwrap.Permutation___getitem__(self, i)

    def swap(self, i, j):
        return _gslwrap.Permutation_swap(self, i, j)

    def permute(self, INOUT):
        return _gslwrap.Permutation_permute(self, INOUT)

    def __len__(self):
        return _gslwrap.Permutation___len__(self)

    def valid(self):
        return _gslwrap.Permutation_valid(self)

    def reverse(self):
        return _gslwrap.Permutation_reverse(self)

    def next(self):
        return _gslwrap.Permutation_next(self)

    def prev(self):
        return _gslwrap.Permutation_prev(self)

    def __str__(self):
        return _gslwrap.Permutation___str__(self)

    def tolist(self):
        return _gslwrap.Permutation_tolist(self)

    def toarray(self):
        return _gslwrap.Permutation_toarray(self)

    def _linear_to_canonical(self, q):
        return _gslwrap.Permutation__linear_to_canonical(self, q)

    def _canonical_to_linear(self, q):
        return _gslwrap.Permutation__canonical_to_linear(self, q)

    def _mul(self, res, m2):
        return _gslwrap.Permutation__mul(self, res, m2)

    def _inverse(self, inv):
        return _gslwrap.Permutation__inverse(self, inv)

    def linear_cycles(self):
        return _gslwrap.Permutation_linear_cycles(self)

    def canonical_cycles(self):
        return _gslwrap.Permutation_canonical_cycles(self)
Permutation_swigregister = _gslwrap.Permutation_swigregister
Permutation_swigregister(Permutation)


def gsl_permutation_alloc(n):
    return _gslwrap.gsl_permutation_alloc(n)
gsl_permutation_alloc = _gslwrap.gsl_permutation_alloc

def gsl_permutation_calloc(n):
    return _gslwrap.gsl_permutation_calloc(n)
gsl_permutation_calloc = _gslwrap.gsl_permutation_calloc

def gsl_permutation_init(p):
    return _gslwrap.gsl_permutation_init(p)
gsl_permutation_init = _gslwrap.gsl_permutation_init

def gsl_permutation_free(p):
    return _gslwrap.gsl_permutation_free(p)
gsl_permutation_free = _gslwrap.gsl_permutation_free

def gsl_permutation_fread(stream, p):
    return _gslwrap.gsl_permutation_fread(stream, p)
gsl_permutation_fread = _gslwrap.gsl_permutation_fread

def gsl_permutation_fwrite(stream, p):
    return _gslwrap.gsl_permutation_fwrite(stream, p)
gsl_permutation_fwrite = _gslwrap.gsl_permutation_fwrite

def gsl_permutation_fscanf(stream, p):
    return _gslwrap.gsl_permutation_fscanf(stream, p)
gsl_permutation_fscanf = _gslwrap.gsl_permutation_fscanf

def gsl_permutation_fprintf(stream, p, format):
    return _gslwrap.gsl_permutation_fprintf(stream, p, format)
gsl_permutation_fprintf = _gslwrap.gsl_permutation_fprintf

def gsl_permutation_size(p):
    return _gslwrap.gsl_permutation_size(p)
gsl_permutation_size = _gslwrap.gsl_permutation_size

def gsl_permutation_data(p):
    return _gslwrap.gsl_permutation_data(p)
gsl_permutation_data = _gslwrap.gsl_permutation_data

def gsl_permutation_swap(p, i, j):
    return _gslwrap.gsl_permutation_swap(p, i, j)
gsl_permutation_swap = _gslwrap.gsl_permutation_swap

def gsl_permutation_valid(p):
    return _gslwrap.gsl_permutation_valid(p)
gsl_permutation_valid = _gslwrap.gsl_permutation_valid

def gsl_permutation_reverse(p):
    return _gslwrap.gsl_permutation_reverse(p)
gsl_permutation_reverse = _gslwrap.gsl_permutation_reverse

def gsl_permutation_inverse(inv, p):
    return _gslwrap.gsl_permutation_inverse(inv, p)
gsl_permutation_inverse = _gslwrap.gsl_permutation_inverse

def gsl_permutation_next(p):
    return _gslwrap.gsl_permutation_next(p)
gsl_permutation_next = _gslwrap.gsl_permutation_next

def gsl_permutation_prev(p):
    return _gslwrap.gsl_permutation_prev(p)
gsl_permutation_prev = _gslwrap.gsl_permutation_prev

def gsl_permutation_linear_to_canonical(q, p):
    return _gslwrap.gsl_permutation_linear_to_canonical(q, p)
gsl_permutation_linear_to_canonical = _gslwrap.gsl_permutation_linear_to_canonical

def gsl_permutation_canonical_to_linear(p, q):
    return _gslwrap.gsl_permutation_canonical_to_linear(p, q)
gsl_permutation_canonical_to_linear = _gslwrap.gsl_permutation_canonical_to_linear

def gsl_permutation_get(p, i):
    return _gslwrap.gsl_permutation_get(p, i)
gsl_permutation_get = _gslwrap.gsl_permutation_get

def pygsl_linalg_complex_householder_mh(tau, v, OUTPUT):
    return _gslwrap.pygsl_linalg_complex_householder_mh(tau, v, OUTPUT)
pygsl_linalg_complex_householder_mh = _gslwrap.pygsl_linalg_complex_householder_mh

def pygsl_linalg_hessenberg_decomp(A, tau):
    return _gslwrap.pygsl_linalg_hessenberg_decomp(A, tau)
pygsl_linalg_hessenberg_decomp = _gslwrap.pygsl_linalg_hessenberg_decomp

def pygsl_linalg_complex_cholesky_invert(cholesky):
    return _gslwrap.pygsl_linalg_complex_cholesky_invert(cholesky)
pygsl_linalg_complex_cholesky_invert = _gslwrap.pygsl_linalg_complex_cholesky_invert

_gslwrap.GSL_LINALG_MOD_NONE_swigconstant(_gslwrap)
GSL_LINALG_MOD_NONE = _gslwrap.GSL_LINALG_MOD_NONE

_gslwrap.GSL_LINALG_MOD_TRANSPOSE_swigconstant(_gslwrap)
GSL_LINALG_MOD_TRANSPOSE = _gslwrap.GSL_LINALG_MOD_TRANSPOSE

_gslwrap.GSL_LINALG_MOD_CONJUGATE_swigconstant(_gslwrap)
GSL_LINALG_MOD_CONJUGATE = _gslwrap.GSL_LINALG_MOD_CONJUGATE

def gsl_linalg_matmult(A, B, C):
    return _gslwrap.gsl_linalg_matmult(A, B, C)
gsl_linalg_matmult = _gslwrap.gsl_linalg_matmult

def gsl_linalg_matmult_mod(A, modA, B, modB, C):
    return _gslwrap.gsl_linalg_matmult_mod(A, modA, B, modB, C)
gsl_linalg_matmult_mod = _gslwrap.gsl_linalg_matmult_mod

def gsl_linalg_exponential_ss(A, eA, mode):
    return _gslwrap.gsl_linalg_exponential_ss(A, eA, mode)
gsl_linalg_exponential_ss = _gslwrap.gsl_linalg_exponential_ss

def gsl_linalg_householder_transform(v):
    return _gslwrap.gsl_linalg_householder_transform(v)
gsl_linalg_householder_transform = _gslwrap.gsl_linalg_householder_transform

def gsl_linalg_complex_householder_transform(v):
    return _gslwrap.gsl_linalg_complex_householder_transform(v)
gsl_linalg_complex_householder_transform = _gslwrap.gsl_linalg_complex_householder_transform

def gsl_linalg_householder_hm(tau, v, A):
    return _gslwrap.gsl_linalg_householder_hm(tau, v, A)
gsl_linalg_householder_hm = _gslwrap.gsl_linalg_householder_hm

def gsl_linalg_householder_mh(tau, v, A):
    return _gslwrap.gsl_linalg_householder_mh(tau, v, A)
gsl_linalg_householder_mh = _gslwrap.gsl_linalg_householder_mh

def gsl_linalg_householder_hv(tau, v, w):
    return _gslwrap.gsl_linalg_householder_hv(tau, v, w)
gsl_linalg_householder_hv = _gslwrap.gsl_linalg_householder_hv

def gsl_linalg_householder_hm1(tau, A):
    return _gslwrap.gsl_linalg_householder_hm1(tau, A)
gsl_linalg_householder_hm1 = _gslwrap.gsl_linalg_householder_hm1

def gsl_linalg_complex_householder_hm(tau, v, A):
    return _gslwrap.gsl_linalg_complex_householder_hm(tau, v, A)
gsl_linalg_complex_householder_hm = _gslwrap.gsl_linalg_complex_householder_hm

def gsl_linalg_complex_householder_hv(tau, v, w):
    return _gslwrap.gsl_linalg_complex_householder_hv(tau, v, w)
gsl_linalg_complex_householder_hv = _gslwrap.gsl_linalg_complex_householder_hv

def gsl_linalg_hessenberg_unpack(H, tau, U):
    return _gslwrap.gsl_linalg_hessenberg_unpack(H, tau, U)
gsl_linalg_hessenberg_unpack = _gslwrap.gsl_linalg_hessenberg_unpack

def gsl_linalg_hessenberg_unpack_accum(H, tau, U):
    return _gslwrap.gsl_linalg_hessenberg_unpack_accum(H, tau, U)
gsl_linalg_hessenberg_unpack_accum = _gslwrap.gsl_linalg_hessenberg_unpack_accum

def gsl_linalg_hessenberg_set_zero(H):
    return _gslwrap.gsl_linalg_hessenberg_set_zero(H)
gsl_linalg_hessenberg_set_zero = _gslwrap.gsl_linalg_hessenberg_set_zero

def gsl_linalg_hessenberg_submatrix(M, A, top, tau):
    return _gslwrap.gsl_linalg_hessenberg_submatrix(M, A, top, tau)
gsl_linalg_hessenberg_submatrix = _gslwrap.gsl_linalg_hessenberg_submatrix

def gsl_linalg_hessenberg(A, tau):
    return _gslwrap.gsl_linalg_hessenberg(A, tau)
gsl_linalg_hessenberg = _gslwrap.gsl_linalg_hessenberg

def gsl_linalg_hesstri_decomp(A, B, U, V, work):
    return _gslwrap.gsl_linalg_hesstri_decomp(A, B, U, V, work)
gsl_linalg_hesstri_decomp = _gslwrap.gsl_linalg_hesstri_decomp

def gsl_linalg_SV_decomp(A, V, S, work):
    return _gslwrap.gsl_linalg_SV_decomp(A, V, S, work)
gsl_linalg_SV_decomp = _gslwrap.gsl_linalg_SV_decomp

def gsl_linalg_SV_decomp_mod(A, X, V, S, work):
    return _gslwrap.gsl_linalg_SV_decomp_mod(A, X, V, S, work)
gsl_linalg_SV_decomp_mod = _gslwrap.gsl_linalg_SV_decomp_mod

def gsl_linalg_SV_decomp_jacobi(A, Q, S):
    return _gslwrap.gsl_linalg_SV_decomp_jacobi(A, Q, S)
gsl_linalg_SV_decomp_jacobi = _gslwrap.gsl_linalg_SV_decomp_jacobi

def gsl_linalg_SV_solve(U, Q, S, b, x):
    return _gslwrap.gsl_linalg_SV_solve(U, Q, S, b, x)
gsl_linalg_SV_solve = _gslwrap.gsl_linalg_SV_solve

def gsl_linalg_LU_solve(LU, p, b, x):
    return _gslwrap.gsl_linalg_LU_solve(LU, p, b, x)
gsl_linalg_LU_solve = _gslwrap.gsl_linalg_LU_solve

def gsl_linalg_LU_svx(LU, p, x):
    return _gslwrap.gsl_linalg_LU_svx(LU, p, x)
gsl_linalg_LU_svx = _gslwrap.gsl_linalg_LU_svx

def gsl_linalg_LU_refine(A, LU, p, b, x, residual):
    return _gslwrap.gsl_linalg_LU_refine(A, LU, p, b, x, residual)
gsl_linalg_LU_refine = _gslwrap.gsl_linalg_LU_refine

def gsl_linalg_LU_invert(LU, p, inverse):
    return _gslwrap.gsl_linalg_LU_invert(LU, p, inverse)
gsl_linalg_LU_invert = _gslwrap.gsl_linalg_LU_invert

def gsl_linalg_LU_det(LU, signum):
    return _gslwrap.gsl_linalg_LU_det(LU, signum)
gsl_linalg_LU_det = _gslwrap.gsl_linalg_LU_det

def gsl_linalg_LU_lndet(LU):
    return _gslwrap.gsl_linalg_LU_lndet(LU)
gsl_linalg_LU_lndet = _gslwrap.gsl_linalg_LU_lndet

def gsl_linalg_LU_sgndet(lu, signum):
    return _gslwrap.gsl_linalg_LU_sgndet(lu, signum)
gsl_linalg_LU_sgndet = _gslwrap.gsl_linalg_LU_sgndet

def gsl_linalg_complex_LU_solve(LU, p, b, x):
    return _gslwrap.gsl_linalg_complex_LU_solve(LU, p, b, x)
gsl_linalg_complex_LU_solve = _gslwrap.gsl_linalg_complex_LU_solve

def gsl_linalg_complex_LU_svx(LU, p, x):
    return _gslwrap.gsl_linalg_complex_LU_svx(LU, p, x)
gsl_linalg_complex_LU_svx = _gslwrap.gsl_linalg_complex_LU_svx

def gsl_linalg_complex_LU_refine(A, LU, p, b, x, residual):
    return _gslwrap.gsl_linalg_complex_LU_refine(A, LU, p, b, x, residual)
gsl_linalg_complex_LU_refine = _gslwrap.gsl_linalg_complex_LU_refine

def gsl_linalg_complex_LU_invert(LU, p, inverse):
    return _gslwrap.gsl_linalg_complex_LU_invert(LU, p, inverse)
gsl_linalg_complex_LU_invert = _gslwrap.gsl_linalg_complex_LU_invert

def gsl_linalg_complex_LU_det(LU, signum):
    return _gslwrap.gsl_linalg_complex_LU_det(LU, signum)
gsl_linalg_complex_LU_det = _gslwrap.gsl_linalg_complex_LU_det

def gsl_linalg_complex_LU_lndet(LU):
    return _gslwrap.gsl_linalg_complex_LU_lndet(LU)
gsl_linalg_complex_LU_lndet = _gslwrap.gsl_linalg_complex_LU_lndet

def gsl_linalg_complex_LU_sgndet(LU, signum):
    return _gslwrap.gsl_linalg_complex_LU_sgndet(LU, signum)
gsl_linalg_complex_LU_sgndet = _gslwrap.gsl_linalg_complex_LU_sgndet

def gsl_linalg_QR_decomp(A, tau):
    return _gslwrap.gsl_linalg_QR_decomp(A, tau)
gsl_linalg_QR_decomp = _gslwrap.gsl_linalg_QR_decomp

def gsl_linalg_QR_solve(QR, tau, b, x):
    return _gslwrap.gsl_linalg_QR_solve(QR, tau, b, x)
gsl_linalg_QR_solve = _gslwrap.gsl_linalg_QR_solve

def gsl_linalg_QR_svx(QR, tau, x):
    return _gslwrap.gsl_linalg_QR_svx(QR, tau, x)
gsl_linalg_QR_svx = _gslwrap.gsl_linalg_QR_svx

def gsl_linalg_QR_lssolve(QR, tau, b, x, residual):
    return _gslwrap.gsl_linalg_QR_lssolve(QR, tau, b, x, residual)
gsl_linalg_QR_lssolve = _gslwrap.gsl_linalg_QR_lssolve

def gsl_linalg_QR_QRsolve(Q, R, b, x):
    return _gslwrap.gsl_linalg_QR_QRsolve(Q, R, b, x)
gsl_linalg_QR_QRsolve = _gslwrap.gsl_linalg_QR_QRsolve

def gsl_linalg_QR_Rsolve(QR, b, x):
    return _gslwrap.gsl_linalg_QR_Rsolve(QR, b, x)
gsl_linalg_QR_Rsolve = _gslwrap.gsl_linalg_QR_Rsolve

def gsl_linalg_QR_Rsvx(QR, x):
    return _gslwrap.gsl_linalg_QR_Rsvx(QR, x)
gsl_linalg_QR_Rsvx = _gslwrap.gsl_linalg_QR_Rsvx

def gsl_linalg_QR_update(Q, R, w, v):
    return _gslwrap.gsl_linalg_QR_update(Q, R, w, v)
gsl_linalg_QR_update = _gslwrap.gsl_linalg_QR_update

def gsl_linalg_QR_QTvec(QR, tau, v):
    return _gslwrap.gsl_linalg_QR_QTvec(QR, tau, v)
gsl_linalg_QR_QTvec = _gslwrap.gsl_linalg_QR_QTvec

def gsl_linalg_QR_Qvec(QR, tau, v):
    return _gslwrap.gsl_linalg_QR_Qvec(QR, tau, v)
gsl_linalg_QR_Qvec = _gslwrap.gsl_linalg_QR_Qvec

def gsl_linalg_QR_QTmat(QR, tau, A):
    return _gslwrap.gsl_linalg_QR_QTmat(QR, tau, A)
gsl_linalg_QR_QTmat = _gslwrap.gsl_linalg_QR_QTmat

def gsl_linalg_QR_unpack(QR, tau, Q, R):
    return _gslwrap.gsl_linalg_QR_unpack(QR, tau, Q, R)
gsl_linalg_QR_unpack = _gslwrap.gsl_linalg_QR_unpack

def gsl_linalg_R_solve(R, b, x):
    return _gslwrap.gsl_linalg_R_solve(R, b, x)
gsl_linalg_R_solve = _gslwrap.gsl_linalg_R_solve

def gsl_linalg_R_svx(R, x):
    return _gslwrap.gsl_linalg_R_svx(R, x)
gsl_linalg_R_svx = _gslwrap.gsl_linalg_R_svx

def gsl_linalg_QRPT_decomp(A, tau, p, norm):
    return _gslwrap.gsl_linalg_QRPT_decomp(A, tau, p, norm)
gsl_linalg_QRPT_decomp = _gslwrap.gsl_linalg_QRPT_decomp

def gsl_linalg_QRPT_decomp2(A, q, r, tau, p, norm):
    return _gslwrap.gsl_linalg_QRPT_decomp2(A, q, r, tau, p, norm)
gsl_linalg_QRPT_decomp2 = _gslwrap.gsl_linalg_QRPT_decomp2

def gsl_linalg_QRPT_solve(QR, tau, p, b, x):
    return _gslwrap.gsl_linalg_QRPT_solve(QR, tau, p, b, x)
gsl_linalg_QRPT_solve = _gslwrap.gsl_linalg_QRPT_solve

def gsl_linalg_QRPT_svx(QR, tau, p, x):
    return _gslwrap.gsl_linalg_QRPT_svx(QR, tau, p, x)
gsl_linalg_QRPT_svx = _gslwrap.gsl_linalg_QRPT_svx

def gsl_linalg_QRPT_QRsolve(Q, R, p, b, x):
    return _gslwrap.gsl_linalg_QRPT_QRsolve(Q, R, p, b, x)
gsl_linalg_QRPT_QRsolve = _gslwrap.gsl_linalg_QRPT_QRsolve

def gsl_linalg_QRPT_Rsolve(QR, p, b, x):
    return _gslwrap.gsl_linalg_QRPT_Rsolve(QR, p, b, x)
gsl_linalg_QRPT_Rsolve = _gslwrap.gsl_linalg_QRPT_Rsolve

def gsl_linalg_QRPT_Rsvx(QR, p, x):
    return _gslwrap.gsl_linalg_QRPT_Rsvx(QR, p, x)
gsl_linalg_QRPT_Rsvx = _gslwrap.gsl_linalg_QRPT_Rsvx

def gsl_linalg_QRPT_update(Q, R, p, u, v):
    return _gslwrap.gsl_linalg_QRPT_update(Q, R, p, u, v)
gsl_linalg_QRPT_update = _gslwrap.gsl_linalg_QRPT_update

def gsl_linalg_LQ_decomp(A, tau):
    return _gslwrap.gsl_linalg_LQ_decomp(A, tau)
gsl_linalg_LQ_decomp = _gslwrap.gsl_linalg_LQ_decomp

def gsl_linalg_LQ_solve_T(LQ, tau, b, x):
    return _gslwrap.gsl_linalg_LQ_solve_T(LQ, tau, b, x)
gsl_linalg_LQ_solve_T = _gslwrap.gsl_linalg_LQ_solve_T

def gsl_linalg_LQ_svx_T(LQ, tau, x):
    return _gslwrap.gsl_linalg_LQ_svx_T(LQ, tau, x)
gsl_linalg_LQ_svx_T = _gslwrap.gsl_linalg_LQ_svx_T

def gsl_linalg_LQ_lssolve_T(LQ, tau, b, x, residual):
    return _gslwrap.gsl_linalg_LQ_lssolve_T(LQ, tau, b, x, residual)
gsl_linalg_LQ_lssolve_T = _gslwrap.gsl_linalg_LQ_lssolve_T

def gsl_linalg_LQ_Lsolve_T(LQ, b, x):
    return _gslwrap.gsl_linalg_LQ_Lsolve_T(LQ, b, x)
gsl_linalg_LQ_Lsolve_T = _gslwrap.gsl_linalg_LQ_Lsolve_T

def gsl_linalg_LQ_Lsvx_T(LQ, x):
    return _gslwrap.gsl_linalg_LQ_Lsvx_T(LQ, x)
gsl_linalg_LQ_Lsvx_T = _gslwrap.gsl_linalg_LQ_Lsvx_T

def gsl_linalg_L_solve_T(L, b, x):
    return _gslwrap.gsl_linalg_L_solve_T(L, b, x)
gsl_linalg_L_solve_T = _gslwrap.gsl_linalg_L_solve_T

def gsl_linalg_LQ_vecQ(LQ, tau, v):
    return _gslwrap.gsl_linalg_LQ_vecQ(LQ, tau, v)
gsl_linalg_LQ_vecQ = _gslwrap.gsl_linalg_LQ_vecQ

def gsl_linalg_LQ_vecQT(LQ, tau, v):
    return _gslwrap.gsl_linalg_LQ_vecQT(LQ, tau, v)
gsl_linalg_LQ_vecQT = _gslwrap.gsl_linalg_LQ_vecQT

def gsl_linalg_LQ_unpack(LQ, tau, Q, L):
    return _gslwrap.gsl_linalg_LQ_unpack(LQ, tau, Q, L)
gsl_linalg_LQ_unpack = _gslwrap.gsl_linalg_LQ_unpack

def gsl_linalg_LQ_update(Q, R, v, w):
    return _gslwrap.gsl_linalg_LQ_update(Q, R, v, w)
gsl_linalg_LQ_update = _gslwrap.gsl_linalg_LQ_update

def gsl_linalg_LQ_LQsolve(Q, L, b, x):
    return _gslwrap.gsl_linalg_LQ_LQsolve(Q, L, b, x)
gsl_linalg_LQ_LQsolve = _gslwrap.gsl_linalg_LQ_LQsolve

def gsl_linalg_PTLQ_decomp(A, tau, p, norm):
    return _gslwrap.gsl_linalg_PTLQ_decomp(A, tau, p, norm)
gsl_linalg_PTLQ_decomp = _gslwrap.gsl_linalg_PTLQ_decomp

def gsl_linalg_PTLQ_decomp2(A, q, r, tau, p, norm):
    return _gslwrap.gsl_linalg_PTLQ_decomp2(A, q, r, tau, p, norm)
gsl_linalg_PTLQ_decomp2 = _gslwrap.gsl_linalg_PTLQ_decomp2

def gsl_linalg_PTLQ_solve_T(QR, tau, p, b, x):
    return _gslwrap.gsl_linalg_PTLQ_solve_T(QR, tau, p, b, x)
gsl_linalg_PTLQ_solve_T = _gslwrap.gsl_linalg_PTLQ_solve_T

def gsl_linalg_PTLQ_svx_T(LQ, tau, p, x):
    return _gslwrap.gsl_linalg_PTLQ_svx_T(LQ, tau, p, x)
gsl_linalg_PTLQ_svx_T = _gslwrap.gsl_linalg_PTLQ_svx_T

def gsl_linalg_PTLQ_LQsolve_T(Q, L, p, b, x):
    return _gslwrap.gsl_linalg_PTLQ_LQsolve_T(Q, L, p, b, x)
gsl_linalg_PTLQ_LQsolve_T = _gslwrap.gsl_linalg_PTLQ_LQsolve_T

def gsl_linalg_PTLQ_Lsolve_T(LQ, p, b, x):
    return _gslwrap.gsl_linalg_PTLQ_Lsolve_T(LQ, p, b, x)
gsl_linalg_PTLQ_Lsolve_T = _gslwrap.gsl_linalg_PTLQ_Lsolve_T

def gsl_linalg_PTLQ_Lsvx_T(LQ, p, x):
    return _gslwrap.gsl_linalg_PTLQ_Lsvx_T(LQ, p, x)
gsl_linalg_PTLQ_Lsvx_T = _gslwrap.gsl_linalg_PTLQ_Lsvx_T

def gsl_linalg_PTLQ_update(Q, L, p, v, w):
    return _gslwrap.gsl_linalg_PTLQ_update(Q, L, p, v, w)
gsl_linalg_PTLQ_update = _gslwrap.gsl_linalg_PTLQ_update

def gsl_linalg_cholesky_decomp(A):
    return _gslwrap.gsl_linalg_cholesky_decomp(A)
gsl_linalg_cholesky_decomp = _gslwrap.gsl_linalg_cholesky_decomp

def gsl_linalg_cholesky_solve(cholesky, b, x):
    return _gslwrap.gsl_linalg_cholesky_solve(cholesky, b, x)
gsl_linalg_cholesky_solve = _gslwrap.gsl_linalg_cholesky_solve

def gsl_linalg_cholesky_svx(cholesky, x):
    return _gslwrap.gsl_linalg_cholesky_svx(cholesky, x)
gsl_linalg_cholesky_svx = _gslwrap.gsl_linalg_cholesky_svx

def gsl_linalg_cholesky_invert(cholesky):
    return _gslwrap.gsl_linalg_cholesky_invert(cholesky)
gsl_linalg_cholesky_invert = _gslwrap.gsl_linalg_cholesky_invert

def gsl_linalg_cholesky_decomp_unit(A, D):
    return _gslwrap.gsl_linalg_cholesky_decomp_unit(A, D)
gsl_linalg_cholesky_decomp_unit = _gslwrap.gsl_linalg_cholesky_decomp_unit

def gsl_linalg_complex_cholesky_decomp(A):
    return _gslwrap.gsl_linalg_complex_cholesky_decomp(A)
gsl_linalg_complex_cholesky_decomp = _gslwrap.gsl_linalg_complex_cholesky_decomp

def gsl_linalg_complex_cholesky_solve(cholesky, b, x):
    return _gslwrap.gsl_linalg_complex_cholesky_solve(cholesky, b, x)
gsl_linalg_complex_cholesky_solve = _gslwrap.gsl_linalg_complex_cholesky_solve

def gsl_linalg_complex_cholesky_svx(cholesky, x):
    return _gslwrap.gsl_linalg_complex_cholesky_svx(cholesky, x)
gsl_linalg_complex_cholesky_svx = _gslwrap.gsl_linalg_complex_cholesky_svx

def gsl_linalg_symmtd_decomp(A, tau):
    return _gslwrap.gsl_linalg_symmtd_decomp(A, tau)
gsl_linalg_symmtd_decomp = _gslwrap.gsl_linalg_symmtd_decomp

def gsl_linalg_symmtd_unpack(A, tau, Q, diag, subdiag):
    return _gslwrap.gsl_linalg_symmtd_unpack(A, tau, Q, diag, subdiag)
gsl_linalg_symmtd_unpack = _gslwrap.gsl_linalg_symmtd_unpack

def gsl_linalg_symmtd_unpack_T(A, diag, subdiag):
    return _gslwrap.gsl_linalg_symmtd_unpack_T(A, diag, subdiag)
gsl_linalg_symmtd_unpack_T = _gslwrap.gsl_linalg_symmtd_unpack_T

def gsl_linalg_hermtd_decomp(A, tau):
    return _gslwrap.gsl_linalg_hermtd_decomp(A, tau)
gsl_linalg_hermtd_decomp = _gslwrap.gsl_linalg_hermtd_decomp

def gsl_linalg_hermtd_unpack(A, tau, U, diag, sudiag):
    return _gslwrap.gsl_linalg_hermtd_unpack(A, tau, U, diag, sudiag)
gsl_linalg_hermtd_unpack = _gslwrap.gsl_linalg_hermtd_unpack

def gsl_linalg_hermtd_unpack_T(A, diag, subdiag):
    return _gslwrap.gsl_linalg_hermtd_unpack_T(A, diag, subdiag)
gsl_linalg_hermtd_unpack_T = _gslwrap.gsl_linalg_hermtd_unpack_T

def gsl_linalg_HH_solve(A, b, x):
    return _gslwrap.gsl_linalg_HH_solve(A, b, x)
gsl_linalg_HH_solve = _gslwrap.gsl_linalg_HH_solve

def gsl_linalg_HH_svx(A, x):
    return _gslwrap.gsl_linalg_HH_svx(A, x)
gsl_linalg_HH_svx = _gslwrap.gsl_linalg_HH_svx

def gsl_linalg_solve_symm_tridiag(diag, offdiag, b, x):
    return _gslwrap.gsl_linalg_solve_symm_tridiag(diag, offdiag, b, x)
gsl_linalg_solve_symm_tridiag = _gslwrap.gsl_linalg_solve_symm_tridiag

def gsl_linalg_solve_tridiag(diag, abovediag, belowdiag, b, x):
    return _gslwrap.gsl_linalg_solve_tridiag(diag, abovediag, belowdiag, b, x)
gsl_linalg_solve_tridiag = _gslwrap.gsl_linalg_solve_tridiag

def gsl_linalg_solve_symm_cyc_tridiag(diag, offdiag, b, x):
    return _gslwrap.gsl_linalg_solve_symm_cyc_tridiag(diag, offdiag, b, x)
gsl_linalg_solve_symm_cyc_tridiag = _gslwrap.gsl_linalg_solve_symm_cyc_tridiag

def gsl_linalg_solve_cyc_tridiag(diag, abovediag, belowdiag, b, x):
    return _gslwrap.gsl_linalg_solve_cyc_tridiag(diag, abovediag, belowdiag, b, x)
gsl_linalg_solve_cyc_tridiag = _gslwrap.gsl_linalg_solve_cyc_tridiag

def gsl_linalg_bidiag_decomp(A, tau_U, tau_V):
    return _gslwrap.gsl_linalg_bidiag_decomp(A, tau_U, tau_V)
gsl_linalg_bidiag_decomp = _gslwrap.gsl_linalg_bidiag_decomp

def gsl_linalg_bidiag_unpack(A, tau_U, U, tau_V, V, diag, superdiag):
    return _gslwrap.gsl_linalg_bidiag_unpack(A, tau_U, U, tau_V, V, diag, superdiag)
gsl_linalg_bidiag_unpack = _gslwrap.gsl_linalg_bidiag_unpack

def gsl_linalg_bidiag_unpack2(A, tau_U, tau_V, V):
    return _gslwrap.gsl_linalg_bidiag_unpack2(A, tau_U, tau_V, V)
gsl_linalg_bidiag_unpack2 = _gslwrap.gsl_linalg_bidiag_unpack2

def gsl_linalg_bidiag_unpack_B(A, diag, superdiag):
    return _gslwrap.gsl_linalg_bidiag_unpack_B(A, diag, superdiag)
gsl_linalg_bidiag_unpack_B = _gslwrap.gsl_linalg_bidiag_unpack_B

def gsl_linalg_balance_matrix(A, D):
    return _gslwrap.gsl_linalg_balance_matrix(A, D)
gsl_linalg_balance_matrix = _gslwrap.gsl_linalg_balance_matrix

def gsl_linalg_balance_accum(A, D):
    return _gslwrap.gsl_linalg_balance_accum(A, D)
gsl_linalg_balance_accum = _gslwrap.gsl_linalg_balance_accum

def gsl_linalg_balance_columns(A, D):
    return _gslwrap.gsl_linalg_balance_columns(A, D)
gsl_linalg_balance_columns = _gslwrap.gsl_linalg_balance_columns

def pygsl_linalg_LU_decomp(A, p):
    return _gslwrap.pygsl_linalg_LU_decomp(A, p)
pygsl_linalg_LU_decomp = _gslwrap.pygsl_linalg_LU_decomp

def pygsl_linalg_complex_LU_decomp(A, p):
    return _gslwrap.pygsl_linalg_complex_LU_decomp(A, p)
pygsl_linalg_complex_LU_decomp = _gslwrap.pygsl_linalg_complex_LU_decomp
class Combination(_object):
    """Proxy of C gsl_combination_struct struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Combination, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Combination, name)
    __repr__ = _swig_repr

    def __init__(self, n, k):
        """bla blamore blah blah"""
        this = _gslwrap.new_Combination(n, k)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_Combination
    __del__ = lambda self: None

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


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


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


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


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


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


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


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


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


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

Combination_swigregister = _gslwrap.Combination_swigregister
Combination_swigregister(Combination)


_gslwrap.M_E_swigconstant(_gslwrap)
M_E = _gslwrap.M_E

_gslwrap.M_LOG2E_swigconstant(_gslwrap)
M_LOG2E = _gslwrap.M_LOG2E

_gslwrap.M_LOG10E_swigconstant(_gslwrap)
M_LOG10E = _gslwrap.M_LOG10E

_gslwrap.M_SQRT2_swigconstant(_gslwrap)
M_SQRT2 = _gslwrap.M_SQRT2

_gslwrap.M_SQRT1_2_swigconstant(_gslwrap)
M_SQRT1_2 = _gslwrap.M_SQRT1_2

_gslwrap.M_SQRT3_swigconstant(_gslwrap)
M_SQRT3 = _gslwrap.M_SQRT3

_gslwrap.M_PI_swigconstant(_gslwrap)
M_PI = _gslwrap.M_PI

_gslwrap.M_PI_2_swigconstant(_gslwrap)
M_PI_2 = _gslwrap.M_PI_2

_gslwrap.M_PI_4_swigconstant(_gslwrap)
M_PI_4 = _gslwrap.M_PI_4

_gslwrap.M_SQRTPI_swigconstant(_gslwrap)
M_SQRTPI = _gslwrap.M_SQRTPI

_gslwrap.M_2_SQRTPI_swigconstant(_gslwrap)
M_2_SQRTPI = _gslwrap.M_2_SQRTPI

_gslwrap.M_1_PI_swigconstant(_gslwrap)
M_1_PI = _gslwrap.M_1_PI

_gslwrap.M_2_PI_swigconstant(_gslwrap)
M_2_PI = _gslwrap.M_2_PI

_gslwrap.M_LN10_swigconstant(_gslwrap)
M_LN10 = _gslwrap.M_LN10

_gslwrap.M_LN2_swigconstant(_gslwrap)
M_LN2 = _gslwrap.M_LN2

_gslwrap.M_LNPI_swigconstant(_gslwrap)
M_LNPI = _gslwrap.M_LNPI

_gslwrap.M_EULER_swigconstant(_gslwrap)
M_EULER = _gslwrap.M_EULER

_gslwrap.GSL_POSZERO_swigconstant(_gslwrap)
GSL_POSZERO = _gslwrap.GSL_POSZERO

_gslwrap.GSL_NEGZERO_swigconstant(_gslwrap)
GSL_NEGZERO = _gslwrap.GSL_NEGZERO

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

_gslwrap.CblasRowMajor_swigconstant(_gslwrap)
CblasRowMajor = _gslwrap.CblasRowMajor

_gslwrap.CblasColMajor_swigconstant(_gslwrap)
CblasColMajor = _gslwrap.CblasColMajor

_gslwrap.CblasNoTrans_swigconstant(_gslwrap)
CblasNoTrans = _gslwrap.CblasNoTrans

_gslwrap.CblasTrans_swigconstant(_gslwrap)
CblasTrans = _gslwrap.CblasTrans

_gslwrap.CblasConjTrans_swigconstant(_gslwrap)
CblasConjTrans = _gslwrap.CblasConjTrans

_gslwrap.CblasUpper_swigconstant(_gslwrap)
CblasUpper = _gslwrap.CblasUpper

_gslwrap.CblasLower_swigconstant(_gslwrap)
CblasLower = _gslwrap.CblasLower

_gslwrap.CblasNonUnit_swigconstant(_gslwrap)
CblasNonUnit = _gslwrap.CblasNonUnit

_gslwrap.CblasUnit_swigconstant(_gslwrap)
CblasUnit = _gslwrap.CblasUnit

_gslwrap.CblasLeft_swigconstant(_gslwrap)
CblasLeft = _gslwrap.CblasLeft

_gslwrap.CblasRight_swigconstant(_gslwrap)
CblasRight = _gslwrap.CblasRight

def gsl_blas_sdsdot(alpha, X, Y, result):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """gsl_blas_snrm2(gsl_vector_float const * X) -> float"""
    return _gslwrap.gsl_blas_snrm2(X)

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

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

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

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

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

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

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

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

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

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

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

def gsl_blas_sswap(X, Y):
    """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):
    """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):
    """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):
    """gsl_blas_dswap(gsl_vector * X, gsl_vector * Y) -> int"""
    return _gslwrap.gsl_blas_dswap(X, Y)

def gsl_blas_dcopy(X, Y):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """gsl_blas_sscal(float alpha, gsl_vector_float * X)"""
    return _gslwrap.gsl_blas_sscal(alpha, X)

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

def gsl_blas_cscal(alpha, X):
    """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):
    """gsl_blas_zscal(gsl_complex const alpha, gsl_vector_complex * X)"""
    return _gslwrap.gsl_blas_zscal(alpha, X)

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

def gsl_blas_zdscal(alpha, X):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """Proxy of C gsl_eigen_symm_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_symm_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_symm_workspace, name)
    __repr__ = _swig_repr

    def __init__(self, n):
        """__init__(gsl_eigen_symm_workspace self, size_t const n) -> gsl_eigen_symm_workspace"""
        this = _gslwrap.new_gsl_eigen_symm_workspace(n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_symm_workspace
    __del__ = lambda self: None
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_symm_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_symm_workspace_size_get)
    __swig_getmethods__["d"] = _gslwrap.gsl_eigen_symm_workspace_d_get
    if _newclass:
        d = _swig_property(_gslwrap.gsl_eigen_symm_workspace_d_get)
    __swig_getmethods__["sd"] = _gslwrap.gsl_eigen_symm_workspace_sd_get
    if _newclass:
        sd = _swig_property(_gslwrap.gsl_eigen_symm_workspace_sd_get)
gsl_eigen_symm_workspace_swigregister = _gslwrap.gsl_eigen_symm_workspace_swigregister
gsl_eigen_symm_workspace_swigregister(gsl_eigen_symm_workspace)


def gsl_eigen_symm_alloc(n):
    """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):
    """gsl_eigen_symm_free(gsl_eigen_symm_workspace w)"""
    return _gslwrap.gsl_eigen_symm_free(w)

def gsl_eigen_symm(A, eval, w):
    """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):
    """Proxy of C gsl_eigen_symmv_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_symmv_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_symmv_workspace, name)
    __repr__ = _swig_repr

    def __init__(self, n):
        """__init__(gsl_eigen_symmv_workspace self, size_t const n) -> gsl_eigen_symmv_workspace"""
        this = _gslwrap.new_gsl_eigen_symmv_workspace(n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_symmv_workspace
    __del__ = lambda self: None
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_symmv_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_symmv_workspace_size_get)
    __swig_getmethods__["d"] = _gslwrap.gsl_eigen_symmv_workspace_d_get
    if _newclass:
        d = _swig_property(_gslwrap.gsl_eigen_symmv_workspace_d_get)
    __swig_getmethods__["sd"] = _gslwrap.gsl_eigen_symmv_workspace_sd_get
    if _newclass:
        sd = _swig_property(_gslwrap.gsl_eigen_symmv_workspace_sd_get)
    __swig_getmethods__["gc"] = _gslwrap.gsl_eigen_symmv_workspace_gc_get
    if _newclass:
        gc = _swig_property(_gslwrap.gsl_eigen_symmv_workspace_gc_get)
    __swig_getmethods__["gs"] = _gslwrap.gsl_eigen_symmv_workspace_gs_get
    if _newclass:
        gs = _swig_property(_gslwrap.gsl_eigen_symmv_workspace_gs_get)
gsl_eigen_symmv_workspace_swigregister = _gslwrap.gsl_eigen_symmv_workspace_swigregister
gsl_eigen_symmv_workspace_swigregister(gsl_eigen_symmv_workspace)


def gsl_eigen_symmv_alloc(n):
    """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):
    """gsl_eigen_symmv_free(gsl_eigen_symmv_workspace w)"""
    return _gslwrap.gsl_eigen_symmv_free(w)

def gsl_eigen_symmv(A, eval, evec, w):
    """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):
    """Proxy of C gsl_eigen_herm_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_herm_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_herm_workspace, name)
    __repr__ = _swig_repr

    def __init__(self, n):
        """__init__(gsl_eigen_herm_workspace self, size_t const n) -> gsl_eigen_herm_workspace"""
        this = _gslwrap.new_gsl_eigen_herm_workspace(n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_herm_workspace
    __del__ = lambda self: None
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_herm_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_herm_workspace_size_get)
    __swig_getmethods__["d"] = _gslwrap.gsl_eigen_herm_workspace_d_get
    if _newclass:
        d = _swig_property(_gslwrap.gsl_eigen_herm_workspace_d_get)
    __swig_getmethods__["sd"] = _gslwrap.gsl_eigen_herm_workspace_sd_get
    if _newclass:
        sd = _swig_property(_gslwrap.gsl_eigen_herm_workspace_sd_get)
    __swig_getmethods__["tau"] = _gslwrap.gsl_eigen_herm_workspace_tau_get
    if _newclass:
        tau = _swig_property(_gslwrap.gsl_eigen_herm_workspace_tau_get)
gsl_eigen_herm_workspace_swigregister = _gslwrap.gsl_eigen_herm_workspace_swigregister
gsl_eigen_herm_workspace_swigregister(gsl_eigen_herm_workspace)


def gsl_eigen_herm_alloc(n):
    """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):
    """gsl_eigen_herm_free(gsl_eigen_herm_workspace w)"""
    return _gslwrap.gsl_eigen_herm_free(w)

def gsl_eigen_herm(A, eval, w):
    """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):
    """Proxy of C gsl_eigen_hermv_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_hermv_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_hermv_workspace, name)
    __repr__ = _swig_repr

    def __init__(self, n):
        """__init__(gsl_eigen_hermv_workspace self, size_t const n) -> gsl_eigen_hermv_workspace"""
        this = _gslwrap.new_gsl_eigen_hermv_workspace(n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_hermv_workspace
    __del__ = lambda self: None
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_hermv_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_hermv_workspace_size_get)
    __swig_getmethods__["d"] = _gslwrap.gsl_eigen_hermv_workspace_d_get
    if _newclass:
        d = _swig_property(_gslwrap.gsl_eigen_hermv_workspace_d_get)
    __swig_getmethods__["sd"] = _gslwrap.gsl_eigen_hermv_workspace_sd_get
    if _newclass:
        sd = _swig_property(_gslwrap.gsl_eigen_hermv_workspace_sd_get)
    __swig_getmethods__["tau"] = _gslwrap.gsl_eigen_hermv_workspace_tau_get
    if _newclass:
        tau = _swig_property(_gslwrap.gsl_eigen_hermv_workspace_tau_get)
    __swig_getmethods__["gc"] = _gslwrap.gsl_eigen_hermv_workspace_gc_get
    if _newclass:
        gc = _swig_property(_gslwrap.gsl_eigen_hermv_workspace_gc_get)
    __swig_getmethods__["gs"] = _gslwrap.gsl_eigen_hermv_workspace_gs_get
    if _newclass:
        gs = _swig_property(_gslwrap.gsl_eigen_hermv_workspace_gs_get)
gsl_eigen_hermv_workspace_swigregister = _gslwrap.gsl_eigen_hermv_workspace_swigregister
gsl_eigen_hermv_workspace_swigregister(gsl_eigen_hermv_workspace)


def gsl_eigen_hermv_alloc(n):
    """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):
    """gsl_eigen_hermv_free(gsl_eigen_hermv_workspace w)"""
    return _gslwrap.gsl_eigen_hermv_free(w)

def gsl_eigen_hermv(A, eval, evec, w):
    """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):
    """Proxy of C gsl_eigen_francis_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_francis_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_francis_workspace, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(gsl_eigen_francis_workspace self) -> gsl_eigen_francis_workspace"""
        this = _gslwrap.new_gsl_eigen_francis_workspace()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_francis_workspace
    __del__ = lambda self: None
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_francis_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_francis_workspace_size_get)
    __swig_getmethods__["max_iterations"] = _gslwrap.gsl_eigen_francis_workspace_max_iterations_get
    if _newclass:
        max_iterations = _swig_property(_gslwrap.gsl_eigen_francis_workspace_max_iterations_get)
    __swig_getmethods__["n_iter"] = _gslwrap.gsl_eigen_francis_workspace_n_iter_get
    if _newclass:
        n_iter = _swig_property(_gslwrap.gsl_eigen_francis_workspace_n_iter_get)
    __swig_getmethods__["n_evals"] = _gslwrap.gsl_eigen_francis_workspace_n_evals_get
    if _newclass:
        n_evals = _swig_property(_gslwrap.gsl_eigen_francis_workspace_n_evals_get)
    __swig_getmethods__["compute_t"] = _gslwrap.gsl_eigen_francis_workspace_compute_t_get
    if _newclass:
        compute_t = _swig_property(_gslwrap.gsl_eigen_francis_workspace_compute_t_get)
    __swig_getmethods__["H"] = _gslwrap.gsl_eigen_francis_workspace_H_get
    if _newclass:
        H = _swig_property(_gslwrap.gsl_eigen_francis_workspace_H_get)
    __swig_getmethods__["Z"] = _gslwrap.gsl_eigen_francis_workspace_Z_get
    if _newclass:
        Z = _swig_property(_gslwrap.gsl_eigen_francis_workspace_Z_get)
gsl_eigen_francis_workspace_swigregister = _gslwrap.gsl_eigen_francis_workspace_swigregister
gsl_eigen_francis_workspace_swigregister(gsl_eigen_francis_workspace)


def gsl_eigen_francis_alloc():
    """gsl_eigen_francis_alloc() -> gsl_eigen_francis_workspace"""
    return _gslwrap.gsl_eigen_francis_alloc()

def gsl_eigen_francis_free(w):
    """gsl_eigen_francis_free(gsl_eigen_francis_workspace w)"""
    return _gslwrap.gsl_eigen_francis_free(w)

def gsl_eigen_francis_T(compute_t, w):
    """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):
    """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):
    """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):
    """Proxy of C gsl_eigen_nonsymm_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_nonsymm_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_nonsymm_workspace, name)
    __repr__ = _swig_repr

    def __init__(self, n):
        """__init__(gsl_eigen_nonsymm_workspace self, size_t const n) -> gsl_eigen_nonsymm_workspace"""
        this = _gslwrap.new_gsl_eigen_nonsymm_workspace(n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_nonsymm_workspace
    __del__ = lambda self: None

    def params(self, compute_t, balance):
        """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)

    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_nonsymm_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_nonsymm_workspace_size_get)
    __swig_getmethods__["diag"] = _gslwrap.gsl_eigen_nonsymm_workspace_diag_get
    if _newclass:
        diag = _swig_property(_gslwrap.gsl_eigen_nonsymm_workspace_diag_get)
    __swig_getmethods__["tau"] = _gslwrap.gsl_eigen_nonsymm_workspace_tau_get
    if _newclass:
        tau = _swig_property(_gslwrap.gsl_eigen_nonsymm_workspace_tau_get)
    __swig_getmethods__["Z"] = _gslwrap.gsl_eigen_nonsymm_workspace_Z_get
    if _newclass:
        Z = _swig_property(_gslwrap.gsl_eigen_nonsymm_workspace_Z_get)
    __swig_getmethods__["do_balance"] = _gslwrap.gsl_eigen_nonsymm_workspace_do_balance_get
    if _newclass:
        do_balance = _swig_property(_gslwrap.gsl_eigen_nonsymm_workspace_do_balance_get)
    __swig_getmethods__["n_evals"] = _gslwrap.gsl_eigen_nonsymm_workspace_n_evals_get
    if _newclass:
        n_evals = _swig_property(_gslwrap.gsl_eigen_nonsymm_workspace_n_evals_get)
    __swig_getmethods__["francis_workspace_p"] = _gslwrap.gsl_eigen_nonsymm_workspace_francis_workspace_p_get
    if _newclass:
        francis_workspace_p = _swig_property(_gslwrap.gsl_eigen_nonsymm_workspace_francis_workspace_p_get)
gsl_eigen_nonsymm_workspace_swigregister = _gslwrap.gsl_eigen_nonsymm_workspace_swigregister
gsl_eigen_nonsymm_workspace_swigregister(gsl_eigen_nonsymm_workspace)


def gsl_eigen_nonsymm_alloc(n):
    """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):
    """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):
    """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):
    """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):
    """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):
    """Proxy of C gsl_eigen_nonsymmv_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_nonsymmv_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_nonsymmv_workspace, name)
    __repr__ = _swig_repr
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_nonsymmv_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_nonsymmv_workspace_size_get)
    __swig_getmethods__["work"] = _gslwrap.gsl_eigen_nonsymmv_workspace_work_get
    if _newclass:
        work = _swig_property(_gslwrap.gsl_eigen_nonsymmv_workspace_work_get)
    __swig_getmethods__["work2"] = _gslwrap.gsl_eigen_nonsymmv_workspace_work2_get
    if _newclass:
        work2 = _swig_property(_gslwrap.gsl_eigen_nonsymmv_workspace_work2_get)
    __swig_getmethods__["work3"] = _gslwrap.gsl_eigen_nonsymmv_workspace_work3_get
    if _newclass:
        work3 = _swig_property(_gslwrap.gsl_eigen_nonsymmv_workspace_work3_get)
    __swig_getmethods__["Z"] = _gslwrap.gsl_eigen_nonsymmv_workspace_Z_get
    if _newclass:
        Z = _swig_property(_gslwrap.gsl_eigen_nonsymmv_workspace_Z_get)
    __swig_getmethods__["nonsymm_workspace_p"] = _gslwrap.gsl_eigen_nonsymmv_workspace_nonsymm_workspace_p_get
    if _newclass:
        nonsymm_workspace_p = _swig_property(_gslwrap.gsl_eigen_nonsymmv_workspace_nonsymm_workspace_p_get)

    def __init__(self):
        """__init__(gsl_eigen_nonsymmv_workspace self) -> gsl_eigen_nonsymmv_workspace"""
        this = _gslwrap.new_gsl_eigen_nonsymmv_workspace()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_nonsymmv_workspace
    __del__ = lambda self: None
gsl_eigen_nonsymmv_workspace_swigregister = _gslwrap.gsl_eigen_nonsymmv_workspace_swigregister
gsl_eigen_nonsymmv_workspace_swigregister(gsl_eigen_nonsymmv_workspace)


def gsl_eigen_nonsymmv_alloc(n):
    """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):
    """gsl_eigen_nonsymmv_free(gsl_eigen_nonsymmv_workspace w)"""
    return _gslwrap.gsl_eigen_nonsymmv_free(w)

def gsl_eigen_nonsymmv(A, eval, evec, w):
    """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):
    """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):
    """Proxy of C gsl_eigen_gensymm_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_gensymm_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_gensymm_workspace, name)
    __repr__ = _swig_repr
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_gensymm_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_gensymm_workspace_size_get)
    __swig_getmethods__["symm_workspace_p"] = _gslwrap.gsl_eigen_gensymm_workspace_symm_workspace_p_get
    if _newclass:
        symm_workspace_p = _swig_property(_gslwrap.gsl_eigen_gensymm_workspace_symm_workspace_p_get)

    def __init__(self):
        """__init__(gsl_eigen_gensymm_workspace self) -> gsl_eigen_gensymm_workspace"""
        this = _gslwrap.new_gsl_eigen_gensymm_workspace()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_gensymm_workspace
    __del__ = lambda self: None
gsl_eigen_gensymm_workspace_swigregister = _gslwrap.gsl_eigen_gensymm_workspace_swigregister
gsl_eigen_gensymm_workspace_swigregister(gsl_eigen_gensymm_workspace)


def gsl_eigen_gensymm_alloc(n):
    """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):
    """gsl_eigen_gensymm_free(gsl_eigen_gensymm_workspace w)"""
    return _gslwrap.gsl_eigen_gensymm_free(w)

def gsl_eigen_gensymm(A, B, eval, w):
    """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):
    """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):
    """Proxy of C gsl_eigen_gensymmv_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_gensymmv_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_gensymmv_workspace, name)
    __repr__ = _swig_repr
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_gensymmv_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_gensymmv_workspace_size_get)
    __swig_getmethods__["symmv_workspace_p"] = _gslwrap.gsl_eigen_gensymmv_workspace_symmv_workspace_p_get
    if _newclass:
        symmv_workspace_p = _swig_property(_gslwrap.gsl_eigen_gensymmv_workspace_symmv_workspace_p_get)

    def __init__(self):
        """__init__(gsl_eigen_gensymmv_workspace self) -> gsl_eigen_gensymmv_workspace"""
        this = _gslwrap.new_gsl_eigen_gensymmv_workspace()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_gensymmv_workspace
    __del__ = lambda self: None
gsl_eigen_gensymmv_workspace_swigregister = _gslwrap.gsl_eigen_gensymmv_workspace_swigregister
gsl_eigen_gensymmv_workspace_swigregister(gsl_eigen_gensymmv_workspace)


def gsl_eigen_gensymmv_alloc(n):
    """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):
    """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):
    """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):
    """Proxy of C gsl_eigen_genherm_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_genherm_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_genherm_workspace, name)
    __repr__ = _swig_repr

    def __init__(self, n):
        """__init__(gsl_eigen_genherm_workspace self, size_t const n) -> gsl_eigen_genherm_workspace"""
        this = _gslwrap.new_gsl_eigen_genherm_workspace(n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_genherm_workspace
    __del__ = lambda self: None
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_genherm_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_genherm_workspace_size_get)
    __swig_getmethods__["herm_workspace_p"] = _gslwrap.gsl_eigen_genherm_workspace_herm_workspace_p_get
    if _newclass:
        herm_workspace_p = _swig_property(_gslwrap.gsl_eigen_genherm_workspace_herm_workspace_p_get)
gsl_eigen_genherm_workspace_swigregister = _gslwrap.gsl_eigen_genherm_workspace_swigregister
gsl_eigen_genherm_workspace_swigregister(gsl_eigen_genherm_workspace)


def gsl_eigen_genherm_alloc(n):
    """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):
    """gsl_eigen_genherm_free(gsl_eigen_genherm_workspace w)"""
    return _gslwrap.gsl_eigen_genherm_free(w)

def gsl_eigen_genherm(A, B, eval, w):
    """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):
    """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):
    """Proxy of C gsl_eigen_genhermv_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_genhermv_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_genhermv_workspace, name)
    __repr__ = _swig_repr

    def __init__(self, n):
        """__init__(gsl_eigen_genhermv_workspace self, size_t const n) -> gsl_eigen_genhermv_workspace"""
        this = _gslwrap.new_gsl_eigen_genhermv_workspace(n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_genhermv_workspace
    __del__ = lambda self: None
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_genhermv_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_genhermv_workspace_size_get)
    __swig_getmethods__["hermv_workspace_p"] = _gslwrap.gsl_eigen_genhermv_workspace_hermv_workspace_p_get
    if _newclass:
        hermv_workspace_p = _swig_property(_gslwrap.gsl_eigen_genhermv_workspace_hermv_workspace_p_get)
gsl_eigen_genhermv_workspace_swigregister = _gslwrap.gsl_eigen_genhermv_workspace_swigregister
gsl_eigen_genhermv_workspace_swigregister(gsl_eigen_genhermv_workspace)


def gsl_eigen_genhermv_alloc(n):
    """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):
    """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):
    """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):
    """Proxy of C gsl_eigen_gen_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_gen_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_gen_workspace, name)
    __repr__ = _swig_repr

    def __init__(self, n):
        """__init__(gsl_eigen_gen_workspace self, size_t const n) -> gsl_eigen_gen_workspace"""
        this = _gslwrap.new_gsl_eigen_gen_workspace(n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_gen_workspace
    __del__ = lambda self: None
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_gen_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_gen_workspace_size_get)
    __swig_getmethods__["work"] = _gslwrap.gsl_eigen_gen_workspace_work_get
    if _newclass:
        work = _swig_property(_gslwrap.gsl_eigen_gen_workspace_work_get)
    __swig_getmethods__["n_evals"] = _gslwrap.gsl_eigen_gen_workspace_n_evals_get
    if _newclass:
        n_evals = _swig_property(_gslwrap.gsl_eigen_gen_workspace_n_evals_get)
    __swig_getmethods__["max_iterations"] = _gslwrap.gsl_eigen_gen_workspace_max_iterations_get
    if _newclass:
        max_iterations = _swig_property(_gslwrap.gsl_eigen_gen_workspace_max_iterations_get)
    __swig_getmethods__["n_iter"] = _gslwrap.gsl_eigen_gen_workspace_n_iter_get
    if _newclass:
        n_iter = _swig_property(_gslwrap.gsl_eigen_gen_workspace_n_iter_get)
    __swig_getmethods__["eshift"] = _gslwrap.gsl_eigen_gen_workspace_eshift_get
    if _newclass:
        eshift = _swig_property(_gslwrap.gsl_eigen_gen_workspace_eshift_get)
    __swig_getmethods__["needtop"] = _gslwrap.gsl_eigen_gen_workspace_needtop_get
    if _newclass:
        needtop = _swig_property(_gslwrap.gsl_eigen_gen_workspace_needtop_get)
    __swig_getmethods__["atol"] = _gslwrap.gsl_eigen_gen_workspace_atol_get
    if _newclass:
        atol = _swig_property(_gslwrap.gsl_eigen_gen_workspace_atol_get)
    __swig_getmethods__["btol"] = _gslwrap.gsl_eigen_gen_workspace_btol_get
    if _newclass:
        btol = _swig_property(_gslwrap.gsl_eigen_gen_workspace_btol_get)
    __swig_getmethods__["ascale"] = _gslwrap.gsl_eigen_gen_workspace_ascale_get
    if _newclass:
        ascale = _swig_property(_gslwrap.gsl_eigen_gen_workspace_ascale_get)
    __swig_getmethods__["bscale"] = _gslwrap.gsl_eigen_gen_workspace_bscale_get
    if _newclass:
        bscale = _swig_property(_gslwrap.gsl_eigen_gen_workspace_bscale_get)
    __swig_getmethods__["H"] = _gslwrap.gsl_eigen_gen_workspace_H_get
    if _newclass:
        H = _swig_property(_gslwrap.gsl_eigen_gen_workspace_H_get)
    __swig_getmethods__["R"] = _gslwrap.gsl_eigen_gen_workspace_R_get
    if _newclass:
        R = _swig_property(_gslwrap.gsl_eigen_gen_workspace_R_get)
    __swig_getmethods__["compute_s"] = _gslwrap.gsl_eigen_gen_workspace_compute_s_get
    if _newclass:
        compute_s = _swig_property(_gslwrap.gsl_eigen_gen_workspace_compute_s_get)
    __swig_getmethods__["compute_t"] = _gslwrap.gsl_eigen_gen_workspace_compute_t_get
    if _newclass:
        compute_t = _swig_property(_gslwrap.gsl_eigen_gen_workspace_compute_t_get)
    __swig_getmethods__["Q"] = _gslwrap.gsl_eigen_gen_workspace_Q_get
    if _newclass:
        Q = _swig_property(_gslwrap.gsl_eigen_gen_workspace_Q_get)
    __swig_getmethods__["Z"] = _gslwrap.gsl_eigen_gen_workspace_Z_get
    if _newclass:
        Z = _swig_property(_gslwrap.gsl_eigen_gen_workspace_Z_get)
gsl_eigen_gen_workspace_swigregister = _gslwrap.gsl_eigen_gen_workspace_swigregister
gsl_eigen_gen_workspace_swigregister(gsl_eigen_gen_workspace)


def gsl_eigen_gen_alloc(n):
    """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):
    """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):
    """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):
    """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):
    """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):
    """Proxy of C gsl_eigen_genv_workspace struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_eigen_genv_workspace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_eigen_genv_workspace, name)
    __repr__ = _swig_repr

    def __init__(self, n):
        """__init__(gsl_eigen_genv_workspace self, size_t const n) -> gsl_eigen_genv_workspace"""
        this = _gslwrap.new_gsl_eigen_genv_workspace(n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_eigen_genv_workspace
    __del__ = lambda self: None
    __swig_getmethods__["size"] = _gslwrap.gsl_eigen_genv_workspace_size_get
    if _newclass:
        size = _swig_property(_gslwrap.gsl_eigen_genv_workspace_size_get)
    __swig_getmethods__["work1"] = _gslwrap.gsl_eigen_genv_workspace_work1_get
    if _newclass:
        work1 = _swig_property(_gslwrap.gsl_eigen_genv_workspace_work1_get)
    __swig_getmethods__["work2"] = _gslwrap.gsl_eigen_genv_workspace_work2_get
    if _newclass:
        work2 = _swig_property(_gslwrap.gsl_eigen_genv_workspace_work2_get)
    __swig_getmethods__["work3"] = _gslwrap.gsl_eigen_genv_workspace_work3_get
    if _newclass:
        work3 = _swig_property(_gslwrap.gsl_eigen_genv_workspace_work3_get)
    __swig_getmethods__["work4"] = _gslwrap.gsl_eigen_genv_workspace_work4_get
    if _newclass:
        work4 = _swig_property(_gslwrap.gsl_eigen_genv_workspace_work4_get)
    __swig_getmethods__["work5"] = _gslwrap.gsl_eigen_genv_workspace_work5_get
    if _newclass:
        work5 = _swig_property(_gslwrap.gsl_eigen_genv_workspace_work5_get)
    __swig_getmethods__["work6"] = _gslwrap.gsl_eigen_genv_workspace_work6_get
    if _newclass:
        work6 = _swig_property(_gslwrap.gsl_eigen_genv_workspace_work6_get)
    __swig_getmethods__["Q"] = _gslwrap.gsl_eigen_genv_workspace_Q_get
    if _newclass:
        Q = _swig_property(_gslwrap.gsl_eigen_genv_workspace_Q_get)
    __swig_getmethods__["Z"] = _gslwrap.gsl_eigen_genv_workspace_Z_get
    if _newclass:
        Z = _swig_property(_gslwrap.gsl_eigen_genv_workspace_Z_get)
    __swig_getmethods__["gen_workspace_p"] = _gslwrap.gsl_eigen_genv_workspace_gen_workspace_p_get
    if _newclass:
        gen_workspace_p = _swig_property(_gslwrap.gsl_eigen_genv_workspace_gen_workspace_p_get)
gsl_eigen_genv_workspace_swigregister = _gslwrap.gsl_eigen_genv_workspace_swigregister
gsl_eigen_genv_workspace_swigregister(gsl_eigen_genv_workspace)


def gsl_eigen_genv_alloc(n):
    """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):
    """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):
    """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):
    """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)

_gslwrap.GSL_EIGEN_SORT_VAL_ASC_swigconstant(_gslwrap)
GSL_EIGEN_SORT_VAL_ASC = _gslwrap.GSL_EIGEN_SORT_VAL_ASC

_gslwrap.GSL_EIGEN_SORT_VAL_DESC_swigconstant(_gslwrap)
GSL_EIGEN_SORT_VAL_DESC = _gslwrap.GSL_EIGEN_SORT_VAL_DESC

_gslwrap.GSL_EIGEN_SORT_ABS_ASC_swigconstant(_gslwrap)
GSL_EIGEN_SORT_ABS_ASC = _gslwrap.GSL_EIGEN_SORT_ABS_ASC

_gslwrap.GSL_EIGEN_SORT_ABS_DESC_swigconstant(_gslwrap)
GSL_EIGEN_SORT_ABS_DESC = _gslwrap.GSL_EIGEN_SORT_ABS_DESC

def gsl_eigen_symmv_sort(eval, evec, sort_type):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """Proxy of C gsl_interp_accel struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gsl_interp_accel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gsl_interp_accel, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(gsl_interp_accel self) -> gsl_interp_accel"""
        this = _gslwrap.new_gsl_interp_accel()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_gsl_interp_accel
    __del__ = lambda self: None

    def reset(self):
        """reset(gsl_interp_accel self) -> gsl_error_flag_drop"""
        return _gslwrap.gsl_interp_accel_reset(self)


    def find(self, x_array, x):
        """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):
        """tocobject(gsl_interp_accel self) -> PyObject *"""
        return _gslwrap.gsl_interp_accel_tocobject(self)

gsl_interp_accel_swigregister = _gslwrap.gsl_interp_accel_swigregister
gsl_interp_accel_swigregister(gsl_interp_accel)

class pygsl_spline(_object):
    """Proxy of C pygsl_spline struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, pygsl_spline, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, pygsl_spline, name)
    __repr__ = _swig_repr

    def __init__(self, T, n):
        """__init__(pygsl_spline self, gsl_interp_type const * T, size_t n) -> pygsl_spline"""
        this = _gslwrap.new_pygsl_spline(T, n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_pygsl_spline
    __del__ = lambda self: None

    def accel_reset(self):
        """accel_reset(pygsl_spline self) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_spline_accel_reset(self)


    def accel_find(self, x):
        """accel_find(pygsl_spline self, double x) -> size_t"""
        return _gslwrap.pygsl_spline_accel_find(self, x)


    def tocobject(self):
        """tocobject(pygsl_spline self) -> PyObject *"""
        return _gslwrap.pygsl_spline_tocobject(self)


    def init(self, xa):
        """init(pygsl_spline self, double const [] xa) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_spline_init(self, xa)


    def eval(self, IN):
        """eval(pygsl_spline self, double IN) -> double"""
        return _gslwrap.pygsl_spline_eval(self, IN)


    def eval_deriv_e(self, IN):
        """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):
        """eval_deriv(pygsl_spline self, double IN) -> double"""
        return _gslwrap.pygsl_spline_eval_deriv(self, IN)


    def eval_deriv2_e(self, IN):
        """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):
        """eval_deriv2(pygsl_spline self, double IN) -> double"""
        return _gslwrap.pygsl_spline_eval_deriv2(self, IN)


    def eval_integ(self, a, b):
        """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):
        """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):
        """eval_e(pygsl_spline self, double IN) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_spline_eval_e(self, IN)


    def eval_vector(self, IN):
        """eval_vector(pygsl_spline self, gsl_vector const * IN) -> PyObject *"""
        return _gslwrap.pygsl_spline_eval_vector(self, IN)


    def eval_e_vector(self, IN):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """name(pygsl_spline self) -> char const *"""
        return _gslwrap.pygsl_spline_name(self)


    def min_size(self):
        """min_size(pygsl_spline self) -> unsigned int"""
        return _gslwrap.pygsl_spline_min_size(self)

pygsl_spline_swigregister = _gslwrap.pygsl_spline_swigregister
pygsl_spline_swigregister(pygsl_spline)

class pygsl_interp(_object):
    """Proxy of C pygsl_interp struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, pygsl_interp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, pygsl_interp, name)
    __repr__ = _swig_repr

    def __init__(self, T, n):
        """__init__(pygsl_interp self, gsl_interp_type const * T, size_t n) -> pygsl_interp"""
        this = _gslwrap.new_pygsl_interp(T, n)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _gslwrap.delete_pygsl_interp
    __del__ = lambda self: None

    def init(self, x, y):
        """init(pygsl_interp self, PyObject * x, PyObject * y) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_interp_init(self, x, y)


    def name(self):
        """name(pygsl_interp self) -> char const *"""
        return _gslwrap.pygsl_interp_name(self)


    def min_size(self):
        """min_size(pygsl_interp self) -> unsigned int"""
        return _gslwrap.pygsl_interp_min_size(self)


    def eval_e(self, x):
        """eval_e(pygsl_interp self, double x) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_interp_eval_e(self, x)


    def eval(self, x):
        """eval(pygsl_interp self, double x) -> double"""
        return _gslwrap.pygsl_interp_eval(self, x)


    def eval_deriv_e(self, x):
        """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):
        """eval_deriv(pygsl_interp self, double x) -> double"""
        return _gslwrap.pygsl_interp_eval_deriv(self, x)


    def eval_deriv2_e(self, x):
        """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):
        """eval_deriv2(pygsl_interp self, double x) -> double"""
        return _gslwrap.pygsl_interp_eval_deriv2(self, x)


    def eval_integ_e(self, a, b):
        """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):
        """eval_integ(pygsl_interp self, double a, double b) -> double"""
        return _gslwrap.pygsl_interp_eval_integ(self, a, b)


    def accel_reset(self):
        """accel_reset(pygsl_interp self) -> gsl_error_flag_drop"""
        return _gslwrap.pygsl_interp_accel_reset(self)


    def accel_find(self, x):
        """accel_find(pygsl_interp self, double x) -> size_t"""
        return _gslwrap.pygsl_interp_accel_find(self, x)

pygsl_interp_swigregister = _gslwrap.pygsl_interp_swigregister
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):
    """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)
# This file is compatible with both classic and new-style classes.


