The following list gives the names of replacement routines for those routines that have been withdrawn or superseded. For routines that have been withdrawn or superseded since Mark 13 replacement calls are also given. The list indicates the minimum change necessary, but many of the replacement routines have additional flexibility and users may wish to take advantage of new features. It is strongly recommended that users consult the routine documents.
Old: CALL C02ADF(AR,AC,N,REZ,IMZ,TOL,IFAIL)
New: CALL C02AFF(A,N-1,SCALE,Z,W,IFAIL)
The coefficients are stored in the real array A of dimension (2, N+1) rather than in the arrays AR and AC, the zeros are returned in the real array Z of dimension (2,N) rather than in the arrays REZ and IMZ, and W is a real work array of dimension (4 * ( N+1)).
Old: CALL C02AEF(A,N,REZ,IMZ,TOL,IFAIL)
New: CALL C02AGF(A,N-1,SCALE,Z,W,IFAIL)
The zeros are returned in the real array Z of dimension (2,N) rather than in the arrays REZ and IMZ, and W is a real work array of dimension (2* ( N+1)).
Old: CALL D02BAF(X,XEND,N,Y,TOL,FCN,W,IFAIL)
New: DO 10 L = 1,N
THRES(L) = TOL
10 CONTINUE
CALL D02PVF(N,X,Y,XEND,TOL,THRES,2,'usualtask',.FALSE.,
+ 0.0e0,W,14*N,IFAIL)
CALL D02PCF(FCN,XEND,X,Y,YP,YMAX,W,IFAIL)
THRES, YP and YMAX are real arrays of length N and the length of array W needs extending to length 14*N.
Old: CALL D02BBF(X,XEND,N,Y,TOL,IRELAB,FCN,OUTPUT,W,IFAIL)
New: CALL D02PVF(N,X,Y,XEND,TOL,THRES,2,'usualtask',.FALSE.,
+ 0.0e0,W,14*N,IFAIL)
... set XWANT ...
10 CONTINUE
CALL D02PCF(FCN,XWANT,X,Y,YP,YMAX,W,IFAIL)
IF (XWANT.LT.XEND) THEN
... reset XWANT ...
GO TO 10
ENDIF
THRES, YP and YMAX are real arrays of length N and the length of array W needs extending to length 14*N.
Old: CALL D02BDF(X,XEND,N,Y,TOL,IRELAB,FCN,STIFF,YNORM,W,
+ IW,M,OUTPUT,IFAIL)
New: CALL D02PVF(N,X,Y,XEND,TOL,THRES,2,'usualtask',.TRUE.,
+ 0.0e0,W,32*N,IFAIL)
... set XWANT ...
10 CONTINUE
CALL D02PCF(FCN,XWANT,X,Y,YP,YMAX,IFAIL)
IF (XWANT.LT.XEND) THEN
... reset XWANT ...
GO TO 10
ENDIF
CALL D02PZF(RMSERR,ERRMAX,TERRMX,W,IFAIL)
THRES, YP, YMAX and RMSERR are real arrays of length N and W is now a real one-dimensional array of length 32*N.
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 real function also provided. Both must be declared as EXTERNAL. The array W needs to be 5 elements greater in length.
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 real 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').
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)
.
.
.
real FUNCTION G(X,Y)
real 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 Y(M)-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.
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 above. The relationship between the parameters IRELAB and RELABS is described under the replacement call for D02CBF.
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 real function also provided. All must be declared as EXTERNAL.
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 real 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.
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)
.
.
.
real FUNCTION G(X,Y)
real 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 Y(M)-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.
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,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 above. 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.
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.
Existing programs should be modified to call D02QWF and D02QFF. The interfaces are significantly different and therefore precise details of a replacement call cannot be given. Please consult the appropriate routine documents.
Existing programs should be modified to call D02NSF, D02NVF and D02NBF. The interfaces are significantly different and therefore precise details of a replacement call cannot be given. Please consult the appropriate routine documents.
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.
Not needed except with D02PAF. The equivalent routine is D02PXF.
Not needed except with D02PAF.
Not needed except with D02QAF. The equivalent routine is D02QZF.
Not needed except with D02QAF. The equivalent routine is D02QZF.
There is no precise equivalent to this routine. The closest alternative routine is D02PDF.
Existing programs should be modified to call D03PCF. 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.
Existing programs should be modified to call D03PCF. 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.
Existing programs should be modified to call D03PCF. 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.
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 real array of dimension ( N1+4), MU is a real array of dimension ( M1+4), C is a real array of dimension (N1*M1), WRK is a real array of dimension (( N1+6)* ( M1+6)), A1, B1 and FF are real arrays of dimension (1), 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. In this case, A1, B1 and FF must be dimensioned of length M.
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.
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.
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.
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 real array of dimension ( PY-4), and IWRK is an INTEGER array of dimension ( PY-4).
Old: CALL E04CGF(N,X,F,IW,LIW,W,LW,IFAIL)
New: CALL E04JAF(N,1,W,W(N+1),X,F,IW,LIW,W(2*N+1),LW-2*N,IFAIL)
Old: CALL E04DBF(N,X,F,G,XTOL,FEST,DUM,W,FUNCT,MONIT,MAXCAL,IFAIL)
New: CALL E04DGF(N,OBJFUN,ITER,F,G,X,IWORK,WORK,IUSER,USER,IFAIL)
The subroutine providing function and gradient values to E04DGF is OBJFUN; it has a different parameter list to FUNCT, but can be constructed simply as
SUBROUTINE OBJFUN(MODE,N,XC,FC,GC,NSTATE,IUSER,USER)
INTEGER MODE, N, NSTATE, IUSER(*)
real XC(N), FC, GC(N), USER(*)
C
CALL FUNCT(N,XC,FC,GC)
RETURN
END
The parameters IWORK and WORK are workspace parameters for E04DGF and must have lengths at least ( N+1) and (12*N) respectively. IUSER and USER must be declared as arrays each of length at least (1).
There is no parameter MONIT to E04DGF, but monitoring output may be obtained by calling an option setting routine. Similarly, values for FEST and MAXCAL may be supplied by calling an option setting routine. See the routine document for further information.
Old: CALL E04DEF(N,X,F,G,IW,LIW,W,LW,IFAIL)
New: CALL E04KAF(N,1,W,W(N+1),X,F,G,IW,LIW,W(2*N+1),LW-2*N,IFAIL)
Old: CALL E04DFF(N,X,F,G,IW,LIW,W,LW,IFAIL)
New: CALL E04KCF(N,1,W,W(N+1),X,F,G,IW,LIW,W(2*N+1),LW-2*N,IFAIL)
Old: CALL E04EBF(N,X,F,G,IW,LIW,W,LW,IFAIL)
New: CALL E04LYF(N,1,FUNCT,HESS,W,W(N+1),X,F,G,IW,LIW,W(2*N+1),LW-2*N,
+ 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(*)
real 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(*)
real 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 IUSER(1) and USER(1), but will not need initialising.
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(*)
real 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 IUSER(1) and USER(1), but will not need initialising.
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(*)
real 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 IUSER(1) and USER(1), but will not need initialising. 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.
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(*)
real 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 IUSER(1) and USER(1), but will not need initialising. 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.
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(*)
real 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(*)
real 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 IUSER(1) and USER(1), but will not need initialising. If, however, the array IW was used to pass information through E04HFF into LSFUN2 or LSHES2, or to get information from LSFUN2, then the array IUSER should be declared appropriately and used for this purpose.
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(*)
real 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 IUSER(1) and USER(1), but will not need initialising.
No comparative calls are given between E04JBF and E04UCF since both routines have considerable flexibility and can be called with many different options. E04UCF allows some values to be passed to it, not through the parameter list, but as 'optional parameters', supplied through calls to E04UDF or E04UEF. Names of optional parameters are given here in bold type.
E04UCF 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 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 (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 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(*)
real X(N), OBJF, OBJGRD(N), USER(*)
INTEGER IFLAG,IW(1)
real 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 supplies the arrays IUSER and USER specifically for this purpose.)
The functions of the parameters BL and BU are similar, but E04UCF 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.0e+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. It should also be noted that E04UCF does not allow a user-supplied routine 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, as indicated in the following list, but the correspondence is not exact and the specifications must be read carefully.
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(*)
real 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 IUSER(1) and USER(1), but will not need initialising.
No comparative calls are given between E04KBF and E04UCF 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 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(*)
real X(N), OBJF, OBJGRD(N), USER(*)
INTEGER IW(1)
real W(1)
C
CALL FUNCT(MODE,N,X,OBJF,OBJGRD,IW,1,W,1)
RETURN
END
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(*)
real 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 IUSER(1) and USER(1), but will not need initialising.
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(*)
real 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(*)
real 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 IUSER(1) and USER(1), but will not need initialising.
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 contains two additional parameters as follows:
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.
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
real HESS(NROWH,NCOLH), X(N), HX(N)
New: SUBROUTINE QPHESS(N,JTHCOL,HESS,NROWH,X,HX)
INTEGER N, JTHCOL, NROWH
real 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 contains one additional parameter as follows:
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.
No comparative calls are given between E04UAF and E04UCF since both routines have considerable flexibility and can be called with many different options. However users of E04UAF should have no difficulty in making the transition. Most of the 'tuning' parameters in E04UAF have their counterparts as optional parameters to E04UCF, and these may be provided by calling an option setting routine prior to the call to E04UCF. The subroutines providing function and constraint values to E04UCF are OBJFUN and CONFUN respectively; they have different parameter lists to FUNCT1 and CON1, but can be constructed simply as
SUBROUTINE OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER)
INTEGER MODE, N, NSTATE, IUSER(*)
real X(N), OBJF, OBJGRD(N), USER(*)
C
CALL FUNCT1(MODE,N,X,OBJF)
RETURN
END
SUBROUTINE CONFUN(MODE,NCNLN,N,NROWJ,NEEDC,X,C,CJAC.NSTATE,
+ IUSER,USER)
INTEGER MODE, NCNLN, N, NROWJ, NEEDC(*), NSTATE, IUSER(*)
real X(X), C(*), CJAC(NROWJ,*), USER(*)
C
CALL CON1(MODE,N,NCNLN,X,C)
RETURN
END
The parameters OBJGRD, NEEDC, CJAC, IUSER and USER are the same as those for E04UCF itself. It is important to note that, unlike FUNCT1 and CON1, a call to CONFUN is not preceded by a call to OBJFUN with the same values in X, so that FUNCT1 and CON1 will need to be modified if this property was being utilized. It should also be noted that E04UCF allows general linear constraints to be supplied separately from nonlinear constraints, and indeed this is to be encouraged, but the above call to CON1 assumes that linear constraints are being regarded as nonlinear.
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,
+ 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)
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(*)
real 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(*)
real X(N),F(*),FJAC(LDFJ,*),USER(*)
See the routine documents for further information.
Old: CALL E04UPF(M,N,NCLIN,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 contains one additional parameter as follows:
Note that a call to E04UPF is the same as a call to E04USF with Y(i)=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(*)
real 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(*)
real X(N),F(*),FJAC(LDFJ,*),USER(*)
See the routine documents for further information.
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
real X(N), OBJF, OBJGRD(N)
New: SUBROUTINE OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER)
INTEGER MODE, N, NSTATE, IUSER(*)
real 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
real 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(*)
real X(N), C(NCNLN), CJAC(NROWJ,N), USER(*)
If NCNLN = 0, then the name of the dummy routine E04VDM (VDME04 in some implementations) may need to be changed to E04UDM (UDME04 in some implementations) 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 contains two additional parameters as follows:
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.
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
real X(N), OBJF, OBJGRD(N)
New: SUBROUTINE OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER)
INTEGER MODE, N, NSTATE, IUSER(*)
real 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
real 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(*)
real X(N), C(NCNLN), CJAC(NROWJ,N), USER(*)
If NCNLN = 0, then the name of the dummy routine E04VDM (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 contains four additional parameters as follows:
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.
Old: CALL F01AAF(A,IA,N,X,IX,WKSPCE,IFAIL)
New: CALL sgetrf(N,N,A,IA,IPIV,IFAIL)
CALL F06QFF('General',N,N,A,IA,X,IX)
CALL sgetri(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 max(1,N). In the replacement calls, F07ADF (SGETRF/DGETRF) computes the LU factorization of the matrix A, F06QFF copies the factorization from A to X, and F07AJF (SGETRI/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 (SGETRI/DGETRI) may be replaced by references to A and IA, in which case A will be overwritten by the inverse.
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.
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 spotrf('L',N,B,IB,INFO)
IF (INFO.EQ.0) THEN
CALL ssygst(1,'L',N,A,IA,B,IB,INFO)
ELSE
IFAIL = 1
END IF
CALL sswap(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.
Old: CALL F01AFF(N,M1,M2,B,IB,DL,Z,IZ)
New: CALL sswap(N,DL,1,B,IB+1)
CALL strsm('L','L','T','N',N,M2-M1+1,1.0e0,B,IB,Z(1,M1),IZ)
CALL sswap(N,DL,1,B,IB+1)
Old: CALL F01AGF(N,TOL,A,IA,D,E,E2)
New: CALL ssytrd('L',N,A,IA,D,E(2),TAU,WORK,LWORK,INFO)
E(1) = 0.0e0
DO 10 I = 1, N
E2(I) = E(I)*E(I)
10 CONTINUE
where TAU is a real 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 (SSYTRD/DSYTRD) is different from that computed by F01AGF, but it has the same eigenvalues.
The following replacement is valid only if the previous call to F01AGF has been replaced by a call to F08FEF (SSYTRD/DSYTRD) as shown above.
Old: CALL F01AHF(N,M1,M2,A,IA,E,Z,IZ)
New: CALL sormtr('L','L','N',N,M2-M1+1,A,IA,TAU,Z(1,M1),IZ,WORK,
+ LWORK,INFO)
where WORK is a real array of length at least (M2-M1+1), and LWORK is its actual length.
Old: CALL F01AJF(N,TOL,A,IA,D,E,Z,IZ)
New: CALL ssytrd('L',N,A,IA,D,E(2),TAU,WORK,LWORK,INFO)
E(1) = 0.0e0
CALL F06QFF('L',N,N,A,IA,Z,IZ)
CALL sorgtr('L',N,Z,IZ,TAU,WORK,LWORK,INFO)
where TAU is a real 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 (SSYTRD/DSYTRD) and F08FFF (SORGTR/DORGTR) are different from those computed by F01AJF, but they satisfy the same relation QTAQ = T.
Old: CALL F01AKF(N,K,L,A,IA,INTGER)
New: CALL sgehrd(N,K,L,A,IA,TAU,WORK,LWORK,INFO)
where TAU is a real 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 (SGEHRD/DGEHRD) is different from that computed by F01AKF, because F08NEF (SGEHRD/DGEHRD) uses orthogonal transformations, whereas F01AKF uses stabilized elementary transformations.
The following replacement is valid only if the previous call to F01AKF has been replaced by a call to F08NEF (SGEHRD/DGEHRD) as indicated above.
Old: CALL F01ALF(K,L,IR,A,IA,INTGER,Z,IZ,N)
New: CALL sormhr('L','N',N,IR,K,L,A,IA,TAU,Z,IZ,WORK,LWORK,INFO)
where WORK is a real array of length at least (IR) and LWORK is its actual length.
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 cgehrd(N,K,L,A,IA,TAU,WORK,LWORK,INFO)
where A is a complex array of dimension (IA,N), TAU is a complex array of length at least (N-1), WORK is a complex array of length at least (N) and LWORK is its actual length.
Note that the Hessenberg matrix computed by F08NSF (CGEHRD/ZGEHRD) is different from that computed by F01AMF, because F08NSF (CGEHRD/ZGEHRD) uses orthogonal transformations, whereas F01AMF uses stabilized elementary transformations.
The following replacement is valid only if the previous call to F01AMF has been replaced by a call to F08NSF (CGEHRD/ZGEHRD) as indicated above.
Old: CALL F01ANF(K,L,IR,AR,IAR,AI,IAI,INTGER,ZR,IZR,ZI,IZI,N)
New: CALL cunhmr('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 array of dimension (IA,N), TAU is a complex array of length at least (N-1), Z is a complex array of dimension (IZ,IR), WORK is a complex array of length at least (IR) and LWORK is its actual length.
The following replacement is valid only if the previous call to F01AKF has been replaced by a call to F08NEF (SGEHRD/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 sorghr(N,K,L,V,IV,TAU,WORK,LWORK,INFO)
where WORK is a real array of length at least (N), and LWORK is its actual length.
Note that the orthogonal matrix formed by F08NFF (SORGHR/DORGHR) is not the same as the non-orthogonal matrix formed by F01APF. See F01AKF above.
Old: CALL F01ATF(N,IB,A,IA,K,L,D)
New: CALL sgebal('B',N,A,IA,K,L,D,INFO)
Note that the balanced matrix returned by F08NHF (SGEBAL/DGEBAL) may be different from that returned by F01ATF.
Old: CALL F01AUF(N,K,L,M,D,Z,IZ)
New: CALL sgebak('B','R',N,K,L,D,M,Z,IZ,INFO)
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 cgebal('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 array of dimension (IA,N).
Note that the balanced matrix returned by F08NVF (CGEBAL/ZGEBAL) may be different from that returned by F01AVF.
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 cgebak('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 array of dimension (IZ,M).
Old: CALL F01AXF(M,N,QR,IQR,ALPHA,IPIV,Y,E,IFAIL)
New: CALL sgeqpf(M,N,QR,IQR,IPIV,Y,WORK,INFO)
CALL scopy(N,QR,IQR+1,ALPHA,1)
where WORK is a real array of length at least (3*N).
Note that the details of the Householder matrices returned by F08BEF (SGEQPF/DGEQPF) are different from those returned by F01AXF, but they determine the same orthogonal matrix Q.
Old: CALL F01AYF(N,TOL,A,IA,D,E,E2)
New: CALL ssptrd('U',N,A,D,E(2),TAU,INFO)
E(1) = 0.0e0
DO 10 I = 1, N
E2(I) = E(I)*E(I)
10 CONTINUE
where TAU is a real array of length at least (N-1).
The following replacement is valid only if the previous call to F01AYF has been replaced by a call to F08GEF (SSPTRD/DSPTRD) as shown above.
Old: CALL F01AZF(N,M1,M2,A,IA,Z,IZ)
New: CALL sopmtr('L','U','N',N,M2-M1+1,A,TAU,Z(1,M1),IZ,WORK,INFO)
where WORK is a real array of length at least (M2-M1+1).
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 chetrd('L',N,A,IA,D,E(2),TAU,WORK,LWORK,INFO)
E(1) = 0.0e0
CALL cungtr('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 array of dimension (IA,N), TAU is a complex array of length at least (N-1), WORK is a complex 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 (CHETRD/ZHETRD) and F08FTF (CUNGTR/ZUNGTR) are different from those computed by F01BCF, but they satisfy the same relation QHAQ = T.
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 spotrf('L',N,B,IB,INFO)
IF (INFO.EQ.0) THEN
CALL ssygst(2,'L',N,A,IA,B,IB,INFO)
ELSE
IFAIL = 1
END IF
CALL sswap(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.
Old: CALL F01BEF(N,M1,M2,B,IB,DL,V,IV)
New: CALL sswap(N,DL,1,B,IB+1)
CALL strmm('L','L','N','N',N,M2-M1+1,1.0e0,B,IB,V(1,M1),IV)
CALL sswap(N,DL,1,B,IB+1)
Old: CALL F01BNF(N,A,IA,P,IFAIL)
New: CALL cpotrf('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 real 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).
Old: CALL F01BPF(N,A,IA,V,IFAIL)
New: CALL cpotrf('Upper',N,A,IA,IFAIL)
CALL cpotri('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.
The replacement routines do not have exactly the same functionality as F01BQF; if this functionality is genuinely required, please contact NAG.
Old: CALL F01BQF(N,EPS,RL,IRL,D,IFAIL)
New: CALL spptrf('Lower',N,RL,IFAIL)
Old: CALL F01BQF(N,EPS,RL,IRL,D,IFAIL)
New: CALL ssptrf('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 N( N-1)/2 to at least N( N+1)/2. It is important to note that for the calls of F07GDF (SPPTRF/DPPTRF) and F07PDF (SSPTRF/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 (SSPTRF/DSPTRF), the INTEGER array IPIV of length N must be supplied.
Old: CALL F01BTF(N,A,IA,P,DP,IFAIL)
New: CALL sgetrf(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 (SGETRF/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 (SGETRF/DGETRF). If this value is required, it may be calculated after a call of F07ADF (SGETRF/DGETRF) by code similar to the following:
DP = 1.0e0
DO 10 I = 1, N
IF (I.NE.IPIV(I)) DP = -DP
10 CONTINUE
Old: CALL F01BWF(N,M1,A,IA,D,E)
New: CALL ssbtrd('N','U',N,M1-1,A,IA,D,E(2),Q,1,WORK,INFO)
E(1) = 0.0e0
where Q is a dummy real array of length (1) (not used in this call), and WORK is a real array of length at least (N).
Note that the tridiagonal matrix computed by F08HEF (SSBTRD/DSBTRD) is different from that computed by F01BWF, but it has the same eigenvalues.
Old: CALL F01BXF(N,A,IA,P,IFAIL)
New: CALL spotrf('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).
Old: CALL F01CAF(A,M,N,IFAIL)
New: CALL F06QHF('General',M,N,0.0e0,0.0e0,A,M)
Old: CALL F01CBF(A,M,N,IFAIL)
New: CALL F06QHF('General',M,N,0.0e0,1.0e0,A,M)
Old: CALL F01CDF(A,B,C,M,N,IFAIL)
New: CALL F01CTF('N','N',M,N,1.0e0,B,M,1.0e0,C,M,A,M,IFAIL)
Old: CALL F01CEF(A,B,C,M,N,IFAIL)
New: CALL F01CTF('N','N',M,N,1.0e0,B,M,-1.0e0,C,M,A,M,IFAIL)
Old: CALL F01CFF(A,MA,NA,P,Q,B,MB,NB,M1,M2,N1,N2,IFAIL)
New: CALL F06QFF('General',M2-M1+1,N2-N1+1,B(M1,N1),MB,A(P,Q),MA)
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.0e0,A(P,Q),MA,1.0e0,
+ B(M1,N1),MB,A(P,Q),MA,IFAIL)
Old: CALL F01CHF(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.0e0,A(P,Q),MA,-1.0e0,
+ B(M1,N1),MB,A(P,Q),MA,IFAIL)
Old: CALL F01CLF(A,B,C,N,P,M,IFAIL)
New: CALL sgemm('N','T',N,P,M,1.0e0,B,N,C,P,0.0e0,A,N)
Old: CALL F01CMF(A,LA,B,LB,M,N)
New: CALL F06QFF('General',M,N,A,LA,B,LB)
Old: CALL F01CNF(V,M,A,LA,I)
New: CALL scopy(M,V,1,A(I,1),LA)
Old: CALL F01CPF(A,B,N)
New: CALL scopy(N,A,1,B,1)
Old: CALL F01CQF(A,N)
New: CALL F06FBF(N,0.0e0,A,1)
Old: CALL F01CSF(A,LA,B,N,C)
New: CALL sspmv('U',N,1.0e0,A,B,1,0.0e0,C,1)
Old: F01DAF(L,M,C1,IRA,ICB,A,IA,B,IB,N)
New: C1 + sdot(M-L+1,A(IRA,L)IA,B(L,ICB),1)
Old: D = F01DBF(L,M,C1,IRA,ICB,A,IA,B,IB,N)
New: CALL X03AAF(A(IRA,L),(M-L)*IA+1,B(L,ICB),M-L+1,IA,1,C1,0.0e0,D,
+ D2,.TRUE.,IFAIL)
(here D2 is a new real variable whose value is not used).
Old: CALL F01DCF(L,M,CX,IRA,ICB,A,IA,B,IB,N,CR,CI)
New: DX = CX - cdotu(M-L+1,A(IRA,L),IA,B(L,ICB),1)
CR = real(DX)
CI = imag(DX)
(here DX is a new complex variable).
Old: CALL F01DDF(L,M,CX,IRA,ICB,A,IA,B,IB,N,CR,CI)
New: CALL X03ABF(A(IRA,L),(M-L)*IA+1,B(L,ICB),M-L+1,IA,1,-CX,DX,
+ .TRUE.,IFAIL)
CR = -real(DX)
CI = -imag(DX)
(here DX is a new complex variable).
Old: F01DEF(A,B,N)
New: sdot(N,A,1,B,1)
Old: CALL F01LBF(N,M1,M2,A,IA,AL,IL,IN,IV,IFAIL)
New: CALL sgbtrf(N,N,M1,M2,A,IA,IN,IFAIL)
where the size of array A must now have a leading dimension IA of at least 2 × M1 + M2 + 1. The array AL, its associated dimension parameter IL, and the parameter IV are not required for F07BDF (SGBTRF/DGBTRF) because this routine overwrites A by both the L and U factors. The scheme by which the matrix is packed into the array is completely different from that used by F01LBF; the relevant routine document should be consulted for details.
Old: CALL F01LZF(N,A,NRA,C,NRC,WANTB,B,WANTQ,WANTY,Y,NRY,LY,WANTZ,Z,
+ NRZ,NCZ,D,E,WORK1,WORK2,IFAIL)
New: CALL sgebrd(N,N,A,NRA,D,E(2),TAUQ,TAUP,WORK1,LWORK,INFO)
IF (WANTB) THEN
CALL sormbr('Q','L','T',N,1,NA,NRA,TAUQ,B,N,WORK1,LWORK,INFO)
ELSE IF (WANTQ) THEN
CALL sorgbr('Q',N,N,N,A,NRA,TAUQ,WORK,LWORK,INFO)
ELSE IF (WANTY) THEN
CALL sormbr('Q','R','N',LY,N,N,A,NRA,TAUQ,Y,NRY,WORK1,LWORK,
+ INFO)
ELSE IF (WANTZ) THEN
CALL sormbr('P','L','T',N,NCZ,N,A,NRA,TAUP,Z,NRZ,WORK1,LWORK,
+ INFO)
END IF
where TAUQ and TAUP are real arrays of length at least (N) and LWORK is the actual length of WORK1. The parameter WORK2 is no longer required.
Existing programs should be modified to call F11JAF. The interfaces are significantly different and therefore precise details of a replacement call cannot be given. Please consult the appropriate routine document.
Old: CALL F01NAF(N,ML,MU,A,NRA,TOL,IN,SCALE,IFAIL)
New: CALL cgbtrf(N,N,ML,MU,A,NRA,IN,IFAIL)
where the parameter TOL and array SCALE are no longer required. The input matrix must be stored using the same scheme as for F01NAF, except in rows ML + 1 to 2× ML + MU + 1 of A instead of rows 1 to ML + MU + 1. In F07BRF (CGBTRF/ZGBTRF), the value returned in IN(N) has no significance as an indicator of near-singularity of the matrix.
Old: CALL F01QAF(M,N,A,NRA,C,NRC,Z,IFAIL)
New: CALL sgeqrf(M,N,A,NRA,Z,WORK,LWORK,INFO)
where WORK is a real array of length at least (LWORK). The parameters C and NRC are no longer required.
Note that the representation of the matrix Q is not identical, but subsequent calls to routines F08AFF (SORGQR/DORGQR) and F08AGF (SORMQR/DORMQR) may be used to obtain Q explicitly and to transform by Q or QT respectively.
Old: CALL F01QBF(M,N,A,NRA,C,NRC,WORK,IFAIL)
New: CALL F06QFF('General',M,N,A,NRA,C,NRC)
CALL F01QJF(M,N,C,NRC,WORK,IFAIL)
The call to F06QFF simply copies the leading M by N part of A to C. This may be omitted if it is desired to use the same arrays for A and C. Note that the representation of the orthogonal matrix Q is not identical, but following F01QJF routine F01QKF may be used to form Q.
Old: CALL F01QCF(M,N,A,LDA,ZETA,IFAIL)
New: CALL sgeqrf(M,N,A,LDA,ZETA,WORK,LWORK,INFO)
where WORK is a real array of length at least (N), and LWORK is its actual length.
The subdiagonal elements of A and the elements of ZETA returned by F08AEF (SGEQRF/DGEQRF) are not the same as those returned by F01QCF. Subsequent calls to F01QDF or F01QEF must also be replaced by calls to F08AGF (SORMQR/DORMQR) or F08AFF (SORGQR/DORGQR) as shown below.
The following replacement is valid only if the previous call to F01QCF has been replaced by a call to F08AEF (SGEQRF/DGEQRF) as shown above. It also assumes that the second argument of F01QDF (WHERET) is 'S', which is appropriate if the contents of A and ZETA have not been changed after the call of F01QCF.
Old: CALL F01QDF(TRANS,'S',M,N,A,LDA,ZETA,NCOLB,B,LDB,WORK,IFAIL)
New: CALL sormqr('L',TRANS,M,NCOLB,N,A,LDA,ZETA,B,LDB,WORK,LWORK,INFO)
where LWORK is the actual length of WORK.
The following replacement is valid only if the previous call to F01QCF has been replaced by a call to F08AEF (SGEQRF/DGEQRF) as shown above. It also assumes that the first argument of F01QEF (WHERET) is 'S', which is appropriate if the contents of A and ZETA have not been changed after the call of F01QCF.
Old: CALL F01QEF('S',M,N,NCOLQ,A,LDA,ZETA,WORK,IFAIL)
New: CALL sorgqr(M,NCOLQ,N,A,LDA,ZETA,WORK,LWORK,INFO)
where LWORK is the actual length of WORK.
The following replacement assumes that the 1st argument of F01QFF (PIVOT) is 'C'. There is no direct replacement if PIVOT = 'S'.
Old: CALL F01QFF('C',M,N,A,LDA,ZETA,PERM,WORK,IFAIL)
New: DO 10 I = 1, N
PERM(I) = 0
10 CONTINUE
CALL sgeqpf(M,N,A,LDA,PERM,ZETA,WORK,INFO)
where WORK is a real array of length at least (3*N) (F01QFF only requires WORK to be of length (2*N)).
The subdiagonal elements of A and the elements of ZETA returned by F08BEF (SGEQPF/DGEQPF) are not the same as those returned by F01QFF. Subsequent calls to F01QDF or F01QEF must also be replaced by calls to F08AGF (SORMQR/DORMQR) or F08AFF (SORGQR/DORGQR) as shown above. Note also that the array PERM returned by F08BEF (SGEQPF/DGEQPF) holds details of the interchanges in a different form than that returned by F01QFF.
Old: CALL F01RCF(M,N,A,LDA,THETA,IFAIL)
New: CALL cgeqrf(M,N,A,LDA,THETA,WORK,LWORK,INFO)
where WORK is a complex array of length at least (N), and LWORK is its actual length.
The subdiagonal elements of A and the elements of THETA returned by F08ASF (CGEQRF/ZGEQRF) are not the same as those returned by F01RCF. Subsequent calls to F01RDF or F01REF must also be replaced by calls to F08AUF (CUNMQR/ZUNMQR) or F08ATF (CUNGQR/ZUNGQR) as shown below.
The following replacement is valid only if the previous call to F01RCF has been replaced by a call to F08ASF (CGEQRF/ZGEQRF) as shown above. It also assumes that the second argument of F01RDF (WHERET) is 'S', which is appropriate if the contents of A and THETA have not been changed after the call of F01RCF.
Old: CALL F01RDF(TRANS,'S',M,N,A,LDA,THETA,NCOLB,B,LDB,WORK,IFAIL)
New: CALL cunmqr('L',TRANS,M,NCOLB,N,A,LDA,THETA,B,LDB,WORK,LWORK,
+ INFO)
where LWORK is the actual length of WORK.
The following replacement is valid only if the previous call to F01RCF has been replaced by a call to F08ASF (CGEQRF/ZGEQRF) as shown above. It also assumes that the first argument of F01REF (WHERET) is 'S', which is appropriate if the contents of A and THETA have not been changed after the call of F01RCF.
Old: CALL F01REF('S',M,N,NCOLQ,A,LDA,THETA,WORK,IFAIL)
New: CALL cungqr(M,NCOLQ,N,A,LDA,THETA,WORK,LWORK,INFO)
where LWORK is the actual length of WORK.
The following replacement assumes that the first argument of F01RFF (PIVOT) is 'C'. There is no direct replacement if PIVOT = 'S'.
Old: CALL F01RFF('C',M,N,A,LDA,THETA,PERM,WORK,IFAIL)
New: DO 10 I = 1, N
PERM(I) = 0
10 CONTINUE
CALL cgeqpf(M,N,A,LDA,PERM,THETA,CWORK,WORK,INFO)
where CWORK is a complex array of length at least (N).
The subdiagonal elements of A and the elements of THETA returned by F08BSF (CGEQPF/ZGEQPF) are not the same as those returned by F01RFF. Subsequent calls to F01RDF or F01REF must also be replaced by calls to F08AUF (CUNMQR/ZUNMQR) or F08ATF (CUNGQR/ZUNGQR) as shown above. Note also that the array PERM returned by F08BSF (CGEQPF/ZGEQPF) holds details of the interchanges in a different form than that returned by F01RFF.
Notes:
Old: CALL F02AAF(A,IA,N,R,E,IFAIL)
New: CALL F02FAF('N','L',N,A,IA,R,WORK,LWORK,IFAIL)
where WORK is a real array of length at least (3*N) and LWORK is its actual length.
Old: CALL F02ABF(A,IA,N,R,V,IV,E,IFAIL)
New: CALL F06QFF('L',N,N,A,IA,V,IV)
CALL F02FAF('V','L',N,V,IV,R,WORK,LWORK,IFAIL)
where WORK is a real array of length at least (3*N) and LWORK is its actual length. If F02ABF was called with the same array supplied for V and A, then the call to F06QFF may be omitted.
Old: CALL F02ADF(A,IA,B,IB,N,R,DE,IFAIL)
New: CALL F02FDF(1,'N','U',N,A,IA,B,IB,R,WORK,LWORK,IFAIL)
where WORK is a real array of length at least (3*N) and LWORK is its actual length.
Note that the call to F02FDF will overwrite the upper triangles of the arrays A and B and leave the subdiagonal elements unchanged, whereas the call to F02ADF overwrites the lower triangle and leaves the elements above the diagonal unchanged.
Old: CALL F02AEF(A,IA,B,IB,N,R,V,IV,DL,E,IFAIL)
New: CALL F06QFF('U',N,N,A,IA,V,IV)
CALL F02FDF(1,'V','U',N,V,IV,B,IB,R,WORK,LWORK,IFAIL)
where WORK is a real array of length at least (3*N) and LWORK is its actual length.
Note that the call to F02FDF will overwrite the upper triangle of the array B and leave the subdiagonal elements unchanged, whereas the call to F02ADF overwrites the lower triangle and leaves the elements above the diagonal unchanged. The call to F06QFF copies A to V, so A is left unchanged. If F02AEF was called with the same array supplied for V and A, then the call to F06QFF may be omitted.
Old: CALL F02AFF(A,IA,N,RR,RI,INTGER,IFAIL)
New: CALL F02EBF('N',N,A,IA,RR,RI,VR,1,VI,1,WORK,LWORK,IFAIL)
where VR and VI are dummy arrays of length (1) (not used in this call), WORK is a real array of length at least (4*N) and LWORK is its actual length; the iteration counts (returned by F02AFF in the array INTGER) are not available from F02EBF.
Old: CALL F02AGF(A,IA,N,RR,RI,VR,IVR,VI,IVI,INTGER,IFAIL)
New: CALL F02EBF('V',N,A,IA,RR,RI,VR,IVR,VI,IVI,WORK,LWORK,IFAIL)
where WORK is a real array of length at least (4*N) and LWORK is its actual length; the iteration counts (returned by F02AGF in the array INTGER) are not available from F02EBF.
Old: CALL F02AJF(AR,IAR,AI,IAI,N,RR,RI,INTGER,IFAIL)
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 F02GBF('N',N,A,IA,R,V,1,RWORK,WORK,LWORK,IFAIL)
DO 30 I = 1, N
RR(I) = real(R(I))
RI(I) = imag(R(I))
30 CONTINUE
where A is a complex array of dimension (IA,N), R is a complex array of dimension (N), V is a dummy complex array of length (1) (not used in this call), RWORK is a real array of length at least (2*N), WORK is a complex array of length at least (2*N) and LWORK is its actual length.
Old: CALL F02AKF(AR,IAR,AI,IAI,N,RR,RI,VR,IVR,VI,IVI,INTGER,IFAIL )
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 F02GBF('V',N,A,IA,R,V,IV,RWORK,WORK,LWORK,IFAIL)
DO 40 J = 1, N
RR(J) = real(R(J))
RI(J) = imag(R(J))
DO 30 I = 1, N
VR(I,J) = real(V(I,J))
VI(I,J) = imag(V(I,J))
30 CONTINUE
40 CONTINUE
where A is a complex array of dimension (IA,N), R is a complex array of length (N), V is a complex array of dimension (IV,N), RWORK is a real array of length at least (2*N), WORK is a complex array of length at least (2*N) and LWORK is its actual length.
Old: CALL F02AMF(N,EPS,D,E,V,IV,IFAIL)
New: CALL ssteqr('V',N,D,E(2),V,IV,WORK,INFO)
where WORK is a real array of length at least (2*(N-1)).
Old: CALL F02ANF(N,EPS,HR,IHR,HI,IHI,RR,RI,IFAIL)
New: DO 20 J = 1, N
DO 10 I = 1, N
H(I,J) = cmplx(HR(I,J),HI(I,J))
10 CONTINUE
20 CONTINUE
CALL chseqr('E','N',N,1,N,H,IH,R,Z,1,WORK,1,INFO)
DO 30 I = 1, N
RR(I) = real(R(I))
RI(I) = imag(R(I))
30 CONTINUE
where H is a complex array of dimension (IH,N), R is a complex array of length (N), Z is a dummy complex array of length (1) (not used in this call), and WORK is a complex array of length at least (N).
Old: CALL F02APF(N,EPS,H,IH,RR,RI,ICNT,IFAIL)
New: CALL shseqr('E','N',N,1,N,H,IH,RR,RI,Z,1,WORK,1,INFO)
where Z is a dummy real array of length (1) (not used in this call), and WORK is a real array of length at least (3* N); the iteration counts (returned by F02APF in the array ICNT) are not available from F08PEF (SHSEQR/DHSEQR).
Old: CALL F02AQF(N,K,L,EPS,H,IH,V,IV,RR,RI,INTGER,IFAIL)
New: CALL shseqr('S','V',N,K,L,H,IH,RR,RI,V,IV,WORK,1,INFO)
CALL strevc('R','O',SELECT,N,H,IH,V,IV,V,IV,N,M,WORK,INFO)
where SELECT is a dummy logical array of length (1) (not used in this call), and WORK is a real array of length at least (3*N); the iteration counts (returned by F02AQF in the array INTGER) are not available from F08PEF (SHSEQR/DHSEQR); M is an integer which is set to N by F08QKF (STREVC/DTREVC).
Old: CALL F02ARF(N,K,L,EPS,INTGER,HR,IHR,HI,IHI,RR,RI,VR,IVR,VI,
+ IVI, IFAIL)
New: DO 20 J = 1, N
DO 10 I = 1, N
H(I,J) = cmplx(HR(I,J),HI(I,J))
10 CONTINUE
20 CONTINUE
CALL chseqr('S','V',N,K,L,H,IH,R,V,IV,WORK,1,INFO)
CALL ctrevc('R','O',SELECT,N,H,IH,V,IV,V,IV,N,M,WORK,INFO)
DO 40 J = 1, N
RR(J) = real(R(J))
RI(J) = imag(R(J))
DO 30 I = 1, N
VR(I,J) = real(V(I,J))
VI(I,J) = imag(V(I,J))
30 CONTINUE
40 CONTINUE
where H is a complex array of dimension (IH,N), R is a complex array of length (N), V is a complex array of dimension (IV,N), WORK is a complex array of length at least (2*N) and RWORK is a real array of length at least (N); M is an integer which is set to N by F08QXF (CTREVC/ZTREVC).
If F02ARF was preceded by a call to F01AMF to reduce a full complex matrix to Hessenberg form, then the call to F01AMF must also be replaced by calls to F08NSF (CGEHRD/ZGEHRD) and F08NTF (CUNGHR/ZUNGHR).
Old: CALL F02AVF(N,EPS,D,E,IFAIL)
New: CALL ssterf(N,D,E(2),INFO)
Old: CALL F02AWF(AR,IAR,AI,IAI,N,R,