NAG Library Advice on Replacement Calls for Withdrawn/Superseded Routines

Old: CALL D02CAF(X,XEND,N,Y,TOL,FCN,W,IFAIL)
New: CALL D02CJF(X,XEND,N,Y,FCN,TOL,'M',D02CJX,D02CJW,W,IFAIL)

D02CJX is a subroutine provided in the NAG Fortran Library and D02CJW is a double precision function also provided. Both must be declared as EXTERNAL. The array W needs to be 5 elements greater in length.

D02CBF

Old: CALL D02CBF(X,XEND,N,Y,TOL,IRELAB,FCN,OUTPUT,W,IFAIL)
New: CALL D02CJF(X,XEND,N,Y,FCN,TOL,RELABS,OUTPUT,D02CJW,W,IFAIL)

D02CJW is a double precision function provided in the NAG Fortran Library and must be declared as EXTERNAL. The array W needs to be 5 elements greater in length. The integer parameter IRELAB (which can take values 0, 1 or 2) is catered for by the new CHARACTER*1 argument RELABS (whose corresponding values are 'M', 'A' and 'R').

D02CGF

Old: CALL D02CGF(X,XEND,N,Y,TOL,HMAX,M,VAL,FCN,W,IFAIL)
New: CALL D02CJF(X,XEND,N,Y,FCN,TOL,'M',D02CJX,G,W,IFAIL)
     .
     .
     .
     double precision FUNCTION G(X,Y)
     double precision X,Y(*)
     G = Y(M)-VAL
     END

D02CJX is a subroutine provided in the NAG Fortran Library and should be declared as EXTERNAL. Note the functionality of HMAX is no longer available directly. Checking the value of YM - VAL at intervals of length HMAX can be effected by a user-supplied procedure OUTPUT in place of D02CJX in the call described above. See the routine document for D02CJF for more details.

D02CHF

Old: CALL D02CHF(X,XEND,N,Y,TOL,IRELAB,HMAX,FCN,G,W,IFAIL)
New: CALL D02CJF(X,XEND,N,Y,FCN,TOL,RELABS,D02CJX,G,W,IFAIL)

D02CJX is a subroutine provided by the NAG Fortran Library and should be declared as EXTERNAL. The functionality of HMAX can be provided as described under the replacement call for D02CGF. The relationship between the parameters IRELAB and RELABS is described under the replacement call for D02CBF.

D02EAF

Old: CALL D02EAF(X,XEND,N,Y,TOL,FCN,W,IW,IFAIL)
New: CALL D02EJF(X,XEND,N,Y,FCN,TOL,'M',D02EJX,D02EJW,D02EJY,W,IW,
    +            IFAIL)

D02EJY and D02EJX are subroutines provided in the NAG Fortran Library and D02EJW is a double precision function also provided. All must be declared as EXTERNAL.

D02EBF

Old: CALL D02EBF(X,XEND,N,Y,TOL,IRELAB,FCN,MPED,PEDERV,OUTPUT,W,IW,
    +            IFAIL)
New: CALL D02EJF(X,XEND,N,Y,FCN,PEDERV,TOL,RELABS,OUTPUT,D02EJW,W,IW,
    +            IFAIL)

D02EJW is a double precision function provided in the NAG Fortran Library and must be declared as EXTERNAL. The integer parameter IRELAB (which can take values 0, 1 or 2) is catered for by the new CHARACTER*1 argument RELABS (whose corresponding values are 'M', 'A' and 'R'). If MPED = 0 in the call of D02EBF then PEDERV must be the routine D02EJY, which is supplied in the Library and should be declared as EXTERNAL.

D02EGF

Old: CALL D02EGF(X,XEND,N,Y,TOL,HMAX,M,VAL,FCN,W,IW,IFAIL)
New: CALL D02EJF(X,XEND,N,Y,FCN,D02EJY,TOL,'M',D02EJX,G,W,IW,IFAIL)
     .
     .
     .
     double precision FUNCTION G(X,Y)
     double precision X,Y(*)
     G = Y(M)-VAL
     END

D02EJY and D02EJX are subroutines provided in the NAG Fortran Library and should be declared as EXTERNAL. Note that the functionality of HMAX is no longer available directly. Checking the value of YM - VAL at intervals of length HMAX can be effected by a user-supplied procedure OUTPUT in place of D02EJX in the call described above. See the routine document for D02EJF for more details.

D02EHF

Withdrawn at Mark 17.
Replaced by D03PCF/D03PCA.

Old: CALL D02EHF(X,XEND,N,Y,TOL,IRELAB,HMAX,MPED,PEDERV,FCN,G,W,IFAIL)
New: CALL D02EJF(X,XEND,N,Y,FCN,PEDERV,TOL,RELABS,D02EJX,G,W,IW,IFAIL)

D02EJX is a subroutine provided by the NAG Fortran Library and should be declared as EXTERNAL. The functionality of HMAX can be provided as described under the replacement call for D02EGF. The relationship between the parameters IRELAB and RELABS is described under the replacement call for D02EBF. If MPED = 0 in the call of D02EHF then PEDERV must be the routine D02EJY, which is supplied in the Library and should be declared as EXTERNAL.

D02PAF

Withdrawn at Mark 18.
Replaced by D02PDF and associated D02P routines.

Existing programs should be modified to call D02PVF and D02PDF. The interfaces are significantly different and therefore precise details of a replacement call cannot be given. Please consult the appropriate routine documents.

D02QDF

Withdrawn at Mark 17.
Replaced by D02NBF or D02NCF.

Existing programs should be modified to call D02NSF, D02NVF and D02NBF, or D02NTF, D02NVF and D02NCF. The interfaces are significantly different and therefore precise details of a replacement call cannot be given. Please consult the appropriate routine documents.

D02QQF

Withdrawn at Mark 17.
Replaced by D02NBF or D02NCF.

D02XAF

Withdrawn at Mark 18.
Replaced by D02PXF and associated D02P routines.

Not needed except with D02PAF. The equivalent routine is D02PXF.

D02XBF

Withdrawn at Mark 18.
Replaced by D02PXF and associated D02P routines.

Not needed except with D02PAF.

D02YAF

Withdrawn at Mark 18.
Replaced by D02PDF and associated D02P routines.

There is no precise equivalent to this routine. The closest alternative routine is D02PDF.

D03 – Partial Differential Equations

D03PAF

Existing programs should be modified to call D03PCF/D03PCA. The replacement routine is designed to solve a broader class of problems. Therefore it is not possible to give precise details of a replacement call. Please consult the appropriate routine documents.

D03PBF

Withdrawn at Mark 17.
Replaced by D03PCF/D03PCA.

D03PGF

Withdrawn at Mark 17.
Replaced by D03PCF/D03PCA.

E01 – Interpolation

E01ACF

Withdrawn at Mark 15.
Replaced by E01DAF and E02DEF.

Old: CALL E01ACF(A,B,X,Y,F,VAL,VALL,IFAIL,XX,WORK,AM,D,IG1,M1,N1)
New: CALL E01DAF(N1,M1,X,Y,F,PX,PY,LAMDA,MU,C,WRK,IFAIL)
     A1(1) = A
     B1(1) = B
     M = 1
     CALL E02DEF(M,PX,PY,A1,B1,LAMDA,MU,C,FF,WRK,IWRK,IFAIL)
     VAL = FF(1)
     VALL = VAL

where PX, PY and M are INTEGER variables, LAMDA is a double precision array of dimension N1+4 , MU is a double precision array of dimension M1+4 , C is a double precision array of dimension N1×M1 , WRK is a double precision array of dimension N1+6 × M1+6 , A1, B1 and FF are double precision arrays of dimension (M), and IWRK is an INTEGER array of dimension (M1).

The above new calls duplicate almost exactly the effect of the old call, except that the new routines produce a single interpolated value for each point, rather than the two alternative values VAL and VALL produced by the old routine. By attempting this duplication, however, efficiency is probably being sacrificed. In general it is preferable to evaluate the interpolating function provided by E01DAF at a set of M points, supplied in arrays A1 and B1, rather than at a single point.

Note also that E01ACF uses natural splines, i.e., splines having zero second derivatives at the ends of the ranges. This is likely to be slightly unsatisfactory, and E01DAF does not have this problem. It does mean however that results produced by E01DAF may not be exactly the same as those produced by E01ACF.

E01SEF

Withdrawn at Mark 20.
Replaced by E01SGF.

Old: CALL E01SEF(M,X,Y,F,RNW,RNQ,NW,NQ,FNODES,MINNQ,WRK,IFAIL)
New: CALL E01SGF(M,X,Y,F,NW,NQ,IQ,LIQ,RQ,LRQ,IFAIL)

E01SEF has been superseded by E01SGF which gives improved accuracy, facilities for obtaining gradient values and a consistent interface with E01TGF for interpolation of scattered data in three dimensions.

The interpolant generated by the two routines will not be identical, but similar results may be obtained by using the same values of NW and NQ. Details of the interpolant are passed to the evaluator through the arrays IQ and RQ rather than FNODES and RNW.

E01SFF

Withdrawn at Mark 20.
Replaced by E01SHF.

Old: CALL E01SFF(M,X,Y,F,RNW,FNODES,PX,PY,PF,IFAIL)
New: CALL E01SHF(M,X,Y,F,IQ,LIQ,RQ,LRQ,1,PX,PY,PF,QX,QY,IFAIL)

The two calls will not produce identical results due to differences in the generation routines E01SEF and E01SGF. Details of the interpolant are passed from E01SGF through the arrays IQ and RQ rather than FNODES and RNW.

E01SHF also returns gradient values in QX and QY and allows evaluation at arrays of points rather than just single points.

E02 – Curve and Surface Fitting

E02DBF

Withdrawn at Mark 16.
Replaced by E02DEF.

Old: CALL E02DBF(M,PX,PY,X,Y,FF,LAMDA,MV,POINT,NPOINT,C,NC,IFAIL)
New: CALL E02DEF(M,PX,PY,X,Y,LAMDA,MU,C,FF,WRK,IWRK,IFAIL)

where WRK is a double precision array of dimension PY-4 , and IWRK is an INTEGER array of dimension PY-4 .

E04 – Minimizing or Maximizing a Function

E04CCF/E04CCA

Scheduled for withdrawal at Mark 24.
Replaced by E04CBF.

Old: CALL E04CCF(N,X,F,TOL,IW,W1,W2,W3,W4,W5,W6,FUNCT,MONIT,MAXCAL,
     *           IFAIL)
                     or
     CALL E04CCA(N,X,F,TOL,IW,W1,W2,W3,W4,W5,W6,FUNCT2,MONIT2,MAXCAL,
     *           IUSER,RUSER,IFAIL)
New: CALL E04CBF(N,X,F,TOLF,TOLX,FUNCT2,MONIT3,MAXCAL,IUSER,RUSER,
     *           IFAIL)

The new routine can be derived from the old as follows:

       SUBROUTINE MONIT3(FMIN,FMAX,SIM,N,NCALL,SERROR,VRATIO,IUSER,RUSER)
       INTEGER    N, NCALL, IUSER(*)
       double precision FMIN, FMAX, SIM(N+1,N), SERROR, VRATIO, RUSER(*)
C
       CALL MONIT2(FMIN,FMAX,SIM,N,N+1,NCALL,IUSER,RUSER)
C      Add code here to monitor the values of SERROR and VRATIO, if necessary
       RETURN
       END

E04FDF

Withdrawn at Mark 19.
Replaced by E04FYF.

Old: CALL E04FDF(M,N,X,FSUMSQ,IW,LIW,W,LW,IFAIL)
New: CALL E04FYF(M,N,LSFUN,X,FSUMSQ,W,LW,IUSER,USER,IFAIL)

LSFUN appears in the parameter list instead of the fixed-name subroutine LSFUN1 of E04FDF. LSFUN must be declared as EXTERNAL in the calling (sub)program. In addition it has an extra two parameters, IUSER and USER, over and above those of LSFUN1. It may be derived from LSFUN1 as follows:

      SUBROUTINE  LSFUN(M,N,XC,FVECC,IUSER,USER)
      INTEGER     M, N, IUSER(*)
      double precision XC(N), FVECC(M), USER(*)
C
      CALL LSFUN1(M,N,XC,FVECC)
C
      RETURN
      END

In general the extra parameters, IUSER and USER, should be declared in the calling program as IUSER1 and USER1 , but will not need initializing.

E04GCF

Withdrawn at Mark 19.
Replaced by E04GYF.

Old: CALL E04GCF(M,N,X,FSUMSQ,IW,LIW,W,LW,IFAIL)
New: CALL E04GYF(M,N,LSFUN,X,FSUMSQ,W,LW,IUSER,USER,IFAIL)

LSFUN appears in the parameter list instead of the fixed-name subroutine LSFUN2 of E04GCF. LSFUN must be declared as EXTERNAL in the calling (sub)program. In addition it has an extra two parameters, IUSER and USER, over and above those of LSFUN2. It may be derived from LSFUN2 as follows:

      SUBROUTINE  LSFUN(M,N,XC,FVECC,FJACC,LJC,IUSER,USER)
      INTEGER     M, N, LJC, IUSER(*)
      double precision XC(N), FVECC(M), FJACC(LJC,N), USER(*)
C
      CALL LSFUN2(M,N,XC,FVECC,FJACC,LJC)
C
      RETURN
      END

In general the extra parameters, IUSER and USER, should be declared in the calling program as IUSER1 and USER1 , but will not need initializing. If however, the array IW was used to pass information through E04GCF into LSFUN2, or get information from LSFUN2, then the array IUSER should be declared appropriately and used for this purpose.

E04GEF

Withdrawn at Mark 19.
Replaced by E04GZF.

Old: CALL E04GEF(M,N,X,FSUMSQ,IW,LIW,W,LW,IFAIL)
New: CALL E04GZF(M,N,LSFUN,X,FSUMSQ,W,LW,IUSER,USER,IFAIL)

LSFUN appears in the parameter list instead of the fixed-name subroutine LSFUN2 of E04GEF. LSFUN must be declared as EXTERNAL in the calling (sub)program. In addition it has an extra two parameters, IUSER and USER, over and above those of LSFUN2. It may be derived from LSFUN2 as follows:

      SUBROUTINE  LSFUN(M,N,X,FVECC,FJACC,LJC,IUSER,USER)
      INTEGER     M, N, LJC, IUSER(*)
      double precision XC(N), FVECC(M), FJACC(LJC,N), USER(*)
C
      CALL LSFUN2(M,N,XC,FVECC,FJACC,LJC)
C
      RETURN
      END

In general the extra parameters, IUSER and USER, should be declared in the calling program as IUSER1 and USER1 , but will not need initializing. If however, the array IW was used to pass information through E04GEF into LSFUN2, or get information from LSFUN2, then the array IUSER should be declared appropriately and used for this purpose.

E04HBF

Withdrawn at Mark 16.
There is no replacement for this routine.

E04HFF

Withdrawn at Mark 19.
Replaced by E04HYF.

Old: CALL E04HFF(M,N,X,FSUMSQ,IW,LIW,W,LW,IFAIL)
New: CALL E04HYF(M,N,LSFUN,LSHES,X,FSUMSQ,W,LW,IUSER,USER,IFAIL)

LSFUN and LSHES appear in the parameter list instead of the fixed-name subroutines LSFUN2 and LSHES2 of E04HFF. LSFUN and LSHES must both be declared as EXTERNAL in the calling (sub)program. In addition they have an extra two parameters, IUSER and USER, over and above those of LSFUN2 and LSHES2. They may be derived from LSFUN2 and LSHES2 as follows:

      SUBROUTINE  LSFUN(M,N,XC,FVECC,FJACC,LJC,IUSER,USER)
      INTEGER     M, N, LJC, IUSER(*)
      double precision XC(N), FVECC(M), FJACC(LJC,N), USER(*)
C
      CALL LSFUN2(M,N,XC,FVECC,FJACC,LJC)
C
      RETURN
      END
C
      SUBROUTINE  LSHES(M,N,FVECC,XC,B,LB,IUSER,USER)
      INTEGER     M, N, LB, IUSER(*)
      double precision FVECC(M), XC(N), B(LB), USER(*)
C
      CALL LSHES2(M,N,FVECC,XC,B,LB)
C
      RETURN
      END

In general, the extra parameters, IUSER and USER, should be declared in the calling program as IUSER1 and USER1 , but will not need initializing. If, however, the array IW was used to pass information through E04HFF into LSFUN2 or LSHES2, or to get information from LSFUN2 or LSHES2, then the array IUSER should be declared appropriately and used for this purpose.

E04JAF

Withdrawn at Mark 19.
Replaced by E04JYF.

Old: CALL E04JAF(N,IBOUND,BL,BU,X,F,IW,LIW,LW,IFAIL)
New: CALL E04JYF(N,IBOUND,FUNCT,BL,BU,X,F,IW,LIW,W,LW,IUSER,USER,IFAIL)

FUNCT appears in the parameter list instead of the fixed-name subroutine FUNCT1 of E04JAF. FUNCT must be declared as EXTERNAL in the calling (sub)program. In addition it has an extra two parameters, IUSER and USER, over and above those of FUNCT1. It may be derived from FUNCT1 as follows:

      SUBROUTINE  FUNCT(N,XC,FC,IUSER,USER)
      INTEGER     N, IUSER(*)
      double precision XC(N), FC, USER(*)
C
      CALL FUNCT1(N,XC,FC)
C
      RETURN
      END

The extra parameters, IUSER and USER, should be declared in the calling program as IUSER1 and USER1 , but will not need initializing.

E04JBF

Withdrawn at Mark 16.
Replaced by E04UCF/E04UCA.

No comparative calls are given between E04JBF and E04UCF/E04UCA since both routines have considerable flexibility and can be called with many different options. E04UCF/E04UCA allows some values to be passed to it, not through the parameter list, but as ‘optional parameters’, supplied through calls to E04UDF/E04UDA or E04UEF/E04UEA.

E04UCF/E04UCA is a more powerful routine than E04JBF, in that it allows for general linear and nonlinear constraints, and for some or all of the first derivatives to be supplied; however when replacing E04JBF, only the simple bound constraints are relevant, and only function values are assumed to be available.

Therefore E04UCF/E04UCA must be called with NCLIN = NCNLN = 0 , with dummy arrays of size (1) supplied as the arguments A, C and CJAC, and with the name of the auxiliary routine E04UDM (UDME04 in some implementations) as the argument CONFUN. The optional parameter Derivative Level must be set to 0.

The subroutine providing function values to E04UCF/E04UCA is OBJFUN. It has a different parameter list to FUNCT, but can be constructed as follows:

       SUBROUTINE  OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER)
       INTEGER     MODE, N, NSTATE, IUSER(*)
       double precision X(N), OBJF, OBJGRD(N), USER(*)
       INTEGER     IFLAG,IW(1)
       double precision W(1)
C
       IFLAG = 0
       CALL FUNCT(IFLAG,N,X,OBJF,OBJGRD,IW,1,W,1)
       IF (IFLAG.LT.0) MODE = IFLAG
       RETURN
       END

(This assumes that the arrays IW and W are not used to communicate between FUNCT and the calling program; E04UCF/E04UCA supplies the arrays IUSER and USER specifically for this purpose.)

The functions of the parameters BL and BU are similar, but E04UCF/E04UCA has no parameter corresponding to IBOUND; all elements of BL and BU must be set (as when IBOUND = 0 in the call to E04JBF). The optional parameter Infinite Bound Size must be set to 1.0D+6 if there are any infinite bounds. The function of the parameter ISTATE is similar but the specification is slightly different. The parameters F and G are equivalent to OBJF and OBJGRD of E04UCF/E04UCA. It should also be noted that E04UCF/E04UCA does not allow a user-supplied parameter MONIT, but intermediate output is provided by the routine, under the control of the optional parameters Major Print Level and Minor Print Level.

Most of the ‘tuning’ parameters in E04JBF have their counterparts as ‘optional parameters’ to E04UCF/E04UCA, as indicated in the following list, but the correspondence is not exact and the specifications must be read carefully.

IPRINT	Minor Print Level
INTYPE	Cold Start/Warm Start
MAXCAL	Minor Iteration Limit (note that this counts iterations rather than function calls)
ETA	Line Search Tolerance
XTOL	Optimality Tolerance (note that this specifies the accuracy in OBJFUN rather than the accuracy in X)
STEPMX	Step Limit
DELTA	Difference Interval

E04KAF

Withdrawn at Mark 19.
Replaced by E04KYF.

Old: CALL E04KAF(N,IBOUND,BL,BU,X,F,G,IW,LIW,W,LW,IFAIL)
New: CALL E04KYF(N,IBOUND,FUNCT,BL,BU,X,F,G,IW,LIW,W,LW,IUSER,USER,IFAIL)

FUNCT appears in the parameter list instead of the fixed-name subroutine FUNCT2 of E04KAF. FUNCT must be declared as EXTERNAL in the calling (sub)program. In addition it has an extra two parameters, IUSER and USER, over and above those of FUNCT2. It may be derived from FUNCT2 as follows:

      SUBROUTINE  FUNCT(N,XC,FC,GC,IUSER,USER)
      INTEGER     N, IUSER(*)
      double precision XC(N), FC, GC(N), USER(*)
C
      CALL FUNCT2(N,XC,FC,GC)
C
      RETURN
      END

The extra parameters, IUSER and USER, should be declared in the calling program as IUSER1 and USER1 , but will not need initializing.

E04KBF

Withdrawn at Mark 16.
Replaced by E04UCF/E04UCA.

No comparative calls are given between E04KBF and E04UCF/E04UCA since both routines have considerable flexibility and can be called with many different options. Most of the advice given for replacing E04JBF (see above) applies also to E04KBF, and only the differences are given here.

The optional parameter Derivative Level must be set to 1.

The subroutine providing both function and gradient values to E04UCF/E04UCA is OBJFUN. It has a different parameter list to FUNCT, but can be constructed as follows:

      SUBROUTINE  OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER)
      INTEGER     MODE, N, NSTATE, IUSER(*)
      double precision X(N), OBJF, OBJGRD(N), USER(*)
      INTEGER     IW(1)
      double precision W(1)
C
      CALL FUNCT(MODE,N,X,OBJF,OBJGRD,IW,1,W,1)
      RETURN
      END

E04KCF

Withdrawn at Mark 19.
Replaced by E04KZF.

Old: CALL E04KCF(N,IBOUND,BL,BU,X,F,G,IW,LIW,W,LW,IFAIL)
New: CALL E04KZF(N,IBOUND,FUNCT,BL,BU,X,F,G,IW,LIW,W,LW,IUSER,USER,IFAIL)

FUNCT appears in the parameter list instead of the fixed-name subroutine FUNCT2 of E04KCF. FUNCT must be declared as EXTERNAL in the calling (sub)program. In addition it has an extra two parameters, IUSER and USER, over and above those of FUNCT2. It may be derived from FUNCT2 as follows:

      SUBROUTINE  FUNCT(N,XC,FC,GC,IUSER,USER)
      INTEGER     N, IUSER(*)
      double precision XC(N), FC, GC(N), USER(*)
C
      CALL FUNCT2(N,XC,FC,GC)
C
      RETURN
      END

The extra parameters, IUSER and USER, should be declared in the calling program as IUSER1 and USER1 , but will not need initializing.

E04LAF

Withdrawn at Mark 19.
Replaced by E04LYF.

Old: CALL E04LAF(N,IBOUND,BL,BU,X,F,G,IW,LIW,W,LW,IFAIL)
New: CALL E04LYF(N,IBOUND,FUNCT,HESS,BL,BU,X,F,G,IW,LIW,W,LW,IUSER,USER,
    +            IFAIL)

FUNCT and HESS appear in the parameter list instead of the fixed-name subroutines FUNCT2 and HESS2 of E04LAF. FUNCT and HESS must both be declared as EXTERNAL in the calling (sub)program. In addition they have an extra two parameters, IUSER and USER, over and above those of FUNCT2 and HESS2. They may be derived from FUNCT2 and HESS2 as follows:

      SUBROUTINE  FUNCT(N,XC,FC,GC,IUSER,USER)
      INTEGER     N, IUSER(*)
      double precision XC(N), FC, GC(N), USER(*)
C
      CALL FUNCT2(N,XC,FC,GC)
C
      RETURN
      END

      SUBROUTINE  HESS(N,XC,HESLC,LH,HESDC,IUSER,USER)
      INTEGER     N, LH, IUSER(*)
      double precision XC(N), HESLC(LH), HESDC(N), USER(*)
C
      CALL HESS2(N,XC,HESLC,LH,HESDC)
C
      RETURN
      END

In general, the extra parameters, IUSER and USER, should be declared in the calling program as IUSER1 and USER1 , but will not need initializing.

E04MBF

Withdrawn at Mark 18.
Replaced by E04MFF/E04MFA.

Old: CALL E04MBF(ITMAX,MSGLVL,N,NCLIN,NCTOTL,NROWA,A,BL,BU,CVEC,
    +            LINOBJ,X,ISTATE,OBJLP,CLAMDA,IWORK,LIWORK,WORK,
    +            LWORK,IFAIL)
New: CALL E04MFF(N,NCLIN,A,NROWA,BL,BU,CVEC,ISTATE,X,ITER,OBJLP,
    +            AX,CLAMDA,IWORK,LIWORK,WORK,LWORK,IFAIL)

The parameter NCTOTL is no longer required. Values for ITMAX, MSGLVL and LINOBJ may be supplied by calling an option setting routine.

E04MFF/E04MFA contains two additional parameters as follows:

ITER– INTEGER.
AX* – double precision array of dimension at least max1,NCLIN .

The minimum value of the parameter LIWORK must be increased from 2 × N to 2 × N + 3 . The minimum value of the parameter LWORK may also need to be changed. See the routine documents for further information.

E04NAF

Withdrawn at Mark 18.
Replaced by E04NFF/E04NFA.

Old: CALL E04NAF(ITMAX,MSGLVL,N,NCLIN,NCTOTL,NROWA,NROWH,NCOLH,
    +            BIGBND,A,BL,BU,CVEC,FEATOL,HESS,QPHESS,COLD,LP,
    +            ORTHOG,X,ISTATE,ITER,OBJ,CLAMDA,IWORK,LIWORK,
    +            WORK,LWORK,IFAIL)
New: CALL E04NFF(N,NCLIN,A,NROWA,BL,BU,CVEC,HESS,NROWH,QPHESS,
    +            ISTATE,X,ITER,OBJ,AX,CLAMDA,IWORK,LIWORK,WORK,
    +            LWORK,IFAIL)

The specification of the subroutine QPHESS must also be changed as follows:

Old: SUBROUTINE  QPHESS(N,NROWH,NCOLH,JTHCOL,HESS,X,HX)
     INTEGER     N, NROWH, NCOLH, JTHCOL
     double precision HESS(NROWH,NCOLH), X(N), HX(N)
New: SUBROUTINE  QPHESS(N,JTHCOL,HESS,NROWH,X,HX)
     INTEGER     N, JTHCOL, NROWH
     double precision HESS(NROWH,*), X(N), HX(N)

The parameters NCTOTL, NCOLH and ORTHOG are no longer required. Values for ITMAX, MSGLVL, BIGBND, FEATOL, COLD and LP may be supplied by calling an option setting routine.

E04NFF/E04NFA contains one additional parameter as follows:

AX* – double precision array of dimension at least max1,NCLIN .

E04UNF

Withdrawn at Mark 22.
Replaced by E04USF/E04USA.

Old: CALL E04UNF(M,N,NCLIN,NCNLN,LDA,LDCJ,LDFJ,
    +            LDR,A,BL,BU,Y,CONFUN,OBJFUN,ITER,
    +            ISTATE,C,CJAC,F,FJAC,CLAMDA,OBJF,
    +            R,X,IWORK,LIWORK,WORK,LWORK,IUSER,
    +            RUSER,IFAIL)
New: CALL E04USF(M,N,NCLIN,NCNLN,LDA,LDCJ,LDFJ,
    +            LDR,A,BL,BU,Y,CONFUN,OBJFUN,ITER,
    +            ISTATE,C,CJAC,F,FJAC,CLAMDA,OBJF,
    +            R,X,IWORK,LIWORK,WORK,LWORK,IUSER,
    +            RUSER,IFAIL)

The specification of the subroutine OBJFUN must also be changed as follows:

Old: SUBROUTINE  OBJFUN(MODE,M,N,LDFJ,X,F,FJAC,NSTATE,IUSER,RUSER)
     INTEGER     MODE,M,N,LDFJ,NSTATE,IUSER(*)
     double precision X(N),F(*),FJAC(LDFJ,*),RUSER(*)
New: SUBROUTINE  OBJFUN(MODE,M,N,LDFJ,NEEDFI,X,F,FJAC,NSTATE,
    +                   IUSER,RUSER)
     INTEGER     MODE,M,N,LDFJ,NEEDFI,NSTATE,IUSER(*)
     double precision X(N),F(*),FJAC(LDFJ,*),RUSER(*)

See the routine documents for further information.

E04UPF

Withdrawn at Mark 19.
Replaced by E04USF/E04USA.

Old: CALL E04UPF(M,N,NCLIN,NCNLN,LDA,LDCJ,LDFJ,LDR,A,BL,BU,
    +            CONFUN,OBJFUN,ITER,ISTATE,C,CJAC,F,FJAC,
    +            CLAMDA,OBJF,R,X,IWORK,LIWORK,WORK,LWORK,
    +            IUSER,USER,IFAIL)
New: CALL E04USF(M,N,NCLIN,NCNLN,LDA,LDCJ,LDFJ,
    +            LDR,A,BL,BU,Y,CONFUN,OBJFUN,ITER,
    +            ISTATE,C,CJAC,F,FJAC,CLAMDA,OBJF,
    +            R,X,IWORK,LIWORK,WORK,LWORK,IUSER,
    +            USER,IFAIL)

E04USF/E04USA contains one additional parameter as follows:

YM – double precision array.

Note that a call to E04UPF is the same as a call to E04USF/E04USA with Yi =0.0 , for i=1,2,…,M .

The specification of the subroutine OBJFUN must also be changed as follows:

Old: SUBROUTINE  OBJFUN(MODE,M,N,LDFJ,X,F,FJAC,NSTATE,IUSER,USER)
     INTEGER     MODE,M,N,LDFJ,NSTATE,IUSER(*)
     double precision X(N),F(*),FJAC(LDFJ,*),USER(*)

New: SUBROUTINE  OBJFUN(MODE,M,N,LDFJ,NEEDFI,X,F,FJAC,NSTATE,
    +                   IUSER,USER)
     INTEGER     MODE,M,N,NEEFI,NSTATE,IUSER(*)
     double precision X(N),F(*),FJAC(LDFJ,*),USER(*)

See the routine documents for further information.

E04VCF

Withdrawn at Mark 17.
Replaced by E04UCF/E04UCA.

Old: CALL E04VCF(ITMAX,MSGLVL,N,NCLIN,NCNLN,NCTOTL,NROWA,NROWJ,
    +            NROWR,BIGBND,EPSAF,ETA,FTOL,A,BL,BU,FEATOL,
    +            CONFUN,OBJFUN,COLD,FEALIN,ORTHOG,X,ISTATE,R,ITER,
    +            C,CJAC,OBJF,OBJGRD,CLAMDA,IWORK,LIWORK,WORK,LWORK,
    +            IFAIL)
New: CALL E04UCF(N,NCLIN,NCNLN,NROWA,NROWJ,NROWR,A,BL,BU,CONFUN,
    +            OBJFUN,ITER,ISTATE,C,CJAC,CLAMDA,OBJF,OBJGRD,R,X,
    +            IWORK,LIWORK,WORK,LWORK,IUSER,USER,IFAIL)

The specification of the subroutine OBJFUN must also be changed as follows:

Old: SUBROUTINE  OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE)
     INTEGER     MODE, N, NSTATE
     double precision X(N), OBJF, OBJGRD(N)
New: SUBROUTINE  OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER)
     INTEGER     MODE, N, NSTATE, IUSER(*)
     double precision X(N), OBJF, OBJGRD(N), USER(*)

If NCNLN > 0 , the specification of the subroutine CONFUN must also be changed as follows:

Old: SUBROUTINE  CONFUN(MODE,NCNLN,N,NROWJ,X,C,CJAC,NSTATE)
     INTEGER     MODE, NCNLN, N, NROWJ, NSTATE
     double precision X(N), C(NROWJ), CJAC(NROWJ,N)
New: SUBROUTINE  CONFUN(MODE,NCNLN,N,NROWJ,NEEDC,X,C,CJAC,NSTATE,
    +                   IUSER,USER)
     INTEGER     MODE, NCNLN, N, NROWJ, NEEDC(NCNLN), NSTATE, IUSER(*)
     double precision X(N), C(NCNLN), CJAC(NROWJ,N), USER(*)

If NCNLN = 0 , then the name of the dummy routine E04VDM/E54VDM may need to be changed to E04UDM in the calling program.

The parameters NCTOTL, EPSAF, FEALIN and ORTHOG are no longer required. Values for ITMAX, MSGLVL, BIGBND, ETA, FTOL, COLD and FEATOL may be supplied by calling an option setting routine.

E04UCF/E04UCA contains two additional parameters as follows:

IUSER* – INTEGER array of dimension at least 1.
USER* – double precision array of dimension at least 1.

The minimum value of the parameter LIWORK must be increased from 3 × N + NCLIN + NCNLN to 3 × N + NCLIN + 2 × NCNLN . The minimum value of the parameter LWORK may also need to be changed. See the routine documents for further information.

E04VDF

Withdrawn at Mark 17.
Replaced by E04UCF/E04UCA.

Old: IFAIL = 110
     CALL E04VDF(ITMAX,MSGLVL,N,NCLIN,NCNLN,NCTOTL,NROWA,NROWJ,
    +            CTOL,FTOL,A,BL,BU,CONFUN,OBJFUN,X,ISTATE,C,CJAC,
    +            CJAC,OBJF,OBJGRD,CLAMDA,IWORK,LIWORK,WORK,LWORK,
    +            IFAIL)
New: IFAIL = -1
     CALL E04UCF(N,NCLIN,NCNLN,NROWA,NROWJ,N,A,BL,BU,CONFUN,OBJFUN,
    +            ITER,ISTATE,C,CJAC,CLAMDA,OBJF,OBJGRD,R,X,IWORK,
    +            LIWORK,WORK,LWORK,IUSER,USER,IFAIL)

The specification of the subroutine OBJFUN must also be changed as follows:

Old: SUBROUTINE  OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE)
     INTEGER     MODE, N, NSTATE
     double precision X(N), OBJF, OBJGRD(N)
New: SUBROUTINE  OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER)
     INTEGER     MODE, N, NSTATE, IUSER(*)
     double precision X(N), OBJF, OBJGRD(N), USER(*)

If NCNLN > 0 , the specification of the subroutine CONFUN must also be changed as follows:

Old: SUBROUTINE  CONFUN(MODE,NCNLN,N,NROWJ,X,C,CJAC,NSTATE)
     INTEGER     MODE, NCNLN, N, NROWJ, NSTATE
     double precision X(N), C(NROWJ), CJAC(NROWJ,N)
New: SUBROUTINE  CONFUN(MODE,NCNLN,N,NROWJ,NEEDC,X,C,CJAC,NSTATE,
    +            IUSER,USER)
     INTEGER     MODE, NCNLN, N, NROWJ, NEEDC(NCNLN), NSTATE, IUSER(*)
     double precision X(N), C(NCNLN), CJAC(NROWJ,N), USER(*)

If NCNLN = 0 , then the name of the dummy routine E04VDM/E54VDM (VDME04 in some implementations) may need to be changed to E04UDM (UDME04 in some implementations) in the calling program.

The parameter NCTOTL is no longer required. Values for ITMAX, MSGLVL, CTOL and FTOL may be supplied by calling an option setting routine.

E04UCF/E04UCA contains four additional parameters as follows:

ITER – INTEGER.
RLDR,N – double precision array.
IUSER* – INTEGER array of dimension at least 1.
USER* – double precision array of dimension at least 1.

F01 – Matrix Operations, Including Inversion

F01AAF

Withdrawn at Mark 17.
Replaced by F07ADF (DGETRF) and F07AJF (DGETRI).

Old: CALL F01AAF(A,IA,N,X,IX,WKSPCE,IFAIL)
New: CALL DGETRF(N,N,A,IA,IPIV,IFAIL)
     CALL F06QFF('General',N,N,A,IA,X,IX)
     CALL DGETRI(N,X,IX,IPIV,WKSPCE,LWORK,IFAIL)

where IPIV is an INTEGER vector of length N, and the INTEGER LWORK is the length of array WKSPCE, which must be at least max1,N . In the replacement calls, F07ADF (DGETRF) computes the LU factorization of the matrix A , F06QFF copies the factorization from A to X, and F07AJF (DGETRI) overwrites X by the inverse of A . If the original matrix A is no longer required, the call to F06QFF is not necessary, and references to X and IX in the call of F07AJF (DGETRI) may be replaced by references to A and IA, in which case A will be overwritten by the inverse.

F01ACF

Withdrawn at Mark 16.
Replaced by F01ABF.

Old: CALL F01ACF(N,EPS,A,IA,B,IB,Z,L,IFAIL)
New: CALL F01ABF(A,IA,N,B,IB,Z,IFAIL)

The number of iterative refinement corrections returned by F01ACF in L is no longer available. The parameter EPS is no longer required.

F01AEF

Withdrawn at Mark 18.
Replaced by F06EGF (DSWAP), F07FDF (DPOTRF) and F08SEF (DSYGST).

Old: CALL F01AEF(N,A,IA,B,IB,DL,IFAIL)
New: DO 20 J = 1, N
        DO 10 I = J, N
           A(I,J) = A(J,I)
           B(I,J) = B(J,I)
  10 CONTINUE
        DL(J) = B(J,J)
  20 CONTINUE
     CALL DPOTRF('L',N,B,IB,INFO)
     IF (INFO.EQ.0) THEN
        CALL DSYGST(1,'L',N,A,IA,B,IB,INFO)
     ELSE
        IFAIL = 1
     END IF
     CALL DSWAP(N,DL,1,B,IB+1)

IFAIL is set to 1 if the matrix B is not positive-definite. It is essential to test IFAIL.

F01AFF

Withdrawn at Mark 18.
Replaced by F06EGF (DSWAP) and F06YJF (DTRSM).

Old: CALL F01AFF(N,M1,M2,B,IB,DL,Z,IZ)
New: CALL DSWAP(N,DL,1,B,IB+1)
     CALL DTRSM('L','L','T','N',N,M2-M1+1,1.0D0,B,IB,Z(1,M1),IZ)
     CALL DSWAP(N,DL,1,B,IB+1)

F01AGF

Withdrawn at Mark 18.
Replaced by F08FEF (DSYTRD).

Old: CALL F01AGF(N,TOL,A,IA,D,E,E2)
New: CALL DSYTRD('L',N,A,IA,D,E(2),TAU,WORK,LWORK,INFO)
     E(1) = 0.0D0
     DO 10 I = 1, N
        E2(I) = E(I)*E(I)
  10 CONTINUE

where TAU is a double precision array of length at least N-1 , WORK is a real array of length at least (1) and LWORK is its actual length.

Note that the tridiagonal matrix computed by F08FEF (DSYTRD) is different from that computed by F01AGF, but it has the same eigenvalues.

F01AHF

Withdrawn at Mark 18.
Replaced by F08FGF (DORMTR).

The following replacement is valid only if the previous call to F01AGF has been replaced by a call to F08FEF (DSYTRD) as shown above.

Old: CALL F01AHF(N,M1,M2,A,IA,E,Z,IZ)
New: CALL DORMTR('L','L','N',N,M2-M1+1,A,IA,TAU,Z(1,M1),IZ,WORK,
    +            LWORK,INFO)

where WORK is a double precision array of length at least M2-M1+1 , and LWORK is its actual length.

F01AJF

Withdrawn at Mark 18.
Replaced by F08FEF (DSYTRD) and F08FFF (DORGTR).

Old: CALL F01AJF(N,TOL,A,IA,D,E,Z,IZ)
New: CALL DSYTRD('L',N,A,IA,D,E(2),TAU,WORK,LWORK,INFO)
     E(1) = 0.0D0
     CALL F06QFF('L',N,N,A,IA,Z,IZ)
     CALL DORGTR('L',N,Z,IZ,TAU,WORK,LWORK,INFO)

where TAU is a double precision array of length at least N-1 , WORK is a real array of length at least N-1 and LWORK is its actual length.

Note that the tridiagonal matrix T and the orthogonal matrix Q computed by F08FEF (DSYTRD) and F08FFF (DORGTR) are different from those computed by F01AJF, but they satisfy the same relation QTAQ=T .

F01AKF

Withdrawn at Mark 18.
Replaced by F08NEF (DGEHRD).

Old: CALL F01AKF(N,K,L,A,IA,INTGER)
New: CALL DGEHRD(N,K,L,A,IA,TAU,WORK,LWORK,INFO)

where TAU is a double precision array of length at least N-1 , WORK is a real array of length at least N and LWORK is its actual length.

Note that the Hessenberg matrix computed by F08NEF (DGEHRD) is different from that computed by F01AKF, because F08NEF (DGEHRD) uses orthogonal transformations, whereas F01AKF uses stabilized elementary transformations.

F01ALF

Withdrawn at Mark 18.
Replaced by F08NGF (DORMHR).

The following replacement is valid only if the previous call to F01AKF has been replaced by a call to F08NEF (DGEHRD) as indicated above.

Old: CALL F01ALF(K,L,IR,A,IA,INTGER,Z,IZ,N)
New: CALL DORMHR('L','N',N,IR,K,L,A,IA,TAU,Z,IZ,WORK,LWORK,INFO)

where WORK is a double precision array of length at least IR and LWORK is its actual length.

F01AMF

Withdrawn at Mark 18.
Replaced by F08NSF (ZGEHRD).

Old: CALL F01AMF(N,K,L,AR,IAR,AI,IAI,INTGER)
New: DO 20 J = 1, N
        DO 10 I = 1, N
           A(I,J) = cmplx(AR(I,J),AI(I,J))
  10    CONTINUE
  20 CONTINUE
     CALL ZGEHRD(N,K,L,A,IA,TAU,WORK,LWORK,INFO)

where A is a complex*16 array of dimension IA,N , TAU is a complex*16 array of length at least N-1 , WORK is a complex*16 array of length at least N and LWORK is its actual length.

Note that the Hessenberg matrix computed by F08NSF (ZGEHRD) is different from that computed by F01AMF, because F08NSF (ZGEHRD) uses orthogonal transformations, whereas F01AMF uses stabilized elementary transformations.

F01ANF

Withdrawn at Mark 18.
Replaced by F08NUF (ZUNMHR).

The following replacement is valid only if the previous call to F01AMF has been replaced by a call to F08NSF (ZGEHRD) as indicated above.

Old: CALL F01ANF(K,L,IR,AR,IAR,AI,IAI,INTGER,ZR,IZR,ZI,IZI,N)
New: CALL ZUNMHR('L','N',N,IR,K,L,A,IA,TAU,Z,IZ,WORK,LWORK,INFO)
     DO 20 J = 1, IR
        DO 10 I = 1, N
           ZR(I,J) = real(Z(I,J))
           ZI(I,J) = imag(Z(I,J))
  10    CONTINUE
  20 CONTINUE

where A is a complex*16 array of dimension IA,N , TAU is a complex*16 array of length at least N-1 , Z is a complex*16 array of dimension IZ,IR , WORK is a complex*16 array of length at least IR and LWORK is its actual length.

F01APF

Withdrawn at Mark 18.
Replaced by F06QFF and F08NFF (DORGHR).

The following replacement is valid only if the previous call to F01AKF has been replaced by a call to F08NEF (DGEHRD) as indicated above.

Old: CALL F01APF(N,K,L,INTGER,H,IH,V,IV)
New: CALL F06QFF('L',N,N,H,IH,V,IV)
     CALL DORGHR(N,K,L,V,IV,TAU,WORK,LWORK,INFO)

where WORK is a double precision array of length at least N , and LWORK is its actual length.

Note that the orthogonal matrix formed by F08NFF (DORGHR) is not the same as the non-orthogonal matrix formed by F01APF. See F01AKF above.

F01ATF

Withdrawn at Mark 18.
Replaced by F08NHF (DGEBAL).

Old: CALL F01ATF(N,IB,A,IA,K,L,D)
New: CALL DGEBAL('B',N,A,IA,K,L,D,INFO)

Note that the balanced matrix returned by F08NHF (DGEBAL) may be different from that returned by F01ATF.

F01AUF

Withdrawn at Mark 18.
Replaced by F08NJF (DGEBAK).

Old: CALL F01AUF(N,K,L,M,D,Z,IZ)
New: CALL DGEBAK('B','R',N,K,L,D,M,Z,IZ,INFO)

F01AVF

Withdrawn at Mark 18.
Replaced by F08NVF (ZGEBAL).

Old: CALL F01AVF(N,IB,AR,IAR,AI,IAI,K,L,D)
New: DO 20 J = 1, N
        DO 10 I = 1, N
           A(I,J) = cmplx(AR(I,J),AI(I,J))
  10    CONTINUE
  20 CONTINUE
     CALL ZGEBAL('B',N,A,IA,K,L,D,INFO)
     DO 20 J = 1, N
        DO 10 I = 1, N
           AR(I,J) = real(A(I,J))
           AI(I,J) = imag(A(I,J))
  10    CONTINUE
  20 CONTINUE

where A is a complex*16 array of dimension IA,N .

Note that the balanced matrix returned by F08NVF (ZGEBAL) may be different from that returned by F01AVF.

F01AWF

Withdrawn at Mark 18.
Replaced by F08NWF (ZGEBAK).

Old: CALL F01AWF(N,K,L,M,D,ZR,IZR,ZI,IZI)
New: DO 20 J = 1, M
        DO 10 I = 1, N
           Z(I,J) = cmplx(ZR(I,J),ZI(I,J))
  10    CONTINUE
  20 CONTINUE
     CALL ZGEBAK('B','R',N,K,L,D,M,Z,IZ,INFO)
     DO 40 J = 1, M
        DO 30 I = 1, N
           ZR(I,J) = real(Z(I,J))
           ZI(I,J) = imag(Z(I,J))
 30     CONTINUE
 40  CONTINUE

where Z is a complex*16 array of dimension IZ,M .

F01AXF

Withdrawn at Mark 18.
Replaced by F06EFF (DCOPY) and F08BEF (DGEQPF).

Old: CALL F01AXF(M,N,QR,IQR,ALPHA,IPIV,Y,E,IFAIL)
New: CALL DGEQPF(M,N,QR,IQR,IPIV,Y,WORK,INFO)
     CALL DCOPY(N,QR,IQR+1,ALPHA,1)

where WORK is a double precision array of length at least 3×N .

Note that the details of the Householder matrices returned by F08BEF (DGEQPF) are different from those returned by F01AXF, but they determine the same orthogonal matrix Q .

F01AYF

Withdrawn at Mark 18.
Replaced by F08GEF (DSPTRD).

Old: CALL F01AYF(N,TOL,A,IA,D,E,E2)
New: CALL DSPTRD('U',N,A,D,E(2),TAU,INFO)
     E(1) = 0.0D0
     DO 10 I = 1, N
        E2(I) = E(I)*E(I)
  10 CONTINUE

where TAU is a double precision array of length at least N-1 .

F01AZF

Withdrawn at Mark 18.
Replaced by F08GGF (DOPMTR).

The following replacement is valid only if the previous call to F01AYF has been replaced by a call to F08GEF (DSPTRD) as shown above.

Old: CALL F01AZF(N,M1,M2,A,IA,Z,IZ)
New: CALL DOPMTR('L','U','N',N,M2-M1+1,A,TAU,Z(1,M1),IZ,WORK,INFO)

where WORK is a double precision array of length at least M2-M1+1 .

F01BCF

Withdrawn at Mark 18.
Replaced by F08FSF (ZHETRD) and F08FTF (ZUNGTR).

Old: CALL F01BCF(N,TOL,AR,IAR,AI,IAI,D,E,WK1,WK2)
New: DO 20 J = 1, N
        DO 10 I = 1, N
           A(I,J) = cmplx(AR(I,J),AI(I,J))
  10    CONTINUE
  20 CONTINUE
     CALL ZHETRD('L',N,A,IA,D,E(2),TAU,WORK,LWORK,INFO)
     E(1) = 0.0D0
     CALL ZUNGTR('L',N,A,IA,TAU,WORK,LWORK,INFO)
     DO 40 J = 1, N
        DO 30 I = 1, N
           AR(I,J) = real(A(I,J))
           AI(I,J) = imag(A(I,J))
 30     CONTINUE
 40  CONTINUE

where A is a complex*16 array of dimension IA,N , TAU is a complex*16 array of length at least N-1 , WORK is a complex*16 array of length at least N-1 , and LWORK is its actual length.

Note that the tridiagonal matrix T and the unitary matrix Q computed by F08FSF (ZHETRD) and F08FTF (ZUNGTR) are different from those computed by F01BCF, but they satisfy the same relation QHAQ=T .

F01BDF

Withdrawn at Mark 18.
Replaced by F06EGF (DSWAP), F07FDF (DPOTRF) and F08SEF (DSYGST).

Old: CALL F01BDF(N,A,IA,B,IB,DL,IFAIL)
New: DO 20 J = 1, N
        DO 10 I = J, N
           A(I,J) = A(J,I)
           B(I,J) = B(J,I)
  10    CONTINUE
        DL(J) = B(J,J)
  20 CONTINUE
     CALL DPOTRF('L',N,B,IB,INFO)
     IF (INFO.EQ.0) THEN
        CALL DSYGST(2,'L',N,A,IA,B,IB,INFO)
     ELSE
        IFAIL = 1
     END IF
     CALL DSWAP(N,DL,1,B,IB+1)

IFAIL is set to 1 if the matrix B is not positive-definite. It is essential to test IFAIL.

F01BEF

Withdrawn at Mark 18.
Replaced by F06YFF (DTRMM).

Old: CALL F01BEF(N,M1,M2,B,IB,DL,V,IV)
New: CALL DSWAP(N,DL,1,B,IB+1)
     CALL DTRMM('L','L','N','N',N,M2-M1+1,1.0D0,B,IB,V(1,M1),IV)
     CALL DSWAP(N,DL,1,B,IB+1)

F01BNF

Withdrawn at Mark 17.
Replaced by F07FRF (ZPOTRF).

Old: CALL F01BNF(N,A,IA,P,IFAIL)
New: CALL ZPOTRF('Upper',N,A,IA,IFAIL)

where, before the call, array A contains the upper triangle of the matrix to be factorized rather than the lower triangle (note that the elements of the upper triangle are the complex conjugates of the elements of the lower triangle). The double precision array P is no longer required; the upper triangle of A is overwritten by the upper triangular factor U , including the diagonal elements (which are not reciprocated).

F01BPF

Withdrawn at Mark 17.
Replaced by F07FRF (ZPOTRF) and F07FWF (ZPOTRI).

Old: CALL F01BPF(N,A,IA,V,IFAIL)
New: CALL ZPOTRF('Upper',N,A,IA,IFAIL)
     CALL ZPOTRI('Upper',N,A,IA,IFAIL)

where, before the calls, the upper triangle of the matrix to be inverted must be contained in rows 1 to N of A, rather than the lower triangle being in rows 2 to N+1 (note that the elements of the upper triangle are the complex conjugates of the elements of the lower triangle). The workspace vector V is no longer required.

F01BQF

Withdrawn at Mark 16.
Replaced by F07GDF (DPPTRF) and F07PDF (DSPTRF).

The replacement routines do not have exactly the same functionality as F01BQF; if this functionality is genuinely required, please contact NAG.

(a)	where the symmetric matrix is known to be positive-definite (if the matrix is in fact not positive-definite, the replacement routine will return a positive value in IFAIL) Old: CALL F01BQF(N,EPS,RL,IRL,D,IFAIL) New: CALL DPPTRF('Lower',N,RL,IFAIL)
(b)	where the matrix is not positive-definite (the replacement routine forms an LDLT factorization where D is block diagonal, rather than a Cholesky factorization) Old: CALL F01BQF(N,EPS,RL,IRL,D,IFAIL) New: CALL DSPTRF('Lower',N,RL,IPIV,IFAIL)

For the replacement calls in both (a) and (b), the array RL must now hold the complete lower triangle of the symmetric matrix, including the diagonal elements, which are no longer required to be stored in the redundant array D. The declared dimension of RL must be increased from at least NN-1 /2 to at least NN+1 /2 . It is important to note that for the calls of F07GDF (DPPTRF) and F07PDF (DSPTRF), the lower triangle of the matrix must be stored packed by column instead of by row. The dimension parameter IRL is no longer required. For the call of F07PDF (DSPTRF), the INTEGER array IPIV of length N must be supplied.

F01BTF

Withdrawn at Mark 18.
Replaced by F07ADF (DGETRF).

Old: CALL F01BTF(N,A,IA,P,DP,IFAIL)
New: CALL DGETRF(N,N,A,IA,IPIV,IFAIL)

where IPIV is an INTEGER array of length N which holds the indices of the pivot elements, and the array P is no longer required. It may be important to note that after a call of F07ADF (DGETRF), A is overwritten by the upper triangular factor U and the off-diagonal elements of the unit lower triangular factor L , whereas the factorization returned by F01BTF gives U the unit diagonal. The permutation determinant DP returned by F01BTF is not computed by F07ADF (DGETRF). If this value is required, it may be calculated after a call of F07ADF (DGETRF) by code similar to the following:

DP = 1.0D0
   DO 10 I = 1, N
      IF (I.NE.IPIV(I)) DP = -DP
10 CONTINUE

F01BWF

Withdrawn at Mark 18.
Replaced by F08HEF (DSBTRD).

Old: CALL F01BWF(N,M1,A,IA,D,E)
New: CALL DSBTRD('N','U',N,M1-1,A,IA,D,E(2),Q,1,WORK,INFO)
     E(1) = 0.0D0

where Q is a dummy double precision array of length (1) (not used in this call), and WORK is a double precision array of length at least N .

Note that the tridiagonal matrix computed by F08HEF (DSBTRD) is different from that computed by F01BWF, but it has the same eigenvalues.

F01BXF

Withdrawn at Mark 17.
Replaced by F07FDF (DPOTRF).

Old: CALL F01BXF(N,A,IA,P,IFAIL)
New: CALL DPOTRF('Upper',N,A,IA,IFAIL)

where, before the call, array A contains the upper triangle of the matrix to be factorized rather than the lower triangle. The array P is no longer required; the upper triangle of A is overwritten by the upper triangular factor U , including the diagonal elements (which are not reciprocated).

F01CDF

Old: CALL F01CDF(A,B,C,M,N,IFAIL)
New: CALL F01CTF('N','N',M,N,1.0D0,B,M,1.0D0,C,M,A,M,IFAIL)

F01CEF

Old: CALL F01CEF(A,B,C,M,N,IFAIL)
New: CALL F01CTF('N','N',M,N,1.0D0,B,M,-1.0D0,C,M,A,M,IFAIL)

F01CGF

Old: CALL F01CGF(A,MA,NA,P,Q,B,MB,NB,M1,M2,N1,N2,IFAIL)
New: CALL F01CTF('N','N',M2-M1+1,N2-N1+1,1.0D0,A(P,Q),MA,1.0D0,
    +            B(M1,N1),MB,A(P,Q),MA,IFAIL)

F01CHF