def d03pfc(npde, ts, tout, pdedef, numflx, bndary, u, npts, x, acc, tsmax, rsave, lrsave, isave, lisave, itask, itrace, outfile, ind, comm, saved, fail):
    """
    General system of convection-diffusion PDEs with source terms in
    conservative form, method of lines, upwind scheme using numerical flux
    function based on Riemann solver, one space variable.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/d03/d03pfc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        ts, u, x, acc, rsave, isave, ind
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        ts, u, x, acc, rsave
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        isave, ind
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _ts = nag_double_type_check_and_cast('d03pfc', ts, 'ts')
    _u = nag_double_type_check_and_cast('d03pfc', u, 'u')
    _x = nag_double_type_check_and_cast('d03pfc', x, 'x')
    _acc = nag_double_type_check_and_cast('d03pfc', acc, 'acc')
    _rsave = nag_double_type_check_and_cast('d03pfc', rsave, 'rsave')
    _isave = nag_integer_type_check_and_cast('d03pfc', isave, 'isave')
    _ind = nag_integer_type_check_and_cast('d03pfc', ind, 'ind')
    d03pfc_ctypes(npde, _ts, tout, pdedef, numflx, bndary, _u, npts, _x, _acc, tsmax, _rsave, lrsave, _isave, lisave, itask, itrace, outfile, _ind, comm, saved, fail)

def f04mcc(selct, n, nrhs, al, lal, d, row, b, tdb, x, tdx, fail):
    """
    Approximate solution of real symmetric positive definite variable-
    bandwidth simultaneous linear equations (coefficient matrix already
    factorized by f01mcc).
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/f04/f04mcc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        al, d, row, b, x
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        al, d, b, x
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        row
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _al = nag_double_type_check_and_cast('f04mcc', al, 'al')
    _d = nag_double_type_check_and_cast('f04mcc', d, 'd')
    _row = nag_integer_type_check_and_cast('f04mcc', row, 'row')
    _b = nag_double_type_check_and_cast('f04mcc', b, 'b')
    _x = nag_double_type_check_and_cast('f04mcc', x, 'x')
    f04mcc_ctypes(selct, n, nrhs, _al, lal, _d, _row, _b, tdb, _x, tdx, fail)

def d06dac(mode, nv, nedge, nelt, ntrans, itype, trans, coori, edgei, conni, cooro, edgeo, conno, itrace, outfile, fail):
    """
    Generates a mesh resulting from an affine transformation of a given
    mesh.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/d06/d06dac.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        itype, trans, coori, edgei, conni, cooro, edgeo, conno
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        trans, coori, cooro
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        itype, edgei, conni, edgeo, conno
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _itype = nag_integer_type_check_and_cast('d06dac', itype, 'itype')
    _trans = nag_double_type_check_and_cast('d06dac', trans, 'trans')
    _coori = nag_double_type_check_and_cast('d06dac', coori, 'coori')
    _edgei = nag_integer_type_check_and_cast('d06dac', edgei, 'edgei')
    _conni = nag_integer_type_check_and_cast('d06dac', conni, 'conni')
    _cooro = nag_double_type_check_and_cast('d06dac', cooro, 'cooro')
    _edgeo = nag_integer_type_check_and_cast('d06dac', edgeo, 'edgeo')
    _conno = nag_integer_type_check_and_cast('d06dac', conno, 'conno')
    d06dac_ctypes(mode, nv, nedge, nelt, ntrans, _itype, _trans, _coori, _edgei, _conni, _cooro, _edgeo, _conno, itrace, outfile, fail)

def e01aec(m, xmin, xmax, x, y, p, itmin, itmax, a, perf, numiter, fail):
    """
    Interpolating functions, polynomial interpolant, data may include
    derivative values, one variable.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/e01/e01aec.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        x, y, p, a, perf, numiter
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        x, y, a, perf
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        p, numiter
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _x = nag_double_type_check_and_cast('e01aec', x, 'x')
    _y = nag_double_type_check_and_cast('e01aec', y, 'y')
    _p = nag_integer_type_check_and_cast('e01aec', p, 'p')
    _a = nag_double_type_check_and_cast('e01aec', a, 'a')
    _perf = nag_double_type_check_and_cast('e01aec', perf, 'perf')
    _numiter = nag_integer_type_check_and_cast('e01aec', numiter, 'numiter')
    e01aec_ctypes(m, xmin, xmax, _x, _y, _p, itmin, itmax, _a, _perf, _numiter, fail)

def f04cgc(order, n, nrhs, d, e, b, pdb, rcond, errbnd, fail):
    """
    Computes the solution, estimated condition number and error-bound to a
    complex Hermitian positive definite tridiagonal system of linear
    equations.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/f04/f04cgc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        d, e, b, rcond, errbnd
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        d, rcond, errbnd
    TypeError will be raised when the following arguments are not of data type
    Complex:
        e, b
    """
    from nag4py.util import nag_complex_type_check_and_cast
    from nag4py.util import nag_double_type_check_and_cast
    _d = nag_double_type_check_and_cast('f04cgc', d, 'd')
    _e = nag_complex_type_check_and_cast('f04cgc', e, 'e')
    _b = nag_complex_type_check_and_cast('f04cgc', b, 'b')
    _rcond = nag_double_type_check_and_cast('f04cgc', rcond, 'rcond')
    _errbnd = nag_double_type_check_and_cast('f04cgc', errbnd, 'errbnd')
    f04cgc_ctypes(order, n, nrhs, _d, _e, _b, pdb, _rcond, _errbnd, fail)

def f12aec(niter, nconv, ritzr, ritzi, rzest, icomm, comm):
    """
    Provides monitoring information for f12abc.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/f12/f12aec.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        niter, nconv, ritzr, ritzi, rzest, icomm, comm
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        ritzr, ritzi, rzest, comm
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        niter, nconv, icomm
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _niter = nag_integer_type_check_and_cast('f12aec', niter, 'niter')
    _nconv = nag_integer_type_check_and_cast('f12aec', nconv, 'nconv')
    _ritzr = nag_double_type_check_and_cast('f12aec', ritzr, 'ritzr')
    _ritzi = nag_double_type_check_and_cast('f12aec', ritzi, 'ritzi')
    _rzest = nag_double_type_check_and_cast('f12aec', rzest, 'rzest')
    _icomm = nag_integer_type_check_and_cast('f12aec', icomm, 'icomm')
    _comm = nag_double_type_check_and_cast('f12aec', comm, 'comm')
    f12aec_ctypes(_niter, _nconv, _ritzr, _ritzi, _rzest, _icomm, _comm)

def g07dbc(sigmaest, n, x, psifun, c, h1, h2, h3, dchi, theta, sigma, maxit, tol, rs, nit, sortedx, fail):
    """
    Robust estimation, M-estimates for location and scale parameters,
    standard weight functions.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/g07/g07dbc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        x, theta, sigma, rs, nit, sortedx
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        x, theta, sigma, rs, sortedx
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        nit
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _x = nag_double_type_check_and_cast('g07dbc', x, 'x')
    _theta = nag_double_type_check_and_cast('g07dbc', theta, 'theta')
    _sigma = nag_double_type_check_and_cast('g07dbc', sigma, 'sigma')
    _rs = nag_double_type_check_and_cast('g07dbc', rs, 'rs')
    _nit = nag_integer_type_check_and_cast('g07dbc', nit, 'nit')
    _sortedx = nag_double_type_check_and_cast('g07dbc', sortedx, 'sortedx')
    g07dbc_ctypes(sigmaest, n, _x, psifun, c, h1, h2, h3, dchi, _theta, _sigma, maxit, tol, _rs, _nit, _sortedx, fail)

def d02gbc(neq, fcnf, fcng, a, b, c, d, gam, mnp, np, x, y, tol, comm, fail):
    """
    Ordinary differential equations solver, for general linear two-point
    boundary value problems, using a finite difference technique with
    deferred correction.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/d02/d02gbc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        c, d, gam, np, x, y
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        c, d, gam, x, y
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        np
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _c = nag_double_type_check_and_cast('d02gbc', c, 'c')
    _d = nag_double_type_check_and_cast('d02gbc', d, 'd')
    _gam = nag_double_type_check_and_cast('d02gbc', gam, 'gam')
    _np = nag_integer_type_check_and_cast('d02gbc', np, 'np')
    _x = nag_double_type_check_and_cast('d02gbc', x, 'x')
    _y = nag_double_type_check_and_cast('d02gbc', y, 'y')
    d02gbc_ctypes(neq, fcnf, fcng, a, b, _c, _d, _gam, mnp, _np, _x, _y, tol, comm, fail)

def d02rac(neq, deleps, fcn, numbeg, nummix, g, init, mnp, np, x, y, tol, abt, jacobf, jacobg, jaceps, jacgep, comm, fail):
    """
    Ordinary differential equations solver, for general nonlinear two-point
    boundary value problems, using a finite difference technique with
    deferred correction.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/d02/d02rac.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        deleps, np, x, y, abt
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        deleps, x, y, abt
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        np
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _deleps = nag_double_type_check_and_cast('d02rac', deleps, 'deleps')
    _np = nag_integer_type_check_and_cast('d02rac', np, 'np')
    _x = nag_double_type_check_and_cast('d02rac', x, 'x')
    _y = nag_double_type_check_and_cast('d02rac', y, 'y')
    _abt = nag_double_type_check_and_cast('d02rac', abt, 'abt')
    d02rac_ctypes(neq, _deleps, fcn, numbeg, nummix, g, init, mnp, _np, _x, _y, tol, _abt, jacobf, jacobg, jaceps, jacgep, comm, fail)

def c09ebc(m, n, ca, pdca, ch, pdch, cv, pdcv, cd, pdcd, b, pdb, icomm, fail):
    """
    Two-dimensional inverse discrete wavelet transform.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/c09/c09ebc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        ca, ch, cv, cd, b, icomm
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        ca, ch, cv, cd, b
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        icomm
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast

    _ca = nag_double_type_check_and_cast("c09ebc", ca, "ca")
    _ch = nag_double_type_check_and_cast("c09ebc", ch, "ch")
    _cv = nag_double_type_check_and_cast("c09ebc", cv, "cv")
    _cd = nag_double_type_check_and_cast("c09ebc", cd, "cd")
    _b = nag_double_type_check_and_cast("c09ebc", b, "b")
    _icomm = nag_integer_type_check_and_cast("c09ebc", icomm, "icomm")
    c09ebc_ctypes(m, n, _ca, pdca, _ch, pdch, _cv, pdcv, _cd, pdcd, _b, pdb, _icomm, fail)

def d02gac(neq, fcn, a, b, u, v, mnp, np, x, y, tol, comm, fail):
    """
    Ordinary differential equations solver, for simple nonlinear two-point
    boundary value problems, using a finite difference technique with
    deferred correction.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/d02/d02gac.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        u, v, np, x, y
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        u, x, y
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        v, np
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _u = nag_double_type_check_and_cast('d02gac', u, 'u')
    _v = nag_integer_type_check_and_cast('d02gac', v, 'v')
    _np = nag_integer_type_check_and_cast('d02gac', np, 'np')
    _x = nag_double_type_check_and_cast('d02gac', x, 'x')
    _y = nag_double_type_check_and_cast('d02gac', y, 'y')
    d02gac_ctypes(neq, fcn, a, b, _u, _v, mnp, _np, _x, _y, tol, comm, fail)

def h02buc(mpsfile, minimize, n, m, a, bl, bu, intvar, cvec, x, options, fail):
    """
    Read MPSX data for IP, LP or QP problem from a file.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/h/h02buc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        n, m, a, bl, bu, cvec, x
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        a, bl, bu, cvec, x
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        n, m
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _n = nag_integer_type_check_and_cast('h02buc', n, 'n')
    _m = nag_integer_type_check_and_cast('h02buc', m, 'm')
    _a = nag_double_type_check_and_cast('h02buc', a, 'a')
    _bl = nag_double_type_check_and_cast('h02buc', bl, 'bl')
    _bu = nag_double_type_check_and_cast('h02buc', bu, 'bu')
    _cvec = nag_double_type_check_and_cast('h02buc', cvec, 'cvec')
    _x = nag_double_type_check_and_cast('h02buc', x, 'x')
    h02buc_ctypes(mpsfile, minimize, _n, _m, _a, _bl, _bu, intvar, _cvec, _x, options, fail)

def g04bcc(nrep, nrow, ncol, y, nt, it, gmean, tmean, table, c, tdc, irep, rpmean, rmean, cmean, r, ef, tol, irdf, fail):
    """
    Analysis of variance, general row and column design, treatment means and
    standard errors.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/g04/g04bcc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        y, it, gmean, tmean, table, c, irep, rpmean, rmean, cmean, r, ef
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        y, gmean, tmean, table, c, rpmean, rmean, cmean, r, ef
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        it, irep
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _y = nag_double_type_check_and_cast('g04bcc', y, 'y')
    _it = nag_integer_type_check_and_cast('g04bcc', it, 'it')
    _gmean = nag_double_type_check_and_cast('g04bcc', gmean, 'gmean')
    _tmean = nag_double_type_check_and_cast('g04bcc', tmean, 'tmean')
    _table = nag_double_type_check_and_cast('g04bcc', table, 'table')
    _c = nag_double_type_check_and_cast('g04bcc', c, 'c')
    _irep = nag_integer_type_check_and_cast('g04bcc', irep, 'irep')
    _rpmean = nag_double_type_check_and_cast('g04bcc', rpmean, 'rpmean')
    _rmean = nag_double_type_check_and_cast('g04bcc', rmean, 'rmean')
    _cmean = nag_double_type_check_and_cast('g04bcc', cmean, 'cmean')
    _r = nag_double_type_check_and_cast('g04bcc', r, 'r')
    _ef = nag_double_type_check_and_cast('g04bcc', ef, 'ef')
    g04bcc_ctypes(nrep, nrow, ncol, _y, nt, _it, _gmean, _tmean, _table, _c, tdc, _irep, _rpmean, _rmean, _cmean, _r, _ef, tol, irdf, fail)

def f01emc(order, n, a, pda, f, comm, iflag, imnorm, fail):
    """
    Function of a real matrix (using user-supplied derivatives).
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/f01/f01emc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        a, iflag, imnorm
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        a, imnorm
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        iflag
    ImportError will be raised for this function on Mac.
    """
    from platform import system
    if system() == 'Darwin':
        from nag4py.util import nagImportErrorMessage
        raise ImportError(nagImportErrorMessage('f01emc', system()))
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _a = nag_double_type_check_and_cast('f01emc', a, 'a')
    _iflag = nag_integer_type_check_and_cast('f01emc', iflag, 'iflag')
    _imnorm = nag_double_type_check_and_cast('f01emc', imnorm, 'imnorm')
    f01emc_ctypes(order, n, _a, pda, f, comm, _iflag, _imnorm, fail)

def f02wgc(order, m, n, k, ncv, av, nconv, sigma, u, pdu, v, pdv, resid, comm, fail):
    """
    Computes leading terms in the singular value decomposition of a real
    general matrix; also computes corresponding left and right singular
    vectors.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/f02/f02wgc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        nconv, sigma, u, v, resid
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        sigma, u, v, resid
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        nconv
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast

    _nconv = nag_integer_type_check_and_cast("f02wgc", nconv, "nconv")
    _sigma = nag_double_type_check_and_cast("f02wgc", sigma, "sigma")
    _u = nag_double_type_check_and_cast("f02wgc", u, "u")
    _v = nag_double_type_check_and_cast("f02wgc", v, "v")
    _resid = nag_double_type_check_and_cast("f02wgc", resid, "resid")
    f02wgc_ctypes(order, m, n, k, ncv, av, _nconv, _sigma, _u, pdu, _v, pdv, _resid, comm, fail)

def g03adc(n, m, z, tdz, isz, nx, ny, wt, e, tde, ncv, cvx, tdcvx, cvy, tdcvy, tol, fail):
    """
    Canonical correlation analysis.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/g03/g03adc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        z, isz, wt, e, ncv, cvx, cvy
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        z, wt, e, cvx, cvy
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        isz, ncv
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _z = nag_double_type_check_and_cast('g03adc', z, 'z')
    _isz = nag_integer_type_check_and_cast('g03adc', isz, 'isz')
    _wt = nag_double_type_check_and_cast('g03adc', wt, 'wt')
    _e = nag_double_type_check_and_cast('g03adc', e, 'e')
    _ncv = nag_integer_type_check_and_cast('g03adc', ncv, 'ncv')
    _cvx = nag_double_type_check_and_cast('g03adc', cvx, 'cvx')
    _cvy = nag_double_type_check_and_cast('g03adc', cvy, 'cvy')
    g03adc_ctypes(n, m, _z, tdz, _isz, nx, ny, _wt, _e, tde, _ncv, _cvx, tdcvx, _cvy, tdcvy, tol, fail)

def f02xec(m, n, a, tda, ncolb, b, tdb, wantq, q, tdq, sv, wantp, ph, tdph, _iter, e, failinfo, fail):
    """
    SVD of complex matrix.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/f02/f02xec.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        a, b, q, sv, ph, _iter, e, failinfo
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        sv, e
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        _iter, failinfo
    TypeError will be raised when the following arguments are not of data type
    Complex:
        a, b, q, ph
    """
    from nag4py.util import nag_complex_type_check_and_cast
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast

    _a = nag_complex_type_check_and_cast("f02xec", a, "a")
    _b = nag_complex_type_check_and_cast("f02xec", b, "b")
    _q = nag_complex_type_check_and_cast("f02xec", q, "q")
    _sv = nag_double_type_check_and_cast("f02xec", sv, "sv")
    _ph = nag_complex_type_check_and_cast("f02xec", ph, "ph")
    __iter = nag_integer_type_check_and_cast("f02xec", _iter, "_iter")
    _e = nag_double_type_check_and_cast("f02xec", e, "e")
    _failinfo = nag_integer_type_check_and_cast("f02xec", failinfo, "failinfo")
    f02xec_ctypes(m, n, _a, tda, ncolb, _b, tdb, wantq, _q, tdq, _sv, wantp, _ph, tdph, __iter, _e, _failinfo, fail)

def g03efc(n, m, x, tdx, isx, nvar, k, cmeans, tdc, wt, inc, nic, css, csw, maxit, fail):
    """
    K-means.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/g03/g03efc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        x, isx, cmeans, wt, inc, nic, css, csw
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        x, cmeans, wt, css, csw
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        isx, inc, nic
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _x = nag_double_type_check_and_cast('g03efc', x, 'x')
    _isx = nag_integer_type_check_and_cast('g03efc', isx, 'isx')
    _cmeans = nag_double_type_check_and_cast('g03efc', cmeans, 'cmeans')
    _wt = nag_double_type_check_and_cast('g03efc', wt, 'wt')
    _inc = nag_integer_type_check_and_cast('g03efc', inc, 'inc')
    _nic = nag_integer_type_check_and_cast('g03efc', nic, 'nic')
    _css = nag_double_type_check_and_cast('g03efc', css, 'css')
    _csw = nag_double_type_check_and_cast('g03efc', csw, 'csw')
    g03efc_ctypes(n, m, _x, tdx, _isx, nvar, k, _cmeans, tdc, _wt, _inc, _nic, _css, _csw, maxit, fail)

def f12fcc(nconv, d, z, sigma, resid, v, comm, icomm, fail):
    """
    Selected eigenvalues and, optionally, eigenvectors of a real symmetric
    sparse eigenproblem, postprocessing for f12fbc.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/f12/f12fcc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        nconv, d, z, resid, v, comm, icomm
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        d, z, resid, v, comm
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        nconv, icomm
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _nconv = nag_integer_type_check_and_cast('f12fcc', nconv, 'nconv')
    _d = nag_double_type_check_and_cast('f12fcc', d, 'd')
    _z = nag_double_type_check_and_cast('f12fcc', z, 'z')
    _resid = nag_double_type_check_and_cast('f12fcc', resid, 'resid')
    _v = nag_double_type_check_and_cast('f12fcc', v, 'v')
    _comm = nag_double_type_check_and_cast('f12fcc', comm, 'comm')
    _icomm = nag_integer_type_check_and_cast('f12fcc', icomm, 'icomm')
    f12fcc_ctypes(_nconv, _d, _z, sigma, _resid, _v, _comm, _icomm, fail)

def g03acc(weight, n, m, x, tdx, isx, nx, ing, ng, wt, nig, cvm, tdcvm, e, tde, ncv, cvx, tdcvx, tol, irankx, fail):
    """
    Canonical variate analysis.
    http://www.nag.co.uk/numeric/CL/nagdoc_cl23/html/g03/g03acc.html

    TypeError will be raised when the following arguments are not instances
    of numpy.ndarray:
        x, isx, ing, wt, nig, cvm, e, ncv, cvx, irankx
    TypeError will be raised when the following arguments are not of data type
    numpy.float:
        x, wt, cvm, e, cvx
    TypeError will be raised when the following arguments are not of data type
    numpy.int32 or numpy.int64:
        isx, ing, nig, ncv, irankx
    """
    from nag4py.util import nag_double_type_check_and_cast
    from nag4py.util import nag_integer_type_check_and_cast
    _x = nag_double_type_check_and_cast('g03acc', x, 'x')
    _isx = nag_integer_type_check_and_cast('g03acc', isx, 'isx')
    _ing = nag_integer_type_check_and_cast('g03acc', ing, 'ing')
    _wt = nag_double_type_check_and_cast('g03acc', wt, 'wt')
    _nig = nag_integer_type_check_and_cast('g03acc', nig, 'nig')
    _cvm = nag_double_type_check_and_cast('g03acc', cvm, 'cvm')
    _e = nag_double_type_check_and_cast('g03acc', e, 'e')
    _ncv = nag_integer_type_check_and_cast('g03acc', ncv, 'ncv')
    _cvx = nag_double_type_check_and_cast('g03acc', cvx, 'cvx')
    _irankx = nag_integer_type_check_and_cast('g03acc', irankx, 'irankx')
    g03acc_ctypes(weight, n, m, _x, tdx, _isx, nx, _ing, ng, _wt, _nig, _cvm, tdcvm, _e, tde, _ncv, _cvx, tdcvx, tol, _irankx, fail)