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
Q^{T} × 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
Q^{H} × 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 onedimensional 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,
g05pd–
g05pz,
g05rc–
g05rz, 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,
g05pd–
g05pz,
g05rc–
g05rz, 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 nonnegative, 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 semiinterquartile range (parameter
semiqr) to be nonnegative, 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
a ≤ b. 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:nb1
theta(i) = b(i+1)/b(1);
end
end
mode = int32(0);
[r, state, var, x, ifail] = g05ph(mode, n, e, na, a, nb1, 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:nb1
theta(i) = b(i+1)/b(1);
end
end
mode = int32(2);
[r, state, var, x, ifail] = g05ph(mode, n, e, na, a, nb1, 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
a ≤ b. 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 nonnegative, 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:iq1
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.