Python util.nag_double_type_check_and_cast函数代码示例

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)