Interfaces: FL CL AD

Replace: FL CL AD

NAG CL Interface
Replacement Calls Advice

Keyword Search:

NAG Library Manual, Mark 27

Interfaces: FL CL AD

Replace: FL CL AD

▸▿ Contents

▸▿ C05 – Roots of One or More Transcendental Equations

c05adc

c05agc

c05nbc

c05pbc

c05sdc

c05tbc

c05ubc

c05zbc

c05zcc

▸▿ C06 – Fourier Transforms

c06eac

c06ebc

c06ecc

c06ekc

c06fpc

c06fqc

c06frc

c06fuc

c06gbc

c06gcc

c06gqc

c06gsc

c06gzc

c06hac

c06hbc

c06hcc

c06hdc

▸▿ D01 – Quadrature

d01ajc

d01akc

d01alc

d01amc

d01anc

d01apc

d01aqc

d01asc

d01bac

d01fcc

d01gbc

d01tac

▸▿ D02 – Ordinary Differential Equations

d02pcc

d02pdc

d02ppc

d02pvc

d02pwc

d02pxc

d02pzc

▸▿ E01 – Interpolation

e01sac

e01sbc

e01szc

▸▿ E04 – Minimizing or Maximizing a Function

e04ccc

e04dgc

e04jbc

e04jcc

▸▿ F01 – Matrix Operations, Including Inversion

f01bnc

f01qcc

f01qdc

f01qec

f01rcc

f01rdc

f01rec

▸▿ F02 – Eigenvalues and Eigenvectors

f02aac

f02abc

f02adc

f02aec

f02afc

f02agc

f02awc

f02axc

f02bjc

f02wec

f02xec

▸▿ F03 – Determinants

f03aec

f03afc

f03ahc

▸▿ F04 – Simultaneous Linear Equations

f04adc

f04agc

f04ajc

f04akc

f04arc

f04awc

▸▿ F06 – Linear Algebra Support Functions

f06pac

f06pbc

f06pcc

f06pdc

f06pec

f06pfc

f06pgc

f06phc

f06pjc

f06pkc

f06plc

f06pmc

f06ppc

f06pqc

f06prc

f06psc

f06sac

f06sbc

f06scc

f06sdc

f06sec

f06sfc

f06sgc

f06shc

f06sjc

f06skc

f06slc

f06smc

f06snc

f06spc

f06sqc

f06src

f06ssc

f06yac

f06ycc

f06yfc

f06yjc

f06ypc

f06yrc

f06zac

f06zcc

f06zfc

f06zjc

f06zpc

f06zrc

f06ztc

f06zuc

f06zwc

▸▿ F08 – Least Squares and Eigenvalue Problems (LAPACK)

f08bec

f08bsc

f08vac

f08vec

f08vnc

f08vsc

f08wac

f08wec

f08wnc

f08wsc

f08xac

f08xnc

▸▿ G01 – Simple Calculations on Statistical Data

g01aac

g01cec

▸▿ G02 – Correlation and Regression Analysis

g02ewc

g02jac

g02jbc

g02jcc

g02jdc

g02jec

▸▿ G05 – Random Number Generators

g05cac

g05cbc

g05ccc

g05cfc

g05cgc

g05dac

g05dbc

g05ddc

g05dyc

g05eac

g05ecc

g05edc

g05ehc

g05ejc

g05exc

g05eyc

g05ezc

g05fec

g05ffc

g05hac

g05hkc

g05hlc

g05hmc

g05kac

g05kbc

g05kcc

g05kec

g05lac

g05lbc

g05lcc

g05ldc

g05lec

g05lfc

g05lgc

g05lhc

g05ljc

g05lkc

g05llc

g05lmc

g05lnc

g05lpc

g05lqc

g05lxc

g05lyc

g05lzc

g05mac

g05mbc

g05mcc

g05mdc

g05mec

g05mjc

g05mkc

g05mlc

g05mrc

g05mzc

g05nac

g05nbc

g05pac

g05pcc

g05qac

g05qbc

g05qdc

g05rac

g05rbc

g05yac

g05ybc

▸▿ G10 – Smoothing in Statistics

g10bac

▸▿ X02 – Machine Constants

X02DAC

X02DJC

▸▿ X04 – Input/Output Utilities

x04aec

C05 – Roots of One or More Transcendental Equations

c05adc

Withdrawn at Mark 24.
Replaced by c05ayc.

Old Code

double f(double xx)
   {
      ...
   }
...
nag_zero_cont_func_bd(a, b, &x, f, xtol, ftol, &fail);

New Code

double f(double xx, Nag_Comm *comm)
   {
      ...
   }
...
Nag_Comm comm;
...
nag_zero_cont_func_brent(a, b, xtol, ftol, f, &x, &comm, &fail);

c05agc

Withdrawn at Mark 25.
Replaced by c05auc.

Old Code

nag_zero_cont_func_brent_bsrch(...);

New Code

nag_zero_cont_func_brent_binsrch(...);

c05nbc

Withdrawn at Mark 24.
Replaced by c05qbc.

Old Code

void f(Integer n, const double x[], double fvec[], Integer *userflag)
   {
      ...
   }
...
nag_zero_nonlin_eqns(n, x, fvec, f, xtol, &fail);

New Code

void fcn(Integer n, const double x[], double fvec[], Nag_Comm *comm,
         Integer *userflag)
   {
      ...
   }
...
Nag_Comm comm;
...
nag_zero_nonlin_eqns_easy(fcn, n, x, fvec, xtol, &comm, &fail);

c05pbc

Withdrawn at Mark 24.
Replaced by c05rbc.

Old Code

void f(Integer n, double x[], double fvec[], double fjac[],
       Integer tdfjac, Integer *userflag)
   {
      ...
   }
...
fjac = NAG_ALLOC(n*tdfjac, double);
...
nag_zero_nonlin_eqns_deriv(n, x, fvec, fjac, tdfjac, f, xtol, &fail);

New Code

void fcn(Integer n, double x[], double fvec[], double fjac[],
         Nag_Comm *comm, Integer *iflag)
   {
      ...
   }
...
Nag_Comm comm;
...
fjac = NAG_ALLOC(n*n, double);
...
nag_zero_nonlin_eqns_deriv_easy(fcn, n, x, fvec, fjac, xtol, &comm,
                                &fail);

c05sdc

Withdrawn at Mark 25.
Replaced by c05ayc.

Old Code

double f(double x, Nag_User *comm)
   {
      ...
   }
...
Nag_User comm;
...
nag_zero_cont_func_bd_1(a, b, &x, f, xtol, ftol, &comm, &fail);

New Code

double f(double xx, Nag_Comm *comm)
   {
      ...
   }
...
Nag_Comm comm;
...
nag_zero_cont_func_brent(a, b, xtol, ftol, f, &x, &comm, &fail);

Note that the communication structure comm is now of type Nag_Comm (see Section 3.1.1 in the Introduction to the NAG Library CL Interface) rather than Nag_User (see Section 3.1.1 in the Introduction to the NAG Library CL Interface).

c05tbc

Withdrawn at Mark 24.
Replaced by c05qbc.

Old Code

void f(Integer n, const double x[], double fvec[], Integer *userflag,
       Nag_User *comm)
   {
      ...
   }
...
Nag_User comm;
...
nag_zero_nonlin_eqns_1(n, x, fvec, fcn, xtol, &comm, &fail);

New Code

void fcn(Integer n, const double x[], double fvec[], Nag_Comm *comm,
         Integer *userflag)
   {
      ...
   }
...
Nag_Comm comm;
...
nag_zero_nonlin_eqns_easy(fcn, n, x, fvec, xtol, &comm, &fail);

c05ubc

Withdrawn at Mark 25.
Replaced by c05rbc.

Old Code

void f(Integer n, double x[], double fvec[], double fjac[],
       Integer tdfjac, Integer *userflag, Nag_User *comm)
   {
      ...
   }
...
Nag_User comm;
...
fjac = NAG_ALLOC(n*tdfjac, double);
...
nag_zero_nonlin_eqns_deriv_1(n, x, fvec, fjac, tdfjac, f, xtol,
                             &comm, &fail);

New Code

void fcn(Integer n, double x[], double fvec[], double fjac[],
         Nag_Comm *comm, Integer *userflag)
   {
      ...
   }
...
Nag_Comm comm;
...
fjac = NAG_ALLOC(n*n, double);
...
nag_zero_nonlin_eqns_deriv_easy(fcn, n, x, fvec, fjac, xtol, &comm,
                                     &fail);

c05zbc

Withdrawn at Mark 24.
Replaced by c05zdc.

Old Code

nag_check_deriv(n, x, fvec, fjac, tdfjac, f, &fail);

New Code

Integer mode, m;
double *xp = 0, *fvecp = 0, *err = 0;
m = n;
mode = 1;
nag_check_derivs(mode, m, n, x, fvec, fjac, xp, fvecp, err, &fail);
/* Set fvec to the function values at the original point x and fvecp
 * to the function values at the update point xp. */
mode = 2;
nag_check_derivs(mode, m, n, x, fvec, fjac, xp, fvecp, err, &fail);
/* Check the contents of err for the measures of correctness of each
 * gradient. */

c05zcc

Withdrawn at Mark 24.
Replaced by c05zdc.

Old Code

nag_check_deriv_1(n, x, fvec, fjac, tdfjac, f, &comm, &fail);

New Code

Integer mode, m;
double *xp = 0, *fvecp = 0, *err = 0;
m = n;
mode = 1;
nag_check_derivs(mode, m, n, x, fvec, fjac, xp, fvecp, err, &fail);
/* Set fvec to the function values at the original point x and fvecp
 * to the function values at the update point xp. */
mode = 2;
nag_check_derivs(mode, m, n, x, fvec, fjac, xp, fvecp, err, &fail);
/* Check the contents of err for the measures of correctness of each
 * gradient. */

C06 – Fourier Transforms

c06eac

Withdrawn at Mark 26.
Replaced by c06pac.

c06pac removes restrictions on sequence length and combines transform directions.

Old Code

nag_sum_withdraw_fft_real_1d_nowork(n, x, &fail);

New Code

nag_sum_fft_realherm_1d(Nag_ForwardTransform, x, n, &fail);

where the dimension of the array x has been extended from the original n to

n + 2

. The output values x are stored in a different order with real and imaginary parts stored contiguously. The mapping of output elements is as follows:

$x [2 \times i - 1] \leftarrow x [i - 1]$ , for $i = 0, 1, \dots, n / 2$ and
$x [2 \times i] \leftarrow x [n - i - 1]$ , for $i = 1, 2, \dots, (n + 1) / 2$ .

c06ebc

Withdrawn at Mark 26.
Replaced by c06pac.

c06pac removes restrictions on sequence length and combines transform directions.

Old Code

nag_sum_withdraw_fft_hermitian_1d_nowork(n, x, &fail);

New Code

nag_sum_fft_realherm_1d(Nag_BackwardTransform, x, n, &fail);

where the dimension of the array x has been extended from the original n to

n + 2

. The input values of x are stored in a different order with real and imaginary parts stored contiguously. Also c06pac performs the inverse transform without the need to first conjugate. If prior conjugation of original array x is assumed then the mapping of input elements is:

$x [2 \times i - 1] \leftarrow x [i - 1]$ , for $i = 0, 1, \dots, n / 2$ and
$x [2 \times i] \leftarrow x [n - i - 1]$ , for $i = 1, 2, \dots, (n - 1) / 2$ .

c06ecc

Withdrawn at Mark 26.
Replaced by c06pcc.

c06pcc removes restrictions on sequence length, combines transform directions and uses complex types.

Old Code

nag_sum_withdraw_fft_complex_1d_nowork(n, x, y, &fail);

New Code

nag_sum_fft_complex_1d(Nag_ForwardTransform, z, n, &fail);

where

z

is a complex array of length n such that

z [i] . re = x [i]

and

z [i] . im = y [i]

, for

i = 0, 1, \dots, n - 1

on input and output.

c06ekc

Withdrawn at Mark 26.
Replaced by c06fkc.

c06fkc removes restrictions on sequence length.

Old Code

nag_sum_withdraw_convcorr_real_nowork(job, n, x, y, &fail);

New Code

nag_sum_convcorr_real(job, x, y, n, &fail);

c06fpc

Scheduled for withdrawal at Mark 29.
Replaced by c06pqc.

c06pqc provides a simpler interface for both forward and backward transforms.

Old Code

nag_sum_withdraw_fft_real_1d_multi_rfmt(m, n, x, trig, &fail);

New Code

nag_sum_fft_realherm_1d_multi_col(Nag_ForwardTransform, n, m, x, &fail);

where the dimension of the array x has been extended from the original

n \times m

(n + 2) \times m

The input values are stored slightly differently to allow for two extra storage spaces at the end of each sequence.

The mapping of input elements is as follows:

for j=0,1,…,m-1
- $J = j \times (n + 2)$ ;
- $x [J + i] \leftarrow x [j \times n + i]$ , for $i = 0, 1, \dots, n - 1$ ;
- $x [J + n]$ and $x [J + n + 1]$ need not be set.

The output values x are stored in a different order with real and imaginary parts of each Hermitian sequence stored contiguously.

The mapping of output elements is as follows:

for j=0,1,…,m-1
- $J = j \times (n + 2)$ ;
- $x [J + 2 \times i] \leftarrow x [j \times n + i]$ , for $i = 0, 1, \dots, n / 2$ (real parts);
- $x [J + 2 \times i + 1] \leftarrow x [j \times n + n - i]$ , for $i = 1, 2, \dots, (n - 1) / 2$ (imaginary parts);
- $x [J + 1] = 0$ ;
- $x [J + n + 1] = 0$ when n is even.

c06fqc

Scheduled for withdrawal at Mark 29.
Replaced by c06pqc.

c06pqc provides a simpler interface for both forward and backward transforms.

Old Code

nag_sum_withdraw_fft_hermitian_1d_multi_rfmt(m, n, x, trig, &fail);

New Code

nag_sum_fft_realherm_1d_multi_col(Nag_BackwardTransform, n, m, x, &fail);

where the dimension of the array x has been extended from the original

n \times m

(n + 2) \times m

The input values x are stored in a different order with real and imaginary parts of each Hermitian sequence stored contiguously.

The mapping of input elements is as follows:

for j=0,1,…,m-1
- $J = j \times (n + 2)$ ;
- $x [J + 2 \times i] \leftarrow x [j \times n + i]$ , for $i = 0, 1, \dots, n / 2$ (real parts);
- $x [J + 2 \times i + 1] \leftarrow x [j \times n + n - i]$ , for $i = 1, 2, \dots, (n - 1) / 2$ (imaginary parts);
- $x [J + 1] = 0$ ;
- $x [J + n + 1] = 0$ when n is even.

The output values are stored slightly differently to allow for two extra storage spaces at the end of each sequence.

The mapping of output elements is as follows:

for j=0,1,…,m-1
- $J = j \times (n + 2)$ ;
- $x [J + i] \leftarrow x [j \times n + i]$ , for $i = 0, 1, \dots, n - 1$ ;
- $x [J + n] = x [J + n + 1] = 0 .$

c06frc

Withdrawn at Mark 26.
Replaced by c06psc.

c06psc provides a simpler interface for both forward and backward transforms.

Old Code

nag_fft_multiple_complex(m, n, x, y, trig, &fail);

New Code

nag_sum_fft_complex_1d_multi_col(Nag_ForwardTransform, n, m, z, &fail);

where

z

is a complex array of length

m \times n

such that

z [i] . re = x [i]

and

z [i] . im = y [i]

, for

i = 0, 1, \dots, m \times n - 1

on input and output.

c06fuc

Withdrawn at Mark 26.
Replaced by c06puc.

c06puc provides a simpler interface for both forward and backward transforms.

Old Code

nag_fft_2d_complex(m, n, x, y, trigm, trign, &fail);

New Code

nag_sum_fft_complex_2d(Nag_ForwardTransform, m, n, z, &fail);

where

z

is a complex array of length

m \times n

such that

z [i] . re = x [i]

and

z [i] . im = y [i]

, for

i = 0, 1, \dots, m \times n - 1

on input and output.

c06gbc

Withdrawn at Mark 26.
There is no replacement for this function.

c06gcc

Withdrawn at Mark 26.
There is no replacement for this function.

c06gqc

Scheduled for withdrawal at Mark 29.
There is no replacement for this function.

c06gsc

Scheduled for withdrawal at Mark 29.
There is no replacement for this function.

c06gzc

Scheduled for withdrawal at Mark 29.
There is no replacement for this function.

c06hac

Withdrawn at Mark 26.
Replaced by c06rec.

c06rec has a simpler interface, storing sequences by column.

Old Code

nag_fft_multiple_sine(m, n, x, trig, &fail);

New Code

nag_sum_fft_sine(m, n, x, &fail);

c06hbc

Withdrawn at Mark 26.
Replaced by c06rfc.

c06rfc has a simpler interface, storing sequences by column.

Old Code

nag_fft_multiple_cosine(m, n, x, trig, &fail);

New Code

nag_sum_fft_cosine(m, n, x, &fail);

c06hcc

Withdrawn at Mark 26.
Replaced by c06rgc.

c06rgc has a simpler interface, storing sequences by column.

Old Code

nag_fft_multiple_qtr_sine(direct, m, n, x, trig, &fail);

New Code

nag_sum_fft_qtrsine(direct, m, n, x, &fail);

c06hdc

Withdrawn at Mark 26.
Replaced by c06rhc.

c06rhc has a simpler interface, storing sequences by column.

Old Code

nag_fft_multiple_qtr_cosine(direct, m, n, x, trig, &fail);

New Code

nag_sum_fft_qtrcosine(direct, m, n, x, &fail);

D01 – Quadrature

d01ajc

Withdrawn at Mark 24.
Replaced by d01sjc.

Where comm, a pointer to a structure of type Nag_User, has been added to allow you to pass information to the user-supplied function f.

d01akc

Withdrawn at Mark 24.
Replaced by d01skc.

Where comm, a pointer to a structure of type Nag_User, has been added to allow you to pass information to the user-supplied function f.

d01alc

Withdrawn at Mark 24.
Replaced by d01slc.

Where comm, a pointer to a structure of type Nag_User, has been added to allow you to pass information to the user-supplied function f.

d01amc

Withdrawn at Mark 24.
Replaced by d01smc.

Where comm, a pointer to a structure of type Nag_User, has been added to allow you to pass information to the user-supplied function f.

d01anc

Withdrawn at Mark 24.
Replaced by d01snc.

Where comm, a pointer to a structure of type Nag_User, has been added to allow you to pass information to the user-supplied function g.

d01apc

Withdrawn at Mark 24.
Replaced by d01spc.

Where comm, a pointer to a structure of type Nag_User, has been added to allow you to pass information to the user-supplied function g.

d01aqc

Withdrawn at Mark 24.
Replaced by d01sqc.

Where comm, a pointer to a structure of type Nag_User, has been added to allow you to pass information to the user-supplied function g.

d01asc

Withdrawn at Mark 24.
Replaced by d01ssc.

Where comm, a pointer to a structure of type Nag_User, has been added to allow you to pass information to the user-supplied function g.

d01bac

Withdrawn at Mark 24.
Replaced by d01uac.

Withdrawn to provide a simpler interface to select the quadrature rule.

Old Code

double fun (double x)
dinest = nag_1d_quad_gauss(quadrule, fun, a, b, n, &fail);

New Code

void f (const double x[], Integer nx, double fv[], Integer *iflag,
Nag_Comm *comm)
nag_quad_1d_gauss_vec(quad_type, a, b, n, f, &dinest, &comm,
                           &fail);

Replace quadrule with quad_type as follows:

Nag_Legendre with Nag_Quad_Gauss_Legendre;
Nag_Rational with Nag_Quad_Gauss_Rational_Adjusted;
Nag_Laguerre with Nag_Quad_Gauss_Laguerre;
Nag_Hermite with Nag_Quad_Gauss_Hermite.

comm is a pointer to a structure of type Nag_Comm available to allow you to pass information to the user-supplied function f.

iflag is an integer which you may use to force an immediate exit from d01uac in case of an error in the user-supplied function f.

f may be used to call the original fun as follows, although it may be more efficient to recode the integrand.

void f(const double x[], const Integer nx, double fv[], Integer *iflag,
  Nag_Comm *comm)
{
   Integer i;
   for(i=0; i<nx; i++)
   {
 fv[i]  = fun(x[i]);
   }
}

d01fcc

Withdrawn at Mark 25.
Replaced by d01wcc.

Where comm, a pointer to a structure of type Nag_User, has been added to allow you to pass information to the user-supplied function f.

d01gbc

Withdrawn at Mark 25.
.

Where comm, a pointer to a structure of type Nag_User, has been added to allow you to pass information to the user-supplied function f.

d01tac

Scheduled for withdrawal at Mark 28.
Replaced by d01uac.

D02 – Ordinary Differential Equations

d02pcc

Withdrawn at Mark 26.
Replaced by d02pec and associated d02p functions.

Old Code

nag_ode_ivp_rk_setup(n, tstart, yinit, tend, tol, thres, method, task,
                     errass, hstart, &opt, &fail);
   ...
  nag_ode_ivp_rk_range(n, f, twant, &tgot, ygot, ypgot, ymax, &opt,
                       &comm,
                       &fail);

New Code

nag_ode_ivp_rkts_setup(n, tstart, tend, yinit, tol, thres, method,
                       errass, hstart, iwsav, rwsav, &fail);
   ...
  nag_ode_ivp_rkts_range(f2, n, twant, &tgot, ygot, ypgot, ymax,
                         &comm2, iwsav, rwsav, &fail);

iwsav is an Integer array of length

130

and rwsav is a double array of length

350 + 32 \times n

comm2 is a pointer to a structure of type Nag_Comm available to allow you to pass information to the user defined function f2 (see f in d02pec).

The definition of f2 (see f in d02pec) can use the original function f as follows:

void f2(double t, Integer n, const double *y, double *yp, Nag_Comm *comm2)
{
  Nag_User comm;
  f(n, t, y, yp, &comm);
}

d02pdc

Withdrawn at Mark 26.
Replaced by d02pfc and associated d02p functions.

d02pgc offers a reverse communication approach.

Old Code

nag_ode_ivp_rk_setup(n, tstart, yinit, tend, tol, thres, method, task,
                     errass, hstart, &opt, &fail);
   nag_ode_ivp_rk_onestep(n, f, &tnow, ynow, ypnow, &opt, &comm,
                          &fail);

New Code

nag_ode_ivp_rkts_setup(n, tstart, tend, yinit, tol, thres, method,
                       errass, hstart, iwsav, rwsav, &fail);
   nag_ode_ivp_rkts_onestep(f2, n, &tnow, ynow, ypnow, &comm2, iwsav,
                            rwsav, &fail);

iwsav is an Integer array of length

130

and rwsav is a double array of length

350 + 32 \times n

comm2 is a pointer to a structure of type Nag_Comm available to allow you to pass information to the user defined function f2 (see f in d02pec).

The definition of f2 (see f in d02pec) can use the original function f as follows:

void f2(double t, Integer n, const double *y, double *yp, Nag_Comm *comm2)
{
  Nag_User comm;
  f(n, t, y, yp, &comm);
}

d02ppc

Withdrawn at Mark 26.
There is no replacement for this function.

d02pvc

Withdrawn at Mark 26.
Replaced by d02pqc.

See d02pcc and d02pdc for further information.

d02pwc

Withdrawn at Mark 26.
Replaced by d02prc.

Old Code

nag_ode_ivp_rk_reset_tend(tendnu, &opt, &fail);

New Code

nag_ode_ivp_rkts_reset_tend(tendnu, iwsav, rwsav, &fail);

iwsav is an Integer array of length

130

and rwsav is a double array of length

350

d02pxc

Withdrawn at Mark 26.
Replaced by d02psc.

Old Code

nag_ode_ivp_rk_interp(n, twant,  request, nwant, ywant, ypwant, f,
                      &opt, &comm, &fail);

New Code

nag_ode_ivp_rkts_interp(n, twant, request, nwant, ywant, ypwant, f2,
                             wcomm, lwcomm, &comm2, iwsav, rwsav, &fail);

iwsav is an Integer array of length

130

and rwsav is a double array of length

350 + 32 \times n

comm2 is a pointer to a structure of type Nag_Comm available to allow you to pass information to the user defined function f2 (see f in d02psc).

wcomm is a double array of length lwcomm. See the function document for d02psc for further information.

The definition of f2 (see f in d02psc) can use the original function f as follows:

void f2(double t, Integer n, const double *y, double *yp, Nag_Comm *comm2)
{
  Nag_User comm;
  f(n, t, y, yp, &comm);
}

d02pzc

Withdrawn at Mark 26.
Replaced by d02puc.

Old Code

nag_ode_ivp_rk_errass(n, rmserr, &errmax, &terrmx, &opt, &fail);

New Code

nag_ode_ivp_rkts_errass(n, rmserr, &errmax, &terrmx, iwsav, rwsav,
                             &fail);

n must be unchanged from that passed to d02pqc.

iwsav is an Integer array of length

130

and rwsav is a double array of length

350 + 32 \times n

E01 – Interpolation

e01sac

Withdrawn at Mark 23.
Replaced by e01sgc or e01sjc.

e01sac generates a two-dimensional surface interpolating a set of scattered data points, using either the method of Renka and Cline or a modification of Shepard's method. The replacement functions separate these two methods.

e01sac_rk.c

provides replacement call information for the Renka and Cline method (e01sgc) and

e01sac_shep.c

provides replacement call information for the Shepard's method (e01sjc).

e01sbc

Withdrawn at Mark 23.
Replaced by e01shc or e01skc.

See the example program

e01sac_rk.c

and

e01sac_shep.c

for full details.

e01szc

Withdrawn at Mark 23.
There is no replacement for this function.

E04 – Minimizing or Maximizing a Function

e04ccc

Withdrawn at Mark 24.
Replaced by e04cbc.

Old Code

nag_opt_withdraw_uncon_simplex(n, funct, x, &objf, &options, &comm, &fail);

New Code

nag_opt_uncon_simplex(n, x, &objf, tolf, tolx, funct, monit, maxcal,
                   &comm, &fail);

The options structure has been removed from e04ccc. The optim_tol and max_iter members of the options structure have been introduced as the arguments tolf and maxcal, respectively. tolx is an additional argument to control tolerance. A new user defined function monit has been added to allow you to monitor the optimization process. If no monitoring is required, monit may be specified as NULLFN.

e04dgc

Deprecated.
Replaced by e04kfc.

The new solver e04kfc is part of the NAG Optimization suite (see Section 4.1 in the E04 Chapter Introduction), therefore the definition of the objective function values and gradients need to be split into two separate subroutines. e04kfc offers a significant improvement in performance over e04dgc as well as additional functionality, such as the addition of variable bounds and monitoring.

Callbacks

Old Code

static void NAG_CALL objfun(Integer n, const double x[], double *objf,
                            double g[], Nag_Comm *comm)
{
  /* Compute objective at point x */
  *objf = ... ;
  
  /* Compute objective gradient at point x */
  g[0] = ... ;
  ...
  g[n-1] = ... ;
}

New Code

static void NAG_CALL objfun(Integer nvar,
                            const double x[],
                            double *fx, Integer * inform, Nag_Comm * comm)
{
    /* Compute objective at point x */
    *fx = ... ;
}

static void NAG_CALL objgrd(Integer nvar,
                            const double x[],
                            Integer nnzfd,
                            double fdx[],
                            Integer * inform, Nag_Comm * comm)
{
    /* Compute objective gradient at point x */
    fdx[0] = ... ;
    fdx[1] = ... ;
    ...
    fdx[nnzfd-1] = ... ;
}

Main Call

Old Code

SET_FAIL(fail);
nag_opt_uncon_conjgrd_comp(n, objfun, x, &objf, g, &options, &comm, &fail);

New Code

    /* Initialize problem with n variables */
    nag_opt_handle_init(&handle, n, NAGERR_DEFAULT);

    /* Add nonlinear objective function with dense gradient
     * (dependent on all variables)
     */
    for (int i=1; i<=n; i++)
      idxfd[i-1] = i;
    nag_opt_handle_set_nlnobj(handle, n, idxfd, NAGERR_DEFAULT);

    /* Solver the problem */
    SET_FAIL(fail);
    nag_opt_handle_solve_bounds_foas(handle, objfun, objgrd, NULLFN, n,
                                     x, rinfo, stats, &comm, &fail);
                                     
    iter = stats[7];
    objf = rinfo[0];

    /* Free the handle memory */
    nag_opt_handle_free(&handle, NAGERR_DEFAULT);

e04jbc

Withdrawn at Mark 26.
Replaced by e04ucc.

See the example program

e04jbce.c

for code demonstrating how to use e04ucc instead of e04jbc.

e04jcc

Deprecated.
Replaced by e04jdc and e04jec.

e04jdc and e04jec are a part of the new NAG Optimization Suite (see Section 4.1 in the E04 Chapter Introduction) which allows you to define and solve various problems in a uniform manner. They also offer various algorithmic additions, such as a performance improvement on noisy problems, a possibility to progress towards the solution earlier than after

n

initial function evaluations, heuristic stopping criteria, recovery from unavailable function evaluations, and various other algorithmic updates and tuning. In addition, e04jec offers a reverse communication interface (see Section 4.2 in the E04 Chapter Introduction) which might be useful in some environments or if you can parallelize your function evaluations.

Callbacks

The objective function callbacks are almost identical, the order of arguments has been slightly altered.

Old Code

void (*objfun)(Integer n, const double x[], double *f, Nag_Comm *comm, Integer *inform)

New Code

void (*objfun)(Integer n, const double x[], double *f, Integer *inform, Nag_Comm *comm)

Main Call

Old Code

     SET_FAIL(fail);
     nag_opt_bounds_bobyqa_func(objfun, n, npt, x, bl, bu, rhobeg, rhoend,
                                NULLFN, maxcal, &f, &nf, &comm, &fail);

New Code

    void *handle;
    Integer *idxfd, i;
    double rinfo[100], stats[100];

    /* Initialize the problem with n variables */
    nag_opt_handle_init(&handle, n, NAGERR_DEFAULT);

    /* Add nonlinear objective function which depends on all variables */
    idxfd = (Integer*) malloc(n*sizeof(Integer));
    for (i=0; i<n; i++)
        idxfd[i] = i+1;
    nag_opt_handle_set_nlnobj(handle, n, idxfd, NAGERR_DEFAULT);

    /* Add bounds for the variables */
    nag_opt_handle_set_simplebounds(handle, n, bl, bu, NAGERR_DEFAULT);

    /* Pass npt, rhobeg, rhoend, maxcal as options if different from defaults */
    nag_opt_handle_opt_set(handle, 'DFO Number Interp Points = <your npt>', NAGERR_DEFAULT);
    nag_opt_handle_opt_set(handle, 'DFO Starting trust Region = <your rhobeg>', NAGERR_DEFAULT);
    nag_opt_handle_opt_set(handle, 'DFO Trust Region Tolerance = <your rhoend>', NAGERR_DEFAULT);
    nag_opt_handle_opt_set(handle, 'DFO Max Objective Calls = <your maxcal>', NAGERR_DEFAULT);

    /* Solve the problem */
    SET_FAIL(fail);
    nag_opt_handle_solve_dfno(handle, objfun, NULLFN, n, x, rinfo, stats,
                              &comm, &fail);

    /* retrieve the objective value and the total number of calls made to the objective function */
    f = rinfo[0];
    nf = (Integer) stats[0];

    /* Free the handle memory */
    nag_opt_handle_free(&handle, NAGERR_DEFAULT);

F01 – Matrix Operations, Including Inversion

f01bnc

Withdrawn at Mark 25.
Replaced by f07frc.

If you were only using f01bnc in order to feed its results into f04awc, then the simple replacement function given further below, in the section for f04awc, will suffice. A more thorough replacement function is given here and it will put the same values in arrays a and p as f01bnc did.

void f01bnc_replacement(Integer n, Complex a[], Integer tda, double p[],
                   NagError *fail)
{
  Integer i, pdb=n;
  Complex *b;

  b = NAG_ALLOC(n*n, Complex);
  /* replacement factorization routine requires the upper triangle
to be stored for U^H*U, but f01bnc expects the lower triangle
to be stored so put the lower triangle of a into the upper
triangle of b */
  /* nag_blast_zge_copy */
  f16tfc(Nag_RowMajor, Nag_ConjTrans, n, n, a, tda, b, pdb, fail);
  /* factorize b */
  /* nag_lapacklin_zpotrf */
  f07frc(Nag_RowMajor, Nag_Upper, n, b,pdb, fail);
  /* diagonal elements to populate the p array */
  for (i = 0; i < n; ++i) p[i] = 1.0/b[i*tda+i].re;
  /* overwrite the off-diagonal upper triangle of a with U */
  /* nag_blast_ztr_copy */
  f16tec(Nag_RowMajor, Nag_Upper, Nag_NoTrans, Nag_UnitDiag, n, b, pdb, a,
    tda, fail);
  NAG_FREE(b);
}

f01qcc

Withdrawn at Mark 25.
Replaced by f08aec.

The subdiagonal elements of a and the elements of zeta returned by f08aec are not the same as those returned by f01qcc. Subsequent calls to f01qdc or f01qec must also be replaced by calls to f08afc or f08agc as shown below.

void f01qcc_replacement(Integer m, Integer n, double a[], Integer tda,
double zeta[], NagError *fail)
{
  /* nag_lapackeig_dgeqrf */
  f08aec(Nag_RowMajor, m, n, a, tda, zeta, fail);
  /* the factorization in a and zeta will be stored differently */
}

f01qdc

Withdrawn at Mark 25.
Replaced by f08agc.

The following replacement is valid only if the previous call to f01qcc has been replaced by a call to f08aec as shown below. It also assumes that the second argument of f01qdc is set to

wheret = Nag_ElementsSeparate

, which is appropriate if the contents of a and zeta have not been changed after the call of f01qcc.

void f01qcc_replacement(Integer m, Integer n, double a[], Integer tda,
double zeta[], NagError *fail)
{
  /* nag_lapackeig_dgeqrf */
  f08aec(Nag_RowMajor, m, n, a, tda, zeta, fail);
  /* the factorization in a and zeta will be stored differently */ }

void f01qdc_replacement(MatrixTranspose trans, Nag_WhereElements wheret,
  Integer m, Integer n, double a[], Integer tda, const double zeta[],
  Integer ncolb, double b[], Integer tdb, NagError *fail) {
  Nag_TransType t = (trans==NoTranspose)? Nag_NoTrans : Nag_Trans;
  /* nag_lapackeig_dormqr */
  f08agc(Nag_RowMajor, Nag_LeftSide, t, m, ncolb, n, a, tda, zeta,
	   b, tdb, fail);
}

f01qec

Withdrawn at Mark 25.
Replaced by f08afc.

The following replacement is valid only if the previous call to f01qcc has been replaced by a call to f08aec as shown below. It also assumes that the first argument of f01qec is set to

wheret = Nag_ElementsSeparate

, which is appropriate if the contents of a and zeta have not been changed after the call of f01qcc.

void f01qcc_replacement(Integer m, Integer n, double a[], Integer tda,
double zeta[], NagError *fail)
{
  /* nag_lapackeig_dgeqrf */
  f08aec(Nag_RowMajor, m, n, a, tda, zeta, fail);
  /* the factorization in a and zeta will be stored differently */
}

void f01qec_replacement(Nag_WhereElements wheret, Integer m, Integer n,
  Integer ncolq, double a[], Integer tda, const double zeta[],
  NagError *fail)
{
  /* factorization performed by nag_dgeqrf (f08aec) */
  /* nag_lapackeig_dorgqr */
  f08afc(Nag_RowMajor, m, ncolq, n, a, tda, zeta, fail);
}

f01rcc

Withdrawn at Mark 25.
Replaced by f08asc.

The subdiagonal elements of a and the elements of theta returned by f08asc are not the same as those returned by f01rcc. Subsequent calls to f01rdc or f01rec must also be replaced by calls to f08auc or f08atc as shown below.

void f01rcc_replacement(Integer m, Integer n, Complex a[], Integer tda,
Complex theta[], NagError *fail)
{
  /* nag_lapackeig_zgeqrf */
  f08asc(Nag_RowMajor, m, n, a, tda, theta, fail);
  /* the factorization in a and theta will be stored differently */
}

f01rdc

Withdrawn at Mark 25.
Replaced by f08auc.

The following replacement is valid only if the previous call to f01rcc has been replaced by a call to f08asc as shown below. It also assumes that the second argument of f01rdc is set to

wheret = Nag_ElementsSeparate

, which is appropriate if the contents of a and theta have not been changed after the call of f01rcc.

void f01rcc_replacement(Integer m, Integer n, Complex a[], Integer tda,
Complex theta[], NagError *fail)
{
  /* nag_lapackeig_zgeqrf */
  f08asc(Nag_RowMajor, m, n, a, tda, theta, fail);
  /* the factorization in a and theta will be stored differently */
}

void f01rdc_replacement(MatrixTranspose trans, Nag_WhereElements wheret,
  Integer m, Integer n, Complex a[], Integer tda, const Complex theta[],
  Integer ncolb, Complex b[], Integer tdb, NagError *fail)
{
  Nag_TransType t = (trans==NoTranspose)? Nag_NoTrans : Nag_ConjTrans;
  /* nag_lapackeig_zunmqr */
  f08auc(Nag_RowMajor, Nag_LeftSide, t, m, ncolb, n, a, tda, theta,
	   b, tdb, fail);
}

f01rec

Withdrawn at Mark 25.
Replaced by f08atc.

The following replacement is valid only if the previous call to f01rcc has been replaced by a call to f08asc as shown below. It also assumes that the first argument of f01rec is set to

wheret = Nag_ElementsSeparate

, which is appropriate if the contents of a and theta have not been changed after the call of f01rcc.

void f01rcc_replacement(Integer m, Integer n, Complex a[], Integer tda,
   Complex theta[], NagError *fail)
{
  /* nag_lapackeig_zgeqrf */
  f08asc(Nag_RowMajor, m, n, a, tda, theta, fail);
  /* the factorization in a and theta will be stored differently */
}

void f01rec_replacement(Nag_WhereElements wheret, Integer m, Integer n,
   Integer ncolq, Complex a[], Integer tda, const Complex theta[],
   NagError *fail)
{
  /* nag_lapackeig_zungqr */
  /* factorization performed by f08asc */
  f08atc(Nag_RowMajor, m, ncolq, n, a, tda, theta, fail);
}

F02 – Eigenvalues and Eigenvectors

f02aac

Withdrawn at Mark 26.
Replaced by f08fac.

Old Code

nag_real_symm_eigenvalues(n, a, tda, r, &fail);

New Code

nag_dsyev(Nag_RowMajor, Nag_EigVals, Nag_Lower, n, a, tda, r, &fail);

f02abc

Withdrawn at Mark 26.
Replaced by f08fac.

Old Code

nag_real_symm_eigensystem(n, a, tda, r, v, tdv, &fail);

New Code

nag_dtr_copy (Nag_RowMajor, Nag_Lower, Nag_NoTrans, Nag_NonUnitDiag, n,
              a, tda, v, tdv, &fail);
     nag_dsyev(Nag_RowMajor, Nag_DoBoth, Nag_Lower, n, v, tdv, r, &fail);

If f02abc was called with the same array supplied for v and a, then the call to f16qec may be omitted.

f02adc

Withdrawn at Mark 26.
Replaced by f08sac.

Old Code

nag_real_symm_general_eigenvalues(n, a, tda, b, tdb, r, &fail);

New Code

nag_dsygv(Nag_RowMajor, 1, Nag_EigVals, Nag_Upper, n, a, tda, b, tdb,
               r, &fail);

Note that the call to f08sac will overwrite the upper triangles of the arrays a and b and leave the subdiagonal elements unchanged, whereas the call to f02adc overwrites the lower triangle and leaves the elements above the diagonal unchanged.

f02aec

Withdrawn at Mark 26.
Replaced by f08sac.

Old Code

nag_real_symm_general_eigensystem(n, a, tda, b, tdb, r, v, tdv,
                                  &fail);

New Code

nag_dtr_copy (Nag_RowMajor, Nag_Upper, Nag_NoTrans, Nag_NonUnitDiag, n,
              a, tda, v, tdv, &fail);
nag_dsygv(Nag_RowMajor, 1, Nag_DoBoth, Nag_Upper, n, v, tdv, b, tdb,
               r, &fail);

Note that the call to f08sac will overwrite the upper triangle of the array b and leave the subdiagonal elements unchanged, whereas the call to f02aec overwrites the lower triangle and leaves the elements above the diagonal unchanged. The call to f16qec copies a to v, so a is left unchanged. If f02aec was called with the same array supplied for v and a, then the call to f16qec may be omitted.

f02afc

Withdrawn at Mark 26.
Replaced by f08nac.

Old Code

nag_real_eigenvalues(n, a, tda, r, iter, &fail);

New Code

nag_dgeev(Nag_RowMajor, Nag_NotLeftVecs, Nag_NotRightVecs, n, a, tda,
               wr, wi,vl, 1, vr, 1, &fail);

where wr and wi are double arrays of lengths

n

such that

wr [i - 1] = r [i - 1] . re

and

wi [i - 1] = r [i - 1] . im

, for

i = 1, 2, \dots, n

; vl and vr are double arrays of length

1

(not used in this call); the iteration counts (returned by f02afc in the array iter) are not available from f08nac.

f02agc

Withdrawn at Mark 26.
Replaced by f08nac.

Old Code

 nag_real_eigensystem(n, a, tda, r, v, tdv, iter, &fail);

New Code

nag_dgeev(Nag_RowMajor, Nag_NotLeftVecs, Nag_RightVecs, n, a, tda,
               wr, wi, vl, 1, vr, pdvr, &fail);

where wr and wi are double arrays of lengths

n

such that

wr [i - 1] = r [i - 1] . re

and

wi [i - 1] = r [i - 1] . im

, for

i = 1, 2, \dots, n

; vl is a double array of length

1

(not used in this call) and vr is a double array of length

n \times n

; the iteration counts (returned by f02agc in the array iter) are not available from f08nac.

Eigenvector information is stored differently in vr:

$v [j] . re = vr [j]$ if $wi [j] = 0.0$ .
$v [j] . re = vr [j]$ and $v [j] . im = vr [j + 1]$ and $v [j + 1] . re = vr [j]$ and $v [j + 1] . im = - vr [j + 1]$ if $wi [j] \neq 0$ and $wi [j] = - wi [j + 1]$ .

f02awc

Withdrawn at Mark 26.
Replaced by f08fnc.

Old Code

nag_hermitian_eigenvalues(n, a, tda, r, &fail);

New Code

nag_zheev(Nag_RowMajor, Nag_EigVals, Nag_Lower, n, a, tda, r, &fail);

f02axc

Withdrawn at Mark 26.
Replaced by f08fnc.

Old Code

nag_hermitian_eigensystem(n, a, tda, r, v, tdv, &fail);

New Code

nag_ztr_copy(Nag_RowMajor, Nag_Lower, Nag_NoTrans, Nag_NonUnitDiag, n,
             a, tda, v, tdv, &fail);
     nag_zheev(Nag_RowMajor, Nag_DoBoth, Nag_Lower, n, v, tdv, r, &fail);

If f02axc was called with the same arrays supplied for v and a, then the call to f16tec may be omitted.

f02bjc

Withdrawn at Mark 26.
Replaced by f08wac.

Old Code

 nag_real_general_eigensystem(n, a, tda, b, tdb, tol, alfa, beta,
                              wantv, v, tdv, iter, &fail);

New Code

if (wantv) jobvr = Nag_RightVecs; else jobvr = Nag_NotRightVecs;
   nag_dggev(Nag_RowMajor, Nag_NotLeftVecs, jobvr, n, a, tda, b, tdb,
                  alphar, alphai, beta, vl, tdvl, vr, tdvr, &fail);

where alphar and alphai are double arrays of lengths

n

such that

alphar [i - 1] = alfa [i - 1] . re

and

alphai [i - 1] = alfa [i - 1] . im

, for

i = 1, 2, \dots, n

f02wec

Withdrawn at Mark 26.
Replaced by f08kbc.

Old Code

nag_real_svd(m, n, a, tda, ncolb, b, tdb, wantq, q, tdq, sv, wantp,
             pt, tdpt, &iter, e, &failinfo, &fail);

New Code

if (wantq) jobu = Nag_AllU; else jobu = Nag_NotU;
if (wantp) jobvt = Nag_AllVT; else jobvt = Nag_NotVT;
nag_dgesvd(Nag_RowMajor, jobu, jobvt, m, n, a, tda, sv, q, tdq,
                pt, tdpt, work, &fail);

work must be a one-dimensional double array of length

\min (m, n)

; the iteration count (returned by f02wec in the argument iter) is not available from f08kbc.

Please note that the facility to return

Q^{T} B

is not provided so arguments

ncolb

and

b

are not required. Instead, f08kbc has an option to return the entire

m * m

orthogonal matrix

Q

, referred to as

u

in its documentation, through its 8th argument.

f02xec

Withdrawn at Mark 26.
Replaced by f08kpc.

Old Code

nag_complex_svd(m, n, a, tda, ncolb, b, tdb, wantq, q, tdq, sv, wantp,
                ph, tdph, &iter, e, &failinfo, &fail);

New Code

if (wantq) jobu = Nag_AllU; else jobu = Nag_NotU;
if (wantp)  jobvt = Nag_AllVT; else jobvt = Nag_NotVT;
nag_zgesvd(Nag_RowMajor, jobu, jobvt, m, n, a, tda, sv, q, tdq,
                ph, tdph, rwork, &fail);

rwork must be a one-dimensional double array of length

\min (m, n)

; the iteration count (returned by f02xec in the argument iter) is not available from f08kpc.

Please note that the facility to return

Q^{H} B

is not provided so arguments ncolb and

b

are not required. Instead, f08kpc has an option to return the entire

m * m

unitary matrix

Q

, referred to as

u

in its documentation, through its 8th argument.

F03 – Determinants

f03aec

Withdrawn at Mark 25.
Replaced by f07fdc and f03bfc.

void f03aec_replacement(Integer n, double a[], Integer tda,
double p[], double *detf, Integer *dete, NagError *fail)
{
  /* nag_dpotrf */
f07fdc(Nag_RowMajor, Nag_Upper, n, a, tda, fail);
  /* nag_det_real_sym */
f03bfc(Nag_RowMajor, n, a, tda, detf, dete, fail);
  /* p is not written to */
  /* factorization in a will be different */
}

f07fdc performs the Cholesky factorization and f03bfc calculates the determinant from the factored form.

Note: subsequent solution of linear systems using the Cholesky factorization performed by f07fdc should be performed using f07fec).

f03afc

Withdrawn at Mark 25.
Replaced by f07adc and f03bac.

void f03afc_replacement(Integer n, double a[], Integer tda,
  Integer pivot[], double *detf, Integer *dete, NagError *fail)
{
  /* nag_lapacklin_dgetrf */
  f07adc(Nag_RowMajor, n, n, a, tda, pivot, fail);
  /* nag_det_real_gen */
  f03bac(Nag_RowMajor, n, a, tda, pivot, detf, dete, fail);
  /* the factorization in a will be different */
  /* the array pivot will be different */
}

Note: subsequent solution of linear systems using the

L U

factorization performed by f07adc should be performed using f07aec).

f03ahc

Withdrawn at Mark 25.
Replaced by f07arc and f03bnc.

void f03ahc_replacement(Integer n, Complex a[], Integer tda,
Integer pivot[], Complex *det, Integer *dete, NagError *fail)
{
  Complex d={0,0};
  Integer id[2]={0,0};
  /* nag_lapacklin_zgetrf */
  f07arc(Nag_RowMajor, n, n, a, tda, pivot, fail);
  /* nag_det_complex_gen */
  f03bnc(Nag_RowMajor, n, a, tda, pivot, &d, id, fail);
  /* Bring real and imaginary parts to a common scale */
  *dete = MAX(id[0],id[1]);
  det->re = ldexp(d.re,id[0]-*dete);
  det->im = ldexp(d.im,id[1]-*dete);
  /* the factorization in a will be different */
}

f07arc performs the

L U

factorization and f03bnc calculates the determinant from the factored form.

Note: the details of the

L U

factorization performed by f07arc differ from those perfomed by f03ahc; subsequent solution of linear systems using the

L U

factorization performed by f07arc should be performed using f07asc. The determinant returned by f03bnc independently scales the real and imaginary parts whereas the determinant returned by f03ahc used a single scaling factor.

F04 – Simultaneous Linear Equations

The factorization and solution of a positive definite linear system can be handled by calls to functions from Chapter f04.

f04adc

Withdrawn at Mark 25.
Replaced by f04cac.

void f04adc_replacement(Integer n, Integer nrhs,
    Complex a[], Integer tda, const Complex b[], Integer tdb,
    Complex x[], Integer tdx, NagError *fail)
{
  Integer *ipiv;
  double rcond, errbnd;

  ipiv = NAG_ALLOC(n, Integer);
  /* nag_blast_zge_copy */
  f16tfc(Nag_RowMajor, Nag_NoTrans, n, nrhs, b, tdb, x, tdx, fail);
  /* nag_linsys_complex_square_solve */
  f04cac(Nag_RowMajor, n, nrhs, a, tda, ipiv, x,
	 tdx, &rcond, &errbnd, fail);
  /* The factorization in a will be different */
  /* Error codes will be different */
  /* Condition number and error bounds are available to you */
  NAG_FREE(ipiv);
}

f04agc

Withdrawn at Mark 25.
Replaced by f07fec.

It is assumed that the matrix has been factorized by a call to f07fdc rather than f03aec. The array p is no longer required.

void f03aec_replacement(Integer n, double a[], Integer tda,
double p[], double *detf, Integer *dete, NagError *fail)
{
  /* nag_lapacklin_dpotrf /*
  f07fdc(Nag_RowMajor, Nag_Upper, n, a, tda, fail);
  /* nag_det_real_sym */
  f03bfc(Nag_RowMajor, n, a, tda, detf, dete, fail);
  /* p is not used */
  /* the factorization in a will be different */
}

void f04agc_replacement(Integer n, Integer nrhs, double a[],
   Integer tda, double p[], const double b[], Integer tdb, double x[],
   Integer tdx, NagError *fail)
{
  /* nag_blast_dge_copy */
  f16qfc(Nag_RowMajor, Nag_NoTrans, n, nrhs, b, tdb, x, tdx, fail);
  /* nag_lapacklin_dpotrs */
  f07fec(Nag_RowMajor, Nag_Upper, n, nrhs, a, tda, x, tdx, fail);
  /* p is not used */
}

f04ajc

Withdrawn at Mark 25.
Replaced by f07aec.

It is assumed that the matrix has been factorized by a call to f07adc rather than f03afc.

void f03afc_replacement(Integer n, double a[], Integer tda,
   Integer pivot[], double *detf, Integer *dete, NagError *fail)
{
  /* nag_lapacklin_dgetrf */
  f07adc(Nag_RowMajor, n, n, a, tda, pivot, fail);
  /* nag_det_real_gen */
  f03bac(Nag_RowMajor, n, a, tda, pivot, detf, dete, fail);
  /* the call to f03bac is not needed if you don't want determinants */
}

void f04ajc_replacement(Integer n, Integer nrhs, const double a[],
   Integer tda, const Integer pivot[], double b[], Integer tdb,
   NagError *fail)
{
  /* nag_lapacklin_dgetrs */
  f07aec(Nag_RowMajor, Nag_NoTrans, n, nrhs, a, tda, pivot, b, tdb, fail);
}

f04akc

Withdrawn at Mark 25.
Replaced by f07asc.

void f03ahc_replacement(Integer n, Complex a[], Integer tda,
Integer pivot[], Complex *det, Integer *dete, NagError *fail)
{
  Complex d={0,0};
  Integer id[2]={0,0};
  /* nag_lapacklin_zgetrf */
  f07arc(Nag_RowMajor, n, n, a, tda, pivot, fail);
  /* nag_det_complex_gen */
  f03bnc(Nag_RowMajor, n, a, tda, pivot, &d, id, fail);
  /* Bring real and imaginary parts to a common scale */
  *dete = MAX(id[0],id[1]);
  det->re = ldexp(d.re,id[0]-*dete);
  det->im = ldexp(d.im,id[1]-*dete);
  /* the factorization in a will be different */
}

void f04akc_replacement(Integer n, Integer nrhs, const Complex a[],
  Integer tda, const Integer pivot[], Complex b[], Integer tdb,
  NagError *fail)
{
  /* nag_lapacklin_zgetrs */
   f07asc(Nag_RowMajor, Nag_NoTrans, n, nrhs, a, tda, pivot, b, tdb, fail );
}

It is assumed that the matrix has been factorized by a call to f07arc rather than f03ahc.

f04arc

Withdrawn at Mark 25.
Replaced by f04bac.

void  f04arc_replacement(Integer n, double a[], Integer tda,
  const double b[], double x[], NagError *fail)
{
  Integer *ipiv;
  double rcond, errbnd;

  ipiv = NAG_ALLOC(n, Integer);
  /* nag_blast_dge_copy */
  f16qfc(Nag_RowMajor, Nag_NoTrans, n, 1, b, 1, x, 1, fail);
  /* nag_linsys_real_square_solve */
  f04bac(Nag_RowMajor, n, 1, a, tda, ipiv, x, 1,
	 &rcond, &errbnd, fail);
  /* The factorization in a will be different */
  /* Error codes will be different */
  /* Condition number and error bounds are available to you */
  NAG_FREE(ipiv);
}

f04awc

Withdrawn at Mark 25.
Replaced by f07fsc.

void f01bnc_replacement(Integer n, Complex a[], Integer tda,
  double p[], NagError *fail)
{
  /* nag_lapacklin_zpotrf */
  f07frc(Nag_RowMajor, Nag_Lower, n, a, tda, fail);
}

void f04awc_replacement(Integer n, Integer nrhs, const Complex a[],
  Integer tda, const double p[], const Complex b[],
  Integer tdb, Complex x[], Integer tdx, NagError *fail)
{
  /* nag_blast_zge_copy */
  f16tfc(Nag_RowMajor, Nag_NoTrans, n, nrhs, b, tdb, x, tdx, fail);
  /* nag_lapacklin_zpotrs */
  f07fsc(Nag_RowMajor, Nag_Lower, n, nrhs, a, tda, x, tdx, fail);
}

Note that the preceding call to f01bnc has been replaced by f07frc.

F06 – Linear Algebra Support Functions

The functions in Chapter f16 provide greater functionality than their corresponding functions in Chapter f06. The essential differences are:

The order argument. This provides the flexibility to operate on matrix data stored in row or column major order.
The addition of the fail argument to trap data errors. The f06 functions used to abort noisily.
The enumeration types and members use NAG_ as the prefix. This is to guard against accidental use of non-NAG enums.
Scale factors have been introduced in some functions. For example nag_dtrmv (f16pfc) has an extra argument, alpha which was not present in the corresponding old_dtrmv (f06pfc) function.

f06pac

Withdrawn at Mark 23.
Replaced by f16pac.

f06pbc

Withdrawn at Mark 23.
Replaced by f16pbc.

f06pcc

Withdrawn at Mark 23.
Replaced by f16pcc.

f06pdc

Withdrawn at Mark 23.
Replaced by f16pdc.

f06pec

Withdrawn at Mark 23.
Replaced by f16pec.

f06pfc

Withdrawn at Mark 23.
Replaced by f16pfc.

f06pgc

Withdrawn at Mark 23.
Replaced by f16pgc.

f06phc

Withdrawn at Mark 23.
Replaced by f16phc.

f06pjc

Withdrawn at Mark 23.
Replaced by f16pjc.

f06pkc

Withdrawn at Mark 23.
Replaced by f16pkc.

f06plc

Withdrawn at Mark 23.
Replaced by f16plc.

f06pmc

Withdrawn at Mark 23.
Replaced by f16pmc.

f06ppc

Withdrawn at Mark 23.
Replaced by f16ppc.

f06pqc

Withdrawn at Mark 23.
Replaced by f16pqc.

f06prc

Withdrawn at Mark 23.
Replaced by f16prc.

f06psc

Withdrawn at Mark 23.
Replaced by f16psc.

f06sac

Withdrawn at Mark 23.
Replaced by f16sac.

f06sbc

Withdrawn at Mark 23.
Replaced by f16sbc.

f06scc

Withdrawn at Mark 23.
Replaced by f16scc.

f06sdc

Withdrawn at Mark 23.
Replaced by f16sdc.

f06sec

Withdrawn at Mark 23.
Replaced by f16sec.

f06sfc

Withdrawn at Mark 23.
Replaced by f16sfc.

f06sgc

Withdrawn at Mark 23.
Replaced by f16sgc.

f06shc

Withdrawn at Mark 23.
Replaced by f16shc.

f06sjc

Withdrawn at Mark 23.
Replaced by f16sjc.

f06skc

Withdrawn at Mark 23.
Replaced by f16skc.

f06slc

Withdrawn at Mark 23.
Replaced by f16slc.

f06smc

Withdrawn at Mark 23.
Replaced by f16smc.

f06snc

Withdrawn at Mark 23.
Replaced by f16smc.

f06spc

Withdrawn at Mark 23.
Replaced by f16spc.

f06sqc

Withdrawn at Mark 23.
Replaced by f16sqc.

f06src

Withdrawn at Mark 23.
Replaced by f16src.

f06ssc

Withdrawn at Mark 23.
Replaced by f16ssc.

f06yac

Withdrawn at Mark 23.
Replaced by f16yac.

f06ycc

Withdrawn at Mark 23.
Replaced by f16ycc.

f06yfc

Withdrawn at Mark 23.
Replaced by f16yfc.

f06yjc

Withdrawn at Mark 23.
Replaced by f16yjc.

f06ypc

Withdrawn at Mark 23.
Replaced by f16ypc.

f06yrc

Withdrawn at Mark 23.
Replaced by f16yrc.

f06zac

Withdrawn at Mark 23.
Replaced by f16zac.

f06zcc

Withdrawn at Mark 23.
Replaced by f16zcc.

f06zfc

Withdrawn at Mark 23.
Replaced by f16zfc.

f06zjc

Withdrawn at Mark 23.
Replaced by f16zjc.

f06zpc

Withdrawn at Mark 23.
Replaced by f16zpc.

f06zrc

Withdrawn at Mark 23.
Replaced by f16zrc.

f06ztc

Withdrawn at Mark 23.
Replaced by f16ztc.

f06zuc

Withdrawn at Mark 23.
Replaced by f16zuc.

f06zwc

Withdrawn at Mark 23.
Replaced by f16zwc.

F08 – Least Squares and Eigenvalue Problems (LAPACK)

For each of the deprecated functions listed below, the replacement function has an identical interface. This disguises algorithmic changes that improve performance at the cost of larger internal memory allocation.

f08bec

Deprecated.
Replaced by f08bfc.

f08bsc

Deprecated.
Replaced by f08btc.

f08vac

Deprecated.
Replaced by f08vcc.

f08vec

Deprecated.
Replaced by f08vgc.

f08vnc

Deprecated.
Replaced by f08vqc.

f08vsc

Deprecated.
Replaced by f08vuc.

f08wac

Deprecated.
Replaced by f08wcc.

f08wec

Deprecated.
Replaced by f08wfc.

f08wnc

Deprecated.
Replaced by f08wqc.

f08wsc

Deprecated.
Replaced by f08wtc.

f08xac

Deprecated.
Replaced by f08xcc.

f08xnc

Deprecated.
Replaced by f08xqc.

G01 – Simple Calculations on Statistical Data

g01aac

Withdrawn at Mark 26.
Replaced by g01atc.

Withdrawn because on output, additional information was needed to allow large datasets to be processed in blocks and the results combined through a call to g01auc. This information is returned in rcomm.

Old Code

/* g01aac */
nag_stat_withdraw_summary_1var(n, x, wt, &nvalid, &xmean, &xsd, &xskew,
                       &xkurt,&xmin, &xmax, &wsum, &fail);

New Code

/* g01atc */
pn = 0;
nag_stat_summary_onevar(n, x, wt, &pn, &xmean, &xsd, &xskew, &xkurt,
                         &xmin, &xmax, rcomm, &fail);
nvalid = pn;
     wtsum = rcomm[0];

g01cec

Withdrawn at Mark 24.
Replaced by g01fac.

Old Code

x = nag_deviates_normal_dist(p, &fail);

New Code

x = nag_deviates_normal(Nag_LowerTail, p, &fail);

G02 – Correlation and Regression Analysis

g02ewc

Withdrawn at Mark 25.
Replaced by g02efh (see monfun in g02efc).

Old Code

nag_correg_(flag, var, val, &fail)

New Code

nag_correg_linregm_fit_stepwise_sample_monfun(flag, var, val, &fail)

Note: it is unlikely that you will need to call this function directly. Rather it will be supplied as a function argument to g02efc when monitoring information is required.

g02jac
g02jbc
g02jcc
g02jdc
g02jec

Deprecated.

For each of the routines g02jac, g02jbc, g02jcc, g02jdc and g02jec there is not a direct one-to-one replacement, rather they have been replaced with a new suite of routines. This new suite allows a linear mixed effects model to be specified using a modelling language; giving a more natural way of specifying the model, allowing interaction terms to be specified and means that it is no longer necessary to create dummy variables when the model contains categorical variables.

The new suite of routines consists of:

g22ybc used to describe the dataset of interest. Calling this function allows labels to be assign to variables, which can then be used when specifying the model.
g22yac multiple calls to this routine are used to specify the fixed and random part of the model. The model is specified using strings and a modelling language, for example the string: $V_{1} + V_{2} + V_{1} . V_{1}$ would specify a model with the main effects of variables $V_{1}$ and $V_{2}$ and the interaction term between them. The modelling language is explained in detail in Section 3 in g22yac.
g02jfc pre-processes the dataset prior to calling the model fitting routine.
g02jhc fits the model and returns the parameter estimates etc.

In addition to the routines listed above, the following can also be used:

g02jgc combines information returned by multiple calls to g02jfc. This is useful for large problems as it allows the dataset to be split up into smaller subsets of data, pre-processing each one separately before combining them into a single set of information as if g02jfc had been called on the full dataset.
g22ydc can be used to obtain labels for the parameter estimates returned by g02jhc.
g22zmc can be used to set any optional arguments.
g22znc can be used to return the value of any optional arguments.

By default, the model fitting routine, g02jhc, fits the linear mixed effects model using restricted maximum likelihood (REML). In order to fit the model using maximum likelihood (ML) you need to call the optional argument setting routine, g22zmc with optstr set to

Likelihood = ML

, between the call to g02jfc and the call to g02jhc.

G05 – Random Number Generators

g05cac

Withdrawn at Mark 24.
Replaced by g05sac.

Old Code

    /* g05cac */
    for (i = 0; i < n; i++)
 x[i] = nag_random_continuous_uniform();

New Code

    /* g05sac */
    nag_rand_dist_uniform01(n,state,x,&fail);

The Integer array state in the call to g05sac contains information on the base generator being used. This array must have been initialized prior to calling g05sac with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05sac is likely to be different from those produced by g05cac.

g05cbc

Withdrawn at Mark 24.
Replaced by g05kfc.

Old Code

/* g05cbc */
nag_random_init_repeatable(i);

New Code

lseed = 1;
seed[0] = i;
genid = Nag_Basic;
subid = 1;

/* g05kfc */
nag_rand_init_repeat(genid,subid,seed,lseed,state,&lstate,&fail);

The Integer array state in the call to g05kfc contains information on the base generator being used. The base generator is chosen via the integer arguments 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 g05kfc is likely to be different from a sequence produced by a generator initialized by g05cbc, even if the same value for i is used.

Note: it may still be necessary to call g05cbc rather than the replacement function g05kfc when using d01xbc. See Section 10 in d01xbc for additional information.

g05ccc

Withdrawn at Mark 24.
Replaced by g05kgc.

Old Code

/* g05ccc */
nag_random_init_nonrepeatable();

New Code

genid = Nag_Basic;
subid = 1;

/* g05kgc */
nag_rand_init_nonrepeat(genid,subid,state,&lstate,&fail);

The Integer array state in the call to g05kgc contains information on the base generator being used. The base generator is chosen via the integer arguments genid and subid. The required length of the array state depends on the base generator chosen.

Note: it may still be necessary to call g05ccc rather than the replacement function g05kgc when using d01xbc. See Section 10 in d01xbc for additional information.

g05cfc

Withdrawn at Mark 24.
There is no replacement for this function.

Old Code

/* g05cfc */
nag_save_random_state(istate,xstate);

New Code

for (i = 0; i < lstate; i++)
  istate[i] = state[i];

The state of the base generator for the group of functions g05kfc, g05kgc, g05khc, g05kjc, g05ncc, g05ndc, g05pdc–g05pzc, g05rcc–g05rzc, 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 functions, therefore either this number of elements can be copied, or the whole array (as defined in the calling program).

g05cgc

Withdrawn at Mark 24.
There is no replacement for this function.

Old Code

/* g05cgc */
nag_restore_random_state(istate,xstate,&fail);

New Code

for (i = 0; i < lstate; i++)
  state[i] = istate[i];

The state of the base generator for the group of functions g05kfc, g05kgc, g05khc, g05kjc, g05ncc, g05ndc, g05pdc–g05pzc, g05rcc–g05rzc, 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 functions, therefore either this number of elements can be copied, or the whole array (as defined in the calling program).

g05dac

Withdrawn at Mark 24.
Replaced by g05sqc.

Old Code

for (i = 0; i < n; i++)
  /* g05dac */
  x[i] =  nag_random_continuous_uniform_ab(aa,bb);

New Code

a = (aa < bb) ? aa : bb;
b = (aa < bb) ? bb : aa;

/* g05sqc */
nag_rand_dist_uniform(n,a,b,state,x,&fail);

The old function g05dac returns a single variate at a time, whereas the new function g05sqc returns a vector of n values in one go. In g05sqc the minimum value must be held in the argument a and the maximum in argument b, therefore

a < b

. This was not the case for the equivalent arguments in g05dac.

The Integer array state in the call to g05sqc contains information on the base generator being used. This array must have been initialized prior to calling g05sqc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05sqc is likely to be different from those produced by g05dac.

g05dbc

Withdrawn at Mark 24.
Replaced by g05sfc.

Old Code

for (i = 0; i < n; i++)
  /* g05dbc */
  x[i] = nag_random_exp(aa);

New Code

a = fabs(aa);

/* g05sfc */
nag_rand_dist_exp(n,a,state,x,&fail);

The old function g05dbc returns a single variate at a time, whereas the new function g05sfc returns a vector of n values in one go. In g05sfc argument a must be non-negative, this was not the case for the equivalent argument in g05dbc.

The Integer array state in the call to g05sfc contains information on the base generator being used. This array must have been initialized prior to calling g05sfc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05sfc is likely to be different from those produced by g05dbc.

g05ddc

Withdrawn at Mark 24.
Replaced by g05skc.

Old Code

    for (i = 0; i < n; i++)
 /* g05ddc */
 x[i] = nag_random_normal(xmu,sd);

New Code

/* g05skc */
nag_rand_dist_normal(n,xmu,var,state,x,&fail);

The old function g05ddc returns a single variate at a time, whereas the new function g05skc returns a vector of n values in one go. g05skc expects the variance of the Normal distribution (argument var), compared to g05ddc which expected the standard deviation.

The Integer array state in the call to g05skc contains information on the base generator being used. This array must have been initialized prior to calling g05skc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05skc is likely to be different from those produced by g05ddc.

g05dyc

Withdrawn at Mark 24.
Replaced by g05tlc.

Old Code

for (i = 0; i < n; i++)
   /* g05dyc */
   x[i] = nag_random_discrete_uniform(aa,bb);

New Code

a = (aa < bb) ? aa : bb;
b = (aa < bb) ? bb : aa;
/* g05tlc */
nag_rand_int_uniform(n,a,b,state,x,&fail);

The old function g05dyc returns a single variate at a time, whereas the new function g05tlc returns a vector of n values in one go. In g05tlc the minimum value must be held in the argument a and the maximum in argument b, therefore

a \leq b

. This was not the case for the equivalent arguments in g05dyc.

The Integer array state in the call to g05tlc contains information on the base generator being used. This array must have been initialized prior to calling g05tlc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05tlc is likely to be different from those produced by g05dyc.

g05eac

Withdrawn at Mark 24.
Replaced by g05rzc.

Old Code

/* g05eac */
nag_ref_vec_multi_normal(a,m,c,tdc,eps,&r,&fail);

New Code

order = Nag_RowMajor;
mode = Nag_InitializeReference;
lr = m * (m + 1) + 1;
r = NAG_ALLOC(lr,double);

/* g05rzc */
nag_rand_multivar_normal(order,mode,n,m,a,c,tdc,r,lr,
   state,x,pdx,&fail);

The old function g05eac sets up a reference vector for use by g05ezc. The functionality of both these functions has been combined into the single new function g05rzc. Setting

mode = Nag_InitializeReference

in the call to g05rzc only sets up the double reference vector r and hence mimics the functionality of g05eac.

The length of the double reference vector, r, in g05rzc must be at least

m \times (m + 1) + 1

. In contrast to the equivalent argument in g05eac, this array must be allocated in the calling program.

g05ecc

Withdrawn at Mark 24.
Replaced by g05tjc.

Old Code

/* g05ecc */
nag_ref_vec_poisson(t,&r,&fail);
for (i = 0; i < n; i++)
  /* g05eyc */
  x[i] = nag_return_discrete(r);

New Code

mode = Nag_InitializeAndGenerate;
lr = 30 + (Integer) (20 * sqrt(t) + t);
r = NAG_ALLOC(lr,double);

/* g05tjc */
nag_rand_int_poisson(mode,n,t,r,lr,state,x,&fail);

The old function g05ecc sets up a reference vector for use by g05eyc. The replacement function g05tjc is now used to both set up a reference vector and generate the required variates. Setting

mode = Nag_InitializeReference

in the call to g05tjc sets up the double reference vector r and hence mimics the functionality of g05ecc. Setting

mode = Nag_GenerateFromReference

generates a series of variates from a reference vector mimicking the functionality of g05eyc for this particular distribution. Setting

mode = Nag_InitializeAndGenerate

initializes the reference vector and generates the variates in one go.

The function g05eyc returns a single variate at a time, whereas the new function g05tjc returns a vector of n values in one go.

The length of the double reference vector, r, in g05tjc, must be allocated in the calling program in contrast to the equivalent argument in g05ecc, see the documentation for more details.

The Integer array state in the call to g05tjc contains information on the base generator being used. This array must have been initialized prior to calling g05tjc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05tjc is likely to be different from those produced by a combination of g05ecc and g05eyc.

g05edc

Withdrawn at Mark 24.
Replaced by g05tac.

Old Code

/* g05edc */
nag_ref_vec_binomial(m,p,&r,&fail);
for (i = 0; i < n; i++)
  /* g05eyc */
  x[i] = nag_return_discrete(r);

New Code

mode = Nag_InitializeAndGenerate;
lr = 22 + 20 * ((Integer) sqrt(m * p * (1 - p)));
r = NAG_ALLOC(lr,double);

/* g05tac */
nag_rand_int_binomial(mode,n,m,p,r,lr,state,x,&fail);

The old function g05edc sets up a reference vector for use by g05eyc. The replacement function g05tac is now used to both set up a reference vector and generate the required variates. Setting

mode = Nag_InitializeReference

in the call to g05tac sets up the double reference vector r and hence mimics the functionality of g05edc. Setting

mode = Nag_GenerateFromReference

generates a series of variates from a reference vector mimicking the functionality of g05eyc for this particular distribution. Setting

mode = Nag_InitializeAndGenerate

initializes the reference vector and generates the variates in one go.

The function g05eyc returns a single variate at a time, whereas the new function g05tac returns a vector of n values in one go.

The length of the double reference vector, r, in g05tac, needs to be a different length from the equivalent argument in g05edc, see the documentation for more details.

The Integer array state in the call to g05tac contains information on the base generator being used. This array must have been initialized prior to calling g05tac with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05tac is likely to be different from those produced by a combination of g05edc and g05eyc.

g05ehc

Withdrawn at Mark 24.
Replaced by g05ncc.

Old Code

/* g05ehc */
 nag_ran_permut_vec(index,n,&fail);

New Code

/* g05ncc */
nag_rand_permute(index,n,state,&fail);

The Integer array state in the call to g05ncc contains information on the base generator being used. This array must have been initialized prior to calling g05ncc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05ncc is likely to be different from those produced by g05ehc.

g05ejc

Withdrawn at Mark 24.
Replaced by g05ndc.

Old Code

/* g05ejc */
nag_ran_sample_vec(ia,n,iz,m,&fail);

New Code

/* g05ndc */
nag_rand_sample(ia,n,iz,m,state,&fail);

The Integer array state in the call to g05ndc contains information on the base generator being used. This array must have been initialized prior to calling g05ndc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05ndc is likely to be different from those produced by g05ejc.

g05exc

Withdrawn at Mark 24.
Replaced by g05tdc.

Old Code

/* g05exc */
nag_ref_vec_discrete_pdf_cdf(p,np,sizep,distf,&r,&fail);
for (i = 0; i < n; i++)
  /* g05eyc */
  x[i] = nag_return_discrete(r);

New Code

mode = Nag_InitializeAndGenerate;
lr = 10 + (Integer) (1.4 * np);
r = NAG_ALLOC(lr,double);

/* g05tdc */
nag_rand_int_general(mode,n,p,np,sizep,distf,r,lr,state,x,&fail);

The old function g05exc sets up a reference vector for use by g05eyc. The replacement function g05tdc is now used to both set up a reference vector and generate the required variates. Setting

mode = Nag_InitializeReference

in the call to g05tdc sets up the double reference vector r and hence mimics the functionality of g05exc. Setting

mode = Nag_GenerateFromReference

generates a series of variates from a reference vector mimicking the functionality of g05eyc for this particular distribution. Setting

mode = Nag_InitializeAndGenerate

initializes the reference vector and generates the variates in one go.

The function g05eyc returns a single variate at a time, whereas the new function g05tdc returns a vector of n values in one go.

The length of the double reference vector, r, in g05tdc must be allocated in the calling program in contrast to the equivalent argument in g05exc, see the documentation for more details.

The Integer array state in the call to g05tdc contains information on the base generator being used. This array must have been initialized prior to calling g05tdc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05tdc is likely to be different from those produced by a combination of g05exc and g05eyc.

g05eyc

Withdrawn at Mark 24.
Replaced by g05tdc.

There is no direct replacement function for g05eyc.

g05eyc is designed to generate random draws from a distribution defined by a reference vector. These reference vectors are created by other functions in Chapter G05, for example g05ecc, which have themselves been superseded. In order to replace a call to g05eyc you must identify which NAG function generated the reference vector being used and look up its replacement. For example, to replace a call to g05eyc preceded by a call to g05exc, as in:

/* g05exc */
nag_ref_vec_discrete_pdf_cdf(p,np,sizep,distf,&r,&fail);
/* g05eyc */
x = nag_return_discrete(r);

you would need to look at the replacement function for g05exc.

g05ezc

Withdrawn at Mark 24.
Replaced by g05rzc.

Old Code

#define X(I,J) x[(I*pdx + J)]
/* g05eac */
nag_ref_vec_multi_normal(a,m,c,tdc,eps,&r,&fail);
for (i = 0; i < n; i++) {
  /* g05ezc */
  nag_return_multi_normal(z,r);
  for (j = 0; j < m; j++)
    X(i,j) = z[j];
}

New Code

order = Nag_RowMajor;
mode = Nag_InitializeAndGenerate;
     lr = m * (m + 1) + 1;     r = NAG_ALLOC(lr,double);
/* g05rzc */
nag_rand_multivar_normal(order,mode,n,m,a,c,tdc,r,lr,
   state,x,pdx,&fail);

The old function g05eac sets up a reference vector for use by g05ezc. The functionality of both these functions has been combined into the single new function g05rzc. Setting

mode = Nag_InitializeAndGenerate

in the call to g05rzc sets up the double reference vector r and generates the draws from the multivariate Normal distribution in one go.

The old function g05ezc returns a single (m-dimensional vector) draw from the multivariate Normal distribution at a time, whereas the new function g05rzc returns an n by m matrix of n draws in one go.

The Integer array state in the call to g05rzc contains information on the base generator being used. This array must have been initialized prior to calling g05rzc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05rzc is likely to be different from those produced by g05ezc.

g05fec

Withdrawn at Mark 24.
Replaced by g05sbc.

Old Code

/* g05fec */
    nag_random_beta(a,b,n,x,&fail);

New Code

/* g05sbc */
nag_rand_dist_beta(n,a,b,state,x,&fail);

The Integer array state in the call to g05sbc contains information on the base generator being used. This array must have been initialized prior to calling g05sbc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05sbc is likely to be different from those produced by g05fec.

g05ffc

Withdrawn at Mark 24.
Replaced by g05sjc.

Old Code

/* g05ffc */
nag_random_gamma(a,b,n,x,&fail);

New Code

/* g05sjc */
nag_rand_dist_gamma(n,a,b,state,x,&fail);

The Integer array state in the call to g05sjc contains information on the base generator being used. This array must have been initialized prior to calling g05sjc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05sjc is likely to be different from those produced by g05ffc.

g05hac

Withdrawn at Mark 24.
Replaced by g05phc.

Old Code

/* g05hac */
nag_arma_time_series(start,p,q,phi,theta,mean,vara,n,w,ref,&fail);

New Code

mode = (start == Nag_TRUE) ? Nag_InitializeAndGenerate :
       Nag_GenerateFromReference;
lr = (p > q + 1) ? p : q + 1;
lr += p + q + 6;
r = NAG_ALLOC(lr,double);

/* g05phc */
nag_rand_times_arma(mode,n,mean,p,phi,q,theta,vara,r,lr,state,&var,x,&fail);

The Integer array state in the call to g05phc contains information on the base generator being used. This array must have been initialized prior to calling g05phc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05phc is likely to be different from those produced by g05hac.

g05hkc

Withdrawn at Mark 24.
Replaced by g05pdc.

Old Code

/* g05hkc */
nag_rand_withdraw_times_garch_asym1(num,p,q,theta,gamma,ht,et,fcall,rvec,&fail);

New Code

dist = Nag_NormalDistn;
df = 0;
bfcall = (fcall == Nag_Garch_Fcall_True) ? Nag_TRUE : Nag_FALSE;
lr = 2 * (p + q + 2);
r = NAG_ALLOC(lr,double);

/* g05pdc */
nag_rand_times_garch_asym1(dist,num,p,q,theta,gamma,df,ht,et,bfcall,r,lr,
   state,&fail);

The Integer array state in the call to g05pdc contains information on the base generator being used. This array must have been initialized prior to calling g05pdc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05pdc is likely to be different from those produced by g05hkc.

g05hlc

Withdrawn at Mark 24.
Replaced by g05pec.

Old Code

/* g05hlc */
nag_rand_withdraw_times_garch_asym2(num,p,q,theta,gamma,ht,et,fcall,rvec,&fail);

New Code

dist = Nag_NormalDistn;
df = 0;
bfcall = (fcall == Nag_Garch_Fcall_True) ? Nag_TRUE : Nag_FALSE;
lr = 2 * (p + q + 2);
r = NAG_ALLOC(lr,double);

/* g05pec */
nag_rand_times_garch_asym2(dist,num,p,q,theta,gamma,df,ht,et,bfcall,r,lr,
   state,&fail);

The Integer array state in the call to g05pec contains information on the base generator being used. This array must have been initialized prior to calling g05pec with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05pec is likely to be different from those produced by g05hlc.

g05hmc

Withdrawn at Mark 24.
Replaced by g05pfc.

Old Code

/* g05hmc */
nag_rand_withdraw_times_garch_gjr(num,p,q,theta,gamma,ht,et,fcall,rvec,&fail);

New Code

dist = Nag_NormalDistn;
df = 0;
bfcall = (fcall == Nag_Garch_Fcall_True) ? Nag_TRUE : Nag_FALSE;
lr = 2 * (p + q + 2);
r = NAG_ALLOC(lr,double);

/* g05pfc */
nag_rand_times_garch_gjr(dist,num,p,q,theta,gamma,df,ht,et,bfcall,r,lr,
   state,&fail);

The Integer array state in the call to g05pfc contains information on the base generator being used. This array must have been initialized prior to calling g05pfc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization. Due to changes in the underlying code the sequence of values produced by g05pfc is likely to be different from those produced by g05hmc.

g05kac

Withdrawn at Mark 24.
Replaced by g05sac.

Old Code

for (i = 0; i < n; i++) 
  /* g05kac */
  x[i] = nag_rand_withdraw_dist_uniform01(igen,iseed);

New Code

/* g05sac */
nag_rand_dist_uniform01(n,state,x,&fail);

The old function g05kac returns a single variate at a time, whereas the new function g05sac returns a vector of n values in one go.

g05kbc

Withdrawn at Mark 24.
Replaced by g05kfc.

Old Code

/* g05kbc */
nag_rand_withdraw_init_repeat(&igen,iseed);

New Code

if (igen == 0) {
  genid = Nag_Basic;
  subid = 1;
} else if (igen >= 1) { 
  genid = Nag_WichmannHill_I;
  subid = igen;
}

/* g05kfc */
nag_rand_init_repeat(genid,subid,iseed,lseed,state,&lstate,&fail);

g05kcc

Withdrawn at Mark 24.
Replaced by g05kgc.

Old Code

/* g05kcc */
nag_rand_withdraw_init_nonrepeat(&igen,iseed);

New Code

if (igen == 0) {
  genid = Nag_Basic;
  subid = 1;
} else if (igen >= 1) { 
  genid = Nag_WichmannHill_I;
  subid = igen;
}

/* g05kgc */
nag_rand_init_nonrepeat(genid,subid,state,&lstate,&fail);

g05kec

Withdrawn at Mark 24.
Replaced by g05tbc.

Old Code

for (i = 0; i < n; i++)
   /* g05kec */
   x[i] = nag_rand_withdraw_logical(p,igen,iseed,&fail);

New Code

/* g05tbc */
nag_rand_logical(n,p,state,x,&fail);

The old function g05kec returns a single variate at a time, whereas the new function g05tbc returns a vector of n values in one go.

The Integer array state in the call to g05tbc contains information on the base generator being used. This array must have been initialized prior to calling g05tbc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05lac

Withdrawn at Mark 24.
Replaced by g05skc.

Old Code

/* g05lac */
nag_rand_withdraw_dist_normal(xmu,var,n,x,igen,iseed,&fail);

New Code

/* g05skc */
nag_rand_dist_normal(n,xmu,var,state,x,&fail);

g05lbc

Withdrawn at Mark 24.
Replaced by g05snc.

Old Code

/* g05lbc */
nag_rand_withdraw_dist_students_t(df,n,x,igen,iseed,&fail);

New Code

/* g05snc */
nag_rand_dist_students_t(n,df,state,x,&fail);

The Integer array state in the call to g05snc contains information on the base generator being used. This array must have been initialized prior to calling g05snc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05lcc

Withdrawn at Mark 24.
Replaced by g05sdc.

Old Code

/* g05lcc */
nag_rand_withdraw_dist_chisq(df,n,x,igen,iseed,&fail);

New Code

/* g05sdc */
nag_rand_dist_chisq(n,df,state,x,&fail);

The Integer array state in the call to g05sdc contains information on the base generator being used. This array must have been initialized prior to calling g05sdc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05ldc

Withdrawn at Mark 24.
Replaced by g05shc.

Old Code

/* g05ldc */
nag_rand_withdraw_dist_f(df1,df2,n,x,igen,iseed,&fail);

New Code

/* g05shc */
nag_rand_dist_f(n,df1,df2,state,x,&fail);

The Integer array state in the call to g05shc contains information on the base generator being used. This array must have been initialized prior to calling g05shc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05lec

Withdrawn at Mark 24.
Replaced by g05sbc.

Old Code

/* g05lec */
nag_rand_withdraw_dist_beta(a,b,n,x,igen,iseed,&fail);

New Code

/* g05sbc */
nag_rand_dist_beta(n,a,b,state,x,&fail);

g05lfc

Withdrawn at Mark 24.
Replaced by g05sjc.

Old Code

/* g05lfc */
nag_rand_withdraw_dist_gamma(a,b,n,x,igen,iseed,&fail);

New Code

/* g05sjc */
nag_rand_dist_gamma(n,a,b,state,x,&fail);

g05lgc

Withdrawn at Mark 24.
Replaced by g05sqc.

Old Code

/* g05lgc */
nag_rand_withdraw_dist_uniform(a,b,n,x,igen,iseed,&fail);

New Code

/* g05sqc */
nag_rand_dist_uniform(n,a,b,state,x,&fail);

g05lhc

Withdrawn at Mark 24.
Replaced by g05spc.

Old Code

/* g05lhc */
nag_rand_withdraw_dist_triangular(xmin,xmax,xmed,n,x,igen,iseed,&fail);

New Code

/* g05spc */
nag_rand_dist_triangular(n,xmin,xmed,xmax,state,x,&fail);

The Integer array state in the call to g05spc contains information on the base generator being used. This array must have been initialized prior to calling g05spc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05ljc

Withdrawn at Mark 24.
Replaced by g05sfc.

Old Code

/* g05ljc */
nag_rand_withdraw_dist_exp(a,n,x,igen,iseed,&fail);

New Code

/* g05sfc */
nag_rand_dist_exp(n,a,state,x,&fail);

g05lkc

Withdrawn at Mark 24.
Replaced by g05smc.

Old Code

/* g05lkc */
nag_rand_withdraw_dist_lognormal(xmu,var,n,x,igen,iseed,&fail);

New Code

/* g05smc */
nag_rand_dist_lognormal(n,xmu,var,state,x,&fail);

The Integer array state in the call to g05smc contains information on the base generator being used. This array must have been initialized prior to calling g05smc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05llc

Withdrawn at Mark 24.
Replaced by g05scc.

Old Code

/* g05llc */
nag_rand_withdraw_dist_cauchy(xmed,semiqr,n,x,igen,iseed,&fail);

New Code

/* g05scc */
nag_rand_dist_cauchy(n,xmed,semiqr,state,x,&fail);

The Integer array state in the call to g05scc contains information on the base generator being used. This array must have been initialized prior to calling g05scc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05lmc

Withdrawn at Mark 24.
Replaced by g05ssc.

Old Code

/* g05lmc */
nag_rand_withdraw_dist_weibull(a,b,n,x,igen,iseed,&fail);

New Code

/* g05ssc */
nag_rand_dist_weibull(n,a,b,state,x,&fail);

The Integer array state in the call to g05ssc contains information on the base generator being used. This array must have been initialized prior to calling g05ssc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05lnc

Withdrawn at Mark 24.
Replaced by g05slc.

Old Code

/* g05lnc */
nag_rand_withdraw_dist_logistic(a,b,n,x,igen,iseed,&fail);

New Code

/* g05slc */
 nag_rand_dist_logistic(n,a,b,state,x,&fail);

The Integer array state in the call to g05slc contains information on the base generator being used. This array must have been initialized prior to calling g05slc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05lpc

Withdrawn at Mark 24.
Replaced by g05src.

Old Code

/* g05lpc */
nag_rand_withdraw_dist_vonmises(vk,n,x,igen,iseed,&fail);

New Code

/* g05src */
nag_rand_dist_vonmises(n,vk,state,x,&fail);

The Integer array state in the call to g05src contains information on the base generator being used. This array must have been initialized prior to calling g05src with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05lqc

Withdrawn at Mark 24.
Replaced by g05sgc.

Old Code

/* g05lqc */
nag_rand_withdraw_dist_expmix(nmix,a,wgt,n,x,igen,iseed,&fail);

New Code

/* g05sgc */
nag_rand_dist_expmix(n,nmix,a,wgt,state,x,&fail);

The Integer array state in the call to g05sgc contains information on the base generator being used. This array must have been initialized prior to calling g05sgc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05lxc

Withdrawn at Mark 24.
Replaced by g05ryc.

Old Code

/* g05lxc */
nag_rand_withdraw_multivar_students_t(order,mode,df,m,xmu,c,pdc,n,x,pdx,
   igen,iseed,r,lr,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeAndGenerate;
} else if (mode == 1) {
  emode = Nag_InitializeReference;
} else if (mode == 2) {
  emode = Nag_GenerateFromReference;
}
lr = m * (m + 1) + 2;
r = NAG_ALLOC(lr,double);

/* g05ryc */
nag_rand_multivar_students_t(order,emode,n,df,m,xmu,c,pdc,r,lr,
   state,x,pdx,&fail);

The Integer array state in the call to g05ryc contains information on the base generator being used. This array must have been initialized prior to calling g05ryc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05lyc

Withdrawn at Mark 24.
Replaced by g05rzc.

Old Code

/* g05lyc */
nag_rand_withdraw_multivar_normal(order,mode,m,xmu,c,pdc,n,x,pdx,igen,
   iseed,r,lr,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeAndGenerate;
} else if (mode == 1) {
  emode = Nag_InitializeReference;
} else if (mode == 2) {
  emode = Nag_GenerateFromReference;
}
lr = m * (m + 1) + 1;
r = NAG_ALLOC(lr,double);

/* g05rzc */
nag_rand_multivar_normal(order,emode,n,m,xmu,c,pdc,r,lr,
   state,x,pdx,&fail);

g05lzc

Withdrawn at Mark 24.
Replaced by g05rzc.

Old Code

/* g05lzc */
nag_rand_withdraw_multivar_normal_svec(order,mode,m,xmu,c,pdc,x,igen,iseed,r,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeAndGenerate;
} else if (mode == 1) {
  emode = Nag_InitializeReference;
} else if (mode == 2) {
  emode = Nag_GenerateFromReference;
}
n = 1;
pdx = 1;
lr = m * (m + 1) + 1;
r = NAG_ALLOC(lr,double);

/* g05rzc */
nag_rand_multivar_normal(order,emode,n,m,xmu,c,pdc,r,lr,
   state,x,pdx,&fail);

g05mac

Withdrawn at Mark 24.
Replaced by g05tlc.

Old Code

/* g05mac */
nag_rand_withdraw_int_uniform(a,b,n,x,igen,iseed,&fail);

New Code

/* g05tlc */
nag_rand_int_uniform(n,a,b,state,x,&fail);

g05mbc

Withdrawn at Mark 24.
Replaced by g05tcc.

Old Code

/* g05mbc */
nag_rand_withdraw_int_geom(mode,p,n,x,igen,iseed,r,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeReference;
} else if (mode == 1) {
  emode = Nag_GenerateFromReference;
} else if (mode == 2) {
  emode = Nag_InitializeAndGenerate;
} else if (mode == 3) {
  emode = Nag_GenerateWithoutReference;
}
lr = (emode == Nag_GenerateWithoutReference) ? 1 : 
     8 + (Integer) (42 / p);
r = NAG_ALLOC(lr,double);

/* g05tcc */
nag_rand_int_geom(emode,n,p,r,lr,state,x,&fail);

g05mbc returned the number of trials required to get the first success, whereas g05tcc returns the number of failures before the first success, therefore the value returned by g05tcc is one less than the equivalent value returned from g05mbc.

The Integer array state in the call to g05tcc contains information on the base generator being used. This array must have been initialized prior to calling g05tcc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05mcc

Withdrawn at Mark 24.
Replaced by g05thc.

Old Code

/* g05mcc */
nag_rand_withdraw_int_negbin(mode,m,p,n,x,igen,iseed,r,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeReference;
} else if (mode == 1) {
  emode = Nag_GenerateFromReference;
} else if (mode == 2) {
  emode = Nag_InitializeAndGenerate;
} else if (mode == 3) {
  emode = Nag_GenerateWithoutReference;
}
lr = (emode == Nag_GenerateWithoutReference) ? 1 : 
     28 + (Integer) ((20 * sqrt(m*p) + 30 * p) / (1 - p));
r = NAG_ALLOC(lr,double);

/* g05thc */
nag_rand_int_negbin(emode,n,m,p,r,lr,state,x,&fail);

The Integer array state in the call to g05thc contains information on the base generator being used. This array must have been initialized prior to calling g05thc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05mdc

Withdrawn at Mark 24.
Replaced by g05tfc.

Old Code

/* g05mdc */
nag_rand_withdraw_int_log(mode,a,n,x,igen,iseed,r,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeReference;
} else if (mode == 1) {
  emode = Nag_GenerateFromReference;
} else if (mode == 2) {
  emode = Nag_InitializeAndGenerate;
} else if (mode == 3) {
  emode = Nag_GenerateWithoutReference;
}
lr = (emode == Nag_GenerateWithoutReference) ? 1 : 
     18 + (Integer) (40 / (1 - a));
r = NAG_ALLOC(lr,double);

/* g05tfc */
nag_rand_int_log(emode,n,a,r,lr,state,x,&fail);

The Integer array state in the call to g05tfc contains information on the base generator being used. This array must have been initialized prior to calling g05tfc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05mec

Withdrawn at Mark 24.
Replaced by g05tkc.

Old Code

/* g05mec */
nag_rand_withdraw_int_poisson_varmean(m,vlamda,x,igen,iseed,&fail);

New Code

/* g05tkc */
nag_rand_int_poisson_varmean(m,vlamda,state,x,&fail);

The Integer array state in the call to g05tkc contains information on the base generator being used. This array must have been initialized prior to calling g05tkc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05mjc

Withdrawn at Mark 24.
Replaced by g05tac.

Old Code

/* g05mjc */
nag_rand_withdraw_int_binomial(mode,m,p,n,x,igen,iseed,r,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeReference;
} else if (mode == 1) {
  emode = Nag_GenerateFromReference;
} else if (mode == 2) {
  emode = Nag_InitializeAndGenerate;
} else if (mode == 3) {
  emode = Nag_GenerateWithoutReference;
}
lr = (emode == Nag_GenerateWithoutReference) ? 1 : 
     22 + 20 * ((Integer) sqrt(m * p * (1 - p)));
r = NAG_ALLOC(lr,double);

/* g05tac */
nag_rand_int_binomial(emode,n,m,p,r,lr,state,x,&fail);

g05mkc

Withdrawn at Mark 24.
Replaced by g05tjc.

Old Code

/* g05mkc */
nag_rand_withdraw_int_poisson(mode,lambda,n,x,igen,iseed,r,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeReference;
} else if (mode == 1) {
  emode = Nag_GenerateFromReference;
} else if (mode == 2) {
  emode = Nag_InitializeAndGenerate;
} else if (mode == 3) {
  emode = Nag_GenerateWithoutReference;
}
lr = (emode == Nag_GenerateWithoutReference) ? 1 : 30 + 
     (Integer) (20 * sqrt(lambda) + lambda);
r = NAG_ALLOC(lr,double);

/* g05tjc */
nag_rand_int_poisson(emode,n,lambda,r,lr,state,x,&fail);

g05mlc

Withdrawn at Mark 24.
Replaced by g05tec.

Old Code

/* g05mlc */
nag_rand_withdraw_int_hypergeom(mode,ns,np,m,n,x,igen,iseed,r,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeReference;
} else if (mode == 1) {
  emode = Nag_GenerateFromReference;
} else if (mode == 2) {
  emode = Nag_InitializeAndGenerate;
} else if (mode == 3) {
  emode = Nag_GenerateWithoutReference;
}
lr = (emode == Nag_GenerateWithoutReference) ? 1 : 28 + 20 * 
     ((Integer) sqrt((ns * m * (np - m) * (np - ns)) / 
     (np * np * np)));
r = NAG_ALLOC(lr,double);

/* g05tec */
nag_rand_int_hypergeom(emode,n,ns,np,m,r,lr,state,x,&fail);

The Integer array state in the call to g05tec contains information on the base generator being used. This array must have been initialized prior to calling g05tec with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05mrc

Withdrawn at Mark 24.
Replaced by g05tgc.

Old Code

/* g05mrc */
nag_rand_withdraw_int_multinomial(order,mode,m,k,p,n,x,pdx,igen,iseed,r,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeReference;
} else if (mode == 1) {
  emode = Nag_GenerateFromReference;
} else if (mode == 2) {
  emode = Nag_InitializeAndGenerate;
} else if (mode == 3) {
  emode = Nag_GenerateWithoutReference;
}
pmax = p[0];
for (i = 1; i < k; i++)
  pmax = (pmax > p[i]) ? p[i] : pmax;
lr = (emode == Nag_GenerateWithoutReference) ? 1 : 30 + 
     20 * ((Integer) sqrt(m * pmax * (1 - pmax)));
r = NAG_ALLOC(lr,double);

/* g05tgc */
nag_rand_int_multinomial(order,emode,n,m,k,p,r,lr,state,x,pdx,&fail);

The Integer array state in the call to g05tgc contains information on the base generator being used. This array must have been initialized prior to calling g05tgc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05mzc

Withdrawn at Mark 24.
Replaced by g05tdc.

Old Code

/* g05mzc */
nag_rand_withdraw_int_general(mode,p,np,ip1,comp_type,n,x,igen,iseed,r,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeReference;
} else if (mode == 1) {
  emode = Nag_GenerateFromReference;
} else if (mode == 2) {
  emode = Nag_InitializeAndGenerate;
}
itype = (comp_type == Nag_Compute_1) ? Nag_PDF : Nag_CDF;
lr = 10 + (Integer) (1.4 * np);
r = NAG_ALLOC(lr,double);

/* g05tdc */
nag_rand_int_general(emode,n,p,np,ip1,itype,r,lr,state,x,&fail);

g05nac

Withdrawn at Mark 24.
Replaced by g05ncc.

Old Code

/* g05nac */
nag_rand_withdraw_permute(index,n,igen,iseed,&fail);

New Code

/* g05ncc */
nag_rand_permute(index,n,state,&fail);

g05nbc

Withdrawn at Mark 24.
Replaced by g05ndc.

Old Code

/* g05nbc */
nag_rand_withdraw_sample(ipop,n,isampl,m,igen,iseed,&fail);

New Code

/* g05ndc */
nag_rand_sample(ipop,n,isampl,m,state,&fail);

g05pac

Withdrawn at Mark 24.
Replaced by g05phc.

Old Code

/* g05pac */
nag_rand_withdraw_times_arma(mode,xmean,p,phi,q,theta,avar,&var,n,x,
   igen,iseed,r,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeReference;
} else if (mode == 1) {
  emode = Nag_GenerateFromReference;
} else if (mode == 2) {
  emode = Nag_InitializeAndGenerate;
}
lr = p + q + 6 * ((p < q + 1) ? q + 1 : p);
r = NAG_ALLOC(lr,double);

/* g05phc */
nag_rand_times_arma(emode,n,xmean,p,phi,q,theta,avar,r,lr,state,&var,x,
   &fail);

g05pcc

Withdrawn at Mark 24.
Replaced by g05pjc.

Old Code

/* g05pcc */
nag_rand_withdraw_times_mv_varma(order,mode,k,xmean,p,phi,q,theta,
   var,pdv,n,x,pdx,igen,iseed,r,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeReference;
} else if (mode == 1) {
  emode = Nag_GenerateFromReference;
} else if (mode == 2) {
  emode = Nag_InitializeAndGenerate;
} else if (mode == 3) {
  emode = Nag_ReGenerateFromReference;
}
tmp1 = (p > q) ? p : q;
if (p == 0) {
  tmp2 = k * (k + 1) / 2;
} else {
  tmp2 = k*(k+1)/2 + (p-1)*k*k;
}
tmp3 = p + q;
if (k >= 6) {
  lr = (5*tmp1*tmp1+1)*k*k + (4*tmp1+3)*k + 4;
} else {
  tmp4 = k*tmp1*(k*tmp1+2);
  tmp5 = k*k*tmp3*tmp3+tmp2*(tmp2+3)+k*k*(q+1);
  lr = (tmp3*tmp3+1)*k*k + (4*tmp3+3)*k + 
       ((tmp4 > tmp5) ? tmp4 : tmp5) + 4;
}
r = NAG_ALLOC(lr,double);

/* g05pjc */
nag_rand_times_mv_varma(order,emode,n,k,xmean,p,phi,q,theta,var,pdv,r,lr,
   state,x,pdx,&fail);

The Integer array state in the call to g05pjc contains information on the base generator being used. This array must have been initialized prior to calling g05pjc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05qac

Withdrawn at Mark 24.
Replaced by g05pxc.

Old Code

/* g05qac */
nag_rand_withdraw_matrix_orthog(order,side,init,m,n,a,pda,igen,iseed,&fail);

New Code

if (order == Nag_RowMajor) {
  /* g05pxc */
  nag_rand_matrix_orthog(side,init,m,n,state,a,pda,&fail);
} else {
  tside = (side == Nag_LeftSide) ? Nag_RightSide : Nag_LeftSide;
  pda = m;
  
  /* g05pxc */
  nag_rand_matrix_orthog(tside,init,n,m,state,a,pda,&fail);
}

The Integer array state in the call to g05pxc contains information on the base generator being used. This array must have been initialized prior to calling g05pxc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05qbc

Withdrawn at Mark 24.
Replaced by g05pyc.

Old Code

/* g05qbc */
nag_rand_withdraw_matrix_corr(order,n,d,c,pdc,eps,igen,iseed,&fail);

New Code

/* g05pyc */
nag_rand_matrix_corr(n,d,eps,state,c,pdc,&fail);

The Integer array state in the call to g05pyc contains information on the base generator being used. This array must have been initialized prior to calling g05pyc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05qdc

Withdrawn at Mark 24.
Replaced by g05pzc.

Old Code

/* g05qdc */
nag_rand_withdraw_matrix_2waytable(order,mode,nrow,ncol,totr,totc,x,pdx,igen,
   iseed,r,nr,&fail);

New Code

if (mode == 0) {
  emode = Nag_InitializeReference;
} else if (mode == 1) {
  emode = Nag_GenerateFromReference;
} else if (mode == 2) {
  emode = Nag_InitializeAndGenerate;
}
for (i = 0, lr = 5; i < nrow; i++)
  lr += totr[i];
r = NAG_ALLOC(lr,double);
if (order == Nag_RowMajor) {
  /* g05pzc */
  nag_rand_matrix_2waytable(emode,nrow,ncol,totr,totc,r,lr,state,x,pdx,
     &fail);
} else {
  pdx = nrow;
  
  /* g05pzc */
  nag_rand_matrix_2waytable(emode,ncol,nrow,totc,totr,r,lr,state,x,pdx,
     &fail);
}

The Integer array state in the call to g05pzc contains information on the base generator being used. This array must have been initialized prior to calling g05pzc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05rac

Withdrawn at Mark 24.
Replaced by g05rdc.

Old Code

/* g05rac */
nag_rand_withdraw_copula_normal(order,mode,m,c,pdc,n,x,pdx,igen,iseed,r,lr,
   &fail);

New Code

if (mode == 1) {
  emode = Nag_InitializeReference;
} else if (mode == 2) {
  emode = Nag_GenerateFromReference;
} else if (mode == 0) {
  emode = Nag_InitializeAndGenerate;
}
lr = m * (m + 1) + 1;
r = NAG_ALLOC(lr,double);

/* g05rdc */
nag_rand_copula_normal(order,emode,n,m,c,pdc,r,lr,state,x,pdx,
   &fail);

The Integer array state in the call to g05rdc contains information on the base generator being used. This array must have been initialized prior to calling g05rdc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05rbc

Withdrawn at Mark 24.
Replaced by g05rcc.

Old Code

/* g05rbc */
nag_rand_withdraw_copula_students_t(order,mode,df,m,c,pdc,n,x,pdx,igen,
   iseed,r,lr,&fail);

New Code

if (mode == 1) {
  emode = Nag_InitializeReference;
} else if (mode == 2) {
  emode = Nag_GenerateFromReference;
} else if (mode == 0) {
  emode = Nag_InitializeAndGenerate;
}

/* g05rcc */
nag_rand_copula_students_t(order,emode,n,df,m,c,pdc,r,lr,
   state,x,pdx,&fail);

The Integer array state in the call to g05rcc contains information on the base generator being used. This array must have been initialized prior to calling g05rcc with a call to either g05kfc or g05kgc. The required length of the array state will depend on the base generator chosen during initialization.

g05yac

Withdrawn at Mark 24.
Replaced by g05ylc and g05ymc.

Old Code

/* g05yac */
nag_rand_(state,seq,iskip,idim,quasi,&gf,&fail);

New Code

liref = (seq == Nag_QuasiRandom_Faure) ? 407 : 32 * idim + 7;
iref = NAG_ALLOC(liref,Integer);
seq = (seq == Nag_QuasiRandom_Sobol) ? 
  Nag_QuasiRandom_SobolA659 : seq;

if (state == Nag_QuasiRandom_Init) {
  /* g05ylc */
  nag_rand_quasi_init(seq,idim,iref,liref,iskip,&fail);
} else if (state == Nag_QuasiRandom_Cont) {
  n = 1;
  pdquasi = (order == Nag_RowMajor) ? idim : n;
  
  /* g05ymc */
  nag_rand_quasi_uniform(order,n,quasi,pdquasi,iref,&fail);
}

g05yac has been split into two functions; g05ylc to initialize the quasi-random generators and g05ymc to generate the values. g05ymc will generate more than one realization at a time. Information is passed between g05ylc and g05ymc using the integer vector iref rather than the NAG defined structure gf. Therefore there is no longer any need to call a function to release memory as iref can be "freed" like any C array.

g05ybc

Withdrawn at Mark 24.
Replaced by g05yjc and g05ylc.

Old Code

/* g05ybc */
nag_rand_(state,seq,lnorm,mean,std,iskip,idim,
   quasi,&gf,&fail);

New Code

liref = (seq == Nag_QuasiRandom_Faure) ? 407 : 32 * idim + 7;
iref = NAG_ALLOC(liref,Integer);
seq = (seq == Nag_QuasiRandom_Sobol) ? 
  Nag_QuasiRandom_SobolA659 : seq;
  
if (state == Nag_QuasiRandom_Init) {
  /* g05ylc */
  nag_rand_quasi_init(seq,idim,iref,liref,iskip,&fail);
} else if (state == Nag_QuasiRandom_Cont) {
  n = 1;
  pdquasi = (order == Nag_RowMajor) ? idim : n;
  
  if (lnorm == Nag_LogNormal) {
    /* g05ykc */
    nag_rand_quasi_lognormal(order,mean,std,n,quasi,pdquasi,iref,
       &fail);
  } else if (lnorm == Nag_Normal) {
    /* g05yjc */
    nag_rand_quasi_normal(order,mean,std,n,quasi,pdquasi,iref,&fail);
  }
}

g05ybc has been split into three functions; g05ylc to initialize the quasi-random generators, g05ykc to generate values from a log-normal distribution and g05yjc to generate values from a normal distribution. Both g05ykc and g05yjc will generate more than one realization at a time. Information is passed between g05ylc and g05ykc and g05yjc using the integer vector iref rather than the NAG defined structure gf. Therefore there is no longer any need to call a function to release memory as iref can be "freed" like any C array.

G10 – Smoothing in Statistics

g10bac

Withdrawn at Mark 26.
Replaced by g10bbc.

The replacement routine introduces new functionality with respect to the automatic selection of a suitable window width.

Old Code

nag_smooth_withdraw_kerndens_gauss(n, x, window, low, high, ns, smooth, t, &fail);

New Code

assert(rcomm = NAG_ALLOC(ns+20,double));
nag_smooth_kerndens_gauss(n, x, Nag_WindowSupplied, &window, &low, &high, ns, smooth, t,
                          Nag_TRUE, rcomm, &fail);

X02 – Machine Constants

X02DAC

Withdrawn at Mark 24.
There is no replacement for this function.

X02DJC

Withdrawn at Mark 24.
There is no replacement for this function.

X04 – Input/Output Utilities

x04aec

Withdrawn at Mark 25.
There is no replacement for this function.

NAG Library Manual, Mark 27

Interfaces: FL CL AD

Replace: FL CL AD

NAG CL InterfaceReplacement Calls Advice

▸▿ Contents

C05 – Roots of One or More Transcendental Equations

c05adc

Old Code

New Code

c05agc

Old Code

New Code

c05nbc

Old Code

New Code

c05pbc

Old Code

New Code

c05sdc

Old Code

New Code

c05tbc

Old Code

New Code

c05ubc

Old Code

New Code

c05zbc

Old Code

New Code

c05zcc

Old Code

New Code

C06 – Fourier Transforms

c06eac

Old Code

New Code

c06ebc

Old Code

New Code

c06ecc

Old Code

New Code

c06ekc

Old Code

New Code

c06fpc

Old Code

New Code

c06fqc

Old Code

New Code

c06frc

Old Code

New Code

c06fuc

Old Code

New Code

c06gbc

c06gcc

c06gqc

c06gsc

c06gzc

c06hac

Old Code

New Code

c06hbc

Old Code

New Code

c06hcc

Old Code

New Code

c06hdc

Old Code

New Code

D01 – Quadrature

d01ajc

d01akc

d01alc

d01amc

d01anc

d01apc

d01aqc

NAG CL Interface
Replacement Calls Advice