NAG CL Interface
Replacement Calls Advice

C02 – Zeros of Polynomials

c02afc

Complex a[n+1], z[n];
Nag_Boolean scale;
...
scale = Nag_True;
nag_zeros_poly_complex(n, a, scale, z, &fail);

Complex a[n+1], z[n];
Integer itmax;
Nag_Root_Polish polish;
double berr[n], cond[n];
Integer conv[n];
...
itmax = 30;
polish = Nag_Root_Polish_Simple;
nag_zeros_poly_complex_fpml(a, n, itmax, polish, z, berr, cond, conv, &fail);

c02agc

double a[n+1];
Complex z[n];
Nag_Boolean scale;
...
scale = Nag_True;
nag_zeros_poly_real(n, a, scale, z, &fail);

double a[n+1];
complex z[n];
integer itmax;
nag_root_polish polish;
double berr[n], cond[n];
Integer conv[n];
...
itmax = 30;
polish = Nag_Root_Polish_Simple;
nag_zeros_poly_real_fpml(a, n, itmax, polish, z, berr, cond, conv, &fail);

C05 – Roots of One or More Transcendental Equations

c05adc

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

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

c05agc

nag_zero_cont_func_brent_bsrch(...);

nag_zero_cont_func_brent_binsrch(...);

c05nbc

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

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

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);

void fcn(Integer n, double x[], double fvec[], double fjac_c[],
         Nag_Comm *comm, Integer *iflag)
   {
      /* The Jacobian must be filled column-wise. */
   }
...
Nag_Comm comm;
...
fjac_c = NAG_ALLOC(n*n, double);
...
nag_zero_nonlin_eqns_deriv_easy(fcn, n, x, fvec, fjac_c, xtol, &comm,
                                &fail);
/* The factorization of the Jacobian is now stored column-wise. */

c05sdc

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

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

c05tbc

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);

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

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);

void fcn(Integer n, double x[], double fvec[], double fjac_c[],
         Nag_Comm *comm, Integer *userflag)
   {
      /* The Jacobian must be filled column-wise. */
   }
...
Nag_Comm comm;
...
fjac_c = NAG_ALLOC(n*n, double);
...
nag_zero_nonlin_eqns_deriv_easy(fcn, n, x, fvec, fjac_c, xtol, &comm,
                                &fail);
/* The factorization of the Jacobian is now stored column-wise. */

c05zbc

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

Integer mode, m;
double *xp = 0, *fvecp = 0, *err = 0;
m = n;
mode = 1;
/* Store fjac by columns. */nag_check_derivs(mode, m, n, x, fvec, fjac_c, 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_c, xp, fvecp, err, &fail);
/* Check the contents of err for the measures of correctness of each
 * gradient. */

c05zcc

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

Integer mode, m;
double *xp = 0, *fvecp = 0, *err = 0;
m = n;
mode = 1;
/* Store fjac by columns. */nag_check_derivs(mode, m, n, x, fvec, fjac_c, 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_c, xp, fvecp, err, &fail);
/* Check the contents of err for the measures of correctness of each
 * gradient. */

C06 – Fourier Transforms

c06eac

nag_sum_withdraw_fft_real_1d_nowork(n, x, &fail);

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

c06ebc

nag_sum_withdraw_fft_hermitian_1d_nowork(n, x, &fail);

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

c06ecc

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

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

c06ekc

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

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

c06fpc

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

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

c06fqc

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

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

c06frc

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

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

c06fuc

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

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

c06gbc

c06gcc

c06gqc

c06gsc

c06gzc

c06hac

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

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

c06hbc

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

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

c06hcc

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

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

c06hdc

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

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

D01 – Quadrature

d01ajc

double (*f)(double x)

void (*f)(const double x[], Integer nx, double fv[], Integer *iflag, Nag_Comm *comm)

nag_1d_quad_gen(f, a, b, epsabs, epsrel, max_num_subint, &result, &abserr,
                &qp, &fail);

nag_quad_dim1_fin_general(f, a, b, epsabs, epsrel, maxsub, &result, &abserr,
                          rinfo, iinfo, &comm, &fail);

d01akc

double (*f)(double x)

void (*f)(const double x[], Integer nx, double fv[], Integer *iflag, Nag_Comm *comm)

nag_1d_quad_osc(f, a, b, epsabs, epsrel, max_num_subint, &result, &abserr,
                &qp, &fail);

key = 6;
nag_quad_dim1_fin_osc_fn(f, a, b, key, epsabs, epsrel, maxsub, &result, &abserr,
                         rinfo, iinfo, &comm, &fail);

d01alc

double (*f)(double x)

void (*f)(const double x[], Integer nx, double fv[], Integer *iflag, Nag_Comm *comm)

nag_1d_quad_brkpts(f, a, b, nbrkpts, brkpts, epsabs, epsrel, max_num_subint, &result, &abserr,
                   &qp, &fail);

nagf_quad_dim1_fin_brkpts(f, a, b, npts, points, epsabs, epsrel, maxsub, &result, &abserr,
                          rinfo, iinfo, &comm, &fail);

d01amc

double (*f)(double x)

void (*f)(const double x[], Integer nx, double fv[], Integer *iflag, Nag_Comm *comm)

Nag_BoundInterval boundinf = Nag_UpperSemiInfinite; /* or Nag_LowerSemiInfinite or Nag_Infinite */
nag_1d_quad_inf(f, boundinf, bound, epsabs, epsrel, max_num_subint, &result, &abserr,
                &qp, &fail);

Integer inf = 1;  /* or -1 or 2 */
nagf_quad_dim1_inf_general(f, bound, inf, epsabs, epsrel, maxsub, &result, &abserr,
                           rinfo, iinfo, &comm, &fail);

d01anc

d01apc

d01aqc

d01asc

d01bac

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

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);

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

d01gbc

d01sjc

double (*f)(double x)

void (*f)(const double x[], Integer nx, double fv[], Integer *iflag, Nag_Comm *comm)

nag_quad_dim1_fin_gen(f, a, b, epsabs, epsrel, max_num_subint, &result, &abserr,
                      &qp, &comm, &fail);

nag_quad_dim1_fin_general(f, a, b, epsabs, epsrel, maxsub, &result, &abserr,
                          rinfo, iinfo, &comm, &fail);

d01skc

double (*f)(double x)

void (*f)(const double x[], Integer nx, double fv[], Integer *iflag, Nag_Comm *comm)

nag_quad_dim1_osc(f, a, b, epsabs, epsrel, max_num_subint, &result, &abserr,
                  &qp, &comm, &fail);

key = 6;
nag_quad_dim1_fin_osc_fn(f, a, b, key, epsabs, epsrel, maxsub, &result, &abserr,
                         rinfo, iinfo, &comm, &fail);

d01slc

double (*f)(double x)

void (*f)(const double x[], Integer nx, double fv[], Integer *iflag, Nag_Comm *comm)

nag_quad_dim1_fin_brkpts_threadsafe(f, a, b, nbrkpts, brkpts, epsabs, epsrel, max_num_subint, &result,
                                    &abserr, &qp, &comm, &fail);

nagf_quad_dim1_fin_brkpts(f, a, b, npts, points, epsabs, epsrel, maxsub, &result, &abserr,
                          rinfo, iinfo, &comm, &fail);

d01smc

double (*f)(double x)

void (*f)(const double x[], Integer nx, double fv[], Integer *iflag, Nag_Comm *comm)

Nag_BoundInterval boundinf = Nag_UpperSemiInfinite; /* or Nag_LowerSemiInfinite or Nag_Infinite */
nag_quad_dim1_quad_inf_1(f, boundinf, bound, epsabs, epsrel, max_num_subint, &result, &abserr,
                         &qp, &comm, &fail);

Integer inf = 1;  /* or -1 or 2 */
nagf_quad_dim1_inf_general(f, bound, inf, epsabs, epsrel, maxsub, &result, &abserr,
                           rinfo, iinfo, &comm, &fail);

d01tac

double (*f)(double x, Nag_User *comm)

void (*f)(const double x[], Integer nx, double fv[], Integer *iflag, Nag_Comm *comm)

Nag_User comm;
Nag_GaussFormulae gaussformula=Nag_Legendre;
result = nag_quad_dim1_gauss_1(gaussformula, f, a, b, npts, &comm, &fail);

Nag_Comm comm;
Nag_QuadType quad_type=Nag_Quad_Gauss_Legendre;
nagf_quad_dim1_gauss_vec(quad_type, a, b, npts, f, &result, &comm, &fail)

D02 – Ordinary Differential Equations

d02pcc

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);

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);

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

d02pdc

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);

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);

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

d02ppc

d02pvc

d02pwc

nag_ode_ivp_rk_reset_tend(tendnu, &opt, &fail);

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

d02pxc

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

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

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

d02pzc

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

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

E01 – Interpolation

e01sac

e01sbc

e01szc

E04 – Minimizing or Maximizing a Function

e04ccc

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

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

e04dgc

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] = ... ;
}

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] = ... ;
}

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

/* 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);

e04gbc

e04jbc

e04jcc

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

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

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

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);

e04ugc

e04vgc

e04vhc

e04vjc

e04vkc

e04vlc

e04vmc

e04vnc

e04vrc

e04vsc

e04yac

E05 – Global Optimization of a Function

e05jac

e05jbc

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

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

SET_FAIL(fail);
nag_glopt_bnd_mcs_solve(n, objfun, boundenum, initmethodenum, bl, bu, sdlist,
                        list, numpts, initpt, monit, x, &obj, &state, &comm,
                        &fail);

/* 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);

/* Define bounds for the variables
* nag_opt_handle_set_simplebounds (e04rhc)
*/
nag_opt_handle_set_simplebounds(handle, nvar, lx, ux, NAGERR_DEFAULT);

/* Solve the problem */
SET_FAIL(fail);
nag_glopt_handle_solve_mcs(handle, objfun, monit, nvar, x, rinfo, stats,
                           &comm, ∓fail);

e05jcc

e05jdc

e05jec

e05jfc

e05jgc

e05jhc

e05jjc

e05jkc

e05jlc

F01 – Matrix Operations, Including Inversion

f01bnc

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

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

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

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

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

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

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

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

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

f02abc

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

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);

f02adc

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

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

f02aec

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

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);

f02afc

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

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

f02agc

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

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

f02awc

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

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

f02axc

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

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);

f02bjc

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

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);

f02wec

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

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);

f02xec

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

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);

F03 – Determinants

f03aec

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 */
}

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 factorization in a will be different */
  /* the array pivot will be different */
}

f03ahc

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 */
}

F04 – Simultaneous Linear Equations

f04adc

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

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

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

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 );
}

f04arc

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

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);
}

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

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

/* 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

x = nag_deviates_normal_dist(p, &fail);

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

G02 – Correlation and Regression Analysis

g02ewc

nag_correg_(flag, var, val, &fail)

nag_correg_linregm_fit_stepwise_sample_monfun(flag, var, val, &fail)

g02jac
g02jbc
g02jcc
g02jdc
g02jec

G05 – Random Number Generators

g05cac

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

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

g05cbc

/* g05cbc */
nag_random_init_repeatable(i);

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

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

g05ccc

/* g05ccc */
nag_random_init_nonrepeatable();

genid = Nag_Basic;
subid = 1;

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

g05cfc

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

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

g05cgc

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

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

g05dac

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

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

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

g05dbc

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

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

g05ddc

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

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

g05dyc

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

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

g05eac

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

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);

g05ecc

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

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);

g05edc

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

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);

g05ehc

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

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

g05ejc

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

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

g05exc

/* 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);

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);

g05eyc

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

g05ezc

#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];
}

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);

g05fec

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

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

g05ffc

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

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

g05hac

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

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);

g05hkc

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

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);

g05hlc

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

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);

g05hmc

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

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);

g05kac

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

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

g05kbc

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

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

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

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

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

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

g05lac

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

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

g05lbc

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

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

g05lcc

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

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

g05ldc

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

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

g05lec

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

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

g05lfc

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

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

g05lgc

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

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

g05lhc

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

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

g05ljc

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

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

g05lkc

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

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

g05llc

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

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

g05lmc

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

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

g05lnc

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

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

g05lpc

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

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

g05lqc

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

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

g05lxc

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

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);

g05lyc

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

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

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

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

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

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

g05mbc

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

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);

g05mcc

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

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);

g05mdc

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

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);

g05mec

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

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

g05mjc

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

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

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

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

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

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);

g05mrc

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

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);

g05mzc

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

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

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

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

g05nbc

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

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

g05pac

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

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

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

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);

g05qac

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

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);
}

g05qbc

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

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

g05qdc

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

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);
}

g05rac

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

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);

g05rbc

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

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);

g05yac

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

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);
}

g05ybc

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

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);
  }
}

G10 – Smoothing in Statistics

g10bac

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

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);

H – Operations Research

h02bbc

X02 – Machine Constants

X02DAC

X02DJC

X04 – Input/Output Utilities

x04aec

X06 – OpenMP Utilities

x06agc

nag_omp_set_nested(nesting)

nag_omp_set_max_active_levels(num, &ifail)

x06ahc

nag_omp_get_nested()

nag_omp_get_max_active_levels()