Chapter Contents
NAG Toolbox

Advice on Replacement Calls for Withdrawn/Superseded Routines

E04 – Minimizing or Maximizing a Function

e04cc

Scheduled for withdrawal at Mark 24.
Replaced by e04cb.
Old: [x, f, user, ifail] = e04cc(x, tol, funct, monit2, maxcal, 'n', n, 'user', user)
New: [x, f, user, ifail] = e04cb(x, tolf, tolx, funct, monit3, maxcal, 'n', n, 'user', user) 
The tolerance tol is now called tolf.
The new monitoring function monit includes two extra parameters compared with its old threadsafe counterpart. The new function can be derived from the old as follows:
       function user = monit3(fmin, fmax, sim, n, ncall, serror, vratio, user)
       user = monit2(fmin,fmax,sim,n,n+1,ncall,user);
%      Add code here to monitor the values of serror and vratio, if necessary

e04un

Withdrawn at Mark 22.
Replaced by e04us.
The specification of the subroutine objfun must also be changed as follows:
Old: [iter, istate, c, cjac, f, fjac, clamda, objf, r, x, user, ...
      ifail] = ...
     e04un(a, bl, bu, y, confun, objfun, istate, cjac, fjac, clamda, r, ...
           x, 'm', m, 'n', n, 'nclin', nclin, 'ncnln', ncnln, 'user', user)
New: [iter, istate, c, cjac, f, fjac, clamda, objf, r, x, user, ...
      lwsav, iwsav, rwsav, ifail] = ...
     e04us(a, bl, bu, y, confun, objfun, istate, cjac, fjac, clamda, r, ...
           x, lwsav, iwsav, rwsav, 'm', m, 'n', n, 'nclin', nclin, ...
           'ncnln', ncnln, 'user', user)
The specification of the subroutine objfun must also be changed as follows:
Old: [mode, f, fjac, user] = objfun(mode, m, n, ldfj, x, fjac, nstate, user)
New: [mode, f, fjac, user] = objfun(mode, m, n, ldfj, needfi, x, fjac, nstate, user) 
See the routine documents for further information.

F02 – Eigenvalues and Eigenvectors

f02bj

Scheduled for withdrawal at Mark 23.
Replaced by f08wa.
Old: [a, b, alfr, alfi, beta, v, iter, ifail] = f02bj(a, b, eps1, matv, 'n', n);
New: if matv 
       jobvr = 'v';
     else
       jobvr = 'n';
     end
     [a, b, alfr, alfi, beta, vl, vr, info] = f08wa('n', jobvr, a, b, 'n', n);

f02ea

Scheduled for withdrawal at Mark 23.
Replaced by f08pa.
Old: [a, wr, wi, z, ifail] = f02ea(job, a, 'n', n)
New: if (job == 'n')
       jobvs = 'n';
     else
       jobvs = 'v';
     end
     [a, sdim, wr, wi, vs, info] = f08pa(jobvs, 'n', select, a, 'n', n);

     function [result] = select(wr, wi)
        result = true;

f02eb

Scheduled for withdrawal at Mark 23.
Replaced by f08na.
Old: [a, wr, wi, vr, vi, ifail] = f02eb(job, a, 'n', n);
New: if (job == 'n')
       jobvr = 'n';
     else
       jobvr = 'v';
     end
     [a, wr, wi, vl, vr, info] = f08na('n', jobvr, a, 'n', n);  
Note that Eigenvector infomation is stored differently in vr. See the routine documents for further details.

f02fa

Scheduled for withdrawal at Mark 23.
Replaced by f08fa.
Old: [a, w, ifail] = f02fa(job, uplo, a, 'n', n);
New: [a, w, info] = f08fa(jobz, uplo, a, 'n', n);

f02fc

Scheduled for withdrawal at Mark 23.
Replaced by f08fb.
Old: [a, m, w, z, ifail] = f02fc(job, range, uplo, a, wl, wu, il, iu, mest, 'n', n);
New: [a, m, w, z, jfail, info] = f08fb(job, range, uplo, a, wl, wu, il, iu, abstol, 'n', n);

f02fd

Scheduled for withdrawal at Mark 23.
Replaced by f08sa.
Old: [a, b, w, ifail] = f02fd(itype, job, uplo, a, b, 'n', n);
New: [a, b, w, info] = f08sa(itype, job, uplo, a, b, 'n', n);

f02fh

Scheduled for withdrawal at Mark 23.
Replaced by f08ua.
Old: [a, b, d, ifail] = f02fh(ma, a, mb, b, 'n', n);
New: [a, b, d, z, info] = f08ua('n', 'u', ma, mb, a, b, 'n', n);
Note that the eigenvalues appear in reverse order.

f02ga

Scheduled for withdrawal at Mark 23.
Replaced by f08pn.
Old: [a, w, z, ifail] = f02ga(job, a, 'n', n);
New: if (job == 'n')
       jobvs = 'n';
     else
       jobvs = 'v';
     end
     [a, sdim, w, z, info] = f08pn(jobvs, 'n', select, a, 'n', n);

     function [result] = select(c)
       result = true;

f02gb

Scheduled for withdrawal at Mark 23.
Replaced by f08nn.
Old: [a, w, v, ifail] = f02gb(job, a, 'n', n);
New: [a, w, vl, v, info] = f08nn('n', job, a, 'n', n);

f02gj

Scheduled for withdrawal at Mark 23.
Replaced by f08wn.
Old: [ar, ai, br, bi, alfr, alfi, beta, vr, vi, iter, ifail] = ...
                           f02gj(ar, ai, br, bi, eps1, matv, 'n', n);
New: if matv
       jobvr = 'v';
     else
       jobvr = 'n';
     end
     [a, b, alpha, beta1, vl, v, info] = ...
                   f08wn('n', jobvr, complex(ar,ai), complex(br,bi), 'n', n);
     % Note that the results are single complex objects, rather than the
     % real, imaginary pairs returned by f02gj

f02ha

Scheduled for withdrawal at Mark 23.
Replaced by f08fn.
Old: [a, w, ifail] = f02ha(job, uplo, a, 'n', n);
New: [a, w, info] = f08fn(job, uplo, a, 'n', n);

f02hc

Scheduled for withdrawal at Mark 23.
Replaced by f08fp.
Old: [a, m, w, z, ifail] = f02hc(job, range, uplo, a, wl, wu, il, iu, mest, 'n', n);
New: [a, m, w, z, jfail, info] = f08fp(job, range, uplo, a, wl, wu, il, iu, abstol, 'n', n); 

f02hd

Scheduled for withdrawal at Mark 23.
Replaced by f08sn.
Old: [a, b, w, ifail] = f02hd(itype, job, uplo, a, b, 'n', n);
New: [a, b, w, info] = f08sn(itype, job, uplo, a, b, 'n', n);

f02we

Scheduled for withdrawal at Mark 23.
Replaced by f08kb.
Old: [a, b, q, sv, pt, work, ifail] = f02we(a, b, wantq, wantp, 'm', m, 'n', n, 'ncolb', ncolb);
New: if wantq 
       jobu = 'a';
     else
       jobu = 'n';
     end 
     if wantp 
       jobvt = 'a';
     else
       jobvt = 'n';
     end 
     [a, sv, u, pt, info] = f08kb(jobu, jobvt, a, 'm', m, 'n', n);
Note that the facility to return QT × B is not provided.

f02xe

Scheduled for withdrawal at Mark 23.
Replaced by f08kp.
Old: [a, b, q, sv, ph, rwork, ifail] = f02xe(a, b, wantq, wantp, 'm', m, 'n', n, 'ncolb', ncolb);
New: if wantq
       jobu = 'a';
     else
       jobu = 'n';
     end
     if wantp
       jobvt = 'a';
     else
       jobvt = 'n';
     end
     [a, sv, q, ph, info] = f08kp(jobu, jobvt, a, 'm', m, 'n', n);
Note that the facility to return QH × B is not provided.

F04 – Simultaneous Linear Equations

f04aa

Scheduled for withdrawal at Mark 23.
Replaced by f07aa.
Old: [a, c, ifail] = f04aa(a, b, 'n', n, 'm', m);
New: [a, ipiv, b, info] = f07aa(a, b, 'n', n, 'nrhs_p', nrhs_p);
Note that the answer is now in b.

f04ac

Scheduled for withdrawal at Mark 23.
Replaced by f07ha.
Old: [c, rl, ifail] = f04ac(a, b, m, 'n', n, 'ir', ir, 'm1', m1);
New: [ab, b, info] = f07ha('u', n, ab, b, 'n', n, 'nrhs_p', nrhs_p) ;
Note that a and ab are stored differently. With the 'U' option, ab may be regarded as the transpose of a. Note also that the answer is now stored in b.

f04ad

Scheduled for withdrawal at Mark 23.
Replaced by f07an.
Old: [a, c, ifail] = f04ad(a, b, 'n', n, 'm', m);
New: [a, ipiv, b, info] = f07an(a, b, 'n', n, 'nrhs_p', nrhs_p);
Note that the answer is now in b.

f04ar

Scheduled for withdrawal at Mark 23.
Replaced by f07aa.
Old: [a, c, ifail] = f04ar(a, b, 'n', n);
New; [a, ipiv, b, info] = f07aa(a, b, 'n', n, 'nrhs_p', nrhs_p);
Note that the answer is now in b.

f04ea

Scheduled for withdrawal at Mark 23.
Replaced by f07ca.
Old: [d, du, dl, b, ifail] = f04ea(d, du, dl, b, 'n', n);
New: [dl, d, du, b, info] = f07ca(dl(2), d, du(2), b, 'n', n, 'nrhs_p', nrhs_p);
Note that the answer is now in b.

f04fa

Scheduled for withdrawal at Mark 23.
Replaced by f07ja, f07jd and f07je.
Old: [d, e, b, ifail] = f04fa(job, d, e, b, 'n', n);
       [d, e, info] = f07jd(d, e, 'n', n);
New: if (job == 0)
       [d, e, b, info] = f07ja(d, e, b, 'n', n, 'nrhs_p', nrhs_p);
     else
       % Have already done
       % [d, e, info] = f07jd(d, e, 'n', n);
       [b, info] = f07je(d, e, b, 'n', n, 'nrhs_p', nrhs_p);
     end
Note that the answer is now in b.

f04ja

Scheduled for withdrawal at Mark 23.
Replaced by f08ka.
Old: [a, b, sigma, irank, work, ifail] = f04ja(a, b, tol, lwork, 'm', m, 'n', n);
New: [a, b, s, rank, info] = f08ka(a, b, rcond, 'm', m, 'n', n, 'nrhs_p', nrhs_p);
Note that the answer is now in b, singular values are in s instead of work, and the standard error is not computed.

f04jd

Scheduled for withdrawal at Mark 23.
Replaced by f08ka.
Old: [a, b, sigma, irank, work, ifail] = f04jd(a, b, tol, lwork, 'm', m, 'n', n);
New: [a, b, s, irank, info] = f08ka(a, b, rcond, 'm', m, 'n', n, 'nrhs_p', nrhs_p);
Note that the answer is now in b, singular values are in s instead of work, and the standard error is not computed.

f04jl

Scheduled for withdrawal at Mark 23.
Replaced by f08zb.
Old: [a, b, d, x, y, ifail] = f04jl(a, b, d, 'm', m, 'n', n, 'p', p);
New: [a, b, d, x, y, info] = f08zb(a, b, d, 'm', m, 'n', n, 'p', p);

f04jm

Scheduled for withdrawal at Mark 23.
Replaced by f08za.
Old: [a, b, c, d, x, ifail] = f04jm(a, b, c, d, 'm', m, 'n', n, 'p', p);
New: [a, b, c, d, x, info] = f08za(a, b, c, d, 'm', m, 'n', n, 'p', p);

f04kl

Scheduled for withdrawal at Mark 23.
Replaced by f08zp.
Old: [a, b, d, x, y, ifail] = f04kl(a, b, d, 'm', m, 'n', n, 'p', p);
New: [a, b, d, x, y, info] = f08zp(a, b, d, 'm', m, 'n', n, 'p', p);

f04km

Scheduled for withdrawal at Mark 23.
Replaced by f08zn.
Old: [a, b, c, d, x, ifail] = f04km(a, b, c, d, 'm', m, 'n', n, 'p', p);
New: [a, b, c, d, x, info] = f08zn(a, b, c, d, 'm', m, 'n', n, 'p', p);

F11 – Large Scale Linear Systems

f11ga

Withdrawn at Mark 22.
Replaced by f11gd.
Old: [lwreq, ifail] = f11ga(method, precon, n, tol, maxitn, anorm, sigmax, ...
                            maxits, monit, 'sigcmp', sigcmp, 'norm_p', norm_p, ...
                            'weight', weight, 'iterm', iterm, 'sigtol', sigtol)
New: [lwreq, work, ifail] = f11gd(method, precon, n, tol, maxitn, anorm, sigmax, ...
                                  maxits, monit, 'sigcmp', sigcmp, 'norm_p', norm_p, ...
                                  'weight', weight, 'iterm', iterm, 'sigtol', sigtol) 
f11gd returns an additional parameter, work.
See the routine document for further information.

f11gb

Withdrawn at Mark 22.
Replaced by f11ge.
Old: [irevcm, u, v, work, ifail] = f11gb(irevcm, u, v, work, 'n', n, 'lwork', lwork)
New: [irevcm, u, v, work, ifail] = f11ge(irevcm, u, v, wgt, work);
wgt must be a one-dimensional double array of length at least n  (the order of the matrix) if weights are to be used in the termination criterion, and 1  otherwise. Note that the call to f11ge requires the weights to be supplied in wgt(1 : n)  rather than work(1 : n) .

f11gc

Withdrawn at Mark 22.
Replaced by f11gf.
Old: [itn, stplhs, stprhs, anorm, sigmax, its, sigerr, ifail] = f11gc();
New: [itn, stplhs, stprhs, anorm, sigmax, its, sigerr, ifail] = f11gf(work);
f11gf takes an additional parameter, work.
See the routine document for further information.

G05 – Random Number Generators

g05ca

Withdrawn at Mark 22.
Replaced by g05sa.
Old: for i=1:n
       x(i) = g05ca;
     end
New: [state, x, ifail] = g05sa(n, state);
The integer array state in the call to g05sa contains information on the base generator being used. This array must have been initialized prior to calling g05sa with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sa is likely to be different to those produced by g05ca.

g05cb

Withdrawn at Mark 22.
Replaced by g05kf.
Old: g05cb(ii);
New: genid = int32(ii);
     subid = int32(1);
     seed  = [int32(1)];
     [state, ifail] = g05kf(genid, subid, seed);
The integer array state in the call to g05kf contains information on the base generator being used. The base generator is chosen via the integer parameters genid and subid. The required length of the array state depends on the base generator chosen. Due to changes in the underlying code a sequence of values produced by using a random number generator initialized via a call to g05kf is likely to be different to a sequence produced by a generator initialized by g05cb, even if the same value for ii is used.

g05cc

Withdrawn at Mark 22.
Replaced by g05kg.
Old: g05cc;
New: genid = int32(1);
     subid = int32(1);
     [state, ifail] = g05kg(genid, subid);
The integer array state in the call to g05kg contains information on the base generator being used. The base generator is chosen via the integer parameters genid and subid.

g05cf

Withdrawn at Mark 22.
.
Old: [ia, xi, ifail] = g05cf(ni, nx);
New: cstate = state;
The state of the base generator for the group of routines g05kf, g05kg, g05kh, g05kj, g05nc, g05nd, g05pdg05pz, g05rcg05rz, G05S and G05T can be saved by simply creating a local copy of the array state. The first element of the state array contains the number of elements that are used by the random number generating routines, therefore either this number of elements can be copied, or the whole array (as defined in the calling program).

g05cg

Withdrawn at Mark 22.
.
Old: [ifail] = g05cg(ia, xa, 'ni', ni, 'nx', nx)
New: lstate = cstate(1);
     state(1:lstate) = cstate(1:lstate);
The state of the base generator for the group of routines g05kf, g05kg, g05kh, g05kj, g05nc or g05nd, g05pdg05pz, g05rcg05rz, G05S and G05T can be restored by simply copying back the previously saved copy of the state array. The first element of the state array contains the number of elements that are used by the random number generating routines, therefore either this number of elements can be copied, or the whole array (as defined in the calling program).

g05da

Withdrawn at Mark 22.
Replaced by g05sq.
Old: for i=1:n
       x(i) = g05da(aa,bb);
     end
New: [a, b] = sort([aa, bb]);
     [state, x, ifail] = g05sq(n, a, b, state);
The old routine g05da returns a single variate at a time, whereas the new routine g05sq returns a vector of N values in one go. In g05sq the minimum value must be held in the parameter a and the maximum in parameter b, therefore a < b. This was not the case for the equivalent parameters in g05da.
The integer array state in the call to g05sq contains information on the base generator being used. This array must have been initialized prior to calling g05sq with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sq is likely to be different to those produced by g05da.

g05db

Withdrawn at Mark 22.
Replaced by g05sf.
Old: for i=1:n
       x(i) = g05db(a);
     end
New: [state, x, ifail] = g05sf(n, abs(a), state);
The old routine g05db returns a single variate at a time, whereas the new routine g05sf returns a vector of n values in one go. In g05sf parameter a must be non-negative, this was not the case for the equivalent parameter in g05db.
The integer array state in the call to g05sf contains information on the base generator being used. This array must have been initialized prior to calling g05sf with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sf is likely to be different to those produced by g05db.

g05dc

Withdrawn at Mark 22.
Replaced by g05sl.
Old: for  i=1:n
       x(i) = g05dc(a,b);
     end
New: [state, x, ifail] = g05sl(n, a, abs(b), state);
The old routine g05dc returns a single variate at a time, whereas the new routine g05sl returns a vector of n values in one go. In g05sl the spread (parameter a) must be positive, this was not the case for the equivalent parameters in g05dc.
The integer array state in the call to g05sl contains information on the base generator being used. This array must have been initialized prior to calling g05sl with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sl is likely to be different to those produced by g05dc.

g05dd

Withdrawn at Mark 22.
Replaced by g05sk.
Old: for i=1:n
       x(i) = g05dd(xmu, sd);
     end
New: [state, x, ifail] = g05sk(n, xmu, sd^2, state);
The old routine g05dd returns a single variate at a time, whereas the new routine g05sk returns a vector of n values in one go. g05sk expects the variance of the normal distribution (parameter var), compared to g05dd which expected the standard deviation.
The integer array state in the call to g05sk contains information on the base generator being used. This array must have been initialized prior to calling g05sk with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sk is likely to be different to those produced by g05dd.

g05de

Withdrawn at Mark 22.
Replaced by g05sm.
Old: for i=1:n
       x(i) = g05de(xmu, sd);
     end
New: [state, x, ifail] = g05sm(n, xmu, sd^2, state);
The old routine g05de returns a single variate at a time, whereas the new routine g05sm returns a vector of n values in one go. g05sm expects the variance of the corresponding normal distribution (parameter var), compared to g05de which expected the standard deviation.
The integer array state in the call to g05sm contains information on the base generator being used. This array must have been initialized prior to calling g05sm with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sm is likely to be different to those produced by g05de.

g05df

Withdrawn at Mark 22.
Replaced by g05sc.
Old: for i=1:n
       x(i) = g05df(xmed, b);
     end
New: [state, x, ifail] = g05sc(n, xmed, abs(b), state);
The old routine g05df returns a single variate at a time, whereas the new routine g05sc returns a vector of n values in one go. g05sc expects the semi-interquartile range (parameter semiqr) to be non-negative, this was not the case for the equivalent parameter in g05df.
The integer array state in the call to g05sc contains information on the base generator being used. This array must have been initialized prior to calling g05sc with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sc is likely to be different to those produced by g05df.

g05dh

Withdrawn at Mark 22.
Replaced by g05sd.
Old: for i=1:n
       [x(i), ifail] = g05dh(df);
     end
New: [state, x, ifail] = g05sd(n, df, state);
The old routine g05dh returns a single variate at a time, whereas the new routine g05sd returns a vector of n values in one go.
The integer array state in the call to g05sd contains information on the base generator being used. This array must have been initialized prior to calling g05sd with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sd is likely to be different to those produced by g05dh.

g05dj

Withdrawn at Mark 22.
Replaced by g05sn.
Old: for i=1:n 
       [x(i), ifail] = g05dj(df);
     end
New: [state, x, ifail] = g05sn(n, df, state);
The old routine g05dj returns a single variate at a time, whereas the new routine g05sn returns a vector of n values in one go.
The integer array state in the call to g05sn contains information on the base generator being used. This array must have been initialized prior to calling g05sn with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sn is likely to be different to those produced by g05dj.

g05dk

Withdrawn at Mark 22.
Replaced by g05sh.
Old: for i=1:n
       [x(i), ifail] = g05df(df1, df2);
     end
New: [state, x, ifail] = g05sh(n, df1, df2, state);
The old routine g05dk returns a single variate at a time, whereas the new routine g05sh returns a vector of n values in one go.
The integer array state in the call to g05sh contains information on the base generator being used. This array must have been initialized prior to calling g05sh with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sh is likely to be different to those produced by g05dk.

g05dp

Withdrawn at Mark 22.
Replaced by g05ss.
Old: for i=1:n
       [x(i), ifail] = g05pd(a, b);
     end
New: [state, x, ifail] = g05ss(n, a, b, state);
The old routine g05dp returns a single variate at a time, whereas the new routine g05ss returns a vector of n values in one go.
The integer array state in the call to g05ss contains information on the base generator being used. This array must have been initialized prior to calling g05ss with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05ss is likely to be different to those produced by g05dp.

g05dr

Withdrawn at Mark 22.
Replaced by g05tk.
Old: for i=1:n
       [x(i), ifail] = g05dr(lambda);
     end
New: [r, state, x, ifail] = g05tj(int32(3), n, lambda, r, state);
The old routine g05dr returns a single variate at a time, whereas the new routine g05tj returns a vector of n values in one go. For efficiency, the new routine can make use of a reference vector, r. If, as in this case, the integer parameter mode is set to 3, the real reference vector r is not referenced .
The integer array state in the call to g05tj contains information on the base generator being used. This array must have been initialized prior to calling g05tj with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05tj is likely to be different to those produced by g05dr.

g05dy

Withdrawn at Mark 22.
Replaced by g05tl.
Old: for i=1:n
       x(i) = g05dy(aa, bb);
     end
New: [a, b] = sort([aa, bb]);
     [state, x, ifail] = g05tl(n, a, b, state);
The old routine g05dy returns a single variate at a time, whereas the new routine g05tl returns a vector of n values in one go. In g05tl the minimum value must be held in the parameter a and the maximum in parameter b, therefore ab. This was not the case for the equivalent parameters in g05dy.
The integer array state in the call to g05tl contains information on the base generator being used. This array must have been initialized prior to calling g05tl with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05tl is likely to be different to those produced by g05dy.

g05dz

Withdrawn at Mark 22.
Replaced by g05tb.
Old: for i=1:n
       x(i) = g05dz(pp);
     end
New: p = max(0, min(pp, 1));
     [state, x, ifail] = g05tb(n, p, state);
The old routine g05dz returns a single variate at a time, whereas the new routine g05tb returns a vector of n values in one go. The double parameter p in g05tb must not be less than zero or greater than one, this was not the case for the equivalent parameter in g05dz.
The integer array state in the call to g05tb contains information on the base generator being used. This array must have been initialized prior to calling g05tb with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05tb is likely to be different to those produced by g05dz.

g05ea

Withdrawn at Mark 22.
Replaced by g05rz.
Old: [r1, ifail] = g05ea(xmu, c, eps, lr1, 'n', m);
New: [r, state, x, ifail] = g05rz(int32(0), n, xmu, c, r, state, 'm', m, 'lr', lr);

The old routine g05ea sets up a reference vector for use by g05ez. The functionality of both these routines has been combined into the single new routine g05rz. Setting the integer parameter mode = 0 in the call to g05rz only sets up the double reference vector r and hence mimics the functionality of g05ea.
The length of the double reference vector, r, in g05rz must be at least m × (m + 1) + 1. This is longer than the equivalent parameter in g05ea. When mode = 0, the integer array state in the call to g05rz need not be set.

g05eb

Withdrawn at Mark 22.
Replaced by g05tl.
There is no direct replacement for routine g05eb. g05eb sets up a reference vector for use by g05ey, this reference vector is no longer required. The replacement routine for g05ey is g05tl.

g05ec

Withdrawn at Mark 22.
Replaced by g05tj.
Old: [r1, ifail] = g05ec(lambda, lr1);
     for i=1:n
       x(i) = g05ey(r1);
     end
New: [r, state, x, ifail] = g05tj(int32(2), n, lambda, r, state);
The old routine g05ec sets up a reference vector for use by g05ey. The replacement routine g05tj is now used to both set up a reference vector and generate the required variates. Setting the integer parameter mode = 0 in the call to g05tj sets up the double reference vector r and hence mimics the functionality of g05ec. Setting mode = 1 generates a series of variates from a reference vector mimicking the functionality of g05ey for this particular distribution. Setting mode = 2 initializes the reference vector and generates the variates in one go.
The routine g05ey returns a single variate at a time, whereas the new routine g05tj returns a vector of n values in one go.
The length of the double reference vector, r, in g05tj, needs to be a different length to the equivalent parameter in g05ec, see the documentation for more details.
The integer array state in the call to g05tj contains information on the base generator being used. This array must have been initialized prior to calling g05tj with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05tj is likely to be different to those produced by a combination of g05ec and g05ey.

g05ed

Withdrawn at Mark 22.
Replaced by g05ta.
Old: [r1, ifail] = g05ed(m, p, lr1);
     for i=1:n
       x(i) = g05ey(r1);
     end
New: [r, state, x, ifail] = g05ta(int32(2), n, m, p, r, state);
The old routine g05ed sets up a reference vector for use by g05ey. The replacement routine g05ta is now used to both set up a reference vector and generate the required variates. Setting the integer parameter mode = 0 in the call to g05ta sets up the double reference vector r and hence mimics the functionality of g05ed. Setting mode = 1 generates a series of variates from a reference vector mimicking the functionality of g05ey for this particular distribution. Setting mode = 2 initializes the reference vector and generates the variates in one go.
The routine g05ey returns a single variate at a time, whereas the new routine g05ta returns a vector of n values in one go.
The length of the double reference vector, r, in g05ta, needs to be a different length to the equivalent parameter in g05ed, see the documentation for more details.
The integer array state in the call to g05ta contains information on the base generator being used. This array must have been initialized prior to calling g05ta with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05ta is likely to be different to those produced by a combination of g05ed and g05ey.

g05ee

Withdrawn at Mark 22.
Replaced by g05th.
Old: [r1, ifail] = g05ee(m, p, lr1);
     for i=1:n
       x(i) = g05ey(r1);
     end
New: [r, state, x, ifail] = g05th(int32(2), n, m, p, r, state);
The old routine g05ee sets up a reference vector for use by g05ey. The replacement routine g05th is now used to both set up a reference vector and generate the required variates. Setting the integer parameter mode = 0 in the call to g05th sets up the double reference vector r and hence mimics the functionality of g05ee. Setting mode = 1 generates a series of variates from a reference vector mimicking the functionality of g05ey for this particular distribution. Setting mode = 2 initializes the reference vector and generates the variates in one go.
The routine g05ey returns a single variate at a time, whereas the new routine g05th returns a vector of n values in one go.
The length of the double reference vector, r, in g05th, needs to be a different length to the equivalent parameter in g05ee, see the documentation for more details.
The integer array state in the call to g05th contains information on the base generator being used. This array must have been initialized prior to calling g05th with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05th is likely to be different to those produced by a combination of g05ee and g05ey.

g05ef

Withdrawn at Mark 22.
Replaced by g05te.
Old: [r1, ifail] = g05ef(ns, m, np, lr1);
     for i=1:n
       x(i) = g05ey(r1);
     end
New: [r, state, x, ifail] = g05te(int32(2), n, ns, np, m, r, state);
The old routine g05ef sets up a reference vector for use by g05ey. The replacement routine g05te is now used to both set up a reference vector and generate the required variates. Setting the integer parameter mode = 0 in the call to g05te sets up the double reference vector r and hence mimics the functionality of g05ef. Setting mode = 1 generates a series of variates from a reference vector mimicking the functionality of g05ey for this particular distribution. Setting mode = 2 initializes the reference vector and generates the variates in one go.
The routine g05ey returns a single variate at a time, whereas the new routine g05te returns a vector of n values in one go.
The length of the double reference vector, r, in g05te, needs to be a different length to the equivalent parameter in g05ef, see the documentation for more details.
The integer array state in the call to g05te contains information on the base generator being used. This array must have been initialized prior to calling g05te with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05te is likely to be different to those produced by a combination of g05ef and g05ey.

g05eg

Withdrawn at Mark 22.
Replaced by g05ph.
Old: [r, var, ifail] = g05eg(e, a, b, nr, 'na', na, 'nb', nb)
New: theta = zeros(iq, 1);
     avar = b(1)^2;
     if avar > 0
       for i=1:nb-1
         theta(i) = -b(i+1)/b(1);
       end
     end
     mode = int32(0);
     [r, state, var, x, ifail] = g05ph(mode, n, e, na, a, nb-1, theta, avar, r, state);
The double vector theta must be of length at least iq = nb - 1.
The old routine g05eg sets up a reference vector for use by g05ew. The replacement routine g05ph is now used to both set up a reference vector and generate the required variates. Setting the integer parameter mode = 0 in the call to g05ph sets up the double reference vector r and hence mimics the functionality of g05eg. When mode = 0, the integer array state in the call to g05ph need not be set.

g05eh

Withdrawn at Mark 22.
Replaced by g05nc.
Old: [index, ifail] = g05eh(index, 'n', n);
New: [index, state, ifail] = g05nc(index, state, 'n', n);
The integer array state in the call to g05nc contains information on the base generator being used. This array must have been initialized prior to calling g05nc with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05nc is likely to be different to those produced by g05eh.

g05ej

Withdrawn at Mark 22.
Replaced by g05nd.
Old: [iz, ifail] = g05ej(ia, m, 'n', n);
New: [iz, state, ifail] = g05nd(ia, m, state, 'n', n);
The integer array state in the call to g05nd contains information on the base generator being used. This array must have been initialized prior to calling g05nd with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05nd is likely to be different to those produced by g05ej.

g05ew

Withdrawn at Mark 22.
Replaced by g05ph.
Old: [r, var, ifail] = g05eg(e, a, b, nr, 'na', na, 'nb', nb)
     for i=1:n
       [x(i), ifail] = g05ew(r);
     end
New: theta = zeros(iq, 1);
     avar = b(1)^2;
     if avar > 0
       for i=1:nb-1
         theta(i) = -b(i+1)/b(1);
       end
     end
     mode = int32(2);
     [r, state, var, x, ifail] = g05ph(mode, n, e, na, a, nb-1, theta, avar, r,
state);

The double vector theta must be of length at least iq = nb - 1.
The old routine g05eg sets up a reference vector for use by g05ew. The replacement routine g05ph is now used to both set up a reference vector and generate the required variates. Setting the integer parameter mode to 0 in the call to g05ph sets up the double reference vector r and hence mimics the functionality of g05eg. Setting mode to 1 generates a series of variates from a reference vector mimicking the functionality of g05ew. Setting mode to 2 initializes the reference vector and generates the variates in one go.
The integer array state in the call to g05ph contains information on the base generator being used. This array must have been initialized prior to calling g05ph with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05ph is likely to be different to those produced by g05eg.

g05ex

Withdrawn at Mark 22.
Replaced by g05td.
Old: [r1, ifail] = g05ex(p, ip1, itype, lr1, 'np', np)
     for i=1:n
      x(i) = g05ey(r1);
     end
New: mode = int32(2);
     [r, state, x, ifail] = g05td(mode, n, p, ip1, itype, r, state, 'np', np);
The old routine g05ex sets up a reference vector for use by g05ey. The replacement routine g05td is now used to both set up a reference vector and generate the required variates. Setting the integer parameter mode to 0 in the call to g05td sets up the double reference vector r and hence mimics the functionality of g05ex. Setting mode to 1 generates a series of variates from a reference vector mimicking the functionality of g05ey for this particular distribution. Setting mode to 2 initializes the reference vector and generates the variates in one go.
The routine g05ey returns a single variate at a time, whereas the new routine g05td returns a vector of N values in one go.
The length of the double reference vector, r, in g05td, needs to be a different length to the equivalent parameter in g05ex, see the documentation for more details.
The integer array state in the call to g05td contains information on the base generator being used. This array must have been initialized prior to calling g05td with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05td is likely to be different to those produced by a combination of g05ex and g05ey.

g05ey

Withdrawn at Mark 22.
Replaced by g05td.
There is no direct replacement routine for g05ey.
g05ey is designed to generate random draws from a distribution defined by a reference vector. These reference vectors are created by other routines in Chapter G05, for example g05eb, which have themselves been superseded. In order to replace a call to g05ey you must identify which NAG routine generated the reference vector being used and look up its replacement. For example, to replace a call to g05ey preceded by a call to g05eb, as in:
    [r, ifail] = g05eb(m, n, nr);
    x = g05ey(r);
you would need to look at the replacement routine for g05eb.

g05ez

Withdrawn at Mark 22.
Replaced by g05rz.
Old: [r1, ifail] = g05ea(xmu, c, eps, lr1, 'n', n);
     for i=1:n
       [x(i,1:m), ifail] = g05ez(m, r);
     end
New: mode = int32(2);
     [r, state, x, ifail] = g05rz(mode, n, xmu, c, r, state, 'm', m, 'lr', lr);
The old routine g05ea sets up a reference vector for use by g05ez. The functionality of both these routines has been combined into the single new routine g05rz. Setting the integer parameter mode = 2 in the call to g05rz sets up the double reference vector r and generates the draws from the multivariate normal distribution in one go.
The old routine g05ez returns a single (M dimensional vector) draw from the multivariate normal distribution at a time, whereas the new routine g05tl returns an n by m matrix of n draws in one go.
The integer array state in the call to g05rz contains information on the base generator being used. This array must have been initialized prior to calling g05rz with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05rz is likely to be different to those produced by g05ez.

g05fa

Withdrawn at Mark 22.
Replaced by g05sq.
Old: [x] = g05fa(aa, bb, n);
New: [a, b] = sort([aa, bb]);
     [state, x, ifail] = g05sq(n, a, b, state);
In g05sq the minimum value must be held in the parameter A and the maximum in parameter b, therefore ab. This was not the case for the equivalent parameters in g05fa.
The integer array state in the call to g05sq contains information on the base generator being used. This array must have been initialized prior to calling g05sq with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sq is likely to be different to those produced by g05fa.

g05fb

Withdrawn at Mark 22.
Replaced by g05sf.
Old: x = g05fb(a, n);
New: [state, x, ifail] = g05sf(n, abs(a), state);
In g05sf parameter a must be non-negative, this was not the case for the equivalent parameter in g05fb
.
The integer array state in the call to g05sf contains information on the base generator being used. This array must have been initialized prior to calling g05sf with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sf is likely to be different to those produced by g05fb.

g05fd

Withdrawn at Mark 22.
Replaced by g05sk.
Old: x = g05fd(xmu, sd, n);
New: var = sd^2;
     [state, x, ifail] = g05sk(n, xmu, var, state);
g05sk expects the variance of the normal distribution (parameter var), compared to g05fd which expected the standard deviation.
The integer array state in the call to g05sk contains information on the base generator being used. This array must have been initialized prior to calling g05sk with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sk is likely to be different to those produced by g05fd.

g05fe

Withdrawn at Mark 22.
Replaced by g05sb.
Old: [x, ifail] = g05fe(a, b, n);
New: [state, x, ifail] = g05sb(n, a, b, state);
The integer array state in the call to g05sb contains information on the base generator being used. This array must have been initialized prior to calling g05sb with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sb is likely to be different to those produced by g05fe.

g05ff

Withdrawn at Mark 22.
Replaced by g05sj.
Old: [x, ifail] = g05ff(a, b, n);
New: [state, x, ifail] = g05sj(n, a, b, state);
The integer array state in the call to g05sj contains information on the base generator being used. This array must have been initialized prior to calling g05sj with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sj is likely to be different to those produced by g05ff.

g05fs

Withdrawn at Mark 22.
Replaced by g05sr.
Old: [x, ifail] = g05sf(vk, n);
New: [state, x, ifail] = g05sr(n, vk, state);
The integer array state in the call to g05sr contains information on the base generator being used. This array must have been initialized prior to calling g05sr with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05sr is likely to be different to those produced by g05fs.

g05ga

Withdrawn at Mark 22.
Replaced by g05px.
Old: [a, ifail] = g05ga(side, init, m, a, 'n', n);
New: [state, a, ifail] = g05px(side, init, state, a, 'm', m, 'n', n);
The integer array state in the call to g05px contains information on the base generator being used. This array must have been initialized prior to calling g05px with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05px is likely to be different to those produced by g05ga.

g05gb

Withdrawn at Mark 22.
Replaced by g05py.
Old: [c, ifail] = g05gb(d, 'n', n, 'eps', eps);
New: [state, c, ifail] = g05py(d, state, 'n', n, 'eps', eps) 
The integer array state in the call to g05py contains information on the base generator being used. This array must have been initialized prior to calling g05py with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05py is likely to be different to those produced by g05gb.

g05hd

Withdrawn at Mark 22.
Replaced by g05pj.
Old: [w, ref, ifail] = g05hd(mode, ip, iq, mean, par, qq, n, ref, 'k', k, 'lpar', lpar, 'lref', lref)
New: if mode = 'c'
       imode = int32(0);
     else
       imode = int32(1);
     end
     ll = 0;
     for l=1:ip
       for i=1:k
         for j=1:k
           ll = ll+1;
           phi(i, j, l) = par(ll);
         end
       end
     end
     for l=1:iq-1
       for i=1:k
         for j=1:k
           ll = ll+1;
           theta(i, j, l) = par(ll);
         end
       end
     end
     xmean = zeros(k, 1);
     if mean = 'm'
       xmean = par(ll+1:ll+k+1);
     end
     [ref, state, x, ifail] = g05pj(imode, n, xmean, ip, phi, iq, theta, ...
                                    qq, ref, state, 'k', k, 'lr', lr) 
The integer parameter imode should be set to 0, 1 or 3 in place of the parameter mode having settings of 'S', 'C' or 'R' respectively. The double array phi should have length at least max (1,ip × (k × k)) ; if dimensioned as phi(k,k,ip)  (as in the above example) then phi (i,j,l)  will contain the element par ((l - 1) × k × k + (i - 1) × k + j) . The double array theta should have length at least max (1,iq × (k × k)) ; if dimensioned as theta (k,k,iq)  (as in the above example) then theta (i,j,l)  will contain the element par (ip × k × k + (l - 1) × k × k + (i - 1) × k + j) . The double array xmean should have length at least k; if mean = 'M'  then xmean (i)  will contain the element par (ip + iq × k × k + i) , otherwise xmean should contain an array of zero values.
The integer array state in the call to g05pj contains information on the base generator being used. This array must have been initialized prior to calling g05pj with a call to either g05kf or g05kg. Due to changes in the underlying code the sequence of values produced by g05pj is likely to be different to those produced by g05hd.

g05hk

Scheduled for withdrawal at Mark 24.
Replaced by g05pd.
Old: [ht, et, rvec, iseed, rwsav, ifail] = g05hk(dist, num, ip, iq, theta, gamma, df, fcall, rvec, igen, iseed, rwsav)
New: [ht, et, r, state, ifail] = g05pd(dist, num, ip, iq, theta, gamma, df, fcall, r, state, 'lr', lr)

g05hl

Scheduled for withdrawal at Mark 24.
Replaced by g05pe.
Old: [ht, et, rvec, iseed, rwsav, ifail] = g05hl(dist, num, ip, iq, theta, gamma, df, fcall, rvec, igen, iseed, rwsav);
New: [ht, et, r, state, ifail] = g05pe(dist, num, ip, iq, theta, gamma, df, fcall, r, state, 'lr', lr);

g05hm

Scheduled for withdrawal at Mark 24.
Replaced by g05pf.
Old: [ht, et, rvec, iseed, rwsav, ifail] = g05hm(dist, num, ip, iq, theta, gamma, df, fcall, rvec, igen, iseed, rwsav);
New: [ht, et, r, state, ifail] = g05pf(dist, num, ip, iq, theta, gamma, df, fcall, r, state, 'lr', lr); 

g05hn

Scheduled for withdrawal at Mark 24.
Replaced by g05pg.
Old: [ht, et, rvec, iseed, rwsav, ifail] = g05hn(dist, num, ip, iq, theta, df, fcall, rvec, igen, iseed, rwsav);
New: [ht, et, r, state, ifail] = g05pg(dist, num, ip, iq, theta, df, fcall, r, state, 'lr', lr);

g05ka

Scheduled for withdrawal at Mark 24.
Replaced by g05sa.
Old: for i=1:n
       [x(i), iseed] = g05ka(igen, iseed);
     end
New: [state, x, ifail] = g05sa(n, state);

g05kb

Scheduled for withdrawal at Mark 24.
Replaced by g05kf.
Old: [igen, iseed] = g05kb(igen, iseed);
New: if (igen == 0)
       [state, ifail] = g05kf(int23(1), int32(1), iseed, 'lseed', lseed);
     else
       [state, ifail] = g05kf(int32(1), igen, iseed, 'lseed', lseed);
     end

g05kc

Scheduled for withdrawal at Mark 24.
Replaced by g05kg.
Old: [igen, iseed] = g05kc(igen);
New: if (igen == 0)
       [state, ifail] = g05kg(int32(1), int32(1));
     else
       [state, ifail] = g05kg(int32(2), igen);
     end

g05ke

Scheduled for withdrawal at Mark 24.
Replaced by g05tb.
Old: for i=1:n
       [x(i), iseed, ifail] = g05ke(p, igen, iseed);
     end
New: [state, x, ifail] = g05tb(n, p, state);

g05la

Scheduled for withdrawal at Mark 24.
Replaced by g05sk.
Old: [x, iseed, ifail] = g05la(xmu, var, n, igen, iseed);
New: [state, x, ifail] = g05sk(n, xmu, var, state);

g05lb

Scheduled for withdrawal at Mark 24.
Replaced by g05sn.
Old: [x, iseed, ifail] = g05lb(df, n, igen, iseed);
New: [state, x, ifail] = g05sn(n, df, state);

g05lc

Scheduled for withdrawal at Mark 24.
Replaced by g05sd.
Old: [x, iseed, ifail] = g05lc(df, n, igen, iseed);
New: [state, x, ifail] = g05sd(n, df, state);

g05ld

Scheduled for withdrawal at Mark 24.
Replaced by g05sh.
Old: [x, iseed, ifail] = g05ld(df1, df2, n, igen, iseed);
New: [state, x, ifail] = g05sh(n, df1, df2, state);

g05le

Scheduled for withdrawal at Mark 24.
Replaced by g05sb.
Old: [x, iseed, ifail] = g05le(a, b, n, igen, iseed);
New: [state, x, ifail] = g05sb(n, a, b, state);

g05lf

Scheduled for withdrawal at Mark 24.
Replaced by g05sj.
Old: [x, iseed, ifail] = g05lf(a, b, n, igen, iseed);
New: [state, x, ifail] = g05sj(n, a, b, state);

g05lg

Scheduled for withdrawal at Mark 24.
Replaced by g05sq.
Old: [x, iseed, ifail] = g05lg(a, b, n, igen, iseed);
New: [state, x, ifail] = g05sq(n, a, b, state);

g05lh

Scheduled for withdrawal at Mark 24.
Replaced by g05sp.
Old: [x, iseed, ifail] = g05lh(xmin, xmax, xmed, n, igen, iseed);
New: [state, x, ifail] = g05sp(n, xmin, xmed, xmax, state);

g05lj

Scheduled for withdrawal at Mark 24.
Replaced by g05sf.
Old: [x, iseed, ifail] = g05lj(a, n, igen, iseed);
New: [state, x, ifail] = g05sf(n, a, state);

g05lk

Scheduled for withdrawal at Mark 24.
Replaced by g05sm.
Old: [x, iseed, ifail] = g05lk(xmu, var, n, igen, iseed);
New: [state, x, ifail] = g05sm(n, xmu, var, state);

g05ll

Scheduled for withdrawal at Mark 24.
Replaced by g05sj.
Old: [x, iseed, ifail] = g05ll(xmed, semiqr, n, igen, iseed);
New: [state, x, ifail] = g05sc(n, xmed, semiqr, state);

g05lm

Scheduled for withdrawal at Mark 24.
Replaced by g05ss.
Old: [x, iseed, ifail] = g05lm(a, b, n, igen, iseed);
New: [state, x, ifail] = g05ss(n, a, b, state);

g05ln

Scheduled for withdrawal at Mark 24.
Replaced by g05sl.
Old: [x, iseed, ifail] = g05ln(a, b, n, igen, iseed);
New: [state, x, ifail] = g05sl(n, a, b, state);

g05lp

Scheduled for withdrawal at Mark 24.
Replaced by g05sr.
Old: [x, iseed, ifail] = g05lp(vk, n, igen, iseed);
New: [state, x, ifail] = g05sr(n, vk, state);

g05lq

Scheduled for withdrawal at Mark 24.
Replaced by g05sg.
Old: [x, iseed, ifail] = g05lq(a, wgt, n, igen, iseed, 'nmix', nmix);
New: [state, x, ifail] = g05sg(n, a, wgt, state, 'nmix', nmix);

g05lx

Scheduled for withdrawal at Mark 24.
Replaced by g05ry.
Old: [x, iseed, r, ifail] = g05lx(mode, df, xmu, c, n, igen, iseed, r, 'm', m, 'lr', lr);
New: [r, state, x, ifail] = g05ry(mode, n, df, xmu, c, r, state, 'm', m, 'lr', lr);

g05ly

Scheduled for withdrawal at Mark 24.
Replaced by g05rz.
Old: [x, iseed, r, ifail] = g05ly(mode, xmu, c, n, igen, iseed, r, 'm', m, 'lr', lr);
New: [r, state, x, ifail] = g05rz(mode, n, xmu, c, r, state, 'm', m, 'lr', lr);

g05lz

Scheduled for withdrawal at Mark 24.
Replaced by g05rz.
Old: [x, iseed, r, ifail] = g05lz(mode, xmu, c, igen, iseed, r, 'n', n);
New: n = int32(1);
     [r, state, x, ifail] = g05rz(mode, n, xmu, c, r, state, 'm', m, 'lr', lr); 

g05ma

Scheduled for withdrawal at Mark 24.
Replaced by g05tl.
Old: [x, iseed, ifail] = g05ma(a, b, n, igen, iseed);
New: [state, x, ifail] = g05tl(n, a, b, state);

g05mb

Scheduled for withdrawal at Mark 24.
Replaced by g05tc.
Old: [x, iseed, r, ifail] = g05mb(mode, p, n, igen, iseed, r);
New: [r, state, x, ifail] = g05tc(mode, n, p, r, state);

g05mc

Scheduled for withdrawal at Mark 24.
Replaced by g05th.
Old: [x, iseed, r, ifail] = g05mc(mode, m, p, n, igen, iseed, r);
New: [r, state, x, ifail] = g05th(mode, n, m, p, r, state);

g05md

Scheduled for withdrawal at Mark 24.
Replaced by g05tf.
Old: [x, iseed, r, ifail] = g05md(mode, a, n, igen, iseed, r);
New: [r, state, x, ifail] = g05tf(mode, n, a, r, state);

g05me

Scheduled for withdrawal at Mark 24.
Replaced by g05tk.
Old: [x, iseed, ifail] = g05me(vlamda, igen, iseed, 'm', m);
New: [state, x, ifail] = g05tk(vlamda, state, 'm', m);

g05mj

Scheduled for withdrawal at Mark 24.
Replaced by g05ta.
Old: [x, iseed, r, ifail] = g05mj(mode, m, p, n, igen, iseed, r);
New: [r, state, x, ifail] = g05ta(mode, n, m, p, r, state);

g05mk

Scheduled for withdrawal at Mark 24.
Replaced by g05tj.
Old: [x, iseed, r, ifail] = g05mk(mode, lambda, n, igen, iseed, r);
New: [r, state, x, ifail] = g05tj(mode, n, lambda, r, state);

g05ml

Scheduled for withdrawal at Mark 24.
Replaced by g05te.
Old: [x, iseed, r, ifail] = g05ml(mode, ns, np, m, n, igen, iseed, r);
New: [r, state, x, ifail] = g05te(mode, n, ns, np, m, r, state);

g05mr

Scheduled for withdrawal at Mark 24.
Replaced by g05tg.
Old: [x, iseed, r, ifail] = g05mr(mode, m, p, n, igen, iseed, r, 'k', k);
New: [r, state, x, ifail] = g05tg(mode, n, m, p, r, state, 'k', k);

g05mz

Scheduled for withdrawal at Mark 24.
Replaced by g05td.
Old: [x, iseed, r, ifail] = g05mz(mode, p, ip1, itype, n, igen, iseed, r, 'np', np);
New: [r, state, x, ifail] = g05td(mode, n, p, ip1, itype, r, state, 'np', np);

g05na

Scheduled for withdrawal at Mark 24.
Replaced by g05nc.
Old: [index, iseed, ifail] = g05na(index, igen, iseed, 'n', n);
New: [index, state, ifail] = g05nc(index, state, 'n', n);

g05nb

Scheduled for withdrawal at Mark 24.
Replaced by g05nd.
Old: [isampl, iseed, ifail] = g05nb(ipop, m, igen, iseed, 'n', n);
New: [isampl, state, ifail] = g05nd(ipop, m, state, 'n', n);

g05pa

Scheduled for withdrawal at Mark 24.
Replaced by g05ph.
Old: [var, x, iseed, r, ifail] = g05pa(mode, xmean, phi, theta, avar, n, igen, iseed, r, 'ip', ip, 'iq', iq);
New: [r, state, var, x, ifail] = g05ph(mode, n, xmean, ip, phi, iq, theta, avar, r, state);

g05pc

Scheduled for withdrawal at Mark 24.
Replaced by g05pj.
Old: [x, iseed, r, ifail] = g05pc(mode, xmean, ip, phi, iq, theta, var, n, igen, iseed, r, 'k', k);
New: [r, state, x, ifail] = g05pj(mode, n, xmean, ip, phi, iq, theta, var, r, state, 'k', k, 'lr', lr);

g05qa

Scheduled for withdrawal at Mark 24.
Replaced by g05px.
Old: [a, iseed, ifail] = g05qa(side, init, a, igen, iseed, 'm', m, 'n', n);
New: [state, a, ifail] = g05px(side, init, state, a, 'm', m, 'n', n);

g05qb

Scheduled for withdrawal at Mark 24.
Replaced by g05py.
Old: [c, iseed, ifail] = g05qb(d, igen, iseed, 'n', n, 'eps', eps);
New: [state, c, ifail] = g05py(d, state, 'n', n, 'eps', eps)

g05qd

Scheduled for withdrawal at Mark 24.
Replaced by g05pz.
Old: [x, iseed, r, ifail] = g05qd(mode, totr, totc, igen, iseed, r, 'nrow', nrow, 'ncol', ncol, 'nr', nr);
New: [r, state, x, ifail] = g05pz(mode, totr, totc, r, state, 'nrow', nrow, 'ncol', ncol, 'lr', lr);

g05ra

Scheduled for withdrawal at Mark 24.
Replaced by g05rd.
Old: [x, iseed, r, ifail] = g05ra(mode, c, n, igen, iseed, r, 'm', m, 'lr', lr);
New: [r, state, x, ifail] = g05rd(mode, n, c, r, state, 'm', m, 'lr', lr);

g05rb

Scheduled for withdrawal at Mark 24.
Replaced by g05rc.
Old: [x, iseed, r, ifail] = g05rb(mode, df, c, n, igen, iseed, r, 'm', m, 'lr', lr);
New: [r, state, x, ifail] = g05rc(mode, n, df, c, r, state, 'm', m, 'lr', lr);

g05ya

Scheduled for withdrawal at Mark 23.
Replaced by g05yl and g05ym.
Faure quasi random numbers
Old: [quas, iref, ifail] = g05ya(true, 'f', iskip, idim, iref);
New: [iref, ifail] = g05yl(int32(4), idim, iskip);
Old: [quas, iref, ifail] = g05ya(false, 'f', iskip, idim, iref);
New: [quas, iref, ifail] = g05ym(int32(1), int32(2), iref);
Sobol quasi random numbers
Old: [quas, iref, ifail] = g05ya(true, 's', iskip, idim, iref);
New: [iref, ifail] = g05yl(int32(2), idim, iskip);
Old: [quas, iref, ifail] = g05ya(false, 's', iskip, idim, iref);
New: [quas, iref, ifail] = g05ym(int32(1), int32(2), iref);
Neiderreiter quasi random numbers
Old: [quas, iref, ifail] = g05ya(true, 'n', iskip, idim, iref);
New: [iref, ifail] = g05yl(int32(3), idim, iskip);
Old: [quas, iref, ifail] = g05ya(false, 'n', iskip, idim, iref);
New: [quas, iref, ifail] = g05ym(int32(1), int32(2), iref);

g05yb

Scheduled for withdrawal at Mark 23.
Replaced by g05yl and either g05yj or g05yk.
This routine has been replaced by a suite of routines consisting of the relevant initialization routine followed by one of two possible generator routines.
Faure quasi random numbers with Gaussian probability:
Old: [quasi, iref, ifail] = g05yb(true, 'f', false, mean, std, iskip, iref, 'idim', idim);
New: [iref, ifail] = g05yl(int32(4), idim, iskip);
Old: [quasi, iref, ifail] = g05yb(false, 'f', false, mean, std, iskip, iref, 'idim', idim);
New: [quasi, iref, ifail] = g05yj(xmean, std, n, iref);
Sobol quasi random numbers with Gaussian probability:
Old: [quasi, iref, ifail] = g05yb(true, 's', false, mean, std, iskip, iref, 'idim', idim);
New: [iref, ifail] = g05yl(int32(2), idim, iskip);
Old: [quasi, iref, ifail] = g05yb(false, 's', false, mean, std, iskip, iref, 'idim', idim);
New: [quasi, iref, ifail] = g05yj(xmean, std, n, iref);
Neiderreiter quasi random numbers with Gaussian probability:
Old: [quasi, iref, ifail] = g05yb(true, 'n', false, mean, std, iskip, iref, 'idim', idim);
New: [iref, ifail] = g05yl(int32(3), idim, iskip);
Old: [quasi, iref, ifail] = g05yb(false, 'n', false, mean, std, iskip, iref, 'idim', idim);
New: [quasi, iref, ifail] = g05yj(xmean, std, n, iref);
Faure quasi random numbers with log Normal probability:
Old: [quasi, iref, ifail] = g05yb(true, 'f', true, mean, std, iskip, iref, 'idim', idim);
New: [iref, ifail] = g05yl(int32(4), idim, iskip);
Old: [quasi, iref, ifail] = g05yb(false, 'f', true, mean, std, iskip, iref, 'idim', idim);
New: [quasi, iref, ifail] = g05yk(xmean, std, n, iref);
Sobol quasi random numbers with log Normal probability:
Old: [quasi, iref, ifail] = g05yb(true, 's', true, mean, std, iskip, iref, 'idim', idim);
New: [iref, ifail] = g05yl(int32(2), idim, iskip);
Old: [quasi, iref, ifail] = g05yb(false, 's', true, mean, std, iskip, iref, 'idim', idim);
New: [quasi, iref, ifail] = g05yk(xmean, std, n, iref);
Neiderreiter quasi random numbers with log Normal probability:
Old: [quasi, iref, ifail] = g05yb(true, 'n', true, mean, std, iskip, iref, 'idim', idim);
New: [iref, ifail] = g05yl(int32(3), idim, iskip);
Old: [quasi, iref, ifail] = g05yb(false, 'n', true, mean, std, iskip, iref, 'idim', idim);
New: [quasi, iref, ifail] = g05yk(xmean, std, n, iref);

g05yc

Scheduled for withdrawal at Mark 24.
Replaced by g05yl.
Old: [iref, ifail] = g05yc(idim);
New: [iref, ifail] = g05yl(int32(4), idim, iskip);

g05yd

Scheduled for withdrawal at Mark 24.
Replaced by g05ym.
Old: [quasi, iref, ifail] = g05yd(n, iref);
New: [quas, iref, ifail] = g05ym(n, rcord, iref);

g05ye

Scheduled for withdrawal at Mark 24.
Replaced by g05yl.
Old: [iref, ifail] = g05ye(idim, iskip);
New: [iref, ifail] = g05yl(int32(2), idim, iskip);

g05yf

Scheduled for withdrawal at Mark 24.
Replaced by g05ym.
Old: [quasi, iref, ifail] = g05yf(n, iref);
New: [quas, iref, ifail] = g05ym(n, rcord, iref);

g05yg

Scheduled for withdrawal at Mark 24.
Replaced by g05yl.
Old: [iref, ifail] = g05yg(idim, iskip);
New: [iref, ifail] = g05yl(int32(3), idim, iskip);

g05yh

Scheduled for withdrawal at Mark 24.
Replaced by g05ym.
Old: [quasi, iref, ifail] = g05yh(n, iref);
New: [quas, iref, ifail] = g05ym(n, rcord, iref);

g05za

Withdrawn at Mark 22.
None.
.

G13 – Time Series Analysis

g13dc

Scheduled for withdrawal at Mark 24.
Replaced by g13dd.
Old: [par, qq, niter, rlogl, v, g, cm, ifail] = ...
        g13dc(ip, iq, mean, par, qq, w, parhld, exact, iprint, cgetol, ishow, ...
              'k', k, 'n', n, 'npar', npar, 'maxcal', maxcal) 
New: [par, qq, niter, rlogl, v, g, cm, ifail] = ...
        g13dd(ip, iq, mean, par, qq, w, parhld, exact, iprint, cgetol, ishow, ...
              'k', k, 'n', n, 'npar', npar, 'maxcal', maxcal) 
This replacement is caused by changes in the underlying Fortran interface (removal of workspace arguments) which have no effect on the MATLAB toolbox interface.

X02 – Machine Constants

x02da

Scheduled for withdrawal at Mark 24.
No longer required.

x02dj

Scheduled for withdrawal at Mark 24.
No longer required.

Chapter Contents
NAG Toolbox

© The Numerical Algorithms Group Ltd, Oxford, UK. 2009