1C Dummy for R 2 LOGICAL FUNCTION STOPX() 3 STOPX = .FALSE. 4 END 5 6C Minimally modernized in 2018-09, so is fixed-form F90, not F77 7 8 SUBROUTINE DRN2G(D, DR, IV, LIV, LV, N, ND, N1, N2, P, R, 9 1 RD, V, X) 10C 11C *** REVISED ITERATION DRIVER FOR NL2SOL (VERSION 2.3) *** 12C 13 INTEGER LIV, LV, N, ND, N1, N2, P 14 INTEGER IV(LIV) 15 DOUBLE PRECISION D(P), DR(ND,P), R(ND), RD(ND), V(LV), X(P) 16C 17C-------------------------- PARAMETER USAGE -------------------------- 18C 19C D........ SCALE VECTOR. 20C DR....... DERIVATIVES OF R AT X. 21C IV....... INTEGER VALUES ARRAY. 22C LIV...... LENGTH OF IV... LIV MUST BE AT LEAST P + 82. 23C LV....... LENGTH OF V... LV MUST BE AT LEAST 105 + P*(2*P+16). 24C N........ TOTAL NUMBER OF RESIDUALS. 25C ND....... MAX. NO. OF RESIDUALS PASSED ON ONE CALL. 26C N1....... LOWEST ROW INDEX FOR RESIDUALS SUPPLIED THIS TIME. 27C N2....... HIGHEST ROW INDEX FOR RESIDUALS SUPPLIED THIS TIME. 28C P........ NUMBER OF PARAMETERS (COMPONENTS OF X) BEING ESTIMATED. 29C R........ RESIDUALS. 30C RD....... RD(I) = SQRT(G(I)**T * H(I)**-1 * G(I)) ON OUTPUT WHEN 31C IV(RDREQ) IS NONZERO. DRN2G SETS IV(REGD) = 1 IF RD 32C IS SUCCESSFULLY COMPUTED, TO 0 IF NO ATTEMPT WAS MADE 33C TO COMPUTE IT, AND TO -1 IF H (THE FINITE-DIFFERENCE HESSIAN) 34C WAS INDEFINITE. IF ND .GE. N, THEN RD IS ALSO USED AS 35C TEMPORARY STORAGE. 36C V........ FLOATING-POINT VALUES ARRAY. 37C X........ PARAMETER VECTOR BEING ESTIMATED (INPUT = INITIAL GUESS, 38C OUTPUT = BEST VALUE FOUND). 39C 40C *** DISCUSSION *** 41C 42C NOTE... NL2SOL AND NL2ITR (MENTIONED BELOW) ARE DESCRIBED IN 43C ACM TRANS. MATH. SOFTWARE, VOL. 7, PP. 369-383 (AN ADAPTIVE 44C NONLINEAR LEAST-SQUARES ALGORITHM, BY J.E. DENNIS, D.M. GAY, 45C AND R.E. WELSCH). 46C 47C THIS ROUTINE CARRIES OUT ITERATIONS FOR SOLVING NONLINEAR 48C LEAST SQUARES PROBLEMS. WHEN ND = N, IT IS SIMILAR TO NL2ITR 49C (WITH J = DR), EXCEPT THAT R(X) AND DR(X) NEED NOT BE INITIALIZED 50C WHEN DRN2G IS CALLED WITH IV(1) = 0 OR 12. DRN2G ALSO ALLOWS 51C R AND DR TO BE SUPPLIED ROW-WISE -- JUST SET ND = 1 AND CALL 52C DRN2G ONCE FOR EACH ROW WHEN PROVIDING RESIDUALS AND JACOBIANS. 53C ANOTHER NEW FEATURE IS THAT CALLING DRN2G WITH IV(1) = 13 54C CAUSES STORAGE ALLOCATION ONLY TO BE PERFORMED -- ON RETURN, SUCH 55C COMPONENTS AS IV(G) (THE FIRST SUBSCRIPT IN G OF THE GRADIENT) 56C AND IV(S) (THE FIRST SUBSCRIPT IN V OF THE S LOWER TRIANGLE OF 57C THE S MATRIX) WILL HAVE BEEN SET (UNLESS LIV OR LV IS TOO SMALL), 58C AND IV(1) WILL HAVE BEEN SET TO 14. CALLING DRN2G WITH IV(1) = 14 59C CAUSES EXECUTION OF THE ALGORITHM TO BEGIN UNDER THE ASSUMPTION 60C THAT STORAGE HAS BEEN ALLOCATED. 61C 62C *** SUPPLYING R AND DR *** 63C 64C DRN2G USES IV AND V IN THE SAME WAY AS NL2SOL, WITH A SMALL 65C NUMBER OF OBVIOUS CHANGES. ONE DIFFERENCE BETWEEN DRN2G AND 66C NL2ITR IS THAT INITIAL FUNCTION AND GRADIENT INFORMATION NEED NOT 67C BE SUPPLIED IN THE VERY FIRST CALL ON DRN2G, THE ONE WITH 68C IV(1) = 0 OR 12. ANOTHER DIFFERENCE IS THAT DRN2G RETURNS WITH 69C IV(1) = -2 WHEN IT WANTS ANOTHER LOOK AT THE OLD JACOBIAN MATRIX 70C AND THE CURRENT RESIDUAL -- THE ONE CORRESPONDING TO X AND 71C IV(NFGCAL). IT THEN RETURNS WITH IV(1) = -3 WHEN IT WANTS TO SEE 72C BOTH THE NEW RESIDUAL AND THE NEW JACOBIAN MATRIX AT ONCE. NOTE 73C THAT IV(NFGCAL) = IV(7) CONTAINS THE VALUE THAT IV(NFCALL) = IV(6) 74C HAD WHEN THE CURRENT RESIDUAL WAS EVALUATED. ALSO NOTE THAT THE 75C VALUE OF X CORRESPONDING TO THE OLD JACOBIAN MATRIX IS STORED IN 76C V, STARTING AT V(IV(X0)) = V(IV(43)). 77C ANOTHER NEW RETURN... DRN2G IV(1) = -1 WHEN IT WANTS BOTH THE 78C RESIDUAL AND THE JACOBIAN TO BE EVALUATED AT X. 79C A NEW RESIDUAL VECTOR MUST BE SUPPLIED WHEN DRN2G RETURNS WITH 80C IV(1) = 1 OR -1. THIS TAKES THE FORM OF VALUES OF R(I,X) PASSED 81C IN R(I-N1+1), I = N1(1)N2. YOU MAY PASS ALL THESE VALUES AT ONCE 82C (I.E., N1 = 1 AND N2 = N) OR IN PIECES BY MAKING SEVERAL CALLS ON 83C DRN2G. EACH TIME DRN2G RETURNS WITH IV(1) = 1, N1 WILL HAVE 84C BEEN SET TO THE INDEX OF THE NEXT RESIDUAL THAT DRN2G EXPECTS TO 85C SEE, AND N2 WILL BE SET TO THE INDEX OF THE HIGHEST RESIDUAL THAT 86C COULD BE GIVEN ON THE NEXT CALL, I.E., N2 = N1 + ND - 1. (THUS 87C WHEN DRN2G FIRST RETURNS WITH IV(1) = 1 FOR A NEW X, IT WILL 88C HAVE SET N1 TO 1 AND N2 TO MIN(ND,N).) THE CALLER MAY PROVIDE 89C FEWER THAN N2-N1+1 RESIDUALS ON THE NEXT CALL BY SETTING N2 TO 90C A SMALLER VALUE. DRN2G ASSUMES IT HAS SEEN ALL THE RESIDUALS 91C FOR THE CURRENT X WHEN IT IS CALLED WITH N2 .GE. N. 92C EXAMPLE... SUPPOSE N = 80 AND THAT R IS TO BE PASSED IN 8 93C BLOCKS OF SIZE 10. THE FOLLOWING CODE WOULD DO THE JOB. 94C 95C N = 80 96C ND = 10 97C ... 98C DO 10 K = 1, 8 99C *** COMPUTE R(I,X) FOR I = 10*K-9 TO 10*K *** 100C *** AND STORE THEM IN R(1),...,R(10) *** 101C CALL DRN2G(..., R, ...) 102C 10 CONTINUE 103C 104C THE SITUATION IS SIMILAR WHEN GRADIENT INFORMATION IS 105C REQUIRED, I.E., WHEN DRN2G RETURNS WITH IV(1) = 2, -1, OR -2. 106C NOTE THAT DRN2G OVERWRITES R, BUT THAT IN THE SPECIAL CASE OF 107C N1 = 1 AND N2 = N ON PREVIOUS CALLS, DRN2G NEVER RETURNS WITH 108C IV(1) = -2. IT SHOULD BE CLEAR THAT THE PARTIAL DERIVATIVE OF 109C R(I,X) WITH RESPECT TO X(L) IS TO BE STORED IN DR(I-N1+1,L), 110C L = 1(1)P, I = N1(1)N2. IT IS ESSENTIAL THAT R(I) AND DR(I,L) 111C ALL CORRESPOND TO THE SAME RESIDUALS WHEN IV(1) = -1 OR -2. 112C 113C *** COVARIANCE MATRIX *** 114C 115C IV(RDREQ) = IV(57) TELLS WHETHER TO COMPUTE A COVARIANCE 116C MATRIX AND/OR REGRESSION DIAGNOSTICS... 0 MEANS NEITHER, 117C 1 MEANS COVARIANCE MATRIX ONLY, 2 MEANS REG. DIAGNOSTICS ONLY, 118C 3 MEANS BOTH. AS WITH NL2SOL, IV(COVREQ) = IV(15) TELLS WHAT 119C HESSIAN APPROXIMATION TO USE IN THIS COMPUTING. 120C 121C *** REGRESSION DIAGNOSTICS *** 122C 123C SEE THE COMMENTS IN SUBROUTINE DN2G. 124C 125C *** GENERAL *** 126C 127C CODED BY DAVID M. GAY. 128C 129C+++++++++++++++++++++++++++++ DECLARATIONS ++++++++++++++++++++++++++ 130C 131C *** INTRINSIC FUNCTIONS *** 132C/+ 133 INTEGER IABS, MOD 134C/ 135C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 136C 137 DOUBLE PRECISION DD7TPR, DV2NRM 138 EXTERNAL DC7VFN,DIVSET, DD7TPR,DD7UPD,DG7LIT,DITSUM,DL7VML, 139 1 DN2CVP, DN2LRD, DQ7APL,DQ7RAD,DV7CPY, DV7SCP, DV2NRM 140C 141C DC7VFN... FINISHES COVARIANCE COMPUTATION. 142C DIVSET.... PROVIDES DEFAULT IV AND V INPUT COMPONENTS. 143C DD7TPR... COMPUTES INNER PRODUCT OF TWO VECTORS. 144C DD7UPD... UPDATES SCALE VECTOR D. 145C DG7LIT.... PERFORMS BASIC MINIMIZATION ALGORITHM. 146C DITSUM.... PRINTS ITERATION SUMMARY, INFO ABOUT INITIAL AND FINAL X. 147C DL7VML.... COMPUTES L * V, V = VECTOR, L = LOWER TRIANGULAR MATRIX. 148C DN2CVP... PRINTS COVARIANCE MATRIX. 149C DN2LRD... COMPUTES REGRESSION DIAGNOSTICS. 150C DQ7APL... APPLIES QR TRANSFORMATIONS STORED BY DQ7RAD. 151C DQ7RAD.... ADDS A NEW BLOCK OF ROWS TO QR DECOMPOSITION. 152C DV7CPY.... COPIES ONE VECTOR TO ANOTHER. 153C DV7SCP... SETS ALL ELEMENTS OF A VECTOR TO A SCALAR. 154C 155C *** LOCAL VARIABLES *** 156C 157 INTEGER G1, GI, I, IV1, IVMODE, JTOL1, K, L, LH, NN, QTR1, 158 1 RMAT1, YI, Y1 159 DOUBLE PRECISION T 160C 161 DOUBLE PRECISION HALF, ZERO 162C 163C *** SUBSCRIPTS FOR IV AND V *** 164C 165 INTEGER CNVCOD, COVMAT, COVREQ, DINIT, DTYPE, DTINIT, D0INIT, F, 166 1 FDH, G, H, IPIVOT, IVNEED, JCN, JTOL, LMAT, MODE, 167 2 NEXTIV, NEXTV, NF0, NF00, NF1, NFCALL, NFCOV, NFGCAL, 168 3 NGCALL, NGCOV, QTR, RDREQ, REGD, RESTOR, RLIMIT, RMAT, 169 4 TOOBIG, VNEED, Y 170C 171 PARAMETER (HALF=0.5D+0, ZERO=0.D+0) 172C 173C *** IV SUBSCRIPT VALUES *** 174C 175 PARAMETER (CNVCOD=55, COVMAT=26, COVREQ=15, DTYPE=16, FDH=74, 176 1 G=28, H=56, IPIVOT=76, IVNEED=3, JCN=66, JTOL=59, 177 2 LMAT=42, MODE=35, NEXTIV=46, NEXTV=47, NFCALL=6, 178 3 NFCOV=52, NF0=68, NF00=81, NF1=69, NFGCAL=7, NGCALL=30, 179 4 NGCOV=53, QTR=77, RESTOR=9, RMAT=78, RDREQ=57, REGD=67, 180 5 TOOBIG=2, VNEED=4, Y=48) 181C 182C *** V SUBSCRIPT VALUES *** 183C 184 PARAMETER (DINIT=38, DTINIT=39, D0INIT=40, F=10, RLIMIT=46) 185C 186C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 187C 188 LH = P * (P+1) / 2 189 IF (IV(1) .EQ. 0) CALL DIVSET(1, IV, LIV, LV, V) 190 IV1 = IV(1) 191 IF (IV1 .GT. 2) GO TO 10 192 NN = N2 - N1 + 1 193 IV(RESTOR) = 0 194 I = IV1 + 4 195c IF (IV(TOOBIG) .EQ. 0) GO TO (150, 130, 150, 120, 120, 150), I 196 IF (IV(TOOBIG) .EQ. 0) THEN 197 select case(I) 198 case(1,3,6) 199 goto 150 200 case(2) 201 goto 130 202 case(4,5) 203 goto 120 204 end select 205 END IF 206 207 IF (I .NE. 5) IV(1) = 2 208 GO TO 40 209C 210C *** FRESH START OR RESTART -- CHECK INPUT INTEGERS *** 211C 212 10 IF (ND .LE. 0) GO TO 210 213 IF (P .LE. 0) GO TO 210 214 IF (N .LE. 0) GO TO 210 215 IF (IV1 .EQ. 14) GO TO 30 216 IF (IV1 .GT. 16) GO TO 300 217 IF (IV1 .LT. 12) GO TO 40 218 IF (IV1 .EQ. 12) IV(1) = 13 219 IF (IV(1) .NE. 13) GO TO 20 220 IV(IVNEED) = IV(IVNEED) + P 221 IV(VNEED) = IV(VNEED) + P*(P+13)/2 222 20 CALL DG7LIT(D, X, IV, LIV, LV, P, P, V, X, X) 223 IF (IV(1) .NE. 14) GO TO 999 224C 225C *** STORAGE ALLOCATION *** 226C 227 IV(IPIVOT) = IV(NEXTIV) 228 IV(NEXTIV) = IV(IPIVOT) + P 229 IV(Y) = IV(NEXTV) 230 IV(G) = IV(Y) + P 231 IV(JCN) = IV(G) + P 232 IV(RMAT) = IV(JCN) + P 233 IV(QTR) = IV(RMAT) + LH 234 IV(JTOL) = IV(QTR) + P 235 IV(NEXTV) = IV(JTOL) + 2*P 236 IF (IV1 .EQ. 13) GO TO 999 237C 238 30 JTOL1 = IV(JTOL) 239 IF (V(DINIT) .GE. ZERO) CALL DV7SCP(P, D, V(DINIT)) 240 IF (V(DTINIT) .GT. ZERO) CALL DV7SCP(P, V(JTOL1), V(DTINIT)) 241 I = JTOL1 + P 242 IF (V(D0INIT) .GT. ZERO) CALL DV7SCP(P, V(I), V(D0INIT)) 243 IV(NF0) = 0 244 IV(NF1) = 0 245 IF (ND .GE. N) GO TO 40 246C 247C *** SPECIAL CASE HANDLING OF FIRST FUNCTION AND GRADIENT EVALUATION 248C *** -- ASK FOR BOTH RESIDUAL AND JACOBIAN AT ONCE 249C 250 G1 = IV(G) 251 Y1 = IV(Y) 252 CALL DG7LIT(D, V(G1), IV, LIV, LV, P, P, V, X, V(Y1)) 253 IF (IV(1) .NE. 1) GO TO 220 254 V(F) = ZERO 255 CALL DV7SCP(P, V(G1), ZERO) 256 IV(1) = -1 257 QTR1 = IV(QTR) 258 CALL DV7SCP(P, V(QTR1), ZERO) 259 IV(REGD) = 0 260 RMAT1 = IV(RMAT) 261 GO TO 100 262C 263 40 G1 = IV(G) 264 Y1 = IV(Y) 265 CALL DG7LIT(D, V(G1), IV, LIV, LV, P, P, V, X, V(Y1)) 266 IF (IV(1) .EQ. 2) GO TO 60 267 IF (IV(1) .GT. 2) GO TO 220 268C 269 V(F) = ZERO 270 IF (IV(NF1) .EQ. 0) GO TO 260 271 IF (IV(RESTOR) .NE. 2) GO TO 260 272 IV(NF0) = IV(NF1) 273 CALL DV7CPY(N, RD, R) 274 IV(REGD) = 0 275 GO TO 260 276C 277 60 CALL DV7SCP(P, V(G1), ZERO) 278 IF (IV(MODE) .GT. 0) GO TO 230 279 RMAT1 = IV(RMAT) 280 QTR1 = IV(QTR) 281 CALL DV7SCP(P, V(QTR1), ZERO) 282 IV(REGD) = 0 283 IF (ND .LT. N) GO TO 90 284 IF (N1 .NE. 1) GO TO 90 285 IF (IV(MODE) .LT. 0) GO TO 100 286 IF (IV(NF1) .EQ. IV(NFGCAL)) GO TO 70 287 IF (IV(NF0) .NE. IV(NFGCAL)) GO TO 90 288 CALL DV7CPY(N, R, RD) 289 GO TO 80 290 70 CALL DV7CPY(N, RD, R) 291 80 CALL DQ7APL(ND, N, P, DR, RD, 0) 292 CALL DL7VML(P, V(Y1), V(RMAT1), RD) 293 GO TO 110 294C 295 90 IV(1) = -2 296 IF (IV(MODE) .LT. 0) IV(1) = -1 297 100 CALL DV7SCP(P, V(Y1), ZERO) 298 110 CALL DV7SCP(LH, V(RMAT1), ZERO) 299 GO TO 260 300C 301C *** COMPUTE F(X) *** 302C 303 120 T = DV2NRM(NN, R) 304 IF (T .GT. V(RLIMIT)) GO TO 200 305 V(F) = V(F) + HALF * T**2 306 IF (N2 .LT. N) GO TO 270 307 IF (N1 .EQ. 1) IV(NF1) = IV(NFCALL) 308 GO TO 40 309C 310C *** COMPUTE Y *** 311C 312 130 Y1 = IV(Y) 313 YI = Y1 314 DO 140 L = 1, P 315 V(YI) = V(YI) + DD7TPR(NN, DR(1,L), R) 316 YI = YI + 1 317 140 CONTINUE 318 IF (N2 .LT. N) GO TO 270 319 IV(1) = 2 320 IF (N1 .GT. 1) IV(1) = -3 321 GO TO 260 322C 323C *** COMPUTE GRADIENT INFORMATION *** 324C 325 150 IF (IV(MODE) .GT. P) GO TO 240 326 G1 = IV(G) 327 IVMODE = IV(MODE) 328 IF (IVMODE .LT. 0) GO TO 170 329 IF (IVMODE .EQ. 0) GO TO 180 330 IV(1) = 2 331C 332C *** COMPUTE GRADIENT ONLY (FOR USE IN COVARIANCE COMPUTATION) *** 333C 334 GI = G1 335 DO 160 L = 1, P 336 V(GI) = V(GI) + DD7TPR(NN, R, DR(1,L)) 337 GI = GI + 1 338 160 CONTINUE 339 GO TO 190 340C 341C *** COMPUTE INITIAL FUNCTION VALUE WHEN ND .LT. N *** 342C 343 170 IF (N .LE. ND) GO TO 180 344 T = DV2NRM(NN, R) 345 IF (T .GT. V(RLIMIT)) GO TO 200 346 V(F) = V(F) + HALF * T**2 347C 348C *** UPDATE D IF DESIRED *** 349C 350 180 IF (IV(DTYPE) .GT. 0) 351 1 CALL DD7UPD(D, DR, IV, LIV, LV, N, ND, NN, N2, P, V) 352C 353C *** COMPUTE RMAT AND QTR *** 354C 355 QTR1 = IV(QTR) 356 RMAT1 = IV(RMAT) 357 CALL DQ7RAD(NN, ND, P, V(QTR1), .TRUE., V(RMAT1), DR, R) 358 IV(NF1) = 0 359C 360 190 IF (N2 .LT. N) GO TO 270 361 IF (IVMODE .GT. 0) GO TO 40 362 IV(NF00) = IV(NFGCAL) 363C 364C *** COMPUTE G FROM RMAT AND QTR *** 365C 366 CALL DL7VML(P, V(G1), V(RMAT1), V(QTR1)) 367 IV(1) = 2 368 IF (IVMODE .EQ. 0) GO TO 40 369 IF (N .LE. ND) GO TO 40 370C 371C *** FINISH SPECIAL CASE HANDLING OF FIRST FUNCTION AND GRADIENT 372C 373 Y1 = IV(Y) 374 IV(1) = 1 375 CALL DG7LIT(D, V(G1), IV, LIV, LV, P, P, V, X, V(Y1)) 376 IF (IV(1) .NE. 2) GO TO 220 377 GO TO 40 378C 379C *** MISC. DETAILS *** 380C 381C *** X IS OUT OF RANGE (OVERSIZE STEP) *** 382C 383 200 IV(TOOBIG) = 1 384 GO TO 40 385C 386C *** BAD N, ND, OR P *** 387C 388 210 IV(1) = 66 389 GO TO 290 390C 391C *** CONVERGENCE OBTAINED -- SEE WHETHER TO COMPUTE COVARIANCE *** 392C 393 220 IF (IV(COVMAT) .NE. 0) GO TO 290 394 IF (IV(REGD) .NE. 0) GO TO 290 395C 396C *** SEE IF CHOLESKY FACTOR OF HESSIAN IS AVAILABLE *** 397C 398 K = IV(FDH) 399 IF (K .LE. 0) GO TO 280 400 IF (IV(RDREQ) .LE. 0) GO TO 290 401C 402C *** COMPUTE REGRESSION DIAGNOSTICS AND DEFAULT COVARIANCE IF 403C DESIRED *** 404C 405 I = 0 406 IF (MOD(IV(RDREQ),4) .GE. 2) I = 1 407 IF (MOD(IV(RDREQ),2) .EQ. 1 .AND. IABS(IV(COVREQ)) .LE. 1) I = I+2 408 IF (I .EQ. 0) GO TO 250 409 IV(MODE) = P + I 410 IV(NGCALL) = IV(NGCALL) + 1 411 IV(NGCOV) = IV(NGCOV) + 1 412 IV(CNVCOD) = IV(1) 413 IF (I .LT. 2) GO TO 230 414 L = IABS(IV(H)) 415 CALL DV7SCP(LH, V(L), ZERO) 416 230 IV(NFCOV) = IV(NFCOV) + 1 417 IV(NFCALL) = IV(NFCALL) + 1 418 IV(NFGCAL) = IV(NFCALL) 419 IV(1) = -1 420 GO TO 260 421C 422 240 L = IV(LMAT) 423 CALL DN2LRD(DR, IV, V(L), LH, LIV, LV, ND, NN, P, R, RD, V) 424 IF (N2 .LT. N) GO TO 270 425 IF (N1 .GT. 1) GO TO 250 426C 427C *** ENSURE WE CAN RESTART -- AND MAKE RETURN STATE OF DR 428C *** INDEPENDENT OF WHETHER REGRESSION DIAGNOSTICS ARE COMPUTED. 429C *** USE STEP VECTOR (ALLOCATED BY DG7LIT) FOR SCRATCH. 430C 431 RMAT1 = IV(RMAT) 432 CALL DV7SCP(LH, V(RMAT1), ZERO) 433 CALL DQ7RAD(NN, ND, P, R, .FALSE., V(RMAT1), DR, R) 434 IV(NF1) = 0 435C 436C *** FINISH COMPUTING COVARIANCE *** 437C 438 250 L = IV(LMAT) 439 CALL DC7VFN(IV, V(L), LH, LIV, LV, N, P, V) 440 GO TO 290 441C 442C *** RETURN FOR MORE FUNCTION OR GRADIENT INFORMATION *** 443C 444 260 N2 = 0 445 270 N1 = N2 + 1 446 N2 = N2 + ND 447 IF (N2 .GT. N) N2 = N 448 GO TO 999 449C 450C *** COME HERE FOR INDEFINITE FINITE-DIFFERENCE HESSIAN *** 451C 452 280 IV(COVMAT) = K 453 IV(REGD) = K 454C 455C *** PRINT SUMMARY OF FINAL ITERATION AND OTHER REQUESTED ITEMS *** 456C 457 290 G1 = IV(G) 458 300 CALL DITSUM(D, V(G1), IV, LIV, LV, P, V, X) 459 IF (IV(1) .LE. 6 .AND. IV(RDREQ) .GT. 0) 460 1 CALL DN2CVP(IV, LIV, LV, P, V) 461C 462 999 RETURN 463C *** LAST LINE OF DRN2G FOLLOWS *** 464 END 465 SUBROUTINE DL7SQR(N, A, L) 466C 467C *** COMPUTE A = LOWER TRIANGLE OF L*(L**T), WITH BOTH 468C *** L AND A STORED COMPACTLY BY ROWS. (BOTH MAY OCCUPY THE 469C *** SAME STORAGE. 470C 471C *** PARAMETERS *** 472C 473 INTEGER N 474 DOUBLE PRECISION A(*), L(*) 475C DIMENSION A(N*(N+1)/2), L(N*(N+1)/2) 476C 477C *** LOCAL VARIABLES *** 478C 479 INTEGER I, II, IJ, IK, IP1, I0, J, JJ, JK, J0, K, NP1 480 DOUBLE PRECISION T 481C 482 NP1 = N + 1 483 I0 = N*(N+1)/2 484 DO 30 II = 1, N 485 I = NP1 - II 486 IP1 = I + 1 487 I0 = I0 - I 488 J0 = I*(I+1)/2 489 DO 20 JJ = 1, I 490 J = IP1 - JJ 491 J0 = J0 - J 492 T = 0.0D0 493 DO 10 K = 1, J 494 IK = I0 + K 495 JK = J0 + K 496 T = T + L(IK)*L(JK) 497 10 CONTINUE 498 IJ = I0 + J 499 A(IJ) = T 500 20 CONTINUE 501 30 CONTINUE 502 RETURN 503 END 504 SUBROUTINE DRMNHB(B, D, FX, G, H, IV, LH, LIV, LV, N, V, X) 505C 506C *** CARRY OUT DMNHB (SIMPLY BOUNDED MINIMIZATION) ITERATIONS, 507C *** USING HESSIAN MATRIX PROVIDED BY THE CALLER. 508C 509C *** PARAMETER DECLARATIONS *** 510C 511 INTEGER LH, LIV, LV, N 512 INTEGER IV(LIV) 513 DOUBLE PRECISION B(2,N), D(N), FX, G(N), H(LH), V(LV), X(N) 514C 515C-------------------------- PARAMETER USAGE -------------------------- 516C 517C D.... SCALE VECTOR. 518C FX... FUNCTION VALUE. 519C G.... GRADIENT VECTOR. 520C H.... LOWER TRIANGLE OF THE HESSIAN, STORED ROWWISE. 521C IV... INTEGER VALUE ARRAY. 522C LH... LENGTH OF H = P*(P+1)/2. 523C LIV.. LENGTH OF IV (AT LEAST 59 + 3*N). 524C LV... LENGTH OF V (AT LEAST 78 + N*(N+27)/2). 525C N.... NUMBER OF VARIABLES (COMPONENTS IN X AND G). 526C V.... FLOATING-POINT VALUE ARRAY. 527C X.... PARAMETER VECTOR. 528C 529C *** DISCUSSION *** 530C 531C PARAMETERS IV, N, V, AND X ARE THE SAME AS THE CORRESPONDING 532C ONES TO DMNHB (WHICH SEE), EXCEPT THAT V CAN BE SHORTER (SINCE 533C THE PART OF V THAT DMNHB USES FOR STORING G AND H IS NOT NEEDED). 534C MOREOVER, COMPARED WITH DMNHB, IV(1) MAY HAVE THE TWO ADDITIONAL 535C OUTPUT VALUES 1 AND 2, WHICH ARE EXPLAINED BELOW, AS IS THE USE 536C OF IV(TOOBIG) AND IV(NFGCAL). THE VALUE IV(G), WHICH IS AN 537C OUTPUT VALUE FROM DMNHB, IS NOT REFERENCED BY DRMNHB OR THE 538C SUBROUTINES IT CALLS. 539C 540C IV(1) = 1 MEANS THE CALLER SHOULD SET FX TO F(X), THE FUNCTION VALUE 541C AT X, AND CALL DRMNHB AGAIN, HAVING CHANGED NONE OF THE 542C OTHER PARAMETERS. AN EXCEPTION OCCURS IF F(X) CANNOT BE 543C COMPUTED (E.G. IF OVERFLOW WOULD OCCUR), WHICH MAY HAPPEN 544C BECAUSE OF AN OVERSIZED STEP. IN THIS CASE THE CALLER 545C SHOULD SET IV(TOOBIG) = IV(2) TO 1, WHICH WILL CAUSE 546C DRMNHB TO IGNORE FX AND TRY A SMALLER STEP. THE PARA- 547C METER NF THAT DMNH PASSES TO CALCF (FOR POSSIBLE USE BY 548C CALCGH) IS A COPY OF IV(NFCALL) = IV(6). 549C IV(1) = 2 MEANS THE CALLER SHOULD SET G TO G(X), THE GRADIENT OF F AT 550C X, AND H TO THE LOWER TRIANGLE OF H(X), THE HESSIAN OF F 551C AT X, AND CALL DRMNHB AGAIN, HAVING CHANGED NONE OF THE 552C OTHER PARAMETERS EXCEPT PERHAPS THE SCALE VECTOR D. 553C THE PARAMETER NF THAT DMNHB PASSES TO CALCG IS 554C IV(NFGCAL) = IV(7). IF G(X) AND H(X) CANNOT BE EVALUATED, 555C THEN THE CALLER MAY SET IV(NFGCAL) TO 0, IN WHICH CASE 556C DRMNHB WILL RETURN WITH IV(1) = 65. 557C NOTE -- DRMNHB OVERWRITES H WITH THE LOWER TRIANGLE 558C OF DIAG(D)**-1 * H(X) * DIAG(D)**-1. 559C. 560C *** GENERAL *** 561C 562C CODED BY DAVID M. GAY (WINTER, SPRING 1983). 563C 564C (SEE DMNG AND DMNH FOR REFERENCES.) 565C 566C+++++++++++++++++++++++++++ DECLARATIONS ++++++++++++++++++++++++++++ 567C 568C *** LOCAL VARIABLES *** 569C 570 INTEGER DG1, I, IPI, IPIV2, IPN, J, K, L, LSTGST, NN1O2, 571 1 RSTRST, STEP0, STEP1, TD1, TEMP0, TEMP1, TG1, W1, X01, X11 572 DOUBLE PRECISION GI, T, XI 573C 574C *** CONSTANTS *** 575C 576 DOUBLE PRECISION NEGONE, ONE, ONEP2, ZERO 577C 578C *** NO INTRINSIC FUNCTIONS *** 579C 580C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 581C 582 LOGICAL STOPX 583 DOUBLE PRECISION DD7TPR, DRLDST, DV2NRM 584 EXTERNAL DA7SST,DIVSET, DD7TPR,DD7DUP, DG7QSB, I7PNVR,DITSUM, 585 1 DPARCK, DRLDST, DS7IPR, DS7LVM, STOPX, DV2NRM,DV2AXY, 586 2 DV7CPY, DV7IPR, DV7SCP, DV7VMP 587C 588C DA7SST.... ASSESSES CANDIDATE STEP. 589C DIVSET.... PROVIDES DEFAULT IV AND V INPUT VALUES. 590C DD7TPR... RETURNS INNER PRODUCT OF TWO VECTORS. 591C DD7DUP.... UPDATES SCALE VECTOR D. 592C DG7QSB... COMPUTES APPROXIMATE OPTIMAL BOUNDED STEP. 593C I7PNVR... INVERTS PERMUTATION ARRAY. 594C DITSUM.... PRINTS ITERATION SUMMARY AND INFO ON INITIAL AND FINAL X. 595C DPARCK.... CHECKS VALIDITY OF INPUT IV AND V VALUES. 596C DRLDST... COMPUTES V(RELDX) = RELATIVE STEP SIZE. 597C DS7IPR... APPLIES PERMUTATION TO LOWER TRIANG. OF SYM. MATRIX. 598C DS7LVM... MULTIPLIES SYMMETRIC MATRIX TIMES VECTOR, GIVEN THE LOWER 599C TRIANGLE OF THE MATRIX. 600C STOPX.... RETURNS .TRUE. IF THE BREAK KEY HAS BEEN PRESSED. 601C DV2NRM... RETURNS THE 2-NORM OF A VECTOR. 602C DV2AXY.... COMPUTES SCALAR TIMES ONE VECTOR PLUS ANOTHER. 603C DV7CPY.... COPIES ONE VECTOR TO ANOTHER. 604C DV7IPR... APPLIES PERMUTATION TO VECTOR. 605C DV7SCP... SETS ALL ELEMENTS OF A VECTOR TO A SCALAR. 606C DV7VMP... MULTIPLIES (OR DIVIDES) TWO VECTORS COMPONENTWISE. 607C 608C *** SUBSCRIPTS FOR IV AND V *** 609C 610 INTEGER CNVCOD, DG, DGNORM, DINIT, DSTNRM, DTINIT, DTOL, DTYPE, 611 1 D0INIT, F, F0, FDIF, GTSTEP, INCFAC, IVNEED, IRC, KAGQT, 612 2 LMAT, LMAX0, LMAXS, MODE, MODEL, MXFCAL, MXITER, N0, NC, 613 3 NEXTIV, NEXTV, NFCALL, NFGCAL, NGCALL, NITER, PERM, 614 4 PHMXFC, PREDUC, RADFAC, RADINC, RADIUS, RAD0, RELDX, 615 5 RESTOR, STEP, STGLIM, STPPAR, TOOBIG, TUNER4, TUNER5, 616 6 VNEED, W, XIRC, X0 617C 618C *** IV SUBSCRIPT VALUES *** 619C 620C *** (NOTE THAT NC AND N0 ARE STORED IN IV(G0) AND IV(STLSTG) RESP.) 621C 622 PARAMETER (CNVCOD=55, DG=37, DTOL=59, DTYPE=16, IRC=29, IVNEED=3, 623 1 KAGQT=33, LMAT=42, MODE=35, MODEL=5, MXFCAL=17, 624 2 MXITER=18, N0=41, NC=48, NEXTIV=46, NEXTV=47, NFCALL=6, 625 3 NFGCAL=7, NGCALL=30, NITER=31, PERM=58, RADINC=8, 626 4 RESTOR=9, STEP=40, STGLIM=11, TOOBIG=2, VNEED=4, W=34, 627 5 XIRC=13, X0=43) 628C 629C *** V SUBSCRIPT VALUES *** 630C 631 PARAMETER (DGNORM=1, DINIT=38, DSTNRM=2, DTINIT=39, D0INIT=40, 632 1 F=10, F0=13, FDIF=11, GTSTEP=4, INCFAC=23, LMAX0=35, 633 2 LMAXS=36, PHMXFC=21, PREDUC=7, RADFAC=16, RADIUS=8, 634 3 RAD0=9, RELDX=17, STPPAR=5, TUNER4=29, TUNER5=30) 635C 636 PARAMETER (NEGONE=-1.D+0, ONE=1.D+0, ONEP2=1.2D+0, ZERO=0.D+0) 637C 638C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 639C 640 I = IV(1) 641 IF (I .EQ. 1) GO TO 50 642 IF (I .EQ. 2) GO TO 60 643C 644C *** CHECK VALIDITY OF IV AND V INPUT VALUES *** 645C 646 IF (IV(1) .EQ. 0) CALL DIVSET(2, IV, LIV, LV, V) 647 IF (IV(1) .LT. 12) GO TO 10 648 IF (IV(1) .GT. 13) GO TO 10 649 IV(VNEED) = IV(VNEED) + N*(N+27)/2 + 7 650 IV(IVNEED) = IV(IVNEED) + 3*N 651 10 CALL DPARCK(2, D, IV, LIV, LV, N, V) 652 I = IV(1) - 2 653 IF (I .GT. 12) GO TO 999 654 NN1O2 = N * (N + 1) / 2 655 IF (LH .GE. NN1O2) THEN 656c GO TO (250,250,250,250,250,250,190,150,190, 20,20,30), I 657 select case(I) 658 case(1:6) 659 goto 250 660 case(7,9) 661 goto 190 662 case(8) 663 goto 150 664 case(10,11) 665 goto 20 666 case(12) 667 goto 30 668 end select 669 END IF 670 IV(1) = 81 671 GO TO 440 672C 673C *** STORAGE ALLOCATION *** 674C 675 20 IV(DTOL) = IV(LMAT) + NN1O2 676 IV(X0) = IV(DTOL) + 2*N 677 IV(STEP) = IV(X0) + 2*N 678 IV(DG) = IV(STEP) + 3*N 679 IV(W) = IV(DG) + 2*N 680 IV(NEXTV) = IV(W) + 4*N + 7 681 IV(NEXTIV) = IV(PERM) + 3*N 682 IF (IV(1) .NE. 13) GO TO 30 683 IV(1) = 14 684 GO TO 999 685C 686C *** INITIALIZATION *** 687C 688 30 IV(NITER) = 0 689 IV(NFCALL) = 1 690 IV(NGCALL) = 1 691 IV(NFGCAL) = 1 692 IV(MODE) = -1 693 IV(MODEL) = 1 694 IV(STGLIM) = 1 695 IV(TOOBIG) = 0 696 IV(CNVCOD) = 0 697 IV(RADINC) = 0 698 IV(NC) = N 699 V(RAD0) = ZERO 700 V(STPPAR) = ZERO 701 IF (V(DINIT) .GE. ZERO) CALL DV7SCP(N, D, V(DINIT)) 702 K = IV(DTOL) 703 IF (V(DTINIT) .GT. ZERO) CALL DV7SCP(N, V(K), V(DTINIT)) 704 K = K + N 705 IF (V(D0INIT) .GT. ZERO) CALL DV7SCP(N, V(K), V(D0INIT)) 706C 707C *** CHECK CONSISTENCY OF B AND INITIALIZE IP ARRAY *** 708C 709 IPI = IV(PERM) 710 DO 40 I = 1, N 711 IV(IPI) = I 712 IPI = IPI + 1 713 IF (B(1,I) .GT. B(2,I)) GO TO 420 714 40 CONTINUE 715C 716C *** GET INITIAL FUNCTION VALUE *** 717C 718 IV(1) = 1 719 GO TO 450 720C 721 50 V(F) = FX 722 IF (IV(MODE) .GE. 0) GO TO 250 723 V(F0) = FX 724 IV(1) = 2 725 IF (IV(TOOBIG) .EQ. 0) GO TO 999 726 IV(1) = 63 727 GO TO 440 728C 729C *** MAKE SURE GRADIENT COULD BE COMPUTED *** 730C 731 60 IF (IV(TOOBIG) .EQ. 0) GO TO 70 732 IV(1) = 65 733 GO TO 440 734C 735C *** UPDATE THE SCALE VECTOR D *** 736C 737 70 DG1 = IV(DG) 738 IF (IV(DTYPE) .LE. 0) GO TO 90 739 K = DG1 740 J = 0 741 DO 80 I = 1, N 742 J = J + I 743 V(K) = H(J) 744 K = K + 1 745 80 CONTINUE 746 CALL DD7DUP(D, V(DG1), IV, LIV, LV, N, V) 747C 748C *** COMPUTE SCALED GRADIENT AND ITS NORM *** 749C 750 90 DG1 = IV(DG) 751 CALL DV7VMP(N, V(DG1), G, D, -1) 752C 753C *** COMPUTE SCALED HESSIAN *** 754C 755 K = 1 756 DO 110 I = 1, N 757 T = ONE / D(I) 758 DO 100 J = 1, I 759 H(K) = T * H(K) / D(J) 760 K = K + 1 761 100 CONTINUE 762 110 CONTINUE 763C 764C *** CHOOSE INITIAL PERMUTATION *** 765C 766 IPI = IV(PERM) 767 IPN = IPI + N 768 IPIV2 = IPN - 1 769C *** INVERT OLD PERMUTATION ARRAY *** 770 CALL I7PNVR(N, IV(IPN), IV(IPI)) 771 K = IV(NC) 772 DO 130 I = 1, N 773 IF (B(1,I) .GE. B(2,I)) GO TO 120 774 XI = X(I) 775 GI = G(I) 776 IF (XI .LE. B(1,I) .AND. GI .GT. ZERO) GO TO 120 777 IF (XI .GE. B(2,I) .AND. GI .LT. ZERO) GO TO 120 778 IV(IPI) = I 779 IPI = IPI + 1 780 J = IPIV2 + I 781C *** DISALLOW CONVERGENCE IF X(I) HAS JUST BEEN FREED *** 782 IF (IV(J) .GT. K) IV(CNVCOD) = 0 783 GO TO 130 784 120 IPN = IPN - 1 785 IV(IPN) = I 786 130 CONTINUE 787 IV(NC) = IPN - IV(PERM) 788C 789C *** PERMUTE SCALED GRADIENT AND HESSIAN ACCORDINGLY *** 790C 791 IPI = IV(PERM) 792 CALL DS7IPR(N, IV(IPI), H) 793 CALL DV7IPR(N, IV(IPI), V(DG1)) 794 V(DGNORM) = ZERO 795 IF (IV(NC) .GT. 0) V(DGNORM) = DV2NRM(IV(NC), V(DG1)) 796C 797 IF (IV(CNVCOD) .NE. 0) GO TO 430 798 IF (IV(MODE) .EQ. 0) GO TO 380 799C 800C *** ALLOW FIRST STEP TO HAVE SCALED 2-NORM AT MOST V(LMAX0) *** 801C 802 V(RADIUS) = V(LMAX0) / (ONE + V(PHMXFC)) 803C 804 IV(MODE) = 0 805C 806C 807C----------------------------- MAIN LOOP ----------------------------- 808C 809C 810C *** PRINT ITERATION SUMMARY, CHECK ITERATION LIMIT *** 811C 812 140 CALL DITSUM(D, G, IV, LIV, LV, N, V, X) 813 150 K = IV(NITER) 814 IF (K .LT. IV(MXITER)) GO TO 160 815 IV(1) = 10 816 GO TO 440 817C 818 160 IV(NITER) = K + 1 819C 820C *** INITIALIZE FOR START OF NEXT ITERATION *** 821C 822 X01 = IV(X0) 823 V(F0) = V(F) 824 IV(IRC) = 4 825 IV(KAGQT) = -1 826C 827C *** COPY X TO X0 *** 828C 829 CALL DV7CPY(N, V(X01), X) 830C 831C *** UPDATE RADIUS *** 832C 833 IF (K .EQ. 0) GO TO 180 834 STEP1 = IV(STEP) 835 K = STEP1 836 DO 170 I = 1, N 837 V(K) = D(I) * V(K) 838 K = K + 1 839 170 CONTINUE 840 T = V(RADFAC) * DV2NRM(N, V(STEP1)) 841 IF (V(RADFAC) .LT. ONE .OR. T .GT. V(RADIUS)) V(RADIUS) = T 842C 843C *** CHECK STOPX AND FUNCTION EVALUATION LIMIT *** 844C 845 180 IF (.NOT. STOPX()) GO TO 200 846 IV(1) = 11 847 GO TO 210 848C 849C *** COME HERE WHEN RESTARTING AFTER FUNC. EVAL. LIMIT OR STOPX. 850C 851 190 IF (V(F) .GE. V(F0)) GO TO 200 852 V(RADFAC) = ONE 853 K = IV(NITER) 854 GO TO 160 855C 856 200 IF (IV(NFCALL) .LT. IV(MXFCAL)) GO TO 220 857 IV(1) = 9 858 210 IF (V(F) .GE. V(F0)) GO TO 440 859C 860C *** IN CASE OF STOPX OR FUNCTION EVALUATION LIMIT WITH 861C *** IMPROVED V(F), EVALUATE THE GRADIENT AT X. 862C 863 IV(CNVCOD) = IV(1) 864 GO TO 370 865C 866C. . . . . . . . . . . . . COMPUTE CANDIDATE STEP . . . . . . . . . . 867C 868 220 STEP1 = IV(STEP) 869 L = IV(LMAT) 870 W1 = IV(W) 871 IPI = IV(PERM) 872 IPN = IPI + N 873 IPIV2 = IPN + N 874 TG1 = IV(DG) 875 TD1 = TG1 + N 876 X01 = IV(X0) 877 X11 = X01 + N 878 CALL DG7QSB(B, D, H, G, IV(IPI), IV(IPN), IV(IPIV2), IV(KAGQT), 879 1 V(L), LV, N, IV(N0), IV(NC), V(STEP1), V(TD1), V(TG1), 880 2 V, V(W1), V(X11), V(X01)) 881 IF (IV(IRC) .NE. 6) GO TO 230 882 IF (IV(RESTOR) .NE. 2) GO TO 250 883 RSTRST = 2 884 GO TO 260 885C 886C *** CHECK WHETHER EVALUATING F(X0 + STEP) LOOKS WORTHWHILE *** 887C 888 230 IV(TOOBIG) = 0 889 IF (V(DSTNRM) .LE. ZERO) GO TO 250 890 IF (IV(IRC) .NE. 5) GO TO 240 891 IF (V(RADFAC) .LE. ONE) GO TO 240 892 IF (V(PREDUC) .GT. ONEP2 * V(FDIF)) GO TO 240 893 IF (IV(RESTOR) .NE. 2) GO TO 250 894 RSTRST = 0 895 GO TO 260 896C 897C *** COMPUTE F(X0 + STEP) *** 898C 899 240 CALL DV2AXY(N, X, ONE, V(STEP1), V(X01)) 900 IV(NFCALL) = IV(NFCALL) + 1 901 IV(1) = 1 902 GO TO 450 903C 904C. . . . . . . . . . . . . ASSESS CANDIDATE STEP . . . . . . . . . . . 905C 906 250 RSTRST = 3 907 260 X01 = IV(X0) 908 V(RELDX) = DRLDST(N, D, X, V(X01)) 909 CALL DA7SST(IV, LIV, LV, V) 910 STEP1 = IV(STEP) 911 LSTGST = STEP1 + 2*N 912 I = IV(RESTOR) + 1 913c GO TO (300, 270, 280, 290), I 914 select case(I) 915 case(1) 916 goto 300 917 case(2) 918 goto 270 919 case(3) 920 goto 280 921 case(4) 922 goto 290 923 end select 924 270 CALL DV7CPY(N, X, V(X01)) 925 GO TO 300 926 280 CALL DV7CPY(N, V(LSTGST), X) 927 GO TO 300 928 290 CALL DV7CPY(N, X, V(LSTGST)) 929 CALL DV2AXY(N, V(STEP1), NEGONE, V(X01), X) 930 V(RELDX) = DRLDST(N, D, X, V(X01)) 931 IV(RESTOR) = RSTRST 932C 933 300 K = IV(IRC) 934c GO TO (310,340,340,340,310,320,330,330,330,330,330,330,410,380), K 935 select case(K) 936 case(1) 937 goto 310 938 case(2:4) 939 goto 340 940 case(5) 941 goto 310 942 case(6) 943 goto 320 944 case(7:12) 945 goto 330 946 case(13) 947 goto 410 948 case(14) 949 goto 380 950 end select 951C 952C *** RECOMPUTE STEP WITH NEW RADIUS *** 953C 954 310 V(RADIUS) = V(RADFAC) * V(DSTNRM) 955 GO TO 180 956C 957C *** COMPUTE STEP OF LENGTH V(LMAXS) FOR SINGULAR CONVERGENCE TEST. 958C 959 320 V(RADIUS) = V(LMAXS) 960 GO TO 220 961C 962C *** CONVERGENCE OR FALSE CONVERGENCE *** 963C 964 330 IV(CNVCOD) = K - 4 965 IF (V(F) .GE. V(F0)) GO TO 430 966 IF (IV(XIRC) .EQ. 14) GO TO 430 967 IV(XIRC) = 14 968C 969C. . . . . . . . . . . . PROCESS ACCEPTABLE STEP . . . . . . . . . . . 970C 971 340 IF (IV(IRC) .NE. 3) GO TO 370 972 TEMP1 = LSTGST 973C 974C *** PREPARE FOR GRADIENT TESTS *** 975C *** SET TEMP1 = HESSIAN * STEP + G(X0) 976C *** = DIAG(D) * (H * STEP + G(X0)) 977C 978 K = TEMP1 979 STEP0 = STEP1 - 1 980 IPI = IV(PERM) 981 DO 350 I = 1, N 982 J = IV(IPI) 983 IPI = IPI + 1 984 STEP1 = STEP0 + J 985 V(K) = D(J) * V(STEP1) 986 K = K + 1 987 350 CONTINUE 988C USE X0 VECTOR AS TEMPORARY. 989 CALL DS7LVM(N, V(X01), H, V(TEMP1)) 990 TEMP0 = TEMP1 - 1 991 IPI = IV(PERM) 992 DO 360 I = 1, N 993 J = IV(IPI) 994 IPI = IPI + 1 995 TEMP1 = TEMP0 + J 996 V(TEMP1) = D(J) * V(X01) + G(J) 997 X01 = X01 + 1 998 360 CONTINUE 999C 1000C *** COMPUTE GRADIENT AND HESSIAN *** 1001C 1002 370 IV(NGCALL) = IV(NGCALL) + 1 1003 IV(TOOBIG) = 0 1004 IV(1) = 2 1005 GO TO 450 1006C 1007 380 IV(1) = 2 1008 IF (IV(IRC) .NE. 3) GO TO 140 1009C 1010C *** SET V(RADFAC) BY GRADIENT TESTS *** 1011C 1012 STEP1 = IV(STEP) 1013C *** TEMP1 = STLSTG *** 1014 TEMP1 = STEP1 + 2*N 1015C 1016C *** SET TEMP1 = DIAG(D)**-1 * (HESSIAN*STEP + (G(X0)-G(X))) *** 1017C 1018 K = TEMP1 1019 DO 390 I = 1, N 1020 V(K) = (V(K) - G(I)) / D(I) 1021 K = K + 1 1022 390 CONTINUE 1023C 1024C *** DO GRADIENT TESTS *** 1025C 1026 IF (DV2NRM(N, V(TEMP1)) .LE. V(DGNORM) * V(TUNER4)) GO TO 400 1027 IF (DD7TPR(N, G, V(STEP1)) 1028 1 .GE. V(GTSTEP) * V(TUNER5)) GO TO 140 1029 400 V(RADFAC) = V(INCFAC) 1030 GO TO 140 1031C 1032C. . . . . . . . . . . . . . MISC. DETAILS . . . . . . . . . . . . . . 1033C 1034C *** BAD PARAMETERS TO ASSESS *** 1035C 1036 410 IV(1) = 64 1037 GO TO 440 1038C 1039C *** INCONSISTENT B *** 1040C 1041 420 IV(1) = 82 1042 GO TO 440 1043C 1044C *** PRINT SUMMARY OF FINAL ITERATION AND OTHER REQUESTED ITEMS *** 1045C 1046 430 IV(1) = IV(CNVCOD) 1047 IV(CNVCOD) = 0 1048 440 CALL DITSUM(D, G, IV, LIV, LV, N, V, X) 1049 GO TO 999 1050C 1051C *** PROJECT X INTO FEASIBLE REGION (PRIOR TO COMPUTING F OR G) *** 1052C 1053 450 DO 460 I = 1, N 1054 IF (X(I) .LT. B(1,I)) X(I) = B(1,I) 1055 IF (X(I) .GT. B(2,I)) X(I) = B(2,I) 1056 460 CONTINUE 1057C 1058 999 RETURN 1059C 1060C *** LAST CARD OF DRMNHB FOLLOWS *** 1061 END 1062 SUBROUTINE DRMNH(D, FX, G, H, IV, LH, LIV, LV, N, V, X) 1063C 1064C *** CARRY OUT DMNH (UNCONSTRAINED MINIMIZATION) ITERATIONS, USING 1065C *** HESSIAN MATRIX PROVIDED BY THE CALLER. 1066C 1067C *** PARAMETER DECLARATIONS *** 1068C 1069 INTEGER LH, LIV, LV, N 1070 INTEGER IV(LIV) 1071 DOUBLE PRECISION D(N), FX, G(N), H(LH), V(LV), X(N) 1072C 1073C-------------------------- PARAMETER USAGE -------------------------- 1074C 1075C D.... SCALE VECTOR. 1076C FX... FUNCTION VALUE. 1077C G.... GRADIENT VECTOR. 1078C H.... LOWER TRIANGLE OF THE HESSIAN, STORED ROWWISE. 1079C IV... INTEGER VALUE ARRAY. 1080C LH... LENGTH OF H = P*(P+1)/2. 1081C LIV.. LENGTH OF IV (AT LEAST 60). 1082C LV... LENGTH OF V (AT LEAST 78 + N*(N+21)/2). 1083C N.... NUMBER OF VARIABLES (COMPONENTS IN X AND G). 1084C V.... FLOATING-POINT VALUE ARRAY. 1085C X.... PARAMETER VECTOR. 1086C 1087C *** DISCUSSION *** 1088C 1089C PARAMETERS IV, N, V, AND X ARE THE SAME AS THE CORRESPONDING 1090C ONES TO DMNH (WHICH SEE), EXCEPT THAT V CAN BE SHORTER (SINCE 1091C THE PART OF V THAT DMNH USES FOR STORING G AND H IS NOT NEEDED). 1092C MOREOVER, COMPARED WITH DMNH, IV(1) MAY HAVE THE TWO ADDITIONAL 1093C OUTPUT VALUES 1 AND 2, WHICH ARE EXPLAINED BELOW, AS IS THE USE 1094C OF IV(TOOBIG) AND IV(NFGCAL). THE VALUE IV(G), WHICH IS AN 1095C OUTPUT VALUE FROM DMNH, IS NOT REFERENCED BY DRMNH OR THE 1096C SUBROUTINES IT CALLS. 1097C 1098C IV(1) = 1 MEANS THE CALLER SHOULD SET FX TO F(X), THE FUNCTION VALUE 1099C AT X, AND CALL DRMNH AGAIN, HAVING CHANGED NONE OF THE 1100C OTHER PARAMETERS. AN EXCEPTION OCCURS IF F(X) CANNOT BE 1101C COMPUTED (E.G. IF OVERFLOW WOULD OCCUR), WHICH MAY HAPPEN 1102C BECAUSE OF AN OVERSIZED STEP. IN THIS CASE THE CALLER 1103C SHOULD SET IV(TOOBIG) = IV(2) TO 1, WHICH WILL CAUSE 1104C DRMNH TO IGNORE FX AND TRY A SMALLER STEP. THE PARA- 1105C METER NF THAT DMNH PASSES TO CALCF (FOR POSSIBLE USE BY 1106C CALCGH) IS A COPY OF IV(NFCALL) = IV(6). 1107C IV(1) = 2 MEANS THE CALLER SHOULD SET G TO G(X), THE GRADIENT OF F AT 1108C X, AND H TO THE LOWER TRIANGLE OF H(X), THE HESSIAN OF F 1109C AT X, AND CALL DRMNH AGAIN, HAVING CHANGED NONE OF THE 1110C OTHER PARAMETERS EXCEPT PERHAPS THE SCALE VECTOR D. 1111C THE PARAMETER NF THAT DMNH PASSES TO CALCG IS 1112C IV(NFGCAL) = IV(7). IF G(X) AND H(X) CANNOT BE EVALUATED, 1113C THEN THE CALLER MAY SET IV(TOOBIG) TO 0, IN WHICH CASE 1114C DRMNH WILL RETURN WITH IV(1) = 65. 1115C NOTE -- DRMNH OVERWRITES H WITH THE LOWER TRIANGLE 1116C OF DIAG(D)**-1 * H(X) * DIAG(D)**-1. 1117C. 1118C *** GENERAL *** 1119C 1120C CODED BY DAVID M. GAY (WINTER 1980). REVISED SEPT. 1982. 1121C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH SUPPORTED 1122C IN PART BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS 1123C MCS-7600324 AND MCS-7906671. 1124C 1125C (SEE DMNG AND DMNH FOR REFERENCES.) 1126C 1127C+++++++++++++++++++++++++++ DECLARATIONS ++++++++++++++++++++++++++++ 1128C 1129C *** LOCAL VARIABLES *** 1130C 1131 INTEGER DG1, I, J, K, L, LSTGST, NN1O2, RSTRST, STEP1, 1132 1 TEMP1, W1, X01 1133 DOUBLE PRECISION T 1134C 1135C *** CONSTANTS *** 1136C 1137 DOUBLE PRECISION ONE, ONEP2, ZERO 1138C 1139C *** NO INTRINSIC FUNCTIONS *** 1140C 1141C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 1142C 1143 LOGICAL STOPX 1144 DOUBLE PRECISION DD7TPR, DRLDST, DV2NRM 1145 EXTERNAL DA7SST,DIVSET, DD7TPR,DD7DUP,DG7QTS,DITSUM,DPARCK, 1146 1 DRLDST, DS7LVM, STOPX,DV2AXY,DV7CPY, DV7SCP, DV2NRM 1147C 1148C DA7SST.... ASSESSES CANDIDATE STEP. 1149C DIVSET.... PROVIDES DEFAULT IV AND V INPUT VALUES. 1150C DD7TPR... RETURNS INNER PRODUCT OF TWO VECTORS. 1151C DD7DUP.... UPDATES SCALE VECTOR D. 1152C DG7QTS.... COMPUTES OPTIMALLY LOCALLY CONSTRAINED STEP. 1153C DITSUM.... PRINTS ITERATION SUMMARY AND INFO ON INITIAL AND FINAL X. 1154C DPARCK.... CHECKS VALIDITY OF INPUT IV AND V VALUES. 1155C DRLDST... COMPUTES V(RELDX) = RELATIVE STEP SIZE. 1156C DS7LVM... MULTIPLIES SYMMETRIC MATRIX TIMES VECTOR, GIVEN THE LOWER 1157C TRIANGLE OF THE MATRIX. 1158C STOPX.... RETURNS .TRUE. IF THE BREAK KEY HAS BEEN PRESSED. 1159C DV2AXY.... COMPUTES SCALAR TIMES ONE VECTOR PLUS ANOTHER. 1160C DV7CPY.... COPIES ONE VECTOR TO ANOTHER. 1161C DV7SCP... SETS ALL ELEMENTS OF A VECTOR TO A SCALAR. 1162C DV2NRM... RETURNS THE 2-NORM OF A VECTOR. 1163C 1164C *** SUBSCRIPTS FOR IV AND V *** 1165C 1166 INTEGER CNVCOD, DG, DGNORM, DINIT, DSTNRM, DTINIT, DTOL, 1167 1 DTYPE, D0INIT, F, F0, FDIF, GTSTEP, INCFAC, IRC, KAGQT, 1168 2 LMAT, LMAX0, LMAXS, MODE, MODEL, MXFCAL, MXITER, NEXTV, 1169 3 NFCALL, NFGCAL, NGCALL, NITER, PHMXFC, PREDUC, RADFAC, 1170 4 RADINC, RADIUS, RAD0, RELDX, RESTOR, STEP, STGLIM, STLSTG, 1171 5 STPPAR, TOOBIG, TUNER4, TUNER5, VNEED, W, XIRC, X0 1172C 1173C *** IV SUBSCRIPT VALUES *** 1174C 1175 PARAMETER (CNVCOD=55, DG=37, DTOL=59, DTYPE=16, IRC=29, KAGQT=33, 1176 1 LMAT=42, MODE=35, MODEL=5, MXFCAL=17, MXITER=18, 1177 2 NEXTV=47, NFCALL=6, NFGCAL=7, NGCALL=30, NITER=31, 1178 3 RADINC=8, RESTOR=9, STEP=40, STGLIM=11, STLSTG=41, 1179 4 TOOBIG=2, VNEED=4, W=34, XIRC=13, X0=43) 1180C 1181C *** V SUBSCRIPT VALUES *** 1182C 1183 PARAMETER (DGNORM=1, DINIT=38, DSTNRM=2, DTINIT=39, D0INIT=40, 1184 1 F=10, F0=13, FDIF=11, GTSTEP=4, INCFAC=23, LMAX0=35, 1185 2 LMAXS=36, PHMXFC=21, PREDUC=7, RADFAC=16, RADIUS=8, 1186 3 RAD0=9, RELDX=17, STPPAR=5, TUNER4=29, TUNER5=30) 1187C 1188 PARAMETER (ONE=1.D+0, ONEP2=1.2D+0, ZERO=0.D+0) 1189C 1190C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 1191C 1192 I = IV(1) 1193 IF (I .EQ. 1) GO TO 30 1194 IF (I .EQ. 2) GO TO 40 1195C 1196C *** CHECK VALIDITY OF IV AND V INPUT VALUES *** 1197C 1198 IF (IV(1) .EQ. 0) CALL DIVSET(2, IV, LIV, LV, V) 1199 IF (IV(1) .EQ. 12 .OR. IV(1) .EQ. 13) 1200 1 IV(VNEED) = IV(VNEED) + N*(N+21)/2 + 7 1201 CALL DPARCK(2, D, IV, LIV, LV, N, V) 1202 I = IV(1) - 2 1203 IF (I .GT. 12) GO TO 999 1204 NN1O2 = N * (N + 1) / 2 1205 IF (LH .GE. NN1O2) THEN 1206c GO TO (220,220,220,220,220,220,160,120,160, 10,10,20), I 1207 select case(I) 1208 case(1:6) 1209 goto 220 1210 case(7,9) 1211 goto 160 1212 case(8) 1213 goto 120 1214 case(10,11) 1215 goto 10 1216 case(12) 1217 goto 20 1218 end select 1219 END IF 1220 IV(1) = 66 1221 GO TO 400 1222C 1223C *** STORAGE ALLOCATION *** 1224C 1225 10 IV(DTOL) = IV(LMAT) + NN1O2 1226 IV(X0) = IV(DTOL) + 2*N 1227 IV(STEP) = IV(X0) + N 1228 IV(STLSTG) = IV(STEP) + N 1229 IV(DG) = IV(STLSTG) + N 1230 IV(W) = IV(DG) + N 1231 IV(NEXTV) = IV(W) + 4*N + 7 1232 IF (IV(1) .NE. 13) GO TO 20 1233 IV(1) = 14 1234 GO TO 999 1235C 1236C *** INITIALIZATION *** 1237C 1238 20 IV(NITER) = 0 1239 IV(NFCALL) = 1 1240 IV(NGCALL) = 1 1241 IV(NFGCAL) = 1 1242 IV(MODE) = -1 1243 IV(MODEL) = 1 1244 IV(STGLIM) = 1 1245 IV(TOOBIG) = 0 1246 IV(CNVCOD) = 0 1247 IV(RADINC) = 0 1248 V(RAD0) = ZERO 1249 V(STPPAR) = ZERO 1250 IF (V(DINIT) .GE. ZERO) CALL DV7SCP(N, D, V(DINIT)) 1251 K = IV(DTOL) 1252 IF (V(DTINIT) .GT. ZERO) CALL DV7SCP(N, V(K), V(DTINIT)) 1253 K = K + N 1254 IF (V(D0INIT) .GT. ZERO) CALL DV7SCP(N, V(K), V(D0INIT)) 1255 IV(1) = 1 1256 GO TO 999 1257C 1258 30 V(F) = FX 1259 IF (IV(MODE) .GE. 0) GO TO 220 1260 V(F0) = FX 1261 IV(1) = 2 1262 IF (IV(TOOBIG) .EQ. 0) GO TO 999 1263 IV(1) = 63 1264 GO TO 400 1265C 1266C *** MAKE SURE GRADIENT COULD BE COMPUTED *** 1267C 1268 40 IF (IV(TOOBIG) .EQ. 0) GO TO 50 1269 IV(1) = 65 1270 GO TO 400 1271C 1272C *** UPDATE THE SCALE VECTOR D *** 1273C 1274 50 DG1 = IV(DG) 1275 IF (IV(DTYPE) .LE. 0) GO TO 70 1276 K = DG1 1277 J = 0 1278 DO 60 I = 1, N 1279 J = J + I 1280 V(K) = H(J) 1281 K = K + 1 1282 60 CONTINUE 1283 CALL DD7DUP(D, V(DG1), IV, LIV, LV, N, V) 1284C 1285C *** COMPUTE SCALED GRADIENT AND ITS NORM *** 1286C 1287 70 DG1 = IV(DG) 1288 K = DG1 1289 DO 80 I = 1, N 1290 V(K) = G(I) / D(I) 1291 K = K + 1 1292 80 CONTINUE 1293 V(DGNORM) = DV2NRM(N, V(DG1)) 1294C 1295C *** COMPUTE SCALED HESSIAN *** 1296C 1297 K = 1 1298 DO 100 I = 1, N 1299 T = ONE / D(I) 1300 DO 90 J = 1, I 1301 H(K) = T * H(K) / D(J) 1302 K = K + 1 1303 90 CONTINUE 1304 100 CONTINUE 1305C 1306 IF (IV(CNVCOD) .NE. 0) GO TO 390 1307 IF (IV(MODE) .EQ. 0) GO TO 350 1308C 1309C *** ALLOW FIRST STEP TO HAVE SCALED 2-NORM AT MOST V(LMAX0) *** 1310C 1311 V(RADIUS) = V(LMAX0) / (ONE + V(PHMXFC)) 1312C 1313 IV(MODE) = 0 1314C 1315C 1316C----------------------------- MAIN LOOP ----------------------------- 1317C 1318C 1319C *** PRINT ITERATION SUMMARY, CHECK ITERATION LIMIT *** 1320C 1321 110 CALL DITSUM(D, G, IV, LIV, LV, N, V, X) 1322 120 K = IV(NITER) 1323 IF (K .LT. IV(MXITER)) GO TO 130 1324 IV(1) = 10 1325 GO TO 400 1326C 1327 130 IV(NITER) = K + 1 1328C 1329C *** INITIALIZE FOR START OF NEXT ITERATION *** 1330C 1331 DG1 = IV(DG) 1332 X01 = IV(X0) 1333 V(F0) = V(F) 1334 IV(IRC) = 4 1335 IV(KAGQT) = -1 1336C 1337C *** COPY X TO X0 *** 1338C 1339 CALL DV7CPY(N, V(X01), X) 1340C 1341C *** UPDATE RADIUS *** 1342C 1343 IF (K .EQ. 0) GO TO 150 1344 STEP1 = IV(STEP) 1345 K = STEP1 1346 DO 140 I = 1, N 1347 V(K) = D(I) * V(K) 1348 K = K + 1 1349 140 CONTINUE 1350 V(RADIUS) = V(RADFAC) * DV2NRM(N, V(STEP1)) 1351C 1352C *** CHECK STOPX AND FUNCTION EVALUATION LIMIT *** 1353C 1354 150 IF (.NOT. STOPX()) GO TO 170 1355 IV(1) = 11 1356 GO TO 180 1357C 1358C *** COME HERE WHEN RESTARTING AFTER FUNC. EVAL. LIMIT OR STOPX. 1359C 1360 160 IF (V(F) .GE. V(F0)) GO TO 170 1361 V(RADFAC) = ONE 1362 K = IV(NITER) 1363 GO TO 130 1364C 1365 170 IF (IV(NFCALL) .LT. IV(MXFCAL)) GO TO 190 1366 IV(1) = 9 1367 180 IF (V(F) .GE. V(F0)) GO TO 400 1368C 1369C *** IN CASE OF STOPX OR FUNCTION EVALUATION LIMIT WITH 1370C *** IMPROVED V(F), EVALUATE THE GRADIENT AT X. 1371C 1372 IV(CNVCOD) = IV(1) 1373 GO TO 340 1374C 1375C. . . . . . . . . . . . . COMPUTE CANDIDATE STEP . . . . . . . . . . 1376C 1377 190 STEP1 = IV(STEP) 1378 DG1 = IV(DG) 1379 L = IV(LMAT) 1380 W1 = IV(W) 1381 CALL DG7QTS(D, V(DG1), H, IV(KAGQT), V(L), N, V(STEP1), V, V(W1)) 1382 IF (IV(IRC) .NE. 6) GO TO 200 1383 IF (IV(RESTOR) .NE. 2) GO TO 220 1384 RSTRST = 2 1385 GO TO 230 1386C 1387C *** CHECK WHETHER EVALUATING F(X0 + STEP) LOOKS WORTHWHILE *** 1388C 1389 200 IV(TOOBIG) = 0 1390 IF (V(DSTNRM) .LE. ZERO) GO TO 220 1391 IF (IV(IRC) .NE. 5) GO TO 210 1392 IF (V(RADFAC) .LE. ONE) GO TO 210 1393 IF (V(PREDUC) .GT. ONEP2 * V(FDIF)) GO TO 210 1394 IF (IV(RESTOR) .NE. 2) GO TO 220 1395 RSTRST = 0 1396 GO TO 230 1397C 1398C *** COMPUTE F(X0 + STEP) *** 1399C 1400 210 X01 = IV(X0) 1401 STEP1 = IV(STEP) 1402 CALL DV2AXY(N, X, ONE, V(STEP1), V(X01)) 1403 IV(NFCALL) = IV(NFCALL) + 1 1404 IV(1) = 1 1405 GO TO 999 1406C 1407C. . . . . . . . . . . . . ASSESS CANDIDATE STEP . . . . . . . . . . . 1408C 1409 220 RSTRST = 3 1410 230 X01 = IV(X0) 1411 V(RELDX) = DRLDST(N, D, X, V(X01)) 1412 CALL DA7SST(IV, LIV, LV, V) 1413 STEP1 = IV(STEP) 1414 LSTGST = IV(STLSTG) 1415 I = IV(RESTOR) + 1 1416c GO TO (270, 240, 250, 260), I 1417 select case(I) 1418 case(1) 1419 goto 270 1420 case(2) 1421 goto 240 1422 case(3) 1423 goto 250 1424 case(4) 1425 goto 260 1426 end select 1427 240 CALL DV7CPY(N, X, V(X01)) 1428 GO TO 270 1429 250 CALL DV7CPY(N, V(LSTGST), V(STEP1)) 1430 GO TO 270 1431 260 CALL DV7CPY(N, V(STEP1), V(LSTGST)) 1432 CALL DV2AXY(N, X, ONE, V(STEP1), V(X01)) 1433 V(RELDX) = DRLDST(N, D, X, V(X01)) 1434 IV(RESTOR) = RSTRST 1435C 1436 270 K = IV(IRC) 1437c GO TO (280,310,310,310,280,290,300,300,300,300,300,300,380,350), K 1438 select case(K) 1439 case(1) 1440 goto 280 1441 case(2:4) 1442 goto 310 1443 case(5) 1444 goto 280 1445 case(6) 1446 goto 290 1447 case(7:12) 1448 goto 300 1449 case(13) 1450 goto 380 1451 case(14) 1452 goto 350 1453 end select 1454C 1455C *** RECOMPUTE STEP WITH NEW RADIUS *** 1456C 1457 280 V(RADIUS) = V(RADFAC) * V(DSTNRM) 1458 GO TO 150 1459C 1460C *** COMPUTE STEP OF LENGTH V(LMAXS) FOR SINGULAR CONVERGENCE TEST. 1461C 1462 290 V(RADIUS) = V(LMAXS) 1463 GO TO 190 1464C 1465C *** CONVERGENCE OR FALSE CONVERGENCE *** 1466C 1467 300 IV(CNVCOD) = K - 4 1468 IF (V(F) .GE. V(F0)) GO TO 390 1469 IF (IV(XIRC) .EQ. 14) GO TO 390 1470 IV(XIRC) = 14 1471C 1472C. . . . . . . . . . . . PROCESS ACCEPTABLE STEP . . . . . . . . . . . 1473C 1474 310 IF (IV(IRC) .NE. 3) GO TO 340 1475 TEMP1 = LSTGST 1476C 1477C *** PREPARE FOR GRADIENT TESTS *** 1478C *** SET TEMP1 = HESSIAN * STEP + G(X0) 1479C *** = DIAG(D) * (H * STEP + G(X0)) 1480C 1481C USE X0 VECTOR AS TEMPORARY. 1482 K = X01 1483 DO 320 I = 1, N 1484 V(K) = D(I) * V(STEP1) 1485 K = K + 1 1486 STEP1 = STEP1 + 1 1487 320 CONTINUE 1488 CALL DS7LVM(N, V(TEMP1), H, V(X01)) 1489 DO 330 I = 1, N 1490 V(TEMP1) = D(I) * V(TEMP1) + G(I) 1491 TEMP1 = TEMP1 + 1 1492 330 CONTINUE 1493C 1494C *** COMPUTE GRADIENT AND HESSIAN *** 1495C 1496 340 IV(NGCALL) = IV(NGCALL) + 1 1497 IV(TOOBIG) = 0 1498 IV(1) = 2 1499 GO TO 999 1500C 1501 350 IV(1) = 2 1502 IF (IV(IRC) .NE. 3) GO TO 110 1503C 1504C *** SET V(RADFAC) BY GRADIENT TESTS *** 1505C 1506 TEMP1 = IV(STLSTG) 1507 STEP1 = IV(STEP) 1508C 1509C *** SET TEMP1 = DIAG(D)**-1 * (HESSIAN*STEP + (G(X0)-G(X))) *** 1510C 1511 K = TEMP1 1512 DO 360 I = 1, N 1513 V(K) = (V(K) - G(I)) / D(I) 1514 K = K + 1 1515 360 CONTINUE 1516C 1517C *** DO GRADIENT TESTS *** 1518C 1519 IF (DV2NRM(N, V(TEMP1)) .LE. V(DGNORM) * V(TUNER4)) GO TO 370 1520 IF (DD7TPR(N, G, V(STEP1)) 1521 1 .GE. V(GTSTEP) * V(TUNER5)) GO TO 110 1522 370 V(RADFAC) = V(INCFAC) 1523 GO TO 110 1524C 1525C. . . . . . . . . . . . . . MISC. DETAILS . . . . . . . . . . . . . . 1526C 1527C *** BAD PARAMETERS TO ASSESS *** 1528C 1529 380 IV(1) = 64 1530 GO TO 400 1531C 1532C *** PRINT SUMMARY OF FINAL ITERATION AND OTHER REQUESTED ITEMS *** 1533C 1534 390 IV(1) = IV(CNVCOD) 1535 IV(CNVCOD) = 0 1536 400 CALL DITSUM(D, G, IV, LIV, LV, N, V, X) 1537C 1538 999 RETURN 1539C 1540C *** LAST CARD OF DRMNH FOLLOWS *** 1541 END 1542 SUBROUTINE DQ7RSH(K, P, HAVQTR, QTR, R, W) 1543C 1544C *** PERMUTE COLUMN K OF R TO COLUMN P, MODIFY QTR ACCORDINGLY *** 1545C 1546 LOGICAL HAVQTR 1547 INTEGER K, P 1548 DOUBLE PRECISION QTR(P), R(*), W(P) 1549C DIMENSION R(P*(P+1)/2) 1550C 1551 DOUBLE PRECISION DH2RFG 1552 EXTERNAL DH2RFA, DH2RFG,DV7CPY 1553C 1554C *** LOCAL VARIABLES *** 1555C 1556 INTEGER I, I1, J, JM1, JP1, J1, KM1, K1, PM1 1557 DOUBLE PRECISION A, B, T, WJ, X, Y, Z, ZERO 1558C 1559 DATA ZERO/0.0D+0/ 1560C 1561C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 1562C 1563 IF (K .GE. P) GO TO 999 1564 KM1 = K - 1 1565 K1 = K * KM1 / 2 1566 CALL DV7CPY(K, W, R(K1+1)) 1567 WJ = W(K) 1568 PM1 = P - 1 1569 J1 = K1 + KM1 1570 DO 50 J = K, PM1 1571 JM1 = J - 1 1572 JP1 = J + 1 1573 IF (JM1 .GT. 0) CALL DV7CPY(JM1, R(K1+1), R(J1+2)) 1574 J1 = J1 + JP1 1575 K1 = K1 + J 1576 A = R(J1) 1577 B = R(J1+1) 1578 IF (B .NE. ZERO) GO TO 10 1579 R(K1) = A 1580 X = ZERO 1581 Z = ZERO 1582 GO TO 40 1583 10 R(K1) = DH2RFG(A, B, X, Y, Z) 1584 IF (J .EQ. PM1) GO TO 30 1585 I1 = J1 1586 DO 20 I = JP1, PM1 1587 I1 = I1 + I 1588 CALL DH2RFA(1, R(I1), R(I1+1), X, Y, Z) 1589 20 CONTINUE 1590 30 IF (HAVQTR) CALL DH2RFA(1, QTR(J), QTR(JP1), X, Y, Z) 1591 40 T = X * WJ 1592 W(J) = WJ + T 1593 WJ = T * Z 1594 50 CONTINUE 1595 W(P) = WJ 1596 CALL DV7CPY(P, R(K1+1), W) 1597 999 RETURN 1598 END 1599 SUBROUTINE DRMNF(D, FX, IV, LIV, LV, N, V, X) 1600C 1601C *** ITERATION DRIVER FOR DMNF... 1602C *** MINIMIZE GENERAL UNCONSTRAINED OBJECTIVE FUNCTION USING 1603C *** FINITE-DIFFERENCE GRADIENTS AND SECANT HESSIAN APPROXIMATIONS. 1604C 1605 INTEGER LIV, LV, N 1606 INTEGER IV(LIV) 1607 DOUBLE PRECISION D(N), FX, X(N), V(LV) 1608C DIMENSION V(77 + N*(N+17)/2) 1609C 1610C *** PURPOSE *** 1611C 1612C THIS ROUTINE INTERACTS WITH SUBROUTINE DRMNG IN AN ATTEMPT 1613C TO FIND AN N-VECTOR X* THAT MINIMIZES THE (UNCONSTRAINED) 1614C OBJECTIVE FUNCTION FX = F(X) COMPUTED BY THE CALLER. (OFTEN 1615C THE X* FOUND IS A LOCAL MINIMIZER RATHER THAN A GLOBAL ONE.) 1616C 1617C *** PARAMETERS *** 1618C 1619C THE PARAMETERS FOR DRMNF ARE THE SAME AS THOSE FOR DMNG 1620C (WHICH SEE), EXCEPT THAT CALCF, CALCG, UIPARM, URPARM, AND UFPARM 1621C ARE OMITTED, AND A PARAMETER FX FOR THE OBJECTIVE FUNCTION 1622C VALUE AT X IS ADDED. INSTEAD OF CALLING CALCG TO OBTAIN THE 1623C GRADIENT OF THE OBJECTIVE FUNCTION AT X, DRMNF CALLS DS7GRD, 1624C WHICH COMPUTES AN APPROXIMATION TO THE GRADIENT BY FINITE 1625C (FORWARD AND CENTRAL) DIFFERENCES USING THE METHOD OF REF. 1. 1626C THE FOLLOWING INPUT COMPONENT IS OF INTEREST IN THIS REGARD 1627C (AND IS NOT DESCRIBED IN DMNG). 1628C 1629C V(ETA0)..... V(42) IS AN ESTIMATED BOUND ON THE RELATIVE ERROR IN THE 1630C OBJECTIVE FUNCTION VALUE COMPUTED BY CALCF... 1631C (TRUE VALUE) = (COMPUTED VALUE) * (1 + E), 1632C WHERE ABS(E) .LE. V(ETA0). DEFAULT = MACHEP * 10**3, 1633C WHERE MACHEP IS THE UNIT ROUNDOFF. 1634C 1635C THE OUTPUT VALUES IV(NFCALL) AND IV(NGCALL) HAVE DIFFERENT 1636C MEANINGS FOR DMNF THAN FOR DMNG... 1637C 1638C IV(NFCALL)... IV(6) IS THE NUMBER OF CALLS SO FAR MADE ON CALCF (I.E., 1639C FUNCTION EVALUATIONS) EXCLUDING THOSE MADE ONLY FOR 1640C COMPUTING GRADIENTS. THE INPUT VALUE IV(MXFCAL) IS A 1641C LIMIT ON IV(NFCALL). 1642C IV(NGCALL)... IV(30) IS THE NUMBER OF FUNCTION EVALUATIONS MADE ONLY 1643C FOR COMPUTING GRADIENTS. THE TOTAL NUMBER OF FUNCTION 1644C EVALUATIONS IS THUS IV(NFCALL) + IV(NGCALL). 1645C 1646C *** REFERENCES *** 1647C 1648C 1. STEWART, G.W. (1967), A MODIFICATION OF DAVIDON*S MINIMIZATION 1649C METHOD TO ACCEPT DIFFERENCE APPROXIMATIONS OF DERIVATIVES, 1650C J. ASSOC. COMPUT. MACH. 14, PP. 72-83. 1651C. 1652C *** GENERAL *** 1653C 1654C CODED BY DAVID M. GAY (AUGUST 1982). 1655C 1656C---------------------------- DECLARATIONS --------------------------- 1657C 1658 DOUBLE PRECISION DD7TPR 1659 EXTERNAL DIVSET, DD7TPR, DS7GRD, DRMNG, DV7SCP 1660C 1661C DIVSET.... SUPPLIES DEFAULT PARAMETER VALUES. 1662C DD7TPR... RETURNS INNER PRODUCT OF TWO VECTORS. 1663C DS7GRD... COMPUTES FINITE-DIFFERENCE GRADIENT APPROXIMATION. 1664C DRMNG.... REVERSE-COMMUNICATION ROUTINE THAT DOES DMNG ALGORITHM. 1665C DV7SCP... SETS ALL ELEMENTS OF A VECTOR TO A SCALAR. 1666C 1667 INTEGER ALPHA, G1, I, IV1, J, K, W 1668 DOUBLE PRECISION ZERO 1669C 1670C *** SUBSCRIPTS FOR IV *** 1671C 1672 INTEGER ETA0, F, G, LMAT, NEXTV, NGCALL, NITER, SGIRC, TOOBIG, 1673 1 VNEED 1674C 1675 PARAMETER (ETA0=42, F=10, G=28, LMAT=42, NEXTV=47, NGCALL=30, 1676 1 NITER=31, SGIRC=57, TOOBIG=2, VNEED=4) 1677 PARAMETER (ZERO=0.D+0) 1678C 1679C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 1680C 1681 IV1 = IV(1) 1682 IF (IV1 .EQ. 1) GO TO 10 1683 IF (IV1 .EQ. 2) GO TO 50 1684 IF (IV(1) .EQ. 0) CALL DIVSET(2, IV, LIV, LV, V) 1685 IV1 = IV(1) 1686 IF (IV1 .EQ. 12 .OR. IV1 .EQ. 13) IV(VNEED) = IV(VNEED) + 2*N + 6 1687 IF (IV1 .EQ. 14) GO TO 10 1688 IF (IV1 .GT. 2 .AND. IV1 .LT. 12) GO TO 10 1689 G1 = 1 1690 IF (IV1 .EQ. 12) IV(1) = 13 1691 GO TO 20 1692C 1693 10 G1 = IV(G) 1694C 1695 20 CALL DRMNG(D, FX, V(G1), IV, LIV, LV, N, V, X) 1696 IF (IV(1) .LT. 2) GO TO 999 1697 IF (IV(1) .GT. 2) GO TO 70 1698C 1699C *** COMPUTE GRADIENT *** 1700C 1701 IF (IV(NITER) .EQ. 0) CALL DV7SCP(N, V(G1), ZERO) 1702 J = IV(LMAT) 1703 K = G1 - N 1704 DO 40 I = 1, N 1705 V(K) = DD7TPR(I, V(J), V(J)) 1706 K = K + 1 1707 J = J + I 1708 40 CONTINUE 1709C *** UNDO INCREMENT OF IV(NGCALL) DONE BY DRMNG *** 1710 IV(NGCALL) = IV(NGCALL) - 1 1711C *** STORE RETURN CODE FROM DS7GRD IN IV(SGIRC) *** 1712 IV(SGIRC) = 0 1713C *** X MAY HAVE BEEN RESTORED, SO COPY BACK FX... *** 1714 FX = V(F) 1715 GO TO 60 1716C 1717C *** GRADIENT LOOP *** 1718C 1719 50 IF (IV(TOOBIG) .NE. 0) GO TO 10 1720C 1721 60 G1 = IV(G) 1722 ALPHA = G1 - N 1723 W = ALPHA - 6 1724 CALL DS7GRD(V(ALPHA), D, V(ETA0), FX, V(G1), IV(SGIRC), N, V(W),X) 1725 IF (IV(SGIRC) .EQ. 0) GO TO 10 1726 IV(NGCALL) = IV(NGCALL) + 1 1727 GO TO 999 1728C 1729 70 IF (IV(1) .NE. 14) GO TO 999 1730C 1731C *** STORAGE ALLOCATION *** 1732C 1733 IV(G) = IV(NEXTV) + N + 6 1734 IV(NEXTV) = IV(G) + N 1735 IF (IV1 .NE. 13) GO TO 10 1736C 1737 999 RETURN 1738C *** LAST CARD OF DRMNF FOLLOWS *** 1739 END 1740 SUBROUTINE DL7VML(N, X, L, Y) 1741C 1742C *** COMPUTE X = L*Y, WHERE L IS AN N X N LOWER TRIANGULAR 1743C *** MATRIX STORED COMPACTLY BY ROWS. X AND Y MAY OCCUPY THE SAME 1744C *** STORAGE. *** 1745C 1746 INTEGER N 1747 DOUBLE PRECISION X(N), L(*), Y(N) 1748C DIMENSION L(N*(N+1)/2) 1749 INTEGER I, II, IJ, I0, J, NP1 1750 DOUBLE PRECISION T, ZERO 1751 PARAMETER (ZERO=0.D+0) 1752C 1753 NP1 = N + 1 1754 I0 = N*(N+1)/2 1755 DO 20 II = 1, N 1756 I = NP1 - II 1757 I0 = I0 - I 1758 T = ZERO 1759 DO 10 J = 1, I 1760 IJ = I0 + J 1761 T = T + L(IJ)*Y(J) 1762 10 CONTINUE 1763 X(I) = T 1764 20 CONTINUE 1765 RETURN 1766C *** LAST CARD OF DL7VML FOLLOWS *** 1767 END 1768 SUBROUTINE DA7SST(IV, LIV, LV, V) 1769C 1770C *** ASSESS CANDIDATE STEP (***SOL VERSION 2.3) *** 1771C 1772 INTEGER LIV, LV 1773 INTEGER IV(LIV) 1774 DOUBLE PRECISION V(LV) 1775C 1776C *** PURPOSE *** 1777C 1778C THIS SUBROUTINE IS CALLED BY AN UNCONSTRAINED MINIMIZATION 1779C ROUTINE TO ASSESS THE NEXT CANDIDATE STEP. IT MAY RECOMMEND ONE 1780C OF SEVERAL COURSES OF ACTION, SUCH AS ACCEPTING THE STEP, RECOM- 1781C PUTING IT USING THE SAME OR A NEW QUADRATIC MODEL, OR HALTING DUE 1782C TO CONVERGENCE OR FALSE CONVERGENCE. SEE THE RETURN CODE LISTING 1783C BELOW. 1784C 1785C-------------------------- PARAMETER USAGE -------------------------- 1786C 1787C IV (I/O) INTEGER PARAMETER AND SCRATCH VECTOR -- SEE DESCRIPTION 1788C BELOW OF IV VALUES REFERENCED. 1789C LIV (IN) LENGTH OF IV ARRAY. 1790C LV (IN) LENGTH OF V ARRAY. 1791C V (I/O) REAL PARAMETER AND SCRATCH VECTOR -- SEE DESCRIPTION 1792C BELOW OF V VALUES REFERENCED. 1793C 1794C *** IV VALUES REFERENCED *** 1795C 1796C IV(IRC) (I/O) ON INPUT FOR THE FIRST STEP TRIED IN A NEW ITERATION, 1797C IV(IRC) SHOULD BE SET TO 3 OR 4 (THE VALUE TO WHICH IT IS 1798C SET WHEN STEP IS DEFINITELY TO BE ACCEPTED). ON INPUT 1799C AFTER STEP HAS BEEN RECOMPUTED, IV(IRC) SHOULD BE 1800C UNCHANGED SINCE THE PREVIOUS RETURN OF DA7SST. 1801C ON OUTPUT, IV(IRC) IS A RETURN CODE HAVING ONE OF THE 1802C FOLLOWING VALUES... 1803C 1 = SWITCH MODELS OR TRY SMALLER STEP. 1804C 2 = SWITCH MODELS OR ACCEPT STEP. 1805C 3 = ACCEPT STEP AND DETERMINE V(RADFAC) BY GRADIENT 1806C TESTS. 1807C 4 = ACCEPT STEP, V(RADFAC) HAS BEEN DETERMINED. 1808C 5 = RECOMPUTE STEP (USING THE SAME MODEL). 1809C 6 = RECOMPUTE STEP WITH RADIUS = V(LMAXS) BUT DO NOT 1810C EVALUATE THE OBJECTIVE FUNCTION. 1811C 7 = X-CONVERGENCE (SEE V(XCTOL)). 1812C 8 = RELATIVE FUNCTION CONVERGENCE (SEE V(RFCTOL)). 1813C 9 = BOTH X- AND RELATIVE FUNCTION CONVERGENCE. 1814C 10 = ABSOLUTE FUNCTION CONVERGENCE (SEE V(AFCTOL)). 1815C 11 = SINGULAR CONVERGENCE (SEE V(LMAXS)). 1816C 12 = FALSE CONVERGENCE (SEE V(XFTOL)). 1817C 13 = IV(IRC) WAS OUT OF RANGE ON INPUT. 1818C RETURN CODE I HAS PRECEDENCE OVER I+1 FOR I = 9, 10, 11. 1819C IV(MLSTGD) (I/O) SAVED VALUE OF IV(MODEL). 1820C IV(MODEL) (I/O) ON INPUT, IV(MODEL) SHOULD BE AN INTEGER IDENTIFYING 1821C THE CURRENT QUADRATIC MODEL OF THE OBJECTIVE FUNCTION. 1822C IF A PREVIOUS STEP YIELDED A BETTER FUNCTION REDUCTION, 1823C THEN IV(MODEL) WILL BE SET TO IV(MLSTGD) ON OUTPUT. 1824C IV(NFCALL) (IN) INVOCATION COUNT FOR THE OBJECTIVE FUNCTION. 1825C IV(NFGCAL) (I/O) VALUE OF IV(NFCALL) AT STEP THAT GAVE THE BIGGEST 1826C FUNCTION REDUCTION THIS ITERATION. IV(NFGCAL) REMAINS 1827C UNCHANGED UNTIL A FUNCTION REDUCTION IS OBTAINED. 1828C IV(RADINC) (I/O) THE NUMBER OF RADIUS INCREASES (OR MINUS THE NUMBER 1829C OF DECREASES) SO FAR THIS ITERATION. 1830C IV(RESTOR) (OUT) SET TO 1 IF V(F) HAS BEEN RESTORED AND X SHOULD BE 1831C RESTORED TO ITS INITIAL VALUE, TO 2 IF X SHOULD BE SAVED, 1832C TO 3 IF X SHOULD BE RESTORED FROM THE SAVED VALUE, AND TO 1833C 0 OTHERWISE. 1834C IV(STAGE) (I/O) COUNT OF THE NUMBER OF MODELS TRIED SO FAR IN THE 1835C CURRENT ITERATION. 1836C IV(STGLIM) (IN) MAXIMUM NUMBER OF MODELS TO CONSIDER. 1837C IV(SWITCH) (OUT) SET TO 0 UNLESS A NEW MODEL IS BEING TRIED AND IT 1838C GIVES A SMALLER FUNCTION VALUE THAN THE PREVIOUS MODEL, 1839C IN WHICH CASE DA7SST SETS IV(SWITCH) = 1. 1840C IV(TOOBIG) (I/O) IS NONZERO ON INPUT IF STEP WAS TOO BIG (E.G., IF 1841C IT WOULD CAUSE OVERFLOW). IT IS SET TO 0 ON RETURN. 1842C IV(XIRC) (I/O) VALUE THAT IV(IRC) WOULD HAVE IN THE ABSENCE OF 1843C CONVERGENCE, FALSE CONVERGENCE, AND OVERSIZED STEPS. 1844C 1845C *** V VALUES REFERENCED *** 1846C 1847C V(AFCTOL) (IN) ABSOLUTE FUNCTION CONVERGENCE TOLERANCE. IF THE 1848C ABSOLUTE VALUE OF THE CURRENT FUNCTION VALUE V(F) IS LESS 1849C THAN V(AFCTOL) AND DA7SST DOES NOT RETURN WITH 1850C IV(IRC) = 11, THEN DA7SST RETURNS WITH IV(IRC) = 10. 1851C V(DECFAC) (IN) FACTOR BY WHICH TO DECREASE RADIUS WHEN IV(TOOBIG) IS 1852C NONZERO. 1853C V(DSTNRM) (IN) THE 2-NORM OF D*STEP. 1854C V(DSTSAV) (I/O) VALUE OF V(DSTNRM) ON SAVED STEP. 1855C V(DST0) (IN) THE 2-NORM OF D TIMES THE NEWTON STEP (WHEN DEFINED, 1856C I.E., FOR V(NREDUC) .GE. 0). 1857C V(F) (I/O) ON BOTH INPUT AND OUTPUT, V(F) IS THE OBJECTIVE FUNC- 1858C TION VALUE AT X. IF X IS RESTORED TO A PREVIOUS VALUE, 1859C THEN V(F) IS RESTORED TO THE CORRESPONDING VALUE. 1860C V(FDIF) (OUT) THE FUNCTION REDUCTION V(F0) - V(F) (FOR THE OUTPUT 1861C VALUE OF V(F) IF AN EARLIER STEP GAVE A BIGGER FUNCTION 1862C DECREASE, AND FOR THE INPUT VALUE OF V(F) OTHERWISE). 1863C V(FLSTGD) (I/O) SAVED VALUE OF V(F). 1864C V(F0) (IN) OBJECTIVE FUNCTION VALUE AT START OF ITERATION. 1865C V(GTSLST) (I/O) VALUE OF V(GTSTEP) ON SAVED STEP. 1866C V(GTSTEP) (IN) INNER PRODUCT BETWEEN STEP AND GRADIENT. 1867C V(INCFAC) (IN) MINIMUM FACTOR BY WHICH TO INCREASE RADIUS. 1868C V(LMAXS) (IN) MAXIMUM REASONABLE STEP SIZE (AND INITIAL STEP BOUND). 1869C IF THE ACTUAL FUNCTION DECREASE IS NO MORE THAN TWICE 1870C WHAT WAS PREDICTED, IF A RETURN WITH IV(IRC) = 7, 8, OR 9 1871C DOES NOT OCCUR, IF V(DSTNRM) .GT. V(LMAXS) OR THE CURRENT 1872C STEP IS A NEWTON STEP, AND IF 1873C V(PREDUC) .LE. V(SCTOL) * ABS(V(F0)), THEN DA7SST RETURNS 1874C WITH IV(IRC) = 11. IF SO DOING APPEARS WORTHWHILE, THEN 1875C DA7SST REPEATS THIS TEST (DISALLOWING A FULL NEWTON STEP) 1876C WITH V(PREDUC) COMPUTED FOR A STEP OF LENGTH V(LMAXS) 1877C (BY A RETURN WITH IV(IRC) = 6). 1878C V(NREDUC) (I/O) FUNCTION REDUCTION PREDICTED BY QUADRATIC MODEL FOR 1879C NEWTON STEP. IF DA7SST IS CALLED WITH IV(IRC) = 6, I.E., 1880C IF V(PREDUC) HAS BEEN COMPUTED WITH RADIUS = V(LMAXS) FOR 1881C USE IN THE SINGULAR CONVERGENCE TEST, THEN V(NREDUC) IS 1882C SET TO -V(PREDUC) BEFORE THE LATTER IS RESTORED. 1883C V(PLSTGD) (I/O) VALUE OF V(PREDUC) ON SAVED STEP. 1884C V(PREDUC) (I/O) FUNCTION REDUCTION PREDICTED BY QUADRATIC MODEL FOR 1885C CURRENT STEP. 1886C V(RADFAC) (OUT) FACTOR TO BE USED IN DETERMINING THE NEW RADIUS, 1887C WHICH SHOULD BE V(RADFAC)*DST, WHERE DST IS EITHER THE 1888C OUTPUT VALUE OF V(DSTNRM) OR THE 2-NORM OF 1889C DIAG(NEWD)*STEP FOR THE OUTPUT VALUE OF STEP AND THE 1890C UPDATED VERSION, NEWD, OF THE SCALE VECTOR D. FOR 1891C IV(IRC) = 3, V(RADFAC) = 1.0 IS RETURNED. 1892C V(RDFCMN) (IN) MINIMUM VALUE FOR V(RADFAC) IN TERMS OF THE INPUT 1893C VALUE OF V(DSTNRM) -- SUGGESTED VALUE = 0.1. 1894C V(RDFCMX) (IN) MAXIMUM VALUE FOR V(RADFAC) -- SUGGESTED VALUE = 4.0. 1895C V(RELDX) (IN) SCALED RELATIVE CHANGE IN X CAUSED BY STEP, COMPUTED 1896C (E.G.) BY FUNCTION DRLDST AS 1897C MAX (D(I)*ABS(X(I)-X0(I)), 1 .LE. I .LE. P) / 1898C MAX (D(I)*(ABS(X(I))+ABS(X0(I))), 1 .LE. I .LE. P). 1899C V(RFCTOL) (IN) RELATIVE FUNCTION CONVERGENCE TOLERANCE. IF THE 1900C ACTUAL FUNCTION REDUCTION IS AT MOST TWICE WHAT WAS PRE- 1901C DICTED AND V(NREDUC) .LE. V(RFCTOL)*ABS(V(F0)), THEN 1902C DA7SST RETURNS WITH IV(IRC) = 8 OR 9. 1903C V(SCTOL) (IN) SINGULAR CONVERGENCE TOLERANCE -- SEE V(LMAXS). 1904C V(STPPAR) (IN) MARQUARDT PARAMETER -- 0 MEANS FULL NEWTON STEP. 1905C V(TUNER1) (IN) TUNING CONSTANT USED TO DECIDE IF THE FUNCTION 1906C REDUCTION WAS MUCH LESS THAN EXPECTED. SUGGESTED 1907C VALUE = 0.1. 1908C V(TUNER2) (IN) TUNING CONSTANT USED TO DECIDE IF THE FUNCTION 1909C REDUCTION WAS LARGE ENOUGH TO ACCEPT STEP. SUGGESTED 1910C VALUE = 10**-4. 1911C V(TUNER3) (IN) TUNING CONSTANT USED TO DECIDE IF THE RADIUS 1912C SHOULD BE INCREASED. SUGGESTED VALUE = 0.75. 1913C V(XCTOL) (IN) X-CONVERGENCE CRITERION. IF STEP IS A NEWTON STEP 1914C (V(STPPAR) = 0) HAVING V(RELDX) .LE. V(XCTOL) AND GIVING 1915C AT MOST TWICE THE PREDICTED FUNCTION DECREASE, THEN 1916C DA7SST RETURNS IV(IRC) = 7 OR 9. 1917C V(XFTOL) (IN) FALSE CONVERGENCE TOLERANCE. IF STEP GAVE NO OR ONLY 1918C A SMALL FUNCTION DECREASE AND V(RELDX) .LE. V(XFTOL), 1919C THEN DA7SST RETURNS WITH IV(IRC) = 12. 1920C 1921C------------------------------- NOTES ------------------------------- 1922C 1923C *** APPLICATION AND USAGE RESTRICTIONS *** 1924C 1925C THIS ROUTINE IS CALLED AS PART OF THE NL2SOL (NONLINEAR 1926C LEAST-SQUARES) PACKAGE. IT MAY BE USED IN ANY UNCONSTRAINED 1927C MINIMIZATION SOLVER THAT USES DOGLEG, GOLDFELD-QUANDT-TROTTER, 1928C OR LEVENBERG-MARQUARDT STEPS. 1929C 1930C *** ALGORITHM NOTES *** 1931C 1932C SEE (1) FOR FURTHER DISCUSSION OF THE ASSESSING AND MODEL 1933C SWITCHING STRATEGIES. WHILE NL2SOL CONSIDERS ONLY TWO MODELS, 1934C DA7SST IS DESIGNED TO HANDLE ANY NUMBER OF MODELS. 1935C 1936C *** USAGE NOTES *** 1937C 1938C ON THE FIRST CALL OF AN ITERATION, ONLY THE I/O VARIABLES 1939C STEP, X, IV(IRC), IV(MODEL), V(F), V(DSTNRM), V(GTSTEP), AND 1940C V(PREDUC) NEED HAVE BEEN INITIALIZED. BETWEEN CALLS, NO I/O 1941C VALUES EXCEPT STEP, X, IV(MODEL), V(F) AND THE STOPPING TOLER- 1942C ANCES SHOULD BE CHANGED. 1943C AFTER A RETURN FOR CONVERGENCE OR FALSE CONVERGENCE, ONE CAN 1944C CHANGE THE STOPPING TOLERANCES AND CALL DA7SST AGAIN, IN WHICH 1945C CASE THE STOPPING TESTS WILL BE REPEATED. 1946C 1947C *** REFERENCES *** 1948C 1949C (1) DENNIS, J.E., JR., GAY, D.M., AND WELSCH, R.E. (1981), 1950C AN ADAPTIVE NONLINEAR LEAST-SQUARES ALGORITHM, 1951C ACM TRANS. MATH. SOFTWARE, VOL. 7, NO. 3. 1952C 1953C (2) POWELL, M.J.D. (1970) A FORTRAN SUBROUTINE FOR SOLVING 1954C SYSTEMS OF NONLINEAR ALGEBRAIC EQUATIONS, IN NUMERICAL 1955C METHODS FOR NONLINEAR ALGEBRAIC EQUATIONS, EDITED BY 1956C P. RABINOWITZ, GORDON AND BREACH, LONDON. 1957C 1958C *** HISTORY *** 1959C 1960C JOHN DENNIS DESIGNED MUCH OF THIS ROUTINE, STARTING WITH 1961C IDEAS IN (2). ROY WELSCH SUGGESTED THE MODEL SWITCHING STRATEGY. 1962C DAVID GAY AND STEPHEN PETERS CAST THIS SUBROUTINE INTO A MORE 1963C PORTABLE FORM (WINTER 1977), AND DAVID GAY CAST IT INTO ITS 1964C PRESENT FORM (FALL 1978), WITH MINOR CHANGES TO THE SINGULAR 1965C CONVERGENCE TEST IN MAY, 1984 (TO DEAL WITH FULL NEWTON STEPS). 1966C 1967C *** GENERAL *** 1968C 1969C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH 1970C SUPPORTED BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS 1971C MCS-7600324, DCR75-10143, 76-14311DSS, MCS76-11989, AND 1972C MCS-7906671. 1973C 1974C------------------------ EXTERNAL QUANTITIES ------------------------ 1975C 1976C *** NO EXTERNAL FUNCTIONS AND SUBROUTINES *** 1977C 1978C-------------------------- LOCAL VARIABLES -------------------------- 1979C 1980 LOGICAL GOODX 1981 INTEGER I, NFC 1982 DOUBLE PRECISION EMAX, EMAXS, GTS, RFAC1, XMAX 1983 DOUBLE PRECISION HALF, ONE, ONEP2, TWO, ZERO 1984C 1985C *** SUBSCRIPTS FOR IV AND V *** 1986C 1987 INTEGER AFCTOL, DECFAC, DSTNRM, DSTSAV, DST0, F, FDIF, FLSTGD, F0, 1988 1 GTSLST, GTSTEP, INCFAC, IRC, LMAXS, MLSTGD, MODEL, NFCALL, 1989 2 NFGCAL, NREDUC, PLSTGD, PREDUC, RADFAC, RADINC, RDFCMN, 1990 3 RDFCMX, RELDX, RESTOR, RFCTOL, SCTOL, STAGE, STGLIM, 1991 4 STPPAR, SWITCH, TOOBIG, TUNER1, TUNER2, TUNER3, XCTOL, 1992 5 XFTOL, XIRC 1993C 1994C *** DATA INITIALIZATIONS *** 1995C 1996 PARAMETER (HALF=0.5D+0, ONE=1.D+0, ONEP2=1.2D+0, TWO=2.D+0, 1997 1 ZERO=0.D+0) 1998C 1999 PARAMETER (IRC=29, MLSTGD=32, MODEL=5, NFCALL=6, NFGCAL=7, 2000 1 RADINC=8, RESTOR=9, STAGE=10, STGLIM=11, SWITCH=12, 2001 2 TOOBIG=2, XIRC=13) 2002 PARAMETER (AFCTOL=31, DECFAC=22, DSTNRM=2, DST0=3, DSTSAV=18, 2003 1 F=10, FDIF=11, FLSTGD=12, F0=13, GTSLST=14, GTSTEP=4, 2004 2 INCFAC=23, LMAXS=36, NREDUC=6, PLSTGD=15, PREDUC=7, 2005 3 RADFAC=16, RDFCMN=24, RDFCMX=25, RELDX=17, RFCTOL=32, 2006 4 SCTOL=37, STPPAR=5, TUNER1=26, TUNER2=27, TUNER3=28, 2007 5 XCTOL=33, XFTOL=34) 2008C 2009C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 2010C 2011 NFC = IV(NFCALL) 2012 IV(SWITCH) = 0 2013 IV(RESTOR) = 0 2014 RFAC1 = ONE 2015 GOODX = .TRUE. 2016 I = IV(IRC) 2017 IF (I .GE. 1 .AND. I .LE. 12) THEN 2018c GO TO (20,30,10,10,40,280,220,220,220,220,220,170), I 2019 select case(I) 2020 case(1) 2021 goto 20 2022 case(2) 2023 goto 30 2024 case(3,4) 2025 goto 10 2026 case(5) 2027 goto 40 2028 case(6) 2029 goto 280 2030 case(7:11) 2031 goto 220 2032 case(12) 2033 goto 170 2034 end select 2035 END IF 2036 IV(IRC) = 13 2037 GO TO 999 2038C 2039C *** INITIALIZE FOR NEW ITERATION *** 2040C 2041 10 IV(STAGE) = 1 2042 IV(RADINC) = 0 2043 V(FLSTGD) = V(F0) 2044 IF (IV(TOOBIG) .EQ. 0) GO TO 110 2045 IV(STAGE) = -1 2046 IV(XIRC) = I 2047 GO TO 60 2048C 2049C *** STEP WAS RECOMPUTED WITH NEW MODEL OR SMALLER RADIUS *** 2050C *** FIRST DECIDE WHICH *** 2051C 2052 20 IF (IV(MODEL) .NE. IV(MLSTGD)) GO TO 30 2053C *** OLD MODEL RETAINED, SMALLER RADIUS TRIED *** 2054C *** DO NOT CONSIDER ANY MORE NEW MODELS THIS ITERATION *** 2055 IV(STAGE) = IV(STGLIM) 2056 IV(RADINC) = -1 2057 GO TO 110 2058C 2059C *** A NEW MODEL IS BEING TRIED. DECIDE WHETHER TO KEEP IT. *** 2060C 2061 30 IV(STAGE) = IV(STAGE) + 1 2062C 2063C *** NOW WE ADD THE POSSIBILITY THAT STEP WAS RECOMPUTED WITH *** 2064C *** THE SAME MODEL, PERHAPS BECAUSE OF AN OVERSIZED STEP. *** 2065C 2066 40 IF (IV(STAGE) .GT. 0) GO TO 50 2067C 2068C *** STEP WAS RECOMPUTED BECAUSE IT WAS TOO BIG. *** 2069C 2070 IF (IV(TOOBIG) .NE. 0) GO TO 60 2071C 2072C *** RESTORE IV(STAGE) AND PICK UP WHERE WE LEFT OFF. *** 2073C 2074 IV(STAGE) = -IV(STAGE) 2075 I = IV(XIRC) 2076c GO TO (20, 30, 110, 110, 70), I 2077 select case(I) 2078 case(1) 2079 goto 20 2080 case(2) 2081 goto 30 2082 case(3,4) 2083 goto 110 2084 case(5) 2085 goto 70 2086 end select 2087C 2088 50 IF (IV(TOOBIG) .EQ. 0) GO TO 70 2089C 2090C *** HANDLE OVERSIZE STEP *** 2091C 2092 IV(TOOBIG) = 0 2093 IF (IV(RADINC) .GT. 0) GO TO 80 2094 IV(STAGE) = -IV(STAGE) 2095 IV(XIRC) = IV(IRC) 2096C 2097 60 IV(TOOBIG) = 0 2098 V(RADFAC) = V(DECFAC) 2099 IV(RADINC) = IV(RADINC) - 1 2100 IV(IRC) = 5 2101 IV(RESTOR) = 1 2102 V(F) = V(FLSTGD) 2103 GO TO 999 2104C 2105 70 IF (V(F) .LT. V(FLSTGD)) GO TO 110 2106C 2107C *** THE NEW STEP IS A LOSER. RESTORE OLD MODEL. *** 2108C 2109 IF (IV(MODEL) .EQ. IV(MLSTGD)) GO TO 80 2110 IV(MODEL) = IV(MLSTGD) 2111 IV(SWITCH) = 1 2112C 2113C *** RESTORE STEP, ETC. ONLY IF A PREVIOUS STEP DECREASED V(F). 2114C 2115 80 IF (V(FLSTGD) .GE. V(F0)) GO TO 110 2116 IF (IV(STAGE) .LT. IV(STGLIM)) THEN 2117 GOODX = .FALSE. 2118 ELSE IF (NFC .LT. IV(NFGCAL) + IV(STGLIM) + 2) THEN 2119 GOODX = .FALSE. 2120 ELSE IF (IV(SWITCH) .NE. 0) THEN 2121 GOODX = .FALSE. 2122 ENDIF 2123 IV(RESTOR) = 3 2124 V(F) = V(FLSTGD) 2125 V(PREDUC) = V(PLSTGD) 2126 V(GTSTEP) = V(GTSLST) 2127 IF (IV(SWITCH) .EQ. 0) RFAC1 = V(DSTNRM) / V(DSTSAV) 2128 V(DSTNRM) = V(DSTSAV) 2129 IF (GOODX) THEN 2130C 2131C *** ACCEPT PREVIOUS SLIGHTLY REDUCING STEP *** 2132C 2133 V(FDIF) = V(F0) - V(F) 2134 IV(IRC) = 4 2135 V(RADFAC) = RFAC1 2136 GO TO 999 2137 ENDIF 2138 NFC = IV(NFGCAL) 2139C 2140 110 V(FDIF) = V(F0) - V(F) 2141 IF (V(FDIF) .GT. V(TUNER2) * V(PREDUC)) GO TO 140 2142 IF (IV(RADINC) .GT. 0) GO TO 140 2143C 2144C *** NO (OR ONLY A TRIVIAL) FUNCTION DECREASE 2145C *** -- SO TRY NEW MODEL OR SMALLER RADIUS 2146C 2147 IF (V(F) .LT. V(F0)) GO TO 120 2148 IV(MLSTGD) = IV(MODEL) 2149 V(FLSTGD) = V(F) 2150 V(F) = V(F0) 2151 IV(RESTOR) = 1 2152 GO TO 130 2153 120 IV(NFGCAL) = NFC 2154 130 IV(IRC) = 1 2155 IF (IV(STAGE) .LT. IV(STGLIM)) GO TO 160 2156 IV(IRC) = 5 2157 IV(RADINC) = IV(RADINC) - 1 2158 GO TO 160 2159C 2160C *** NONTRIVIAL FUNCTION DECREASE ACHIEVED *** 2161C 2162 140 IV(NFGCAL) = NFC 2163 RFAC1 = ONE 2164 V(DSTSAV) = V(DSTNRM) 2165 IF (V(FDIF) .GT. V(PREDUC)*V(TUNER1)) GO TO 190 2166C 2167C *** DECREASE WAS MUCH LESS THAN PREDICTED -- EITHER CHANGE MODELS 2168C *** OR ACCEPT STEP WITH DECREASED RADIUS. 2169C 2170 IF (IV(STAGE) .GE. IV(STGLIM)) GO TO 150 2171C *** CONSIDER SWITCHING MODELS *** 2172 IV(IRC) = 2 2173 GO TO 160 2174C 2175C *** ACCEPT STEP WITH DECREASED RADIUS *** 2176C 2177 150 IV(IRC) = 4 2178C 2179C *** SET V(RADFAC) TO FLETCHER*S DECREASE FACTOR *** 2180C 2181 160 IV(XIRC) = IV(IRC) 2182 EMAX = V(GTSTEP) + V(FDIF) 2183 V(RADFAC) = HALF * RFAC1 2184 IF (EMAX .LT. V(GTSTEP)) V(RADFAC) = RFAC1 * DMAX1(V(RDFCMN), 2185 1 HALF * V(GTSTEP)/EMAX) 2186C 2187C *** DO FALSE CONVERGENCE TEST *** 2188C 2189 170 IF (V(RELDX) .LE. V(XFTOL)) GO TO 180 2190 IV(IRC) = IV(XIRC) 2191 IF (V(F) .LT. V(F0)) GO TO 200 2192 GO TO 230 2193C 2194 180 IV(IRC) = 12 2195 GO TO 240 2196C 2197C *** HANDLE GOOD FUNCTION DECREASE *** 2198C 2199 190 IF (V(FDIF) .LT. (-V(TUNER3) * V(GTSTEP))) GO TO 210 2200C 2201C *** INCREASING RADIUS LOOKS WORTHWHILE. SEE IF WE JUST 2202C *** RECOMPUTED STEP WITH A DECREASED RADIUS OR RESTORED STEP 2203C *** AFTER RECOMPUTING IT WITH A LARGER RADIUS. 2204C 2205 IF (IV(RADINC) .LT. 0) GO TO 210 2206 IF (IV(RESTOR) .EQ. 1) GO TO 210 2207 IF (IV(RESTOR) .EQ. 3) GO TO 210 2208C 2209C *** WE DID NOT. TRY A LONGER STEP UNLESS THIS WAS A NEWTON 2210C *** STEP. 2211C 2212 V(RADFAC) = V(RDFCMX) 2213 GTS = V(GTSTEP) 2214 IF (V(FDIF) .LT. (HALF/V(RADFAC) - ONE) * GTS) 2215 1 V(RADFAC) = DMAX1(V(INCFAC), HALF*GTS/(GTS + V(FDIF))) 2216 IV(IRC) = 4 2217 IF (V(STPPAR) .EQ. ZERO) GO TO 230 2218 IF (V(DST0) .GE. ZERO .AND. (V(DST0) .LT. TWO*V(DSTNRM) 2219 1 .OR. V(NREDUC) .LT. ONEP2*V(FDIF))) GO TO 230 2220C *** STEP WAS NOT A NEWTON STEP. RECOMPUTE IT WITH 2221C *** A LARGER RADIUS. 2222 IV(IRC) = 5 2223 IV(RADINC) = IV(RADINC) + 1 2224C 2225C *** SAVE VALUES CORRESPONDING TO GOOD STEP *** 2226C 2227 200 V(FLSTGD) = V(F) 2228 IV(MLSTGD) = IV(MODEL) 2229 IF (IV(RESTOR) .EQ. 0) IV(RESTOR) = 2 2230 V(DSTSAV) = V(DSTNRM) 2231 IV(NFGCAL) = NFC 2232 V(PLSTGD) = V(PREDUC) 2233 V(GTSLST) = V(GTSTEP) 2234 GO TO 230 2235C 2236C *** ACCEPT STEP WITH RADIUS UNCHANGED *** 2237C 2238 210 V(RADFAC) = ONE 2239 IV(IRC) = 3 2240 GO TO 230 2241C 2242C *** COME HERE FOR A RESTART AFTER CONVERGENCE *** 2243C 2244 220 IV(IRC) = IV(XIRC) 2245 IF (V(DSTSAV) .GE. ZERO) GO TO 240 2246 IV(IRC) = 12 2247 GO TO 240 2248C 2249C *** PERFORM CONVERGENCE TESTS *** 2250C 2251 230 IV(XIRC) = IV(IRC) 2252 240 IF (IV(RESTOR) .EQ. 1 .AND. V(FLSTGD) .LT. V(F0)) IV(RESTOR) = 3 2253 IF (DABS(V(F)) .LT. V(AFCTOL)) IV(IRC) = 10 2254 IF (HALF * V(FDIF) .GT. V(PREDUC)) GO TO 999 2255 EMAX = V(RFCTOL) * DABS(V(F0)) 2256 EMAXS = V(SCTOL) * DABS(V(F0)) 2257 IF (V(PREDUC) .LE. EMAXS .AND. (V(DSTNRM) .GT. V(LMAXS) .OR. 2258 1 V(STPPAR) .EQ. ZERO)) IV(IRC) = 11 2259 IF (V(DST0) .LT. ZERO) GO TO 250 2260 I = 0 2261 IF ((V(NREDUC) .GT. ZERO .AND. V(NREDUC) .LE. EMAX) .OR. 2262 1 (V(NREDUC) .EQ. ZERO. AND. V(PREDUC) .EQ. ZERO)) I = 2 2263 IF (V(STPPAR) .EQ. ZERO .AND. V(RELDX) .LE. V(XCTOL) 2264 1 .AND. GOODX) I = I + 1 2265 IF (I .GT. 0) IV(IRC) = I + 6 2266C 2267C *** CONSIDER RECOMPUTING STEP OF LENGTH V(LMAXS) FOR SINGULAR 2268C *** CONVERGENCE TEST. 2269C 2270 250 IF (IV(IRC) .GT. 5 .AND. IV(IRC) .NE. 12) GO TO 999 2271 IF (V(STPPAR) .EQ. ZERO) GO TO 999 2272 IF (V(DSTNRM) .GT. V(LMAXS)) GO TO 260 2273 IF (V(PREDUC) .GE. EMAXS) GO TO 999 2274 IF (V(DST0) .LE. ZERO) GO TO 270 2275 IF (HALF * V(DST0) .LE. V(LMAXS)) GO TO 999 2276 GO TO 270 2277 260 IF (HALF * V(DSTNRM) .LE. V(LMAXS)) GO TO 999 2278 XMAX = V(LMAXS) / V(DSTNRM) 2279 IF (XMAX * (TWO - XMAX) * V(PREDUC) .GE. EMAXS) GO TO 999 2280 270 IF (V(NREDUC) .LT. ZERO) GO TO 290 2281C 2282C *** RECOMPUTE V(PREDUC) FOR USE IN SINGULAR CONVERGENCE TEST *** 2283C 2284 V(GTSLST) = V(GTSTEP) 2285 V(DSTSAV) = V(DSTNRM) 2286 IF (IV(IRC) .EQ. 12) V(DSTSAV) = -V(DSTSAV) 2287 V(PLSTGD) = V(PREDUC) 2288 I = IV(RESTOR) 2289 IV(RESTOR) = 2 2290 IF (I .EQ. 3) IV(RESTOR) = 0 2291 IV(IRC) = 6 2292 GO TO 999 2293C 2294C *** PERFORM SINGULAR CONVERGENCE TEST WITH RECOMPUTED V(PREDUC) *** 2295C 2296 280 V(GTSTEP) = V(GTSLST) 2297 V(DSTNRM) = DABS(V(DSTSAV)) 2298 IV(IRC) = IV(XIRC) 2299 IF (V(DSTSAV) .LE. ZERO) IV(IRC) = 12 2300 V(NREDUC) = -V(PREDUC) 2301 V(PREDUC) = V(PLSTGD) 2302 IV(RESTOR) = 3 2303 290 IF (-V(NREDUC) .LE. V(SCTOL) * DABS(V(F0))) IV(IRC) = 11 2304C 2305 999 RETURN 2306C 2307C *** LAST LINE OF DA7SST FOLLOWS *** 2308 END 2309 SUBROUTINE I7SHFT(N, K, X) 2310C 2311C *** SHIFT X(K),...,X(N) LEFT CIRCULARLY ONE POSITION IF K .GT. 0. 2312C *** SHIFT X(-K),...,X(N) RIGHT CIRCULARLY ONE POSITION IF K .LT. 0. 2313C 2314 INTEGER N, K 2315 INTEGER X(N) 2316C 2317 INTEGER I, II, K1, NM1, T 2318C 2319 IF (K .LT. 0) GO TO 20 2320 IF (K .GE. N) GO TO 999 2321 NM1 = N - 1 2322 T = X(K) 2323 DO 10 I = K, NM1 2324 X(I) = X(I+1) 2325 10 CONTINUE 2326 X(N) = T 2327 GO TO 999 2328C 2329 20 K1 = -K 2330 IF (K1 .GE. N) GO TO 999 2331 T = X(N) 2332 NM1 = N - K1 2333 DO 30 II = 1, NM1 2334 I = N - II 2335 X(I+1) = X(I) 2336 30 CONTINUE 2337 X(K1) = T 2338 999 RETURN 2339C *** LAST LINE OF I7SHFT FOLLOWS *** 2340 END 2341 SUBROUTINE S7ETR(M,N,NPAIRS,INDROW,JPNTR,INDCOL,IPNTR,IWA) 2342 INTEGER M,N 2343 INTEGER INDROW(NPAIRS),JPNTR(N+1),INDCOL(NPAIRS),IPNTR(M+1), 2344 * IWA(M) 2345C ********** 2346C 2347C SUBROUTINE S7ETR 2348C 2349C GIVEN A COLUMN-ORIENTED DEFINITION OF THE SPARSITY PATTERN 2350C OF AN M BY N MATRIX A, THIS SUBROUTINE DETERMINES A 2351C ROW-ORIENTED DEFINITION OF THE SPARSITY PATTERN OF A. 2352C 2353C ON INPUT THE COLUMN-ORIENTED DEFINITION IS SPECIFIED BY 2354C THE ARRAYS INDROW AND JPNTR. ON OUTPUT THE ROW-ORIENTED 2355C DEFINITION IS SPECIFIED BY THE ARRAYS INDCOL AND IPNTR. 2356C 2357C THE SUBROUTINE STATEMENT IS 2358C 2359C SUBROUTINE S7ETR(M,N,INDROW,JPNTR,INDCOL,IPNTR,IWA) 2360C 2361C WHERE 2362C 2363C M IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE NUMBER 2364C OF ROWS OF A. 2365C 2366C N IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE NUMBER 2367C OF COLUMNS OF A. 2368C 2369C INDROW IS AN INTEGER INPUT ARRAY WHICH CONTAINS THE ROW 2370C INDICES FOR THE NON-ZEROES IN THE MATRIX A. 2371C 2372C JPNTR IS AN INTEGER INPUT ARRAY OF LENGTH N + 1 WHICH 2373C SPECIFIES THE LOCATIONS OF THE ROW INDICES IN INDROW. 2374C THE ROW INDICES FOR COLUMN J ARE 2375C 2376C INDROW(K), K = JPNTR(J),...,JPNTR(J+1)-1. 2377C 2378C NOTE THAT JPNTR(N+1)-1 IS THEN THE NUMBER OF NON-ZERO 2379C ELEMENTS OF THE MATRIX A. 2380C 2381C INDCOL IS AN INTEGER OUTPUT ARRAY WHICH CONTAINS THE 2382C COLUMN INDICES FOR THE NON-ZEROES IN THE MATRIX A. 2383C 2384C IPNTR IS AN INTEGER OUTPUT ARRAY OF LENGTH M + 1 WHICH 2385C SPECIFIES THE LOCATIONS OF THE COLUMN INDICES IN INDCOL. 2386C THE COLUMN INDICES FOR ROW I ARE 2387C 2388C INDCOL(K), K = IPNTR(I),...,IPNTR(I+1)-1. 2389C 2390C NOTE THAT IPNTR(1) IS SET TO 1 AND THAT IPNTR(M+1)-1 IS 2391C THEN THE NUMBER OF NON-ZERO ELEMENTS OF THE MATRIX A. 2392C 2393C IWA IS AN INTEGER WORK ARRAY OF LENGTH M. 2394C 2395C ARGONNE NATIONAL LABORATORY. MINPACK PROJECT. JUNE 1982. 2396C THOMAS F. COLEMAN, BURTON S. GARBOW, JORGE J. MORE 2397C 2398C ********** 2399 INTEGER IR,JCOL,JP,JPL,JPU,L,NNZ 2400C 2401C DETERMINE THE NUMBER OF NON-ZEROES IN THE ROWS. 2402C 2403 DO 10 IR = 1, M 2404 IWA(IR) = 0 2405 10 CONTINUE 2406 NNZ = JPNTR(N+1) - 1 2407 DO 20 JP = 1, NNZ 2408 IR = INDROW(JP) 2409 IWA(IR) = IWA(IR) + 1 2410 20 CONTINUE 2411C 2412C SET POINTERS TO THE START OF THE ROWS IN INDCOL. 2413C 2414 IPNTR(1) = 1 2415 DO 30 IR = 1, M 2416 IPNTR(IR+1) = IPNTR(IR) + IWA(IR) 2417 IWA(IR) = IPNTR(IR) 2418 30 CONTINUE 2419C 2420C FILL INDCOL. 2421C 2422 DO 60 JCOL = 1, N 2423 JPL = JPNTR(JCOL) 2424 JPU = JPNTR(JCOL+1) - 1 2425 IF (JPU .LT. JPL) GO TO 50 2426 DO 40 JP = JPL, JPU 2427 IR = INDROW(JP) 2428 L = IWA(IR) 2429 INDCOL(L) = JCOL 2430 IWA(IR) = IWA(IR) + 1 2431 40 CONTINUE 2432 50 CONTINUE 2433 60 CONTINUE 2434 RETURN 2435C 2436C LAST CARD OF SUBROUTINE S7ETR. 2437C 2438 END 2439 SUBROUTINE DG7QSB(B, D, DIHDI, G, IPIV, IPIV1, IPIV2, KA, L, LV, 2440 1 P, P0, PC, STEP, TD, TG, V, W, X, X0) 2441C 2442C *** COMPUTE HEURISTIC BOUNDED NEWTON STEP *** 2443C 2444 INTEGER KA, LV, P, P0, PC 2445 INTEGER IPIV(P), IPIV1(P), IPIV2(P) 2446 DOUBLE PRECISION B(2,P), D(P), DIHDI(*), G(P), L(*), 2447 1 STEP(P,2), TD(P), TG(P), V(LV), W(P), X0(P), X(P) 2448C DIMENSION DIHDI(P*(P+1)/2), L(P*(P+1)/2) 2449C 2450 DOUBLE PRECISION DD7TPR 2451 EXTERNAL DD7TPR,DG7QTS, DS7BQN, DS7IPR,DV7CPY, DV7IPR, 2452 1 DV7SCP, DV7VMP 2453C 2454C *** LOCAL VARIABLES *** 2455C 2456 INTEGER K, KB, KINIT, NS, P1, P10 2457 DOUBLE PRECISION DS0, NRED, PRED, RAD 2458 DOUBLE PRECISION ZERO 2459C 2460C *** V SUBSCRIPTS *** 2461C 2462 INTEGER DST0, DSTNRM, GTSTEP, NREDUC, PREDUC, RADIUS 2463C 2464 PARAMETER (DST0=3, DSTNRM=2, GTSTEP=4, NREDUC=6, PREDUC=7, 2465 1 RADIUS=8) 2466 DATA ZERO/0.D+0/ 2467C 2468C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 2469C 2470 P1 = PC 2471 IF (KA .LT. 0) GO TO 10 2472 NRED = V(NREDUC) 2473 DS0 = V(DST0) 2474 GO TO 20 2475 10 P0 = 0 2476 KA = -1 2477C 2478 20 KINIT = -1 2479 IF (P0 .EQ. P1) KINIT = KA 2480 CALL DV7CPY(P, X, X0) 2481 PRED = ZERO 2482 RAD = V(RADIUS) 2483 KB = -1 2484 V(DSTNRM) = ZERO 2485 IF (P1 .GT. 0) GO TO 30 2486 NRED = ZERO 2487 DS0 = ZERO 2488 CALL DV7SCP(P, STEP, ZERO) 2489 GO TO 60 2490C 2491 30 CALL DV7CPY(P, TD, D) 2492 CALL DV7IPR(P, IPIV, TD) 2493 CALL DV7VMP(P, TG, G, D, -1) 2494 CALL DV7IPR(P, IPIV, TG) 2495 40 K = KINIT 2496 KINIT = -1 2497 V(RADIUS) = RAD - V(DSTNRM) 2498 CALL DG7QTS(TD, TG, DIHDI, K, L, P1, STEP, V, W) 2499 P0 = P1 2500 IF (KA .GE. 0) GO TO 50 2501 NRED = V(NREDUC) 2502 DS0 = V(DST0) 2503C 2504 50 KA = K 2505 V(RADIUS) = RAD 2506 P10 = P1 2507 CALL DS7BQN(B, D, STEP(1,2), IPIV, IPIV1, IPIV2, KB, L, LV, 2508 1 NS, P, P1, STEP, TD, TG, V, W, X, X0) 2509 IF (NS .GT. 0) CALL DS7IPR(P10, IPIV1, DIHDI) 2510 PRED = PRED + V(PREDUC) 2511 IF (NS .NE. 0) P0 = 0 2512 IF (KB .LE. 0) GO TO 40 2513C 2514 60 V(DST0) = DS0 2515 V(NREDUC) = NRED 2516 V(PREDUC) = PRED 2517 V(GTSTEP) = DD7TPR(P, G, STEP) 2518C 2519 RETURN 2520C *** LAST LINE OF DG7QSB FOLLOWS *** 2521 END 2522 DOUBLE PRECISION FUNCTION DL7SVX(P, L, X, Y) 2523C 2524C *** ESTIMATE LARGEST SING. VALUE OF PACKED LOWER TRIANG. MATRIX L 2525C 2526C *** PARAMETER DECLARATIONS *** 2527C 2528 INTEGER P 2529 DOUBLE PRECISION L(*), X(P), Y(P) 2530C DIMENSION L(P*(P+1)/2) 2531C 2532C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2533C 2534C *** PURPOSE *** 2535C 2536C THIS FUNCTION RETURNS A GOOD UNDER-ESTIMATE OF THE LARGEST 2537C SINGULAR VALUE OF THE PACKED LOWER TRIANGULAR MATRIX L. 2538C 2539C *** PARAMETER DESCRIPTION *** 2540C 2541C P (IN) = THE ORDER OF L. L IS A P X P LOWER TRIANGULAR MATRIX. 2542C L (IN) = ARRAY HOLDING THE ELEMENTS OF L IN ROW ORDER, I.E. 2543C L(1,1), L(2,1), L(2,2), L(3,1), L(3,2), L(3,3), ETC. 2544C X (OUT) IF DL7SVX RETURNS A POSITIVE VALUE, THEN X = (L**T)*Y IS AN 2545C (UNNORMALIZED) APPROXIMATE RIGHT SINGULAR VECTOR 2546C CORRESPONDING TO THE LARGEST SINGULAR VALUE. THIS 2547C APPROXIMATION MAY BE CRUDE. 2548C Y (OUT) IF DL7SVX RETURNS A POSITIVE VALUE, THEN Y = L*X IS A 2549C NORMALIZED APPROXIMATE LEFT SINGULAR VECTOR CORRESPOND- 2550C ING TO THE LARGEST SINGULAR VALUE. THIS APPROXIMATION 2551C MAY BE VERY CRUDE. THE CALLER MAY PASS THE SAME VECTOR 2552C FOR X AND Y (NONSTANDARD FORTRAN USAGE), IN WHICH CASE X 2553C OVER-WRITES Y. 2554C 2555C *** ALGORITHM NOTES *** 2556C 2557C THE ALGORITHM IS BASED ON ANALOGY WITH (1). IT USES A 2558C RANDOM NUMBER GENERATOR PROPOSED IN (4), WHICH PASSES THE 2559C SPECTRAL TEST WITH FLYING COLORS -- SEE (2) AND (3). 2560C 2561C *** SUBROUTINES AND FUNCTIONS CALLED *** 2562C 2563C DV2NRM - FUNCTION, RETURNS THE 2-NORM OF A VECTOR. 2564C 2565C *** REFERENCES *** 2566C 2567C (1) CLINE, A., MOLER, C., STEWART, G., AND WILKINSON, J.H.(1977), 2568C AN ESTIMATE FOR THE CONDITION NUMBER OF A MATRIX, REPORT 2569C TM-310, APPLIED MATH. DIV., ARGONNE NATIONAL LABORATORY. 2570C 2571C (2) HOAGLIN, D.C. (1976), THEORETICAL PROPERTIES OF CONGRUENTIAL 2572C RANDOM-NUMBER GENERATORS -- AN EMPIRICAL VIEW, 2573C MEMORANDUM NS-340, DEPT. OF STATISTICS, HARVARD UNIV. 2574C 2575C (3) KNUTH, D.E. (1969), THE ART OF COMPUTER PROGRAMMING, VOL. 2 2576C (SEMINUMERICAL ALGORITHMS), ADDISON-WESLEY, READING, MASS. 2577C 2578C (4) SMITH, C.S. (1971), MULTIPLICATIVE PSEUDO-RANDOM NUMBER 2579C GENERATORS WITH PRIME MODULUS, J. ASSOC. COMPUT. MACH. 18, 2580C PP. 586-593. 2581C 2582C *** HISTORY *** 2583C 2584C DESIGNED AND CODED BY DAVID M. GAY (WINTER 1977/SUMMER 1978). 2585C 2586C *** GENERAL *** 2587C 2588C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH 2589C SUPPORTED BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS 2590C MCS-7600324, DCR75-10143, 76-14311DSS, AND MCS76-11989. 2591C 2592C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2593C 2594C *** LOCAL VARIABLES *** 2595C 2596 INTEGER I, IX, J, JI, JJ, JJJ, JM1, J0, PM1, PPLUS1 2597 DOUBLE PRECISION B, BLJI, SMINUS, SPLUS, T, YI 2598C 2599C *** CONSTANTS *** 2600C 2601 DOUBLE PRECISION HALF, ONE, R9973, ZERO 2602C 2603C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 2604C 2605 DOUBLE PRECISION DD7TPR, DV2NRM 2606 EXTERNAL DD7TPR, DV2NRM,DV2AXY 2607C 2608 PARAMETER (HALF=0.5D+0, ONE=1.D+0, R9973=9973.D+0, ZERO=0.D+0) 2609C 2610C *** BODY *** 2611C 2612 IX = 2 2613 PPLUS1 = P + 1 2614 PM1 = P - 1 2615C 2616C *** FIRST INITIALIZE X TO PARTIAL SUMS *** 2617C 2618 J0 = P*PM1/2 2619 JJ = J0 + P 2620 IX = MOD(3432*IX, 9973) 2621 B = HALF*(ONE + DBLE(IX)/R9973) 2622 X(P) = B * L(JJ) 2623 IF (P .LE. 1) GO TO 40 2624 DO 10 I = 1, PM1 2625 JI = J0 + I 2626 X(I) = B * L(JI) 2627 10 CONTINUE 2628C 2629C *** COMPUTE X = (L**T)*B, WHERE THE COMPONENTS OF B HAVE RANDOMLY 2630C *** CHOSEN MAGNITUDES IN (.5,1) WITH SIGNS CHOSEN TO MAKE X LARGE. 2631C 2632C DO J = P-1 TO 1 BY -1... 2633 DO 30 JJJ = 1, PM1 2634 J = P - JJJ 2635C *** DETERMINE X(J) IN THIS ITERATION. NOTE FOR I = 1,2,...,J 2636C *** THAT X(I) HOLDS THE CURRENT PARTIAL SUM FOR ROW I. 2637 IX = MOD(3432*IX, 9973) 2638 B = HALF*(ONE + DBLE(IX)/R9973) 2639 JM1 = J - 1 2640 J0 = J*JM1/2 2641 SPLUS = ZERO 2642 SMINUS = ZERO 2643 DO 20 I = 1, J 2644 JI = J0 + I 2645 BLJI = B * L(JI) 2646 SPLUS = SPLUS + DABS(BLJI + X(I)) 2647 SMINUS = SMINUS + DABS(BLJI - X(I)) 2648 20 CONTINUE 2649 IF (SMINUS .GT. SPLUS) B = -B 2650 X(J) = ZERO 2651C *** UPDATE PARTIAL SUMS *** 2652 CALL DV2AXY(J, X, B, L(J0+1), X) 2653 30 CONTINUE 2654C 2655C *** NORMALIZE X *** 2656C 2657 40 T = DV2NRM(P, X) 2658 IF (T .LE. ZERO) GO TO 80 2659 T = ONE / T 2660 DO 50 I = 1, P 2661 X(I) = T*X(I) 2662 50 CONTINUE 2663C 2664C *** COMPUTE L*X = Y AND RETURN SVMAX = TWONORM(Y) *** 2665C 2666 DO 60 JJJ = 1, P 2667 J = PPLUS1 - JJJ 2668 JI = J*(J-1)/2 + 1 2669 Y(J) = DD7TPR(J, L(JI), X) 2670 60 CONTINUE 2671C 2672C *** NORMALIZE Y AND SET X = (L**T)*Y *** 2673C 2674 T = ONE / DV2NRM(P, Y) 2675 JI = 1 2676 DO 70 I = 1, P 2677 YI = T * Y(I) 2678 X(I) = ZERO 2679 CALL DV2AXY(I, X, YI, L(JI), X) 2680 JI = JI + I 2681 70 CONTINUE 2682 DL7SVX = DV2NRM(P, X) 2683 GO TO 999 2684C 2685 80 DL7SVX = ZERO 2686C 2687 999 RETURN 2688C *** LAST CARD OF DL7SVX FOLLOWS *** 2689 END 2690 SUBROUTINE DD7DUP(D, HDIAG, IV, LIV, LV, N, V) 2691C 2692C *** UPDATE SCALE VECTOR D FOR DMNH *** 2693C 2694C *** PARAMETER DECLARATIONS *** 2695C 2696 INTEGER LIV, LV, N 2697 INTEGER IV(LIV) 2698 DOUBLE PRECISION D(N), HDIAG(N), V(LV) 2699C 2700C *** LOCAL VARIABLES *** 2701C 2702 INTEGER DTOLI, D0I, I 2703 DOUBLE PRECISION T, VDFAC 2704C 2705C *** INTRINSIC FUNCTIONS *** 2706C/+ 2707 DOUBLE PRECISION DSQRT 2708C/ 2709C *** SUBSCRIPTS FOR IV AND V *** 2710C 2711 INTEGER DFAC, DTOL, DTYPE, NITER 2712 PARAMETER (DFAC=41, DTOL=59, DTYPE=16, NITER=31) 2713C 2714C------------------------------- BODY -------------------------------- 2715C 2716 I = IV(DTYPE) 2717 IF (I .EQ. 1) GO TO 10 2718 IF (IV(NITER) .GT. 0) GO TO 999 2719C 2720 10 DTOLI = IV(DTOL) 2721 D0I = DTOLI + N 2722 VDFAC = V(DFAC) 2723 DO 20 I = 1, N 2724 T = DMAX1(DSQRT(DABS(HDIAG(I))), VDFAC*D(I)) 2725 IF (T .LT. V(DTOLI)) T = DMAX1(V(DTOLI), V(D0I)) 2726 D(I) = T 2727 DTOLI = DTOLI + 1 2728 D0I = D0I + 1 2729 20 CONTINUE 2730C 2731 999 RETURN 2732C *** LAST CARD OF DD7DUP FOLLOWS *** 2733 END 2734 SUBROUTINE S7RTDT(N,NNZ,INDROW,INDCOL,JPNTR,IWA) 2735 INTEGER N,NNZ 2736 INTEGER INDROW(NNZ),INDCOL(NNZ),JPNTR(N+1),IWA(N) 2737C ********** 2738C 2739C SUBROUTINE S7RTDT 2740C 2741C GIVEN THE NON-ZERO ELEMENTS OF AN M BY N MATRIX A IN 2742C ARBITRARY ORDER AS SPECIFIED BY THEIR ROW AND COLUMN 2743C INDICES, THIS SUBROUTINE PERMUTES THESE ELEMENTS SO 2744C THAT THEIR COLUMN INDICES ARE IN NON-DECREASING ORDER. 2745C 2746C ON INPUT IT IS ASSUMED THAT THE ELEMENTS ARE SPECIFIED IN 2747C 2748C INDROW(K),INDCOL(K), K = 1,...,NNZ. 2749C 2750C ON OUTPUT THE ELEMENTS ARE PERMUTED SO THAT INDCOL IS 2751C IN NON-DECREASING ORDER. IN ADDITION, THE ARRAY JPNTR 2752C IS SET SO THAT THE ROW INDICES FOR COLUMN J ARE 2753C 2754C INDROW(K), K = JPNTR(J),...,JPNTR(J+1)-1. 2755C 2756C NOTE THAT THE VALUE OF M IS NOT NEEDED BY S7RTDT AND IS 2757C THEREFORE NOT PRESENT IN THE SUBROUTINE STATEMENT. 2758C 2759C THE SUBROUTINE STATEMENT IS 2760C 2761C SUBROUTINE S7RTDT(N,NNZ,INDROW,INDCOL,JPNTR,IWA) 2762C 2763C WHERE 2764C 2765C N IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE NUMBER 2766C OF COLUMNS OF A. 2767C 2768C NNZ IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE NUMBER 2769C OF NON-ZERO ELEMENTS OF A. 2770C 2771C INDROW IS AN INTEGER ARRAY OF LENGTH NNZ. ON INPUT INDROW 2772C MUST CONTAIN THE ROW INDICES OF THE NON-ZERO ELEMENTS OF A. 2773C ON OUTPUT INDROW IS PERMUTED SO THAT THE CORRESPONDING 2774C COLUMN INDICES OF INDCOL ARE IN NON-DECREASING ORDER. 2775C 2776C INDCOL IS AN INTEGER ARRAY OF LENGTH NNZ. ON INPUT INDCOL 2777C MUST CONTAIN THE COLUMN INDICES OF THE NON-ZERO ELEMENTS 2778C OF A. ON OUTPUT INDCOL IS PERMUTED SO THAT THESE INDICES 2779C ARE IN NON-DECREASING ORDER. 2780C 2781C JPNTR IS AN INTEGER OUTPUT ARRAY OF LENGTH N + 1 WHICH 2782C SPECIFIES THE LOCATIONS OF THE ROW INDICES IN THE OUTPUT 2783C INDROW. THE ROW INDICES FOR COLUMN J ARE 2784C 2785C INDROW(K), K = JPNTR(J),...,JPNTR(J+1)-1. 2786C 2787C NOTE THAT JPNTR(1) IS SET TO 1 AND THAT JPNTR(N+1)-1 2788C IS THEN NNZ. 2789C 2790C IWA IS AN INTEGER WORK ARRAY OF LENGTH N. 2791C 2792C SUBPROGRAMS CALLED 2793C 2794C FORTRAN-SUPPLIED ... MAX0 2795C 2796C ARGONNE NATIONAL LABORATORY. MINPACK PROJECT. JUNE 1982. 2797C THOMAS F. COLEMAN, BURTON S. GARBOW, JORGE J. MORE 2798C 2799C ********** 2800 INTEGER I,J,K,L 2801C 2802C DETERMINE THE NUMBER OF NON-ZEROES IN THE COLUMNS. 2803C 2804 DO 10 J = 1, N 2805 IWA(J) = 0 2806 10 CONTINUE 2807 DO 20 K = 1, NNZ 2808 J = INDCOL(K) 2809 IWA(J) = IWA(J) + 1 2810 20 CONTINUE 2811C 2812C SET POINTERS TO THE START OF THE COLUMNS IN INDROW. 2813C 2814 JPNTR(1) = 1 2815 DO 30 J = 1, N 2816 JPNTR(J+1) = JPNTR(J) + IWA(J) 2817 IWA(J) = JPNTR(J) 2818 30 CONTINUE 2819 K = 1 2820C 2821C BEGIN IN-PLACE SORT. 2822C 2823 40 CONTINUE 2824 J = INDCOL(K) 2825 IF (K .LT. JPNTR(J) .OR. K .GE. JPNTR(J+1)) GO TO 50 2826C 2827C CURRENT ELEMENT IS IN POSITION. NOW EXAMINE THE 2828C NEXT ELEMENT OR THE FIRST UN-SORTED ELEMENT IN 2829C THE J-TH GROUP. 2830C 2831 K = MAX0(K+1,IWA(J)) 2832 GO TO 60 2833 50 CONTINUE 2834C 2835C CURRENT ELEMENT IS NOT IN POSITION. PLACE ELEMENT 2836C IN POSITION AND MAKE THE DISPLACED ELEMENT THE 2837C CURRENT ELEMENT. 2838C 2839 L = IWA(J) 2840 IWA(J) = IWA(J) + 1 2841 I = INDROW(K) 2842 INDROW(K) = INDROW(L) 2843 INDCOL(K) = INDCOL(L) 2844 INDROW(L) = I 2845 INDCOL(L) = J 2846 60 CONTINUE 2847 IF (K .LE. NNZ) GO TO 40 2848 RETURN 2849C 2850C LAST CARD OF SUBROUTINE S7RTDT. 2851C 2852 END 2853 SUBROUTINE DL7SRT(N1, N, L, A, IRC) 2854C 2855C *** COMPUTE ROWS N1 THROUGH N OF THE CHOLESKY FACTOR L OF 2856C *** A = L*(L**T), WHERE L AND THE LOWER TRIANGLE OF A ARE BOTH 2857C *** STORED COMPACTLY BY ROWS (AND MAY OCCUPY THE SAME STORAGE). 2858C *** IRC = 0 MEANS ALL WENT WELL. IRC = J MEANS THE LEADING 2859C *** PRINCIPAL J X J SUBMATRIX OF A IS NOT POSITIVE DEFINITE -- 2860C *** AND L(J*(J+1)/2) CONTAINS THE (NONPOS.) REDUCED J-TH DIAGONAL. 2861C 2862C *** PARAMETERS *** 2863C 2864 INTEGER N1, N, IRC 2865 DOUBLE PRECISION L(*), A(*) 2866C DIMENSION L(N*(N+1)/2), A(N*(N+1)/2) 2867C 2868C *** LOCAL VARIABLES *** 2869C 2870 INTEGER I, IJ, IK, IM1, I0, J, JK, JM1, J0, K 2871 DOUBLE PRECISION T, TD, ZERO 2872C 2873C *** INTRINSIC FUNCTIONS *** 2874C/+ 2875 DOUBLE PRECISION DSQRT 2876C/ 2877 PARAMETER (ZERO=0.D+0) 2878C 2879C *** BODY *** 2880C 2881 I0 = N1 * (N1 - 1) / 2 2882 DO 50 I = N1, N 2883 TD = ZERO 2884 IF (I .EQ. 1) GO TO 40 2885 J0 = 0 2886 IM1 = I - 1 2887 DO 30 J = 1, IM1 2888 T = ZERO 2889 IF (J .EQ. 1) GO TO 20 2890 JM1 = J - 1 2891 DO 10 K = 1, JM1 2892 IK = I0 + K 2893 JK = J0 + K 2894 T = T + L(IK)*L(JK) 2895 10 CONTINUE 2896 20 IJ = I0 + J 2897 J0 = J0 + J 2898 T = (A(IJ) - T) / L(J0) 2899 L(IJ) = T 2900 TD = TD + T*T 2901 30 CONTINUE 2902 40 I0 = I0 + I 2903 T = A(I0) - TD 2904 IF (T .LE. ZERO) GO TO 60 2905 L(I0) = DSQRT(T) 2906 50 CONTINUE 2907C 2908 IRC = 0 2909 GO TO 999 2910C 2911 60 L(I0) = T 2912 IRC = I 2913C 2914 999 RETURN 2915C 2916C *** LAST CARD OF DL7SRT *** 2917 END 2918 DOUBLE PRECISION FUNCTION DL7SVN(P, L, X, Y) 2919C 2920C *** ESTIMATE SMALLEST SING. VALUE OF PACKED LOWER TRIANG. MATRIX L 2921C 2922C *** PARAMETER DECLARATIONS *** 2923C 2924 INTEGER P 2925 DOUBLE PRECISION L(*), X(P), Y(P) 2926C DIMENSION L(P*(P+1)/2) 2927C 2928C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2929C 2930C *** PURPOSE *** 2931C 2932C THIS FUNCTION RETURNS A GOOD OVER-ESTIMATE OF THE SMALLEST 2933C SINGULAR VALUE OF THE PACKED LOWER TRIANGULAR MATRIX L. 2934C 2935C *** PARAMETER DESCRIPTION *** 2936C 2937C P (IN) = THE ORDER OF L. L IS A P X P LOWER TRIANGULAR MATRIX. 2938C L (IN) = ARRAY HOLDING THE ELEMENTS OF L IN ROW ORDER, I.E. 2939C L(1,1), L(2,1), L(2,2), L(3,1), L(3,2), L(3,3), ETC. 2940C X (OUT) IF DL7SVN RETURNS A POSITIVE VALUE, THEN X IS A NORMALIZED 2941C APPROXIMATE LEFT SINGULAR VECTOR CORRESPONDING TO THE 2942C SMALLEST SINGULAR VALUE. THIS APPROXIMATION MAY BE VERY 2943C CRUDE. IF DL7SVN RETURNS ZERO, THEN SOME COMPONENTS OF X 2944C ARE ZERO AND THE REST RETAIN THEIR INPUT VALUES. 2945C Y (OUT) IF DL7SVN RETURNS A POSITIVE VALUE, THEN Y = (L**-1)*X IS AN 2946C UNNORMALIZED APPROXIMATE RIGHT SINGULAR VECTOR CORRESPOND- 2947C ING TO THE SMALLEST SINGULAR VALUE. THIS APPROXIMATION 2948C MAY BE CRUDE. IF DL7SVN RETURNS ZERO, THEN Y RETAINS ITS 2949C INPUT VALUE. THE CALLER MAY PASS THE SAME VECTOR FOR X 2950C AND Y (NONSTANDARD FORTRAN USAGE), IN WHICH CASE Y OVER- 2951C WRITES X (FOR NONZERO DL7SVN RETURNS). 2952C 2953C *** ALGORITHM NOTES *** 2954C 2955C THE ALGORITHM IS BASED ON (1), WITH THE ADDITIONAL PROVISION THAT 2956C DL7SVN = 0 IS RETURNED IF THE SMALLEST DIAGONAL ELEMENT OF L 2957C (IN MAGNITUDE) IS NOT MORE THAN THE UNIT ROUNDOFF TIMES THE 2958C LARGEST. THE ALGORITHM USES A RANDOM NUMBER GENERATOR PROPOSED 2959C IN (4), WHICH PASSES THE SPECTRAL TEST WITH FLYING COLORS -- SEE 2960C (2) AND (3). 2961C 2962C *** SUBROUTINES AND FUNCTIONS CALLED *** 2963C 2964C DV2NRM - FUNCTION, RETURNS THE 2-NORM OF A VECTOR. 2965C 2966C *** REFERENCES *** 2967C 2968C (1) CLINE, A., MOLER, C., STEWART, G., AND WILKINSON, J.H.(1977), 2969C AN ESTIMATE FOR THE CONDITION NUMBER OF A MATRIX, REPORT 2970C TM-310, APPLIED MATH. DIV., ARGONNE NATIONAL LABORATORY. 2971C 2972C (2) HOAGLIN, D.C. (1976), THEORETICAL PROPERTIES OF CONGRUENTIAL 2973C RANDOM-NUMBER GENERATORS -- AN EMPIRICAL VIEW, 2974C MEMORANDUM NS-340, DEPT. OF STATISTICS, HARVARD UNIV. 2975C 2976C (3) KNUTH, D.E. (1969), THE ART OF COMPUTER PROGRAMMING, VOL. 2 2977C (SEMINUMERICAL ALGORITHMS), ADDISON-WESLEY, READING, MASS. 2978C 2979C (4) SMITH, C.S. (1971), MULTIPLICATIVE PSEUDO-RANDOM NUMBER 2980C GENERATORS WITH PRIME MODULUS, J. ASSOC. COMPUT. MACH. 18, 2981C PP. 586-593. 2982C 2983C *** HISTORY *** 2984C 2985C DESIGNED AND CODED BY DAVID M. GAY (WINTER 1977/SUMMER 1978). 2986C 2987C *** GENERAL *** 2988C 2989C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH 2990C SUPPORTED BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS 2991C MCS-7600324, DCR75-10143, 76-14311DSS, AND MCS76-11989. 2992C 2993C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2994C 2995C *** LOCAL VARIABLES *** 2996C 2997 INTEGER I, II, IX, J, JI, JJ, JJJ, JM1, J0, PM1 2998 DOUBLE PRECISION B, SMINUS, SPLUS, T, XMINUS, XPLUS 2999C 3000C *** CONSTANTS *** 3001C 3002 DOUBLE PRECISION HALF, ONE, R9973, ZERO 3003C 3004C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 3005C 3006 DOUBLE PRECISION DD7TPR, DV2NRM 3007 EXTERNAL DD7TPR, DV2NRM,DV2AXY 3008C 3009 PARAMETER (HALF=0.5D+0, ONE=1.D+0, R9973=9973.D+0, ZERO=0.D+0) 3010C 3011C *** BODY *** 3012C 3013 IX = 2 3014 PM1 = P - 1 3015C 3016C *** FIRST CHECK WHETHER TO RETURN DL7SVN = 0 AND INITIALIZE X *** 3017C 3018 II = 0 3019 J0 = P*PM1/2 3020 JJ = J0 + P 3021 IF (L(JJ) .EQ. ZERO) GO TO 110 3022 IX = MOD(3432*IX, 9973) 3023 B = HALF*(ONE + DBLE(IX)/R9973) 3024 XPLUS = B / L(JJ) 3025 X(P) = XPLUS 3026 IF (P .LE. 1) GO TO 60 3027 DO 10 I = 1, PM1 3028 II = II + I 3029 IF (L(II) .EQ. ZERO) GO TO 110 3030 JI = J0 + I 3031 X(I) = XPLUS * L(JI) 3032 10 CONTINUE 3033C 3034C *** SOLVE (L**T)*X = B, WHERE THE COMPONENTS OF B HAVE RANDOMLY 3035C *** CHOSEN MAGNITUDES IN (.5,1) WITH SIGNS CHOSEN TO MAKE X LARGE. 3036C 3037C DO J = P-1 TO 1 BY -1... 3038 DO 50 JJJ = 1, PM1 3039 J = P - JJJ 3040C *** DETERMINE X(J) IN THIS ITERATION. NOTE FOR I = 1,2,...,J 3041C *** THAT X(I) HOLDS THE CURRENT PARTIAL SUM FOR ROW I. 3042 IX = MOD(3432*IX, 9973) 3043 B = HALF*(ONE + DBLE(IX)/R9973) 3044 XPLUS = (B - X(J)) 3045 XMINUS = (-B - X(J)) 3046 SPLUS = DABS(XPLUS) 3047 SMINUS = DABS(XMINUS) 3048 JM1 = J - 1 3049 J0 = J*JM1/2 3050 JJ = J0 + J 3051 XPLUS = XPLUS/L(JJ) 3052 XMINUS = XMINUS/L(JJ) 3053 IF (JM1 .EQ. 0) GO TO 30 3054 DO 20 I = 1, JM1 3055 JI = J0 + I 3056 SPLUS = SPLUS + DABS(X(I) + L(JI)*XPLUS) 3057 SMINUS = SMINUS + DABS(X(I) + L(JI)*XMINUS) 3058 20 CONTINUE 3059 30 IF (SMINUS .GT. SPLUS) XPLUS = XMINUS 3060 X(J) = XPLUS 3061C *** UPDATE PARTIAL SUMS *** 3062 IF (JM1 .GT. 0) CALL DV2AXY(JM1, X, XPLUS, L(J0+1), X) 3063 50 CONTINUE 3064C 3065C *** NORMALIZE X *** 3066C 3067 60 T = ONE/DV2NRM(P, X) 3068 DO 70 I = 1, P 3069 X(I) = T*X(I) 3070 70 CONTINUE 3071C 3072C *** SOLVE L*Y = X AND RETURN DL7SVN = 1/TWONORM(Y) *** 3073C 3074 DO 100 J = 1, P 3075 JM1 = J - 1 3076 J0 = J*JM1/2 3077 JJ = J0 + J 3078 T = ZERO 3079 IF (JM1 .GT. 0) T = DD7TPR(JM1, L(J0+1), Y) 3080 Y(J) = (X(J) - T) / L(JJ) 3081 100 CONTINUE 3082C 3083 DL7SVN = ONE/DV2NRM(P, Y) 3084 GO TO 999 3085C 3086 110 DL7SVN = ZERO 3087 999 RETURN 3088C *** LAST CARD OF DL7SVN FOLLOWS *** 3089 END 3090 SUBROUTINE DS7LVM(P, Y, S, X) 3091C 3092C *** SET Y = S * X, S = P X P SYMMETRIC MATRIX. *** 3093C *** LOWER TRIANGLE OF S STORED ROWWISE. *** 3094C 3095C *** PARAMETER DECLARATIONS *** 3096C 3097 INTEGER P 3098 DOUBLE PRECISION S(*), X(P), Y(P) 3099C DIMENSION S(P*(P+1)/2) 3100C 3101C *** LOCAL VARIABLES *** 3102C 3103 INTEGER I, IM1, J, K 3104 DOUBLE PRECISION XI 3105C 3106C *** NO INTRINSIC FUNCTIONS *** 3107C 3108C *** EXTERNAL FUNCTION *** 3109C 3110 DOUBLE PRECISION DD7TPR 3111 EXTERNAL DD7TPR 3112C 3113C----------------------------------------------------------------------- 3114C 3115 J = 1 3116 DO 10 I = 1, P 3117 Y(I) = DD7TPR(I, S(J), X) 3118 J = J + I 3119 10 CONTINUE 3120C 3121 IF (P .LE. 1) GO TO 999 3122 J = 1 3123 DO 40 I = 2, P 3124 XI = X(I) 3125 IM1 = I - 1 3126 J = J + 1 3127 DO 30 K = 1, IM1 3128 Y(K) = Y(K) + S(J)*XI 3129 J = J + 1 3130 30 CONTINUE 3131 40 CONTINUE 3132C 3133 999 RETURN 3134C *** LAST CARD OF DS7LVM FOLLOWS *** 3135 END 3136 DOUBLE PRECISION FUNCTION DH2RFG(A, B, X, Y, Z) 3137C 3138C *** DETERMINE X, Y, Z SO I + (1,Z)**T * (X,Y) IS A 2X2 3139C *** HOUSEHOLDER REFLECTION SENDING (A,B)**T INTO (C,0)**T, 3140C *** WHERE C = -SIGN(A)*SQRT(A**2 + B**2) IS THE VALUE DH2RFG 3141C *** RETURNS. 3142C 3143 DOUBLE PRECISION A, B, X, Y, Z 3144C 3145 DOUBLE PRECISION A1, B1, C, T 3146C/+ 3147 DOUBLE PRECISION DSQRT 3148C/ 3149 DOUBLE PRECISION ZERO 3150 DATA ZERO/0.D+0/ 3151C 3152C *** BODY *** 3153C 3154 IF (B .NE. ZERO) GO TO 10 3155 X = ZERO 3156 Y = ZERO 3157 Z = ZERO 3158 DH2RFG = A 3159 GO TO 999 3160 10 T = DABS(A) + DABS(B) 3161 A1 = A / T 3162 B1 = B / T 3163 C = DSQRT(A1**2 + B1**2) 3164 IF (A1 .GT. ZERO) C = -C 3165 A1 = A1 - C 3166 Z = B1 / A1 3167 X = A1 / C 3168 Y = B1 / C 3169 DH2RFG = T * C 3170 999 RETURN 3171C *** LAST LINE OF DH2RFG FOLLOWS *** 3172 END 3173 SUBROUTINE DL7NVR(N, LIN, L) 3174C 3175C *** COMPUTE LIN = L**-1, BOTH N X N LOWER TRIANG. STORED *** 3176C *** COMPACTLY BY ROWS. LIN AND L MAY SHARE THE SAME STORAGE. *** 3177C 3178C *** PARAMETERS *** 3179C 3180 INTEGER N 3181 DOUBLE PRECISION L(*), LIN(*) 3182C DIMENSION L(N*(N+1)/2), LIN(N*(N+1)/2) 3183C 3184C *** LOCAL VARIABLES *** 3185C 3186 INTEGER I, II, IM1, JJ, J0, J1, K, K0, NP1 3187 DOUBLE PRECISION ONE, T, ZERO 3188 PARAMETER (ONE=1.D+0, ZERO=0.D+0) 3189C 3190C *** BODY *** 3191C 3192 NP1 = N + 1 3193 J0 = N*NP1/2 3194 DO 30 II = 1, N 3195 I = NP1 - II 3196 LIN(J0) = ONE/L(J0) 3197 IF (I .LE. 1) GO TO 999 3198 J1 = J0 3199 IM1 = I - 1 3200 DO 20 JJ = 1, IM1 3201 T = ZERO 3202 J0 = J1 3203 K0 = J1 - JJ 3204 DO 10 K = 1, JJ 3205 T = T - L(K0)*LIN(J0) 3206 J0 = J0 - 1 3207 K0 = K0 + K - I 3208 10 CONTINUE 3209 LIN(J0) = T/L(K0) 3210 20 CONTINUE 3211 J0 = J0 - 1 3212 30 CONTINUE 3213 999 RETURN 3214C *** LAST CARD OF DL7NVR FOLLOWS *** 3215 END 3216 SUBROUTINE DD7DOG(DIG, LV, N, NWTSTP, STEP, V) 3217C 3218C *** COMPUTE DOUBLE DOGLEG STEP *** 3219C 3220C *** PARAMETER DECLARATIONS *** 3221C 3222 INTEGER LV, N 3223 DOUBLE PRECISION DIG(N), NWTSTP(N), STEP(N), V(LV) 3224C 3225C *** PURPOSE *** 3226C 3227C THIS SUBROUTINE COMPUTES A CANDIDATE STEP (FOR USE IN AN UNCON- 3228C STRAINED MINIMIZATION CODE) BY THE DOUBLE DOGLEG ALGORITHM OF 3229C DENNIS AND MEI (REF. 1), WHICH IS A VARIATION ON POWELL*S DOGLEG 3230C SCHEME (REF. 2, P. 95). 3231C 3232C-------------------------- PARAMETER USAGE -------------------------- 3233C 3234C DIG (INPUT) DIAG(D)**-2 * G -- SEE ALGORITHM NOTES. 3235C G (INPUT) THE CURRENT GRADIENT VECTOR. 3236C LV (INPUT) LENGTH OF V. 3237C N (INPUT) NUMBER OF COMPONENTS IN DIG, G, NWTSTP, AND STEP. 3238C NWTSTP (INPUT) NEGATIVE NEWTON STEP -- SEE ALGORITHM NOTES. 3239C STEP (OUTPUT) THE COMPUTED STEP. 3240C V (I/O) VALUES ARRAY, THE FOLLOWING COMPONENTS OF WHICH ARE 3241C USED HERE... 3242C V(BIAS) (INPUT) BIAS FOR RELAXED NEWTON STEP, WHICH IS V(BIAS) OF 3243C THE WAY FROM THE FULL NEWTON TO THE FULLY RELAXED NEWTON 3244C STEP. RECOMMENDED VALUE = 0.8 . 3245C V(DGNORM) (INPUT) 2-NORM OF DIAG(D)**-1 * G -- SEE ALGORITHM NOTES. 3246C V(DSTNRM) (OUTPUT) 2-NORM OF DIAG(D) * STEP, WHICH IS V(RADIUS) 3247C UNLESS V(STPPAR) = 0 -- SEE ALGORITHM NOTES. 3248C V(DST0) (INPUT) 2-NORM OF DIAG(D) * NWTSTP -- SEE ALGORITHM NOTES. 3249C V(GRDFAC) (OUTPUT) THE COEFFICIENT OF DIG IN THE STEP RETURNED -- 3250C STEP(I) = V(GRDFAC)*DIG(I) + V(NWTFAC)*NWTSTP(I). 3251C V(GTHG) (INPUT) SQUARE-ROOT OF (DIG**T) * (HESSIAN) * DIG -- SEE 3252C ALGORITHM NOTES. 3253C V(GTSTEP) (OUTPUT) INNER PRODUCT BETWEEN G AND STEP. 3254C V(NREDUC) (OUTPUT) FUNCTION REDUCTION PREDICTED FOR THE FULL NEWTON 3255C STEP. 3256C V(NWTFAC) (OUTPUT) THE COEFFICIENT OF NWTSTP IN THE STEP RETURNED -- 3257C SEE V(GRDFAC) ABOVE. 3258C V(PREDUC) (OUTPUT) FUNCTION REDUCTION PREDICTED FOR THE STEP RETURNED. 3259C V(RADIUS) (INPUT) THE TRUST REGION RADIUS. D TIMES THE STEP RETURNED 3260C HAS 2-NORM V(RADIUS) UNLESS V(STPPAR) = 0. 3261C V(STPPAR) (OUTPUT) CODE TELLING HOW STEP WAS COMPUTED... 0 MEANS A 3262C FULL NEWTON STEP. BETWEEN 0 AND 1 MEANS V(STPPAR) OF THE 3263C WAY FROM THE NEWTON TO THE RELAXED NEWTON STEP. BETWEEN 3264C 1 AND 2 MEANS A TRUE DOUBLE DOGLEG STEP, V(STPPAR) - 1 OF 3265C THE WAY FROM THE RELAXED NEWTON TO THE CAUCHY STEP. 3266C GREATER THAN 2 MEANS 1 / (V(STPPAR) - 1) TIMES THE CAUCHY 3267C STEP. 3268C 3269C------------------------------- NOTES ------------------------------- 3270C 3271C *** ALGORITHM NOTES *** 3272C 3273C LET G AND H BE THE CURRENT GRADIENT AND HESSIAN APPROXIMA- 3274C TION RESPECTIVELY AND LET D BE THE CURRENT SCALE VECTOR. THIS 3275C ROUTINE ASSUMES DIG = DIAG(D)**-2 * G AND NWTSTP = H**-1 * G. 3276C THE STEP COMPUTED IS THE SAME ONE WOULD GET BY REPLACING G AND H 3277C BY DIAG(D)**-1 * G AND DIAG(D)**-1 * H * DIAG(D)**-1, 3278C COMPUTING STEP, AND TRANSLATING STEP BACK TO THE ORIGINAL 3279C VARIABLES, I.E., PREMULTIPLYING IT BY DIAG(D)**-1. 3280C 3281C *** REFERENCES *** 3282C 3283C 1. DENNIS, J.E., AND MEI, H.H.W. (1979), TWO NEW UNCONSTRAINED OPTI- 3284C MIZATION ALGORITHMS WHICH USE FUNCTION AND GRADIENT 3285C VALUES, J. OPTIM. THEORY APPLIC. 28, PP. 453-482. 3286C 2. POWELL, M.J.D. (1970), A HYBRID METHOD FOR NON-LINEAR EQUATIONS, 3287C IN NUMERICAL METHODS FOR NON-LINEAR EQUATIONS, EDITED BY 3288C P. RABINOWITZ, GORDON AND BREACH, LONDON. 3289C 3290C *** GENERAL *** 3291C 3292C CODED BY DAVID M. GAY. 3293C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH SUPPORTED 3294C BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS MCS-7600324 AND 3295C MCS-7906671. 3296C 3297C------------------------ EXTERNAL QUANTITIES ------------------------ 3298C 3299C *** INTRINSIC FUNCTIONS *** 3300C/+ 3301 DOUBLE PRECISION DSQRT 3302C/ 3303C-------------------------- LOCAL VARIABLES -------------------------- 3304C 3305 INTEGER I 3306 DOUBLE PRECISION CFACT, CNORM, CTRNWT, GHINVG, FEMNSQ, GNORM, 3307 1 NWTNRM, RELAX, RLAMBD, T, T1, T2 3308 DOUBLE PRECISION HALF, ONE, TWO, ZERO 3309C 3310C *** V SUBSCRIPTS *** 3311C 3312 INTEGER BIAS, DGNORM, DSTNRM, DST0, GRDFAC, GTHG, GTSTEP, 3313 1 NREDUC, NWTFAC, PREDUC, RADIUS, STPPAR 3314C 3315C *** DATA INITIALIZATIONS *** 3316C 3317 PARAMETER (HALF=0.5D+0, ONE=1.D+0, TWO=2.D+0, ZERO=0.D+0) 3318C 3319 PARAMETER (BIAS=43, DGNORM=1, DSTNRM=2, DST0=3, GRDFAC=45, 3320 1 GTHG=44, GTSTEP=4, NREDUC=6, NWTFAC=46, PREDUC=7, 3321 2 RADIUS=8, STPPAR=5) 3322C 3323C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 3324C 3325 NWTNRM = V(DST0) 3326 RLAMBD = ONE 3327 IF (NWTNRM .GT. ZERO) RLAMBD = V(RADIUS) / NWTNRM 3328 GNORM = V(DGNORM) 3329 GHINVG = TWO * V(NREDUC) 3330 V(GRDFAC) = ZERO 3331 V(NWTFAC) = ZERO 3332 IF (RLAMBD .LT. ONE) GO TO 30 3333C 3334C *** THE NEWTON STEP IS INSIDE THE TRUST REGION *** 3335C 3336 V(STPPAR) = ZERO 3337 V(DSTNRM) = NWTNRM 3338 V(GTSTEP) = -GHINVG 3339 V(PREDUC) = V(NREDUC) 3340 V(NWTFAC) = -ONE 3341 DO 20 I = 1, N 3342 STEP(I) = -NWTSTP(I) 3343 20 CONTINUE 3344 GO TO 999 3345C 3346 30 V(DSTNRM) = V(RADIUS) 3347 CFACT = (GNORM / V(GTHG))**2 3348C *** CAUCHY STEP = -CFACT * G. 3349 CNORM = GNORM * CFACT 3350 RELAX = ONE - V(BIAS) * (ONE - GNORM*CNORM/GHINVG) 3351 IF (RLAMBD .LT. RELAX) GO TO 50 3352C 3353C *** STEP IS BETWEEN RELAXED NEWTON AND FULL NEWTON STEPS *** 3354C 3355 V(STPPAR) = ONE - (RLAMBD - RELAX) / (ONE - RELAX) 3356 T = -RLAMBD 3357 V(GTSTEP) = T * GHINVG 3358 V(PREDUC) = RLAMBD * (ONE - HALF*RLAMBD) * GHINVG 3359 V(NWTFAC) = T 3360 DO 40 I = 1, N 3361 STEP(I) = T * NWTSTP(I) 3362 40 CONTINUE 3363 GO TO 999 3364C 3365 50 IF (CNORM .LT. V(RADIUS)) GO TO 70 3366C 3367C *** THE CAUCHY STEP LIES OUTSIDE THE TRUST REGION -- 3368C *** STEP = SCALED CAUCHY STEP *** 3369C 3370 T = -V(RADIUS) / GNORM 3371 V(GRDFAC) = T 3372 V(STPPAR) = ONE + CNORM / V(RADIUS) 3373 V(GTSTEP) = -V(RADIUS) * GNORM 3374 V(PREDUC) = V(RADIUS)*(GNORM - HALF*V(RADIUS)*(V(GTHG)/GNORM)**2) 3375 DO 60 I = 1, N 3376 STEP(I) = T * DIG(I) 3377 60 CONTINUE 3378 GO TO 999 3379C 3380C *** COMPUTE DOGLEG STEP BETWEEN CAUCHY AND RELAXED NEWTON *** 3381C *** FEMUR = RELAXED NEWTON STEP MINUS CAUCHY STEP *** 3382C 3383 70 CTRNWT = CFACT * RELAX * GHINVG / GNORM 3384C *** CTRNWT = INNER PROD. OF CAUCHY AND RELAXED NEWTON STEPS, 3385C *** SCALED BY GNORM**-1. 3386 T1 = CTRNWT - GNORM*CFACT**2 3387C *** T1 = INNER PROD. OF FEMUR AND CAUCHY STEP, SCALED BY 3388C *** GNORM**-1. 3389 T2 = V(RADIUS)*(V(RADIUS)/GNORM) - GNORM*CFACT**2 3390 T = RELAX * NWTNRM 3391 FEMNSQ = (T/GNORM)*T - CTRNWT - T1 3392C *** FEMNSQ = SQUARE OF 2-NORM OF FEMUR, SCALED BY GNORM**-1. 3393 T = T2 / (T1 + DSQRT(T1**2 + FEMNSQ*T2)) 3394C *** DOGLEG STEP = CAUCHY STEP + T * FEMUR. 3395 T1 = (T - ONE) * CFACT 3396 V(GRDFAC) = T1 3397 T2 = -T * RELAX 3398 V(NWTFAC) = T2 3399 V(STPPAR) = TWO - T 3400 V(GTSTEP) = T1*GNORM**2 + T2*GHINVG 3401 V(PREDUC) = -T1*GNORM * ((T2 + ONE)*GNORM) 3402 1 - T2 * (ONE + HALF*T2)*GHINVG 3403 2 - HALF * (V(GTHG)*T1)**2 3404 DO 80 I = 1, N 3405 STEP(I) = T1*DIG(I) + T2*NWTSTP(I) 3406 80 CONTINUE 3407C 3408 999 RETURN 3409C *** LAST LINE OF DD7DOG FOLLOWS *** 3410 END 3411 SUBROUTINE DS7IPR(P, IP, H) 3412C 3413C APPLY THE PERMUTATION DEFINED BY IP TO THE ROWS AND COLUMNS OF THE 3414C P X P SYMMETRIC MATRIX WHOSE LOWER TRIANGLE IS STORED COMPACTLY IN H. 3415C THUS H.OUTPUT(I,J) = H.INPUT(IP(I), IP(J)). 3416C 3417 INTEGER P 3418 INTEGER IP(P) 3419 DOUBLE PRECISION H(*) 3420C 3421 INTEGER I, J, J1, JM, K, K1, KK, KM, KMJ, L, M 3422 DOUBLE PRECISION T 3423C 3424C *** BODY *** 3425C 3426 DO 90 I = 1, P 3427 J = IP(I) 3428 IF (J .EQ. I) GO TO 90 3429 IP(I) = IABS(J) 3430 IF (J .LT. 0) GO TO 90 3431 K = I 3432 10 J1 = J 3433 K1 = K 3434 IF (J .LE. K) GO TO 20 3435 J1 = K 3436 K1 = J 3437 20 KMJ = K1-J1 3438 L = J1-1 3439 JM = J1*L/2 3440 KM = K1*(K1-1)/2 3441 IF (L .LE. 0) GO TO 40 3442 DO 30 M = 1, L 3443 JM = JM+1 3444 T = H(JM) 3445 KM = KM+1 3446 H(JM) = H(KM) 3447 H(KM) = T 3448 30 CONTINUE 3449 40 KM = KM+1 3450 KK = KM+KMJ 3451 JM = JM+1 3452 T = H(JM) 3453 H(JM) = H(KK) 3454 H(KK) = T 3455 J1 = L 3456 L = KMJ-1 3457 IF (L .LE. 0) GO TO 60 3458 DO 50 M = 1, L 3459 JM = JM+J1+M 3460 T = H(JM) 3461 KM = KM+1 3462 H(JM) = H(KM) 3463 H(KM) = T 3464 50 CONTINUE 3465 60 IF (K1 .GE. P) GO TO 80 3466 L = P-K1 3467 K1 = K1-1 3468 KM = KK 3469 DO 70 M = 1, L 3470 KM = KM+K1+M 3471 JM = KM-KMJ 3472 T = H(JM) 3473 H(JM) = H(KM) 3474 H(KM) = T 3475 70 CONTINUE 3476 80 K = J 3477 J = IP(K) 3478 IP(K) = -J 3479 IF (J .GT. I) GO TO 10 3480 90 CONTINUE 3481 RETURN 3482C *** LAST LINE OF DS7IPR FOLLOWS *** 3483 END 3484 SUBROUTINE DH2RFA(N, A, B, X, Y, Z) 3485C 3486C *** APPLY 2X2 HOUSEHOLDER REFLECTION DETERMINED BY X, Y, Z TO 3487C *** N-VECTORS A, B *** 3488C 3489 INTEGER N 3490 DOUBLE PRECISION A(N), B(N), X, Y, Z 3491 INTEGER I 3492 DOUBLE PRECISION T 3493 DO 10 I = 1, N 3494 T = A(I)*X + B(I)*Y 3495 A(I) = A(I) + T 3496 B(I) = B(I) + T*Z 3497 10 CONTINUE 3498 RETURN 3499C *** LAST LINE OF DH2RFA FOLLOWS *** 3500 END 3501 SUBROUTINE DPARCK(ALG, D, IV, LIV, LV, N, V) 3502C 3503C *** CHECK ***SOL (VERSION 2.3) PARAMETERS, PRINT CHANGED VALUES *** 3504C 3505C *** ALG = 1 FOR REGRESSION, ALG = 2 FOR GENERAL UNCONSTRAINED OPT. 3506C 3507 INTEGER ALG, LIV, LV, N 3508 INTEGER IV(LIV) 3509 DOUBLE PRECISION D(N), V(LV) 3510C 3511 DOUBLE PRECISION DR7MDC 3512 EXTERNAL DIVSET, DR7MDC,DV7CPY,DV7DFL 3513C DIVSET -- SUPPLIES DEFAULT VALUES TO BOTH IV AND V. 3514C DR7MDC -- RETURNS MACHINE-DEPENDENT CONSTANTS. 3515C DV7CPY -- COPIES ONE VECTOR TO ANOTHER. 3516C DV7DFL -- SUPPLIES DEFAULT PARAMETER VALUES TO V ALONE. 3517C 3518C *** LOCAL VARIABLES *** 3519C 3520 INTEGER ALG1, I, II, IV1, J, K, L, M, MIV1, MIV2, NDFALT, PARSV1, 3521 1 PU 3522 INTEGER IJMP, JLIM(4), MINIV(4), NDFLT(4) 3523 CHARACTER(4) CNGD(3), DFLT(3), WHICH(3) 3524 DOUBLE PRECISION BIG, MACHEP, TINY, VK, VM(34), VX(34), ZERO 3525C 3526C *** IV AND V SUBSCRIPTS *** 3527C 3528 INTEGER ALGSAV, DINIT, DTYPE, DTYPE0, EPSLON, INITS, IVNEED, 3529 1 LASTIV, LASTV, LMAT, NEXTIV, NEXTV, NVDFLT, OLDN, 3530 2 PARPRT, PARSAV, PERM, PRUNIT, VNEED 3531C 3532C 3533 PARAMETER (ALGSAV=51, DINIT=38, DTYPE=16, DTYPE0=54, EPSLON=19, 3534 1 INITS=25, IVNEED=3, LASTIV=44, LASTV=45, LMAT=42, 3535 2 NEXTIV=46, NEXTV=47, NVDFLT=50, OLDN=38, PARPRT=20, 3536 3 PARSAV=49, PERM=58, PRUNIT=21, VNEED=4) 3537 SAVE BIG, MACHEP, TINY 3538C 3539 DATA BIG/0.D+0/, MACHEP/-1.D+0/, TINY/1.D+0/, ZERO/0.D+0/ 3540C 3541 DATA VM(1)/1.0D-3/, VM(2)/-0.99D+0/, VM(3)/1.0D-3/, VM(4)/1.0D-2/, 3542 1 VM(5)/1.2D+0/, VM(6)/1.D-2/, VM(7)/1.2D+0/, VM(8)/0.D+0/, 3543 2 VM(9)/0.D+0/, VM(10)/1.D-3/, VM(11)/-1.D+0/, VM(13)/0.D+0/, 3544 3 VM(15)/0.D+0/, VM(16)/0.D+0/, VM(19)/0.D+0/, VM(20)/-10.D+0/, 3545 4 VM(21)/0.D+0/, VM(22)/0.D+0/, VM(23)/0.D+0/, VM(27)/1.01D+0/, 3546 5 VM(28)/1.D+10/, VM(30)/0.D+0/, VM(31)/0.D+0/, VM(32)/0.D+0/, 3547 6 VM(34)/0.D+0/ 3548 DATA VX(1)/0.9D+0/, VX(2)/-1.D-3/, VX(3)/1.D+1/, VX(4)/0.8D+0/, 3549 1 VX(5)/1.D+2/, VX(6)/0.8D+0/, VX(7)/1.D+2/, VX(8)/0.5D+0/, 3550 2 VX(9)/0.5D+0/, VX(10)/1.D+0/, VX(11)/1.D+0/, VX(14)/0.1D+0/, 3551 3 VX(15)/1.D+0/, VX(16)/1.D+0/, VX(19)/1.D+0/, VX(23)/1.D+0/, 3552 4 VX(24)/1.D+0/, VX(25)/1.D+0/, VX(26)/1.D+0/, VX(27)/1.D+10/, 3553 5 VX(29)/1.D+0/, VX(31)/1.D+0/, VX(32)/1.D+0/, VX(33)/1.D+0/, 3554 6 VX(34)/1.D+0/ 3555C 3556 DATA CNGD(1),CNGD(2),CNGD(3)/'---C','HANG','ED V'/, 3557 1 DFLT(1),DFLT(2),DFLT(3)/'NOND','EFAU','LT V'/ 3558 DATA IJMP/33/, JLIM(1)/0/, JLIM(2)/24/, JLIM(3)/0/, JLIM(4)/24/, 3559 1 NDFLT(1)/32/, NDFLT(2)/25/, NDFLT(3)/32/, NDFLT(4)/25/ 3560 DATA MINIV(1)/82/, MINIV(2)/59/, MINIV(3)/103/, MINIV(4)/103/ 3561C 3562C............................... BODY ................................ 3563C 3564 PU = 0 3565 IF (PRUNIT .LE. LIV) PU = IV(PRUNIT) 3566 IF (ALGSAV .GT. LIV) GO TO 20 3567 IF (ALG .EQ. IV(ALGSAV)) GO TO 20 3568C IF (PU .NE. 0) WRITE(PU,10) ALG, IV(ALGSAV) 3569C 10 FORMAT(/40H THE FIRST PARAMETER TO DIVSET SHOULD BE,I3, 3570C 1 12H RATHER THAN,I3) 3571 IV(1) = 67 3572 GO TO 999 3573 20 IF (ALG .LT. 1 .OR. ALG .GT. 4) GO TO 340 3574 MIV1 = MINIV(ALG) 3575 IF (IV(1) .EQ. 15) GO TO 360 3576 ALG1 = MOD(ALG-1,2) + 1 3577 IF (IV(1) .EQ. 0) CALL DIVSET(ALG, IV, LIV, LV, V) 3578 IV1 = IV(1) 3579 IF (IV1 .NE. 13 .AND. IV1 .NE. 12) GO TO 30 3580 IF (PERM .LE. LIV) MIV1 = MAX0(MIV1, IV(PERM) - 1) 3581 IF (IVNEED .LE. LIV) MIV2 = MIV1 + MAX0(IV(IVNEED), 0) 3582 IF (LASTIV .LE. LIV) IV(LASTIV) = MIV2 3583 IF (LIV .LT. MIV1) GO TO 300 3584 IV(IVNEED) = 0 3585 IV(LASTV) = MAX0(IV(VNEED), 0) + IV(LMAT) - 1 3586 IV(VNEED) = 0 3587 IF (LIV .LT. MIV2) GO TO 300 3588 IF (LV .LT. IV(LASTV)) GO TO 320 3589 30 IF (IV1 .LT. 12 .OR. IV1 .GT. 14) GO TO 60 3590 IF (N .GE. 1) GO TO 50 3591 IV(1) = 81 3592 IF (PU .EQ. 0) GO TO 999 3593C WRITE(PU,40) VARNM(ALG1), N 3594C 40 FORMAT(/8H /// BAD,A1,2H =,I5) 3595 GO TO 999 3596 50 IF (IV1 .NE. 14) IV(NEXTIV) = IV(PERM) 3597 IF (IV1 .NE. 14) IV(NEXTV) = IV(LMAT) 3598 IF (IV1 .EQ. 13) GO TO 999 3599 K = IV(PARSAV) - EPSLON 3600 CALL DV7DFL(ALG1, LV-K, V(K+1)) 3601 IV(DTYPE0) = 2 - ALG1 3602 IV(OLDN) = N 3603 WHICH(1) = DFLT(1) 3604 WHICH(2) = DFLT(2) 3605 WHICH(3) = DFLT(3) 3606 GO TO 110 3607 60 IF (N .EQ. IV(OLDN)) GO TO 80 3608 IV(1) = 17 3609 IF (PU .EQ. 0) GO TO 999 3610C WRITE(PU,70) VARNM(ALG1), IV(OLDN), N 3611C 70 FORMAT(/5H /// ,1A1,14H CHANGED FROM ,I5,4H TO ,I5) 3612 GO TO 999 3613C 3614 80 IF (IV1 .LE. 11 .AND. IV1 .GE. 1) GO TO 100 3615 IV(1) = 80 3616C IF (PU .NE. 0) WRITE(PU,90) IV1 3617C 90 FORMAT(/13H /// IV(1) =,I5,28H SHOULD BE BETWEEN 0 AND 14.) 3618 GO TO 999 3619C 3620 100 WHICH(1) = CNGD(1) 3621 WHICH(2) = CNGD(2) 3622 WHICH(3) = CNGD(3) 3623C 3624 110 IF (IV1 .EQ. 14) IV1 = 12 3625 IF (BIG .GT. TINY) GO TO 120 3626 TINY = DR7MDC(1) 3627 MACHEP = DR7MDC(3) 3628 BIG = DR7MDC(6) 3629 VM(12) = MACHEP 3630 VX(12) = BIG 3631 VX(13) = BIG 3632 VM(14) = MACHEP 3633 VM(17) = TINY 3634 VX(17) = BIG 3635 VM(18) = TINY 3636 VX(18) = BIG 3637 VX(20) = BIG 3638 VX(21) = BIG 3639 VX(22) = BIG 3640 VM(24) = MACHEP 3641 VM(25) = MACHEP 3642 VM(26) = MACHEP 3643 VX(28) = DR7MDC(5) 3644 VM(29) = MACHEP 3645 VX(30) = BIG 3646 VM(33) = MACHEP 3647 120 M = 0 3648 I = 1 3649 J = JLIM(ALG1) 3650 K = EPSLON 3651 NDFALT = NDFLT(ALG1) 3652 DO 150 L = 1, NDFALT 3653 VK = V(K) 3654 IF (VK .GE. VM(I) .AND. VK .LE. VX(I)) GO TO 140 3655 M = K 3656C IF (PU .NE. 0) WRITE(PU,130) VN(1,I), VN(2,I), K, VK, 3657C 1 VM(I), VX(I) 3658C 130 FORMAT(/6H /// ,2A4,5H.. V(,I2,3H) =,D11.3,7H SHOULD, 3659C 1 11H BE BETWEEN,D11.3,4H AND,D11.3) 3660 140 K = K + 1 3661 I = I + 1 3662 IF (I .EQ. J) I = IJMP 3663 150 CONTINUE 3664C 3665 IF (IV(NVDFLT) .EQ. NDFALT) GO TO 170 3666 IV(1) = 51 3667 IF (PU .EQ. 0) GO TO 999 3668C WRITE(PU,160) IV(NVDFLT), NDFALT 3669C 160 FORMAT(/13H IV(NVDFLT) =,I5,13H RATHER THAN ,I5) 3670 GO TO 999 3671 170 IF ((IV(DTYPE) .GT. 0 .OR. V(DINIT) .GT. ZERO) .AND. IV1 .EQ. 12) 3672 1 GO TO 200 3673 DO 190 I = 1, N 3674 IF (D(I) .GT. ZERO) GO TO 190 3675 M = 18 3676C IF (PU .NE. 0) WRITE(PU,180) I, D(I) 3677C 180 FORMAT(/8H /// D(,I3,3H) =,D11.3,19H SHOULD BE POSITIVE) 3678 190 CONTINUE 3679 200 IF (M .EQ. 0) GO TO 210 3680 IV(1) = M 3681 GO TO 999 3682C 3683 210 IF (PU .EQ. 0 .OR. IV(PARPRT) .EQ. 0) GO TO 999 3684 IF (IV1 .NE. 12 .OR. IV(INITS) .EQ. ALG1-1) GO TO 230 3685 M = 1 3686C WRITE(PU,220) SH(ALG1), IV(INITS) 3687C 220 FORMAT(/22H NONDEFAULT VALUES..../5H INIT,A1,14H..... IV(25) =, 3688C 1 I3) 3689 230 IF (IV(DTYPE) .EQ. IV(DTYPE0)) GO TO 250 3690C IF (M .EQ. 0) WRITE(PU,260) WHICH 3691 M = 1 3692C WRITE(PU,240) IV(DTYPE) 3693C 240 FORMAT(20H DTYPE..... IV(16) =,I3) 3694 250 I = 1 3695 J = JLIM(ALG1) 3696 K = EPSLON 3697 L = IV(PARSAV) 3698 NDFALT = NDFLT(ALG1) 3699 DO 290 II = 1, NDFALT 3700 IF (V(K) .EQ. V(L)) GO TO 280 3701C IF (M .EQ. 0) WRITE(PU,260) WHICH 3702C 260 FORMAT(/1H ,3A4,9HALUES..../) 3703 M = 1 3704C WRITE(PU,270) VN(1,I), VN(2,I), K, V(K) 3705C 270 FORMAT(1X,2A4,5H.. V(,I2,3H) =,D15.7) 3706 280 K = K + 1 3707 L = L + 1 3708 I = I + 1 3709 IF (I .EQ. J) I = IJMP 3710 290 CONTINUE 3711C 3712 IV(DTYPE0) = IV(DTYPE) 3713 PARSV1 = IV(PARSAV) 3714 CALL DV7CPY(IV(NVDFLT), V(PARSV1), V(EPSLON)) 3715 GO TO 999 3716C 3717 300 IV(1) = 15 3718 IF (PU .EQ. 0) GO TO 999 3719C WRITE(PU,310) LIV, MIV2 3720C 310 FORMAT(/10H /// LIV =,I5,17H MUST BE AT LEAST,I5) 3721 IF (LIV .LT. MIV1) GO TO 999 3722 IF (LV .LT. IV(LASTV)) GO TO 320 3723 GO TO 999 3724C 3725 320 IV(1) = 16 3726C IF (PU .NE. 0) WRITE(PU,330) LV, IV(LASTV) 3727C 330 FORMAT(/9H /// LV =,I5,17H MUST BE AT LEAST,I5) 3728 GO TO 999 3729C 3730 340 IV(1) = 67 3731C IF (PU .NE. 0) WRITE(PU,350) ALG 3732C 350 FORMAT(/10H /// ALG =,I5,21H MUST BE 1 2, 3, OR 4) 3733 GO TO 999 3734 360 CONTINUE 3735C 360 IF (PU .NE. 0) WRITE(PU,370) LIV, MIV1 3736C 370 FORMAT(/10H /// LIV =,I5,17H MUST BE AT LEAST,I5, 3737C 1 37H TO COMPUTE TRUE MIN. LIV AND MIN. LV) 3738 IF (LASTIV .LE. LIV) IV(LASTIV) = MIV1 3739 IF (LASTV .LE. LIV) IV(LASTV) = 0 3740C 3741 999 RETURN 3742C *** LAST LINE OF DPARCK FOLLOWS *** 3743 END 3744 3745 SUBROUTINE DQ7APL(NN, N, P, J, R, IERR) 3746C *****PARAMETERS. 3747 INTEGER NN, N, P, IERR 3748 DOUBLE PRECISION J(NN,P), R(N) 3749C 3750C .................................................................. 3751C .................................................................. 3752C 3753C *****PURPOSE. 3754C THIS SUBROUTINE APPLIES TO R THE ORTHOGONAL TRANSFORMATIONS 3755C STORED IN J BY QRFACT 3756C 3757C *****PARAMETER DESCRIPTION. 3758C ON INPUT. 3759C 3760C NN IS THE ROW DIMENSION OF THE MATRIX J AS DECLARED IN 3761C THE CALLING PROGRAM DIMENSION STATEMENT 3762C 3763C N IS THE NUMBER OF ROWS OF J AND THE SIZE OF THE VECTOR R 3764C 3765C P IS THE NUMBER OF COLUMNS OF J AND THE SIZE OF SIGMA 3766C 3767C J CONTAINS ON AND BELOW ITS DIAGONAL THE COLUMN VECTORS 3768C U WHICH DETERMINE THE HOUSEHOLDER TRANSFORMATIONS 3769C IDENT - U*U.TRANSPOSE 3770C 3771C R IS THE RIGHT HAND SIDE VECTOR TO WHICH THE ORTHOGONAL 3772C TRANSFORMATIONS WILL BE APPLIED 3773C 3774C IERR IF NON-ZERO INDICATES THAT NOT ALL THE TRANSFORMATIONS 3775C WERE SUCCESSFULLY DETERMINED AND ONLY THE FIRST 3776C ABS(IERR) - 1 TRANSFORMATIONS WILL BE USED 3777C 3778C ON OUTPUT. 3779C 3780C R HAS BEEN OVERWRITTEN BY ITS TRANSFORMED IMAGE 3781C 3782C *****APPLICATION AND USAGE RESTRICTIONS. 3783C NONE 3784C 3785C *****ALGORITHM NOTES. 3786C THE VECTORS U WHICH DETERMINE THE HOUSEHOLDER TRANSFORMATIONS 3787C ARE NORMALIZED SO THAT THEIR 2-NORM SQUARED IS 2. THE USE OF 3788C THESE TRANSFORMATIONS HERE IS IN THE SPIRIT OF (1). 3789C 3790C *****SUBROUTINES AND FUNCTIONS CALLED. 3791C 3792C DD7TPR - FUNCTION, RETURNS THE INNER PRODUCT OF VECTORS 3793C 3794C *****REFERENCES. 3795C (1) BUSINGER, P. A., AND GOLUB, G. H. (1965), LINEAR LEAST SQUARES 3796C SOLUTIONS BY HOUSEHOLDER TRANSFORMATIONS, NUMER. MATH. 7, 3797C PP. 269-276. 3798C 3799C *****HISTORY. 3800C DESIGNED BY DAVID M. GAY, CODED BY STEPHEN C. PETERS (WINTER 1977) 3801C CALL ON DV2AXY SUBSTITUTED FOR DO LOOP, FALL 1983. 3802C 3803C *****GENERAL. 3804C 3805C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH 3806C SUPPORTED BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS 3807C MCS-7600324, DCR75-10143, 76-14311DSS, AND MCS76-11989. 3808C 3809C .................................................................. 3810C .................................................................. 3811C 3812C *****LOCAL VARIABLES. 3813 INTEGER K, L, NL1 3814C *****FUNCTIONS. 3815 DOUBLE PRECISION DD7TPR 3816 EXTERNAL DD7TPR,DV2AXY 3817C 3818C *** BODY *** 3819C 3820 K = P 3821 IF (IERR .NE. 0) K = IABS(IERR) - 1 3822 IF ( K .EQ. 0) GO TO 999 3823C 3824 DO 20 L = 1, K 3825 NL1 = N - L + 1 3826 CALL DV2AXY(NL1, R(L), -DD7TPR(NL1,J(L,L),R(L)), J(L,L), R(L)) 3827 20 CONTINUE 3828C 3829 999 RETURN 3830C *** LAST LINE OF DQ7APL FOLLOWS *** 3831 END 3832 3833 SUBROUTINE DV7DFL(ALG, LV, V) 3834C 3835C *** SUPPLY ***SOL (VERSION 2.3) DEFAULT VALUES TO V *** 3836C 3837C *** ALG = 1 MEANS REGRESSION CONSTANTS. 3838C *** ALG = 2 MEANS GENERAL UNCONSTRAINED OPTIMIZATION CONSTANTS. 3839C 3840 INTEGER ALG, LV 3841 DOUBLE PRECISION V(LV) 3842C 3843 DOUBLE PRECISION DR7MDC 3844 EXTERNAL DR7MDC 3845C DR7MDC... RETURNS MACHINE-DEPENDENT CONSTANTS 3846C 3847 DOUBLE PRECISION MACHEP, MEPCRT, ONE, SQTEPS, THREE 3848C 3849C *** SUBSCRIPTS FOR V *** 3850C 3851 INTEGER AFCTOL, BIAS, COSMIN, DECFAC, DELTA0, DFAC, DINIT, DLTFDC, 3852 1 DLTFDJ, DTINIT, D0INIT, EPSLON, ETA0, FUZZ, 3853 2 INCFAC, LMAX0, LMAXS, PHMNFC, PHMXFC, RDFCMN, RDFCMX, 3854 3 RFCTOL, RLIMIT, RSPTOL, SCTOL, SIGMIN, TUNER1, TUNER2, 3855 4 TUNER3, TUNER4, TUNER5, XCTOL, XFTOL 3856C 3857 PARAMETER (ONE=1.D+0, THREE=3.D+0) 3858C 3859C *** V SUBSCRIPT VALUES *** 3860C 3861 PARAMETER (AFCTOL=31, BIAS=43, COSMIN=47, DECFAC=22, DELTA0=44, 3862 1 DFAC=41, DINIT=38, DLTFDC=42, DLTFDJ=43, DTINIT=39, 3863 2 D0INIT=40, EPSLON=19, ETA0=42, FUZZ=45, 3864 3 INCFAC=23, LMAX0=35, LMAXS=36, PHMNFC=20, PHMXFC=21, 3865 4 RDFCMN=24, RDFCMX=25, RFCTOL=32, RLIMIT=46, RSPTOL=49, 3866 5 SCTOL=37, SIGMIN=50, TUNER1=26, TUNER2=27, TUNER3=28, 3867 6 TUNER4=29, TUNER5=30, XCTOL=33, XFTOL=34) 3868C 3869C------------------------------- BODY -------------------------------- 3870C 3871 MACHEP = DR7MDC(3) 3872 if (MACHEP .GT. 1.D-10) then 3873 V(AFCTOL) = MACHEP**2 3874 else 3875 V(AFCTOL) = 1.D-20 3876 endif 3877 3878 V(DECFAC) = 0.5D+0 3879 SQTEPS = DR7MDC(4) 3880 V(DFAC) = 0.6D+0 3881 V(DTINIT) = 1.D-6 3882 MEPCRT = MACHEP ** (ONE/THREE) 3883 V(D0INIT) = 1.D+0 3884 V(EPSLON) = 0.1D+0 3885 V(INCFAC) = 2.D+0 3886 V(LMAX0) = 1.D+0 3887 V(LMAXS) = 1.D+0 3888 V(PHMNFC) = -0.1D+0 3889 V(PHMXFC) = 0.1D+0 3890 V(RDFCMN) = 0.1D+0 3891 V(RDFCMX) = 4.D+0 3892 V(RFCTOL) = DMAX1(1.D-10, MEPCRT**2) 3893 V(SCTOL) = V(RFCTOL) 3894 V(TUNER1) = 0.1D+0 3895 V(TUNER2) = 1.D-4 3896 V(TUNER3) = 0.75D+0 3897 V(TUNER4) = 0.5D+0 3898 V(TUNER5) = 0.75D+0 3899 V(XCTOL) = SQTEPS 3900 V(XFTOL) = 1.D+2 * MACHEP 3901C 3902 if (ALG .eq. 1) then 3903C 3904C *** REGRESSION VALUES (nls) 3905C 3906 V(COSMIN) = DMAX1(1.D-6, 1.D+2 * MACHEP) 3907 V(DINIT) = 0.D+0 3908 V(DELTA0) = SQTEPS 3909 V(DLTFDC) = MEPCRT 3910 V(DLTFDJ) = SQTEPS 3911 V(FUZZ) = 1.5D+0 3912 V(RLIMIT) = DR7MDC(5) 3913 V(RSPTOL) = 1.D-3 3914 V(SIGMIN) = 1.D-4 3915 else 3916C 3917C *** GENERAL OPTIMIZATION VALUES (nlminb) 3918C 3919 V(BIAS) = 0.8D+0 3920 V(DINIT) = -1.0D+0 3921 V(ETA0) = 1.0D+3 * MACHEP 3922C 3923 end if 3924C *** LAST CARD OF DV7DFL FOLLOWS *** 3925 END 3926 3927 DOUBLE PRECISION FUNCTION DR7MDC(K) 3928C 3929C *** RETURN MACHINE DEPENDENT CONSTANTS USED BY NL2SOL *** 3930C 3931 INTEGER K 3932C 3933C *** THE CONSTANT RETURNED DEPENDS ON K... 3934C 3935C *** K = 1... SMALLEST POS. ETA SUCH THAT -ETA EXISTS. 3936C *** K = 2... SQUARE ROOT OF ETA. 3937C *** K = 3... UNIT ROUNDOFF = SMALLEST POS. NO. MACHEP SUCH 3938C *** THAT 1 + MACHEP .GT. 1 .AND. 1 - MACHEP .LT. 1. 3939C *** K = 4... SQUARE ROOT OF MACHEP. 3940C *** K = 5... SQUARE ROOT OF BIG (SEE K = 6). 3941C *** K = 6... LARGEST MACHINE NO. BIG SUCH THAT -BIG EXISTS. 3942C 3943 DOUBLE PRECISION BIG, ETA, MACHEP 3944C/+ 3945 DOUBLE PRECISION DSQRT 3946C/ 3947C 3948 DOUBLE PRECISION D1MACH, ZERO 3949 EXTERNAL D1MACH 3950 DATA BIG/0.D+0/, ETA/0.D+0/, MACHEP/0.D+0/, ZERO/0.D+0/ 3951 IF (BIG .GT. ZERO) GO TO 1 3952 BIG = D1MACH(2) 3953 ETA = D1MACH(1) 3954 MACHEP = D1MACH(4) 3955 1 CONTINUE 3956C 3957C------------------------------- BODY -------------------------------- 3958C 3959c GO TO (10, 20, 30, 40, 50, 60), K 3960 select case(K) 3961 case(1) 3962 goto 10 3963 case(2) 3964 goto 20 3965 case(3) 3966 goto 30 3967 case(4) 3968 goto 40 3969 case(5) 3970 goto 50 3971 case(6) 3972 goto 60 3973 end select 3974C 3975 10 DR7MDC = ETA 3976 GO TO 999 3977C 3978 20 DR7MDC = DSQRT(256.D+0*ETA)/16.D+0 3979 GO TO 999 3980C 3981 30 DR7MDC = MACHEP 3982 GO TO 999 3983C 3984 40 DR7MDC = DSQRT(MACHEP) 3985 GO TO 999 3986C 3987 50 DR7MDC = DSQRT(BIG/256.D+0)*16.D+0 3988 GO TO 999 3989C 3990 60 DR7MDC = BIG 3991C 3992 999 RETURN 3993C *** LAST CARD OF DR7MDC FOLLOWS *** 3994 END 3995 SUBROUTINE DG7ITB(B, D, G, IV, LIV, LV, P, PS, V, X, Y) 3996C 3997C *** CARRY OUT NL2SOL-LIKE ITERATIONS FOR GENERALIZED LINEAR *** 3998C *** REGRESSION PROBLEMS (AND OTHERS OF SIMILAR STRUCTURE) *** 3999C *** HAVING SIMPLE BOUNDS ON THE PARAMETERS BEING ESTIMATED. *** 4000C 4001C *** PARAMETER DECLARATIONS *** 4002C 4003 INTEGER LIV, LV, P, PS 4004 INTEGER IV(LIV) 4005 DOUBLE PRECISION B(2,P), D(P), G(P), V(LV), X(P), Y(P) 4006C 4007C-------------------------- PARAMETER USAGE -------------------------- 4008C 4009C B.... VECTOR OF LOWER AND UPPER BOUNDS ON X. 4010C D.... SCALE VECTOR. 4011C IV... INTEGER VALUE ARRAY. 4012C LIV.. LENGTH OF IV. MUST BE AT LEAST 80. 4013C LH... LENGTH OF H = P*(P+1)/2. 4014C LV... LENGTH OF V. MUST BE AT LEAST P*(3*P + 19)/2 + 7. 4015C G.... GRADIENT AT X (WHEN IV(1) = 2). 4016C HC... GAUSS-NEWTON HESSIAN AT X (WHEN IV(1) = 2). 4017C P.... NUMBER OF PARAMETERS (COMPONENTS IN X). 4018C PS... NUMBER OF NONZERO ROWS AND COLUMNS IN S. 4019C V.... FLOATING-POINT VALUE ARRAY. 4020C X.... PARAMETER VECTOR. 4021C Y.... PART OF YIELD VECTOR (WHEN IV(1)= 2, SCRATCH OTHERWISE). 4022C 4023C *** DISCUSSION *** 4024C 4025C DG7ITB IS SIMILAR TO DG7LIT, EXCEPT FOR THE EXTRA PARAMETER B 4026C -- DG7ITB ENFORCES THE BOUNDS B(1,I) .LE. X(I) .LE. B(2,I), 4027C I = 1(1)P. 4028C DG7ITB PERFORMS NL2SOL-LIKE ITERATIONS FOR A VARIETY OF 4029C REGRESSION PROBLEMS THAT ARE SIMILAR TO NONLINEAR LEAST-SQUARES 4030C IN THAT THE HESSIAN IS THE SUM OF TWO TERMS, A READILY-COMPUTED 4031C FIRST-ORDER TERM AND A SECOND-ORDER TERM. THE CALLER SUPPLIES 4032C THE FIRST-ORDER TERM OF THE HESSIAN IN HC (LOWER TRIANGLE, STORED 4033C COMPACTLY BY ROWS), AND DG7ITB BUILDS AN APPROXIMATION, S, TO THE 4034C SECOND-ORDER TERM. THE CALLER ALSO PROVIDES THE FUNCTION VALUE, 4035C GRADIENT, AND PART OF THE YIELD VECTOR USED IN UPDATING S. 4036C DG7ITB DECIDES DYNAMICALLY WHETHER OR NOT TO USE S WHEN CHOOSING 4037C THE NEXT STEP TO TRY... THE HESSIAN APPROXIMATION USED IS EITHER 4038C HC ALONE (GAUSS-NEWTON MODEL) OR HC + S (AUGMENTED MODEL). 4039C IF PS .LT. P, THEN ROWS AND COLUMNS PS+1...P OF S ARE KEPT 4040C CONSTANT. THEY WILL BE ZERO UNLESS THE CALLER SETS IV(INITS) TO 4041C 1 OR 2 AND SUPPLIES NONZERO VALUES FOR THEM, OR THE CALLER SETS 4042C IV(INITS) TO 3 OR 4 AND THE FINITE-DIFFERENCE INITIAL S THEN 4043C COMPUTED HAS NONZERO VALUES IN THESE ROWS. 4044C 4045C IF IV(INITS) IS 3 OR 4, THEN THE INITIAL S IS COMPUTED BY 4046C FINITE DIFFERENCES. 3 MEANS USE FUNCTION DIFFERENCES, 4 MEANS 4047C USE GRADIENT DIFFERENCES. FINITE DIFFERENCING IS DONE THE SAME 4048C WAY AS IN COMPUTING A COVARIANCE MATRIX (WITH IV(COVREQ) = -1, -2, 4049C 1, OR 2). 4050C 4051C FOR UPDATING S, DG7ITB ASSUMES THAT THE GRADIENT HAS THE FORM 4052C OF A SUM OVER I OF RHO(I,X)*GRAD(R(I,X)), WHERE GRAD DENOTES THE 4053C GRADIENT WITH RESPECT TO X. THE TRUE SECOND-ORDER TERM THEN IS 4054C THE SUM OVER I OF RHO(I,X)*HESSIAN(R(I,X)). IF X = X0 + STEP, 4055C THEN WE WISH TO UPDATE S SO THAT S*STEP IS THE SUM OVER I OF 4056C RHO(I,X)*(GRAD(R(I,X)) - GRAD(R(I,X0))). THE CALLER MUST SUPPLY 4057C PART OF THIS IN Y, NAMELY THE SUM OVER I OF 4058C RHO(I,X)*GRAD(R(I,X0)), WHEN CALLING DG7ITB WITH IV(1) = 2 AND 4059C IV(MODE) = 0 (WHERE MODE = 38). G THEN CONTANS THE OTHER PART, 4060C SO THAT THE DESIRED YIELD VECTOR IS G - Y. IF PS .LT. P, THEN 4061C THE ABOVE DISCUSSION APPLIES ONLY TO THE FIRST PS COMPONENTS OF 4062C GRAD(R(I,X)), STEP, AND Y. 4063C 4064C PARAMETERS IV, P, V, AND X ARE THE SAME AS THE CORRESPONDING 4065C ONES TO DN2GB (AND NL2SOL), EXCEPT THAT V CAN BE SHORTER 4066C (SINCE THE PART OF V THAT DN2GB USES FOR STORING D, J, AND R IS 4067C NOT NEEDED). MOREOVER, COMPARED WITH DN2GB (AND NL2SOL), IV(1) 4068C MAY HAVE THE TWO ADDITIONAL OUTPUT VALUES 1 AND 2, WHICH ARE 4069C EXPLAINED BELOW, AS IS THE USE OF IV(TOOBIG) AND IV(NFGCAL). 4070C THE VALUES IV(D), IV(J), AND IV(R), WHICH ARE OUTPUT VALUES FROM 4071C DN2GB (AND DN2FB), ARE NOT REFERENCED BY DG7ITB OR THE 4072C SUBROUTINES IT CALLS. 4073C 4074C WHEN DG7ITB IS FIRST CALLED, I.E., WHEN DG7ITB IS CALLED WITH 4075C IV(1) = 0 OR 12, V(F), G, AND HC NEED NOT BE INITIALIZED. TO 4076C OBTAIN THESE STARTING VALUES, DG7ITB RETURNS FIRST WITH IV(1) = 1, 4077C THEN WITH IV(1) = 2, WITH IV(MODE) = -1 IN BOTH CASES. ON 4078C SUBSEQUENT RETURNS WITH IV(1) = 2, IV(MODE) = 0 IMPLIES THAT 4079C Y MUST ALSO BE SUPPLIED. (NOTE THAT Y IS USED FOR SCRATCH -- ITS 4080C INPUT CONTENTS ARE LOST. BY CONTRAST, HC IS NEVER CHANGED.) 4081C ONCE CONVERGENCE HAS BEEN OBTAINED, IV(RDREQ) AND IV(COVREQ) MAY 4082C IMPLY THAT A FINITE-DIFFERENCE HESSIAN SHOULD BE COMPUTED FOR USE 4083C IN COMPUTING A COVARIANCE MATRIX. IN THIS CASE DG7ITB WILL MAKE 4084C A NUMBER OF RETURNS WITH IV(1) = 1 OR 2 AND IV(MODE) POSITIVE. 4085C WHEN IV(MODE) IS POSITIVE, Y SHOULD NOT BE CHANGED. 4086C 4087C IV(1) = 1 MEANS THE CALLER SHOULD SET V(F) (I.E., V(10)) TO F(X), THE 4088C FUNCTION VALUE AT X, AND CALL DG7ITB AGAIN, HAVING CHANGED 4089C NONE OF THE OTHER PARAMETERS. AN EXCEPTION OCCURS IF F(X) 4090C CANNOT BE EVALUATED (E.G. IF OVERFLOW WOULD OCCUR), WHICH 4091C MAY HAPPEN BECAUSE OF AN OVERSIZED STEP. IN THIS CASE 4092C THE CALLER SHOULD SET IV(TOOBIG) = IV(2) TO 1, WHICH WILL 4093C CAUSE DG7ITB TO IGNORE V(F) AND TRY A SMALLER STEP. NOTE 4094C THAT THE CURRENT FUNCTION EVALUATION COUNT IS AVAILABLE 4095C IN IV(NFCALL) = IV(6). THIS MAY BE USED TO IDENTIFY 4096C WHICH COPY OF SAVED INFORMATION SHOULD BE USED IN COM- 4097C PUTING G, HC, AND Y THE NEXT TIME DG7ITB RETURNS WITH 4098C IV(1) = 2. SEE MLPIT FOR AN EXAMPLE OF THIS. 4099C IV(1) = 2 MEANS THE CALLER SHOULD SET G TO G(X), THE GRADIENT OF F AT 4100C X. THE CALLER SHOULD ALSO SET HC TO THE GAUSS-NEWTON 4101C HESSIAN AT X. IF IV(MODE) = 0, THEN THE CALLER SHOULD 4102C ALSO COMPUTE THE PART OF THE YIELD VECTOR DESCRIBED ABOVE. 4103C THE CALLER SHOULD THEN CALL DG7ITB AGAIN (WITH IV(1) = 2). 4104C THE CALLER MAY ALSO CHANGE D AT THIS TIME, BUT SHOULD NOT 4105C CHANGE X. NOTE THAT IV(NFGCAL) = IV(7) CONTAINS THE 4106C VALUE THAT IV(NFCALL) HAD DURING THE RETURN WITH 4107C IV(1) = 1 IN WHICH X HAD THE SAME VALUE AS IT NOW HAS. 4108C IV(NFGCAL) IS EITHER IV(NFCALL) OR IV(NFCALL) - 1. MLPIT 4109C IS AN EXAMPLE WHERE THIS INFORMATION IS USED. IF G OR HC 4110C CANNOT BE EVALUATED AT X, THEN THE CALLER MAY SET 4111C IV(NFGCAL) TO 0, IN WHICH CASE DG7ITB WILL RETURN WITH 4112C IV(1) = 15. 4113C 4114C *** GENERAL *** 4115C 4116C CODED BY DAVID M. GAY. 4117C 4118C (SEE NL2SOL FOR REFERENCES.) 4119C 4120C+++++++++++++++++++++++++++ DECLARATIONS ++++++++++++++++++++++++++++ 4121C 4122C *** LOCAL VARIABLES *** 4123C 4124 LOGICAL HAVQTR, HAVRM 4125 INTEGER DIG1, G01, H1, HC1, I, I1, IPI, IPIV0, IPIV1, 4126 1 IPIV2, IPN, J, K, L, LMAT1, LSTGST, P1, P1LEN, PP1, PP1O2, 4127 2 QTR1, RMAT1, RSTRST, STEP1, STPMOD, S1, TD1, TEMP1, TEMP2, 4128 3 TG1, W1, WLM1, X01 4129 DOUBLE PRECISION E, GI, STTSST, T, T1, XI 4130C 4131C *** CONSTANTS *** 4132C 4133 DOUBLE PRECISION HALF, NEGONE, ONE, ONEP2, ZERO 4134C 4135C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 4136C 4137 LOGICAL STOPX 4138 DOUBLE PRECISION DD7TPR, DRLDST, DV2NRM 4139 EXTERNAL DA7SST, DD7TPR, DF7DHB, DG7QSB,I7COPY, I7PNVR, I7SHFT, 4140 1 DITSUM, DL7MSB, DL7SQR, DL7TVM,DL7VML,DPARCK, DQ7RSH, 4141 2 DRLDST, DS7DMP, DS7IPR, DS7LUP, DS7LVM, STOPX, DV2NRM, 4142 3 DV2AXY,DV7CPY, DV7IPR, DV7SCP, DV7VMP 4143C 4144C DA7SST.... ASSESSES CANDIDATE STEP. 4145C DD7TPR... RETURNS INNER PRODUCT OF TWO VECTORS. 4146C DF7DHB... COMPUTE FINITE-DIFFERENCE HESSIAN (FOR INIT. S MATRIX). 4147C DG7QSB... COMPUTES GOLDFELD-QUANDT-TROTTER STEP (AUGMENTED MODEL). 4148C I7COPY.... COPIES ONE INTEGER VECTOR TO ANOTHER. 4149C I7PNVR... INVERTS PERMUTATION ARRAY. 4150C I7SHFT... SHIFTS AN INTEGER VECTOR. 4151C DITSUM.... PRINTS ITERATION SUMMARY AND INFO ON INITIAL AND FINAL X. 4152C DL7MSB... COMPUTES LEVENBERG-MARQUARDT STEP (GAUSS-NEWTON MODEL). 4153C DL7SQR... COMPUTES L * L**T FROM LOWER TRIANGULAR MATRIX L. 4154C DL7TVM... COMPUTES L**T * V, V = VECTOR, L = LOWER TRIANGULAR MATRIX. 4155C DL7VML.... COMPUTES L * V, V = VECTOR, L = LOWER TRIANGULAR MATRIX. 4156C DPARCK.... CHECK VALIDITY OF IV AND V INPUT COMPONENTS. 4157C DQ7RSH... SHIFTS A QR FACTORIZATION. 4158C DRLDST... COMPUTES V(RELDX) = RELATIVE STEP SIZE. 4159C DS7DMP... MULTIPLIES A SYM. MATRIX FORE AND AFT BY A DIAG. MATRIX. 4160C DS7IPR... APPLIES PERMUTATION TO (LOWER TRIANG. OF) SYM. MATRIX. 4161C DS7LUP... PERFORMS QUASI-NEWTON UPDATE ON COMPACTLY STORED LOWER TRI- 4162C ANGLE OF A SYMMETRIC MATRIX. 4163C DS7LVM... MULTIPLIES COMPACTLY STORED SYM. MATRIX TIMES VECTOR. 4164C STOPX.... RETURNS .TRUE. IF THE BREAK KEY HAS BEEN PRESSED. 4165C DV2NRM... RETURNS THE 2-NORM OF A VECTOR. 4166C DV2AXY.... COMPUTES SCALAR TIMES ONE VECTOR PLUS ANOTHER. 4167C DV7CPY.... COPIES ONE VECTOR TO ANOTHER. 4168C DV7IPR... APPLIES A PERMUTATION TO A VECTOR. 4169C DV7SCP... SETS ALL ELEMENTS OF A VECTOR TO A SCALAR. 4170C DV7VMP... MULTIPLIES (DIVIDES) VECTORS COMPONENTWISE. 4171C 4172C *** SUBSCRIPTS FOR IV AND V *** 4173C 4174 INTEGER CNVCOD, COSMIN, COVMAT, COVREQ, DGNORM, DIG, 4175 1 DSTNRM, F, FDH, FDIF, FUZZ, F0, GTSTEP, H, HC, IERR, 4176 2 INCFAC, INITS, IPIVOT, IRC, IVNEED, KAGQT, KALM, LMAT, 4177 3 LMAX0, LMAXS, MODE, MODEL, MXFCAL, MXITER, NEXTIV, NEXTV, 4178 4 NFCALL, NFGCAL, NFCOV, NGCOV, NGCALL, NITER, NVSAVE, P0, 4179 5 PC, PERM, PHMXFC, PREDUC, QTR, RADFAC, RADINC, RADIUS, 4180 6 RAD0, RDREQ, REGD, RELDX, RESTOR, RMAT, S, SIZE, STEP, 4181 7 STGLIM, STPPAR, SUSED, SWITCH, TOOBIG, TUNER4, TUNER5, 4182 8 VNEED, VSAVE, W, WSCALE, XIRC, X0 4183C 4184C *** IV SUBSCRIPT VALUES *** 4185C 4186C *** (NOTE THAT P0 AND PC ARE STORED IN IV(G0) AND IV(STLSTG) RESP.) 4187C 4188 PARAMETER (CNVCOD=55, COVMAT=26, COVREQ=15, DIG=37, FDH=74, H=56, 4189 1 HC=71, IERR=75, INITS=25, IPIVOT=76, IRC=29, IVNEED=3, 4190 2 KAGQT=33, KALM=34, LMAT=42, MODE=35, MODEL=5, 4191 3 MXFCAL=17, MXITER=18, NEXTIV=46, NEXTV=47, NFCALL=6, 4192 4 NFGCAL=7, NFCOV=52, NGCOV=53, NGCALL=30, NITER=31, 4193 5 P0=48, PC=41, PERM=58, QTR=77, RADINC=8, RDREQ=57, 4194 6 REGD=67, RESTOR=9, RMAT=78, S=62, STEP=40, STGLIM=11, 4195 7 SUSED=64, SWITCH=12, TOOBIG=2, VNEED=4, VSAVE=60, W=65, 4196 8 XIRC=13, X0=43) 4197C 4198C *** V SUBSCRIPT VALUES *** 4199C 4200 PARAMETER (COSMIN=47, DGNORM=1, DSTNRM=2, F=10, FDIF=11, FUZZ=45, 4201 1 F0=13, GTSTEP=4, INCFAC=23, LMAX0=35, LMAXS=36, 4202 2 NVSAVE=9, PHMXFC=21, PREDUC=7, RADFAC=16, RADIUS=8, 4203 3 RAD0=9, RELDX=17, SIZE=55, STPPAR=5, TUNER4=29, 4204 4 TUNER5=30, WSCALE=56) 4205C 4206C 4207 PARAMETER (HALF=0.5D+0, NEGONE=-1.D+0, ONE=1.D+0, ONEP2=1.2D+0, 4208 1 ZERO=0.D+0) 4209C 4210C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 4211C 4212 I = IV(1) 4213 IF (I .EQ. 1) GO TO 50 4214 IF (I .EQ. 2) GO TO 60 4215C 4216 IF (I .LT. 12) GO TO 10 4217 IF (I .GT. 13) GO TO 10 4218 IV(VNEED) = IV(VNEED) + P*(3*P + 25)/2 + 7 4219 IV(IVNEED) = IV(IVNEED) + 4*P 4220 10 CALL DPARCK(1, D, IV, LIV, LV, P, V) 4221 I = IV(1) - 2 4222 IF (I .GT. 12) GO TO 999 4223c GO TO (360, 360, 360, 360, 360, 360, 240, 190, 240, 20, 20, 30), I 4224 select case(I) 4225 case(1:6) 4226 goto 360 4227 case(7,9) 4228 goto 240 4229 case(8) 4230 goto 190 4231 case(10,11) 4232 goto 20 4233 case(12) 4234 goto 30 4235 end select 4236C 4237C *** STORAGE ALLOCATION *** 4238C 4239 20 PP1O2 = P * (P + 1) / 2 4240 IV(S) = IV(LMAT) + PP1O2 4241 IV(X0) = IV(S) + PP1O2 4242 IV(STEP) = IV(X0) + 2*P 4243 IV(DIG) = IV(STEP) + 3*P 4244 IV(W) = IV(DIG) + 2*P 4245 IV(H) = IV(W) + 4*P + 7 4246 IV(NEXTV) = IV(H) + PP1O2 4247 IV(IPIVOT) = IV(PERM) + 3*P 4248 IV(NEXTIV) = IV(IPIVOT) + P 4249 IF (IV(1) .NE. 13) GO TO 30 4250 IV(1) = 14 4251 GO TO 999 4252C 4253C *** INITIALIZATION *** 4254C 4255 30 IV(NITER) = 0 4256 IV(NFCALL) = 1 4257 IV(NGCALL) = 1 4258 IV(NFGCAL) = 1 4259 IV(MODE) = -1 4260 IV(STGLIM) = 2 4261 IV(TOOBIG) = 0 4262 IV(CNVCOD) = 0 4263 IV(COVMAT) = 0 4264 IV(NFCOV) = 0 4265 IV(NGCOV) = 0 4266 IV(RADINC) = 0 4267 IV(PC) = P 4268 V(RAD0) = ZERO 4269 V(STPPAR) = ZERO 4270 V(RADIUS) = V(LMAX0) / (ONE + V(PHMXFC)) 4271C 4272C *** CHECK CONSISTENCY OF B AND INITIALIZE IP ARRAY *** 4273C 4274 IPI = IV(IPIVOT) 4275 DO 40 I = 1, P 4276 IV(IPI) = I 4277 IPI = IPI + 1 4278 IF (B(1,I) .GT. B(2,I)) GO TO 680 4279 40 CONTINUE 4280C 4281C *** SET INITIAL MODEL AND S MATRIX *** 4282C 4283 IV(MODEL) = 1 4284 IV(1) = 1 4285 IF (IV(S) .LT. 0) GO TO 710 4286 IF (IV(INITS) .GT. 1) IV(MODEL) = 2 4287 S1 = IV(S) 4288 IF (IV(INITS) .EQ. 0 .OR. IV(INITS) .GT. 2) 4289 1 CALL DV7SCP(P*(P+1)/2, V(S1), ZERO) 4290 GO TO 710 4291C 4292C *** NEW FUNCTION VALUE *** 4293C 4294 50 IF (IV(MODE) .EQ. 0) GO TO 360 4295 IF (IV(MODE) .GT. 0) GO TO 590 4296C 4297 IF (IV(TOOBIG) .EQ. 0) GO TO 690 4298 IV(1) = 63 4299 GO TO 999 4300C 4301C *** MAKE SURE GRADIENT COULD BE COMPUTED *** 4302C 4303 60 IF (IV(TOOBIG) .EQ. 0) GO TO 70 4304 IV(1) = 65 4305 GO TO 999 4306C 4307C *** NEW GRADIENT *** 4308C 4309 70 IV(KALM) = -1 4310 IV(KAGQT) = -1 4311 IV(FDH) = 0 4312 IF (IV(MODE) .GT. 0) GO TO 590 4313 IF (IV(HC) .LE. 0 .AND. IV(RMAT) .LE. 0) GO TO 670 4314C 4315C *** CHOOSE INITIAL PERMUTATION *** 4316C 4317 IPI = IV(IPIVOT) 4318 IPN = IPI + P - 1 4319 IPIV2 = IV(PERM) - 1 4320 K = IV(PC) 4321 P1 = P 4322 PP1 = P + 1 4323 RMAT1 = IV(RMAT) 4324 HAVRM = RMAT1 .GT. 0 4325 QTR1 = IV(QTR) 4326 HAVQTR = QTR1 .GT. 0 4327C *** MAKE SURE V(QTR1) IS LEGAL (EVEN WHEN NOT REFERENCED) *** 4328 W1 = IV(W) 4329 IF (.NOT. HAVQTR) QTR1 = W1 + P 4330C 4331 DO 100 I = 1, P 4332 I1 = IV(IPN) 4333 IPN = IPN - 1 4334 IF (B(1,I1) .GE. B(2,I1)) GO TO 80 4335 XI = X(I1) 4336 GI = G(I1) 4337 IF (XI .LE. B(1,I1) .AND. GI .GT. ZERO) GO TO 80 4338 IF (XI .GE. B(2,I1) .AND. GI .LT. ZERO) GO TO 80 4339C *** DISALLOW CONVERGENCE IF X(I1) HAS JUST BEEN FREED *** 4340 J = IPIV2 + I1 4341 IF (IV(J) .GT. K) IV(CNVCOD) = 0 4342 GO TO 100 4343 80 IF (I1 .GE. P1) GO TO 90 4344 I1 = PP1 - I 4345 CALL I7SHFT(P1, I1, IV(IPI)) 4346 IF (HAVRM) 4347 1 CALL DQ7RSH(I1, P1, HAVQTR, V(QTR1), V(RMAT1), V(W1)) 4348 90 P1 = P1 - 1 4349 100 CONTINUE 4350 IV(PC) = P1 4351C 4352C *** COMPUTE V(DGNORM) (AN OUTPUT VALUE IF WE STOP NOW) *** 4353C 4354 V(DGNORM) = ZERO 4355 IF (P1 .LE. 0) GO TO 110 4356 DIG1 = IV(DIG) 4357 CALL DV7VMP(P, V(DIG1), G, D, -1) 4358 CALL DV7IPR(P, IV(IPI), V(DIG1)) 4359 V(DGNORM) = DV2NRM(P1, V(DIG1)) 4360 110 IF (IV(CNVCOD) .NE. 0) GO TO 580 4361 IF (IV(MODE) .EQ. 0) GO TO 510 4362 IV(MODE) = 0 4363 V(F0) = V(F) 4364 IF (IV(INITS) .LE. 2) GO TO 170 4365C 4366C *** ARRANGE FOR FINITE-DIFFERENCE INITIAL S *** 4367C 4368 IV(XIRC) = IV(COVREQ) 4369 IV(COVREQ) = -1 4370 IF (IV(INITS) .GT. 3) IV(COVREQ) = 1 4371 IV(CNVCOD) = 70 4372 GO TO 600 4373C 4374C *** COME TO NEXT STMT AFTER COMPUTING F.D. HESSIAN FOR INIT. S *** 4375C 4376 120 H1 = IV(FDH) 4377 IF (H1 .LE. 0) GO TO 660 4378 IV(CNVCOD) = 0 4379 IV(MODE) = 0 4380 IV(NFCOV) = 0 4381 IV(NGCOV) = 0 4382 IV(COVREQ) = IV(XIRC) 4383 S1 = IV(S) 4384 PP1O2 = PS * (PS + 1) / 2 4385 HC1 = IV(HC) 4386 IF (HC1 .LE. 0) GO TO 130 4387 CALL DV2AXY(PP1O2, V(S1), NEGONE, V(HC1), V(H1)) 4388 GO TO 140 4389 130 RMAT1 = IV(RMAT) 4390 LMAT1 = IV(LMAT) 4391 CALL DL7SQR(P, V(LMAT1), V(RMAT1)) 4392 IPI = IV(IPIVOT) 4393 IPIV1 = IV(PERM) + P 4394 CALL I7PNVR(P, IV(IPIV1), IV(IPI)) 4395 CALL DS7IPR(P, IV(IPIV1), V(LMAT1)) 4396 CALL DV2AXY(PP1O2, V(S1), NEGONE, V(LMAT1), V(H1)) 4397C 4398C *** ZERO PORTION OF S CORRESPONDING TO FIXED X COMPONENTS *** 4399C 4400 140 DO 160 I = 1, P 4401 IF (B(1,I) .LT. B(2,I)) GO TO 160 4402 K = S1 + I*(I-1)/2 4403 CALL DV7SCP(I, V(K), ZERO) 4404 IF (I .GE. P) GO TO 170 4405 K = K + 2*I - 1 4406 I1 = I + 1 4407 DO 150 J = I1, P 4408 V(K) = ZERO 4409 K = K + J 4410 150 CONTINUE 4411 160 CONTINUE 4412C 4413 170 IV(1) = 2 4414C 4415C 4416C----------------------------- MAIN LOOP ----------------------------- 4417C 4418C 4419C *** PRINT ITERATION SUMMARY, CHECK ITERATION LIMIT *** 4420C 4421 180 CALL DITSUM(D, G, IV, LIV, LV, P, V, X) 4422 190 K = IV(NITER) 4423 IF (K .LT. IV(MXITER)) GO TO 200 4424 IV(1) = 10 4425 GO TO 999 4426 200 IV(NITER) = K + 1 4427C 4428C *** UPDATE RADIUS *** 4429C 4430 IF (K .EQ. 0) GO TO 220 4431 STEP1 = IV(STEP) 4432 DO 210 I = 1, P 4433 V(STEP1) = D(I) * V(STEP1) 4434 STEP1 = STEP1 + 1 4435 210 CONTINUE 4436 STEP1 = IV(STEP) 4437 T = V(RADFAC) * DV2NRM(P, V(STEP1)) 4438 IF (V(RADFAC) .LT. ONE .OR. T .GT. V(RADIUS)) V(RADIUS) = T 4439C 4440C *** INITIALIZE FOR START OF NEXT ITERATION *** 4441C 4442 220 X01 = IV(X0) 4443 V(F0) = V(F) 4444 IV(IRC) = 4 4445 IV(H) = -IABS(IV(H)) 4446 IV(SUSED) = IV(MODEL) 4447C 4448C *** COPY X TO X0 *** 4449C 4450 CALL DV7CPY(P, V(X01), X) 4451C 4452C *** CHECK STOPX AND FUNCTION EVALUATION LIMIT *** 4453C 4454 230 IF (.NOT. STOPX()) GO TO 250 4455 IV(1) = 11 4456 GO TO 260 4457C 4458C *** COME HERE WHEN RESTARTING AFTER FUNC. EVAL. LIMIT OR STOPX. 4459C 4460 240 IF (V(F) .GE. V(F0)) GO TO 250 4461 V(RADFAC) = ONE 4462 K = IV(NITER) 4463 GO TO 200 4464C 4465 250 IF (IV(NFCALL) .LT. IV(MXFCAL) + IV(NFCOV)) GO TO 270 4466 IV(1) = 9 4467 260 IF (V(F) .GE. V(F0)) GO TO 999 4468C 4469C *** IN CASE OF STOPX OR FUNCTION EVALUATION LIMIT WITH 4470C *** IMPROVED V(F), EVALUATE THE GRADIENT AT X. 4471C 4472 IV(CNVCOD) = IV(1) 4473 GO TO 500 4474C 4475C. . . . . . . . . . . . . COMPUTE CANDIDATE STEP . . . . . . . . . . 4476C 4477 270 STEP1 = IV(STEP) 4478 TG1 = IV(DIG) 4479 TD1 = TG1 + P 4480 X01 = IV(X0) 4481 W1 = IV(W) 4482 H1 = IV(H) 4483 P1 = IV(PC) 4484 IPI = IV(PERM) 4485 IPIV1 = IPI + P 4486 IPIV2 = IPIV1 + P 4487 IPIV0 = IV(IPIVOT) 4488 IF (IV(MODEL) .EQ. 2) GO TO 280 4489C 4490C *** COMPUTE LEVENBERG-MARQUARDT STEP IF POSSIBLE... 4491C 4492 RMAT1 = IV(RMAT) 4493 IF (RMAT1 .LE. 0) GO TO 280 4494 QTR1 = IV(QTR) 4495 IF (QTR1 .LE. 0) GO TO 280 4496 LMAT1 = IV(LMAT) 4497 WLM1 = W1 + P 4498 CALL DL7MSB(B, D, G, IV(IERR), IV(IPIV0), IV(IPIV1), 4499 1 IV(IPIV2), IV(KALM), V(LMAT1), LV, P, IV(P0), 4500 2 IV(PC), V(QTR1), V(RMAT1), V(STEP1), V(TD1), 4501 3 V(TG1), V, V(W1), V(WLM1), X, V(X01)) 4502C *** H IS STORED IN THE END OF W AND HAS JUST BEEN OVERWRITTEN, 4503C *** SO WE MARK IT INVALID... 4504 IV(H) = -IABS(H1) 4505C *** EVEN IF H WERE STORED ELSEWHERE, IT WOULD BE NECESSARY TO 4506C *** MARK INVALID THE INFORMATION DG7QTS MAY HAVE STORED IN V... 4507 IV(KAGQT) = -1 4508 GO TO 330 4509C 4510 280 IF (H1 .GT. 0) GO TO 320 4511C 4512C *** SET H TO D**-1 * (HC + T1*S) * D**-1. *** 4513C 4514 P1LEN = P1*(P1+1)/2 4515 H1 = -H1 4516 IV(H) = H1 4517 IV(FDH) = 0 4518 IF (P1 .LE. 0) GO TO 320 4519C *** MAKE TEMPORARY PERMUTATION ARRAY *** 4520 CALL I7COPY(P, IV(IPI), IV(IPIV0)) 4521 J = IV(HC) 4522 IF (J .GT. 0) GO TO 290 4523 J = H1 4524 RMAT1 = IV(RMAT) 4525 CALL DL7SQR(P1, V(H1), V(RMAT1)) 4526 GO TO 300 4527 290 CALL DV7CPY(P*(P+1)/2, V(H1), V(J)) 4528 CALL DS7IPR(P, IV(IPI), V(H1)) 4529 300 IF (IV(MODEL) .EQ. 1) GO TO 310 4530 LMAT1 = IV(LMAT) 4531 S1 = IV(S) 4532 CALL DV7CPY(P*(P+1)/2, V(LMAT1), V(S1)) 4533 CALL DS7IPR(P, IV(IPI), V(LMAT1)) 4534 CALL DV2AXY(P1LEN, V(H1), ONE, V(LMAT1), V(H1)) 4535 310 CALL DV7CPY(P, V(TD1), D) 4536 CALL DV7IPR(P, IV(IPI), V(TD1)) 4537 CALL DS7DMP(P1, V(H1), V(H1), V(TD1), -1) 4538 IV(KAGQT) = -1 4539C 4540C *** COMPUTE ACTUAL GOLDFELD-QUANDT-TROTTER STEP *** 4541C 4542 320 LMAT1 = IV(LMAT) 4543 CALL DG7QSB(B, D, V(H1), G, IV(IPI), IV(IPIV1), IV(IPIV2), 4544 1 IV(KAGQT), V(LMAT1), LV, P, IV(P0), P1, V(STEP1), 4545 2 V(TD1), V(TG1), V, V(W1), X, V(X01)) 4546 IF (IV(KALM) .GT. 0) IV(KALM) = 0 4547C 4548 330 IF (IV(IRC) .NE. 6) GO TO 340 4549 IF (IV(RESTOR) .NE. 2) GO TO 360 4550 RSTRST = 2 4551 GO TO 370 4552C 4553C *** CHECK WHETHER EVALUATING F(X0 + STEP) LOOKS WORTHWHILE *** 4554C 4555 340 IV(TOOBIG) = 0 4556 IF (V(DSTNRM) .LE. ZERO) GO TO 360 4557 IF (IV(IRC) .NE. 5) GO TO 350 4558 IF (V(RADFAC) .LE. ONE) GO TO 350 4559 IF (V(PREDUC) .GT. ONEP2 * V(FDIF)) GO TO 350 4560 STEP1 = IV(STEP) 4561 X01 = IV(X0) 4562 CALL DV2AXY(P, V(STEP1), NEGONE, V(X01), X) 4563 IF (IV(RESTOR) .NE. 2) GO TO 360 4564 RSTRST = 0 4565 GO TO 370 4566C 4567C *** COMPUTE F(X0 + STEP) *** 4568C 4569 350 X01 = IV(X0) 4570 STEP1 = IV(STEP) 4571 CALL DV2AXY(P, X, ONE, V(STEP1), V(X01)) 4572 IV(NFCALL) = IV(NFCALL) + 1 4573 IV(1) = 1 4574 GO TO 710 4575C 4576C. . . . . . . . . . . . . ASSESS CANDIDATE STEP . . . . . . . . . . . 4577C 4578 360 RSTRST = 3 4579 370 X01 = IV(X0) 4580 V(RELDX) = DRLDST(P, D, X, V(X01)) 4581 CALL DA7SST(IV, LIV, LV, V) 4582 STEP1 = IV(STEP) 4583 LSTGST = X01 + P 4584 I = IV(RESTOR) + 1 4585c GO TO (410, 380, 390, 400), I 4586 select case(I) 4587 case(1) 4588 goto 410 4589 case(2) 4590 goto 380 4591 case(3) 4592 goto 390 4593 case(4) 4594 goto 400 4595 end select 4596 380 CALL DV7CPY(P, X, V(X01)) 4597 GO TO 410 4598 390 CALL DV7CPY(P, V(LSTGST), V(STEP1)) 4599 GO TO 410 4600 400 CALL DV7CPY(P, V(STEP1), V(LSTGST)) 4601 CALL DV2AXY(P, X, ONE, V(STEP1), V(X01)) 4602 V(RELDX) = DRLDST(P, D, X, V(X01)) 4603 IV(RESTOR) = RSTRST 4604C 4605C *** IF NECESSARY, SWITCH MODELS *** 4606C 4607 410 IF (IV(SWITCH) .EQ. 0) GO TO 420 4608 IV(H) = -IABS(IV(H)) 4609 IV(SUSED) = IV(SUSED) + 2 4610 L = IV(VSAVE) 4611 CALL DV7CPY(NVSAVE, V, V(L)) 4612 420 L = IV(IRC) - 4 4613 STPMOD = IV(MODEL) 4614 IF (L .GT. 0) THEN 4615c GO TO (440,450,460,460,460,460,460,460,570,510), L 4616 select case(L) 4617 case(1) 4618 goto 440 4619 case(2) 4620 goto 450 4621 case(3:8) 4622 goto 460 4623 case(9) 4624 goto 570 4625 case(10) 4626 goto 510 4627 end select 4628 END IF 4629C 4630C *** DECIDE WHETHER TO CHANGE MODELS *** 4631C 4632 E = V(PREDUC) - V(FDIF) 4633 S1 = IV(S) 4634 CALL DS7LVM(PS, Y, V(S1), V(STEP1)) 4635 STTSST = HALF * DD7TPR(PS, V(STEP1), Y) 4636 IF (IV(MODEL) .EQ. 1) STTSST = -STTSST 4637 IF (DABS(E + STTSST) * V(FUZZ) .GE. DABS(E)) GO TO 430 4638C 4639C *** SWITCH MODELS *** 4640C 4641 IV(MODEL) = 3 - IV(MODEL) 4642 IF (-2 .LT. L) GO TO 470 4643 IV(H) = -IABS(IV(H)) 4644 IV(SUSED) = IV(SUSED) + 2 4645 L = IV(VSAVE) 4646 CALL DV7CPY(NVSAVE, V(L), V) 4647 GO TO 230 4648C 4649 430 IF (-3 .LT. L) GO TO 470 4650C 4651C *** RECOMPUTE STEP WITH DIFFERENT RADIUS *** 4652C 4653 440 V(RADIUS) = V(RADFAC) * V(DSTNRM) 4654 GO TO 230 4655C 4656C *** COMPUTE STEP OF LENGTH V(LMAXS) FOR SINGULAR CONVERGENCE TEST 4657C 4658 450 V(RADIUS) = V(LMAXS) 4659 GO TO 270 4660C 4661C *** CONVERGENCE OR FALSE CONVERGENCE *** 4662C 4663 460 IV(CNVCOD) = L 4664 IF (V(F) .GE. V(F0)) GO TO 580 4665 IF (IV(XIRC) .EQ. 14) GO TO 580 4666 IV(XIRC) = 14 4667C 4668C. . . . . . . . . . . . PROCESS ACCEPTABLE STEP . . . . . . . . . . . 4669C 4670 470 IV(COVMAT) = 0 4671 IV(REGD) = 0 4672C 4673C *** SEE WHETHER TO SET V(RADFAC) BY GRADIENT TESTS *** 4674C 4675 IF (IV(IRC) .NE. 3) GO TO 500 4676 STEP1 = IV(STEP) 4677 TEMP1 = STEP1 + P 4678 TEMP2 = IV(X0) 4679C 4680C *** SET TEMP1 = HESSIAN * STEP FOR USE IN GRADIENT TESTS *** 4681C 4682 HC1 = IV(HC) 4683 IF (HC1 .LE. 0) GO TO 480 4684 CALL DS7LVM(P, V(TEMP1), V(HC1), V(STEP1)) 4685 GO TO 490 4686 480 RMAT1 = IV(RMAT) 4687 IPIV0 = IV(IPIVOT) 4688 CALL DV7CPY(P, V(TEMP1), V(STEP1)) 4689 CALL DV7IPR(P, IV(IPIV0), V(TEMP1)) 4690 CALL DL7TVM(P, V(TEMP1), V(RMAT1), V(TEMP1)) 4691 CALL DL7VML(P, V(TEMP1), V(RMAT1), V(TEMP1)) 4692 IPIV1 = IV(PERM) + P 4693 CALL I7PNVR(P, IV(IPIV1), IV(IPIV0)) 4694 CALL DV7IPR(P, IV(IPIV1), V(TEMP1)) 4695C 4696 490 IF (STPMOD .EQ. 1) GO TO 500 4697 S1 = IV(S) 4698 CALL DS7LVM(PS, V(TEMP2), V(S1), V(STEP1)) 4699 CALL DV2AXY(PS, V(TEMP1), ONE, V(TEMP2), V(TEMP1)) 4700C 4701C *** SAVE OLD GRADIENT AND COMPUTE NEW ONE *** 4702C 4703 500 IV(NGCALL) = IV(NGCALL) + 1 4704 G01 = IV(W) 4705 CALL DV7CPY(P, V(G01), G) 4706 GO TO 690 4707C 4708C *** INITIALIZATIONS -- G0 = G - G0, ETC. *** 4709C 4710 510 G01 = IV(W) 4711 CALL DV2AXY(P, V(G01), NEGONE, V(G01), G) 4712 STEP1 = IV(STEP) 4713 TEMP1 = STEP1 + P 4714 TEMP2 = IV(X0) 4715 IF (IV(IRC) .NE. 3) GO TO 540 4716C 4717C *** SET V(RADFAC) BY GRADIENT TESTS *** 4718C 4719C *** SET TEMP1 = D**-1 * (HESSIAN * STEP + (G(X0) - G(X))) *** 4720C 4721 K = TEMP1 4722 L = G01 4723 DO 520 I = 1, P 4724 V(K) = (V(K) - V(L)) / D(I) 4725 K = K + 1 4726 L = L + 1 4727 520 CONTINUE 4728C 4729C *** DO GRADIENT TESTS *** 4730C 4731 IF (DV2NRM(P, V(TEMP1)) .LE. V(DGNORM) * V(TUNER4)) GO TO 530 4732 IF (DD7TPR(P, G, V(STEP1)) 4733 1 .GE. V(GTSTEP) * V(TUNER5)) GO TO 540 4734 530 V(RADFAC) = V(INCFAC) 4735C 4736C *** COMPUTE Y VECTOR NEEDED FOR UPDATING S *** 4737C 4738 540 CALL DV2AXY(PS, Y, NEGONE, Y, G) 4739C 4740C *** DETERMINE SIZING FACTOR V(SIZE) *** 4741C 4742C *** SET TEMP1 = S * STEP *** 4743 S1 = IV(S) 4744 CALL DS7LVM(PS, V(TEMP1), V(S1), V(STEP1)) 4745C 4746 T1 = DABS(DD7TPR(PS, V(STEP1), V(TEMP1))) 4747 T = DABS(DD7TPR(PS, V(STEP1), Y)) 4748 V(SIZE) = ONE 4749 IF (T .LT. T1) V(SIZE) = T / T1 4750C 4751C *** SET G0 TO WCHMTD CHOICE OF FLETCHER AND AL-BAALI *** 4752C 4753 HC1 = IV(HC) 4754 IF (HC1 .LE. 0) GO TO 550 4755 CALL DS7LVM(PS, V(G01), V(HC1), V(STEP1)) 4756 GO TO 560 4757C 4758 550 RMAT1 = IV(RMAT) 4759 IPIV0 = IV(IPIVOT) 4760 CALL DV7CPY(P, V(G01), V(STEP1)) 4761 I = G01 + PS 4762 IF (PS .LT. P) CALL DV7SCP(P-PS, V(I), ZERO) 4763 CALL DV7IPR(P, IV(IPIV0), V(G01)) 4764 CALL DL7TVM(P, V(G01), V(RMAT1), V(G01)) 4765 CALL DL7VML(P, V(G01), V(RMAT1), V(G01)) 4766 IPIV1 = IV(PERM) + P 4767 CALL I7PNVR(P, IV(IPIV1), IV(IPIV0)) 4768 CALL DV7IPR(P, IV(IPIV1), V(G01)) 4769C 4770 560 CALL DV2AXY(PS, V(G01), ONE, Y, V(G01)) 4771C 4772C *** UPDATE S *** 4773C 4774 CALL DS7LUP(V(S1), V(COSMIN), PS, V(SIZE), V(STEP1), V(TEMP1), 4775 1 V(TEMP2), V(G01), V(WSCALE), Y) 4776 IV(1) = 2 4777 GO TO 180 4778C 4779C. . . . . . . . . . . . . . MISC. DETAILS . . . . . . . . . . . . . . 4780C 4781C *** BAD PARAMETERS TO ASSESS *** 4782C 4783 570 IV(1) = 64 4784 GO TO 999 4785C 4786C 4787C *** CONVERGENCE OBTAINED -- SEE WHETHER TO COMPUTE COVARIANCE *** 4788C 4789 580 IF (IV(RDREQ) .EQ. 0) GO TO 660 4790 IF (IV(FDH) .NE. 0) GO TO 660 4791 IF (IV(CNVCOD) .GE. 7) GO TO 660 4792 IF (IV(REGD) .GT. 0) GO TO 660 4793 IF (IV(COVMAT) .GT. 0) GO TO 660 4794 IF (IABS(IV(COVREQ)) .GE. 3) GO TO 640 4795 IF (IV(RESTOR) .EQ. 0) IV(RESTOR) = 2 4796 GO TO 600 4797C 4798C *** COMPUTE FINITE-DIFFERENCE HESSIAN FOR COMPUTING COVARIANCE *** 4799C 4800 590 IV(RESTOR) = 0 4801 600 CALL DF7DHB(B, D, G, I, IV, LIV, LV, P, V, X) 4802c GO TO (610, 620, 630), I 4803 select case(I) 4804 case(1) 4805 goto 610 4806 case(2) 4807 goto 620 4808 case(3) 4809 goto 630 4810 end select 4811 610 IV(NFCOV) = IV(NFCOV) + 1 4812 IV(NFCALL) = IV(NFCALL) + 1 4813 IV(1) = 1 4814 GO TO 710 4815C 4816 620 IV(NGCOV) = IV(NGCOV) + 1 4817 IV(NGCALL) = IV(NGCALL) + 1 4818 IV(NFGCAL) = IV(NFCALL) + IV(NGCOV) 4819 GO TO 690 4820C 4821 630 IF (IV(CNVCOD) .EQ. 70) GO TO 120 4822 GO TO 660 4823C 4824 640 H1 = IABS(IV(H)) 4825 IV(FDH) = H1 4826 IV(H) = -H1 4827 HC1 = IV(HC) 4828 IF (HC1 .LE. 0) GO TO 650 4829 CALL DV7CPY(P*(P+1)/2, V(H1), V(HC1)) 4830 GO TO 660 4831 650 RMAT1 = IV(RMAT) 4832 CALL DL7SQR(P, V(H1), V(RMAT1)) 4833C 4834 660 IV(MODE) = 0 4835 IV(1) = IV(CNVCOD) 4836 IV(CNVCOD) = 0 4837 GO TO 999 4838C 4839C *** SPECIAL RETURN FOR MISSING HESSIAN INFORMATION -- BOTH 4840C *** IV(HC) .LE. 0 AND IV(RMAT) .LE. 0 4841C 4842 670 IV(1) = 1400 4843 GO TO 999 4844C 4845C *** INCONSISTENT B *** 4846C 4847 680 IV(1) = 82 4848 GO TO 999 4849C 4850C *** SAVE, THEN INITIALIZE IPIVOT ARRAY BEFORE COMPUTING G *** 4851C 4852 690 IV(1) = 2 4853 J = IV(IPIVOT) 4854 IPI = IV(PERM) 4855 CALL I7PNVR(P, IV(IPI), IV(J)) 4856 DO 700 I = 1, P 4857 IV(J) = I 4858 J = J + 1 4859 700 CONTINUE 4860C 4861C *** PROJECT X INTO FEASIBLE REGION (PRIOR TO COMPUTING F OR G) *** 4862C 4863 710 DO 720 I = 1, P 4864 IF (X(I) .LT. B(1,I)) X(I) = B(1,I) 4865 IF (X(I) .GT. B(2,I)) X(I) = B(2,I) 4866 720 CONTINUE 4867 IV(TOOBIG) = 0 4868C 4869 999 RETURN 4870C 4871C *** LAST LINE OF DG7ITB FOLLOWS *** 4872 END 4873 SUBROUTINE DRNSGB(A, ALF, B, C, DA, IN, IV, L, L1, LA, LIV, LV, 4874 1 N, NDA, P, V, Y) 4875C 4876C *** ITERATION DRIVER FOR SEPARABLE NONLINEAR LEAST SQUARES, 4877C *** WITH SIMPLE BOUNDS ON THE NONLINEAR VARIABLES. 4878C 4879C *** PARAMETER DECLARATIONS *** 4880C 4881 INTEGER L, L1, LA, LIV, LV, N, NDA, P 4882 INTEGER IN(2,NDA), IV(LIV) 4883C DIMENSION UIPARM(*) 4884 DOUBLE PRECISION A(LA,L1), ALF(P), B(2,P), C(L), DA(LA,NDA), 4885 1 V(LV), Y(N) 4886C 4887C *** PURPOSE *** 4888C 4889C GIVEN A SET OF N OBSERVATIONS Y(1)....Y(N) OF A DEPENDENT VARIABLE 4890C T(1)...T(N), DRNSGB ATTEMPTS TO COMPUTE A LEAST SQUARES FIT 4891C TO A FUNCTION ETA (THE MODEL) WHICH IS A LINEAR COMBINATION 4892C 4893C L 4894C ETA(C,ALF,T) = SUM C * PHI(ALF,T) +PHI (ALF,T) 4895C J=1 J J L+1 4896C 4897C OF NONLINEAR FUNCTIONS PHI(J) DEPENDENT ON T AND ALF(1),...,ALF(P) 4898C (.E.G. A SUM OF EXPONENTIALS OR GAUSSIANS). THAT IS, IT DETERMINES 4899C NONLINEAR PARAMETERS ALF WHICH MINIMIZE 4900C 4901C 2 N 2 4902C NORM(RESIDUAL) = SUM (Y - ETA(C,ALF,T )) , 4903C I=1 I I 4904C 4905C SUBJECT TO THE SIMPLE BOUND CONSTRAINTS 4906C B(1,I) .LE. ALF(I) .LE. B(2,I), I = 1(1)P. 4907C 4908C THE (L+1)ST TERM IS OPTIONAL. 4909C 4910C 4911C *** PARAMETERS *** 4912C 4913C A (IN) MATRIX PHI(ALF,T) OF THE MODEL. 4914C ALF (I/O) NONLINEAR PARAMETERS. 4915C INPUT = INITIAL GUESS, 4916C OUTPUT = BEST ESTIMATE FOUND. 4917C C (OUT) LINEAR PARAMETERS (ESTIMATED). 4918C DA (IN) DERIVATIVES OF COLUMNS OF A WITH RESPECT TO COMPONENTS 4919C OF ALF, AS SPECIFIED BY THE IN ARRAY... 4920C IN (IN) WHEN DRNSGB IS CALLED WITH IV(1) = 2 OR -2, THEN FOR 4921C I = 1(1)NDA, COLUMN I OF DA IS THE PARTIAL 4922C DERIVATIVE WITH RESPECT TO ALF(IN(1,I)) OF COLUMN 4923C IN(2,I) OF A, UNLESS IV(1,I) IS NOT POSITIVE (IN 4924C WHICH CASE COLUMN I OF DA IS IGNORED. IV(1) = -2 4925C MEANS THERE ARE MORE COLUMNS OF DA TO COME AND 4926C DRNSGB SHOULD RETURN FOR THEM. 4927C IV (I/O) INTEGER PARAMETER AND SCRATCH VECTOR. DRNSGB RETURNS 4928C WITH IV(1) = 1 WHEN IT WANTS A TO BE EVALUATED AT 4929C ALF AND WITH IV(1) = 2 WHEN IT WANTS DA TO BE 4930C EVALUATED AT ALF. WHEN CALLED WITH IV(1) = -2 4931C (AFTER A RETURN WITH IV(1) = 2), DRNSGB RETURNS 4932C WITH IV(1) = -2 TO GET MORE COLUMNS OF DA. 4933C L (IN) NUMBER OF LINEAR PARAMETERS TO BE ESTIMATED. 4934C L1 (IN) L+1 IF PHI(L+1) IS IN THE MODEL, L IF NOT. 4935C LA (IN) LEAD DIMENSION OF A. MUST BE AT LEAST N. 4936C LIV (IN) LENGTH OF IV. MUST BE AT LEAST 110 + L + 4*P. 4937C LV (IN) LENGTH OF V. MUST BE AT LEAST 4938C 105 + 2*N + L*(L+3)/2 + P*(2*P + 21 + N). 4939C N (IN) NUMBER OF OBSERVATIONS. 4940C NDA (IN) NUMBER OF COLUMNS IN DA AND IN. 4941C P (IN) NUMBER OF NONLINEAR PARAMETERS TO BE ESTIMATED. 4942C V (I/O) FLOATING-POINT PARAMETER AND SCRATCH VECTOR. 4943C Y (IN) RIGHT-HAND SIDE VECTOR. 4944C 4945C 4946C *** EXTERNAL SUBROUTINES *** 4947C 4948 DOUBLE PRECISION DL7SVX, DL7SVN, DR7MDC 4949 EXTERNAL DIVSET,DITSUM, DL7ITV, DL7SVX, DL7SVN, DRN2GB, DQ7APL, 4950 1 DQ7RFH, DR7MDC, DS7CPR,DV2AXY,DV7CPY,DV7PRM, DV7SCP 4951C 4952C DIVSET.... SUPPLIES DEFAULT PARAMETER VALUES. 4953C DITSUM.... PRINTS ITERATION SUMMARY, INITIAL AND FINAL ALF. 4954C DL7ITV... APPLIES INVERSE-TRANSPOSE OF COMPACT LOWER TRIANG. MATRIX. 4955C DL7SVX... ESTIMATES LARGEST SING. VALUE OF LOWER TRIANG. MATRIX. 4956C DL7SVN... ESTIMATES SMALLEST SING. VALUE OF LOWER TRIANG. MATRIX. 4957C DRN2GB... UNDERLYING NONLINEAR LEAST-SQUARES SOLVER. 4958C DQ7APL... APPLIES HOUSEHOLDER TRANSFORMS STORED BY DQ7RFH. 4959C DQ7RFH.... COMPUTES QR FACT. VIA HOUSEHOLDER TRANSFORMS WITH PIVOTING. 4960C DR7MDC... RETURNS MACHINE-DEP. CONSTANTS. 4961C DS7CPR... PRINTS LINEAR PARAMETERS AT SOLUTION. 4962C DV2AXY.... ADDS MULTIPLE OF ONE VECTOR TO ANOTHER. 4963C DV7CPY.... COPIES ONE VECTOR TO ANOTHER. 4964C DV7PRM.... PERMUTES VECTOR. 4965C DV7SCL... SCALES AND COPIES ONE VECTOR TO ANOTHER. 4966C 4967C *** LOCAL VARIABLES *** 4968C 4969 INTEGER AR1, CSAVE1, D1, DR1, DR1L, I, I1, 4970 1 IPIV1, IER, IV1, J1, JLEN, K, LL1O2, MD, N1, N2, 4971 2 NML, NRAN, R1, R1L, RD1 4972 DOUBLE PRECISION SINGTL, T 4973 DOUBLE PRECISION MACHEP, NEGONE, SNGFAC, ZERO 4974C 4975C *** SUBSCRIPTS FOR IV AND V *** 4976C 4977 INTEGER AR, CSAVE, D, IERS, IPIVS, IV1SAV, 4978 2 IVNEED, J, MODE, NEXTIV, NEXTV, 4979 2 NFCALL, NFGCAL, PERM, R, 4980 3 REGD, REGD0, RESTOR, TOOBIG, VNEED 4981C 4982C *** IV SUBSCRIPT VALUES *** 4983C 4984 PARAMETER (AR=110, CSAVE=105, D=27, IERS=108, IPIVS=109, 4985 1 IV1SAV=104, IVNEED=3, J=70, MODE=35, NEXTIV=46, 4986 2 NEXTV=47, NFCALL=6, NFGCAL=7, PERM=58, R=61, REGD=67, 4987 3 REGD0=82, RESTOR=9, TOOBIG=2, VNEED=4) 4988 DATA MACHEP/-1.D+0/, NEGONE/-1.D+0/, SNGFAC/1.D+2/, ZERO/0.D+0/ 4989C 4990C++++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++ 4991C 4992C 4993 IF (IV(1) .EQ. 0) CALL DIVSET(1, IV, LIV, LV, V) 4994 N1 = 1 4995 NML = N 4996 IV1 = IV(1) 4997 IF (IV1 .LE. 2) GO TO 20 4998C 4999C *** CHECK INPUT INTEGERS *** 5000C 5001 IF (P .LE. 0) GO TO 240 5002 IF (L .LT. 0) GO TO 240 5003 IF (N .LE. L) GO TO 240 5004 IF (LA .LT. N) GO TO 240 5005 IF (IV1 .LT. 12) GO TO 20 5006 IF (IV1 .EQ. 14) GO TO 20 5007 IF (IV1 .EQ. 12) IV(1) = 13 5008C 5009C *** FRESH START -- COMPUTE STORAGE REQUIREMENTS *** 5010C 5011 IF (IV(1) .GT. 16) GO TO 240 5012 LL1O2 = L*(L+1)/2 5013 JLEN = N*P 5014 I = L + P 5015 IF (IV(1) .NE. 13) GO TO 10 5016 IV(IVNEED) = IV(IVNEED) + L 5017 IV(VNEED) = IV(VNEED) + P + 2*N + JLEN + LL1O2 + L 5018 10 IF (IV(PERM) .LE. AR) IV(PERM) = AR + 1 5019 CALL DRN2GB(B, V, V, IV, LIV, LV, N, N, N1, NML, P, V, V, V, ALF) 5020 IF (IV(1) .NE. 14) GO TO 999 5021C 5022C *** STORAGE ALLOCATION *** 5023C 5024 IV(IPIVS) = IV(NEXTIV) 5025 IV(NEXTIV) = IV(NEXTIV) + L 5026 IV(D) = IV(NEXTV) 5027 IV(REGD0) = IV(D) + P 5028 IV(AR) = IV(REGD0) + N 5029 IV(CSAVE) = IV(AR) + LL1O2 5030 IV(J) = IV(CSAVE) + L 5031 IV(R) = IV(J) + JLEN 5032 IV(NEXTV) = IV(R) + N 5033 IV(IERS) = 0 5034 IF (IV1 .EQ. 13) GO TO 999 5035C 5036C *** SET POINTERS INTO IV AND V *** 5037C 5038 20 AR1 = IV(AR) 5039 D1 = IV(D) 5040 DR1 = IV(J) 5041 DR1L = DR1 + L 5042 R1 = IV(R) 5043 R1L = R1 + L 5044 RD1 = IV(REGD0) 5045 CSAVE1 = IV(CSAVE) 5046 NML = N - L 5047 IF (IV1 .LE. 2) GO TO 50 5048C 5049 30 N2 = NML 5050 CALL DRN2GB(B, V(D1), V(DR1L), IV, LIV, LV, NML, N, N1, N2, P, 5051 1 V(R1L), V(RD1), V, ALF) 5052 IF (IABS(IV(RESTOR)-2) .EQ. 1 .AND. L .GT. 0) 5053 1 CALL DV7CPY(L, C, V(CSAVE1)) 5054 IV1 = IV(1) 5055 IF (IV1 .EQ. 2) GO TO 150 5056 IF (IV1 .GT. 2) GO TO 230 5057C 5058C *** NEW FUNCTION VALUE (RESIDUAL) NEEDED *** 5059C 5060 IV(IV1SAV) = IV(1) 5061 IV(1) = IABS(IV1) 5062 IF (IV(RESTOR) .EQ. 2 .AND. L .GT. 0) CALL DV7CPY(L, V(CSAVE1), C) 5063 GO TO 999 5064C 5065C *** COMPUTE NEW RESIDUAL OR GRADIENT *** 5066C 5067 50 IV(1) = IV(IV1SAV) 5068 MD = IV(MODE) 5069 IF (MD .LE. 0) GO TO 60 5070 NML = N 5071 DR1L = DR1 5072 R1L = R1 5073 60 IF (IV(TOOBIG) .NE. 0) GO TO 30 5074 IF (IABS(IV1) .EQ. 2) GO TO 170 5075C 5076C *** COMPUTE NEW RESIDUAL *** 5077C 5078 IF (L1 .LE. L) CALL DV7CPY(N, V(R1), Y) 5079 IF (L1 .GT. L) CALL DV2AXY(N, V(R1), NEGONE, A(1,L1), Y) 5080 IF (MD .GT. 0) GO TO 120 5081 IER = 0 5082 IF (L .LE. 0) GO TO 110 5083 LL1O2 = L * (L + 1) / 2 5084 IPIV1 = IV(IPIVS) 5085 CALL DQ7RFH(IER, IV(IPIV1), N, LA, 0, L, A, V(AR1), LL1O2, C) 5086C 5087C *** DETERMINE NUMERICAL RANK OF A *** 5088C 5089 IF (MACHEP .LE. ZERO) MACHEP = DR7MDC(3) 5090 SINGTL = SNGFAC * DBLE(MAX0(L,N)) * MACHEP 5091 K = L 5092 IF (IER .NE. 0) K = IER - 1 5093 70 IF (K .LE. 0) GO TO 90 5094 T = DL7SVX(K, V(AR1), C, C) 5095 IF (T .GT. ZERO) T = DL7SVN(K, V(AR1), C, C) / T 5096 IF (T .GT. SINGTL) GO TO 80 5097 K = K - 1 5098 GO TO 70 5099C 5100C *** RECORD RANK IN IV(IERS)... IV(IERS) = 0 MEANS FULL RANK, 5101C *** IV(IERS) .GT. 0 MEANS RANK IV(IERS) - 1. 5102C 5103 80 IF (K .GE. L) GO TO 100 5104 90 IER = K + 1 5105 CALL DV7SCP(L-K, C(K+1), ZERO) 5106 100 IV(IERS) = IER 5107 IF (K .LE. 0) GO TO 110 5108C 5109C *** APPLY HOUSEHOLDER TRANSFORMATONS TO RESIDUALS... 5110C 5111 CALL DQ7APL(LA, N, K, A, V(R1), IER) 5112C 5113C *** COMPUTING C NOW MAY SAVE A FUNCTION EVALUATION AT 5114C *** THE LAST ITERATION. 5115C 5116 CALL DL7ITV(K, C, V(AR1), V(R1)) 5117 CALL DV7PRM(L, IV(IPIV1), C) 5118C 5119 110 IF(IV(1) .LT. 2) GO TO 220 5120 GO TO 999 5121C 5122C 5123C *** RESIDUAL COMPUTATION FOR F.D. HESSIAN *** 5124C 5125 120 IF (L .LE. 0) GO TO 140 5126 DO 130 I = 1, L 5127 CALL DV2AXY(N, V(R1), -C(I), A(1,I), V(R1)) 5128 130 CONTINUE 5129 140 IF (IV(1) .GT. 0) GO TO 30 5130 IV(1) = 2 5131 GO TO 160 5132C 5133C *** NEW GRADIENT (JACOBIAN) NEEDED *** 5134C 5135 150 IV(IV1SAV) = IV1 5136 IF (IV(NFGCAL) .NE. IV(NFCALL)) IV(1) = 1 5137 160 CALL DV7SCP(N*P, V(DR1), ZERO) 5138 GO TO 999 5139C 5140C *** COMPUTE NEW JACOBIAN *** 5141C 5142 170 IF (NDA .LE. 0) GO TO 240 5143 DO 180 I = 1, NDA 5144 I1 = IN(1,I) - 1 5145 IF (I1 .LT. 0) GO TO 180 5146 J1 = IN(2,I) 5147 K = DR1 + I1*N 5148 T = NEGONE 5149 IF (J1 .LE. L) T = -C(J1) 5150 CALL DV2AXY(N, V(K), T, DA(1,I), V(K)) 5151 180 CONTINUE 5152 IF (IV1 .EQ. 2) GO TO 190 5153 IV(1) = IV1 5154 GO TO 999 5155 190 IF (L .LE. 0) GO TO 30 5156 IF (MD .GT. 0) GO TO 30 5157 K = DR1 5158 IER = IV(IERS) 5159 NRAN = L 5160 IF (IER .GT. 0) NRAN = IER - 1 5161 IF (NRAN .LE. 0) GO TO 210 5162 DO 200 I = 1, P 5163 CALL DQ7APL(LA, N, NRAN, A, V(K), IER) 5164 K = K + N 5165 200 CONTINUE 5166 210 CALL DV7CPY(L, V(CSAVE1), C) 5167 220 IF (IER .EQ. 0) GO TO 30 5168C 5169C *** ADJUST SUBSCRIPTS DESCRIBING R AND DR... 5170C 5171 NRAN = IER - 1 5172 DR1L = DR1 + NRAN 5173 NML = N - NRAN 5174 R1L = R1 + NRAN 5175 GO TO 30 5176C 5177C *** CONVERGENCE OR LIMIT REACHED *** 5178C 5179 230 IF (IV(REGD) .EQ. 1) IV(REGD) = RD1 5180 IF (IV(1) .LE. 11) CALL DS7CPR(C, IV, L, LIV) 5181 GO TO 999 5182C 5183 240 IV(1) = 66 5184 CALL DITSUM(V, V, IV, LIV, LV, P, V, ALF) 5185C 5186 999 RETURN 5187C 5188C *** LAST CARD OF DRNSGB FOLLOWS *** 5189 END 5190 SUBROUTINE DS7LUP(A, COSMIN, P, SIZE, STEP, U, W, WCHMTD, WSCALE, 5191 1 Y) 5192C 5193C *** UPDATE SYMMETRIC A SO THAT A * STEP = Y *** 5194C *** (LOWER TRIANGLE OF A STORED ROWWISE *** 5195C 5196C *** PARAMETER DECLARATIONS *** 5197C 5198 INTEGER P 5199 DOUBLE PRECISION A(*), COSMIN, SIZE, STEP(P), U(P), W(P), 5200 1 WCHMTD(P), WSCALE, Y(P) 5201C DIMENSION A(P*(P+1)/2) 5202C 5203C *** LOCAL VARIABLES *** 5204C 5205 INTEGER I, J, K 5206 DOUBLE PRECISION DENMIN, SDOTWM, T, UI, WI 5207C 5208C *** CONSTANTS *** 5209 DOUBLE PRECISION HALF, ONE, ZERO 5210C 5211C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 5212C 5213 DOUBLE PRECISION DD7TPR, DV2NRM 5214 EXTERNAL DD7TPR, DS7LVM, DV2NRM 5215C 5216 PARAMETER (HALF=0.5D+0, ONE=1.D+0, ZERO=0.D+0) 5217C 5218C----------------------------------------------------------------------- 5219C 5220 SDOTWM = DD7TPR(P, STEP, WCHMTD) 5221 DENMIN = COSMIN * DV2NRM(P,STEP) * DV2NRM(P,WCHMTD) 5222 WSCALE = ONE 5223 IF (DENMIN .NE. ZERO) WSCALE = DMIN1(ONE, DABS(SDOTWM/DENMIN)) 5224 T = ZERO 5225 IF (SDOTWM .NE. ZERO) T = WSCALE / SDOTWM 5226 DO 10 I = 1, P 5227 W(I) = T * WCHMTD(I) 5228 10 CONTINUE 5229 CALL DS7LVM(P, U, A, STEP) 5230 T = HALF * (SIZE * DD7TPR(P, STEP, U) - DD7TPR(P, STEP, Y)) 5231 DO 20 I = 1, P 5232 U(I) = T*W(I) + Y(I) - SIZE*U(I) 5233 20 CONTINUE 5234C 5235C *** SET A = A + U*(W**T) + W*(U**T) *** 5236C 5237 K = 1 5238 DO 40 I = 1, P 5239 UI = U(I) 5240 WI = W(I) 5241 DO 30 J = 1, I 5242 A(K) = SIZE*A(K) + UI*W(J) + WI*U(J) 5243 K = K + 1 5244 30 CONTINUE 5245 40 CONTINUE 5246C 5247 RETURN 5248C *** LAST CARD OF DS7LUP FOLLOWS *** 5249 END 5250 SUBROUTINE DL7MST(D, G, IERR, IPIVOT, KA, P, QTR, R, STEP, V, W) 5251C 5252C *** COMPUTE LEVENBERG-MARQUARDT STEP USING MORE-HEBDEN TECHNIQUE ** 5253C *** NL2SOL VERSION 2.2. *** 5254C 5255C *** PARAMETER DECLARATIONS *** 5256C 5257 INTEGER IERR, KA, P 5258 INTEGER IPIVOT(P) 5259 DOUBLE PRECISION D(P), G(P), QTR(P), R(*), STEP(P), V(21), W(*) 5260C DIMENSION W(P*(P+5)/2 + 4) 5261C 5262C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 5263C 5264C *** PURPOSE *** 5265C 5266C GIVEN THE R MATRIX FROM THE QR DECOMPOSITION OF A JACOBIAN 5267C MATRIX, J, AS WELL AS Q-TRANSPOSE TIMES THE CORRESPONDING 5268C RESIDUAL VECTOR, RESID, THIS SUBROUTINE COMPUTES A LEVENBERG- 5269C MARQUARDT STEP OF APPROXIMATE LENGTH V(RADIUS) BY THE MORE- 5270C TECHNIQUE. 5271C 5272C *** PARAMETER DESCRIPTION *** 5273C 5274C D (IN) = THE SCALE VECTOR. 5275C G (IN) = THE GRADIENT VECTOR (J**T)*R. 5276C IERR (I/O) = RETURN CODE FROM QRFACT OR DQ7RGS -- 0 MEANS R HAS 5277C FULL RANK. 5278C IPIVOT (I/O) = PERMUTATION ARRAY FROM QRFACT OR DQ7RGS, WHICH COMPUTE 5279C QR DECOMPOSITIONS WITH COLUMN PIVOTING. 5280C KA (I/O). KA .LT. 0 ON INPUT MEANS THIS IS THE FIRST CALL ON 5281C DL7MST FOR THE CURRENT R AND QTR. ON OUTPUT KA CON- 5282C TAINS THE NUMBER OF HEBDEN ITERATIONS NEEDED TO DETERMINE 5283C STEP. KA = 0 MEANS A GAUSS-NEWTON STEP. 5284C P (IN) = NUMBER OF PARAMETERS. 5285C QTR (IN) = (Q**T)*RESID = Q-TRANSPOSE TIMES THE RESIDUAL VECTOR. 5286C R (IN) = THE R MATRIX, STORED COMPACTLY BY COLUMNS. 5287C STEP (OUT) = THE LEVENBERG-MARQUARDT STEP COMPUTED. 5288C V (I/O) CONTAINS VARIOUS CONSTANTS AND VARIABLES DESCRIBED BELOW. 5289C W (I/O) = WORKSPACE OF LENGTH P*(P+5)/2 + 4. 5290C 5291C *** ENTRIES IN V *** 5292C 5293C V(DGNORM) (I/O) = 2-NORM OF (D**-1)*G. 5294C V(DSTNRM) (I/O) = 2-NORM OF D*STEP. 5295C V(DST0) (I/O) = 2-NORM OF GAUSS-NEWTON STEP (FOR NONSING. J). 5296C V(EPSLON) (IN) = MAX. REL. ERROR ALLOWED IN TWONORM(R)**2 MINUS 5297C TWONORM(R - J*STEP)**2. (SEE ALGORITHM NOTES BELOW.) 5298C V(GTSTEP) (OUT) = INNER PRODUCT BETWEEN G AND STEP. 5299C V(NREDUC) (OUT) = HALF THE REDUCTION IN THE SUM OF SQUARES PREDICTED 5300C FOR A GAUSS-NEWTON STEP. 5301C V(PHMNFC) (IN) = TOL. (TOGETHER WITH V(PHMXFC)) FOR ACCEPTING STEP 5302C (MORE*S SIGMA). THE ERROR V(DSTNRM) - V(RADIUS) MUST LIE 5303C BETWEEN V(PHMNFC)*V(RADIUS) AND V(PHMXFC)*V(RADIUS). 5304C V(PHMXFC) (IN) (SEE V(PHMNFC).) 5305C V(PREDUC) (OUT) = HALF THE REDUCTION IN THE SUM OF SQUARES PREDICTED 5306C BY THE STEP RETURNED. 5307C V(RADIUS) (IN) = RADIUS OF CURRENT (SCALED) TRUST REGION. 5308C V(RAD0) (I/O) = VALUE OF V(RADIUS) FROM PREVIOUS CALL. 5309C V(STPPAR) (I/O) = MARQUARDT PARAMETER (OR ITS NEGATIVE IF THE SPECIAL 5310C CASE MENTIONED BELOW IN THE ALGORITHM NOTES OCCURS). 5311C 5312C NOTE -- SEE DATA STATEMENT BELOW FOR VALUES OF ABOVE SUBSCRIPTS. 5313C 5314C *** USAGE NOTES *** 5315C 5316C IF IT IS DESIRED TO RECOMPUTE STEP USING A DIFFERENT VALUE OF 5317C V(RADIUS), THEN THIS ROUTINE MAY BE RESTARTED BY CALLING IT 5318C WITH ALL PARAMETERS UNCHANGED EXCEPT V(RADIUS). (THIS EXPLAINS 5319C WHY MANY PARAMETERS ARE LISTED AS I/O). ON AN INTIIAL CALL (ONE 5320C WITH KA = -1), THE CALLER NEED ONLY HAVE INITIALIZED D, G, KA, P, 5321C QTR, R, V(EPSLON), V(PHMNFC), V(PHMXFC), V(RADIUS), AND V(RAD0). 5322C 5323C *** APPLICATION AND USAGE RESTRICTIONS *** 5324C 5325C THIS ROUTINE IS CALLED AS PART OF THE NL2SOL (NONLINEAR LEAST- 5326C SQUARES) PACKAGE (REF. 1). 5327C 5328C *** ALGORITHM NOTES *** 5329C 5330C THIS CODE IMPLEMENTS THE STEP COMPUTATION SCHEME DESCRIBED IN 5331C REFS. 2 AND 4. FAST GIVENS TRANSFORMATIONS (SEE REF. 3, PP. 60- 5332C 62) ARE USED TO COMPUTE STEP WITH A NONZERO MARQUARDT PARAMETER. 5333C A SPECIAL CASE OCCURS IF J IS (NEARLY) SINGULAR AND V(RADIUS) 5334C IS SUFFICIENTLY LARGE. IN THIS CASE THE STEP RETURNED IS SUCH 5335C THAT TWONORM(R)**2 - TWONORM(R - J*STEP)**2 DIFFERS FROM ITS 5336C OPTIMAL VALUE BY LESS THAN V(EPSLON) TIMES THIS OPTIMAL VALUE, 5337C WHERE J AND R DENOTE THE ORIGINAL JACOBIAN AND RESIDUAL. (SEE 5338C REF. 2 FOR MORE DETAILS.) 5339C 5340C *** FUNCTIONS AND SUBROUTINES CALLED *** 5341C 5342C DD7TPR - RETURNS INNER PRODUCT OF TWO VECTORS. 5343C DL7ITV - APPLY INVERSE-TRANSPOSE OF COMPACT LOWER TRIANG. MATRIX. 5344C DL7IVM - APPLY INVERSE OF COMPACT LOWER TRIANG. MATRIX. 5345C DV7CPY - COPIES ONE VECTOR TO ANOTHER. 5346C DV2NRM - RETURNS 2-NORM OF A VECTOR. 5347C 5348C *** REFERENCES *** 5349C 5350C 1. DENNIS, J.E., GAY, D.M., AND WELSCH, R.E. (1981), AN ADAPTIVE 5351C NONLINEAR LEAST-SQUARES ALGORITHM, ACM TRANS. MATH. 5352C SOFTWARE, VOL. 7, NO. 3. 5353C 2. GAY, D.M. (1981), COMPUTING OPTIMAL LOCALLY CONSTRAINED STEPS, 5354C SIAM J. SCI. STATIST. COMPUTING, VOL. 2, NO. 2, PP. 5355C 186-197. 5356C 3. LAWSON, C.L., AND HANSON, R.J. (1974), SOLVING LEAST SQUARES 5357C PROBLEMS, PRENTICE-HALL, ENGLEWOOD CLIFFS, N.J. 5358C 4. MORE, J.J. (1978), THE LEVENBERG-MARQUARDT ALGORITHM, IMPLEMEN- 5359C TATION AND THEORY, PP.105-116 OF SPRINGER LECTURE NOTES 5360C IN MATHEMATICS NO. 630, EDITED BY G.A. WATSON, SPRINGER- 5361C VERLAG, BERLIN AND NEW YORK. 5362C 5363C *** GENERAL *** 5364C 5365C CODED BY DAVID M. GAY. 5366C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH 5367C SUPPORTED BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS 5368C MCS-7600324, DCR75-10143, 76-14311DSS, MCS76-11989, AND 5369C MCS-7906671. 5370C 5371C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 5372C 5373C *** LOCAL VARIABLES *** 5374C 5375 INTEGER DSTSAV, I, IP1, I1, J1, K, KALIM, L, LK0, PHIPIN, 5376 1 PP1O2, RES, RES0, RMAT, RMAT0, UK0 5377 DOUBLE PRECISION A, ADI, ALPHAK, B, DFACSQ, DST, DTOL, D1, D2, 5378 1 LK, OLDPHI, PHI, PHIMAX, PHIMIN, PSIFAC, RAD, 5379 2 SI, SJ, SQRTAK, T, TWOPSI, UK, WL 5380C 5381C *** CONSTANTS *** 5382 DOUBLE PRECISION DFAC, EIGHT, HALF, NEGONE, ONE, P001, THREE, 5383 1 TTOL, ZERO 5384 DOUBLE PRECISION BIG 5385C 5386C *** INTRINSIC FUNCTIONS *** 5387C/+ 5388 DOUBLE PRECISION DSQRT 5389C/ 5390C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 5391C 5392 DOUBLE PRECISION DD7TPR, DL7SVN, DR7MDC, DV2NRM 5393 EXTERNAL DD7TPR, DL7ITV, DL7IVM, DL7SVN, DR7MDC,DV7CPY, DV2NRM 5394C 5395C *** SUBSCRIPTS FOR V *** 5396C 5397 INTEGER DGNORM, DSTNRM, DST0, EPSLON, GTSTEP, NREDUC, PHMNFC, 5398 1 PHMXFC, PREDUC, RADIUS, RAD0, STPPAR 5399 PARAMETER (DGNORM=1, DSTNRM=2, DST0=3, EPSLON=19, GTSTEP=4, 5400 1 NREDUC=6, PHMNFC=20, PHMXFC=21, PREDUC=7, RADIUS=8, 5401 2 RAD0=9, STPPAR=5) 5402C 5403 PARAMETER (DFAC=256.D+0, EIGHT=8.D+0, HALF=0.5D+0, NEGONE=-1.D+0, 5404 1 ONE=1.D+0, P001=1.D-3, THREE=3.D+0, TTOL=2.5D+0, 5405 2 ZERO=0.D+0) 5406 SAVE BIG 5407 DATA BIG/0.D+0/ 5408C 5409C *** BODY *** 5410C 5411C *** FOR USE IN RECOMPUTING STEP, THE FINAL VALUES OF LK AND UK, 5412C *** THE INVERSE DERIVATIVE OF MORE*S PHI AT 0 (FOR NONSING. J) 5413C *** AND THE VALUE RETURNED AS V(DSTNRM) ARE STORED AT W(LK0), 5414C *** W(UK0), W(PHIPIN), AND W(DSTSAV) RESPECTIVELY. 5415 LK0 = P + 1 5416 PHIPIN = LK0 + 1 5417 UK0 = PHIPIN + 1 5418 DSTSAV = UK0 + 1 5419 RMAT0 = DSTSAV 5420C *** A COPY OF THE R-MATRIX FROM THE QR DECOMPOSITION OF J IS 5421C *** STORED IN W STARTING AT W(RMAT), AND A COPY OF THE RESIDUAL 5422C *** VECTOR IS STORED IN W STARTING AT W(RES). THE LOOPS BELOW 5423C *** THAT UPDATE THE QR DECOMP. FOR A NONZERO MARQUARDT PARAMETER 5424C *** WORK ON THESE COPIES. 5425 RMAT = RMAT0 + 1 5426 PP1O2 = P * (P + 1) / 2 5427 RES0 = PP1O2 + RMAT0 5428 RES = RES0 + 1 5429 RAD = V(RADIUS) 5430 IF (RAD .GT. ZERO) 5431 1 PSIFAC = V(EPSLON)/((EIGHT*(V(PHMNFC) + ONE) + THREE) * RAD**2) 5432 IF (BIG .LE. ZERO) BIG = DR7MDC(6) 5433 PHIMAX = V(PHMXFC) * RAD 5434 PHIMIN = V(PHMNFC) * RAD 5435C *** DTOL, DFAC, AND DFACSQ ARE USED IN RESCALING THE FAST GIVENS 5436C *** REPRESENTATION OF THE UPDATED QR DECOMPOSITION. 5437 DTOL = ONE/DFAC 5438 DFACSQ = DFAC*DFAC 5439C *** OLDPHI IS USED TO DETECT LIMITS OF NUMERICAL ACCURACY. IF 5440C *** WE RECOMPUTE STEP AND IT DOES NOT CHANGE, THEN WE ACCEPT IT. 5441 OLDPHI = ZERO 5442 LK = ZERO 5443 UK = ZERO 5444 KALIM = KA + 12 5445C 5446C *** START OR RESTART, DEPENDING ON KA *** 5447C 5448 IF (KA .EQ. 0) GO TO 20 5449 IF (KA .GT. 0) GO TO 370 5450C 5451C *** FRESH START -- COMPUTE V(NREDUC) *** 5452C 5453 KA = 0 5454 KALIM = 12 5455 K = P 5456 IF (IERR .NE. 0) K = IABS(IERR) - 1 5457 V(NREDUC) = HALF*DD7TPR(K, QTR, QTR) 5458C 5459C *** SET UP TO TRY INITIAL GAUSS-NEWTON STEP *** 5460C 5461 20 V(DST0) = NEGONE 5462 IF (IERR .NE. 0) GO TO 90 5463 T = DL7SVN(P, R, STEP, W(RES)) 5464 IF (T .GE. ONE) GO TO 30 5465 IF (DV2NRM(P, QTR) .GE. BIG*T) GO TO 90 5466C 5467C *** COMPUTE GAUSS-NEWTON STEP *** 5468C 5469C *** NOTE -- THE R-MATRIX IS STORED COMPACTLY BY COLUMNS IN 5470C *** R(1), R(2), R(3), ... IT IS THE TRANSPOSE OF A 5471C *** LOWER TRIANGULAR MATRIX STORED COMPACTLY BY ROWS, AND WE 5472C *** TREAT IT AS SUCH WHEN USING DL7ITV AND DL7IVM. 5473 30 CALL DL7ITV(P, W, R, QTR) 5474C *** TEMPORARILY STORE PERMUTED -D*STEP IN STEP. 5475 DO 60 I = 1, P 5476 J1 = IPIVOT(I) 5477 STEP(I) = D(J1)*W(I) 5478 60 CONTINUE 5479 DST = DV2NRM(P, STEP) 5480 V(DST0) = DST 5481 PHI = DST - RAD 5482 IF (PHI .LE. PHIMAX) GO TO 410 5483C *** IF THIS IS A RESTART, GO TO 110 *** 5484 IF (KA .GT. 0) GO TO 110 5485C 5486C *** GAUSS-NEWTON STEP WAS UNACCEPTABLE. COMPUTE L0 *** 5487C 5488 DO 70 I = 1, P 5489 J1 = IPIVOT(I) 5490 STEP(I) = D(J1)*(STEP(I)/DST) 5491 70 CONTINUE 5492 CALL DL7IVM(P, STEP, R, STEP) 5493 T = ONE / DV2NRM(P, STEP) 5494 W(PHIPIN) = (T/RAD)*T 5495 LK = PHI*W(PHIPIN) 5496C 5497C *** COMPUTE U0 *** 5498C 5499 90 DO 100 I = 1, P 5500 W(I) = G(I)/D(I) 5501 100 CONTINUE 5502 V(DGNORM) = DV2NRM(P, W) 5503 UK = V(DGNORM)/RAD 5504 IF (UK .LE. ZERO) GO TO 390 5505C 5506C *** ALPHAK WILL BE USED AS THE CURRENT MARQUARDT PARAMETER. WE 5507C *** USE MORE*S SCHEME FOR INITIALIZING IT. 5508C 5509 ALPHAK = DABS(V(STPPAR)) * V(RAD0)/RAD 5510 ALPHAK = DMIN1(UK, DMAX1(ALPHAK, LK)) 5511C 5512C 5513C *** TOP OF LOOP -- INCREMENT KA, COPY R TO RMAT, QTR TO RES *** 5514C 5515 110 KA = KA + 1 5516 CALL DV7CPY(PP1O2, W(RMAT), R) 5517 CALL DV7CPY(P, W(RES), QTR) 5518C 5519C *** SAFEGUARD ALPHAK AND INITIALIZE FAST GIVENS SCALE VECTOR. *** 5520C 5521 IF (ALPHAK .LE. ZERO .OR. ALPHAK .LT. LK .OR. ALPHAK .GE. UK) 5522 1 ALPHAK = UK * DMAX1(P001, DSQRT(LK/UK)) 5523 IF (ALPHAK .LE. ZERO) ALPHAK = HALF * UK 5524 SQRTAK = DSQRT(ALPHAK) 5525 DO 120 I = 1, P 5526 W(I) = ONE 5527 120 CONTINUE 5528C 5529C *** ADD ALPHAK*D AND UPDATE QR DECOMP. USING FAST GIVENS TRANS. *** 5530C 5531 DO 270 I = 1, P 5532C *** GENERATE, APPLY 1ST GIVENS TRANS. FOR ROW I OF ALPHAK*D. 5533C *** (USE STEP TO STORE TEMPORARY ROW) *** 5534 L = I*(I+1)/2 + RMAT0 5535 WL = W(L) 5536 D2 = ONE 5537 D1 = W(I) 5538 J1 = IPIVOT(I) 5539 ADI = SQRTAK*D(J1) 5540 IF (ADI .GE. DABS(WL)) GO TO 150 5541 130 A = ADI/WL 5542 B = D2*A/D1 5543 T = A*B + ONE 5544 IF (T .GT. TTOL) GO TO 150 5545 W(I) = D1/T 5546 D2 = D2/T 5547 W(L) = T*WL 5548 A = -A 5549 DO 140 J1 = I, P 5550 L = L + J1 5551 STEP(J1) = A*W(L) 5552 140 CONTINUE 5553 GO TO 170 5554C 5555 150 B = WL/ADI 5556 A = D1*B/D2 5557 T = A*B + ONE 5558 IF (T .GT. TTOL) GO TO 130 5559 W(I) = D2/T 5560 D2 = D1/T 5561 W(L) = T*ADI 5562 DO 160 J1 = I, P 5563 L = L + J1 5564 WL = W(L) 5565 STEP(J1) = -WL 5566 W(L) = A*WL 5567 160 CONTINUE 5568C 5569 170 IF (I .EQ. P) GO TO 280 5570C 5571C *** NOW USE GIVENS TRANS. TO ZERO ELEMENTS OF TEMP. ROW *** 5572C 5573 IP1 = I + 1 5574 DO 260 I1 = IP1, P 5575 SI = STEP(I1-1) 5576 IF (SI .EQ. ZERO) GO TO 260 5577 L = I1*(I1+1)/2 + RMAT0 5578 WL = W(L) 5579 D1 = W(I1) 5580C 5581C *** RESCALE ROW I1 IF NECESSARY *** 5582C 5583 IF (D1 .GE. DTOL) GO TO 190 5584 D1 = D1*DFACSQ 5585 WL = WL/DFAC 5586 K = L 5587 DO 180 J1 = I1, P 5588 K = K + J1 5589 W(K) = W(K)/DFAC 5590 180 CONTINUE 5591C 5592C *** USE GIVENS TRANS. TO ZERO NEXT ELEMENT OF TEMP. ROW 5593C 5594 190 IF (DABS(SI) .GT. DABS(WL)) GO TO 220 5595 200 A = SI/WL 5596 B = D2*A/D1 5597 T = A*B + ONE 5598 IF (T .GT. TTOL) GO TO 220 5599 W(L) = T*WL 5600 W(I1) = D1/T 5601 D2 = D2/T 5602 DO 210 J1 = I1, P 5603 L = L + J1 5604 WL = W(L) 5605 SJ = STEP(J1) 5606 W(L) = WL + B*SJ 5607 STEP(J1) = SJ - A*WL 5608 210 CONTINUE 5609 GO TO 240 5610C 5611 220 B = WL/SI 5612 A = D1*B/D2 5613 T = A*B + ONE 5614 IF (T .GT. TTOL) GO TO 200 5615 W(I1) = D2/T 5616 D2 = D1/T 5617 W(L) = T*SI 5618 DO 230 J1 = I1, P 5619 L = L + J1 5620 WL = W(L) 5621 SJ = STEP(J1) 5622 W(L) = A*WL + SJ 5623 STEP(J1) = B*SJ - WL 5624 230 CONTINUE 5625C 5626C *** RESCALE TEMP. ROW IF NECESSARY *** 5627C 5628 240 IF (D2 .GE. DTOL) GO TO 260 5629 D2 = D2*DFACSQ 5630 DO 250 K = I1, P 5631 STEP(K) = STEP(K)/DFAC 5632 250 CONTINUE 5633 260 CONTINUE 5634 270 CONTINUE 5635C 5636C *** COMPUTE STEP *** 5637C 5638 280 CALL DL7ITV(P, W(RES), W(RMAT), W(RES)) 5639C *** RECOVER STEP AND STORE PERMUTED -D*STEP AT W(RES) *** 5640 DO 290 I = 1, P 5641 J1 = IPIVOT(I) 5642 K = RES0 + I 5643 T = W(K) 5644 STEP(J1) = -T 5645 W(K) = T*D(J1) 5646 290 CONTINUE 5647 DST = DV2NRM(P, W(RES)) 5648 PHI = DST - RAD 5649 IF (PHI .LE. PHIMAX .AND. PHI .GE. PHIMIN) GO TO 430 5650 IF (OLDPHI .EQ. PHI) GO TO 430 5651 OLDPHI = PHI 5652C 5653C *** CHECK FOR (AND HANDLE) SPECIAL CASE *** 5654C 5655 IF (PHI .GT. ZERO) GO TO 310 5656 IF (KA .GE. KALIM) GO TO 430 5657 TWOPSI = ALPHAK*DST*DST - DD7TPR(P, STEP, G) 5658 IF (ALPHAK .GE. TWOPSI*PSIFAC) GO TO 310 5659 V(STPPAR) = -ALPHAK 5660 GO TO 440 5661C 5662C *** UNACCEPTABLE STEP -- UPDATE LK, UK, ALPHAK, AND TRY AGAIN *** 5663C 5664 300 IF (PHI .LT. ZERO) UK = DMIN1(UK, ALPHAK) 5665 GO TO 320 5666 310 IF (PHI .LT. ZERO) UK = ALPHAK 5667 320 DO 330 I = 1, P 5668 J1 = IPIVOT(I) 5669 K = RES0 + I 5670 STEP(I) = D(J1) * (W(K)/DST) 5671 330 CONTINUE 5672 CALL DL7IVM(P, STEP, W(RMAT), STEP) 5673 DO 340 I = 1, P 5674 STEP(I) = STEP(I) / DSQRT(W(I)) 5675 340 CONTINUE 5676 T = ONE / DV2NRM(P, STEP) 5677 ALPHAK = ALPHAK + T*PHI*T/RAD 5678 LK = DMAX1(LK, ALPHAK) 5679 ALPHAK = LK 5680 GO TO 110 5681C 5682C *** RESTART *** 5683C 5684 370 LK = W(LK0) 5685 UK = W(UK0) 5686 IF (V(DST0) .GT. ZERO .AND. V(DST0) - RAD .LE. PHIMAX) GO TO 20 5687 ALPHAK = DABS(V(STPPAR)) 5688 DST = W(DSTSAV) 5689 PHI = DST - RAD 5690 T = V(DGNORM)/RAD 5691 IF (RAD .GT. V(RAD0)) GO TO 380 5692C 5693C *** SMALLER RADIUS *** 5694 UK = T 5695 IF (ALPHAK .LE. ZERO) LK = ZERO 5696 IF (V(DST0) .GT. ZERO) LK = DMAX1(LK, (V(DST0)-RAD)*W(PHIPIN)) 5697 GO TO 300 5698C 5699C *** BIGGER RADIUS *** 5700 380 IF (ALPHAK .LE. ZERO .OR. UK .GT. T) UK = T 5701 LK = ZERO 5702 IF (V(DST0) .GT. ZERO) LK = DMAX1(LK, (V(DST0)-RAD)*W(PHIPIN)) 5703 GO TO 300 5704C 5705C *** SPECIAL CASE -- RAD .LE. 0 OR (G = 0 AND J IS SINGULAR) *** 5706C 5707 390 V(STPPAR) = ZERO 5708 DST = ZERO 5709 LK = ZERO 5710 UK = ZERO 5711 V(GTSTEP) = ZERO 5712 V(PREDUC) = ZERO 5713 DO 400 I = 1, P 5714 STEP(I) = ZERO 5715 400 CONTINUE 5716 GO TO 450 5717C 5718C *** ACCEPTABLE GAUSS-NEWTON STEP -- RECOVER STEP FROM W *** 5719C 5720 410 ALPHAK = ZERO 5721 DO 420 I = 1, P 5722 J1 = IPIVOT(I) 5723 STEP(J1) = -W(I) 5724 420 CONTINUE 5725C 5726C *** SAVE VALUES FOR USE IN A POSSIBLE RESTART *** 5727C 5728 430 V(STPPAR) = ALPHAK 5729 440 V(GTSTEP) = DMIN1(DD7TPR(P,STEP,G), ZERO) 5730 V(PREDUC) = HALF * (ALPHAK*DST*DST - V(GTSTEP)) 5731 450 V(DSTNRM) = DST 5732 W(DSTSAV) = DST 5733 W(LK0) = LK 5734 W(UK0) = UK 5735 V(RAD0) = RAD 5736C 5737 RETURN 5738C 5739C *** LAST CARD OF DL7MST FOLLOWS *** 5740 END 5741 SUBROUTINE DRMNFB(B, D, FX, IV, LIV, LV, P, V, X) 5742C 5743C *** ITERATION DRIVER FOR DMNF... 5744C *** MINIMIZE GENERAL UNCONSTRAINED OBJECTIVE FUNCTION USING 5745C *** FINITE-DIFFERENCE GRADIENTS AND SECANT HESSIAN APPROXIMATIONS. 5746C 5747 INTEGER LIV, LV, P 5748 INTEGER IV(LIV) 5749 DOUBLE PRECISION B(2,P), D(P), FX, X(P), V(LV) 5750C DIMENSION IV(59 + P), V(77 + P*(P+23)/2) 5751C 5752C *** PURPOSE *** 5753C 5754C THIS ROUTINE INTERACTS WITH SUBROUTINE DRMNGB IN AN ATTEMPT 5755C TO FIND AN P-VECTOR X* THAT MINIMIZES THE (UNCONSTRAINED) 5756C OBJECTIVE FUNCTION FX = F(X) COMPUTED BY THE CALLER. (OFTEN 5757C THE X* FOUND IS A LOCAL MINIMIZER RATHER THAN A GLOBAL ONE.) 5758C 5759C *** PARAMETERS *** 5760C 5761C THE PARAMETERS FOR DRMNFB ARE THE SAME AS THOSE FOR DMNG 5762C (WHICH SEE), EXCEPT THAT CALCF, CALCG, UIPARM, URPARM, AND UFPARM 5763C ARE OMITTED, AND A PARAMETER FX FOR THE OBJECTIVE FUNCTION 5764C VALUE AT X IS ADDED. INSTEAD OF CALLING CALCG TO OBTAIN THE 5765C GRADIENT OF THE OBJECTIVE FUNCTION AT X, DRMNFB CALLS DS3GRD, 5766C WHICH COMPUTES AN APPROXIMATION TO THE GRADIENT BY FINITE 5767C (FORWARD AND CENTRAL) DIFFERENCES USING THE METHOD OF REF. 1. 5768C THE FOLLOWING INPUT COMPONENT IS OF INTEREST IN THIS REGARD 5769C (AND IS NOT DESCRIBED IN DMNG). 5770C 5771C V(ETA0)..... V(42) IS AN ESTIMATED BOUND ON THE RELATIVE ERROR IN THE 5772C OBJECTIVE FUNCTION VALUE COMPUTED BY CALCF... 5773C (TRUE VALUE) = (COMPUTED VALUE) * (1 + E), 5774C WHERE ABS(E) .LE. V(ETA0). DEFAULT = MACHEP * 10**3, 5775C WHERE MACHEP IS THE UNIT ROUNDOFF. 5776C 5777C THE OUTPUT VALUES IV(NFCALL) AND IV(NGCALL) HAVE DIFFERENT 5778C MEANINGS FOR DMNF THAN FOR DMNG... 5779C 5780C IV(NFCALL)... IV(6) IS THE NUMBER OF CALLS SO FAR MADE ON CALCF (I.E., 5781C FUNCTION EVALUATIONS) EXCLUDING THOSE MADE ONLY FOR 5782C COMPUTING GRADIENTS. THE INPUT VALUE IV(MXFCAL) IS A 5783C LIMIT ON IV(NFCALL). 5784C IV(NGCALL)... IV(30) IS THE NUMBER OF FUNCTION EVALUATIONS MADE ONLY 5785C FOR COMPUTING GRADIENTS. THE TOTAL NUMBER OF FUNCTION 5786C EVALUATIONS IS THUS IV(NFCALL) + IV(NGCALL). 5787C 5788C *** REFERENCES *** 5789C 5790C 1. STEWART, G.W. (1967), A MODIFICATION OF DAVIDON*S MINIMIZATION 5791C METHOD TO ACCEPT DIFFERENCE APPROXIMATIONS OF DERIVATIVES, 5792C J. ASSOC. COMPUT. MACH. 14, PP. 72-83. 5793C. 5794C *** GENERAL *** 5795C 5796C CODED BY DAVID M. GAY (AUGUST 1982). 5797C 5798C---------------------------- DECLARATIONS --------------------------- 5799C 5800 DOUBLE PRECISION DD7TPR 5801 EXTERNAL DIVSET, DD7TPR, DS3GRD, DRMNGB, DV7SCP 5802C 5803C DIVSET.... SUPPLIES DEFAULT PARAMETER VALUES. 5804C DD7TPR... RETURNS INNER PRODUCT OF TWO VECTORS. 5805C DS3GRD... COMPUTES FINITE-DIFFERENCE GRADIENT APPROXIMATION. 5806C DRMNGB... REVERSE-COMMUNICATION ROUTINE THAT DOES DMNGB ALGORITHM. 5807C DV7SCP... SETS ALL ELEMENTS OF A VECTOR TO A SCALAR. 5808C 5809 INTEGER ALPHA, ALPHA0, G1, I, IPI, IV1, J, K, W 5810 DOUBLE PRECISION ZERO 5811C 5812C *** SUBSCRIPTS FOR IV *** 5813C 5814 INTEGER ETA0, F, G, LMAT, NEXTV, NGCALL, 5815 1 NITER, PERM, SGIRC, TOOBIG, VNEED 5816C 5817 PARAMETER (ETA0=42, F=10, G=28, LMAT=42, NEXTV=47, NGCALL=30, 5818 1 NITER=31, PERM=58, SGIRC=57, TOOBIG=2, VNEED=4) 5819 PARAMETER (ZERO=0.D+0) 5820C 5821C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 5822C 5823 IV1 = IV(1) 5824 IF (IV1 .EQ. 1) GO TO 10 5825 IF (IV1 .EQ. 2) GO TO 50 5826 IF (IV(1) .EQ. 0) CALL DIVSET(2, IV, LIV, LV, V) 5827 IV1 = IV(1) 5828 IF (IV1 .EQ. 12 .OR. IV1 .EQ. 13) IV(VNEED) = IV(VNEED) + 2*P + 6 5829 IF (IV1 .EQ. 14) GO TO 10 5830 IF (IV1 .GT. 2 .AND. IV1 .LT. 12) GO TO 10 5831 G1 = 1 5832 IF (IV1 .EQ. 12) IV(1) = 13 5833 GO TO 20 5834C 5835 10 G1 = IV(G) 5836C 5837 20 CALL DRMNGB(B, D, FX, V(G1), IV, LIV, LV, P, V, X) 5838 IF (IV(1) .LT. 2) GO TO 999 5839 IF (IV(1) .GT. 2) GO TO 80 5840C 5841C *** COMPUTE GRADIENT *** 5842C 5843 IF (IV(NITER) .EQ. 0) CALL DV7SCP(P, V(G1), ZERO) 5844 J = IV(LMAT) 5845 ALPHA0 = G1 - P - 1 5846 IPI = IV(PERM) 5847 DO 40 I = 1, P 5848 K = ALPHA0 + IV(IPI) 5849 V(K) = DD7TPR(I, V(J), V(J)) 5850 IPI = IPI + 1 5851 J = J + I 5852 40 CONTINUE 5853C *** UNDO INCREMENT OF IV(NGCALL) DONE BY DRMNGB *** 5854 IV(NGCALL) = IV(NGCALL) - 1 5855C *** STORE RETURN CODE FROM DS3GRD IN IV(SGIRC) *** 5856 IV(SGIRC) = 0 5857C *** X MAY HAVE BEEN RESTORED, SO COPY BACK FX... *** 5858 FX = V(F) 5859 GO TO 60 5860C 5861C *** GRADIENT LOOP *** 5862C 5863 50 IF (IV(TOOBIG) .NE. 0) GO TO 10 5864C 5865 60 G1 = IV(G) 5866 ALPHA = G1 - P 5867 W = ALPHA - 6 5868 CALL DS3GRD(V(ALPHA), B, D, V(ETA0), FX, V(G1), IV(SGIRC), P, 5869 1 V(W), X) 5870 I = IV(SGIRC) 5871 IF (I .EQ. 0) GO TO 10 5872 IF (I .LE. P) GO TO 70 5873 IV(TOOBIG) = 1 5874 GO TO 10 5875C 5876 70 IV(NGCALL) = IV(NGCALL) + 1 5877 GO TO 999 5878C 5879 80 IF (IV(1) .NE. 14) GO TO 999 5880C 5881C *** STORAGE ALLOCATION *** 5882C 5883 IV(G) = IV(NEXTV) + P + 6 5884 IV(NEXTV) = IV(G) + P 5885 IF (IV1 .NE. 13) GO TO 10 5886C 5887 999 RETURN 5888C *** LAST CARD OF DRMNFB FOLLOWS *** 5889 END 5890 SUBROUTINE D7EGR(M,N,NPAIRS,INDROW,JPNTR,INDCOL,IPNTR,NDEG, 5891 * IWA,BWA) 5892 INTEGER M,N,NPAIRS 5893 INTEGER INDROW(NPAIRS),JPNTR(N+1),INDCOL(NPAIRS),IPNTR(M+1), 5894 * NDEG(N),IWA(N) 5895 LOGICAL BWA(N) 5896C ********** 5897C 5898C SUBROUTINE D7EGR 5899C 5900C GIVEN THE SPARSITY PATTERN OF AN M BY N MATRIX A, 5901C THIS SUBROUTINE DETERMINES THE DEGREE SEQUENCE FOR 5902C THE INTERSECTION GRAPH OF THE COLUMNS OF A. 5903C 5904C IN GRAPH-THEORY TERMINOLOGY, THE INTERSECTION GRAPH OF 5905C THE COLUMNS OF A IS THE LOOPLESS GRAPH G WITH VERTICES 5906C A(J), J = 1,2,...,N WHERE A(J) IS THE J-TH COLUMN OF A 5907C AND WITH EDGE (A(I),A(J)) IF AND ONLY IF COLUMNS I AND J 5908C HAVE A NON-ZERO IN THE SAME ROW POSITION. 5909C 5910C NOTE THAT THE VALUE OF M IS NOT NEEDED BY D7EGR AND IS 5911C THEREFORE NOT PRESENT IN THE SUBROUTINE STATEMENT. 5912C 5913C THE SUBROUTINE STATEMENT IS 5914C 5915C SUBROUTINE D7EGR(N,INDROW,JPNTR,INDCOL,IPNTR,NDEG,IWA,BWA) 5916C 5917C WHERE 5918C 5919C N IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE NUMBER 5920C OF COLUMNS OF A. 5921C 5922C INDROW IS AN INTEGER INPUT ARRAY WHICH CONTAINS THE ROW 5923C INDICES FOR THE NON-ZEROES IN THE MATRIX A. 5924C 5925C JPNTR IS AN INTEGER INPUT ARRAY OF LENGTH N + 1 WHICH 5926C SPECIFIES THE LOCATIONS OF THE ROW INDICES IN INDROW. 5927C THE ROW INDICES FOR COLUMN J ARE 5928C 5929C INDROW(K), K = JPNTR(J),...,JPNTR(J+1)-1. 5930C 5931C NOTE THAT JPNTR(N+1)-1 IS THEN THE NUMBER OF NON-ZERO 5932C ELEMENTS OF THE MATRIX A. 5933C 5934C INDCOL IS AN INTEGER INPUT ARRAY WHICH CONTAINS THE 5935C COLUMN INDICES FOR THE NON-ZEROES IN THE MATRIX A. 5936C 5937C IPNTR IS AN INTEGER INPUT ARRAY OF LENGTH M + 1 WHICH 5938C SPECIFIES THE LOCATIONS OF THE COLUMN INDICES IN INDCOL. 5939C THE COLUMN INDICES FOR ROW I ARE 5940C 5941C INDCOL(K), K = IPNTR(I),...,IPNTR(I+1)-1. 5942C 5943C NOTE THAT IPNTR(M+1)-1 IS THEN THE NUMBER OF NON-ZERO 5944C ELEMENTS OF THE MATRIX A. 5945C 5946C NDEG IS AN INTEGER OUTPUT ARRAY OF LENGTH N WHICH 5947C SPECIFIES THE DEGREE SEQUENCE. THE DEGREE OF THE 5948C J-TH COLUMN OF A IS NDEG(J). 5949C 5950C IWA IS AN INTEGER WORK ARRAY OF LENGTH N. 5951C 5952C BWA IS A LOGICAL WORK ARRAY OF LENGTH N. 5953C 5954C ARGONNE NATIONAL LABORATORY. MINPACK PROJECT. JUNE 1982. 5955C THOMAS F. COLEMAN, BURTON S. GARBOW, JORGE J. MORE 5956C 5957C ********** 5958 INTEGER DEG,IC,IP,IPL,IPU,IR,JCOL,JP,JPL,JPU 5959C 5960C INITIALIZATION BLOCK. 5961C 5962 DO 10 JP = 1, N 5963 NDEG(JP) = 0 5964 BWA(JP) = .FALSE. 5965 10 CONTINUE 5966C 5967C COMPUTE THE DEGREE SEQUENCE BY DETERMINING THE CONTRIBUTIONS 5968C TO THE DEGREES FROM THE CURRENT(JCOL) COLUMN AND FURTHER 5969C COLUMNS WHICH HAVE NOT YET BEEN CONSIDERED. 5970C 5971 IF (N .LT. 2) GO TO 90 5972 DO 80 JCOL = 2, N 5973 BWA(JCOL) = .TRUE. 5974 DEG = 0 5975C 5976C DETERMINE ALL POSITIONS (IR,JCOL) WHICH CORRESPOND 5977C TO NON-ZEROES IN THE MATRIX. 5978C 5979 JPL = JPNTR(JCOL) 5980 JPU = JPNTR(JCOL+1) - 1 5981 IF (JPU .LT. JPL) GO TO 50 5982 DO 40 JP = JPL, JPU 5983 IR = INDROW(JP) 5984C 5985C FOR EACH ROW IR, DETERMINE ALL POSITIONS (IR,IC) 5986C WHICH CORRESPOND TO NON-ZEROES IN THE MATRIX. 5987C 5988 IPL = IPNTR(IR) 5989 IPU = IPNTR(IR+1) - 1 5990 DO 30 IP = IPL, IPU 5991 IC = INDCOL(IP) 5992C 5993C ARRAY BWA MARKS COLUMNS WHICH HAVE CONTRIBUTED TO 5994C THE DEGREE COUNT OF COLUMN JCOL. UPDATE THE DEGREE 5995C COUNTS OF THESE COLUMNS. ARRAY IWA RECORDS THE 5996C MARKED COLUMNS. 5997C 5998 IF (BWA(IC)) GO TO 20 5999 BWA(IC) = .TRUE. 6000 NDEG(IC) = NDEG(IC) + 1 6001 DEG = DEG + 1 6002 IWA(DEG) = IC 6003 20 CONTINUE 6004 30 CONTINUE 6005 40 CONTINUE 6006 50 CONTINUE 6007C 6008C UN-MARK THE COLUMNS RECORDED BY IWA AND FINALIZE THE 6009C DEGREE COUNT OF COLUMN JCOL. 6010C 6011 IF (DEG .LT. 1) GO TO 70 6012 DO 60 JP = 1, DEG 6013 IC = IWA(JP) 6014 BWA(IC) = .FALSE. 6015 60 CONTINUE 6016 NDEG(JCOL) = NDEG(JCOL) + DEG 6017 70 CONTINUE 6018 80 CONTINUE 6019 90 CONTINUE 6020 RETURN 6021C 6022C LAST CARD OF SUBROUTINE D7EGR. 6023C 6024 END 6025 SUBROUTINE DRMNG(D, FX, G, IV, LIV, LV, N, V, X) 6026C 6027C *** CARRY OUT DMNG (UNCONSTRAINED MINIMIZATION) ITERATIONS, USING 6028C *** DOUBLE-DOGLEG/BFGS STEPS. 6029C 6030C *** PARAMETER DECLARATIONS *** 6031C 6032 INTEGER LIV, LV, N 6033 INTEGER IV(LIV) 6034 DOUBLE PRECISION D(N), FX, G(N), V(LV), X(N) 6035C 6036C-------------------------- PARAMETER USAGE -------------------------- 6037C 6038C D.... SCALE VECTOR. 6039C FX... FUNCTION VALUE. 6040C G.... GRADIENT VECTOR. 6041C IV... INTEGER VALUE ARRAY. 6042C LIV.. LENGTH OF IV (AT LEAST 60). 6043C LV... LENGTH OF V (AT LEAST 71 + N*(N+13)/2). 6044C N.... NUMBER OF VARIABLES (COMPONENTS IN X AND G). 6045C V.... FLOATING-POINT VALUE ARRAY. 6046C X.... VECTOR OF PARAMETERS TO BE OPTIMIZED. 6047C 6048C *** DISCUSSION *** 6049C 6050C PARAMETERS IV, N, V, AND X ARE THE SAME AS THE CORRESPONDING 6051C ONES TO DMNG (WHICH SEE), EXCEPT THAT V CAN BE SHORTER (SINCE 6052C THE PART OF V THAT DMNG USES FOR STORING G IS NOT NEEDED). 6053C MOREOVER, COMPARED WITH DMNG, IV(1) MAY HAVE THE TWO ADDITIONAL 6054C OUTPUT VALUES 1 AND 2, WHICH ARE EXPLAINED BELOW, AS IS THE USE 6055C OF IV(TOOBIG) AND IV(NFGCAL). THE VALUE IV(G), WHICH IS AN 6056C OUTPUT VALUE FROM DMNG (AND DMNF), IS NOT REFERENCED BY 6057C DRMNG OR THE SUBROUTINES IT CALLS. 6058C FX AND G NEED NOT HAVE BEEN INITIALIZED WHEN DRMNG IS CALLED 6059C WITH IV(1) = 12, 13, OR 14. 6060C 6061C IV(1) = 1 MEANS THE CALLER SHOULD SET FX TO F(X), THE FUNCTION VALUE 6062C AT X, AND CALL DRMNG AGAIN, HAVING CHANGED NONE OF THE 6063C OTHER PARAMETERS. AN EXCEPTION OCCURS IF F(X) CANNOT BE 6064C (E.G. IF OVERFLOW WOULD OCCUR), WHICH MAY HAPPEN BECAUSE 6065C OF AN OVERSIZED STEP. IN THIS CASE THE CALLER SHOULD SET 6066C IV(TOOBIG) = IV(2) TO 1, WHICH WILL CAUSE DRMNG TO IG- 6067C NORE FX AND TRY A SMALLER STEP. THE PARAMETER NF THAT 6068C DMNG PASSES TO CALCF (FOR POSSIBLE USE BY CALCG) IS A 6069C COPY OF IV(NFCALL) = IV(6). 6070C IV(1) = 2 MEANS THE CALLER SHOULD SET G TO G(X), THE GRADIENT VECTOR 6071C OF F AT X, AND CALL DRMNG AGAIN, HAVING CHANGED NONE OF 6072C THE OTHER PARAMETERS EXCEPT POSSIBLY THE SCALE VECTOR D 6073C WHEN IV(DTYPE) = 0. THE PARAMETER NF THAT DMNG PASSES 6074C TO CALCG IS IV(NFGCAL) = IV(7). IF G(X) CANNOT BE 6075C EVALUATED, THEN THE CALLER MAY SET IV(TOOBIG) TO 0, IN 6076C WHICH CASE DRMNG WILL RETURN WITH IV(1) = 65. 6077C. 6078C *** GENERAL *** 6079C 6080C CODED BY DAVID M. GAY (DECEMBER 1979). REVISED SEPT. 1982. 6081C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH SUPPORTED 6082C IN PART BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS 6083C MCS-7600324 AND MCS-7906671. 6084C 6085C (SEE DMNG FOR REFERENCES.) 6086C 6087C+++++++++++++++++++++++++++ DECLARATIONS ++++++++++++++++++++++++++++ 6088C 6089C *** LOCAL VARIABLES *** 6090C 6091 INTEGER DG1, G01, I, K, L, LSTGST, NWTST1, RSTRST, STEP1, 6092 1 TEMP1, W, X01, Z 6093 DOUBLE PRECISION T 6094C 6095C *** CONSTANTS *** 6096C 6097 DOUBLE PRECISION HALF, NEGONE, ONE, ONEP2, ZERO 6098C 6099C *** NO INTRINSIC FUNCTIONS *** 6100C 6101C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 6102C 6103 LOGICAL STOPX 6104 DOUBLE PRECISION DD7TPR, DRLDST, DV2NRM 6105 EXTERNAL DA7SST,DD7DOG,DIVSET, DD7TPR,DITSUM, DL7ITV, DL7IVM, 6106 1 DL7TVM, DL7UPD,DL7VML,DPARCK, DRLDST, STOPX,DV2AXY, 6107 2 DV7CPY, DV7SCP, DV7VMP, DV2NRM, DW7ZBF 6108C 6109C DA7SST.... ASSESSES CANDIDATE STEP. 6110C DD7DOG.... COMPUTES DOUBLE-DOGLEG (CANDIDATE) STEP. 6111C DIVSET.... SUPPLIES DEFAULT IV AND V INPUT COMPONENTS. 6112C DD7TPR... RETURNS INNER PRODUCT OF TWO VECTORS. 6113C DITSUM.... PRINTS ITERATION SUMMARY AND INFO ON INITIAL AND FINAL X. 6114C DL7ITV... MULTIPLIES INVERSE TRANSPOSE OF LOWER TRIANGLE TIMES VECTOR. 6115C DL7IVM... MULTIPLIES INVERSE OF LOWER TRIANGLE TIMES VECTOR. 6116C DL7TVM... MULTIPLIES TRANSPOSE OF LOWER TRIANGLE TIMES VECTOR. 6117C LUPDT.... UPDATES CHOLESKY FACTOR OF HESSIAN APPROXIMATION. 6118C DL7VML.... MULTIPLIES LOWER TRIANGLE TIMES VECTOR. 6119C DPARCK.... CHECKS VALIDITY OF INPUT IV AND V VALUES. 6120C DRLDST... COMPUTES V(RELDX) = RELATIVE STEP SIZE. 6121C STOPX.... RETURNS .TRUE. IF THE BREAK KEY HAS BEEN PRESSED. 6122C DV2AXY.... COMPUTES SCALAR TIMES ONE VECTOR PLUS ANOTHER. 6123C DV7CPY.... COPIES ONE VECTOR TO ANOTHER. 6124C DV7SCP... SETS ALL ELEMENTS OF A VECTOR TO A SCALAR. 6125C DV7VMP... MULTIPLIES VECTOR BY VECTOR RAISED TO POWER (COMPONENTWISE). 6126C DV2NRM... RETURNS THE 2-NORM OF A VECTOR. 6127C DW7ZBF... COMPUTES W AND Z FOR DL7UPD CORRESPONDING TO BFGS UPDATE. 6128C 6129C *** SUBSCRIPTS FOR IV AND V *** 6130C 6131 INTEGER CNVCOD, DG, DGNORM, DINIT, DSTNRM, DST0, F, F0, FDIF, 6132 1 GTHG, GTSTEP, G0, INCFAC, INITH, IRC, KAGQT, LMAT, LMAX0, 6133 2 LMAXS, MODE, MODEL, MXFCAL, MXITER, NEXTV, NFCALL, NFGCAL, 6134 3 NGCALL, NITER, NREDUC, NWTSTP, PREDUC, RADFAC, RADINC, 6135 4 RADIUS, RAD0, RELDX, RESTOR, STEP, STGLIM, STLSTG, TOOBIG, 6136 5 TUNER4, TUNER5, VNEED, XIRC, X0 6137C 6138C *** IV SUBSCRIPT VALUES *** 6139C 6140 PARAMETER (CNVCOD=55, DG=37, G0=48, INITH=25, IRC=29, KAGQT=33, 6141 1 MODE=35, MODEL=5, MXFCAL=17, MXITER=18, NFCALL=6, 6142 2 NFGCAL=7, NGCALL=30, NITER=31, NWTSTP=34, RADINC=8, 6143 3 RESTOR=9, STEP=40, STGLIM=11, STLSTG=41, TOOBIG=2, 6144 4 VNEED=4, XIRC=13, X0=43) 6145C 6146C *** V SUBSCRIPT VALUES *** 6147C 6148 PARAMETER (DGNORM=1, DINIT=38, DSTNRM=2, DST0=3, F=10, F0=13, 6149 1 FDIF=11, GTHG=44, GTSTEP=4, INCFAC=23, LMAT=42, 6150 2 LMAX0=35, LMAXS=36, NEXTV=47, NREDUC=6, PREDUC=7, 6151 3 RADFAC=16, RADIUS=8, RAD0=9, RELDX=17, TUNER4=29, 6152 4 TUNER5=30) 6153C 6154 PARAMETER (HALF=0.5D+0, NEGONE=-1.D+0, ONE=1.D+0, ONEP2=1.2D+0, 6155 1 ZERO=0.D+0) 6156C 6157C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 6158C 6159 I = IV(1) 6160 IF (I .EQ. 1) GO TO 50 6161 IF (I .EQ. 2) GO TO 60 6162C 6163C *** CHECK VALIDITY OF IV AND V INPUT VALUES *** 6164C 6165 IF (IV(1) .EQ. 0) CALL DIVSET(2, IV, LIV, LV, V) 6166 IF (IV(1) .EQ. 12 .OR. IV(1) .EQ. 13) 6167 1 IV(VNEED) = IV(VNEED) + N*(N+13)/2 6168 CALL DPARCK(2, D, IV, LIV, LV, N, V) 6169 I = IV(1) - 2 6170 IF (I .GT. 12) GO TO 999 6171c GO TO (190, 190, 190, 190, 190, 190, 120, 90, 120, 10, 10, 20), I 6172 select case(I) 6173 case(1:6) 6174 goto 190 6175 case(7,9) 6176 goto 120 6177 case(8) 6178 goto 90 6179 case(10,11) 6180 goto 10 6181 case(12) 6182 goto 20 6183 end select 6184C 6185C *** STORAGE ALLOCATION *** 6186C 6187 10 L = IV(LMAT) 6188 IV(X0) = L + N*(N+1)/2 6189 IV(STEP) = IV(X0) + N 6190 IV(STLSTG) = IV(STEP) + N 6191 IV(G0) = IV(STLSTG) + N 6192 IV(NWTSTP) = IV(G0) + N 6193 IV(DG) = IV(NWTSTP) + N 6194 IV(NEXTV) = IV(DG) + N 6195 IF (IV(1) .NE. 13) GO TO 20 6196 IV(1) = 14 6197 GO TO 999 6198C 6199C *** INITIALIZATION *** 6200C 6201 20 IV(NITER) = 0 6202 IV(NFCALL) = 1 6203 IV(NGCALL) = 1 6204 IV(NFGCAL) = 1 6205 IV(MODE) = -1 6206 IV(MODEL) = 1 6207 IV(STGLIM) = 1 6208 IV(TOOBIG) = 0 6209 IV(CNVCOD) = 0 6210 IV(RADINC) = 0 6211 V(RAD0) = ZERO 6212 IF (V(DINIT) .GE. ZERO) CALL DV7SCP(N, D, V(DINIT)) 6213 IF (IV(INITH) .NE. 1) GO TO 40 6214C 6215C *** SET THE INITIAL HESSIAN APPROXIMATION TO DIAG(D)**-2 *** 6216C 6217 L = IV(LMAT) 6218 CALL DV7SCP(N*(N+1)/2, V(L), ZERO) 6219 K = L - 1 6220 DO 30 I = 1, N 6221 K = K + I 6222 T = D(I) 6223 IF (T .LE. ZERO) T = ONE 6224 V(K) = T 6225 30 CONTINUE 6226C 6227C *** COMPUTE INITIAL FUNCTION VALUE *** 6228C 6229 40 IV(1) = 1 6230 GO TO 999 6231C 6232 50 V(F) = FX 6233 IF (IV(MODE) .GE. 0) GO TO 190 6234 V(F0) = FX 6235 IV(1) = 2 6236 IF (IV(TOOBIG) .EQ. 0) GO TO 999 6237 IV(1) = 63 6238 GO TO 350 6239C 6240C *** MAKE SURE GRADIENT COULD BE COMPUTED *** 6241C 6242 60 IF (IV(TOOBIG) .EQ. 0) GO TO 70 6243 IV(1) = 65 6244 GO TO 350 6245C 6246 70 DG1 = IV(DG) 6247 CALL DV7VMP(N, V(DG1), G, D, -1) 6248 V(DGNORM) = DV2NRM(N, V(DG1)) 6249C 6250 IF (IV(CNVCOD) .NE. 0) GO TO 340 6251 IF (IV(MODE) .EQ. 0) GO TO 300 6252C 6253C *** ALLOW FIRST STEP TO HAVE SCALED 2-NORM AT MOST V(LMAX0) *** 6254C 6255 V(RADIUS) = V(LMAX0) 6256C 6257 IV(MODE) = 0 6258C 6259C 6260C----------------------------- MAIN LOOP ----------------------------- 6261C 6262C 6263C *** PRINT ITERATION SUMMARY, CHECK ITERATION LIMIT *** 6264C 6265 80 CALL DITSUM(D, G, IV, LIV, LV, N, V, X) 6266 90 K = IV(NITER) 6267 IF (K .LT. IV(MXITER)) GO TO 100 6268 IV(1) = 10 6269 GO TO 350 6270C 6271C *** UPDATE RADIUS *** 6272C 6273 100 IV(NITER) = K + 1 6274 IF (K .GT. 0) V(RADIUS) = V(RADFAC) * V(DSTNRM) 6275C 6276C *** INITIALIZE FOR START OF NEXT ITERATION *** 6277C 6278 G01 = IV(G0) 6279 X01 = IV(X0) 6280 V(F0) = V(F) 6281 IV(IRC) = 4 6282 IV(KAGQT) = -1 6283C 6284C *** COPY X TO X0, G TO G0 *** 6285C 6286 CALL DV7CPY(N, V(X01), X) 6287 CALL DV7CPY(N, V(G01), G) 6288C 6289C *** CHECK STOPX AND FUNCTION EVALUATION LIMIT *** 6290C 6291 110 IF (.NOT. STOPX()) GO TO 130 6292 IV(1) = 11 6293 GO TO 140 6294C 6295C *** COME HERE WHEN RESTARTING AFTER FUNC. EVAL. LIMIT OR STOPX. 6296C 6297 120 IF (V(F) .GE. V(F0)) GO TO 130 6298 V(RADFAC) = ONE 6299 K = IV(NITER) 6300 GO TO 100 6301C 6302 130 IF (IV(NFCALL) .LT. IV(MXFCAL)) GO TO 150 6303 IV(1) = 9 6304 140 IF (V(F) .GE. V(F0)) GO TO 350 6305C 6306C *** IN CASE OF STOPX OR FUNCTION EVALUATION LIMIT WITH 6307C *** IMPROVED V(F), EVALUATE THE GRADIENT AT X. 6308C 6309 IV(CNVCOD) = IV(1) 6310 GO TO 290 6311C 6312C. . . . . . . . . . . . . COMPUTE CANDIDATE STEP . . . . . . . . . . 6313C 6314 150 STEP1 = IV(STEP) 6315 DG1 = IV(DG) 6316 NWTST1 = IV(NWTSTP) 6317 IF (IV(KAGQT) .GE. 0) GO TO 160 6318 L = IV(LMAT) 6319 CALL DL7IVM(N, V(NWTST1), V(L), G) 6320 V(NREDUC) = HALF * DD7TPR(N, V(NWTST1), V(NWTST1)) 6321 CALL DL7ITV(N, V(NWTST1), V(L), V(NWTST1)) 6322 CALL DV7VMP(N, V(STEP1), V(NWTST1), D, 1) 6323 V(DST0) = DV2NRM(N, V(STEP1)) 6324 CALL DV7VMP(N, V(DG1), V(DG1), D, -1) 6325 CALL DL7TVM(N, V(STEP1), V(L), V(DG1)) 6326 V(GTHG) = DV2NRM(N, V(STEP1)) 6327 IV(KAGQT) = 0 6328 160 CALL DD7DOG(V(DG1), LV, N, V(NWTST1), V(STEP1), V) 6329 IF (IV(IRC) .NE. 6) GO TO 170 6330 IF (IV(RESTOR) .NE. 2) GO TO 190 6331 RSTRST = 2 6332 GO TO 200 6333C 6334C *** CHECK WHETHER EVALUATING F(X0 + STEP) LOOKS WORTHWHILE *** 6335C 6336 170 IV(TOOBIG) = 0 6337 IF (V(DSTNRM) .LE. ZERO) GO TO 190 6338 IF (IV(IRC) .NE. 5) GO TO 180 6339 IF (V(RADFAC) .LE. ONE) GO TO 180 6340 IF (V(PREDUC) .GT. ONEP2 * V(FDIF)) GO TO 180 6341 IF (IV(RESTOR) .NE. 2) GO TO 190 6342 RSTRST = 0 6343 GO TO 200 6344C 6345C *** COMPUTE F(X0 + STEP) *** 6346C 6347 180 X01 = IV(X0) 6348 STEP1 = IV(STEP) 6349 CALL DV2AXY(N, X, ONE, V(STEP1), V(X01)) 6350 IV(NFCALL) = IV(NFCALL) + 1 6351 IV(1) = 1 6352 GO TO 999 6353C 6354C. . . . . . . . . . . . . ASSESS CANDIDATE STEP . . . . . . . . . . . 6355C 6356 190 RSTRST = 3 6357 200 X01 = IV(X0) 6358 V(RELDX) = DRLDST(N, D, X, V(X01)) 6359 CALL DA7SST(IV, LIV, LV, V) 6360 STEP1 = IV(STEP) 6361 LSTGST = IV(STLSTG) 6362 I = IV(RESTOR) + 1 6363c GO TO (240, 210, 220, 230), I 6364 select case(I) 6365 case(1) 6366 goto 240 6367 case(2) 6368 goto 210 6369 case(3) 6370 goto 220 6371 case(4) 6372 goto 230 6373 end select 6374 210 CALL DV7CPY(N, X, V(X01)) 6375 GO TO 240 6376 220 CALL DV7CPY(N, V(LSTGST), V(STEP1)) 6377 GO TO 240 6378 230 CALL DV7CPY(N, V(STEP1), V(LSTGST)) 6379 CALL DV2AXY(N, X, ONE, V(STEP1), V(X01)) 6380 V(RELDX) = DRLDST(N, D, X, V(X01)) 6381 IV(RESTOR) = RSTRST 6382C 6383 240 K = IV(IRC) 6384c GO TO (250,280,280,280,250,260,270,270,270,270,270,270,330,300), K 6385 select case(K) 6386 case(1,5) 6387 goto 250 6388 case(2:4) 6389 goto 280 6390 case(6) 6391 goto 260 6392 case(7:12) 6393 goto 270 6394 case(13) 6395 goto 330 6396 case(14) 6397 goto 300 6398 end select 6399C 6400C *** RECOMPUTE STEP WITH CHANGED RADIUS *** 6401C 6402 250 V(RADIUS) = V(RADFAC) * V(DSTNRM) 6403 GO TO 110 6404C 6405C *** COMPUTE STEP OF LENGTH V(LMAXS) FOR SINGULAR CONVERGENCE TEST. 6406C 6407 260 V(RADIUS) = V(LMAXS) 6408 GO TO 150 6409C 6410C *** CONVERGENCE OR FALSE CONVERGENCE *** 6411C 6412 270 IV(CNVCOD) = K - 4 6413 IF (V(F) .GE. V(F0)) GO TO 340 6414 IF (IV(XIRC) .EQ. 14) GO TO 340 6415 IV(XIRC) = 14 6416C 6417C. . . . . . . . . . . . PROCESS ACCEPTABLE STEP . . . . . . . . . . . 6418C 6419 280 IF (IV(IRC) .NE. 3) GO TO 290 6420 STEP1 = IV(STEP) 6421 TEMP1 = IV(STLSTG) 6422C 6423C *** SET TEMP1 = HESSIAN * STEP FOR USE IN GRADIENT TESTS *** 6424C 6425 L = IV(LMAT) 6426 CALL DL7TVM(N, V(TEMP1), V(L), V(STEP1)) 6427 CALL DL7VML(N, V(TEMP1), V(L), V(TEMP1)) 6428C 6429C *** COMPUTE GRADIENT *** 6430C 6431 290 IV(NGCALL) = IV(NGCALL) + 1 6432 IV(1) = 2 6433 GO TO 999 6434C 6435C *** INITIALIZATIONS -- G0 = G - G0, ETC. *** 6436C 6437 300 G01 = IV(G0) 6438 CALL DV2AXY(N, V(G01), NEGONE, V(G01), G) 6439 STEP1 = IV(STEP) 6440 TEMP1 = IV(STLSTG) 6441 IF (IV(IRC) .NE. 3) GO TO 320 6442C 6443C *** SET V(RADFAC) BY GRADIENT TESTS *** 6444C 6445C *** SET TEMP1 = DIAG(D)**-1 * (HESSIAN*STEP + (G(X0)-G(X))) *** 6446C 6447 CALL DV2AXY(N, V(TEMP1), NEGONE, V(G01), V(TEMP1)) 6448 CALL DV7VMP(N, V(TEMP1), V(TEMP1), D, -1) 6449C 6450C *** DO GRADIENT TESTS *** 6451C 6452 IF (DV2NRM(N, V(TEMP1)) .LE. V(DGNORM) * V(TUNER4)) 6453 1 GO TO 310 6454 IF (DD7TPR(N, G, V(STEP1)) 6455 1 .GE. V(GTSTEP) * V(TUNER5)) GO TO 320 6456 310 V(RADFAC) = V(INCFAC) 6457C 6458C *** UPDATE H, LOOP *** 6459C 6460 320 W = IV(NWTSTP) 6461 Z = IV(X0) 6462 L = IV(LMAT) 6463 CALL DW7ZBF(V(L), N, V(STEP1), V(W), V(G01), V(Z)) 6464C 6465C ** USE THE N-VECTORS STARTING AT V(STEP1) AND V(G01) FOR SCRATCH.. 6466 CALL DL7UPD(V(TEMP1), V(STEP1), V(L), V(G01), V(L), N, V(W), V(Z)) 6467 IV(1) = 2 6468 GO TO 80 6469C 6470C. . . . . . . . . . . . . . MISC. DETAILS . . . . . . . . . . . . . . 6471C 6472C *** BAD PARAMETERS TO ASSESS *** 6473C 6474 330 IV(1) = 64 6475 GO TO 350 6476C 6477C *** PRINT SUMMARY OF FINAL ITERATION AND OTHER REQUESTED ITEMS *** 6478C 6479 340 IV(1) = IV(CNVCOD) 6480 IV(CNVCOD) = 0 6481 350 CALL DITSUM(D, G, IV, LIV, LV, N, V, X) 6482C 6483 999 RETURN 6484C 6485C *** LAST LINE OF DRMNG FOLLOWS *** 6486 END 6487 SUBROUTINE I7DO(M,N,NPAIRS,INDROW,JPNTR,INDCOL,IPNTR,NDEG,LIST, 6488 * MAXCLQ,IWA1,IWA2,IWA3,IWA4,BWA) 6489 INTEGER M,N,MAXCLQ,NPAIRS 6490 INTEGER INDROW(NPAIRS),JPNTR(N+1),INDCOL(NPAIRS),IPNTR(M+1), 6491 * NDEG(N),LIST(N),IWA1(N),IWA2(N),IWA3(N),IWA4(N) 6492 LOGICAL BWA(N) 6493C ********** 6494C 6495C SUBROUTINE I7DO 6496C 6497C GIVEN THE SPARSITY PATTERN OF AN M BY N MATRIX A, THIS 6498C SUBROUTINE DETERMINES AN INCIDENCE-DEGREE ORDERING OF THE 6499C COLUMNS OF A. 6500C 6501C THE INCIDENCE-DEGREE ORDERING IS DEFINED FOR THE LOOPLESS 6502C GRAPH G WITH VERTICES A(J), J = 1,2,...,N WHERE A(J) IS THE 6503C J-TH COLUMN OF A AND WITH EDGE (A(I),A(J)) IF AND ONLY IF 6504C COLUMNS I AND J HAVE A NON-ZERO IN THE SAME ROW POSITION. 6505C 6506C AT EACH STAGE OF I7DO, A COLUMN OF MAXIMAL INCIDENCE IS 6507C CHOSEN AND ORDERED. IF JCOL IS AN UN-ORDERED COLUMN, THEN 6508C THE INCIDENCE OF JCOL IS THE NUMBER OF ORDERED COLUMNS 6509C ADJACENT TO JCOL IN THE GRAPH G. AMONG ALL THE COLUMNS OF 6510C MAXIMAL INCIDENCE,I7DO CHOOSES A COLUMN OF MAXIMAL DEGREE. 6511C 6512C THE SUBROUTINE STATEMENT IS 6513C 6514C SUBROUTINE I7DO(M,N,INDROW,JPNTR,INDCOL,IPNTR,NDEG,LIST, 6515C MAXCLQ,IWA1,IWA2,IWA3,IWA4,BWA) 6516C 6517C WHERE 6518C 6519C M IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE NUMBER 6520C OF ROWS OF A. 6521C 6522C N IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE NUMBER 6523C OF COLUMNS OF A. 6524C 6525C INDROW IS AN INTEGER INPUT ARRAY WHICH CONTAINS THE ROW 6526C INDICES FOR THE NON-ZEROES IN THE MATRIX A. 6527C 6528C JPNTR IS AN INTEGER INPUT ARRAY OF LENGTH N + 1 WHICH 6529C SPECIFIES THE LOCATIONS OF THE ROW INDICES IN INDROW. 6530C THE ROW INDICES FOR COLUMN J ARE 6531C 6532C INDROW(K), K = JPNTR(J),...,JPNTR(J+1)-1. 6533C 6534C NOTE THAT JPNTR(N+1)-1 IS THEN THE NUMBER OF NON-ZERO 6535C ELEMENTS OF THE MATRIX A. 6536C 6537C INDCOL IS AN INTEGER INPUT ARRAY WHICH CONTAINS THE 6538C COLUMN INDICES FOR THE NON-ZEROES IN THE MATRIX A. 6539C 6540C IPNTR IS AN INTEGER INPUT ARRAY OF LENGTH M + 1 WHICH 6541C SPECIFIES THE LOCATIONS OF THE COLUMN INDICES IN INDCOL. 6542C THE COLUMN INDICES FOR ROW I ARE 6543C 6544C INDCOL(K), K = IPNTR(I),...,IPNTR(I+1)-1. 6545C 6546C NOTE THAT IPNTR(M+1)-1 IS THEN THE NUMBER OF NON-ZERO 6547C ELEMENTS OF THE MATRIX A. 6548C 6549C NDEG IS AN INTEGER INPUT ARRAY OF LENGTH N WHICH SPECIFIES 6550C THE DEGREE SEQUENCE. THE DEGREE OF THE J-TH COLUMN 6551C OF A IS NDEG(J). 6552C 6553C LIST IS AN INTEGER OUTPUT ARRAY OF LENGTH N WHICH SPECIFIES 6554C THE INCIDENCE-DEGREE ORDERING OF THE COLUMNS OF A. THE J-TH 6555C COLUMN IN THIS ORDER IS LIST(J). 6556C 6557C MAXCLQ IS AN INTEGER OUTPUT VARIABLE SET TO THE SIZE 6558C OF THE LARGEST CLIQUE FOUND DURING THE ORDERING. 6559C 6560C IWA1,IWA2,IWA3, AND IWA4 ARE INTEGER WORK ARRAYS OF LENGTH N. 6561C 6562C BWA IS A LOGICAL WORK ARRAY OF LENGTH N. 6563C 6564C SUBPROGRAMS CALLED 6565C 6566C MINPACK-SUPPLIED ... N7MSRT 6567C 6568C FORTRAN-SUPPLIED ... MAX0 6569C 6570C ARGONNE NATIONAL LABORATORY. MINPACK PROJECT. JUNE 1982. 6571C THOMAS F. COLEMAN, BURTON S. GARBOW, JORGE J. MORE 6572C 6573C ********** 6574 INTEGER DEG,HEAD,IC,IP,IPL,IPU,IR,JCOL,JP,JPL,JPU,L,MAXINC, 6575 * MAXLST,NCOMP,NUMINC,NUMLST,NUMORD,NUMWGT 6576C 6577C SORT THE DEGREE SEQUENCE. 6578C 6579 CALL N7MSRT(N,N-1,NDEG,-1,IWA4,IWA1,IWA3) 6580C 6581C INITIALIZATION BLOCK. 6582C 6583C CREATE A DOUBLY-LINKED LIST TO ACCESS THE INCIDENCES OF THE 6584C COLUMNS. THE POINTERS FOR THE LINKED LIST ARE AS FOLLOWS. 6585C 6586C EACH UN-ORDERED COLUMN JCOL IS IN A LIST (THE INCIDENCE LIST) 6587C OF COLUMNS WITH THE SAME INCIDENCE. 6588C 6589C IWA1(NUMINC+1) IS THE FIRST COLUMN IN THE NUMINC LIST 6590C UNLESS IWA1(NUMINC+1) = 0. IN THIS CASE THERE ARE 6591C NO COLUMNS IN THE NUMINC LIST. 6592C 6593C IWA2(JCOL) IS THE COLUMN BEFORE JCOL IN THE INCIDENCE LIST 6594C UNLESS IWA2(JCOL) = 0. IN THIS CASE JCOL IS THE FIRST 6595C COLUMN IN THIS INCIDENCE LIST. 6596C 6597C IWA3(JCOL) IS THE COLUMN AFTER JCOL IN THE INCIDENCE LIST 6598C UNLESS IWA3(JCOL) = 0. IN THIS CASE JCOL IS THE LAST 6599C COLUMN IN THIS INCIDENCE LIST. 6600C 6601C IF JCOL IS AN UN-ORDERED COLUMN, THEN LIST(JCOL) IS THE 6602C INCIDENCE OF JCOL IN THE GRAPH. IF JCOL IS AN ORDERED COLUMN, 6603C THEN LIST(JCOL) IS THE INCIDENCE-DEGREE ORDER OF COLUMN JCOL. 6604C 6605 MAXINC = 0 6606 DO 10 JP = 1, N 6607 LIST(JP) = 0 6608 BWA(JP) = .FALSE. 6609 IWA1(JP) = 0 6610 L = IWA4(JP) 6611 IF (JP .NE. 1) IWA2(L) = IWA4(JP-1) 6612 IF (JP .NE. N) IWA3(L) = IWA4(JP+1) 6613 10 CONTINUE 6614 IWA1(1) = IWA4(1) 6615 L = IWA4(1) 6616 IWA2(L) = 0 6617 L = IWA4(N) 6618 IWA3(L) = 0 6619C 6620C DETERMINE THE MAXIMAL SEARCH LENGTH FOR THE LIST 6621C OF COLUMNS OF MAXIMAL INCIDENCE. 6622C 6623 MAXLST = 0 6624 DO 20 IR = 1, M 6625 MAXLST = MAXLST + (IPNTR(IR+1) - IPNTR(IR))**2 6626 20 CONTINUE 6627 MAXLST = MAXLST/N 6628 MAXCLQ = 1 6629C 6630C BEGINNING OF ITERATION LOOP. 6631C 6632 DO 140 NUMORD = 1, N 6633C 6634C CHOOSE A COLUMN JCOL OF MAXIMAL DEGREE AMONG THE 6635C COLUMNS OF MAXIMAL INCIDENCE. 6636C 6637 JP = IWA1(MAXINC+1) 6638 NUMLST = 1 6639 NUMWGT = -1 6640 30 CONTINUE 6641 IF (NDEG(JP) .LE. NUMWGT) GO TO 40 6642 NUMWGT = NDEG(JP) 6643 JCOL = JP 6644 40 CONTINUE 6645 JP = IWA3(JP) 6646 NUMLST = NUMLST + 1 6647 IF (JP .GT. 0 .AND. NUMLST .LE. MAXLST) GO TO 30 6648 LIST(JCOL) = NUMORD 6649C 6650C DELETE COLUMN JCOL FROM THE LIST OF COLUMNS OF 6651C MAXIMAL INCIDENCE. 6652C 6653 L = IWA2(JCOL) 6654 IF (L .EQ. 0) IWA1(MAXINC+1) = IWA3(JCOL) 6655 IF (L .GT. 0) IWA3(L) = IWA3(JCOL) 6656 L = IWA3(JCOL) 6657 IF (L .GT. 0) IWA2(L) = IWA2(JCOL) 6658C 6659C UPDATE THE SIZE OF THE LARGEST CLIQUE 6660C FOUND DURING THE ORDERING. 6661C 6662 IF (MAXINC .EQ. 0) NCOMP = 0 6663 NCOMP = NCOMP + 1 6664 IF (MAXINC + 1 .EQ. NCOMP) MAXCLQ = MAX0(MAXCLQ,NCOMP) 6665C 6666C UPDATE THE MAXIMAL INCIDENCE COUNT. 6667C 6668 50 CONTINUE 6669 IF (IWA1(MAXINC+1) .GT. 0) GO TO 60 6670 MAXINC = MAXINC - 1 6671 IF (MAXINC .GE. 0) GO TO 50 6672 60 CONTINUE 6673C 6674C FIND ALL COLUMNS ADJACENT TO COLUMN JCOL. 6675C 6676 BWA(JCOL) = .TRUE. 6677 DEG = 0 6678C 6679C DETERMINE ALL POSITIONS (IR,JCOL) WHICH CORRESPOND 6680C TO NON-ZEROES IN THE MATRIX. 6681C 6682 JPL = JPNTR(JCOL) 6683 JPU = JPNTR(JCOL+1) - 1 6684 IF (JPU .LT. JPL) GO TO 100 6685 DO 90 JP = JPL, JPU 6686 IR = INDROW(JP) 6687C 6688C FOR EACH ROW IR, DETERMINE ALL POSITIONS (IR,IC) 6689C WHICH CORRESPOND TO NON-ZEROES IN THE MATRIX. 6690C 6691 IPL = IPNTR(IR) 6692 IPU = IPNTR(IR+1) - 1 6693 DO 80 IP = IPL, IPU 6694 IC = INDCOL(IP) 6695C 6696C ARRAY BWA MARKS COLUMNS WHICH ARE ADJACENT TO 6697C COLUMN JCOL. ARRAY IWA4 RECORDS THE MARKED COLUMNS. 6698C 6699 IF (BWA(IC)) GO TO 70 6700 BWA(IC) = .TRUE. 6701 DEG = DEG + 1 6702 IWA4(DEG) = IC 6703 70 CONTINUE 6704 80 CONTINUE 6705 90 CONTINUE 6706 100 CONTINUE 6707C 6708C UPDATE THE POINTERS TO THE INCIDENCE LISTS. 6709C 6710 IF (DEG .LT. 1) GO TO 130 6711 DO 120 JP = 1, DEG 6712 IC = IWA4(JP) 6713 IF (LIST(IC) .GT. 0) GO TO 110 6714 NUMINC = -LIST(IC) + 1 6715 LIST(IC) = -NUMINC 6716 MAXINC = MAX0(MAXINC,NUMINC) 6717C 6718C DELETE COLUMN IC FROM THE NUMINC-1 LIST. 6719C 6720 L = IWA2(IC) 6721 IF (L .EQ. 0) IWA1(NUMINC) = IWA3(IC) 6722 IF (L .GT. 0) IWA3(L) = IWA3(IC) 6723 L = IWA3(IC) 6724 IF (L .GT. 0) IWA2(L) = IWA2(IC) 6725C 6726C ADD COLUMN IC TO THE NUMINC LIST. 6727C 6728 HEAD = IWA1(NUMINC+1) 6729 IWA1(NUMINC+1) = IC 6730 IWA2(IC) = 0 6731 IWA3(IC) = HEAD 6732 IF (HEAD .GT. 0) IWA2(HEAD) = IC 6733 110 CONTINUE 6734C 6735C UN-MARK COLUMN IC IN THE ARRAY BWA. 6736C 6737 BWA(IC) = .FALSE. 6738 120 CONTINUE 6739 130 CONTINUE 6740 BWA(JCOL) = .FALSE. 6741C 6742C END OF ITERATION LOOP. 6743C 6744 140 CONTINUE 6745C 6746C INVERT THE ARRAY LIST. 6747C 6748 DO 150 JCOL = 1, N 6749 NUMORD = LIST(JCOL) 6750 IWA1(NUMORD) = JCOL 6751 150 CONTINUE 6752 DO 160 JP = 1, N 6753 LIST(JP) = IWA1(JP) 6754 160 CONTINUE 6755 RETURN 6756C 6757C LAST CARD OF SUBROUTINE I7DO. 6758C 6759 END 6760 SUBROUTINE M7SLO(N,INDROW,JPNTR,INDCOL,IPNTR,NDEG,LIST, 6761 * MAXCLQ,IWA1,IWA2,IWA3,IWA4,BWA) 6762 INTEGER N,MAXCLQ 6763 INTEGER INDROW(1),JPNTR(1),INDCOL(1),IPNTR(1),NDEG(N), 6764 * LIST(N),IWA1(N),IWA2(N),IWA3(N),IWA4(N) 6765 LOGICAL BWA(N) 6766C ********** 6767C 6768C SUBROUTINE M7SLO 6769C 6770C GIVEN THE SPARSITY PATTERN OF AN M BY N MATRIX A, THIS 6771C SUBROUTINE DETERMINES THE SMALLEST-LAST ORDERING OF THE 6772C COLUMNS OF A. 6773C 6774C THE SMALLEST-LAST ORDERING IS DEFINED FOR THE LOOPLESS 6775C GRAPH G WITH VERTICES A(J), J = 1,2,...,N WHERE A(J) IS THE 6776C J-TH COLUMN OF A AND WITH EDGE (A(I),A(J)) IF AND ONLY IF 6777C COLUMNS I AND J HAVE A NON-ZERO IN THE SAME ROW POSITION. 6778C 6779C THE SMALLEST-LAST ORDERING IS DETERMINED RECURSIVELY BY 6780C LETTING LIST(K), K = N,...,1 BE A COLUMN WITH LEAST DEGREE 6781C IN THE SUBGRAPH SPANNED BY THE UN-ORDERED COLUMNS. 6782C 6783C NOTE THAT THE VALUE OF M IS NOT NEEDED BY M7SLO AND IS 6784C THEREFORE NOT PRESENT IN THE SUBROUTINE STATEMENT. 6785C 6786C THE SUBROUTINE STATEMENT IS 6787C 6788C SUBROUTINE M7SLO(N,INDROW,JPNTR,INDCOL,IPNTR,NDEG,LIST, 6789C MAXCLQ,IWA1,IWA2,IWA3,IWA4,BWA) 6790C 6791C WHERE 6792C 6793C N IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE NUMBER 6794C OF COLUMNS OF A. 6795C 6796C INDROW IS AN INTEGER INPUT ARRAY WHICH CONTAINS THE ROW 6797C INDICES FOR THE NON-ZEROES IN THE MATRIX A. 6798C 6799C JPNTR IS AN INTEGER INPUT ARRAY OF LENGTH N + 1 WHICH 6800C SPECIFIES THE LOCATIONS OF THE ROW INDICES IN INDROW. 6801C THE ROW INDICES FOR COLUMN J ARE 6802C 6803C INDROW(K), K = JPNTR(J),...,JPNTR(J+1)-1. 6804C 6805C NOTE THAT JPNTR(N+1)-1 IS THEN THE NUMBER OF NON-ZERO 6806C ELEMENTS OF THE MATRIX A. 6807C 6808C INDCOL IS AN INTEGER INPUT ARRAY WHICH CONTAINS THE 6809C COLUMN INDICES FOR THE NON-ZEROES IN THE MATRIX A. 6810C 6811C IPNTR IS AN INTEGER INPUT ARRAY OF LENGTH M + 1 WHICH 6812C SPECIFIES THE LOCATIONS OF THE COLUMN INDICES IN INDCOL. 6813C THE COLUMN INDICES FOR ROW I ARE 6814C 6815C INDCOL(K), K = IPNTR(I),...,IPNTR(I+1)-1. 6816C 6817C NOTE THAT IPNTR(M+1)-1 IS THEN THE NUMBER OF NON-ZERO 6818C ELEMENTS OF THE MATRIX A. 6819C 6820C NDEG IS AN INTEGER INPUT ARRAY OF LENGTH N WHICH SPECIFIES 6821C THE DEGREE SEQUENCE. THE DEGREE OF THE J-TH COLUMN 6822C OF A IS NDEG(J). 6823C 6824C LIST IS AN INTEGER OUTPUT ARRAY OF LENGTH N WHICH SPECIFIES 6825C THE SMALLEST-LAST ORDERING OF THE COLUMNS OF A. THE J-TH 6826C COLUMN IN THIS ORDER IS LIST(J). 6827C 6828C MAXCLQ IS AN INTEGER OUTPUT VARIABLE SET TO THE SIZE 6829C OF THE LARGEST CLIQUE FOUND DURING THE ORDERING. 6830C 6831C IWA1,IWA2,IWA3, AND IWA4 ARE INTEGER WORK ARRAYS OF LENGTH N. 6832C 6833C BWA IS A LOGICAL WORK ARRAY OF LENGTH N. 6834C 6835C SUBPROGRAMS CALLED 6836C 6837C FORTRAN-SUPPLIED ... MIN0 6838C 6839C ARGONNE NATIONAL LABORATORY. MINPACK PROJECT. JUNE 1982. 6840C THOMAS F. COLEMAN, BURTON S. GARBOW, JORGE J. MORE 6841C 6842C ********** 6843 INTEGER DEG,HEAD,IC,IP,IPL,IPU,IR,JCOL,JP,JPL,JPU, 6844 * L,MINDEG,NUMDEG,NUMORD 6845C 6846C INITIALIZATION BLOCK. 6847C 6848 MINDEG = N 6849 DO 10 JP = 1, N 6850 IWA1(JP) = 0 6851 BWA(JP) = .FALSE. 6852 LIST(JP) = NDEG(JP) 6853 MINDEG = MIN0(MINDEG,NDEG(JP)) 6854 10 CONTINUE 6855C 6856C CREATE A DOUBLY-LINKED LIST TO ACCESS THE DEGREES OF THE 6857C COLUMNS. THE POINTERS FOR THE LINKED LIST ARE AS FOLLOWS. 6858C 6859C EACH UN-ORDERED COLUMN JCOL IS IN A LIST (THE DEGREE 6860C LIST) OF COLUMNS WITH THE SAME DEGREE. 6861C 6862C IWA1(NUMDEG+1) IS THE FIRST COLUMN IN THE NUMDEG LIST 6863C UNLESS IWA1(NUMDEG+1) = 0. IN THIS CASE THERE ARE 6864C NO COLUMNS IN THE NUMDEG LIST. 6865C 6866C IWA2(JCOL) IS THE COLUMN BEFORE JCOL IN THE DEGREE LIST 6867C UNLESS IWA2(JCOL) = 0. IN THIS CASE JCOL IS THE FIRST 6868C COLUMN IN THIS DEGREE LIST. 6869C 6870C IWA3(JCOL) IS THE COLUMN AFTER JCOL IN THE DEGREE LIST 6871C UNLESS IWA3(JCOL) = 0. IN THIS CASE JCOL IS THE LAST 6872C COLUMN IN THIS DEGREE LIST. 6873C 6874C IF JCOL IS AN UN-ORDERED COLUMN, THEN LIST(JCOL) IS THE 6875C DEGREE OF JCOL IN THE GRAPH INDUCED BY THE UN-ORDERED 6876C COLUMNS. IF JCOL IS AN ORDERED COLUMN, THEN LIST(JCOL) 6877C IS THE SMALLEST-LAST ORDER OF COLUMN JCOL. 6878C 6879 DO 20 JP = 1, N 6880 NUMDEG = NDEG(JP) 6881 HEAD = IWA1(NUMDEG+1) 6882 IWA1(NUMDEG+1) = JP 6883 IWA2(JP) = 0 6884 IWA3(JP) = HEAD 6885 IF (HEAD .GT. 0) IWA2(HEAD) = JP 6886 20 CONTINUE 6887 MAXCLQ = 0 6888 NUMORD = N 6889C 6890C BEGINNING OF ITERATION LOOP. 6891C 6892 30 CONTINUE 6893C 6894C MARK THE SIZE OF THE LARGEST CLIQUE 6895C FOUND DURING THE ORDERING. 6896C 6897 IF (MINDEG + 1 .EQ. NUMORD .AND. MAXCLQ .EQ. 0) 6898 * MAXCLQ = NUMORD 6899C 6900C CHOOSE A COLUMN JCOL OF MINIMAL DEGREE MINDEG. 6901C 6902 40 CONTINUE 6903 JCOL = IWA1(MINDEG+1) 6904 IF (JCOL .GT. 0) GO TO 50 6905 MINDEG = MINDEG + 1 6906 GO TO 40 6907 50 CONTINUE 6908 LIST(JCOL) = NUMORD 6909 NUMORD = NUMORD - 1 6910C 6911C TERMINATION TEST. 6912C 6913 IF (NUMORD .EQ. 0) GO TO 120 6914C 6915C DELETE COLUMN JCOL FROM THE MINDEG LIST. 6916C 6917 L = IWA3(JCOL) 6918 IWA1(MINDEG+1) = L 6919 IF (L .GT. 0) IWA2(L) = 0 6920C 6921C FIND ALL COLUMNS ADJACENT TO COLUMN JCOL. 6922C 6923 BWA(JCOL) = .TRUE. 6924 DEG = 0 6925C 6926C DETERMINE ALL POSITIONS (IR,JCOL) WHICH CORRESPOND 6927C TO NON-ZEROES IN THE MATRIX. 6928C 6929 JPL = JPNTR(JCOL) 6930 JPU = JPNTR(JCOL+1) - 1 6931 IF (JPU .LT. JPL) GO TO 90 6932 DO 80 JP = JPL, JPU 6933 IR = INDROW(JP) 6934C 6935C FOR EACH ROW IR, DETERMINE ALL POSITIONS (IR,IC) 6936C WHICH CORRESPOND TO NON-ZEROES IN THE MATRIX. 6937C 6938 IPL = IPNTR(IR) 6939 IPU = IPNTR(IR+1) - 1 6940 DO 70 IP = IPL, IPU 6941 IC = INDCOL(IP) 6942C 6943C ARRAY BWA MARKS COLUMNS WHICH ARE ADJACENT TO 6944C COLUMN JCOL. ARRAY IWA4 RECORDS THE MARKED COLUMNS. 6945C 6946 IF (BWA(IC)) GO TO 60 6947 BWA(IC) = .TRUE. 6948 DEG = DEG + 1 6949 IWA4(DEG) = IC 6950 60 CONTINUE 6951 70 CONTINUE 6952 80 CONTINUE 6953 90 CONTINUE 6954C 6955C UPDATE THE POINTERS TO THE CURRENT DEGREE LISTS. 6956C 6957 IF (DEG .LT. 1) GO TO 110 6958 DO 100 JP = 1, DEG 6959 IC = IWA4(JP) 6960 NUMDEG = LIST(IC) 6961 LIST(IC) = LIST(IC) - 1 6962 MINDEG = MIN0(MINDEG,LIST(IC)) 6963C 6964C DELETE COLUMN IC FROM THE NUMDEG LIST. 6965C 6966 L = IWA2(IC) 6967 IF (L .EQ. 0) IWA1(NUMDEG+1) = IWA3(IC) 6968 IF (L .GT. 0) IWA3(L) = IWA3(IC) 6969 L = IWA3(IC) 6970 IF (L .GT. 0) IWA2(L) = IWA2(IC) 6971C 6972C ADD COLUMN IC TO THE NUMDEG-1 LIST. 6973C 6974 HEAD = IWA1(NUMDEG) 6975 IWA1(NUMDEG) = IC 6976 IWA2(IC) = 0 6977 IWA3(IC) = HEAD 6978 IF (HEAD .GT. 0) IWA2(HEAD) = IC 6979C 6980C UN-MARK COLUMN IC IN THE ARRAY BWA. 6981C 6982 BWA(IC) = .FALSE. 6983 100 CONTINUE 6984 110 CONTINUE 6985C 6986C END OF ITERATION LOOP. 6987C 6988 GO TO 30 6989 120 CONTINUE 6990C 6991C INVERT THE ARRAY LIST. 6992C 6993 DO 130 JCOL = 1, N 6994 NUMORD = LIST(JCOL) 6995 IWA1(NUMORD) = JCOL 6996 130 CONTINUE 6997 DO 140 JP = 1, N 6998 LIST(JP) = IWA1(JP) 6999 140 CONTINUE 7000 RETURN 7001C 7002C LAST CARD OF SUBROUTINE M7SLO. 7003C 7004 END 7005 SUBROUTINE DS7DMP(N, X, Y, Z, K) 7006C 7007C *** SET X = DIAG(Z)**K * Y * DIAG(Z)**K 7008C *** FOR X, Y = COMPACTLY STORED LOWER TRIANG. MATRICES 7009C *** K = 1 OR -1. 7010C 7011 INTEGER N, K 7012 DOUBLE PRECISION X(*), Y(*), Z(N) 7013 INTEGER I, J, L 7014 DOUBLE PRECISION ONE, T 7015 DATA ONE/1.D+0/ 7016C 7017 L = 1 7018 IF (K .GE. 0) GO TO 30 7019 DO 20 I = 1, N 7020 T = ONE / Z(I) 7021 DO 10 J = 1, I 7022 X(L) = T * Y(L) / Z(J) 7023 L = L + 1 7024 10 CONTINUE 7025 20 CONTINUE 7026 GO TO 999 7027C 7028 30 DO 50 I = 1, N 7029 T = Z(I) 7030 DO 40 J = 1, I 7031 X(L) = T * Y(L) * Z(J) 7032 L = L + 1 7033 40 CONTINUE 7034 50 CONTINUE 7035 999 RETURN 7036C *** LAST CARD OF DS7DMP FOLLOWS *** 7037 END 7038 SUBROUTINE DS7BQN(B, D, DST, IPIV, IPIV1, IPIV2, KB, L, LV, NS, 7039 1 P, P1, STEP, TD, TG, V, W, X, X0) 7040C 7041C *** COMPUTE BOUNDED MODIFIED NEWTON STEP *** 7042C 7043 INTEGER KB, LV, NS, P, P1 7044 INTEGER IPIV(P), IPIV1(P), IPIV2(P) 7045 DOUBLE PRECISION B(2,P), D(P), DST(P), L(*), 7046 1 STEP(P), TD(P), TG(P), V(LV), W(P), X(P), 7047 2 X0(P) 7048C DIMENSION L(P*(P+1)/2) 7049C 7050 DOUBLE PRECISION DD7TPR, DR7MDC, DV2NRM 7051 EXTERNAL DD7TPR, I7SHFT, DL7ITV, DL7IVM, DQ7RSH, DR7MDC, DV2NRM, 7052 1 DV2AXY,DV7CPY, DV7IPR, DV7SCP, DV7SHF 7053C 7054C *** LOCAL VARIABLES *** 7055C 7056 INTEGER I, J, K, P0, P1M1 7057 DOUBLE PRECISION ALPHA, DST0, DST1, DSTMAX, DSTMIN, DX, GTS, T, 7058 1 TI, T1, XI 7059 DOUBLE PRECISION FUDGE, HALF, MEPS2, ONE, TWO, ZERO 7060C 7061C *** V SUBSCRIPTS *** 7062C 7063 INTEGER DSTNRM, GTSTEP, PHMNFC, PHMXFC, PREDUC, RADIUS, STPPAR 7064C 7065 PARAMETER (DSTNRM=2, GTSTEP=4, PHMNFC=20, PHMXFC=21, PREDUC=7, 7066 1 RADIUS=8, STPPAR=5) 7067 SAVE MEPS2 7068C 7069 DATA FUDGE/1.0001D+0/, HALF/0.5D+0/, MEPS2/0.D+0/, 7070 1 ONE/1.0D+0/, TWO/2.D+0/, ZERO/0.D+0/ 7071C 7072C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 7073C 7074 DSTMAX = FUDGE * (ONE + V(PHMXFC)) * V(RADIUS) 7075 DSTMIN = (ONE + V(PHMNFC)) * V(RADIUS) 7076 DST1 = ZERO 7077 IF (MEPS2 .LE. ZERO) MEPS2 = TWO * DR7MDC(3) 7078 P0 = P1 7079 NS = 0 7080 DO 10 I = 1, P 7081 IPIV1(I) = I 7082 IPIV2(I) = I 7083 10 CONTINUE 7084 DO 20 I = 1, P1 7085 W(I) = -STEP(I) * TD(I) 7086 20 CONTINUE 7087 ALPHA = DABS(V(STPPAR)) 7088 V(PREDUC) = ZERO 7089 GTS = -V(GTSTEP) 7090 IF (KB .LT. 0) CALL DV7SCP(P, DST, ZERO) 7091 KB = 1 7092C 7093C *** -W = D TIMES RESTRICTED NEWTON STEP FROM X + DST/D. 7094C 7095C *** FIND T SUCH THAT X - T*W IS STILL FEASIBLE. 7096C 7097 30 T = ONE 7098 K = 0 7099 DO 60 I = 1, P1 7100 J = IPIV(I) 7101 DX = W(I) / D(J) 7102 XI = X(J) - DX 7103 IF (XI .LT. B(1,J)) GO TO 40 7104 IF (XI .LE. B(2,J)) GO TO 60 7105 TI = ( X(J) - B(2,J) ) / DX 7106 K = I 7107 GO TO 50 7108 40 TI = ( X(J) - B(1,J) ) / DX 7109 K = -I 7110 50 IF (T .LE. TI) GO TO 60 7111 T = TI 7112 60 CONTINUE 7113C 7114 IF (P .GT. P1) CALL DV7CPY(P-P1, STEP(P1+1), DST(P1+1)) 7115 CALL DV2AXY(P1, STEP, -T, W, DST) 7116 DST0 = DST1 7117 DST1 = DV2NRM(P, STEP) 7118C 7119C *** CHECK FOR OVERSIZE STEP *** 7120C 7121 IF (DST1 .LE. DSTMAX) GO TO 80 7122 IF (P1 .GE. P0) GO TO 70 7123 IF (DST0 .LT. DSTMIN) KB = 0 7124 GO TO 110 7125C 7126 70 K = 0 7127C 7128C *** UPDATE DST, TG, AND V(PREDUC) *** 7129C 7130 80 V(DSTNRM) = DST1 7131 CALL DV7CPY(P1, DST, STEP) 7132 T1 = ONE - T 7133 DO 90 I = 1, P1 7134 TG(I) = T1 * TG(I) 7135 90 CONTINUE 7136 IF (ALPHA .GT. ZERO) CALL DV2AXY(P1, TG, T*ALPHA, W, TG) 7137 V(PREDUC) = V(PREDUC) + T*((ONE - HALF*T)*GTS + 7138 1 HALF*ALPHA*T*DD7TPR(P1,W,W)) 7139 IF (K .EQ. 0) GO TO 110 7140C 7141C *** PERMUTE L, ETC. IF NECESSARY *** 7142C 7143 P1M1 = P1 - 1 7144 J = IABS(K) 7145 IF (J .EQ. P1) GO TO 100 7146 NS = NS + 1 7147 IPIV2(P1) = J 7148 CALL DQ7RSH(J, P1, .FALSE., TG, L, W) 7149 CALL I7SHFT(P1, J, IPIV) 7150 CALL I7SHFT(P1, J, IPIV1) 7151 CALL DV7SHF(P1, J, TG) 7152 CALL DV7SHF(P1, J, DST) 7153 100 IF (K .LT. 0) IPIV(P1) = -IPIV(P1) 7154 P1 = P1M1 7155 IF (P1 .LE. 0) GO TO 110 7156 CALL DL7IVM(P1, W, L, TG) 7157 GTS = DD7TPR(P1, W, W) 7158 CALL DL7ITV(P1, W, L, W) 7159 GO TO 30 7160C 7161C *** UNSCALE STEP *** 7162C 7163 110 DO 120 I = 1, P 7164 J = IABS(IPIV(I)) 7165 STEP(J) = DST(I) / D(J) 7166 120 CONTINUE 7167C 7168C *** FUDGE STEP TO ENSURE THAT IT FORCES APPROPRIATE COMPONENTS 7169C *** TO THEIR BOUNDS *** 7170C 7171 IF (P1 .GE. P0) GO TO 150 7172 K = P1 + 1 7173 DO 140 I = K, P0 7174 J = IPIV(I) 7175 T = MEPS2 7176 IF (J .GT. 0) GO TO 130 7177 T = -T 7178 J = -J 7179 IPIV(I) = J 7180 130 T = T * DMAX1(DABS(X(J)), DABS(X0(J))) 7181 STEP(J) = STEP(J) + T 7182 140 CONTINUE 7183C 7184 150 CALL DV2AXY(P, X, ONE, STEP, X0) 7185 IF (NS .GT. 0) CALL DV7IPR(P0, IPIV1, TD) 7186 RETURN 7187C *** LAST LINE OF DS7BQN FOLLOWS *** 7188 END 7189 SUBROUTINE N7MSRT(N,NMAX,NUM,MODE,INDEX,LAST,NEXT) 7190 INTEGER N,NMAX,MODE 7191 INTEGER NUM(N),INDEX(N),LAST(1),NEXT(N) 7192C **********. 7193C 7194C SUBROUTINE N7MSRT 7195C 7196C GIVEN A SEQUENCE OF INTEGERS, THIS SUBROUTINE GROUPS 7197C TOGETHER THOSE INDICES WITH THE SAME SEQUENCE VALUE 7198C AND, OPTIONALLY, SORTS THE SEQUENCE INTO EITHER 7199C ASCENDING OR DESCENDING ORDER. 7200C 7201C THE SEQUENCE OF INTEGERS IS DEFINED BY THE ARRAY NUM, 7202C AND IT IS ASSUMED THAT THE INTEGERS ARE EACH FROM THE SET 7203C 0,1,...,NMAX. ON OUTPUT THE INDICES K SUCH THAT NUM(K) = L 7204C FOR ANY L = 0,1,...,NMAX CAN BE OBTAINED FROM THE ARRAYS 7205C LAST AND NEXT AS FOLLOWS. 7206C 7207C K = LAST(L+1) 7208C WHILE (K .NE. 0) K = NEXT(K) 7209C 7210C OPTIONALLY, THE SUBROUTINE PRODUCES AN ARRAY INDEX SO THAT 7211C THE SEQUENCE NUM(INDEX(I)), I = 1,2,...,N IS SORTED. 7212C 7213C THE SUBROUTINE STATEMENT IS 7214C 7215C SUBROUTINE N7MSRT(N,NMAX,NUM,MODE,INDEX,LAST,NEXT) 7216C 7217C WHERE 7218C 7219C N IS A POSITIVE INTEGER INPUT VARIABLE. 7220C 7221C NMAX IS A POSITIVE INTEGER INPUT VARIABLE. 7222C 7223C NUM IS AN INPUT ARRAY OF LENGTH N WHICH CONTAINS THE 7224C SEQUENCE OF INTEGERS TO BE GROUPED AND SORTED. IT 7225C IS ASSUMED THAT THE INTEGERS ARE EACH FROM THE SET 7226C 0,1,...,NMAX. 7227C 7228C MODE IS AN INTEGER INPUT VARIABLE. THE SEQUENCE NUM IS 7229C SORTED IN ASCENDING ORDER IF MODE IS POSITIVE AND IN 7230C DESCENDING ORDER IF MODE IS NEGATIVE. IF MODE IS 0, 7231C NO SORTING IS DONE. 7232C 7233C INDEX IS AN INTEGER OUTPUT ARRAY OF LENGTH N SET SO 7234C THAT THE SEQUENCE 7235C 7236C NUM(INDEX(I)), I = 1,2,...,N 7237C 7238C IS SORTED ACCORDING TO THE SETTING OF MODE. IF MODE 7239C IS 0, INDEX IS NOT REFERENCED. 7240C 7241C LAST IS AN INTEGER OUTPUT ARRAY OF LENGTH NMAX + 1. THE 7242C INDEX OF NUM FOR THE LAST OCCURRENCE OF L IS LAST(L+1) 7243C FOR ANY L = 0,1,...,NMAX UNLESS LAST(L+1) = 0. IN 7244C THIS CASE L DOES NOT APPEAR IN NUM. 7245C 7246C NEXT IS AN INTEGER OUTPUT ARRAY OF LENGTH N. IF 7247C NUM(K) = L, THEN THE INDEX OF NUM FOR THE PREVIOUS 7248C OCCURRENCE OF L IS NEXT(K) FOR ANY L = 0,1,...,NMAX 7249C UNLESS NEXT(K) = 0. IN THIS CASE THERE IS NO PREVIOUS 7250C OCCURRENCE OF L IN NUM. 7251C 7252C ARGONNE NATIONAL LABORATORY. MINPACK PROJECT. JUNE 1982. 7253C THOMAS F. COLEMAN, BURTON S. GARBOW, JORGE J. MORE 7254C 7255C ********** 7256 INTEGER I,J,JP,K,L,NMAXP1,NMAXP2 7257C 7258C DETERMINE THE ARRAYS NEXT AND LAST. 7259C 7260 NMAXP1 = NMAX + 1 7261 DO 10 I = 1, NMAXP1 7262 LAST(I) = 0 7263 10 CONTINUE 7264 DO 20 K = 1, N 7265 L = NUM(K) 7266 NEXT(K) = LAST(L+1) 7267 LAST(L+1) = K 7268 20 CONTINUE 7269 IF (MODE .EQ. 0) GO TO 60 7270C 7271C STORE THE POINTERS TO THE SORTED ARRAY IN INDEX. 7272C 7273 I = 1 7274 NMAXP2 = NMAXP1 + 1 7275 DO 50 J = 1, NMAXP1 7276 JP = J 7277 IF (MODE .LT. 0) JP = NMAXP2 - J 7278 K = LAST(JP) 7279 30 CONTINUE 7280 IF (K .EQ. 0) GO TO 40 7281 INDEX(I) = K 7282 I = I + 1 7283 K = NEXT(K) 7284 GO TO 30 7285 40 CONTINUE 7286 50 CONTINUE 7287 60 CONTINUE 7288 RETURN 7289C 7290C LAST CARD OF SUBROUTINE N7MSRT. 7291C 7292 END 7293 SUBROUTINE DG7LIT(D, G, IV, LIV, LV, P, PS, V, X, Y) 7294C 7295C *** CARRY OUT NL2SOL-LIKE ITERATIONS FOR GENERALIZED LINEAR *** 7296C *** REGRESSION PROBLEMS (AND OTHERS OF SIMILAR STRUCTURE) *** 7297C 7298C *** PARAMETER DECLARATIONS *** 7299C 7300 INTEGER LIV, LV, P, PS 7301 INTEGER IV(LIV) 7302 DOUBLE PRECISION D(P), G(P), V(LV), X(P), Y(P) 7303C 7304C-------------------------- PARAMETER USAGE -------------------------- 7305C 7306C D.... SCALE VECTOR. 7307C IV... INTEGER VALUE ARRAY. 7308C LIV.. LENGTH OF IV. MUST BE AT LEAST 82. 7309C LH... LENGTH OF H = P*(P+1)/2. 7310C LV... LENGTH OF V. MUST BE AT LEAST P*(3*P + 19)/2 + 7. 7311C G.... GRADIENT AT X (WHEN IV(1) = 2). 7312C P.... NUMBER OF PARAMETERS (COMPONENTS IN X). 7313C PS... NUMBER OF NONZERO ROWS AND COLUMNS IN S. 7314C V.... FLOATING-POINT VALUE ARRAY. 7315C X.... PARAMETER VECTOR. 7316C Y.... PART OF YIELD VECTOR (WHEN IV(1)= 2, SCRATCH OTHERWISE). 7317C 7318C *** DISCUSSION *** 7319C 7320C DG7LIT PERFORMS NL2SOL-LIKE ITERATIONS FOR A VARIETY OF 7321C REGRESSION PROBLEMS THAT ARE SIMILAR TO NONLINEAR LEAST-SQUARES 7322C IN THAT THE HESSIAN IS THE SUM OF TWO TERMS, A READILY-COMPUTED 7323C FIRST-ORDER TERM AND A SECOND-ORDER TERM. THE CALLER SUPPLIES 7324C THE FIRST-ORDER TERM OF THE HESSIAN IN HC (LOWER TRIANGLE, STORED 7325C COMPACTLY BY ROWS IN V, STARTING AT IV(HC)), AND DG7LIT BUILDS AN 7326C APPROXIMATION, S, TO THE SECOND-ORDER TERM. THE CALLER ALSO 7327C PROVIDES THE FUNCTION VALUE, GRADIENT, AND PART OF THE YIELD 7328C VECTOR USED IN UPDATING S. DG7LIT DECIDES DYNAMICALLY WHETHER OR 7329C NOT TO USE S WHEN CHOOSING THE NEXT STEP TO TRY... THE HESSIAN 7330C APPROXIMATION USED IS EITHER HC ALONE (GAUSS-NEWTON MODEL) OR 7331C HC + S (AUGMENTED MODEL). 7332C 7333C IF PS .LT. P, THEN ROWS AND COLUMNS PS+1...P OF S ARE KEPT 7334C CONSTANT. THEY WILL BE ZERO UNLESS THE CALLER SETS IV(INITS) TO 7335C 1 OR 2 AND SUPPLIES NONZERO VALUES FOR THEM, OR THE CALLER SETS 7336C IV(INITS) TO 3 OR 4 AND THE FINITE-DIFFERENCE INITIAL S THEN 7337C COMPUTED HAS NONZERO VALUES IN THESE ROWS. 7338C 7339C IF IV(INITS) IS 3 OR 4, THEN THE INITIAL S IS COMPUTED BY 7340C FINITE DIFFERENCES. 3 MEANS USE FUNCTION DIFFERENCES, 4 MEANS 7341C USE GRADIENT DIFFERENCES. FINITE DIFFERENCING IS DONE THE SAME 7342C WAY AS IN COMPUTING A COVARIANCE MATRIX (WITH IV(COVREQ) = -1, -2, 7343C 1, OR 2). 7344C 7345C FOR UPDATING S,DG7LIT ASSUMES THAT THE GRADIENT HAS THE FORM 7346C OF A SUM OVER I OF RHO(I,X)*GRAD(R(I,X)), WHERE GRAD DENOTES THE 7347C GRADIENT WITH RESPECT TO X. THE TRUE SECOND-ORDER TERM THEN IS 7348C THE SUM OVER I OF RHO(I,X)*HESSIAN(R(I,X)). IF X = X0 + STEP, 7349C THEN WE WISH TO UPDATE S SO THAT S*STEP IS THE SUM OVER I OF 7350C RHO(I,X)*(GRAD(R(I,X)) - GRAD(R(I,X0))). THE CALLER MUST SUPPLY 7351C PART OF THIS IN Y, NAMELY THE SUM OVER I OF 7352C RHO(I,X)*GRAD(R(I,X0)), WHEN CALLING DG7LIT WITH IV(1) = 2 AND 7353C IV(MODE) = 0 (WHERE MODE = 38). G THEN CONTANS THE OTHER PART, 7354C SO THAT THE DESIRED YIELD VECTOR IS G - Y. IF PS .LT. P, THEN 7355C THE ABOVE DISCUSSION APPLIES ONLY TO THE FIRST PS COMPONENTS OF 7356C GRAD(R(I,X)), STEP, AND Y. 7357C 7358C PARAMETERS IV, P, V, AND X ARE THE SAME AS THE CORRESPONDING 7359C ONES TO NL2SOL (WHICH SEE), EXCEPT THAT V CAN BE SHORTER 7360C (SINCE THE PART OF V THAT NL2SOL USES FOR STORING D, J, AND R IS 7361C NOT NEEDED). MOREOVER, COMPARED WITH NL2SOL, IV(1) MAY HAVE THE 7362C TWO ADDITIONAL OUTPUT VALUES 1 AND 2, WHICH ARE EXPLAINED BELOW, 7363C AS IS THE USE OF IV(TOOBIG) AND IV(NFGCAL). THE VALUES IV(D), 7364C IV(J), AND IV(R), WHICH ARE OUTPUT VALUES FROM NL2SOL (AND 7365C NL2SNO), ARE NOT REFERENCED BY DG7LIT OR THE SUBROUTINES IT CALLS. 7366C 7367C WHEN DG7LIT IS FIRST CALLED, I.E., WHEN DG7LIT IS CALLED WITH 7368C IV(1) = 0 OR 12, V(F), G, AND HC NEED NOT BE INITIALIZED. TO 7369C OBTAIN THESE STARTING VALUES,DG7LIT RETURNS FIRST WITH IV(1) = 1, 7370C THEN WITH IV(1) = 2, WITH IV(MODE) = -1 IN BOTH CASES. ON 7371C SUBSEQUENT RETURNS WITH IV(1) = 2, IV(MODE) = 0 IMPLIES THAT 7372C Y MUST ALSO BE SUPPLIED. (NOTE THAT Y IS USED FOR SCRATCH -- ITS 7373C INPUT CONTENTS ARE LOST. BY CONTRAST, HC IS NEVER CHANGED.) 7374C ONCE CONVERGENCE HAS BEEN OBTAINED, IV(RDREQ) AND IV(COVREQ) MAY 7375C IMPLY THAT A FINITE-DIFFERENCE HESSIAN SHOULD BE COMPUTED FOR USE 7376C IN COMPUTING A COVARIANCE MATRIX. IN THIS CASE DG7LIT WILL MAKE A 7377C NUMBER OF RETURNS WITH IV(1) = 1 OR 2 AND IV(MODE) POSITIVE. 7378C WHEN IV(MODE) IS POSITIVE, Y SHOULD NOT BE CHANGED. 7379C 7380C IV(1) = 1 MEANS THE CALLER SHOULD SET V(F) (I.E., V(10)) TO F(X), THE 7381C FUNCTION VALUE AT X, AND CALL DG7LIT AGAIN, HAVING CHANGED 7382C NONE OF THE OTHER PARAMETERS. AN EXCEPTION OCCURS IF F(X) 7383C CANNOT BE EVALUATED (E.G. IF OVERFLOW WOULD OCCUR), WHICH 7384C MAY HAPPEN BECAUSE OF AN OVERSIZED STEP. IN THIS CASE 7385C THE CALLER SHOULD SET IV(TOOBIG) = IV(2) TO 1, WHICH WILL 7386C CAUSE DG7LIT TO IGNORE V(F) AND TRY A SMALLER STEP. NOTE 7387C THAT THE CURRENT FUNCTION EVALUATION COUNT IS AVAILABLE 7388C IN IV(NFCALL) = IV(6). THIS MAY BE USED TO IDENTIFY 7389C WHICH COPY OF SAVED INFORMATION SHOULD BE USED IN COM- 7390C PUTING G, HC, AND Y THE NEXT TIME DG7LIT RETURNS WITH 7391C IV(1) = 2. SEE MLPIT FOR AN EXAMPLE OF THIS. 7392C IV(1) = 2 MEANS THE CALLER SHOULD SET G TO G(X), THE GRADIENT OF F AT 7393C X. THE CALLER SHOULD ALSO SET HC TO THE GAUSS-NEWTON 7394C HESSIAN AT X. IF IV(MODE) = 0, THEN THE CALLER SHOULD 7395C ALSO COMPUTE THE PART OF THE YIELD VECTOR DESCRIBED ABOVE. 7396C THE CALLER SHOULD THEN CALL DG7LIT AGAIN (WITH IV(1) = 2). 7397C THE CALLER MAY ALSO CHANGE D AT THIS TIME, BUT SHOULD NOT 7398C CHANGE X. NOTE THAT IV(NFGCAL) = IV(7) CONTAINS THE 7399C VALUE THAT IV(NFCALL) HAD DURING THE RETURN WITH 7400C IV(1) = 1 IN WHICH X HAD THE SAME VALUE AS IT NOW HAS. 7401C IV(NFGCAL) IS EITHER IV(NFCALL) OR IV(NFCALL) - 1. MLPIT 7402C IS AN EXAMPLE WHERE THIS INFORMATION IS USED. IF G OR HC 7403C CANNOT BE EVALUATED AT X, THEN THE CALLER MAY SET 7404C IV(TOOBIG) TO 1, IN WHICH CASE DG7LIT WILL RETURN WITH 7405C IV(1) = 15. 7406C 7407C *** GENERAL *** 7408C 7409C CODED BY DAVID M. GAY. 7410C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH 7411C SUPPORTED IN PART BY D.O.E. GRANT EX-76-A-01-2295 TO MIT/CCREMS. 7412C 7413C (SEE NL2SOL FOR REFERENCES.) 7414C 7415C+++++++++++++++++++++++++++ DECLARATIONS ++++++++++++++++++++++++++++ 7416C 7417C *** LOCAL VARIABLES *** 7418C 7419 INTEGER DIG1, G01, H1, HC1, I, IPIV1, J, K, L, LMAT1, 7420 1 LSTGST, PP1O2, QTR1, RMAT1, RSTRST, STEP1, STPMOD, S1, 7421 2 TEMP1, TEMP2, W1, X01 7422 DOUBLE PRECISION E, STTSST, T, T1 7423C 7424C *** CONSTANTS *** 7425C 7426 DOUBLE PRECISION HALF, NEGONE, ONE, ONEP2, ZERO 7427C 7428C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 7429C 7430 LOGICAL STOPX 7431 DOUBLE PRECISION DD7TPR, DL7SVX, DL7SVN, DRLDST, DR7MDC, DV2NRM 7432 EXTERNAL DA7SST, DD7TPR,DF7HES,DG7QTS,DITSUM, DL7MST,DL7SRT, 7433 1 DL7SQR, DL7SVX, DL7SVN, DL7TVM,DL7VML,DPARCK, DRLDST, 7434 2 DR7MDC, DS7LUP, DS7LVM, STOPX,DV2AXY,DV7CPY, DV7SCP, 7435 3 DV2NRM 7436C 7437C DA7SST.... ASSESSES CANDIDATE STEP. 7438C DD7TPR... RETURNS INNER PRODUCT OF TWO VECTORS. 7439C DF7HES.... COMPUTE FINITE-DIFFERENCE HESSIAN (FOR COVARIANCE). 7440C DG7QTS.... COMPUTES GOLDFELD-QUANDT-TROTTER STEP (AUGMENTED MODEL). 7441C DITSUM.... PRINTS ITERATION SUMMARY AND INFO ON INITIAL AND FINAL X. 7442C DL7MST... COMPUTES LEVENBERG-MARQUARDT STEP (GAUSS-NEWTON MODEL). 7443C DL7SRT.... COMPUTES CHOLESKY FACTOR OF (LOWER TRIANG. OF) SYM. MATRIX. 7444C DL7SQR... COMPUTES L * L**T FROM LOWER TRIANGULAR MATRIX L. 7445C DL7TVM... COMPUTES L**T * V, V = VECTOR, L = LOWER TRIANGULAR MATRIX. 7446C DL7SVX... ESTIMATES LARGEST SING. VALUE OF LOWER TRIANG. MATRIX. 7447C DL7SVN... ESTIMATES SMALLEST SING. VALUE OF LOWER TRIANG. MATRIX. 7448C DL7VML.... COMPUTES L * V, V = VECTOR, L = LOWER TRIANGULAR MATRIX. 7449C DPARCK.... CHECK VALIDITY OF IV AND V INPUT COMPONENTS. 7450C DRLDST... COMPUTES V(RELDX) = RELATIVE STEP SIZE. 7451C DR7MDC... RETURNS MACHINE-DEPENDENT CONSTANTS. 7452C DS7LUP... PERFORMS QUASI-NEWTON UPDATE ON COMPACTLY STORED LOWER TRI- 7453C ANGLE OF A SYMMETRIC MATRIX. 7454C STOPX.... RETURNS .TRUE. IF THE BREAK KEY HAS BEEN PRESSED. 7455C DV2AXY.... COMPUTES SCALAR TIMES ONE VECTOR PLUS ANOTHER. 7456C DV7CPY.... COPIES ONE VECTOR TO ANOTHER. 7457C DV7SCP... SETS ALL ELEMENTS OF A VECTOR TO A SCALAR. 7458C DV2NRM... RETURNS THE 2-NORM OF A VECTOR. 7459C 7460C *** SUBSCRIPTS FOR IV AND V *** 7461C 7462 INTEGER CNVCOD, COSMIN, COVMAT, COVREQ, DGNORM, DIG, DSTNRM, F, 7463 1 FDH, FDIF, FUZZ, F0, GTSTEP, H, HC, IERR, INCFAC, INITS, 7464 2 IPIVOT, IRC, KAGQT, KALM, LMAT, LMAX0, LMAXS, MODE, MODEL, 7465 3 MXFCAL, MXITER, NEXTV, NFCALL, NFGCAL, NFCOV, NGCOV, 7466 4 NGCALL, NITER, NVSAVE, PHMXFC, PREDUC, QTR, RADFAC, 7467 5 RADINC, RADIUS, RAD0, RCOND, RDREQ, REGD, RELDX, RESTOR, 7468 6 RMAT, S, SIZE, STEP, STGLIM, STLSTG, STPPAR, SUSED, 7469 7 SWITCH, TOOBIG, TUNER4, TUNER5, VNEED, VSAVE, W, WSCALE, 7470 8 XIRC, X0 7471C 7472C *** IV SUBSCRIPT VALUES *** 7473C 7474 PARAMETER (CNVCOD=55, COVMAT=26, COVREQ=15, DIG=37, FDH=74, H=56, 7475 1 HC=71, IERR=75, INITS=25, IPIVOT=76, IRC=29, KAGQT=33, 7476 2 KALM=34, LMAT=42, MODE=35, MODEL=5, MXFCAL=17, 7477 3 MXITER=18, NEXTV=47, NFCALL=6, NFGCAL=7, NFCOV=52, 7478 4 NGCOV=53, NGCALL=30, NITER=31, QTR=77, RADINC=8, 7479 5 RDREQ=57, REGD=67, RESTOR=9, RMAT=78, S=62, STEP=40, 7480 6 STGLIM=11, STLSTG=41, SUSED=64, SWITCH=12, TOOBIG=2, 7481 7 VNEED=4, VSAVE=60, W=65, XIRC=13, X0=43) 7482C 7483C *** V SUBSCRIPT VALUES *** 7484C 7485 PARAMETER (COSMIN=47, DGNORM=1, DSTNRM=2, F=10, FDIF=11, FUZZ=45, 7486 1 F0=13, GTSTEP=4, INCFAC=23, LMAX0=35, LMAXS=36, 7487 2 NVSAVE=9, PHMXFC=21, PREDUC=7, RADFAC=16, RADIUS=8, 7488 3 RAD0=9, RCOND=53, RELDX=17, SIZE=55, STPPAR=5, 7489 4 TUNER4=29, TUNER5=30, WSCALE=56) 7490C 7491C 7492 PARAMETER (HALF=0.5D+0, NEGONE=-1.D+0, ONE=1.D+0, ONEP2=1.2D+0, 7493 1 ZERO=0.D+0) 7494C 7495C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 7496C 7497 I = IV(1) 7498 IF (I .EQ. 1) GO TO 40 7499 IF (I .EQ. 2) GO TO 50 7500C 7501 IF (I .EQ. 12 .OR. I .EQ. 13) 7502 1 IV(VNEED) = IV(VNEED) + P*(3*P + 19)/2 + 7 7503 CALL DPARCK(1, D, IV, LIV, LV, P, V) 7504 I = IV(1) - 2 7505 IF (I .GT. 12) GO TO 999 7506c GO TO (290, 290, 290, 290, 290, 290, 170, 120, 170, 10, 10, 20), I 7507 select case(I) 7508 case(1:6) 7509 goto 290 7510 case(7,9) 7511 goto 170 7512 case(8) 7513 goto 120 7514 case(10,11) 7515 goto 10 7516 case(12) 7517 goto 20 7518 end select 7519C 7520C *** STORAGE ALLOCATION *** 7521C 7522 10 PP1O2 = P * (P + 1) / 2 7523 IV(S) = IV(LMAT) + PP1O2 7524 IV(X0) = IV(S) + PP1O2 7525 IV(STEP) = IV(X0) + P 7526 IV(STLSTG) = IV(STEP) + P 7527 IV(DIG) = IV(STLSTG) + P 7528 IV(W) = IV(DIG) + P 7529 IV(H) = IV(W) + 4*P + 7 7530 IV(NEXTV) = IV(H) + PP1O2 7531 IF (IV(1) .NE. 13) GO TO 20 7532 IV(1) = 14 7533 GO TO 999 7534C 7535C *** INITIALIZATION *** 7536C 7537 20 IV(NITER) = 0 7538 IV(NFCALL) = 1 7539 IV(NGCALL) = 1 7540 IV(NFGCAL) = 1 7541 IV(MODE) = -1 7542 IV(STGLIM) = 2 7543 IV(TOOBIG) = 0 7544 IV(CNVCOD) = 0 7545 IV(COVMAT) = 0 7546 IV(NFCOV) = 0 7547 IV(NGCOV) = 0 7548 IV(RADINC) = 0 7549 IV(RESTOR) = 0 7550 IV(FDH) = 0 7551 V(RAD0) = ZERO 7552 V(STPPAR) = ZERO 7553 V(RADIUS) = V(LMAX0) / (ONE + V(PHMXFC)) 7554C 7555C *** SET INITIAL MODEL AND S MATRIX *** 7556C 7557 IV(MODEL) = 1 7558 IF (IV(S) .LT. 0) GO TO 999 7559 IF (IV(INITS) .GT. 1) IV(MODEL) = 2 7560 S1 = IV(S) 7561 IF (IV(INITS) .EQ. 0 .OR. IV(INITS) .GT. 2) 7562 1 CALL DV7SCP(P*(P+1)/2, V(S1), ZERO) 7563 IV(1) = 1 7564 J = IV(IPIVOT) 7565 IF (J .LE. 0) GO TO 999 7566 DO 30 I = 1, P 7567 IV(J) = I 7568 J = J + 1 7569 30 CONTINUE 7570 GO TO 999 7571C 7572C *** NEW FUNCTION VALUE *** 7573C 7574 40 IF (IV(MODE) .EQ. 0) GO TO 290 7575 IF (IV(MODE) .GT. 0) GO TO 520 7576C 7577 IV(1) = 2 7578 IF (IV(TOOBIG) .EQ. 0) GO TO 999 7579 IV(1) = 63 7580 GO TO 999 7581C 7582C *** NEW GRADIENT *** 7583C 7584 50 IV(KALM) = -1 7585 IV(KAGQT) = -1 7586 IV(FDH) = 0 7587 IF (IV(MODE) .GT. 0) GO TO 520 7588C 7589C *** MAKE SURE GRADIENT COULD BE COMPUTED *** 7590C 7591 IF (IV(TOOBIG) .EQ. 0) GO TO 60 7592 IV(1) = 65 7593 GO TO 999 7594 60 IF (IV(HC) .LE. 0 .AND. IV(RMAT) .LE. 0) GO TO 610 7595C 7596C *** COMPUTE D**-1 * GRADIENT *** 7597C 7598 DIG1 = IV(DIG) 7599 K = DIG1 7600 DO 70 I = 1, P 7601 V(K) = G(I) / D(I) 7602 K = K + 1 7603 70 CONTINUE 7604 V(DGNORM) = DV2NRM(P, V(DIG1)) 7605C 7606 IF (IV(CNVCOD) .NE. 0) GO TO 510 7607 IF (IV(MODE) .EQ. 0) GO TO 440 7608 IV(MODE) = 0 7609 V(F0) = V(F) 7610 IF (IV(INITS) .LE. 2) GO TO 100 7611C 7612C *** ARRANGE FOR FINITE-DIFFERENCE INITIAL S *** 7613C 7614 IV(XIRC) = IV(COVREQ) 7615 IV(COVREQ) = -1 7616 IF (IV(INITS) .GT. 3) IV(COVREQ) = 1 7617 IV(CNVCOD) = 70 7618 GO TO 530 7619C 7620C *** COME TO NEXT STMT AFTER COMPUTING F.D. HESSIAN FOR INIT. S *** 7621C 7622 80 IV(CNVCOD) = 0 7623 IV(MODE) = 0 7624 IV(NFCOV) = 0 7625 IV(NGCOV) = 0 7626 IV(COVREQ) = IV(XIRC) 7627 S1 = IV(S) 7628 PP1O2 = PS * (PS + 1) / 2 7629 HC1 = IV(HC) 7630 IF (HC1 .LE. 0) GO TO 90 7631 CALL DV2AXY(PP1O2, V(S1), NEGONE, V(HC1), V(H1)) 7632 GO TO 100 7633 90 RMAT1 = IV(RMAT) 7634 CALL DL7SQR(PS, V(S1), V(RMAT1)) 7635 CALL DV2AXY(PP1O2, V(S1), NEGONE, V(S1), V(H1)) 7636 100 IV(1) = 2 7637C 7638C 7639C----------------------------- MAIN LOOP ----------------------------- 7640C 7641C 7642C *** PRINT ITERATION SUMMARY, CHECK ITERATION LIMIT *** 7643C 7644 110 CALL DITSUM(D, G, IV, LIV, LV, P, V, X) 7645 120 K = IV(NITER) 7646 IF (K .LT. IV(MXITER)) GO TO 130 7647 IV(1) = 10 7648 GO TO 999 7649 130 IV(NITER) = K + 1 7650C 7651C *** UPDATE RADIUS *** 7652C 7653 IF (K .EQ. 0) GO TO 150 7654 STEP1 = IV(STEP) 7655 DO 140 I = 1, P 7656 V(STEP1) = D(I) * V(STEP1) 7657 STEP1 = STEP1 + 1 7658 140 CONTINUE 7659 STEP1 = IV(STEP) 7660 T = V(RADFAC) * DV2NRM(P, V(STEP1)) 7661 IF (V(RADFAC) .LT. ONE .OR. T .GT. V(RADIUS)) V(RADIUS) = T 7662C 7663C *** INITIALIZE FOR START OF NEXT ITERATION *** 7664C 7665 150 X01 = IV(X0) 7666 V(F0) = V(F) 7667 IV(IRC) = 4 7668 IV(H) = -IABS(IV(H)) 7669 IV(SUSED) = IV(MODEL) 7670C 7671C *** COPY X TO X0 *** 7672C 7673 CALL DV7CPY(P, V(X01), X) 7674C 7675C *** CHECK STOPX AND FUNCTION EVALUATION LIMIT *** 7676C 7677 160 IF (.NOT. STOPX()) GO TO 180 7678 IV(1) = 11 7679 GO TO 190 7680C 7681C *** COME HERE WHEN RESTARTING AFTER FUNC. EVAL. LIMIT OR STOPX. 7682C 7683 170 IF (V(F) .GE. V(F0)) GO TO 180 7684 V(RADFAC) = ONE 7685 K = IV(NITER) 7686 GO TO 130 7687C 7688 180 IF (IV(NFCALL) .LT. IV(MXFCAL) + IV(NFCOV)) GO TO 200 7689 IV(1) = 9 7690 190 IF (V(F) .GE. V(F0)) GO TO 999 7691C 7692C *** IN CASE OF STOPX OR FUNCTION EVALUATION LIMIT WITH 7693C *** IMPROVED V(F), EVALUATE THE GRADIENT AT X. 7694C 7695 IV(CNVCOD) = IV(1) 7696 GO TO 430 7697C 7698C. . . . . . . . . . . . . COMPUTE CANDIDATE STEP . . . . . . . . . . 7699C 7700 200 STEP1 = IV(STEP) 7701 W1 = IV(W) 7702 H1 = IV(H) 7703 T1 = ONE 7704 IF (IV(MODEL) .EQ. 2) GO TO 210 7705 T1 = ZERO 7706C 7707C *** COMPUTE LEVENBERG-MARQUARDT STEP IF POSSIBLE... 7708C 7709 RMAT1 = IV(RMAT) 7710 IF (RMAT1 .LE. 0) GO TO 210 7711 QTR1 = IV(QTR) 7712 IF (QTR1 .LE. 0) GO TO 210 7713 IPIV1 = IV(IPIVOT) 7714 CALL DL7MST(D, G, IV(IERR), IV(IPIV1), IV(KALM), P, V(QTR1), 7715 1 V(RMAT1), V(STEP1), V, V(W1)) 7716C *** H IS STORED IN THE END OF W AND HAS JUST BEEN OVERWRITTEN, 7717C *** SO WE MARK IT INVALID... 7718 IV(H) = -IABS(H1) 7719C *** EVEN IF H WERE STORED ELSEWHERE, IT WOULD BE NECESSARY TO 7720C *** MARK INVALID THE INFORMATION DG7QTS MAY HAVE STORED IN V... 7721 IV(KAGQT) = -1 7722 GO TO 260 7723C 7724 210 IF (H1 .GT. 0) GO TO 250 7725C 7726C *** SET H TO D**-1 * (HC + T1*S) * D**-1. *** 7727C 7728 H1 = -H1 7729 IV(H) = H1 7730 IV(FDH) = 0 7731 J = IV(HC) 7732 IF (J .GT. 0) GO TO 220 7733 J = H1 7734 RMAT1 = IV(RMAT) 7735 CALL DL7SQR(P, V(H1), V(RMAT1)) 7736 220 S1 = IV(S) 7737 DO 240 I = 1, P 7738 T = ONE / D(I) 7739 DO 230 K = 1, I 7740 V(H1) = T * (V(J) + T1*V(S1)) / D(K) 7741 J = J + 1 7742 H1 = H1 + 1 7743 S1 = S1 + 1 7744 230 CONTINUE 7745 240 CONTINUE 7746 H1 = IV(H) 7747 IV(KAGQT) = -1 7748C 7749C *** COMPUTE ACTUAL GOLDFELD-QUANDT-TROTTER STEP *** 7750C 7751 250 DIG1 = IV(DIG) 7752 LMAT1 = IV(LMAT) 7753 CALL DG7QTS(D, V(DIG1), V(H1), IV(KAGQT), V(LMAT1), P, V(STEP1), 7754 1 V, V(W1)) 7755 IF (IV(KALM) .GT. 0) IV(KALM) = 0 7756C 7757 260 IF (IV(IRC) .NE. 6) GO TO 270 7758 IF (IV(RESTOR) .NE. 2) GO TO 290 7759 RSTRST = 2 7760 GO TO 300 7761C 7762C *** CHECK WHETHER EVALUATING F(X0 + STEP) LOOKS WORTHWHILE *** 7763C 7764 270 IV(TOOBIG) = 0 7765 IF (V(DSTNRM) .LE. ZERO) GO TO 290 7766 IF (IV(IRC) .NE. 5) GO TO 280 7767 IF (V(RADFAC) .LE. ONE) GO TO 280 7768 IF (V(PREDUC) .GT. ONEP2 * V(FDIF)) GO TO 280 7769 STEP1 = IV(STEP) 7770 X01 = IV(X0) 7771 CALL DV2AXY(P, V(STEP1), NEGONE, V(X01), X) 7772 IF (IV(RESTOR) .NE. 2) GO TO 290 7773 RSTRST = 0 7774 GO TO 300 7775C 7776C *** COMPUTE F(X0 + STEP) *** 7777C 7778 280 X01 = IV(X0) 7779 STEP1 = IV(STEP) 7780 CALL DV2AXY(P, X, ONE, V(STEP1), V(X01)) 7781 IV(NFCALL) = IV(NFCALL) + 1 7782 IV(1) = 1 7783 GO TO 999 7784C 7785C. . . . . . . . . . . . . ASSESS CANDIDATE STEP . . . . . . . . . . . 7786C 7787 290 RSTRST = 3 7788 300 X01 = IV(X0) 7789 V(RELDX) = DRLDST(P, D, X, V(X01)) 7790 CALL DA7SST(IV, LIV, LV, V) 7791 STEP1 = IV(STEP) 7792 LSTGST = IV(STLSTG) 7793 I = IV(RESTOR) + 1 7794c GO TO (340, 310, 320, 330), I 7795 select case(I) 7796 case(1) 7797 goto 340 7798 case(2) 7799 goto 310 7800 case(3) 7801 goto 320 7802 case(4) 7803 goto 330 7804 end select 7805 310 CALL DV7CPY(P, X, V(X01)) 7806 GO TO 340 7807 320 CALL DV7CPY(P, V(LSTGST), V(STEP1)) 7808 GO TO 340 7809 330 CALL DV7CPY(P, V(STEP1), V(LSTGST)) 7810 CALL DV2AXY(P, X, ONE, V(STEP1), V(X01)) 7811 V(RELDX) = DRLDST(P, D, X, V(X01)) 7812 IV(RESTOR) = RSTRST 7813C 7814C *** IF NECESSARY, SWITCH MODELS *** 7815C 7816 340 IF (IV(SWITCH) .EQ. 0) GO TO 350 7817 IV(H) = -IABS(IV(H)) 7818 IV(SUSED) = IV(SUSED) + 2 7819 L = IV(VSAVE) 7820 CALL DV7CPY(NVSAVE, V, V(L)) 7821 350 L = IV(IRC) - 4 7822 STPMOD = IV(MODEL) 7823 IF (L .GT. 0) THEN 7824c GO TO (370,380,390,390,390,390,390,390,500,440), L 7825 select case(L) 7826 case(1) 7827 goto 370 7828 case(2) 7829 goto 380 7830 case(3:8) 7831 goto 390 7832 case(9) 7833 goto 500 7834 case(10) 7835 goto 440 7836 end select 7837 END IF 7838C 7839C *** DECIDE WHETHER TO CHANGE MODELS *** 7840C 7841 E = V(PREDUC) - V(FDIF) 7842 S1 = IV(S) 7843 CALL DS7LVM(PS, Y, V(S1), V(STEP1)) 7844 STTSST = HALF * DD7TPR(PS, V(STEP1), Y) 7845 IF (IV(MODEL) .EQ. 1) STTSST = -STTSST 7846 IF (DABS(E + STTSST) * V(FUZZ) .GE. DABS(E)) GO TO 360 7847C 7848C *** SWITCH MODELS *** 7849C 7850 IV(MODEL) = 3 - IV(MODEL) 7851 IF (-2 .LT. L) GO TO 400 7852 IV(H) = -IABS(IV(H)) 7853 IV(SUSED) = IV(SUSED) + 2 7854 L = IV(VSAVE) 7855 CALL DV7CPY(NVSAVE, V(L), V) 7856 GO TO 160 7857C 7858 360 IF (-3 .LT. L) GO TO 400 7859C 7860C *** RECOMPUTE STEP WITH NEW RADIUS *** 7861C 7862 370 V(RADIUS) = V(RADFAC) * V(DSTNRM) 7863 GO TO 160 7864C 7865C *** COMPUTE STEP OF LENGTH V(LMAXS) FOR SINGULAR CONVERGENCE TEST 7866C 7867 380 V(RADIUS) = V(LMAXS) 7868 GO TO 200 7869C 7870C *** CONVERGENCE OR FALSE CONVERGENCE *** 7871C 7872 390 IV(CNVCOD) = L 7873 IF (V(F) .GE. V(F0)) GO TO 510 7874 IF (IV(XIRC) .EQ. 14) GO TO 510 7875 IV(XIRC) = 14 7876C 7877C. . . . . . . . . . . . PROCESS ACCEPTABLE STEP . . . . . . . . . . . 7878C 7879 400 IV(COVMAT) = 0 7880 IV(REGD) = 0 7881C 7882C *** SEE WHETHER TO SET V(RADFAC) BY GRADIENT TESTS *** 7883C 7884 IF (IV(IRC) .NE. 3) GO TO 430 7885 STEP1 = IV(STEP) 7886 TEMP1 = IV(STLSTG) 7887 TEMP2 = IV(W) 7888C 7889C *** SET TEMP1 = HESSIAN * STEP FOR USE IN GRADIENT TESTS *** 7890C 7891 HC1 = IV(HC) 7892 IF (HC1 .LE. 0) GO TO 410 7893 CALL DS7LVM(P, V(TEMP1), V(HC1), V(STEP1)) 7894 GO TO 420 7895 410 RMAT1 = IV(RMAT) 7896 CALL DL7TVM(P, V(TEMP1), V(RMAT1), V(STEP1)) 7897 CALL DL7VML(P, V(TEMP1), V(RMAT1), V(TEMP1)) 7898C 7899 420 IF (STPMOD .EQ. 1) GO TO 430 7900 S1 = IV(S) 7901 CALL DS7LVM(PS, V(TEMP2), V(S1), V(STEP1)) 7902 CALL DV2AXY(PS, V(TEMP1), ONE, V(TEMP2), V(TEMP1)) 7903C 7904C *** SAVE OLD GRADIENT AND COMPUTE NEW ONE *** 7905C 7906 430 IV(NGCALL) = IV(NGCALL) + 1 7907 G01 = IV(W) 7908 CALL DV7CPY(P, V(G01), G) 7909 IV(1) = 2 7910 IV(TOOBIG) = 0 7911 GO TO 999 7912C 7913C *** INITIALIZATIONS -- G0 = G - G0, ETC. *** 7914C 7915 440 G01 = IV(W) 7916 CALL DV2AXY(P, V(G01), NEGONE, V(G01), G) 7917 STEP1 = IV(STEP) 7918 TEMP1 = IV(STLSTG) 7919 TEMP2 = IV(W) 7920 IF (IV(IRC) .NE. 3) GO TO 470 7921C 7922C *** SET V(RADFAC) BY GRADIENT TESTS *** 7923C 7924C *** SET TEMP1 = D**-1 * (HESSIAN * STEP + (G(X0) - G(X))) *** 7925C 7926 K = TEMP1 7927 L = G01 7928 DO 450 I = 1, P 7929 V(K) = (V(K) - V(L)) / D(I) 7930 K = K + 1 7931 L = L + 1 7932 450 CONTINUE 7933C 7934C *** DO GRADIENT TESTS *** 7935C 7936 IF (DV2NRM(P, V(TEMP1)) .LE. V(DGNORM) * V(TUNER4)) GO TO 460 7937 IF (DD7TPR(P, G, V(STEP1)) 7938 1 .GE. V(GTSTEP) * V(TUNER5)) GO TO 470 7939 460 V(RADFAC) = V(INCFAC) 7940C 7941C *** COMPUTE Y VECTOR NEEDED FOR UPDATING S *** 7942C 7943 470 CALL DV2AXY(PS, Y, NEGONE, Y, G) 7944C 7945C *** DETERMINE SIZING FACTOR V(SIZE) *** 7946C 7947C *** SET TEMP1 = S * STEP *** 7948 S1 = IV(S) 7949 CALL DS7LVM(PS, V(TEMP1), V(S1), V(STEP1)) 7950C 7951 T1 = DABS(DD7TPR(PS, V(STEP1), V(TEMP1))) 7952 T = DABS(DD7TPR(PS, V(STEP1), Y)) 7953 V(SIZE) = ONE 7954 IF (T .LT. T1) V(SIZE) = T / T1 7955C 7956C *** SET G0 TO WCHMTD CHOICE OF FLETCHER AND AL-BAALI *** 7957C 7958 HC1 = IV(HC) 7959 IF (HC1 .LE. 0) GO TO 480 7960 CALL DS7LVM(PS, V(G01), V(HC1), V(STEP1)) 7961 GO TO 490 7962C 7963 480 RMAT1 = IV(RMAT) 7964 CALL DL7TVM(PS, V(G01), V(RMAT1), V(STEP1)) 7965 CALL DL7VML(PS, V(G01), V(RMAT1), V(G01)) 7966C 7967 490 CALL DV2AXY(PS, V(G01), ONE, Y, V(G01)) 7968C 7969C *** UPDATE S *** 7970C 7971 CALL DS7LUP(V(S1), V(COSMIN), PS, V(SIZE), V(STEP1), V(TEMP1), 7972 1 V(TEMP2), V(G01), V(WSCALE), Y) 7973 IV(1) = 2 7974 GO TO 110 7975C 7976C. . . . . . . . . . . . . . MISC. DETAILS . . . . . . . . . . . . . . 7977C 7978C *** BAD PARAMETERS TO ASSESS *** 7979C 7980 500 IV(1) = 64 7981 GO TO 999 7982C 7983C 7984C *** CONVERGENCE OBTAINED -- SEE WHETHER TO COMPUTE COVARIANCE *** 7985C 7986 510 IF (IV(RDREQ) .EQ. 0) GO TO 600 7987 IF (IV(FDH) .NE. 0) GO TO 600 7988 IF (IV(CNVCOD) .GE. 7) GO TO 600 7989 IF (IV(REGD) .GT. 0) GO TO 600 7990 IF (IV(COVMAT) .GT. 0) GO TO 600 7991 IF (IABS(IV(COVREQ)) .GE. 3) GO TO 560 7992 IF (IV(RESTOR) .EQ. 0) IV(RESTOR) = 2 7993 GO TO 530 7994C 7995C *** COMPUTE FINITE-DIFFERENCE HESSIAN FOR COMPUTING COVARIANCE *** 7996C 7997 520 IV(RESTOR) = 0 7998 530 CALL DF7HES(D, G, I, IV, LIV, LV, P, V, X) 7999c GO TO (540, 550, 580), I 8000 select case(I) 8001 case(1) 8002 goto 540 8003 case(2) 8004 goto 550 8005 case(3) 8006 goto 580 8007 end select 8008 540 IV(NFCOV) = IV(NFCOV) + 1 8009 IV(NFCALL) = IV(NFCALL) + 1 8010 IV(1) = 1 8011 GO TO 999 8012C 8013 550 IV(NGCOV) = IV(NGCOV) + 1 8014 IV(NGCALL) = IV(NGCALL) + 1 8015 IV(NFGCAL) = IV(NFCALL) + IV(NGCOV) 8016 IV(1) = 2 8017 GO TO 999 8018C 8019 560 H1 = IABS(IV(H)) 8020 IV(H) = -H1 8021 PP1O2 = P * (P + 1) / 2 8022 RMAT1 = IV(RMAT) 8023 IF (RMAT1 .LE. 0) GO TO 570 8024 LMAT1 = IV(LMAT) 8025 CALL DV7CPY(PP1O2, V(LMAT1), V(RMAT1)) 8026 V(RCOND) = ZERO 8027 GO TO 590 8028 570 HC1 = IV(HC) 8029 IV(FDH) = H1 8030 CALL DV7CPY(P*(P+1)/2, V(H1), V(HC1)) 8031C 8032C *** COMPUTE CHOLESKY FACTOR OF FINITE-DIFFERENCE HESSIAN 8033C *** FOR USE IN CALLER*S COVARIANCE CALCULATION... 8034C 8035 580 LMAT1 = IV(LMAT) 8036 H1 = IV(FDH) 8037 IF (H1 .LE. 0) GO TO 600 8038 IF (IV(CNVCOD) .EQ. 70) GO TO 80 8039 CALL DL7SRT(1, P, V(LMAT1), V(H1), I) 8040 IV(FDH) = -1 8041 V(RCOND) = ZERO 8042 IF (I .NE. 0) GO TO 600 8043C 8044 590 IV(FDH) = -1 8045 STEP1 = IV(STEP) 8046 T = DL7SVN(P, V(LMAT1), V(STEP1), V(STEP1)) 8047 IF (T .LE. ZERO) GO TO 600 8048 T = T / DL7SVX(P, V(LMAT1), V(STEP1), V(STEP1)) 8049 IF (T .GT. DR7MDC(4)) IV(FDH) = H1 8050 V(RCOND) = T 8051C 8052 600 IV(MODE) = 0 8053 IV(1) = IV(CNVCOD) 8054 IV(CNVCOD) = 0 8055 GO TO 999 8056C 8057C *** SPECIAL RETURN FOR MISSING HESSIAN INFORMATION -- BOTH 8058C *** IV(HC) .LE. 0 AND IV(RMAT) .LE. 0 8059C 8060 610 IV(1) = 1400 8061C 8062 999 RETURN 8063C 8064C *** LAST LINE OF DG7LIT FOLLOWS *** 8065 END 8066 SUBROUTINE DL7MSB(B, D, G, IERR, IPIV, IPIV1, IPIV2, KA, LMAT, 8067 1 LV, P, P0, PC, QTR, RMAT, STEP, TD, TG, V, 8068 2 W, WLM, X, X0) 8069C 8070C *** COMPUTE HEURISTIC BOUNDED NEWTON STEP *** 8071C 8072 INTEGER IERR, KA, LV, P, P0, PC 8073 INTEGER IPIV(P), IPIV1(P), IPIV2(P) 8074 DOUBLE PRECISION B(2,P), D(P), G(P), LMAT(*), QTR(P), RMAT(*), 8075 1 STEP(P,3), TD(P), TG(P), V(LV), W(P), WLM(*), 8076 2 X0(P), X(P) 8077C DIMENSION LMAT(P*(P+1)/2), RMAT(P*(P+1)/2), WLM(P*(P+5)/2 + 4) 8078C 8079 DOUBLE PRECISION DD7TPR 8080 EXTERNAL DD7MLP, DD7TPR, DL7MST, DL7TVM, DQ7RSH, DS7BQN, 8081 1 DV2AXY,DV7CPY, DV7IPR, DV7SCP, DV7VMP 8082C 8083C *** LOCAL VARIABLES *** 8084C 8085 INTEGER I, J, K, K0, KB, KINIT, L, NS, P1, P10, P11 8086 DOUBLE PRECISION DS0, NRED, PRED, RAD 8087 DOUBLE PRECISION ONE, ZERO 8088C 8089C *** V SUBSCRIPTS *** 8090C 8091 INTEGER DST0, DSTNRM, GTSTEP, NREDUC, PREDUC, RADIUS 8092C 8093 PARAMETER (DST0=3, DSTNRM=2, GTSTEP=4, NREDUC=6, PREDUC=7, 8094 1 RADIUS=8) 8095 DATA ONE/1.D+0/, ZERO/0.D+0/ 8096C 8097C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 8098C 8099 P1 = PC 8100 IF (KA .LT. 0) GO TO 10 8101 NRED = V(NREDUC) 8102 DS0 = V(DST0) 8103 GO TO 20 8104 10 P0 = 0 8105 KA = -1 8106C 8107 20 KINIT = -1 8108 IF (P0 .EQ. P1) KINIT = KA 8109 CALL DV7CPY(P, X, X0) 8110 CALL DV7CPY(P, TD, D) 8111C *** USE STEP(1,3) AS TEMP. COPY OF QTR *** 8112 CALL DV7CPY(P, STEP(1,3), QTR) 8113 CALL DV7IPR(P, IPIV, TD) 8114 PRED = ZERO 8115 RAD = V(RADIUS) 8116 KB = -1 8117 V(DSTNRM) = ZERO 8118 IF (P1 .GT. 0) GO TO 30 8119 NRED = ZERO 8120 DS0 = ZERO 8121 CALL DV7SCP(P, STEP, ZERO) 8122 GO TO 90 8123C 8124 30 CALL DV7VMP(P, TG, G, D, -1) 8125 CALL DV7IPR(P, IPIV, TG) 8126 P10 = P1 8127 40 K = KINIT 8128 KINIT = -1 8129 V(RADIUS) = RAD - V(DSTNRM) 8130 CALL DV7VMP(P1, TG, TG, TD, 1) 8131 DO 50 I = 1, P1 8132 IPIV1(I) = I 8133 50 CONTINUE 8134 K0 = MAX0(0, K) 8135 CALL DL7MST(TD, TG, IERR, IPIV1, K, P1, STEP(1,3), RMAT, STEP, 8136 1 V, WLM) 8137 CALL DV7VMP(P1, TG, TG, TD, -1) 8138 P0 = P1 8139 IF (KA .GE. 0) GO TO 60 8140 NRED = V(NREDUC) 8141 DS0 = V(DST0) 8142C 8143 60 KA = K 8144 V(RADIUS) = RAD 8145 L = P1 + 5 8146 IF (K .LE. K0) CALL DD7MLP(P1, LMAT, TD, RMAT, -1) 8147 IF (K .GT. K0) CALL DD7MLP(P1, LMAT, TD, WLM(L), -1) 8148 CALL DS7BQN(B, D, STEP(1,2), IPIV, IPIV1, IPIV2, KB, LMAT, 8149 1 LV, NS, P, P1, STEP, TD, TG, V, W, X, X0) 8150 PRED = PRED + V(PREDUC) 8151 IF (NS .EQ. 0) GO TO 80 8152 P0 = 0 8153C 8154C *** UPDATE RMAT AND QTR *** 8155C 8156 P11 = P1 + 1 8157 L = P10 + P11 8158 DO 70 K = P11, P10 8159 J = L - K 8160 I = IPIV2(J) 8161 IF (I .LT. J) CALL DQ7RSH(I, J, .TRUE., QTR, RMAT, W) 8162 70 CONTINUE 8163C 8164 80 IF (KB .GT. 0) GO TO 90 8165C 8166C *** UPDATE LOCAL COPY OF QTR *** 8167C 8168 CALL DV7VMP(P10, W, STEP(1,2), TD, -1) 8169 CALL DL7TVM(P10, W, LMAT, W) 8170 CALL DV2AXY(P10, STEP(1,3), ONE, W, QTR) 8171 GO TO 40 8172C 8173 90 V(DST0) = DS0 8174 V(NREDUC) = NRED 8175 V(PREDUC) = PRED 8176 V(GTSTEP) = DD7TPR(P, G, STEP) 8177C 8178 RETURN 8179C *** LAST LINE OF DL7MSB FOLLOWS *** 8180 END 8181 SUBROUTINE DN2LRD(DR, IV, L, LH, LIV, LV, ND, NN, P, R, RD, V) 8182C 8183C *** COMPUTE REGRESSION DIAGNOSTIC AND DEFAULT COVARIANCE MATRIX FOR 8184C DRN2G *** 8185C 8186C *** PARAMETERS *** 8187C 8188 INTEGER LH, LIV, LV, ND, NN, P 8189 INTEGER IV(LIV) 8190 DOUBLE PRECISION DR(ND,P), L(LH), R(NN), RD(NN), V(LV) 8191C 8192C *** CODED BY DAVID M. GAY (WINTER 1982, FALL 1983) *** 8193C 8194C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 8195C 8196 DOUBLE PRECISION DD7TPR 8197 EXTERNAL DD7TPR, DL7ITV, DL7IVM,DO7PRD, DV7SCP 8198C 8199C *** LOCAL VARIABLES *** 8200C 8201 INTEGER COV, I, J, M, STEP1 8202 DOUBLE PRECISION A, FF, S, T 8203C 8204C *** CONSTANTS *** 8205C 8206 DOUBLE PRECISION NEGONE, ONE, ONEV(1), ZERO 8207C 8208C *** INTRINSIC FUNCTIONS *** 8209C/+ 8210 DOUBLE PRECISION DSQRT 8211C/ 8212C 8213C *** IV AND V SUBSCRIPTS *** 8214C 8215 INTEGER F, H, MODE, RDREQ, STEP 8216 PARAMETER (F=10, H=56, MODE=35, RDREQ=57, STEP=40) 8217 PARAMETER (NEGONE=-1.D+0, ONE=1.D+0, ZERO=0.D+0) 8218 DATA ONEV(1)/1.D+0/ 8219C 8220C++++++++++++++++++++++++++++++++ BODY +++++++++++++++++++++++++++++++ 8221C 8222 STEP1 = IV(STEP) 8223 I = IV(RDREQ) 8224 IF (I .LE. 0) GO TO 999 8225 IF (MOD(I,4) .LT. 2) GO TO 30 8226 FF = ONE 8227 IF (V(F) .NE. ZERO) FF = ONE / DSQRT(DABS(V(F))) 8228 CALL DV7SCP(NN, RD, NEGONE) 8229 DO 20 I = 1, NN 8230 A = R(I)**2 8231 M = STEP1 8232 DO 10 J = 1, P 8233 V(M) = DR(I,J) 8234 M = M + 1 8235 10 CONTINUE 8236 CALL DL7IVM(P, V(STEP1), L, V(STEP1)) 8237 S = DD7TPR(P, V(STEP1), V(STEP1)) 8238 T = ONE - S 8239 IF (T .LE. ZERO) GO TO 20 8240 A = A * S / T 8241 RD(I) = DSQRT(A) * FF 8242 20 CONTINUE 8243C 8244 30 IF (IV(MODE) - P .LT. 2) GO TO 999 8245C 8246C *** COMPUTE DEFAULT COVARIANCE MATRIX *** 8247C 8248 COV = IABS(IV(H)) 8249 DO 50 I = 1, NN 8250 M = STEP1 8251 DO 40 J = 1, P 8252 V(M) = DR(I,J) 8253 M = M + 1 8254 40 CONTINUE 8255 CALL DL7IVM(P, V(STEP1), L, V(STEP1)) 8256 CALL DL7ITV(P, V(STEP1), L, V(STEP1)) 8257 CALL DO7PRD(1, LH, P, V(COV), ONEV, V(STEP1), V(STEP1)) 8258 50 CONTINUE 8259C 8260 999 RETURN 8261C *** LAST LINE OF DN2LRD FOLLOWS *** 8262 END 8263 SUBROUTINE DR7TVM(N, P, Y, D, U, X) 8264C 8265C *** SET Y TO R*X, WHERE R IS THE UPPER TRIANGULAR MATRIX WHOSE 8266C *** DIAGONAL IS IN D AND WHOSE STRICT UPPER TRIANGLE IS IN U. 8267C 8268C *** X AND Y MAY SHARE STORAGE. 8269C 8270 INTEGER N, P 8271 DOUBLE PRECISION Y(P), D(P), U(N,P), X(P) 8272C 8273 DOUBLE PRECISION DD7TPR 8274 EXTERNAL DD7TPR 8275C 8276C *** LOCAL VARIABLES *** 8277C 8278 INTEGER I, II, PL, PP1 8279 DOUBLE PRECISION T 8280C 8281C *** BODY *** 8282C 8283 PL = MIN0(N, P) 8284 PP1 = PL + 1 8285 DO 10 II = 1, PL 8286 I = PP1 - II 8287 T = X(I) * D(I) 8288 IF (I .GT. 1) T = T + DD7TPR(I-1, U(1,I), X) 8289 Y(I) = T 8290 10 CONTINUE 8291 RETURN 8292C *** LAST LINE OF DR7TVM FOLLOWS *** 8293 END 8294 SUBROUTINE DQ7RAD(N, NN, P, QTR, QTRSET, RMAT, W, Y) 8295C 8296C *** ADD ROWS W TO QR FACTORIZATION WITH R MATRIX RMAT AND 8297C *** Q**T * RESIDUAL = QTR. Y = NEW COMPONENTS OF RESIDUAL 8298C *** CORRESPONDING TO W. QTR, Y REFERENCED ONLY IF QTRSET = .TRUE. 8299C 8300 LOGICAL QTRSET 8301 INTEGER N, NN, P 8302 DOUBLE PRECISION QTR(P), RMAT(*), W(NN,P), Y(N) 8303C DIMENSION RMAT(P*(P+1)/2) 8304C/+ 8305 DOUBLE PRECISION DSQRT 8306C/ 8307 DOUBLE PRECISION DD7TPR, DR7MDC, DV2NRM 8308 EXTERNAL DD7TPR, DR7MDC,DV2AXY, DV7SCL, DV2NRM 8309C 8310C *** LOCAL VARIABLES *** 8311C 8312 INTEGER I, II, IJ, IP1, J, K, NK 8313 DOUBLE PRECISION ARI, QRI, RI, S, T, WI 8314 DOUBLE PRECISION BIG, BIGRT, ONE, TINY, TINYRT, ZERO 8315 SAVE BIGRT, TINY, TINYRT 8316 DATA BIG/-1.D+0/, BIGRT/-1.D+0/, ONE/1.D+0/, TINY/0.D+0/, 8317 1 TINYRT/0.D+0/, ZERO/0.D+0/ 8318C 8319C------------------------------ BODY ----------------------------------- 8320C 8321 IF (TINY .GT. ZERO) GO TO 10 8322 TINY = DR7MDC(1) 8323 BIG = DR7MDC(6) 8324 IF (TINY*BIG .LT. ONE) TINY = ONE / BIG 8325 10 K = 1 8326 NK = N 8327 II = 0 8328 DO 180 I = 1, P 8329 II = II + I 8330 IP1 = I + 1 8331 IJ = II + I 8332 IF (NK .LE. 1) T = DABS(W(K,I)) 8333 IF (NK .GT. 1) T = DV2NRM(NK, W(K,I)) 8334 IF (T .LT. TINY) GOTO 180 8335 RI = RMAT(II) 8336 IF (RI .NE. ZERO) GO TO 100 8337 IF (NK .GT. 1) GO TO 30 8338 IJ = II 8339 DO 20 J = I, P 8340 RMAT(IJ) = W(K,J) 8341 IJ = IJ + J 8342 20 CONTINUE 8343 IF (QTRSET) QTR(I) = Y(K) 8344 W(K,I) = ZERO 8345 GO TO 999 8346 30 WI = W(K,I) 8347 IF (BIGRT .GT. ZERO) GO TO 40 8348 BIGRT = DR7MDC(5) 8349 TINYRT = DR7MDC(2) 8350 40 IF (T .LE. TINYRT) GO TO 50 8351 IF (T .GE. BIGRT) GO TO 50 8352 IF (WI .LT. ZERO) T = -T 8353 WI = WI + T 8354 S = DSQRT(T * WI) 8355 GO TO 70 8356 50 S = DSQRT(T) 8357 IF (WI .LT. ZERO) GO TO 60 8358 WI = WI + T 8359 S = S * DSQRT(WI) 8360 GO TO 70 8361 60 T = -T 8362 WI = WI + T 8363 S = S * DSQRT(-WI) 8364 70 W(K,I) = WI 8365 CALL DV7SCL(NK, W(K,I), ONE/S, W(K,I)) 8366 RMAT(II) = -T 8367 IF (.NOT. QTRSET) GO TO 80 8368 CALL DV2AXY(NK, Y(K), -DD7TPR(NK,Y(K),W(K,I)), W(K,I), Y(K)) 8369 QTR(I) = Y(K) 8370 80 IF (IP1 .GT. P) GO TO 999 8371 DO 90 J = IP1, P 8372 CALL DV2AXY(NK, W(K,J), -DD7TPR(NK,W(K,J),W(K,I)), 8373 1 W(K,I), W(K,J)) 8374 RMAT(IJ) = W(K,J) 8375 IJ = IJ + J 8376 90 CONTINUE 8377 IF (NK .LE. 1) GO TO 999 8378 K = K + 1 8379 NK = NK - 1 8380 GO TO 180 8381C 8382 100 ARI = DABS(RI) 8383 IF (ARI .GT. T) GO TO 110 8384 T = T * DSQRT(ONE + (ARI/T)**2) 8385 GO TO 120 8386 110 T = ARI * DSQRT(ONE + (T/ARI)**2) 8387 120 IF (RI .LT. ZERO) T = -T 8388 RI = RI + T 8389 RMAT(II) = -T 8390 S = -RI / T 8391 IF (NK .LE. 1) GO TO 150 8392 CALL DV7SCL(NK, W(K,I), ONE/RI, W(K,I)) 8393 IF (.NOT. QTRSET) GO TO 130 8394 QRI = QTR(I) 8395 T = S * ( QRI + DD7TPR(NK, Y(K), W(K,I)) ) 8396 QTR(I) = QRI + T 8397 130 IF (IP1 .GT. P) GO TO 999 8398 IF (QTRSET) CALL DV2AXY(NK, Y(K), T, W(K,I), Y(K)) 8399 DO 140 J = IP1, P 8400 RI = RMAT(IJ) 8401 T = S * ( RI + DD7TPR(NK, W(K,J), W(K,I)) ) 8402 CALL DV2AXY(NK, W(K,J), T, W(K,I), W(K,J)) 8403 RMAT(IJ) = RI + T 8404 IJ = IJ + J 8405 140 CONTINUE 8406 GO TO 180 8407C 8408 150 WI = W(K,I) / RI 8409 W(K,I) = WI 8410 IF (.NOT. QTRSET) GO TO 160 8411 QRI = QTR(I) 8412 T = S * ( QRI + Y(K)*WI ) 8413 QTR(I) = QRI + T 8414 160 IF (IP1 .GT. P) GO TO 999 8415 IF (QTRSET) Y(K) = T*WI + Y(K) 8416 DO 170 J = IP1, P 8417 RI = RMAT(IJ) 8418 T = S * (RI + W(K,J)*WI) 8419 W(K,J) = W(K,J) + T*WI 8420 RMAT(IJ) = RI + T 8421 IJ = IJ + J 8422 170 CONTINUE 8423 180 CONTINUE 8424C 8425 999 RETURN 8426C *** LAST LINE OF DQ7RAD FOLLOWS *** 8427 END 8428 SUBROUTINE DF7HES(D, G, IRT, IV, LIV, LV, P, V, X) 8429C 8430C *** COMPUTE FINITE-DIFFERENCE HESSIAN, STORE IT IN V STARTING 8431C *** AT V(IV(FDH)) = V(-IV(H)). 8432C 8433C *** IF IV(COVREQ) .GE. 0 THEN DF7HES USES GRADIENT DIFFERENCES, 8434C *** OTHERWISE FUNCTION DIFFERENCES. STORAGE IN V IS AS IN DG7LIT. 8435C 8436C IRT VALUES... 8437C 1 = COMPUTE FUNCTION VALUE, I.E., V(F). 8438C 2 = COMPUTE G. 8439C 3 = DONE. 8440C 8441C 8442C *** PARAMETER DECLARATIONS *** 8443C 8444 INTEGER IRT, LIV, LV, P 8445 INTEGER IV(LIV) 8446 DOUBLE PRECISION D(P), G(P), V(LV), X(P) 8447C 8448C *** LOCAL VARIABLES *** 8449C 8450 INTEGER GSAVE1, HES, HMI, HPI, HPM, I, K, KIND, L, M, MM1, MM1O2, 8451 1 PP1O2, STPI, STPM, STP0 8452 DOUBLE PRECISION DEL, HALF, NEGPT5, ONE, TWO, ZERO 8453C 8454C *** EXTERNAL SUBROUTINES *** 8455C 8456 EXTERNAL DV7CPY 8457C 8458C DV7CPY.... COPY ONE VECTOR TO ANOTHER. 8459C 8460C *** SUBSCRIPTS FOR IV AND V *** 8461C 8462 INTEGER COVREQ, DELTA, DELTA0, DLTFDC, F, FDH, FX, H, KAGQT, MODE, 8463 1 NFGCAL, SAVEI, SWITCH, TOOBIG, W, XMSAVE 8464C 8465 PARAMETER (HALF=0.5D+0, NEGPT5=-0.5D+0, ONE=1.D+0, TWO=2.D+0, 8466 1 ZERO=0.D+0) 8467C 8468 PARAMETER (COVREQ=15, DELTA=52, DELTA0=44, DLTFDC=42, F=10, 8469 1 FDH=74, FX=53, H=56, KAGQT=33, MODE=35, NFGCAL=7, 8470 2 SAVEI=63, SWITCH=12, TOOBIG=2, W=65, XMSAVE=51) 8471C 8472C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 8473C 8474 IRT = 4 8475 KIND = IV(COVREQ) 8476 M = IV(MODE) 8477 IF (M .GT. 0) GO TO 10 8478 IV(H) = -IABS(IV(H)) 8479 IV(FDH) = 0 8480 IV(KAGQT) = -1 8481 V(FX) = V(F) 8482 10 IF (M .GT. P) GO TO 999 8483 IF (KIND .LT. 0) GO TO 110 8484C 8485C *** COMPUTE FINITE-DIFFERENCE HESSIAN USING BOTH FUNCTION AND 8486C *** GRADIENT VALUES. 8487C 8488 GSAVE1 = IV(W) + P 8489 IF (M .GT. 0) GO TO 20 8490C *** FIRST CALL ON DF7HES. SET GSAVE = G, TAKE FIRST STEP *** 8491 CALL DV7CPY(P, V(GSAVE1), G) 8492 IV(SWITCH) = IV(NFGCAL) 8493 GO TO 90 8494C 8495 20 DEL = V(DELTA) 8496 X(M) = V(XMSAVE) 8497 IF (IV(TOOBIG) .EQ. 0) GO TO 40 8498C 8499C *** HANDLE OVERSIZE V(DELTA) *** 8500C 8501 IF (DEL*X(M) .GT. ZERO) GO TO 30 8502C *** WE ALREADY TRIED SHRINKING V(DELTA), SO QUIT *** 8503 IV(FDH) = -2 8504 GO TO 220 8505C 8506C *** TRY SHRINKING V(DELTA) *** 8507 30 DEL = NEGPT5 * DEL 8508 GO TO 100 8509C 8510 40 HES = -IV(H) 8511C 8512C *** SET G = (G - GSAVE)/DEL *** 8513C 8514 DO 50 I = 1, P 8515 G(I) = (G(I) - V(GSAVE1)) / DEL 8516 GSAVE1 = GSAVE1 + 1 8517 50 CONTINUE 8518C 8519C *** ADD G AS NEW COL. TO FINITE-DIFF. HESSIAN MATRIX *** 8520C 8521 K = HES + M*(M-1)/2 8522 L = K + M - 2 8523 IF (M .EQ. 1) GO TO 70 8524C 8525C *** SET H(I,M) = 0.5 * (H(I,M) + G(I)) FOR I = 1 TO M-1 *** 8526C 8527 MM1 = M - 1 8528 DO 60 I = 1, MM1 8529 V(K) = HALF * (V(K) + G(I)) 8530 K = K + 1 8531 60 CONTINUE 8532C 8533C *** ADD H(I,M) = G(I) FOR I = M TO P *** 8534C 8535 70 L = L + 1 8536 DO 80 I = M, P 8537 V(L) = G(I) 8538 L = L + I 8539 80 CONTINUE 8540C 8541 90 M = M + 1 8542 IV(MODE) = M 8543 IF (M .GT. P) GO TO 210 8544C 8545C *** CHOOSE NEXT FINITE-DIFFERENCE STEP, RETURN TO GET G THERE *** 8546C 8547 DEL = V(DELTA0) * DMAX1(ONE/D(M), DABS(X(M))) 8548 IF (X(M) .LT. ZERO) DEL = -DEL 8549 V(XMSAVE) = X(M) 8550 100 X(M) = X(M) + DEL 8551 V(DELTA) = DEL 8552 IRT = 2 8553 GO TO 999 8554C 8555C *** COMPUTE FINITE-DIFFERENCE HESSIAN USING FUNCTION VALUES ONLY. 8556C 8557 110 STP0 = IV(W) + P - 1 8558 MM1 = M - 1 8559 MM1O2 = M*MM1/2 8560 IF (M .GT. 0) GO TO 120 8561C *** FIRST CALL ON DF7HES. *** 8562 IV(SAVEI) = 0 8563 GO TO 200 8564C 8565 120 I = IV(SAVEI) 8566 HES = -IV(H) 8567 IF (I .GT. 0) GO TO 180 8568 IF (IV(TOOBIG) .EQ. 0) GO TO 140 8569C 8570C *** HANDLE OVERSIZE STEP *** 8571C 8572 STPM = STP0 + M 8573 DEL = V(STPM) 8574 IF (DEL*X(XMSAVE) .GT. ZERO) GO TO 130 8575C *** WE ALREADY TRIED SHRINKING THE STEP, SO QUIT *** 8576 IV(FDH) = -2 8577 GO TO 220 8578C 8579C *** TRY SHRINKING THE STEP *** 8580 130 DEL = NEGPT5 * DEL 8581 X(M) = X(XMSAVE) + DEL 8582 V(STPM) = DEL 8583 IRT = 1 8584 GO TO 999 8585C 8586C *** SAVE F(X + STP(M)*E(M)) IN H(P,M) *** 8587C 8588 140 PP1O2 = P * (P-1) / 2 8589 HPM = HES + PP1O2 + MM1 8590 V(HPM) = V(F) 8591C 8592C *** START COMPUTING ROW M OF THE FINITE-DIFFERENCE HESSIAN H. *** 8593C 8594 HMI = HES + MM1O2 8595 IF (MM1 .EQ. 0) GO TO 160 8596 HPI = HES + PP1O2 8597 DO 150 I = 1, MM1 8598 V(HMI) = V(FX) - (V(F) + V(HPI)) 8599 HMI = HMI + 1 8600 HPI = HPI + 1 8601 150 CONTINUE 8602 160 V(HMI) = V(F) - TWO*V(FX) 8603C 8604C *** COMPUTE FUNCTION VALUES NEEDED TO COMPLETE ROW M OF H. *** 8605C 8606 I = 1 8607C 8608 170 IV(SAVEI) = I 8609 STPI = STP0 + I 8610 V(DELTA) = X(I) 8611 X(I) = X(I) + V(STPI) 8612 IF (I .EQ. M) X(I) = V(XMSAVE) - V(STPI) 8613 IRT = 1 8614 GO TO 999 8615C 8616 180 X(I) = V(DELTA) 8617 IF (IV(TOOBIG) .EQ. 0) GO TO 190 8618C *** PUNT IN THE EVENT OF AN OVERSIZE STEP *** 8619 IV(FDH) = -2 8620 GO TO 220 8621C 8622C *** FINISH COMPUTING H(M,I) *** 8623C 8624 190 STPI = STP0 + I 8625 HMI = HES + MM1O2 + I - 1 8626 STPM = STP0 + M 8627 V(HMI) = (V(HMI) + V(F)) / (V(STPI)*V(STPM)) 8628 I = I + 1 8629 IF (I .LE. M) GO TO 170 8630 IV(SAVEI) = 0 8631 X(M) = V(XMSAVE) 8632C 8633 200 M = M + 1 8634 IV(MODE) = M 8635 IF (M .GT. P) GO TO 210 8636C 8637C *** PREPARE TO COMPUTE ROW M OF THE FINITE-DIFFERENCE HESSIAN H. 8638C *** COMPUTE M-TH STEP SIZE STP(M), THEN RETURN TO OBTAIN 8639C *** F(X + STP(M)*E(M)), WHERE E(M) = M-TH STD. UNIT VECTOR. 8640C 8641 DEL = V(DLTFDC) * DMAX1(ONE/D(M), DABS(X(M))) 8642 IF (X(M) .LT. ZERO) DEL = -DEL 8643 V(XMSAVE) = X(M) 8644 X(M) = X(M) + DEL 8645 STPM = STP0 + M 8646 V(STPM) = DEL 8647 IRT = 1 8648 GO TO 999 8649C 8650C *** RESTORE V(F), ETC. *** 8651C 8652 210 IV(FDH) = HES 8653 220 V(F) = V(FX) 8654 IRT = 3 8655 IF (KIND .LT. 0) GO TO 999 8656 IV(NFGCAL) = IV(SWITCH) 8657 GSAVE1 = IV(W) + P 8658 CALL DV7CPY(P, G, V(GSAVE1)) 8659 GO TO 999 8660C 8661 999 RETURN 8662C *** LAST CARD OF DF7HES FOLLOWS *** 8663 END 8664 SUBROUTINE DRNSG(A, ALF, C, DA, IN, IV, L, L1, LA, LIV, LV, 8665 1 N, NDA, P, V, Y) 8666C 8667C *** ITERATION DRIVER FOR SEPARABLE NONLINEAR LEAST SQUARES. 8668C 8669C *** PARAMETER DECLARATIONS *** 8670C 8671 INTEGER L, L1, LA, LIV, LV, N, NDA, P 8672 INTEGER IN(2,NDA), IV(LIV) 8673C DIMENSION UIPARM(*) 8674 DOUBLE PRECISION A(LA,L1), ALF(P), C(L), DA(LA,NDA), V(LV), Y(N) 8675C 8676C *** PURPOSE *** 8677C 8678C GIVEN A SET OF N OBSERVATIONS Y(1)....Y(N) OF A DEPENDENT VARIABLE 8679C T(1)...T(N), DRNSG ATTEMPTS TO COMPUTE A LEAST SQUARES FIT 8680C TO A FUNCTION ETA (THE MODEL) WHICH IS A LINEAR COMBINATION 8681C 8682C L 8683C ETA(C,ALF,T) = SUM C * PHI(ALF,T) +PHI (ALF,T) 8684C J=1 J J L+1 8685C 8686C OF NONLINEAR FUNCTIONS PHI(J) DEPENDENT ON T AND ALF(1),...,ALF(P) 8687C (.E.G. A SUM OF EXPONENTIALS OR GAUSSIANS). THAT IS, IT DETERMINES 8688C NONLINEAR PARAMETERS ALF WHICH MINIMIZE 8689C 8690C 2 N 2 8691C NORM(RESIDUAL) = SUM (Y - ETA(C,ALF,T )). 8692C I=1 I I 8693C 8694C THE (L+1)ST TERM IS OPTIONAL. 8695C 8696C 8697C *** PARAMETERS *** 8698C 8699C A (IN) MATRIX PHI(ALF,T) OF THE MODEL. 8700C ALF (I/O) NONLINEAR PARAMETERS. 8701C INPUT = INITIAL GUESS, 8702C OUTPUT = BEST ESTIMATE FOUND. 8703C C (OUT) LINEAR PARAMETERS (ESTIMATED). 8704C DA (IN) DERIVATIVES OF COLUMNS OF A WITH RESPECT TO COMPONENTS 8705C OF ALF, AS SPECIFIED BY THE IN ARRAY... 8706C IN (IN) WHEN DRNSG IS CALLED WITH IV(1) = 2 OR -2, THEN FOR 8707C I = 1(1)NDA, COLUMN I OF DA IS THE PARTIAL 8708C DERIVATIVE WITH RESPECT TO ALF(IN(1,I)) OF COLUMN 8709C IN(2,I) OF A, UNLESS IV(1,I) IS NOT POSITIVE (IN 8710C WHICH CASE COLUMN I OF DA IS IGNORED. IV(1) = -2 8711C MEANS THERE ARE MORE COLUMNS OF DA TO COME AND 8712C DRNSG SHOULD RETURN FOR THEM. 8713C IV (I/O) INTEGER PARAMETER AND SCRATCH VECTOR. DRNSG RETURNS 8714C WITH IV(1) = 1 WHEN IT WANTS A TO BE EVALUATED AT 8715C ALF AND WITH IV(1) = 2 WHEN IT WANTS DA TO BE 8716C EVALUATED AT ALF. WHEN CALLED WITH IV(1) = -2 8717C (AFTER A RETURN WITH IV(1) = 2), DRNSG RETURNS 8718C WITH IV(1) = -2 TO GET MORE COLUMNS OF DA. 8719C L (IN) NUMBER OF LINEAR PARAMETERS TO BE ESTIMATED. 8720C L1 (IN) L+1 IF PHI(L+1) IS IN THE MODEL, L IF NOT. 8721C LA (IN) LEAD DIMENSION OF A. MUST BE AT LEAST N. 8722C LIV (IN) LENGTH OF IV. MUST BE AT LEAST 110 + L + P. 8723C LV (IN) LENGTH OF V. MUST BE AT LEAST 8724C 105 + 2*N + JLEN + L*(L+3)/2 + P*(2*P + 17), 8725C WHERE JLEN = (L+P)*(N+L+P+1), UNLESS NEITHER A 8726C COVARIANCE MATRIX NOR REGRESSION DIAGNOSTICS ARE 8727C REQUESTED, IN WHICH CASE JLEN = N*P. 8728C N (IN) NUMBER OF OBSERVATIONS. 8729C NDA (IN) NUMBER OF COLUMNS IN DA AND IN. 8730C P (IN) NUMBER OF NONLINEAR PARAMETERS TO BE ESTIMATED. 8731C V (I/O) FLOATING-POINT PARAMETER AND SCRATCH VECTOR. 8732C IF A COVARIANCE ESTIMATE IS REQUESTED, IT IS FOR 8733C (ALF,C) -- NONLINEAR PARAMETERS ORDERED FIRST, 8734C FOLLOWED BY LINEAR PARAMETERS. 8735C Y (IN) RIGHT-HAND SIDE VECTOR. 8736C 8737C 8738C *** EXTERNAL SUBROUTINES *** 8739C 8740 DOUBLE PRECISION DD7TPR, DL7SVX, DL7SVN, DR7MDC 8741 EXTERNAL DC7VFN,DIVSET, DD7TPR,DITSUM, DL7ITV,DL7SRT, DL7SVX, 8742 1 DL7SVN, DN2CVP, DN2LRD, DN2RDP, DRN2G, DQ7APL,DQ7RAD, 8743 2 DQ7RFH, DR7MDC, DS7CPR,DV2AXY,DV7CPY,DV7PRM, DV7SCL, 8744 3 DV7SCP 8745C 8746C DC7VFN... FINISHES COVARIANCE COMPUTATION. 8747C DIVSET.... SUPPLIES DEFAULT PARAMETER VALUES. 8748C DD7TPR... RETURNS INNER PRODUCT OF TWO VECTORS. 8749C DITSUM.... PRINTS ITERATION SUMMARY, INITIAL AND FINAL ALF. 8750C DL7ITV... APPLIES INVERSE-TRANSPOSE OF COMPACT LOWER TRIANG. MATRIX. 8751C DL7SRT.... COMPUTES (PARTIAL) CHOLESKY FACTORIZATION. 8752C DL7SVX... ESTIMATES LARGEST SING. VALUE OF LOWER TRIANG. MATRIX. 8753C DL7SVN... ESTIMATES SMALLEST SING. VALUE OF LOWER TRIANG. MATRIX. 8754C DN2CVP... PRINTS COVARIANCE MATRIX. 8755C DN2LRD... COMPUTES COVARIANCE AND REGRESSION DIAGNOSTICS. 8756C DN2RDP... PRINTS REGRESSION DIAGNOSTICS. 8757C DRN2G... UNDERLYING NONLINEAR LEAST-SQUARES SOLVER. 8758C DQ7APL... APPLIES HOUSEHOLDER TRANSFORMS STORED BY DQ7RFH. 8759C DQ7RFH.... COMPUTES QR FACT. VIA HOUSEHOLDER TRANSFORMS WITH PIVOTING. 8760C DQ7RAD.... QR FACT., NO PIVOTING. 8761C DR7MDC... RETURNS MACHINE-DEP. CONSTANTS. 8762C DS7CPR... PRINTS LINEAR PARAMETERS AT SOLUTION. 8763C DV2AXY.... ADDS MULTIPLE OF ONE VECTOR TO ANOTHER. 8764C DV7CPY.... COPIES ONE VECTOR TO ANOTHER. 8765C DV7PRM.... PERMUTES A VECTOR. 8766C DV7SCL... SCALES AND COPIES ONE VECTOR TO ANOTHER. 8767C DV7SCP... SETS ALL COMPONENTS OF A VECTOR TO A SCALAR. 8768C 8769C *** LOCAL VARIABLES *** 8770C 8771 LOGICAL NOCOV 8772 INTEGER AR1, CSAVE1, D1, DR1, DR1L, DRI, DRI1, FDH0, HSAVE, I, I1, 8773 1 IPIV1, IER, IV1, J1, JLEN, K, LH, LI, LL1O2, MD, N1, N2, 8774 2 NML, NRAN, PP, PP1, R1, R1L, RD1, TEMP1 8775 DOUBLE PRECISION SINGTL, T 8776 DOUBLE PRECISION MACHEP, NEGONE, SNGFAC, ZERO 8777C 8778C *** SUBSCRIPTS FOR IV AND V *** 8779C 8780 INTEGER AR, CNVCOD, COVMAT, COVREQ, CSAVE, CVRQSV, D, FDH, H, 8781 1 IERS, IPIVS, IV1SAV, IVNEED, J, LMAT, MODE, NEXTIV, NEXTV, 8782 2 NFCALL, NFCOV, NFGCAL, NGCALL, NGCOV, PERM, R, RCOND, 8783 3 RDREQ, RDRQSV, REGD, REGD0, RESTOR, TOOBIG, VNEED 8784C 8785C *** IV SUBSCRIPT VALUES *** 8786C 8787 PARAMETER (AR=110, CNVCOD=55, COVMAT=26, COVREQ=15, CSAVE=105, 8788 1 CVRQSV=106, D=27, FDH=74, H=56, IERS=108, IPIVS=109, 8789 2 IV1SAV=104, IVNEED=3, J=70, LMAT=42, MODE=35, 8790 3 NEXTIV=46, NEXTV=47, NFCALL=6, NFCOV=52, NFGCAL=7, 8791 4 NGCALL=30, NGCOV=53, PERM=58, R=61, RCOND=53, RDREQ=57, 8792 5 RDRQSV=107, REGD=67, REGD0=82, RESTOR=9, TOOBIG=2, 8793 6 VNEED=4) 8794 DATA MACHEP/-1.D+0/, NEGONE/-1.D+0/, SNGFAC/1.D+2/, ZERO/0.D+0/ 8795C 8796C++++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++ 8797C 8798C 8799 IF (IV(1) .EQ. 0) CALL DIVSET(1, IV, LIV, LV, V) 8800 N1 = 1 8801 NML = N 8802 IV1 = IV(1) 8803 IF (IV1 .LE. 2) GO TO 20 8804C 8805C *** CHECK INPUT INTEGERS *** 8806C 8807 IF (P .LE. 0) GO TO 370 8808 IF (L .LT. 0) GO TO 370 8809 IF (N .LE. L) GO TO 370 8810 IF (LA .LT. N) GO TO 370 8811 IF (IV1 .LT. 12) GO TO 20 8812 IF (IV1 .EQ. 14) GO TO 20 8813 IF (IV1 .EQ. 12) IV(1) = 13 8814C 8815C *** FRESH START -- COMPUTE STORAGE REQUIREMENTS *** 8816C 8817 IF (IV(1) .GT. 16) GO TO 370 8818 LL1O2 = L*(L+1)/2 8819 JLEN = N*P 8820 I = L + P 8821 IF (IV(RDREQ) .GT. 0 .AND. IV(COVREQ) .NE. 0) JLEN = I*(N + I + 1) 8822 IF (IV(1) .NE. 13) GO TO 10 8823 IV(IVNEED) = IV(IVNEED) + L 8824 IV(VNEED) = IV(VNEED) + P + 2*N + JLEN + LL1O2 + L 8825 10 IF (IV(PERM) .LE. AR) IV(PERM) = AR + 1 8826 CALL DRN2G(V, V, IV, LIV, LV, N, N, N1, NML, P, V, V, V, ALF) 8827 IF (IV(1) .NE. 14) GO TO 999 8828C 8829C *** STORAGE ALLOCATION *** 8830C 8831 IV(IPIVS) = IV(NEXTIV) 8832 IV(NEXTIV) = IV(NEXTIV) + L 8833 IV(D) = IV(NEXTV) 8834 IV(REGD0) = IV(D) + P 8835 IV(AR) = IV(REGD0) + N 8836 IV(CSAVE) = IV(AR) + LL1O2 8837 IV(J) = IV(CSAVE) + L 8838 IV(R) = IV(J) + JLEN 8839 IV(NEXTV) = IV(R) + N 8840 IV(IERS) = 0 8841 IF (IV1 .EQ. 13) GO TO 999 8842C 8843C *** SET POINTERS INTO IV AND V *** 8844C 8845 20 AR1 = IV(AR) 8846 D1 = IV(D) 8847 DR1 = IV(J) 8848 DR1L = DR1 + L 8849 R1 = IV(R) 8850 R1L = R1 + L 8851 RD1 = IV(REGD0) 8852 CSAVE1 = IV(CSAVE) 8853 NML = N - L 8854 IF (IV1 .LE. 2) GO TO 50 8855C 8856C *** IF F.D. HESSIAN WILL BE NEEDED (FOR COVARIANCE OR REG. 8857C *** DIAGNOSTICS), HAVE DRN2G COMPUTE ONLY THE PART CORRESP. 8858C *** TO ALF WITH C FIXED... 8859C 8860 IF (L .LE. 0) GO TO 30 8861 IV(CVRQSV) = IV(COVREQ) 8862 IF (IABS(IV(COVREQ)) .GE. 3) IV(COVREQ) = 0 8863 IV(RDRQSV) = IV(RDREQ) 8864 IF (IV(RDREQ) .GT. 0) IV(RDREQ) = -1 8865C 8866 30 N2 = NML 8867 CALL DRN2G(V(D1), V(DR1L), IV, LIV, LV, NML, N, N1, N2, P, 8868 1 V(R1L), V(RD1), V, ALF) 8869 IF (IABS(IV(RESTOR)-2) .EQ. 1 .AND. L .GT. 0) 8870 1 CALL DV7CPY(L, C, V(CSAVE1)) 8871 IV1 = IV(1) 8872 IF (IV1 .EQ. 2) GO TO 150 8873 IF (IV1 .GT. 2) GO TO 230 8874C 8875C *** NEW FUNCTION VALUE (RESIDUAL) NEEDED *** 8876C 8877 IV(IV1SAV) = IV(1) 8878 IV(1) = IABS(IV1) 8879 IF (IV(RESTOR) .EQ. 2 .AND. L .GT. 0) CALL DV7CPY(L, V(CSAVE1), C) 8880 GO TO 999 8881C 8882C *** COMPUTE NEW RESIDUAL OR GRADIENT *** 8883C 8884 50 IV(1) = IV(IV1SAV) 8885 MD = IV(MODE) 8886 IF (MD .LE. 0) GO TO 60 8887 NML = N 8888 DR1L = DR1 8889 R1L = R1 8890 60 IF (IV(TOOBIG) .NE. 0) GO TO 30 8891 IF (IABS(IV1) .EQ. 2) GO TO 170 8892C 8893C *** COMPUTE NEW RESIDUAL *** 8894C 8895 IF (L1 .LE. L) CALL DV7CPY(N, V(R1), Y) 8896 IF (L1 .GT. L) CALL DV2AXY(N, V(R1), NEGONE, A(1,L1), Y) 8897 IF (MD .GT. 0) GO TO 120 8898 IER = 0 8899 IF (L .LE. 0) GO TO 110 8900 LL1O2 = L * (L + 1) / 2 8901 IPIV1 = IV(IPIVS) 8902 CALL DQ7RFH(IER, IV(IPIV1), N, LA, 0, L, A, V(AR1), LL1O2, C) 8903C 8904C *** DETERMINE NUMERICAL RANK OF A *** 8905C 8906 IF (MACHEP .LE. ZERO) MACHEP = DR7MDC(3) 8907 SINGTL = SNGFAC * DBLE(MAX0(L,N)) * MACHEP 8908 K = L 8909 IF (IER .NE. 0) K = IER - 1 8910 70 IF (K .LE. 0) GO TO 90 8911 T = DL7SVX(K, V(AR1), C, C) 8912 IF (T .GT. ZERO) T = DL7SVN(K, V(AR1), C, C) / T 8913 IF (T .GT. SINGTL) GO TO 80 8914 K = K - 1 8915 GO TO 70 8916C 8917C *** RECORD RANK IN IV(IERS)... IV(IERS) = 0 MEANS FULL RANK, 8918C *** IV(IERS) .GT. 0 MEANS RANK IV(IERS) - 1. 8919C 8920 80 IF (K .GE. L) GO TO 100 8921 90 IER = K + 1 8922 CALL DV7SCP(L-K, C(K+1), ZERO) 8923 100 IV(IERS) = IER 8924 IF (K .LE. 0) GO TO 110 8925C 8926C *** APPLY HOUSEHOLDER TRANSFORMATONS TO RESIDUALS... 8927C 8928 CALL DQ7APL(LA, N, K, A, V(R1), IER) 8929C 8930C *** COMPUTING C NOW MAY SAVE A FUNCTION EVALUATION AT 8931C *** THE LAST ITERATION. 8932C 8933 CALL DL7ITV(K, C, V(AR1), V(R1)) 8934 CALL DV7PRM(L, IV(IPIV1), C) 8935C 8936 110 IF(IV(1) .LT. 2) GO TO 220 8937 GO TO 999 8938C 8939C 8940C *** RESIDUAL COMPUTATION FOR F.D. HESSIAN *** 8941C 8942 120 IF (L .LE. 0) GO TO 140 8943 DO 130 I = 1, L 8944 CALL DV2AXY(N, V(R1), -C(I), A(1,I), V(R1)) 8945 130 CONTINUE 8946 140 IF (IV(1) .GT. 0) GO TO 30 8947 IV(1) = 2 8948 GO TO 160 8949C 8950C *** NEW GRADIENT (JACOBIAN) NEEDED *** 8951C 8952 150 IV(IV1SAV) = IV1 8953 IF (IV(NFGCAL) .NE. IV(NFCALL)) IV(1) = 1 8954 160 CALL DV7SCP(N*P, V(DR1), ZERO) 8955 GO TO 999 8956C 8957C *** COMPUTE NEW JACOBIAN *** 8958C 8959 170 NOCOV = MD .LE. P .OR. IABS(IV(COVREQ)) .GE. 3 8960 FDH0 = DR1 + N*(P+L) 8961 IF (NDA .LE. 0) GO TO 370 8962 DO 180 I = 1, NDA 8963 I1 = IN(1,I) - 1 8964 IF (I1 .LT. 0) GO TO 180 8965 J1 = IN(2,I) 8966 K = DR1 + I1*N 8967 T = NEGONE 8968 IF (J1 .LE. L) T = -C(J1) 8969 CALL DV2AXY(N, V(K), T, DA(1,I), V(K)) 8970 IF (NOCOV) GO TO 180 8971 IF (J1 .GT. L) GO TO 180 8972C *** ADD IN (L,P) PORTION OF SECOND-ORDER PART OF HESSIAN 8973C *** FOR COVARIANCE OR REG. DIAG. COMPUTATIONS... 8974 J1 = J1 + P 8975 K = FDH0 + J1*(J1-1)/2 + I1 8976 V(K) = V(K) - DD7TPR(N, V(R1), DA(1,I)) 8977 180 CONTINUE 8978 IF (IV1 .EQ. 2) GO TO 190 8979 IV(1) = IV1 8980 GO TO 999 8981 190 IF (L .LE. 0) GO TO 30 8982 IF (MD .GT. P) GO TO 240 8983 IF (MD .GT. 0) GO TO 30 8984 K = DR1 8985 IER = IV(IERS) 8986 NRAN = L 8987 IF (IER .GT. 0) NRAN = IER - 1 8988 IF (NRAN .LE. 0) GO TO 210 8989 DO 200 I = 1, P 8990 CALL DQ7APL(LA, N, NRAN, A, V(K), IER) 8991 K = K + N 8992 200 CONTINUE 8993 210 CALL DV7CPY(L, V(CSAVE1), C) 8994 220 IF (IER .EQ. 0) GO TO 30 8995C 8996C *** ADJUST SUBSCRIPTS DESCRIBING R AND DR... 8997C 8998 NRAN = IER - 1 8999 DR1L = DR1 + NRAN 9000 NML = N - NRAN 9001 R1L = R1 + NRAN 9002 GO TO 30 9003C 9004C *** CONVERGENCE OR LIMIT REACHED *** 9005C 9006 230 IF (L .LE. 0) GO TO 350 9007 IV(COVREQ) = IV(CVRQSV) 9008 IV(RDREQ) = IV(RDRQSV) 9009 IF (IV(1) .GT. 6) GO TO 360 9010 IF (MOD(IV(RDREQ),4) .EQ. 0) GO TO 360 9011 IF (IV(FDH) .LE. 0 .AND. IABS(IV(COVREQ)) .LT. 3) GO TO 360 9012 IF (IV(REGD) .GT. 0) GO TO 360 9013 IF (IV(COVMAT) .GT. 0) GO TO 360 9014C 9015C *** PREPARE TO FINISH COMPUTING COVARIANCE MATRIX AND REG. DIAG. *** 9016C 9017 PP = L + P 9018 I = 0 9019 IF (MOD(IV(RDREQ),4) .GE. 2) I = 1 9020 IF (MOD(IV(RDREQ),2) .EQ. 1 .AND. IABS(IV(COVREQ)) .EQ. 1) I = I+2 9021 IV(MODE) = PP + I 9022 I = DR1 + N*PP 9023 K = P * (P + 1) / 2 9024 I1 = IV(LMAT) 9025 CALL DV7CPY(K, V(I), V(I1)) 9026 I = I + K 9027 CALL DV7SCP(PP*(PP+1)/2 - K, V(I), ZERO) 9028 IV(NFCOV) = IV(NFCOV) + 1 9029 IV(NFCALL) = IV(NFCALL) + 1 9030 IV(NFGCAL) = IV(NFCALL) 9031 IV(CNVCOD) = IV(1) 9032 IV(IV1SAV) = -1 9033 IV(1) = 1 9034 IV(NGCALL) = IV(NGCALL) + 1 9035 IV(NGCOV) = IV(NGCOV) + 1 9036 GO TO 999 9037C 9038C *** FINISH COVARIANCE COMPUTATION *** 9039C 9040 240 I = DR1 + N*P 9041 DO 250 I1 = 1, L 9042 CALL DV7SCL(N, V(I), NEGONE, A(1,I1)) 9043 I = I + N 9044 250 CONTINUE 9045 PP = L + P 9046 HSAVE = IV(H) 9047 K = DR1 + N*PP 9048 LH = PP * (PP + 1) / 2 9049 IF (IABS(IV(COVREQ)) .LT. 3) GO TO 270 9050 I = IV(MODE) - 4 9051 IF (I .GE. PP) GO TO 260 9052 CALL DV7SCP(LH, V(K), ZERO) 9053 CALL DQ7RAD(N, N, PP, V, .FALSE., V(K), V(DR1), V) 9054 IV(MODE) = I + 8 9055 IV(1) = 2 9056 IV(NGCALL) = IV(NGCALL) + 1 9057 IV(NGCOV) = IV(NGCOV) + 1 9058 GO TO 160 9059C 9060 260 IV(MODE) = I 9061 GO TO 300 9062C 9063 270 PP1 = P + 1 9064 DRI = DR1 + N*P 9065 LI = K + P*PP1/2 9066 DO 290 I = PP1, PP 9067 DRI1 = DR1 9068 DO 280 I1 = 1, I 9069 V(LI) = V(LI) + DD7TPR(N, V(DRI), V(DRI1)) 9070 LI = LI + 1 9071 DRI1 = DRI1 + N 9072 280 CONTINUE 9073 DRI = DRI + N 9074 290 CONTINUE 9075 CALL DL7SRT(PP1, PP, V(K), V(K), I) 9076 IF (I .NE. 0) GO TO 310 9077 300 TEMP1 = K + LH 9078 T = DL7SVN(PP, V(K), V(TEMP1), V(TEMP1)) 9079 IF (T .LE. ZERO) GO TO 310 9080 T = T / DL7SVX(PP, V(K), V(TEMP1), V(TEMP1)) 9081 V(RCOND) = T 9082 IF (T .GT. DR7MDC(4)) GO TO 320 9083 310 IV(REGD) = -1 9084 IV(COVMAT) = -1 9085 IV(FDH) = -1 9086 GO TO 340 9087 320 IV(H) = TEMP1 9088 IV(FDH) = IABS(HSAVE) 9089 IF (IV(MODE) - PP .LT. 2) GO TO 330 9090 I = IV(H) 9091 CALL DV7SCP(LH, V(I), ZERO) 9092 330 CALL DN2LRD(V(DR1), IV, V(K), LH, LIV, LV, N, N, PP, V(R1), 9093 1 V(RD1), V) 9094 340 CALL DC7VFN(IV, V(K), LH, LIV, LV, N, PP, V) 9095 IV(H) = HSAVE 9096C 9097 350 IF (IV(REGD) .EQ. 1) IV(REGD) = RD1 9098 360 IF (IV(1) .LE. 11) CALL DS7CPR(C, IV, L, LIV) 9099 IF (IV(1) .GT. 6) GO TO 999 9100 CALL DN2CVP(IV, LIV, LV, P+L, V) 9101 CALL DN2RDP(IV, LIV, LV, N, V(RD1), V) 9102 GO TO 999 9103C 9104 370 IV(1) = 66 9105 CALL DITSUM(V, V, IV, LIV, LV, P, V, ALF) 9106C 9107 999 RETURN 9108C 9109C *** LAST CARD OF DRNSG FOLLOWS *** 9110 END 9111 SUBROUTINE DL7TVM(N, X, L, Y) 9112C 9113C *** COMPUTE X = (L**T)*Y, WHERE L IS AN N X N LOWER 9114C *** TRIANGULAR MATRIX STORED COMPACTLY BY ROWS. X AND Y MAY 9115C *** OCCUPY THE SAME STORAGE. *** 9116C 9117 INTEGER N 9118 DOUBLE PRECISION X(N), L(*), Y(N) 9119C DIMENSION L(N*(N+1)/2) 9120 INTEGER I, IJ, I0, J 9121 DOUBLE PRECISION YI, ZERO 9122 PARAMETER (ZERO=0.D+0) 9123C 9124 I0 = 0 9125 DO 20 I = 1, N 9126 YI = Y(I) 9127 X(I) = ZERO 9128 DO 10 J = 1, I 9129 IJ = I0 + J 9130 X(J) = X(J) + YI*L(IJ) 9131 10 CONTINUE 9132 I0 = I0 + I 9133 20 CONTINUE 9134 RETURN 9135C *** LAST CARD OF DL7TVM FOLLOWS *** 9136 END 9137 SUBROUTINE DL7ITV(N, X, L, Y) 9138C 9139C *** SOLVE (L**T)*X = Y, WHERE L IS AN N X N LOWER TRIANGULAR 9140C *** MATRIX STORED COMPACTLY BY ROWS. X AND Y MAY OCCUPY THE SAME 9141C *** STORAGE. *** 9142C 9143 INTEGER N 9144 DOUBLE PRECISION X(N), L(*), Y(N) 9145 INTEGER I, II, IJ, IM1, I0, J, NP1 9146 DOUBLE PRECISION XI, ZERO 9147 PARAMETER (ZERO=0.D+0) 9148C 9149 DO 10 I = 1, N 9150 X(I) = Y(I) 9151 10 CONTINUE 9152 NP1 = N + 1 9153 I0 = N*(N+1)/2 9154 DO 30 II = 1, N 9155 I = NP1 - II 9156 XI = X(I)/L(I0) 9157 X(I) = XI 9158 IF (I .LE. 1) GO TO 999 9159 I0 = I0 - I 9160 IF (XI .EQ. ZERO) GO TO 30 9161 IM1 = I - 1 9162 DO 20 J = 1, IM1 9163 IJ = I0 + J 9164 X(J) = X(J) - XI*L(IJ) 9165 20 CONTINUE 9166 30 CONTINUE 9167 999 RETURN 9168C *** LAST CARD OF DL7ITV FOLLOWS *** 9169 END 9170 SUBROUTINE DRMNGB(B, D, FX, G, IV, LIV, LV, N, V, X) 9171C 9172C *** CARRY OUT DMNGB (SIMPLY BOUNDED MINIMIZATION) ITERATIONS, 9173C *** USING DOUBLE-DOGLEG/BFGS STEPS. 9174C 9175C *** PARAMETER DECLARATIONS *** 9176C 9177 INTEGER LIV, LV, N 9178 INTEGER IV(LIV) 9179 DOUBLE PRECISION B(2,N), D(N), FX, G(N), V(LV), X(N) 9180C 9181C-------------------------- PARAMETER USAGE -------------------------- 9182C 9183C B.... VECTOR OF LOWER AND UPPER BOUNDS ON X. 9184C D.... SCALE VECTOR. 9185C FX... FUNCTION VALUE. 9186C G.... GRADIENT VECTOR. 9187C IV... INTEGER VALUE ARRAY. 9188C LIV.. LENGTH OF IV (AT LEAST 59) + N. 9189C LV... LENGTH OF V (AT LEAST 71 + N*(N+19)/2). 9190C N.... NUMBER OF VARIABLES (COMPONENTS IN X AND G). 9191C V.... FLOATING-POINT VALUE ARRAY. 9192C X.... VECTOR OF PARAMETERS TO BE OPTIMIZED. 9193C 9194C *** DISCUSSION *** 9195C 9196C PARAMETERS IV, N, V, AND X ARE THE SAME AS THE CORRESPONDING 9197C ONES TO DMNGB (WHICH SEE), EXCEPT THAT V CAN BE SHORTER (SINCE 9198C THE PART OF V THAT DMNGB USES FOR STORING G IS NOT NEEDED). 9199C MOREOVER, COMPARED WITH DMNGB, IV(1) MAY HAVE THE TWO ADDITIONAL 9200C OUTPUT VALUES 1 AND 2, WHICH ARE EXPLAINED BELOW, AS IS THE USE 9201C OF IV(TOOBIG) AND IV(NFGCAL). THE VALUE IV(G), WHICH IS AN 9202C OUTPUT VALUE FROM DMNGB (AND SMSNOB), IS NOT REFERENCED BY 9203C DRMNGB OR THE SUBROUTINES IT CALLS. 9204C FX AND G NEED NOT HAVE BEEN INITIALIZED WHEN DRMNGB IS CALLED 9205C WITH IV(1) = 12, 13, OR 14. 9206C 9207C IV(1) = 1 MEANS THE CALLER SHOULD SET FX TO F(X), THE FUNCTION VALUE 9208C AT X, AND CALL DRMNGB AGAIN, HAVING CHANGED NONE OF THE 9209C OTHER PARAMETERS. AN EXCEPTION OCCURS IF F(X) CANNOT BE 9210C (E.G. IF OVERFLOW WOULD OCCUR), WHICH MAY HAPPEN BECAUSE 9211C OF AN OVERSIZED STEP. IN THIS CASE THE CALLER SHOULD SET 9212C IV(TOOBIG) = IV(2) TO 1, WHICH WILL CAUSE DRMNGB TO IG- 9213C NORE FX AND TRY A SMALLER STEP. THE PARAMETER NF THAT 9214C DMNGB PASSES TO CALCF (FOR POSSIBLE USE BY CALCG) IS A 9215C COPY OF IV(NFCALL) = IV(6). 9216C IV(1) = 2 MEANS THE CALLER SHOULD SET G TO G(X), THE GRADIENT VECTOR 9217C OF F AT X, AND CALL DRMNGB AGAIN, HAVING CHANGED NONE OF 9218C THE OTHER PARAMETERS EXCEPT POSSIBLY THE SCALE VECTOR D 9219C WHEN IV(DTYPE) = 0. THE PARAMETER NF THAT DMNGB PASSES 9220C TO CALCG IS IV(NFGCAL) = IV(7). IF G(X) CANNOT BE 9221C EVALUATED, THEN THE CALLER MAY SET IV(NFGCAL) TO 0, IN 9222C WHICH CASE DRMNGB WILL RETURN WITH IV(1) = 65. 9223C. 9224C *** GENERAL *** 9225C 9226C CODED BY DAVID M. GAY (DECEMBER 1979). REVISED SEPT. 1982. 9227C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH SUPPORTED 9228C IN PART BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS 9229C MCS-7600324 AND MCS-7906671. 9230C 9231C (SEE DMNG FOR REFERENCES.) 9232C 9233C+++++++++++++++++++++++++++ DECLARATIONS ++++++++++++++++++++++++++++ 9234C 9235C *** LOCAL VARIABLES *** 9236C 9237 INTEGER DG1, DSTEP1, G01, I, I1, IPI, IPN, J, K, L, LSTGST, 9238 1 N1, NP1, NWTST1, RSTRST, STEP1, TEMP0, TEMP1, TD1, TG1, 9239 2 W1, X01, Z 9240 DOUBLE PRECISION GI, T, XI 9241C 9242C *** CONSTANTS *** 9243C 9244 DOUBLE PRECISION NEGONE, ONE, ONEP2, ZERO 9245C 9246C *** NO INTRINSIC FUNCTIONS *** 9247C 9248C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 9249C 9250 LOGICAL STOPX 9251 DOUBLE PRECISION DD7TPR, DRLDST, DV2NRM 9252 EXTERNAL DA7SST, DD7DGB,DIVSET, DD7TPR, I7SHFT,DITSUM, DL7TVM, 9253 1 DL7UPD,DL7VML,DPARCK, DQ7RSH, DRLDST, STOPX, DV2NRM, 9254 2 DV2AXY,DV7CPY, DV7IPR, DV7SCP, DV7VMP, DW7ZBF 9255C 9256C DA7SST.... ASSESSES CANDIDATE STEP. 9257C DD7DGB... COMPUTES SIMPLY BOUNDED DOUBLE-DOGLEG (CANDIDATE) STEP. 9258C DIVSET.... SUPPLIES DEFAULT IV AND V INPUT COMPONENTS. 9259C DD7TPR... RETURNS INNER PRODUCT OF TWO VECTORS. 9260C I7SHFT... CYCLICALLLY SHIFTS AN ARRAY OF INTEGERS. 9261C DITSUM.... PRINTS ITERATION SUMMARY AND INFO ON INITIAL AND FINAL X. 9262C DL7TVM... MULTIPLIES TRANSPOSE OF LOWER TRIANGLE TIMES VECTOR. 9263C LUPDT.... UPDATES CHOLESKY FACTOR OF HESSIAN APPROXIMATION. 9264C DL7VML.... MULTIPLIES LOWER TRIANGLE TIMES VECTOR. 9265C DPARCK.... CHECKS VALIDITY OF INPUT IV AND V VALUES. 9266C DQ7RSH... CYCLICALLY SHIFTS CHOLESKY FACTOR. 9267C DRLDST... COMPUTES V(RELDX) = RELATIVE STEP SIZE. 9268C STOPX.... RETURNS .TRUE. IF THE BREAK KEY HAS BEEN PRESSED. 9269C DV2NRM... RETURNS THE 2-NORM OF A VECTOR. 9270C DV2AXY.... COMPUTES SCALAR TIMES ONE VECTOR PLUS ANOTHER. 9271C DV7CPY.... COPIES ONE VECTOR TO ANOTHER. 9272C DV7IPR... CYCLICALLY SHIFTS A FLOATING-POINT ARRAY. 9273C DV7SCP... SETS ALL ELEMENTS OF A VECTOR TO A SCALAR. 9274C DV7VMP... MULTIPLIES VECTOR BY VECTOR RAISED TO POWER (COMPONENTWISE). 9275C DW7ZBF... COMPUTES W AND Z FOR DL7UPD CORRESPONDING TO BFGS UPDATE. 9276C 9277C *** SUBSCRIPTS FOR IV AND V *** 9278C 9279 INTEGER CNVCOD, DG, DGNORM, DINIT, DSTNRM, F, F0, FDIF, 9280 1 GTSTEP, INCFAC, INITH, IRC, IVNEED, KAGQT, LMAT, 9281 2 LMAX0, LMAXS, MODE, MODEL, MXFCAL, MXITER, NC, NEXTIV, 9282 3 NEXTV, NFCALL, NFGCAL, NGCALL, NITER, NWTSTP, PERM, 9283 4 PREDUC, RADFAC, RADINC, RADIUS, RAD0, RELDX, RESTOR, STEP, 9284 4 STGLIM, STLSTG, TOOBIG, TUNER4, TUNER5, VNEED, XIRC, X0 9285C 9286C *** IV SUBSCRIPT VALUES *** 9287C 9288C *** (NOTE THAT NC IS STORED IN IV(G0)) *** 9289C 9290 PARAMETER (CNVCOD=55, DG=37, INITH=25, IRC=29, IVNEED=3, KAGQT=33, 9291 1 MODE=35, MODEL=5, MXFCAL=17, MXITER=18, NC=48, 9292 2 NEXTIV=46, NEXTV=47, NFCALL=6, NFGCAL=7, NGCALL=30, 9293 3 NITER=31, NWTSTP=34, PERM=58, RADINC=8, RESTOR=9, 9294 4 STEP=40, STGLIM=11, STLSTG=41, TOOBIG=2, XIRC=13, 9295 5 X0=43) 9296C 9297C *** V SUBSCRIPT VALUES *** 9298C 9299 PARAMETER (DGNORM=1, DINIT=38, DSTNRM=2, F=10, F0=13, FDIF=11, 9300 1 GTSTEP=4, INCFAC=23, LMAT=42, LMAX0=35, LMAXS=36, 9301 2 PREDUC=7, RADFAC=16, RADIUS=8, RAD0=9, RELDX=17, 9302 3 TUNER4=29, TUNER5=30, VNEED=4) 9303C 9304 PARAMETER (NEGONE=-1.D+0, ONE=1.D+0, ONEP2=1.2D+0, ZERO=0.D+0) 9305C 9306C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 9307C 9308 I = IV(1) 9309 IF (I .EQ. 1) GO TO 70 9310 IF (I .EQ. 2) GO TO 80 9311C 9312C *** CHECK VALIDITY OF IV AND V INPUT VALUES *** 9313C 9314 IF (IV(1) .EQ. 0) CALL DIVSET(2, IV, LIV, LV, V) 9315 IF (IV(1) .LT. 12) GO TO 10 9316 IF (IV(1) .GT. 13) GO TO 10 9317 IV(VNEED) = IV(VNEED) + N*(N+19)/2 9318 IV(IVNEED) = IV(IVNEED) + N 9319 10 CALL DPARCK(2, D, IV, LIV, LV, N, V) 9320 I = IV(1) - 2 9321 IF (I .GT. 12) GO TO 999 9322c GO TO (250, 250, 250, 250, 250, 250, 190, 150, 190, 20, 20, 30), I 9323 select case(I) 9324 case(1:6) 9325 goto 250 9326 case(7,9) 9327 goto 190 9328 case(8) 9329 goto 150 9330 case(10,11) 9331 goto 20 9332 case(12) 9333 goto 30 9334 end select 9335C 9336C *** STORAGE ALLOCATION *** 9337C 9338 20 L = IV(LMAT) 9339 IV(X0) = L + N*(N+1)/2 9340 IV(STEP) = IV(X0) + 2*N 9341 IV(STLSTG) = IV(STEP) + 2*N 9342 IV(NWTSTP) = IV(STLSTG) + N 9343 IV(DG) = IV(NWTSTP) + 2*N 9344 IV(NEXTV) = IV(DG) + 2*N 9345 IV(NEXTIV) = IV(PERM) + N 9346 IF (IV(1) .NE. 13) GO TO 30 9347 IV(1) = 14 9348 GO TO 999 9349C 9350C *** INITIALIZATION *** 9351C 9352 30 IV(NITER) = 0 9353 IV(NFCALL) = 1 9354 IV(NGCALL) = 1 9355 IV(NFGCAL) = 1 9356 IV(MODE) = -1 9357 IV(MODEL) = 1 9358 IV(STGLIM) = 1 9359 IV(TOOBIG) = 0 9360 IV(CNVCOD) = 0 9361 IV(RADINC) = 0 9362 IV(NC) = N 9363 V(RAD0) = ZERO 9364C 9365C *** CHECK CONSISTENCY OF B AND INITIALIZE IP ARRAY *** 9366C 9367 IPI = IV(PERM) 9368 DO 40 I = 1, N 9369 IV(IPI) = I 9370 IPI = IPI + 1 9371 IF (B(1,I) .GT. B(2,I)) GO TO 410 9372 40 CONTINUE 9373C 9374 IF (V(DINIT) .GE. ZERO) CALL DV7SCP(N, D, V(DINIT)) 9375 IF (IV(INITH) .NE. 1) GO TO 60 9376C 9377C *** SET THE INITIAL HESSIAN APPROXIMATION TO DIAG(D)**-2 *** 9378C 9379 L = IV(LMAT) 9380 CALL DV7SCP(N*(N+1)/2, V(L), ZERO) 9381 K = L - 1 9382 DO 50 I = 1, N 9383 K = K + I 9384 T = D(I) 9385 IF (T .LE. ZERO) T = ONE 9386 V(K) = T 9387 50 CONTINUE 9388C 9389C *** GET INITIAL FUNCTION VALUE *** 9390C 9391 60 IV(1) = 1 9392 GO TO 440 9393C 9394 70 V(F) = FX 9395 IF (IV(MODE) .GE. 0) GO TO 250 9396 V(F0) = FX 9397 IV(1) = 2 9398 IF (IV(TOOBIG) .EQ. 0) GO TO 999 9399 IV(1) = 63 9400 GO TO 430 9401C 9402C *** MAKE SURE GRADIENT COULD BE COMPUTED *** 9403C 9404 80 IF (IV(TOOBIG) .EQ. 0) GO TO 90 9405 IV(1) = 65 9406 GO TO 430 9407C 9408C *** CHOOSE INITIAL PERMUTATION *** 9409C 9410 90 IPI = IV(PERM) 9411 IPN = IPI + N 9412 N1 = N 9413 NP1 = N + 1 9414 L = IV(LMAT) 9415 W1 = IV(NWTSTP) + N 9416 K = N - IV(NC) 9417 DO 120 I = 1, N 9418 IPN = IPN - 1 9419 J = IV(IPN) 9420 IF (B(1,J) .GE. B(2,J)) GO TO 100 9421 XI = X(J) 9422 GI = G(J) 9423 IF (XI .LE. B(1,J) .AND. GI .GT. ZERO) GO TO 100 9424 IF (XI .GE. B(2,J) .AND. GI .LT. ZERO) GO TO 100 9425C *** DISALLOW CONVERGENCE IF X(J) HAS JUST BEEN FREED *** 9426 IF (I .LE. K) IV(CNVCOD) = 0 9427 GO TO 120 9428 100 I1 = NP1 - I 9429 IF (I1 .GE. N1) GO TO 110 9430 CALL I7SHFT(N1, I1, IV(IPI)) 9431 CALL DQ7RSH(I1, N1, .FALSE., G, V(L), V(W1)) 9432 110 N1 = N1 - 1 9433 120 CONTINUE 9434C 9435 IV(NC) = N1 9436 V(DGNORM) = ZERO 9437 IF (N1 .LE. 0) GO TO 130 9438 DG1 = IV(DG) 9439 CALL DV7VMP(N, V(DG1), G, D, -1) 9440 CALL DV7IPR(N, IV(IPI), V(DG1)) 9441 V(DGNORM) = DV2NRM(N1, V(DG1)) 9442 130 IF (IV(CNVCOD) .NE. 0) GO TO 420 9443 IF (IV(MODE) .EQ. 0) GO TO 370 9444C 9445C *** ALLOW FIRST STEP TO HAVE SCALED 2-NORM AT MOST V(LMAX0) *** 9446C 9447 V(RADIUS) = V(LMAX0) 9448C 9449 IV(MODE) = 0 9450C 9451C 9452C----------------------------- MAIN LOOP ----------------------------- 9453C 9454C 9455C *** PRINT ITERATION SUMMARY, CHECK ITERATION LIMIT *** 9456C 9457 140 CALL DITSUM(D, G, IV, LIV, LV, N, V, X) 9458 150 K = IV(NITER) 9459 IF (K .LT. IV(MXITER)) GO TO 160 9460 IV(1) = 10 9461 GO TO 430 9462C 9463C *** UPDATE RADIUS *** 9464C 9465 160 IV(NITER) = K + 1 9466 IF (K .EQ. 0) GO TO 170 9467 T = V(RADFAC) * V(DSTNRM) 9468 IF (V(RADFAC) .LT. ONE .OR. T .GT. V(RADIUS)) V(RADIUS) = T 9469C 9470C *** INITIALIZE FOR START OF NEXT ITERATION *** 9471C 9472 170 X01 = IV(X0) 9473 V(F0) = V(F) 9474 IV(IRC) = 4 9475 IV(KAGQT) = -1 9476C 9477C *** COPY X TO X0 *** 9478C 9479 CALL DV7CPY(N, V(X01), X) 9480C 9481C *** CHECK STOPX AND FUNCTION EVALUATION LIMIT *** 9482C 9483 180 IF (.NOT. STOPX()) GO TO 200 9484 IV(1) = 11 9485 GO TO 210 9486C 9487C *** COME HERE WHEN RESTARTING AFTER FUNC. EVAL. LIMIT OR STOPX. 9488C 9489 190 IF (V(F) .GE. V(F0)) GO TO 200 9490 V(RADFAC) = ONE 9491 K = IV(NITER) 9492 GO TO 160 9493C 9494 200 IF (IV(NFCALL) .LT. IV(MXFCAL)) GO TO 220 9495 IV(1) = 9 9496 210 IF (V(F) .GE. V(F0)) GO TO 430 9497C 9498C *** IN CASE OF STOPX OR FUNCTION EVALUATION LIMIT WITH 9499C *** IMPROVED V(F), EVALUATE THE GRADIENT AT X. 9500C 9501 IV(CNVCOD) = IV(1) 9502 GO TO 360 9503C 9504C. . . . . . . . . . . . . COMPUTE CANDIDATE STEP . . . . . . . . . . 9505C 9506 220 STEP1 = IV(STEP) 9507 DG1 = IV(DG) 9508 NWTST1 = IV(NWTSTP) 9509 W1 = NWTST1 + N 9510 DSTEP1 = STEP1 + N 9511 IPI = IV(PERM) 9512 L = IV(LMAT) 9513 TG1 = DG1 + N 9514 X01 = IV(X0) 9515 TD1 = X01 + N 9516 CALL DD7DGB(B, D, V(DG1), V(DSTEP1), G, IV(IPI), IV(KAGQT), 9517 1 V(L), LV, N, IV(NC), V(NWTST1), V(STEP1), V(TD1), 9518 2 V(TG1), V, V(W1), V(X01)) 9519 IF (IV(IRC) .NE. 6) GO TO 230 9520 IF (IV(RESTOR) .NE. 2) GO TO 250 9521 RSTRST = 2 9522 GO TO 260 9523C 9524C *** CHECK WHETHER EVALUATING F(X0 + STEP) LOOKS WORTHWHILE *** 9525C 9526 230 IV(TOOBIG) = 0 9527 IF (V(DSTNRM) .LE. ZERO) GO TO 250 9528 IF (IV(IRC) .NE. 5) GO TO 240 9529 IF (V(RADFAC) .LE. ONE) GO TO 240 9530 IF (V(PREDUC) .GT. ONEP2 * V(FDIF)) GO TO 240 9531 IF (IV(RESTOR) .NE. 2) GO TO 250 9532 RSTRST = 0 9533 GO TO 260 9534C 9535C *** COMPUTE F(X0 + STEP) *** 9536C 9537 240 CALL DV2AXY(N, X, ONE, V(STEP1), V(X01)) 9538 IV(NFCALL) = IV(NFCALL) + 1 9539 IV(1) = 1 9540 GO TO 440 9541C 9542C. . . . . . . . . . . . . ASSESS CANDIDATE STEP . . . . . . . . . . . 9543C 9544 250 RSTRST = 3 9545 260 X01 = IV(X0) 9546 V(RELDX) = DRLDST(N, D, X, V(X01)) 9547 CALL DA7SST(IV, LIV, LV, V) 9548 STEP1 = IV(STEP) 9549 LSTGST = IV(STLSTG) 9550 I = IV(RESTOR) + 1 9551c GO TO (300, 270, 280, 290), I 9552 select case(I) 9553 case(1) 9554 goto 300 9555 case(2) 9556 goto 270 9557 case(3) 9558 goto 280 9559 case(4) 9560 goto 290 9561 end select 9562 270 CALL DV7CPY(N, X, V(X01)) 9563 GO TO 300 9564 280 CALL DV7CPY(N, V(LSTGST), X) 9565 GO TO 300 9566 290 CALL DV7CPY(N, X, V(LSTGST)) 9567 CALL DV2AXY(N, V(STEP1), NEGONE, V(X01), X) 9568 V(RELDX) = DRLDST(N, D, X, V(X01)) 9569 IV(RESTOR) = RSTRST 9570C 9571 300 K = IV(IRC) 9572c GO TO (310,340,340,340,310,320,330,330,330,330,330,330,400,370), K 9573 select case(K) 9574 case(1,5) 9575 goto 310 9576 case(2:4) 9577 goto 340 9578 case(6) 9579 goto 320 9580 case(7:12) 9581 goto 330 9582 case(13) 9583 goto 400 9584 case(14) 9585 goto 370 9586 end select 9587C 9588C *** RECOMPUTE STEP WITH CHANGED RADIUS *** 9589C 9590 310 V(RADIUS) = V(RADFAC) * V(DSTNRM) 9591 GO TO 180 9592C 9593C *** COMPUTE STEP OF LENGTH V(LMAXS) FOR SINGULAR CONVERGENCE TEST. 9594C 9595 320 V(RADIUS) = V(LMAXS) 9596 GO TO 220 9597C 9598C *** CONVERGENCE OR FALSE CONVERGENCE *** 9599C 9600 330 IV(CNVCOD) = K - 4 9601 IF (V(F) .GE. V(F0)) GO TO 420 9602 IF (IV(XIRC) .EQ. 14) GO TO 420 9603 IV(XIRC) = 14 9604C 9605C. . . . . . . . . . . . PROCESS ACCEPTABLE STEP . . . . . . . . . . . 9606C 9607 340 X01 = IV(X0) 9608 STEP1 = IV(STEP) 9609 CALL DV2AXY(N, V(STEP1), NEGONE, V(X01), X) 9610 IF (IV(IRC) .NE. 3) GO TO 360 9611C 9612C *** SET TEMP1 = HESSIAN * STEP FOR USE IN GRADIENT TESTS *** 9613C 9614C *** USE X0 AS TEMPORARY... 9615C 9616 IPI = IV(PERM) 9617 CALL DV7CPY(N, V(X01), V(STEP1)) 9618 CALL DV7IPR(N, IV(IPI), V(X01)) 9619 L = IV(LMAT) 9620 CALL DL7TVM(N, V(X01), V(L), V(X01)) 9621 CALL DL7VML(N, V(X01), V(L), V(X01)) 9622C 9623C *** UNPERMUTE X0 INTO TEMP1 *** 9624C 9625 TEMP1 = IV(STLSTG) 9626 TEMP0 = TEMP1 - 1 9627 DO 350 I = 1, N 9628 J = IV(IPI) 9629 IPI = IPI + 1 9630 K = TEMP0 + J 9631 V(K) = V(X01) 9632 X01 = X01 + 1 9633 350 CONTINUE 9634C 9635C *** SAVE OLD GRADIENT, COMPUTE NEW ONE *** 9636C 9637 360 G01 = IV(NWTSTP) + N 9638 CALL DV7CPY(N, V(G01), G) 9639 IV(NGCALL) = IV(NGCALL) + 1 9640 IV(TOOBIG) = 0 9641 IV(1) = 2 9642 GO TO 999 9643C 9644C *** INITIALIZATIONS -- G0 = G - G0, ETC. *** 9645C 9646 370 G01 = IV(NWTSTP) + N 9647 CALL DV2AXY(N, V(G01), NEGONE, V(G01), G) 9648 STEP1 = IV(STEP) 9649 TEMP1 = IV(STLSTG) 9650 IF (IV(IRC) .NE. 3) GO TO 390 9651C 9652C *** SET V(RADFAC) BY GRADIENT TESTS *** 9653C 9654C *** SET TEMP1 = DIAG(D)**-1 * (HESSIAN*STEP + (G(X0)-G(X))) *** 9655C 9656 CALL DV2AXY(N, V(TEMP1), NEGONE, V(G01), V(TEMP1)) 9657 CALL DV7VMP(N, V(TEMP1), V(TEMP1), D, -1) 9658C 9659C *** DO GRADIENT TESTS *** 9660C 9661 IF (DV2NRM(N, V(TEMP1)) .LE. V(DGNORM) * V(TUNER4)) 9662 1 GO TO 380 9663 IF (DD7TPR(N, G, V(STEP1)) 9664 1 .GE. V(GTSTEP) * V(TUNER5)) GO TO 390 9665 380 V(RADFAC) = V(INCFAC) 9666C 9667C *** UPDATE H, LOOP *** 9668C 9669 390 W1 = IV(NWTSTP) 9670 Z = IV(X0) 9671 L = IV(LMAT) 9672 IPI = IV(PERM) 9673 CALL DV7IPR(N, IV(IPI), V(STEP1)) 9674 CALL DV7IPR(N, IV(IPI), V(G01)) 9675 CALL DW7ZBF(V(L), N, V(STEP1), V(W1), V(G01), V(Z)) 9676C 9677C ** USE THE N-VECTORS STARTING AT V(STEP1) AND V(G01) FOR SCRATCH.. 9678 CALL DL7UPD(V(TEMP1), V(STEP1), V(L), V(G01), V(L), N, V(W1), 9679 1 V(Z)) 9680 IV(1) = 2 9681 GO TO 140 9682C 9683C. . . . . . . . . . . . . . MISC. DETAILS . . . . . . . . . . . . . . 9684C 9685C *** BAD PARAMETERS TO ASSESS *** 9686C 9687 400 IV(1) = 64 9688 GO TO 430 9689C 9690C *** INCONSISTENT B *** 9691C 9692 410 IV(1) = 82 9693 GO TO 430 9694C 9695C *** PRINT SUMMARY OF FINAL ITERATION AND OTHER REQUESTED ITEMS *** 9696C 9697 420 IV(1) = IV(CNVCOD) 9698 IV(CNVCOD) = 0 9699 430 CALL DITSUM(D, G, IV, LIV, LV, N, V, X) 9700 GO TO 999 9701C 9702C *** PROJECT X INTO FEASIBLE REGION (PRIOR TO COMPUTING F OR G) *** 9703C 9704 440 DO 450 I = 1, N 9705 IF (X(I) .LT. B(1,I)) X(I) = B(1,I) 9706 IF (X(I) .GT. B(2,I)) X(I) = B(2,I) 9707 450 CONTINUE 9708C 9709 999 RETURN 9710C 9711C *** LAST CARD OF DRMNGB FOLLOWS *** 9712 END 9713 SUBROUTINE DS7GRD (ALPHA, D, ETA0, FX, G, IRC, N, W, X) 9714C 9715C *** COMPUTE FINITE DIFFERENCE GRADIENT BY STWEART*S SCHEME *** 9716C 9717C *** PARAMETERS *** 9718C 9719 INTEGER IRC, N 9720 DOUBLE PRECISION ALPHA(N), D(N), ETA0, FX, G(N), W(6), X(N) 9721C 9722C....................................................................... 9723C 9724C *** PURPOSE *** 9725C 9726C THIS SUBROUTINE USES AN EMBELLISHED FORM OF THE FINITE-DIFFER- 9727C ENCE SCHEME PROPOSED BY STEWART (REF. 1) TO APPROXIMATE THE 9728C GRADIENT OF THE FUNCTION F(X), WHOSE VALUES ARE SUPPLIED BY 9729C REVERSE COMMUNICATION. 9730C 9731C *** PARAMETER DESCRIPTION *** 9732C 9733C ALPHA IN (APPROXIMATE) DIAGONAL ELEMENTS OF THE HESSIAN OF F(X). 9734C D IN SCALE VECTOR SUCH THAT D(I)*X(I), I = 1,...,N, ARE IN 9735C COMPARABLE UNITS. 9736C ETA0 IN ESTIMATED BOUND ON RELATIVE ERROR IN THE FUNCTION VALUE... 9737C (TRUE VALUE) = (COMPUTED VALUE)*(1+E), WHERE 9738C ABS(E) .LE. ETA0. 9739C FX I/O ON INPUT, FX MUST BE THE COMPUTED VALUE OF F(X). ON 9740C OUTPUT WITH IRC = 0, FX HAS BEEN RESTORED TO ITS ORIGINAL 9741C VALUE, THE ONE IT HAD WHEN DS7GRD WAS LAST CALLED WITH 9742C IRC = 0. 9743C G I/O ON INPUT WITH IRC = 0, G SHOULD CONTAIN AN APPROXIMATION 9744C TO THE GRADIENT OF F NEAR X, E.G., THE GRADIENT AT THE 9745C PREVIOUS ITERATE. WHEN DS7GRD RETURNS WITH IRC = 0, G IS 9746C THE DESIRED FINITE-DIFFERENCE APPROXIMATION TO THE 9747C GRADIENT AT X. 9748C IRC I/O INPUT/RETURN CODE... BEFORE THE VERY FIRST CALL ON DS7GRD, 9749C THE CALLER MUST SET IRC TO 0. WHENEVER DS7GRD RETURNS A 9750C NONZERO VALUE FOR IRC, IT HAS PERTURBED SOME COMPONENT OF 9751C X... THE CALLER SHOULD EVALUATE F(X) AND CALL DS7GRD 9752C AGAIN WITH FX = F(X). 9753C N IN THE NUMBER OF VARIABLES (COMPONENTS OF X) ON WHICH F 9754C DEPENDS. 9755C X I/O ON INPUT WITH IRC = 0, X IS THE POINT AT WHICH THE 9756C GRADIENT OF F IS DESIRED. ON OUTPUT WITH IRC NONZERO, X 9757C IS THE POINT AT WHICH F SHOULD BE EVALUATED. ON OUTPUT 9758C WITH IRC = 0, X HAS BEEN RESTORED TO ITS ORIGINAL VALUE 9759C (THE ONE IT HAD WHEN DS7GRD WAS LAST CALLED WITH IRC = 0) 9760C AND G CONTAINS THE DESIRED GRADIENT APPROXIMATION. 9761C W I/O WORK VECTOR OF LENGTH 6 IN WHICH DS7GRD SAVES CERTAIN 9762C QUANTITIES WHILE THE CALLER IS EVALUATING F(X) AT A 9763C PERTURBED X. 9764C 9765C *** APPLICATION AND USAGE RESTRICTIONS *** 9766C 9767C THIS ROUTINE IS INTENDED FOR USE WITH QUASI-NEWTON ROUTINES 9768C FOR UNCONSTRAINED MINIMIZATION (IN WHICH CASE ALPHA COMES FROM 9769C THE DIAGONAL OF THE QUASI-NEWTON HESSIAN APPROXIMATION). 9770C 9771C *** ALGORITHM NOTES *** 9772C 9773C THIS CODE DEPARTS FROM THE SCHEME PROPOSED BY STEWART (REF. 1) 9774C IN ITS GUARDING AGAINST OVERLY LARGE OR SMALL STEP SIZES AND ITS 9775C HANDLING OF SPECIAL CASES (SUCH AS ZERO COMPONENTS OF ALPHA OR G). 9776C 9777C *** REFERENCES *** 9778C 9779C 1. STEWART, G.W. (1967), A MODIFICATION OF DAVIDON*S MINIMIZATION 9780C METHOD TO ACCEPT DIFFERENCE APPROXIMATIONS OF DERIVATIVES, 9781C J. ASSOC. COMPUT. MACH. 14, PP. 72-83. 9782C 9783C *** HISTORY *** 9784C 9785C DESIGNED AND CODED BY DAVID M. GAY (SUMMER 1977/SUMMER 1980). 9786C 9787C *** GENERAL *** 9788C 9789C THIS ROUTINE WAS PREPARED IN CONNECTION WITH WORK SUPPORTED BY 9790C THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS MCS76-00324 AND 9791C MCS-7906671. 9792C 9793C....................................................................... 9794C 9795C ***** EXTERNAL FUNCTION ***** 9796C 9797 DOUBLE PRECISION DR7MDC 9798 EXTERNAL DR7MDC 9799C DR7MDC... RETURNS MACHINE-DEPENDENT CONSTANTS. 9800C 9801C ***** INTRINSIC FUNCTIONS ***** 9802C/+ 9803 DOUBLE PRECISION DSQRT 9804C/ 9805C ***** LOCAL VARIABLES ***** 9806C 9807 INTEGER FH, FX0, HSAVE, I, XISAVE 9808 DOUBLE PRECISION AAI, AFX, AFXETA, AGI, ALPHAI, AXI, AXIBAR, 9809 1 DISCON, ETA, GI, H, HMIN 9810 DOUBLE PRECISION C2000, FOUR, HMAX0, HMIN0, H0, MACHEP, ONE, P002, 9811 1 THREE, TWO, ZERO 9812C 9813 PARAMETER (C2000=2.0D+3, FOUR=4.0D+0, HMAX0=0.02D+0, HMIN0=5.0D+1, 9814 1 ONE=1.0D+0, P002=0.002D+0, THREE=3.0D+0, 9815 2 TWO=2.0D+0, ZERO=0.0D+0) 9816 PARAMETER (FH=3, FX0=4, HSAVE=5, XISAVE=6) 9817C 9818C--------------------------------- BODY ------------------------------ 9819C 9820 IF (IRC .LT. 0) GO TO 140 9821 IF (IRC .GT. 0) GO TO 210 9822C 9823C *** FRESH START -- GET MACHINE-DEPENDENT CONSTANTS *** 9824C 9825C STORE MACHEP IN W(1) AND H0 IN W(2), WHERE MACHEP IS THE UNIT 9826C ROUNDOFF (THE SMALLEST POSITIVE NUMBER SUCH THAT 9827C 1 + MACHEP .GT. 1 AND 1 - MACHEP .LT. 1), AND H0 IS THE 9828C SQUARE-ROOT OF MACHEP. 9829C 9830 W(1) = DR7MDC(3) 9831 W(2) = DSQRT(W(1)) 9832C 9833 W(FX0) = FX 9834C 9835C *** INCREMENT I AND START COMPUTING G(I) *** 9836C 9837 110 I = IABS(IRC) + 1 9838 IF (I .GT. N) GO TO 300 9839 IRC = I 9840 AFX = DABS(W(FX0)) 9841 MACHEP = W(1) 9842 H0 = W(2) 9843 HMIN = HMIN0 * MACHEP 9844 W(XISAVE) = X(I) 9845 AXI = DABS(X(I)) 9846 AXIBAR = DMAX1(AXI, ONE/D(I)) 9847 GI = G(I) 9848 AGI = DABS(GI) 9849 ETA = DABS(ETA0) 9850 IF (AFX .GT. ZERO) ETA = DMAX1(ETA, AGI*AXI*MACHEP/AFX) 9851 ALPHAI = ALPHA(I) 9852 IF (ALPHAI .EQ. ZERO) GO TO 170 9853 IF (GI .EQ. ZERO .OR. FX .EQ. ZERO) GO TO 180 9854 AFXETA = AFX*ETA 9855 AAI = DABS(ALPHAI) 9856C 9857C *** COMPUTE H = STEWART*S FORWARD-DIFFERENCE STEP SIZE. 9858C 9859 IF (GI**2 .LE. AFXETA*AAI) GO TO 120 9860 H = TWO*DSQRT(AFXETA/AAI) 9861 H = H*(ONE - AAI*H/(THREE*AAI*H + FOUR*AGI)) 9862 GO TO 130 9863C120 H = TWO*(AFXETA*AGI/(AAI**2))**(ONE/THREE) 9864 120 H = TWO * (AFXETA*AGI)**(ONE/THREE) * AAI**(-TWO/THREE) 9865 H = H*(ONE - TWO*AGI/(THREE*AAI*H + FOUR*AGI)) 9866C 9867C *** ENSURE THAT H IS NOT INSIGNIFICANTLY SMALL *** 9868C 9869 130 H = DMAX1(H, HMIN*AXIBAR) 9870C 9871C *** USE FORWARD DIFFERENCE IF BOUND ON TRUNCATION ERROR IS AT 9872C *** MOST 10**-3. 9873C 9874 IF (AAI*H .LE. P002*AGI) GO TO 160 9875C 9876C *** COMPUTE H = STEWART*S STEP FOR CENTRAL DIFFERENCE. 9877C 9878 DISCON = C2000*AFXETA 9879 H = DISCON/(AGI + DSQRT(GI**2 + AAI*DISCON)) 9880C 9881C *** ENSURE THAT H IS NEITHER TOO SMALL NOR TOO BIG *** 9882C 9883 H = DMAX1(H, HMIN*AXIBAR) 9884 IF (H .GE. HMAX0*AXIBAR) H = AXIBAR * H0**(TWO/THREE) 9885C 9886C *** COMPUTE CENTRAL DIFFERENCE *** 9887C 9888 IRC = -I 9889 GO TO 200 9890C 9891 140 H = -W(HSAVE) 9892 I = IABS(IRC) 9893 IF (H .GT. ZERO) GO TO 150 9894 W(FH) = FX 9895 GO TO 200 9896C 9897 150 G(I) = (W(FH) - FX) / (TWO * H) 9898 X(I) = W(XISAVE) 9899 GO TO 110 9900C 9901C *** COMPUTE FORWARD DIFFERENCES IN VARIOUS CASES *** 9902C 9903 160 IF (H .GE. HMAX0*AXIBAR) H = H0 * AXIBAR 9904 IF (ALPHAI*GI .LT. ZERO) H = -H 9905 GO TO 200 9906 170 H = AXIBAR 9907 GO TO 200 9908 180 H = H0 * AXIBAR 9909C 9910 200 X(I) = W(XISAVE) + H 9911 W(HSAVE) = H 9912 GO TO 999 9913C 9914C *** COMPUTE ACTUAL FORWARD DIFFERENCE *** 9915C 9916 210 G(IRC) = (FX - W(FX0)) / W(HSAVE) 9917 X(IRC) = W(XISAVE) 9918 GO TO 110 9919C 9920C *** RESTORE FX AND INDICATE THAT G HAS BEEN COMPUTED *** 9921C 9922 300 FX = W(FX0) 9923 IRC = 0 9924C 9925 999 RETURN 9926C *** LAST CARD OF DS7GRD FOLLOWS *** 9927 END 9928 SUBROUTINE DG7QTS(D, DIG, DIHDI, KA, L, P, STEP, V, W) 9929C 9930C *** COMPUTE GOLDFELD-QUANDT-TROTTER STEP BY MORE-HEBDEN TECHNIQUE *** 9931C *** (NL2SOL VERSION 2.2), MODIFIED A LA MORE AND SORENSEN *** 9932C 9933C *** PARAMETER DECLARATIONS *** 9934C 9935 INTEGER KA, P 9936 DOUBLE PRECISION D(P), DIG(P), DIHDI(*), L(*), V(21), STEP(P), 9937 1 W(*) 9938C DIMENSION DIHDI(P*(P+1)/2), L(P*(P+1)/2), W(4*P+7) 9939C 9940C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 9941C 9942C *** PURPOSE *** 9943C 9944C GIVEN THE (COMPACTLY STORED) LOWER TRIANGLE OF A SCALED 9945C HESSIAN (APPROXIMATION) AND A NONZERO SCALED GRADIENT VECTOR, 9946C THIS SUBROUTINE COMPUTES A GOLDFELD-QUANDT-TROTTER STEP OF 9947C APPROXIMATE LENGTH V(RADIUS) BY THE MORE-HEBDEN TECHNIQUE. IN 9948C OTHER WORDS, STEP IS COMPUTED TO (APPROXIMATELY) MINIMIZE 9949C PSI(STEP) = (G**T)*STEP + 0.5*(STEP**T)*H*STEP SUCH THAT THE 9950C 2-NORM OF D*STEP IS AT MOST (APPROXIMATELY) V(RADIUS), WHERE 9951C G IS THE GRADIENT, H IS THE HESSIAN, AND D IS A DIAGONAL 9952C SCALE MATRIX WHOSE DIAGONAL IS STORED IN THE PARAMETER D. 9953C (DG7QTS ASSUMES DIG = D**-1 * G AND DIHDI = D**-1 * H * D**-1.) 9954C 9955C *** PARAMETER DESCRIPTION *** 9956C 9957C D (IN) = THE SCALE VECTOR, I.E. THE DIAGONAL OF THE SCALE 9958C MATRIX D MENTIONED ABOVE UNDER PURPOSE. 9959C DIG (IN) = THE SCALED GRADIENT VECTOR, D**-1 * G. IF G = 0, THEN 9960C STEP = 0 AND V(STPPAR) = 0 ARE RETURNED. 9961C DIHDI (IN) = LOWER TRIANGLE OF THE SCALED HESSIAN (APPROXIMATION), 9962C I.E., D**-1 * H * D**-1, STORED COMPACTLY BY ROWS., I.E., 9963C IN THE ORDER (1,1), (2,1), (2,2), (3,1), (3,2), ETC. 9964C KA (I/O) = THE NUMBER OF HEBDEN ITERATIONS (SO FAR) TAKEN TO DETER- 9965C MINE STEP. KA .LT. 0 ON INPUT MEANS THIS IS THE FIRST 9966C ATTEMPT TO DETERMINE STEP (FOR THE PRESENT DIG AND DIHDI) 9967C -- KA IS INITIALIZED TO 0 IN THIS CASE. OUTPUT WITH 9968C KA = 0 (OR V(STPPAR) = 0) MEANS STEP = -(H**-1)*G. 9969C L (I/O) = WORKSPACE OF LENGTH P*(P+1)/2 FOR CHOLESKY FACTORS. 9970C P (IN) = NUMBER OF PARAMETERS -- THE HESSIAN IS A P X P MATRIX. 9971C STEP (I/O) = THE STEP COMPUTED. 9972C V (I/O) CONTAINS VARIOUS CONSTANTS AND VARIABLES DESCRIBED BELOW. 9973C W (I/O) = WORKSPACE OF LENGTH 4*P + 6. 9974C 9975C *** ENTRIES IN V *** 9976C 9977C V(DGNORM) (I/O) = 2-NORM OF (D**-1)*G. 9978C V(DSTNRM) (OUTPUT) = 2-NORM OF D*STEP. 9979C V(DST0) (I/O) = 2-NORM OF D*(H**-1)*G (FOR POS. DEF. H ONLY), OR 9980C OVERESTIMATE OF SMALLEST EIGENVALUE OF (D**-1)*H*(D**-1). 9981C V(EPSLON) (IN) = MAX. REL. ERROR ALLOWED FOR PSI(STEP). FOR THE 9982C STEP RETURNED, PSI(STEP) WILL EXCEED ITS OPTIMAL VALUE 9983C BY LESS THAN -V(EPSLON)*PSI(STEP). SUGGESTED VALUE = 0.1. 9984C V(GTSTEP) (OUT) = INNER PRODUCT BETWEEN G AND STEP. 9985C V(NREDUC) (OUT) = PSI(-(H**-1)*G) = PSI(NEWTON STEP) (FOR POS. DEF. 9986C H ONLY -- V(NREDUC) IS SET TO ZERO OTHERWISE). 9987C V(PHMNFC) (IN) = TOL. (TOGETHER WITH V(PHMXFC)) FOR ACCEPTING STEP 9988C (MORE*S SIGMA). THE ERROR V(DSTNRM) - V(RADIUS) MUST LIE 9989C BETWEEN V(PHMNFC)*V(RADIUS) AND V(PHMXFC)*V(RADIUS). 9990C V(PHMXFC) (IN) (SEE V(PHMNFC).) 9991C SUGGESTED VALUES -- V(PHMNFC) = -0.25, V(PHMXFC) = 0.5. 9992C V(PREDUC) (OUT) = PSI(STEP) = PREDICTED OBJ. FUNC. REDUCTION FOR STEP. 9993C V(RADIUS) (IN) = RADIUS OF CURRENT (SCALED) TRUST REGION. 9994C V(RAD0) (I/O) = VALUE OF V(RADIUS) FROM PREVIOUS CALL. 9995C V(STPPAR) (I/O) IS NORMALLY THE MARQUARDT PARAMETER, I.E. THE ALPHA 9996C DESCRIBED BELOW UNDER ALGORITHM NOTES. IF H + ALPHA*D**2 9997C (SEE ALGORITHM NOTES) IS (NEARLY) SINGULAR, HOWEVER, 9998C THEN V(STPPAR) = -ALPHA. 9999C 10000C *** USAGE NOTES *** 10001C 10002C IF IT IS DESIRED TO RECOMPUTE STEP USING A DIFFERENT VALUE OF 10003C V(RADIUS), THEN THIS ROUTINE MAY BE RESTARTED BY CALLING IT 10004C WITH ALL PARAMETERS UNCHANGED EXCEPT V(RADIUS). (THIS EXPLAINS 10005C WHY STEP AND W ARE LISTED AS I/O). ON AN INITIAL CALL (ONE WITH 10006C KA .LT. 0), STEP AND W NEED NOT BE INITIALIZED AND ONLY COMPO- 10007C NENTS V(EPSLON), V(STPPAR), V(PHMNFC), V(PHMXFC), V(RADIUS), AND 10008C V(RAD0) OF V MUST BE INITIALIZED. 10009C 10010C *** ALGORITHM NOTES *** 10011C 10012C THE DESIRED G-Q-T STEP (REF. 2, 3, 4, 6) SATISFIES 10013C (H + ALPHA*D**2)*STEP = -G FOR SOME NONNEGATIVE ALPHA SUCH THAT 10014C H + ALPHA*D**2 IS POSITIVE SEMIDEFINITE. ALPHA AND STEP ARE 10015C COMPUTED BY A SCHEME ANALOGOUS TO THE ONE DESCRIBED IN REF. 5. 10016C ESTIMATES OF THE SMALLEST AND LARGEST EIGENVALUES OF THE HESSIAN 10017C ARE OBTAINED FROM THE GERSCHGORIN CIRCLE THEOREM ENHANCED BY A 10018C SIMPLE FORM OF THE SCALING DESCRIBED IN REF. 7. CASES IN WHICH 10019C H + ALPHA*D**2 IS NEARLY (OR EXACTLY) SINGULAR ARE HANDLED BY 10020C THE TECHNIQUE DISCUSSED IN REF. 2. IN THESE CASES, A STEP OF 10021C (EXACT) LENGTH V(RADIUS) IS RETURNED FOR WHICH PSI(STEP) EXCEEDS 10022C ITS OPTIMAL VALUE BY LESS THAN -V(EPSLON)*PSI(STEP). THE TEST 10023C SUGGESTED IN REF. 6 FOR DETECTING THE SPECIAL CASE IS PERFORMED 10024C ONCE TWO MATRIX FACTORIZATIONS HAVE BEEN DONE -- DOING SO SOONER 10025C SEEMS TO DEGRADE THE PERFORMANCE OF OPTIMIZATION ROUTINES THAT 10026C CALL THIS ROUTINE. 10027C 10028C *** FUNCTIONS AND SUBROUTINES CALLED *** 10029C 10030C DD7TPR - RETURNS INNER PRODUCT OF TWO VECTORS. 10031C DL7ITV - APPLIES INVERSE-TRANSPOSE OF COMPACT LOWER TRIANG. MATRIX. 10032C DL7IVM - APPLIES INVERSE OF COMPACT LOWER TRIANG. MATRIX. 10033C DL7SRT - FINDS CHOLESKY FACTOR (OF COMPACTLY STORED LOWER TRIANG.). 10034C DL7SVN - RETURNS APPROX. TO MIN. SING. VALUE OF LOWER TRIANG. MATRIX. 10035C DR7MDC - RETURNS MACHINE-DEPENDENT CONSTANTS. 10036C DV2NRM - RETURNS 2-NORM OF A VECTOR. 10037C 10038C *** REFERENCES *** 10039C 10040C 1. DENNIS, J.E., GAY, D.M., AND WELSCH, R.E. (1981), AN ADAPTIVE 10041C NONLINEAR LEAST-SQUARES ALGORITHM, ACM TRANS. MATH. 10042C SOFTWARE, VOL. 7, NO. 3. 10043C 2. GAY, D.M. (1981), COMPUTING OPTIMAL LOCALLY CONSTRAINED STEPS, 10044C SIAM J. SCI. STATIST. COMPUTING, VOL. 2, NO. 2, PP. 10045C 186-197. 10046C 3. GOLDFELD, S.M., QUANDT, R.E., AND TROTTER, H.F. (1966), 10047C MAXIMIZATION BY QUADRATIC HILL-CLIMBING, ECONOMETRICA 34, 10048C PP. 541-551. 10049C 4. HEBDEN, M.D. (1973), AN ALGORITHM FOR MINIMIZATION USING EXACT 10050C SECOND DERIVATIVES, REPORT T.P. 515, THEORETICAL PHYSICS 10051C DIV., A.E.R.E. HARWELL, OXON., ENGLAND. 10052C 5. MORE, J.J. (1978), THE LEVENBERG-MARQUARDT ALGORITHM, IMPLEMEN- 10053C TATION AND THEORY, PP.105-116 OF SPRINGER LECTURE NOTES 10054C IN MATHEMATICS NO. 630, EDITED BY G.A. WATSON, SPRINGER- 10055C VERLAG, BERLIN AND NEW YORK. 10056C 6. MORE, J.J., AND SORENSEN, D.C. (1981), COMPUTING A TRUST REGION 10057C STEP, TECHNICAL REPORT ANL-81-83, ARGONNE NATIONAL LAB. 10058C 7. VARGA, R.S. (1965), MINIMAL GERSCHGORIN SETS, PACIFIC J. MATH. 15, 10059C PP. 719-729. 10060C 10061C *** GENERAL *** 10062C 10063C CODED BY DAVID M. GAY. 10064C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH 10065C SUPPORTED BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS 10066C MCS-7600324, DCR75-10143, 76-14311DSS, MCS76-11989, AND 10067C MCS-7906671. 10068C 10069C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 10070C 10071C *** LOCAL VARIABLES *** 10072C 10073 LOGICAL RESTRT 10074 INTEGER DGGDMX, DIAG, DIAG0, DSTSAV, EMAX, EMIN, I, IM1, INC, IRC, 10075 1 J, K, KALIM, KAMIN, K1, LK0, PHIPIN, Q, Q0, UK0, X 10076 DOUBLE PRECISION ALPHAK, AKI, AKK, DELTA, DST, EPS, GTSTA, LK, 10077 1 OLDPHI, PHI, PHIMAX, PHIMIN, PSIFAC, RAD, RADSQ, 10078 2 ROOT, SI, SK, SW, T, TWOPSI, T1, T2, UK, WI 10079C 10080C *** CONSTANTS *** 10081 DOUBLE PRECISION BIG, DGXFAC, EPSFAC, FOUR, HALF, KAPPA, NEGONE, 10082 1 ONE, P001, SIX, THREE, TWO, ZERO 10083C 10084C *** INTRINSIC FUNCTIONS *** 10085C/+ 10086 DOUBLE PRECISION DSQRT 10087C/ 10088C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 10089C 10090 DOUBLE PRECISION DD7TPR, DL7SVN, DR7MDC, DV2NRM 10091 EXTERNAL DD7TPR, DL7ITV, DL7IVM,DL7SRT, DL7SVN, DR7MDC, DV2NRM 10092C 10093C *** SUBSCRIPTS FOR V *** 10094C 10095 INTEGER DGNORM, DSTNRM, DST0, EPSLON, GTSTEP, STPPAR, NREDUC, 10096 1 PHMNFC, PHMXFC, PREDUC, RADIUS, RAD0 10097 PARAMETER (DGNORM=1, DSTNRM=2, DST0=3, EPSLON=19, GTSTEP=4, 10098 1 NREDUC=6, PHMNFC=20, PHMXFC=21, PREDUC=7, RADIUS=8, 10099 2 RAD0=9, STPPAR=5) 10100C 10101 PARAMETER (EPSFAC=50.0D+0, FOUR=4.0D+0, HALF=0.5D+0, 10102 1 KAPPA=2.0D+0, NEGONE=-1.0D+0, ONE=1.0D+0, P001=1.0D-3, 10103 2 SIX=6.0D+0, THREE=3.0D+0, TWO=2.0D+0, ZERO=0.0D+0) 10104 SAVE DGXFAC 10105 DATA BIG/0.D+0/, DGXFAC/0.D+0/ 10106C 10107C *** BODY *** 10108C 10109 IF (BIG .LE. ZERO) BIG = DR7MDC(6) 10110C 10111C *** STORE LARGEST ABS. ENTRY IN (D**-1)*H*(D**-1) AT W(DGGDMX). 10112 DGGDMX = P + 1 10113C *** STORE GERSCHGORIN OVER- AND UNDERESTIMATES OF THE LARGEST 10114C *** AND SMALLEST EIGENVALUES OF (D**-1)*H*(D**-1) AT W(EMAX) 10115C *** AND W(EMIN) RESPECTIVELY. 10116 EMAX = DGGDMX + 1 10117 EMIN = EMAX + 1 10118C *** FOR USE IN RECOMPUTING STEP, THE FINAL VALUES OF LK, UK, DST, 10119C *** AND THE INVERSE DERIVATIVE OF MORE*S PHI AT 0 (FOR POS. DEF. 10120C *** H) ARE STORED IN W(LK0), W(UK0), W(DSTSAV), AND W(PHIPIN) 10121C *** RESPECTIVELY. 10122 LK0 = EMIN + 1 10123 PHIPIN = LK0 + 1 10124 UK0 = PHIPIN + 1 10125 DSTSAV = UK0 + 1 10126C *** STORE DIAG OF (D**-1)*H*(D**-1) IN W(DIAG),...,W(DIAG0+P). 10127 DIAG0 = DSTSAV 10128 DIAG = DIAG0 + 1 10129C *** STORE -D*STEP IN W(Q),...,W(Q0+P). 10130 Q0 = DIAG0 + P 10131 Q = Q0 + 1 10132C *** ALLOCATE STORAGE FOR SCRATCH VECTOR X *** 10133 X = Q + P 10134 RAD = V(RADIUS) 10135 RADSQ = RAD**2 10136C *** PHITOL = MAX. ERROR ALLOWED IN DST = V(DSTNRM) = 2-NORM OF 10137C *** D*STEP. 10138 PHIMAX = V(PHMXFC) * RAD 10139 PHIMIN = V(PHMNFC) * RAD 10140 PSIFAC = BIG 10141 T1 = TWO * V(EPSLON) / (THREE * (FOUR * (V(PHMNFC) + ONE) * 10142 1 (KAPPA + ONE) + KAPPA + TWO) * RAD) 10143 IF (T1 .LT. BIG*DMIN1(RAD,ONE)) PSIFAC = T1 / RAD 10144C *** OLDPHI IS USED TO DETECT LIMITS OF NUMERICAL ACCURACY. IF 10145C *** WE RECOMPUTE STEP AND IT DOES NOT CHANGE, THEN WE ACCEPT IT. 10146 OLDPHI = ZERO 10147 EPS = V(EPSLON) 10148 IRC = 0 10149 RESTRT = .FALSE. 10150 KALIM = KA + 50 10151C 10152C *** START OR RESTART, DEPENDING ON KA *** 10153C 10154 IF (KA .GE. 0) GO TO 290 10155C 10156C *** FRESH START *** 10157C 10158 K = 0 10159 UK = NEGONE 10160 KA = 0 10161 KALIM = 50 10162 V(DGNORM) = DV2NRM(P, DIG) 10163 V(NREDUC) = ZERO 10164 V(DST0) = ZERO 10165 KAMIN = 3 10166 IF (V(DGNORM) .EQ. ZERO) KAMIN = 0 10167C 10168C *** STORE DIAG(DIHDI) IN W(DIAG0+1),...,W(DIAG0+P) *** 10169C 10170 J = 0 10171 DO 10 I = 1, P 10172 J = J + I 10173 K1 = DIAG0 + I 10174 W(K1) = DIHDI(J) 10175 10 CONTINUE 10176C 10177C *** DETERMINE W(DGGDMX), THE LARGEST ELEMENT OF DIHDI *** 10178C 10179 T1 = ZERO 10180 J = P * (P + 1) / 2 10181 DO 20 I = 1, J 10182 T = DABS(DIHDI(I)) 10183 IF (T1 .LT. T) T1 = T 10184 20 CONTINUE 10185 W(DGGDMX) = T1 10186C 10187C *** TRY ALPHA = 0 *** 10188C 10189 30 CALL DL7SRT(1, P, L, DIHDI, IRC) 10190 IF (IRC .EQ. 0) GO TO 50 10191C *** INDEF. H -- UNDERESTIMATE SMALLEST EIGENVALUE, USE THIS 10192C *** ESTIMATE TO INITIALIZE LOWER BOUND LK ON ALPHA. 10193 J = IRC*(IRC+1)/2 10194 T = L(J) 10195 L(J) = ONE 10196 DO 40 I = 1, IRC 10197 W(I) = ZERO 10198 40 CONTINUE 10199 W(IRC) = ONE 10200 CALL DL7ITV(IRC, W, L, W) 10201 T1 = DV2NRM(IRC, W) 10202 LK = -T / T1 / T1 10203 V(DST0) = -LK 10204 IF (RESTRT) GO TO 210 10205 GO TO 70 10206C 10207C *** POSITIVE DEFINITE H -- COMPUTE UNMODIFIED NEWTON STEP. *** 10208 50 LK = ZERO 10209 T = DL7SVN(P, L, W(Q), W(Q)) 10210 IF (T .GE. ONE) GO TO 60 10211 IF (V(DGNORM) .GE. T*T*BIG) GO TO 70 10212 60 CALL DL7IVM(P, W(Q), L, DIG) 10213 GTSTA = DD7TPR(P, W(Q), W(Q)) 10214 V(NREDUC) = HALF * GTSTA 10215 CALL DL7ITV(P, W(Q), L, W(Q)) 10216 DST = DV2NRM(P, W(Q)) 10217 V(DST0) = DST 10218 PHI = DST - RAD 10219 IF (PHI .LE. PHIMAX) GO TO 260 10220 IF (RESTRT) GO TO 210 10221C 10222C *** PREPARE TO COMPUTE GERSCHGORIN ESTIMATES OF LARGEST (AND 10223C *** SMALLEST) EIGENVALUES. *** 10224C 10225 70 K = 0 10226 DO 100 I = 1, P 10227 WI = ZERO 10228 IF (I .EQ. 1) GO TO 90 10229 IM1 = I - 1 10230 DO 80 J = 1, IM1 10231 K = K + 1 10232 T = DABS(DIHDI(K)) 10233 WI = WI + T 10234 W(J) = W(J) + T 10235 80 CONTINUE 10236 90 W(I) = WI 10237 K = K + 1 10238 100 CONTINUE 10239C 10240C *** (UNDER-)ESTIMATE SMALLEST EIGENVALUE OF (D**-1)*H*(D**-1) *** 10241C 10242 K = 1 10243 T1 = W(DIAG) - W(1) 10244 IF (P .LE. 1) GO TO 120 10245 DO 110 I = 2, P 10246 J = DIAG0 + I 10247 T = W(J) - W(I) 10248 IF (T .GE. T1) GO TO 110 10249 T1 = T 10250 K = I 10251 110 CONTINUE 10252C 10253 120 SK = W(K) 10254 J = DIAG0 + K 10255 AKK = W(J) 10256 K1 = K*(K-1)/2 + 1 10257 INC = 1 10258 T = ZERO 10259 DO 150 I = 1, P 10260 IF (I .EQ. K) GO TO 130 10261 AKI = DABS(DIHDI(K1)) 10262 SI = W(I) 10263 J = DIAG0 + I 10264 T1 = HALF * (AKK - W(J) + SI - AKI) 10265 T1 = T1 + DSQRT(T1*T1 + SK*AKI) 10266 IF (T .LT. T1) T = T1 10267 IF (I .LT. K) GO TO 140 10268 130 INC = I 10269 140 K1 = K1 + INC 10270 150 CONTINUE 10271C 10272 W(EMIN) = AKK - T 10273 UK = V(DGNORM)/RAD - W(EMIN) 10274 IF (V(DGNORM) .EQ. ZERO) UK = UK + P001 + P001*UK 10275 IF (UK .LE. ZERO) UK = P001 10276C 10277C *** COMPUTE GERSCHGORIN (OVER-)ESTIMATE OF LARGEST EIGENVALUE *** 10278C 10279 K = 1 10280 T1 = W(DIAG) + W(1) 10281 IF (P .LE. 1) GO TO 170 10282 DO 160 I = 2, P 10283 J = DIAG0 + I 10284 T = W(J) + W(I) 10285 IF (T .LE. T1) GO TO 160 10286 T1 = T 10287 K = I 10288 160 CONTINUE 10289C 10290 170 SK = W(K) 10291 J = DIAG0 + K 10292 AKK = W(J) 10293 K1 = K*(K-1)/2 + 1 10294 INC = 1 10295 T = ZERO 10296 DO 200 I = 1, P 10297 IF (I .EQ. K) GO TO 180 10298 AKI = DABS(DIHDI(K1)) 10299 SI = W(I) 10300 J = DIAG0 + I 10301 T1 = HALF * (W(J) + SI - AKI - AKK) 10302 T1 = T1 + DSQRT(T1*T1 + SK*AKI) 10303 IF (T .LT. T1) T = T1 10304 IF (I .LT. K) GO TO 190 10305 180 INC = I 10306 190 K1 = K1 + INC 10307 200 CONTINUE 10308C 10309 W(EMAX) = AKK + T 10310 LK = DMAX1(LK, V(DGNORM)/RAD - W(EMAX)) 10311C 10312C *** ALPHAK = CURRENT VALUE OF ALPHA (SEE ALG. NOTES ABOVE). WE 10313C *** USE MORE*S SCHEME FOR INITIALIZING IT. 10314 ALPHAK = DABS(V(STPPAR)) * V(RAD0)/RAD 10315 ALPHAK = DMIN1(UK, DMAX1(ALPHAK, LK)) 10316C 10317 IF (IRC .NE. 0) GO TO 210 10318C 10319C *** COMPUTE L0 FOR POSITIVE DEFINITE H *** 10320C 10321 CALL DL7IVM(P, W, L, W(Q)) 10322 T = DV2NRM(P, W) 10323 W(PHIPIN) = RAD / T / T 10324 LK = DMAX1(LK, PHI*W(PHIPIN)) 10325C 10326C *** SAFEGUARD ALPHAK AND ADD ALPHAK*I TO (D**-1)*H*(D**-1) *** 10327C 10328 210 KA = KA + 1 10329 IF (-V(DST0) .GE. ALPHAK .OR. ALPHAK .LT. LK .OR. ALPHAK .GE. UK) 10330 1 ALPHAK = UK * DMAX1(P001, DSQRT(LK/UK)) 10331 IF (ALPHAK .LE. ZERO) ALPHAK = HALF * UK 10332 IF (ALPHAK .LE. ZERO) ALPHAK = UK 10333 K = 0 10334 DO 220 I = 1, P 10335 K = K + I 10336 J = DIAG0 + I 10337 DIHDI(K) = W(J) + ALPHAK 10338 220 CONTINUE 10339C 10340C *** TRY COMPUTING CHOLESKY DECOMPOSITION *** 10341C 10342 CALL DL7SRT(1, P, L, DIHDI, IRC) 10343 IF (IRC .EQ. 0) GO TO 240 10344C 10345C *** (D**-1)*H*(D**-1) + ALPHAK*I IS INDEFINITE -- OVERESTIMATE 10346C *** SMALLEST EIGENVALUE FOR USE IN UPDATING LK *** 10347C 10348 J = (IRC*(IRC+1))/2 10349 T = L(J) 10350 L(J) = ONE 10351 DO 230 I = 1, IRC 10352 W(I) = ZERO 10353 230 CONTINUE 10354 W(IRC) = ONE 10355 CALL DL7ITV(IRC, W, L, W) 10356 T1 = DV2NRM(IRC, W) 10357 LK = ALPHAK - T/T1/T1 10358 V(DST0) = -LK 10359 IF (UK .LT. LK) UK = LK 10360 IF (ALPHAK .LT. LK) GO TO 210 10361C 10362C *** NASTY CASE -- EXACT GERSCHGORIN BOUNDS. FUDGE LK, UK... 10363C 10364 T = P001 * ALPHAK 10365 IF (T .LE. ZERO) T = P001 10366 LK = ALPHAK + T 10367 IF (UK .LE. LK) UK = LK + T 10368 GO TO 210 10369C 10370C *** ALPHAK MAKES (D**-1)*H*(D**-1) POSITIVE DEFINITE. 10371C *** COMPUTE Q = -D*STEP, CHECK FOR CONVERGENCE. *** 10372C 10373 240 CALL DL7IVM(P, W(Q), L, DIG) 10374 GTSTA = DD7TPR(P, W(Q), W(Q)) 10375 CALL DL7ITV(P, W(Q), L, W(Q)) 10376 DST = DV2NRM(P, W(Q)) 10377 PHI = DST - RAD 10378 IF (PHI .LE. PHIMAX .AND. PHI .GE. PHIMIN) GO TO 270 10379 IF (PHI .EQ. OLDPHI) GO TO 270 10380 OLDPHI = PHI 10381 IF (PHI .LT. ZERO) GO TO 330 10382C 10383C *** UNACCEPTABLE ALPHAK -- UPDATE LK, UK, ALPHAK *** 10384C 10385 250 IF (KA .GE. KALIM) GO TO 270 10386C *** THE FOLLOWING DMIN1 IS NECESSARY BECAUSE OF RESTARTS *** 10387 IF (PHI .LT. ZERO) UK = DMIN1(UK, ALPHAK) 10388C *** KAMIN = 0 ONLY IFF THE GRADIENT VANISHES *** 10389 IF (KAMIN .EQ. 0) GO TO 210 10390 CALL DL7IVM(P, W, L, W(Q)) 10391C *** THE FOLLOWING, COMMENTED CALCULATION OF ALPHAK IS SOMETIMES 10392C *** SAFER BUT WORSE IN PERFORMANCE... 10393C T1 = DST / DV2NRM(P, W) 10394C ALPHAK = ALPHAK + T1 * (PHI/RAD) * T1 10395 T1 = DV2NRM(P, W) 10396 ALPHAK = ALPHAK + (PHI/T1) * (DST/T1) * (DST/RAD) 10397 LK = DMAX1(LK, ALPHAK) 10398 ALPHAK = LK 10399 GO TO 210 10400C 10401C *** ACCEPTABLE STEP ON FIRST TRY *** 10402C 10403 260 ALPHAK = ZERO 10404C 10405C *** SUCCESSFUL STEP IN GENERAL. COMPUTE STEP = -(D**-1)*Q *** 10406C 10407 270 DO 280 I = 1, P 10408 J = Q0 + I 10409 STEP(I) = -W(J)/D(I) 10410 280 CONTINUE 10411 V(GTSTEP) = -GTSTA 10412 V(PREDUC) = HALF * (DABS(ALPHAK)*DST*DST + GTSTA) 10413 GO TO 410 10414C 10415C 10416C *** RESTART WITH NEW RADIUS *** 10417C 10418 290 IF (V(DST0) .LE. ZERO .OR. V(DST0) - RAD .GT. PHIMAX) GO TO 310 10419C 10420C *** PREPARE TO RETURN NEWTON STEP *** 10421C 10422 RESTRT = .TRUE. 10423 KA = KA + 1 10424 K = 0 10425 DO 300 I = 1, P 10426 K = K + I 10427 J = DIAG0 + I 10428 DIHDI(K) = W(J) 10429 300 CONTINUE 10430 UK = NEGONE 10431 GO TO 30 10432C 10433 310 KAMIN = KA + 3 10434 IF (V(DGNORM) .EQ. ZERO) KAMIN = 0 10435 IF (KA .EQ. 0) GO TO 50 10436C 10437 DST = W(DSTSAV) 10438 ALPHAK = DABS(V(STPPAR)) 10439 PHI = DST - RAD 10440 T = V(DGNORM)/RAD 10441 UK = T - W(EMIN) 10442 IF (V(DGNORM) .EQ. ZERO) UK = UK + P001 + P001*UK 10443 IF (UK .LE. ZERO) UK = P001 10444 IF (RAD .GT. V(RAD0)) GO TO 320 10445C 10446C *** SMALLER RADIUS *** 10447 LK = ZERO 10448 IF (ALPHAK .GT. ZERO) LK = W(LK0) 10449 LK = DMAX1(LK, T - W(EMAX)) 10450 IF (V(DST0) .GT. ZERO) LK = DMAX1(LK, (V(DST0)-RAD)*W(PHIPIN)) 10451 GO TO 250 10452C 10453C *** BIGGER RADIUS *** 10454 320 IF (ALPHAK .GT. ZERO) UK = DMIN1(UK, W(UK0)) 10455 LK = DMAX1(ZERO, -V(DST0), T - W(EMAX)) 10456 IF (V(DST0) .GT. ZERO) LK = DMAX1(LK, (V(DST0)-RAD)*W(PHIPIN)) 10457 GO TO 250 10458C 10459C *** DECIDE WHETHER TO CHECK FOR SPECIAL CASE... IN PRACTICE (FROM 10460C *** THE STANDPOINT OF THE CALLING OPTIMIZATION CODE) IT SEEMS BEST 10461C *** NOT TO CHECK UNTIL A FEW ITERATIONS HAVE FAILED -- HENCE THE 10462C *** TEST ON KAMIN BELOW. 10463C 10464 330 DELTA = ALPHAK + DMIN1(ZERO, V(DST0)) 10465 TWOPSI = ALPHAK*DST*DST + GTSTA 10466 IF (KA .GE. KAMIN) GO TO 340 10467C *** IF THE TEST IN REF. 2 IS SATISFIED, FALL THROUGH TO HANDLE 10468C *** THE SPECIAL CASE (AS SOON AS THE MORE-SORENSEN TEST DETECTS 10469C *** IT). 10470 IF (PSIFAC .GE. BIG) GO TO 340 10471 IF (DELTA .GE. PSIFAC*TWOPSI) GO TO 370 10472C 10473C *** CHECK FOR THE SPECIAL CASE OF H + ALPHA*D**2 (NEARLY) 10474C *** SINGULAR. USE ONE STEP OF INVERSE POWER METHOD WITH START 10475C *** FROM DL7SVN TO OBTAIN APPROXIMATE EIGENVECTOR CORRESPONDING 10476C *** TO SMALLEST EIGENVALUE OF (D**-1)*H*(D**-1). DL7SVN RETURNS 10477C *** X AND W WITH L*W = X. 10478C 10479 340 T = DL7SVN(P, L, W(X), W) 10480C 10481C *** NORMALIZE W *** 10482 DO 350 I = 1, P 10483 W(I) = T*W(I) 10484 350 CONTINUE 10485C *** COMPLETE CURRENT INV. POWER ITER. -- REPLACE W BY (L**-T)*W. 10486 CALL DL7ITV(P, W, L, W) 10487 T2 = ONE/DV2NRM(P, W) 10488 DO 360 I = 1, P 10489 W(I) = T2*W(I) 10490 360 CONTINUE 10491 T = T2 * T 10492C 10493C *** NOW W IS THE DESIRED APPROXIMATE (UNIT) EIGENVECTOR AND 10494C *** T*X = ((D**-1)*H*(D**-1) + ALPHAK*I)*W. 10495C 10496 SW = DD7TPR(P, W(Q), W) 10497 T1 = (RAD + DST) * (RAD - DST) 10498 ROOT = DSQRT(SW*SW + T1) 10499 IF (SW .LT. ZERO) ROOT = -ROOT 10500 SI = T1 / (SW + ROOT) 10501C 10502C *** THE ACTUAL TEST FOR THE SPECIAL CASE... 10503C 10504 IF ((T2*SI)**2 .LE. EPS*(DST**2 + ALPHAK*RADSQ)) GO TO 380 10505C 10506C *** UPDATE UPPER BOUND ON SMALLEST EIGENVALUE (WHEN NOT POSITIVE) 10507C *** (AS RECOMMENDED BY MORE AND SORENSEN) AND CONTINUE... 10508C 10509 IF (V(DST0) .LE. ZERO) V(DST0) = DMIN1(V(DST0), T2**2 - ALPHAK) 10510 LK = DMAX1(LK, -V(DST0)) 10511C 10512C *** CHECK WHETHER WE CAN HOPE TO DETECT THE SPECIAL CASE IN 10513C *** THE AVAILABLE ARITHMETIC. ACCEPT STEP AS IT IS IF NOT. 10514C 10515C *** IF NOT YET AVAILABLE, OBTAIN MACHINE DEPENDENT VALUE DGXFAC. 10516 370 IF (DGXFAC .EQ. ZERO) DGXFAC = EPSFAC * DR7MDC(3) 10517C 10518 IF (DELTA .GT. DGXFAC*W(DGGDMX)) GO TO 250 10519 GO TO 270 10520C 10521C *** SPECIAL CASE DETECTED... NEGATE ALPHAK TO INDICATE SPECIAL CASE 10522C 10523 380 ALPHAK = -ALPHAK 10524 V(PREDUC) = HALF * TWOPSI 10525C 10526C *** ACCEPT CURRENT STEP IF ADDING SI*W WOULD LEAD TO A 10527C *** FURTHER RELATIVE REDUCTION IN PSI OF LESS THAN V(EPSLON)/3. 10528C 10529 T1 = ZERO 10530 T = SI*(ALPHAK*SW - HALF*SI*(ALPHAK + T*DD7TPR(P,W(X),W))) 10531 IF (T .LT. EPS*TWOPSI/SIX) GO TO 390 10532 V(PREDUC) = V(PREDUC) + T 10533 DST = RAD 10534 T1 = -SI 10535 390 DO 400 I = 1, P 10536 J = Q0 + I 10537 W(J) = T1*W(I) - W(J) 10538 STEP(I) = W(J) / D(I) 10539 400 CONTINUE 10540 V(GTSTEP) = DD7TPR(P, DIG, W(Q)) 10541C 10542C *** SAVE VALUES FOR USE IN A POSSIBLE RESTART *** 10543C 10544 410 V(DSTNRM) = DST 10545 V(STPPAR) = ALPHAK 10546 W(LK0) = LK 10547 W(UK0) = UK 10548 V(RAD0) = RAD 10549 W(DSTSAV) = DST 10550C 10551C *** RESTORE DIAGONAL OF DIHDI *** 10552C 10553 J = 0 10554 DO 420 I = 1, P 10555 J = J + I 10556 K = DIAG0 + I 10557 DIHDI(J) = W(K) 10558 420 CONTINUE 10559C 10560 RETURN 10561C 10562C *** LAST CARD OF DG7QTS FOLLOWS *** 10563 END 10564 SUBROUTINE DW7ZBF (L, N, S, W, Y, Z) 10565C 10566C *** COMPUTE Y AND Z FOR DL7UPD CORRESPONDING TO BFGS UPDATE. 10567C 10568 INTEGER N 10569 DOUBLE PRECISION L(*), S(N), W(N), Y(N), Z(N) 10570C DIMENSION L(N*(N+1)/2) 10571C 10572C-------------------------- PARAMETER USAGE -------------------------- 10573C 10574C L (I/O) CHOLESKY FACTOR OF HESSIAN, A LOWER TRIANG. MATRIX STORED 10575C COMPACTLY BY ROWS. 10576C N (INPUT) ORDER OF L AND LENGTH OF S, W, Y, Z. 10577C S (INPUT) THE STEP JUST TAKEN. 10578C W (OUTPUT) RIGHT SINGULAR VECTOR OF RANK 1 CORRECTION TO L. 10579C Y (INPUT) CHANGE IN GRADIENTS CORRESPONDING TO S. 10580C Z (OUTPUT) LEFT SINGULAR VECTOR OF RANK 1 CORRECTION TO L. 10581C 10582C------------------------------- NOTES ------------------------------- 10583C 10584C *** ALGORITHM NOTES *** 10585C 10586C WHEN S IS COMPUTED IN CERTAIN WAYS, E.G. BY GQTSTP OR 10587C DBLDOG, IT IS POSSIBLE TO SAVE N**2/2 OPERATIONS SINCE (L**T)*S 10588C OR L*(L**T)*S IS THEN KNOWN. 10589C IF THE BFGS UPDATE TO L*(L**T) WOULD REDUCE ITS DETERMINANT TO 10590C LESS THAN EPS TIMES ITS OLD VALUE, THEN THIS ROUTINE IN EFFECT 10591C REPLACES Y BY THETA*Y + (1 - THETA)*L*(L**T)*S, WHERE THETA 10592C (BETWEEN 0 AND 1) IS CHOSEN TO MAKE THE REDUCTION FACTOR = EPS. 10593C 10594C *** GENERAL *** 10595C 10596C CODED BY DAVID M. GAY (FALL 1979). 10597C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH SUPPORTED 10598C BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS MCS-7600324 AND 10599C MCS-7906671. 10600C 10601C------------------------ EXTERNAL QUANTITIES ------------------------ 10602C 10603C *** FUNCTIONS AND SUBROUTINES CALLED *** 10604C 10605 DOUBLE PRECISION DD7TPR 10606 EXTERNAL DD7TPR, DL7IVM, DL7TVM 10607C DD7TPR RETURNS INNER PRODUCT OF TWO VECTORS. 10608C DL7IVM MULTIPLIES L**-1 TIMES A VECTOR. 10609C DL7TVM MULTIPLIES L**T TIMES A VECTOR. 10610C 10611C *** INTRINSIC FUNCTIONS *** 10612C/+ 10613 DOUBLE PRECISION DSQRT 10614C/ 10615C-------------------------- LOCAL VARIABLES -------------------------- 10616C 10617 INTEGER I 10618 DOUBLE PRECISION CS, CY, EPS, EPSRT, ONE, SHS, YS, THETA 10619C 10620C *** DATA INITIALIZATIONS *** 10621C 10622 PARAMETER (EPS=0.1D+0, ONE=1.D+0) 10623C 10624C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 10625C 10626 CALL DL7TVM(N, W, L, S) 10627 SHS = DD7TPR(N, W, W) 10628 YS = DD7TPR(N, Y, S) 10629 IF (YS .GE. EPS*SHS) GO TO 10 10630 THETA = (ONE - EPS) * SHS / (SHS - YS) 10631 EPSRT = DSQRT(EPS) 10632 CY = THETA / (SHS * EPSRT) 10633 CS = (ONE + (THETA-ONE)/EPSRT) / SHS 10634 GO TO 20 10635 10 CY = ONE / (DSQRT(YS) * DSQRT(SHS)) 10636 CS = ONE / SHS 10637 20 CALL DL7IVM(N, Z, L, Y) 10638 DO 30 I = 1, N 10639 Z(I) = CY * Z(I) - CS * W(I) 10640 30 CONTINUE 10641C 10642 RETURN 10643C *** LAST CARD OF DW7ZBF FOLLOWS *** 10644 END 10645 SUBROUTINE DC7VFN(IV, L, LH, LIV, LV, N, P, V) 10646C 10647C *** FINISH COVARIANCE COMPUTATION FOR DRN2G, DRNSG *** 10648C 10649 INTEGER LH, LIV, LV, N, P 10650 INTEGER IV(LIV) 10651 DOUBLE PRECISION L(LH), V(LV) 10652C 10653 EXTERNAL DL7NVR, DL7TSQ, DV7SCL 10654C 10655C *** LOCAL VARIABLES *** 10656C 10657 INTEGER COV, I 10658 DOUBLE PRECISION HALF 10659C 10660C *** SUBSCRIPTS FOR IV AND V *** 10661C 10662 INTEGER CNVCOD, COVMAT, F, FDH, H, MODE, RDREQ, REGD 10663C 10664 PARAMETER (CNVCOD=55, COVMAT=26, F=10, FDH=74, H=56, MODE=35, 10665 1 RDREQ=57, REGD=67) 10666 DATA HALF/0.5D+0/ 10667C 10668C *** BODY *** 10669C 10670 IV(1) = IV(CNVCOD) 10671 I = IV(MODE) - P 10672 IV(MODE) = 0 10673 IV(CNVCOD) = 0 10674 IF (IV(FDH) .LE. 0) GO TO 999 10675 IF ((I-2)**2 .EQ. 1) IV(REGD) = 1 10676 IF (MOD(IV(RDREQ),2) .NE. 1) GO TO 999 10677C 10678C *** FINISH COMPUTING COVARIANCE MATRIX = INVERSE OF F.D. HESSIAN. 10679C 10680 COV = IABS(IV(H)) 10681 IV(FDH) = 0 10682C 10683 IF (IV(COVMAT) .NE. 0) GO TO 999 10684 IF (I .GE. 2) GO TO 10 10685 CALL DL7NVR(P, V(COV), L) 10686 CALL DL7TSQ(P, V(COV), V(COV)) 10687C 10688 10 CALL DV7SCL(LH, V(COV), V(F)/(HALF * DBLE(MAX0(1,N-P))), V(COV)) 10689 IV(COVMAT) = COV 10690C 10691 999 RETURN 10692C *** LAST LINE OF DC7VFN FOLLOWS *** 10693 END 10694 SUBROUTINE DD7MLP(N, X, Y, Z, K) 10695C 10696C *** SET X = DIAG(Y)**K * Z 10697C *** FOR X, Z = LOWER TRIANG. MATRICES STORED COMPACTLY BY ROW 10698C *** K = 1 OR -1. 10699C 10700 INTEGER N, K 10701 DOUBLE PRECISION X(*), Y(N), Z(*) 10702 INTEGER I, J, L 10703 DOUBLE PRECISION ONE, T 10704 DATA ONE/1.D+0/ 10705C 10706 L = 1 10707 IF (K .GE. 0) GO TO 30 10708 DO 20 I = 1, N 10709 T = ONE / Y(I) 10710 DO 10 J = 1, I 10711 X(L) = T * Z(L) 10712 L = L + 1 10713 10 CONTINUE 10714 20 CONTINUE 10715 GO TO 999 10716C 10717 30 DO 50 I = 1, N 10718 T = Y(I) 10719 DO 40 J = 1, I 10720 X(L) = T * Z(L) 10721 L = L + 1 10722 40 CONTINUE 10723 50 CONTINUE 10724 999 RETURN 10725C *** LAST CARD OF DD7MLP FOLLOWS *** 10726 END 10727 SUBROUTINE DL7IVM(N, X, L, Y) 10728C 10729C *** SOLVE L*X = Y, WHERE L IS AN N X N LOWER TRIANGULAR 10730C *** MATRIX STORED COMPACTLY BY ROWS. X AND Y MAY OCCUPY THE SAME 10731C *** STORAGE. *** 10732C 10733 INTEGER N 10734 DOUBLE PRECISION X(N), L(*), Y(N) 10735 DOUBLE PRECISION DD7TPR 10736 EXTERNAL DD7TPR 10737 INTEGER I, J, K 10738 DOUBLE PRECISION T, ZERO 10739 PARAMETER (ZERO=0.D+0) 10740C 10741 DO 10 K = 1, N 10742 IF (Y(K) .NE. ZERO) GO TO 20 10743 X(K) = ZERO 10744 10 CONTINUE 10745 GO TO 999 10746 20 J = K*(K+1)/2 10747 X(K) = Y(K) / L(J) 10748 IF (K .GE. N) GO TO 999 10749 K = K + 1 10750 DO 30 I = K, N 10751 T = DD7TPR(I-1, L(J+1), X) 10752 J = J + I 10753 X(I) = (Y(I) - T)/L(J) 10754 30 CONTINUE 10755 999 RETURN 10756C *** LAST CARD OF DL7IVM FOLLOWS *** 10757 END 10758 SUBROUTINE DD7UPD(D, DR, IV, LIV, LV, N, ND, NN, N2, P, V) 10759C 10760C *** UPDATE SCALE VECTOR D FOR NL2IT *** 10761C 10762C *** PARAMETER DECLARATIONS *** 10763C 10764 INTEGER LIV, LV, N, ND, NN, N2, P 10765 INTEGER IV(LIV) 10766 DOUBLE PRECISION D(P), DR(ND,P), V(LV) 10767C DIMENSION V(*) 10768C 10769C *** LOCAL VARIABLES *** 10770C 10771 INTEGER D0, I, JCN0, JCN1, JCNI, JTOL0, JTOLI, K, SII 10772 DOUBLE PRECISION T, VDFAC 10773C 10774C *** CONSTANTS *** 10775C 10776 DOUBLE PRECISION ZERO 10777C 10778C *** INTRINSIC FUNCTIONS *** 10779C/+ 10780 DOUBLE PRECISION DSQRT 10781C/ 10782C *** EXTERNAL SUBROUTINE *** 10783C 10784 EXTERNAL DV7SCP 10785C 10786C DV7SCP... SETS ALL COMPONENTS OF A VECTOR TO A SCALAR. 10787C 10788C *** SUBSCRIPTS FOR IV AND V *** 10789C 10790 INTEGER DFAC, DTYPE, JCN, JTOL, NITER, S 10791 PARAMETER (DFAC=41, DTYPE=16, JCN=66, JTOL=59, NITER=31, S=62) 10792C 10793 PARAMETER (ZERO=0.D+0) 10794C 10795C------------------------------- BODY -------------------------------- 10796C 10797 IF (IV(DTYPE) .NE. 1 .AND. IV(NITER) .GT. 0) GO TO 999 10798 JCN1 = IV(JCN) 10799 JCN0 = IABS(JCN1) - 1 10800 IF (JCN1 .LT. 0) GO TO 10 10801 IV(JCN) = -JCN1 10802 CALL DV7SCP(P, V(JCN1), ZERO) 10803 10 DO 30 I = 1, P 10804 JCNI = JCN0 + I 10805 T = V(JCNI) 10806 DO 20 K = 1, NN 10807 T = DMAX1(T, DABS(DR(K,I))) 10808 20 CONTINUE 10809 V(JCNI) = T 10810 30 CONTINUE 10811 IF (N2 .LT. N) GO TO 999 10812 VDFAC = V(DFAC) 10813 JTOL0 = IV(JTOL) - 1 10814 D0 = JTOL0 + P 10815 SII = IV(S) - 1 10816 DO 50 I = 1, P 10817 SII = SII + I 10818 JCNI = JCN0 + I 10819 T = V(JCNI) 10820 IF (V(SII) .GT. ZERO) T = DMAX1(DSQRT(V(SII)), T) 10821 JTOLI = JTOL0 + I 10822 D0 = D0 + 1 10823 IF (T .LT. V(JTOLI)) T = DMAX1(V(D0), V(JTOLI)) 10824 D(I) = DMAX1(VDFAC*D(I), T) 10825 50 CONTINUE 10826C 10827 999 RETURN 10828C *** LAST CARD OF DD7UPD FOLLOWS *** 10829 END 10830 SUBROUTINE DV7SHF(N, K, X) 10831C 10832C *** SHIFT X(K),...,X(N) LEFT CIRCULARLY ONE POSITION *** 10833C 10834 INTEGER N, K 10835 DOUBLE PRECISION X(N) 10836C 10837 INTEGER I, NM1 10838 DOUBLE PRECISION T 10839C 10840 IF (K .GE. N) GO TO 999 10841 NM1 = N - 1 10842 T = X(K) 10843 DO 10 I = K, NM1 10844 X(I) = X(I+1) 10845 10 CONTINUE 10846 X(N) = T 10847 999 RETURN 10848 END 10849 SUBROUTINE DS3GRD(ALPHA, B, D, ETA0, FX, G, IRC, P, W, X) 10850C 10851C *** COMPUTE FINITE DIFFERENCE GRADIENT BY STWEART*S SCHEME *** 10852C 10853C *** PARAMETERS *** 10854C 10855 INTEGER IRC, P 10856 DOUBLE PRECISION ALPHA(P), B(2,P), D(P), ETA0, FX, G(P), W(6), 10857 1 X(P) 10858C 10859C....................................................................... 10860C 10861C *** PURPOSE *** 10862C 10863C THIS SUBROUTINE USES AN EMBELLISHED FORM OF THE FINITE-DIFFER- 10864C ENCE SCHEME PROPOSED BY STEWART (REF. 1) TO APPROXIMATE THE 10865C GRADIENT OF THE FUNCTION F(X), WHOSE VALUES ARE SUPPLIED BY 10866C REVERSE COMMUNICATION. 10867C 10868C *** PARAMETER DESCRIPTION *** 10869C 10870C ALPHA IN (APPROXIMATE) DIAGONAL ELEMENTS OF THE HESSIAN OF F(X). 10871C B IN ARRAY OF SIMPLE LOWER AND UPPER BOUNDS ON X. X MUST 10872C SATISFY B(1,I) .LE. X(I) .LE. B(2,I), I = 1(1)P. 10873C FOR ALL I WITH B(1,I) .GE. B(2,I), DS3GRD SIMPLY 10874C SETS G(I) TO 0. 10875C D IN SCALE VECTOR SUCH THAT D(I)*X(I), I = 1,...,P, ARE IN 10876C COMPARABLE UNITS. 10877C ETA0 IN ESTIMATED BOUND ON RELATIVE ERROR IN THE FUNCTION VALUE... 10878C (TRUE VALUE) = (COMPUTED VALUE)*(1+E), WHERE 10879C ABS(E) .LE. ETA0. 10880C FX I/O ON INPUT, FX MUST BE THE COMPUTED VALUE OF F(X). ON 10881C OUTPUT WITH IRC = 0, FX HAS BEEN RESTORED TO ITS ORIGINAL 10882C VALUE, THE ONE IT HAD WHEN DS3GRD WAS LAST CALLED WITH 10883C IRC = 0. 10884C G I/O ON INPUT WITH IRC = 0, G SHOULD CONTAIN AN APPROXIMATION 10885C TO THE GRADIENT OF F NEAR X, E.G., THE GRADIENT AT THE 10886C PREVIOUS ITERATE. WHEN DS3GRD RETURNS WITH IRC = 0, G IS 10887C THE DESIRED FINITE-DIFFERENCE APPROXIMATION TO THE 10888C GRADIENT AT X. 10889C IRC I/O INPUT/RETURN CODE... BEFORE THE VERY FIRST CALL ON DS3GRD, 10890C THE CALLER MUST SET IRC TO 0. WHENEVER DS3GRD RETURNS A 10891C NONZERO VALUE (OF AT MOST P) FOR IRC, IT HAS PERTURBED 10892C SOME COMPONENT OF X... THE CALLER SHOULD EVALUATE F(X) 10893C AND CALL DS3GRD AGAIN WITH FX = F(X). IF B PREVENTS 10894C ESTIMATING G(I) I.E., IF THERE IS AN I WITH 10895C B(1,I) .LT. B(2,I) BUT WITH B(1,I) SO CLOSE TO B(2,I) 10896C THAT THE FINITE-DIFFERENCING STEPS CANNOT BE CHOSEN, 10897C THEN DS3GRD RETURNS WITH IRC .GT. P. 10898C P IN THE NUMBER OF VARIABLES (COMPONENTS OF X) ON WHICH F 10899C DEPENDS. 10900C X I/O ON INPUT WITH IRC = 0, X IS THE POINT AT WHICH THE 10901C GRADIENT OF F IS DESIRED. ON OUTPUT WITH IRC NONZERO, X 10902C IS THE POINT AT WHICH F SHOULD BE EVALUATED. ON OUTPUT 10903C WITH IRC = 0, X HAS BEEN RESTORED TO ITS ORIGINAL VALUE 10904C (THE ONE IT HAD WHEN DS3GRD WAS LAST CALLED WITH IRC = 0) 10905C AND G CONTAINS THE DESIRED GRADIENT APPROXIMATION. 10906C W I/O WORK VECTOR OF LENGTH 6 IN WHICH DS3GRD SAVES CERTAIN 10907C QUANTITIES WHILE THE CALLER IS EVALUATING F(X) AT A 10908C PERTURBED X. 10909C 10910C *** APPLICATION AND USAGE RESTRICTIONS *** 10911C 10912C THIS ROUTINE IS INTENDED FOR USE WITH QUASI-NEWTON ROUTINES 10913C FOR UNCONSTRAINED MINIMIZATION (IN WHICH CASE ALPHA COMES FROM 10914C THE DIAGONAL OF THE QUASI-NEWTON HESSIAN APPROXIMATION). 10915C 10916C *** ALGORITHM NOTES *** 10917C 10918C THIS CODE DEPARTS FROM THE SCHEME PROPOSED BY STEWART (REF. 1) 10919C IN ITS GUARDING AGAINST OVERLY LARGE OR SMALL STEP SIZES AND ITS 10920C HANDLING OF SPECIAL CASES (SUCH AS ZERO COMPONENTS OF ALPHA OR G). 10921C 10922C *** REFERENCES *** 10923C 10924C 1. STEWART, G.W. (1967), A MODIFICATION OF DAVIDON*S MINIMIZATION 10925C METHOD TO ACCEPT DIFFERENCE APPROXIMATIONS OF DERIVATIVES, 10926C J. ASSOC. COMPUT. MACH. 14, PP. 72-83. 10927C 10928C *** HISTORY *** 10929C 10930C DESIGNED AND CODED BY DAVID M. GAY (SUMMER 1977/SUMMER 1980). 10931C 10932C *** GENERAL *** 10933C 10934C THIS ROUTINE WAS PREPARED IN CONNECTION WITH WORK SUPPORTED BY 10935C THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS MCS76-00324 AND 10936C MCS-7906671. 10937C 10938C....................................................................... 10939C 10940C ***** EXTERNAL FUNCTION ***** 10941C 10942 DOUBLE PRECISION DR7MDC 10943 EXTERNAL DR7MDC 10944C DR7MDC... RETURNS MACHINE-DEPENDENT CONSTANTS. 10945C 10946C ***** INTRINSIC FUNCTIONS ***** 10947C/+ 10948 DOUBLE PRECISION DSQRT 10949C/ 10950C ***** LOCAL VARIABLES ***** 10951C 10952 LOGICAL HIT 10953 INTEGER FH, FX0, HSAVE, I, XISAVE 10954 DOUBLE PRECISION AAI, AFX, AFXETA, AGI, ALPHAI, AXI, AXIBAR, 10955 1 DISCON, ETA, GI, H, HMIN, XI, XIH 10956 DOUBLE PRECISION C2000, FOUR, HMAX0, HMIN0, H0, MACHEP, ONE, P002, 10957 1 THREE, TWO, ZERO 10958C 10959 PARAMETER (C2000=2.0D+3, FOUR=4.0D+0, HMAX0=0.02D+0, HMIN0=5.0D+1, 10960 1 ONE=1.0D+0, P002=0.002D+0, THREE=3.0D+0, 10961 2 TWO=2.0D+0, ZERO=0.0D+0) 10962 PARAMETER (FH=3, FX0=4, HSAVE=5, XISAVE=6) 10963C 10964C--------------------------------- BODY ------------------------------ 10965C 10966 IF (IRC .LT. 0) GO TO 80 10967 IF (IRC .GT. 0) GO TO 210 10968C 10969C *** FRESH START -- GET MACHINE-DEPENDENT CONSTANTS *** 10970C 10971C STORE MACHEP IN W(1) AND H0 IN W(2), WHERE MACHEP IS THE UNIT 10972C ROUNDOFF (THE SMALLEST POSITIVE NUMBER SUCH THAT 10973C 1 + MACHEP .GT. 1 AND 1 - MACHEP .LT. 1), AND H0 IS THE 10974C SQUARE-ROOT OF MACHEP. 10975C 10976 W(1) = DR7MDC(3) 10977 W(2) = DSQRT(W(1)) 10978C 10979 W(FX0) = FX 10980C 10981C *** INCREMENT I AND START COMPUTING G(I) *** 10982C 10983 20 I = IABS(IRC) + 1 10984 IF (I .GT. P) GO TO 220 10985 IRC = I 10986 IF (B(1,I) .LT. B(2,I)) GO TO 30 10987 G(I) = ZERO 10988 GO TO 20 10989 30 AFX = DABS(W(FX0)) 10990 MACHEP = W(1) 10991 H0 = W(2) 10992 HMIN = HMIN0 * MACHEP 10993 XI = X(I) 10994 W(XISAVE) = XI 10995 AXI = DABS(XI) 10996 AXIBAR = DMAX1(AXI, ONE/D(I)) 10997 GI = G(I) 10998 AGI = DABS(GI) 10999 ETA = DABS(ETA0) 11000 IF (AFX .GT. ZERO) ETA = DMAX1(ETA, AGI*AXI*MACHEP/AFX) 11001 ALPHAI = ALPHA(I) 11002 IF (ALPHAI .EQ. ZERO) GO TO 130 11003 IF (GI .EQ. ZERO .OR. FX .EQ. ZERO) GO TO 140 11004 AFXETA = AFX*ETA 11005 AAI = DABS(ALPHAI) 11006C 11007C *** COMPUTE H = STEWART*S FORWARD-DIFFERENCE STEP SIZE. 11008C 11009 IF (GI**2 .LE. AFXETA*AAI) GO TO 40 11010 H = TWO*DSQRT(AFXETA/AAI) 11011 H = H*(ONE - AAI*H/(THREE*AAI*H + FOUR*AGI)) 11012 GO TO 50 11013C40 H = TWO*(AFXETA*AGI/(AAI**2))**(ONE/THREE) 11014 40 H = TWO * (AFXETA*AGI)**(ONE/THREE) * AAI**(-TWO/THREE) 11015 H = H*(ONE - TWO*AGI/(THREE*AAI*H + FOUR*AGI)) 11016C 11017C *** ENSURE THAT H IS NOT INSIGNIFICANTLY SMALL *** 11018C 11019 50 H = DMAX1(H, HMIN*AXIBAR) 11020C 11021C *** USE FORWARD DIFFERENCE IF BOUND ON TRUNCATION ERROR IS AT 11022C *** MOST 10**-3. 11023C 11024 IF (AAI*H .LE. P002*AGI) GO TO 120 11025C 11026C *** COMPUTE H = STEWART*S STEP FOR CENTRAL DIFFERENCE. 11027C 11028 DISCON = C2000*AFXETA 11029 H = DISCON/(AGI + DSQRT(GI**2 + AAI*DISCON)) 11030C 11031C *** ENSURE THAT H IS NEITHER TOO SMALL NOR TOO BIG *** 11032C 11033 H = DMAX1(H, HMIN*AXIBAR) 11034 IF (H .GE. HMAX0*AXIBAR) H = AXIBAR * H0**(TWO/THREE) 11035C 11036C *** COMPUTE CENTRAL DIFFERENCE *** 11037C 11038 XIH = XI + H 11039 IF (XI - H .LT. B(1,I)) GO TO 60 11040 IRC = -I 11041 IF (XIH .LE. B(2,I)) GO TO 200 11042 H = -H 11043 XIH = XI + H 11044 IF (XI + TWO*H .LT. B(1,I)) GO TO 190 11045 GO TO 70 11046 60 IF (XI + TWO*H .GT. B(2,I)) GO TO 190 11047C *** MUST DO OFF-SIDE CENTRAL DIFFERENCE *** 11048 70 IRC = -(I + P) 11049 GO TO 200 11050C 11051 80 I = -IRC 11052 IF (I .LE. P) GO TO 100 11053 I = I - P 11054 IF (I .GT. P) GO TO 90 11055 W(FH) = FX 11056 H = TWO * W(HSAVE) 11057 XIH = W(XISAVE) + H 11058 IRC = IRC - P 11059 GO TO 200 11060C 11061C *** FINISH OFF-SIDE CENTRAL DIFFERENCE *** 11062C 11063 90 I = I - P 11064 G(I) = (FOUR*W(FH) - FX - THREE*W(FX0)) / W(HSAVE) 11065 IRC = I 11066 X(I) = W(XISAVE) 11067 GO TO 20 11068C 11069 100 H = -W(HSAVE) 11070 IF (H .GT. ZERO) GO TO 110 11071 W(FH) = FX 11072 XIH = W(XISAVE) + H 11073 GO TO 200 11074C 11075 110 G(I) = (W(FH) - FX) / (TWO * H) 11076 X(I) = W(XISAVE) 11077 GO TO 20 11078C 11079C *** COMPUTE FORWARD DIFFERENCES IN VARIOUS CASES *** 11080C 11081 120 IF (H .GE. HMAX0*AXIBAR) H = H0 * AXIBAR 11082 IF (ALPHAI*GI .LT. ZERO) H = -H 11083 GO TO 150 11084 130 H = AXIBAR 11085 GO TO 150 11086 140 H = H0 * AXIBAR 11087C 11088 150 HIT = .FALSE. 11089 160 XIH = XI + H 11090 IF (H .GT. ZERO) GO TO 170 11091 IF (XIH .GE. B(1,I)) GO TO 200 11092 GO TO 180 11093 170 IF (XIH .LE. B(2,I)) GO TO 200 11094 180 IF (HIT) GO TO 190 11095 HIT = .TRUE. 11096 H = -H 11097 GO TO 160 11098C 11099C *** ERROR RETURN... 11100 190 IRC = I + P 11101 GO TO 230 11102C 11103C *** RETURN FOR NEW FUNCTION VALUE... 11104 200 X(I) = XIH 11105 W(HSAVE) = H 11106 GO TO 999 11107C 11108C *** COMPUTE ACTUAL FORWARD DIFFERENCE *** 11109C 11110 210 G(IRC) = (FX - W(FX0)) / W(HSAVE) 11111 X(IRC) = W(XISAVE) 11112 GO TO 20 11113C 11114C *** RESTORE FX AND INDICATE THAT G HAS BEEN COMPUTED *** 11115C 11116 220 IRC = 0 11117 230 FX = W(FX0) 11118C 11119 999 RETURN 11120C *** LAST LINE OF DS3GRD FOLLOWS *** 11121 END 11122 SUBROUTINE DL7UPD(BETA, GAMMA, L, LAMBDA, LPLUS, N, W, Z) 11123C 11124C *** COMPUTE LPLUS = SECANT UPDATE OF L *** 11125C 11126C *** PARAMETER DECLARATIONS *** 11127C 11128 INTEGER N 11129 DOUBLE PRECISION BETA(N), GAMMA(N), L(*), LAMBDA(N), LPLUS(*), 11130 1 W(N), Z(N) 11131C DIMENSION L(N*(N+1)/2), LPLUS(N*(N+1)/2) 11132C 11133C-------------------------- PARAMETER USAGE -------------------------- 11134C 11135C BETA = SCRATCH VECTOR. 11136C GAMMA = SCRATCH VECTOR. 11137C L (INPUT) LOWER TRIANGULAR MATRIX, STORED ROWWISE. 11138C LAMBDA = SCRATCH VECTOR. 11139C LPLUS (OUTPUT) LOWER TRIANGULAR MATRIX, STORED ROWWISE, WHICH MAY 11140C OCCUPY THE SAME STORAGE AS L. 11141C N (INPUT) LENGTH OF VECTOR PARAMETERS AND ORDER OF MATRICES. 11142C W (INPUT, DESTROYED ON OUTPUT) RIGHT SINGULAR VECTOR OF RANK 1 11143C CORRECTION TO L. 11144C Z (INPUT, DESTROYED ON OUTPUT) LEFT SINGULAR VECTOR OF RANK 1 11145C CORRECTION TO L. 11146C 11147C------------------------------- NOTES ------------------------------- 11148C 11149C *** APPLICATION AND USAGE RESTRICTIONS *** 11150C 11151C THIS ROUTINE UPDATES THE CHOLESKY FACTOR L OF A SYMMETRIC 11152C POSITIVE DEFINITE MATRIX TO WHICH A SECANT UPDATE IS BEING 11153C APPLIED -- IT COMPUTES A CHOLESKY FACTOR LPLUS OF 11154C L * (I + Z*W**T) * (I + W*Z**T) * L**T. IT IS ASSUMED THAT W 11155C AND Z HAVE BEEN CHOSEN SO THAT THE UPDATED MATRIX IS STRICTLY 11156C POSITIVE DEFINITE. 11157C 11158C *** ALGORITHM NOTES *** 11159C 11160C THIS CODE USES RECURRENCE 3 OF REF. 1 (WITH D(J) = 1 FOR ALL J) 11161C TO COMPUTE LPLUS OF THE FORM L * (I + Z*W**T) * Q, WHERE Q 11162C IS AN ORTHOGONAL MATRIX THAT MAKES THE RESULT LOWER TRIANGULAR. 11163C LPLUS MAY HAVE SOME NEGATIVE DIAGONAL ELEMENTS. 11164C 11165C *** REFERENCES *** 11166C 11167C 1. GOLDFARB, D. (1976), FACTORIZED VARIABLE METRIC METHODS FOR UNCON- 11168C STRAINED OPTIMIZATION, MATH. COMPUT. 30, PP. 796-811. 11169C 11170C *** GENERAL *** 11171C 11172C CODED BY DAVID M. GAY (FALL 1979). 11173C THIS SUBROUTINE WAS WRITTEN IN CONNECTION WITH RESEARCH SUPPORTED 11174C BY THE NATIONAL SCIENCE FOUNDATION UNDER GRANTS MCS-7600324 AND 11175C MCS-7906671. 11176C 11177C------------------------ EXTERNAL QUANTITIES ------------------------ 11178C 11179C *** INTRINSIC FUNCTIONS *** 11180C/+ 11181 DOUBLE PRECISION DSQRT 11182C/ 11183C-------------------------- LOCAL VARIABLES -------------------------- 11184C 11185 INTEGER I, IJ, J, JJ, JP1, K, NM1, NP1 11186 DOUBLE PRECISION A, B, BJ, ETA, GJ, LJ, LIJ, LJJ, NU, S, THETA, 11187 1 WJ, ZJ 11188 DOUBLE PRECISION ONE, ZERO 11189C 11190C *** DATA INITIALIZATIONS *** 11191C 11192 PARAMETER (ONE=1.D+0, ZERO=0.D+0) 11193C 11194C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 11195C 11196 NU = ONE 11197 ETA = ZERO 11198 IF (N .LE. 1) GO TO 30 11199 NM1 = N - 1 11200C 11201C *** TEMPORARILY STORE S(J) = SUM OVER K = J+1 TO N OF W(K)**2 IN 11202C *** LAMBDA(J). 11203C 11204 S = ZERO 11205 DO 10 I = 1, NM1 11206 J = N - I 11207 S = S + W(J+1)**2 11208 LAMBDA(J) = S 11209 10 CONTINUE 11210C 11211C *** COMPUTE LAMBDA, GAMMA, AND BETA BY GOLDFARB*S RECURRENCE 3. 11212C 11213 DO 20 J = 1, NM1 11214 WJ = W(J) 11215 A = NU*Z(J) - ETA*WJ 11216 THETA = ONE + A*WJ 11217 S = A*LAMBDA(J) 11218 LJ = DSQRT(THETA**2 + A*S) 11219 IF (THETA .GT. ZERO) LJ = -LJ 11220 LAMBDA(J) = LJ 11221 B = THETA*WJ + S 11222 GAMMA(J) = B * NU / LJ 11223 BETA(J) = (A - B*ETA) / LJ 11224 NU = -NU / LJ 11225 ETA = -(ETA + (A**2)/(THETA - LJ)) / LJ 11226 20 CONTINUE 11227 30 LAMBDA(N) = ONE + (NU*Z(N) - ETA*W(N))*W(N) 11228C 11229C *** UPDATE L, GRADUALLY OVERWRITING W AND Z WITH L*W AND L*Z. 11230C 11231 NP1 = N + 1 11232 JJ = N * (N + 1) / 2 11233 DO 60 K = 1, N 11234 J = NP1 - K 11235 LJ = LAMBDA(J) 11236 LJJ = L(JJ) 11237 LPLUS(JJ) = LJ * LJJ 11238 WJ = W(J) 11239 W(J) = LJJ * WJ 11240 ZJ = Z(J) 11241 Z(J) = LJJ * ZJ 11242 IF (K .EQ. 1) GO TO 50 11243 BJ = BETA(J) 11244 GJ = GAMMA(J) 11245 IJ = JJ + J 11246 JP1 = J + 1 11247 DO 40 I = JP1, N 11248 LIJ = L(IJ) 11249 LPLUS(IJ) = LJ*LIJ + BJ*W(I) + GJ*Z(I) 11250 W(I) = W(I) + LIJ*WJ 11251 Z(I) = Z(I) + LIJ*ZJ 11252 IJ = IJ + I 11253 40 CONTINUE 11254 50 JJ = JJ - J 11255 60 CONTINUE 11256C 11257 RETURN 11258C *** LAST CARD OF DL7UPD FOLLOWS *** 11259 END 11260 SUBROUTINE DO7PRD(L, LS, P, S, W, Y, Z) 11261C 11262C *** FOR I = 1..L, SET S = S + W(I)*Y(.,I)*(Z(.,I)**T), I.E., 11263C *** ADD W(I) TIMES THE OUTER PRODUCT OF Y(.,I) AND Z(.,I). 11264C 11265 INTEGER L, LS, P 11266 DOUBLE PRECISION S(LS), W(L), Y(P,L), Z(P,L) 11267C DIMENSION S(P*(P+1)/2) 11268C 11269 INTEGER I, J, K, M 11270 DOUBLE PRECISION WK, YI, ZERO 11271 DATA ZERO/0.D+0/ 11272C 11273 DO 30 K = 1, L 11274 WK = W(K) 11275 IF (WK .EQ. ZERO) GO TO 30 11276 M = 1 11277 DO 20 I = 1, P 11278 YI = WK * Y(I,K) 11279 DO 10 J = 1, I 11280 S(M) = S(M) + YI*Z(J,K) 11281 M = M + 1 11282 10 CONTINUE 11283 20 CONTINUE 11284 30 CONTINUE 11285C 11286 RETURN 11287C *** LAST CARD OF DO7PRD FOLLOWS *** 11288 END 11289 SUBROUTINE DV7VMP(N, X, Y, Z, K) 11290C 11291C *** SET X(I) = Y(I) * Z(I)**K, 1 .LE. I .LE. N (FOR K = 1 OR -1) *** 11292C 11293 INTEGER N, K 11294 DOUBLE PRECISION X(N), Y(N), Z(N) 11295 INTEGER I 11296C 11297 IF (K .GE. 0) GO TO 20 11298 DO 10 I = 1, N 11299 X(I) = Y(I) / Z(I) 11300 10 CONTINUE 11301 GO TO 999 11302C 11303 20 DO 30 I = 1, N 11304 X(I) = Y(I) * Z(I) 11305 30 CONTINUE 11306 999 RETURN 11307C *** LAST CARD OF DV7VMP FOLLOWS *** 11308 END 11309 SUBROUTINE DSM(M,N,NPAIRS,INDROW,INDCOL,NGRP,MAXGRP,MINGRP, 11310 * INFO,IPNTR,JPNTR,IWA,LIWA,BWA) 11311 INTEGER M,N,NPAIRS,MAXGRP,MINGRP,INFO,LIWA 11312 INTEGER INDROW(NPAIRS),INDCOL(NPAIRS),NGRP(N), 11313 * IPNTR(M+1),JPNTR(N+1),IWA(LIWA) 11314 LOGICAL BWA(N) 11315C ********** 11316C 11317C SUBROUTINE DSM 11318C 11319C THE PURPOSE OF DSM IS TO DETERMINE AN OPTIMAL OR NEAR- 11320C OPTIMAL CONSISTENT PARTITION OF THE COLUMNS OF A SPARSE 11321C M BY N MATRIX A. 11322C 11323C THE SPARSITY PATTERN OF THE MATRIX A IS SPECIFIED BY 11324C THE ARRAYS INDROW AND INDCOL. ON INPUT THE INDICES 11325C FOR THE NON-ZERO ELEMENTS OF A ARE 11326C 11327C INDROW(K),INDCOL(K), K = 1,2,...,NPAIRS. 11328C 11329C THE (INDROW,INDCOL) PAIRS MAY BE SPECIFIED IN ANY ORDER. 11330C DUPLICATE INPUT PAIRS ARE PERMITTED, BUT THE SUBROUTINE 11331C ELIMINATES THEM. 11332C 11333C THE SUBROUTINE PARTITIONS THE COLUMNS OF A INTO GROUPS 11334C SUCH THAT COLUMNS IN THE SAME GROUP DO NOT HAVE A 11335C NON-ZERO IN THE SAME ROW POSITION. A PARTITION OF THE 11336C COLUMNS OF A WITH THIS PROPERTY IS CONSISTENT WITH THE 11337C DIRECT DETERMINATION OF A. 11338C 11339C THE SUBROUTINE STATEMENT IS 11340C 11341C SUBROUTINE DSM(M,N,NPAIRS,INDROW,INDCOL,NGRP,MAXGRP,MINGRP, 11342C INFO,IPNTR,JPNTR,IWA,LIWA,BWA) 11343C 11344C WHERE 11345C 11346C M IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE NUMBER 11347C OF ROWS OF A. 11348C 11349C N IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE NUMBER 11350C OF COLUMNS OF A. 11351C 11352C NPAIRS IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE 11353C NUMBER OF (INDROW,INDCOL) PAIRS USED TO DESCRIBE THE 11354C SPARSITY PATTERN OF A. 11355C 11356C INDROW IS AN INTEGER ARRAY OF LENGTH NPAIRS. ON INPUT INDROW 11357C MUST CONTAIN THE ROW INDICES OF THE NON-ZERO ELEMENTS OF A. 11358C ON OUTPUT INDROW IS PERMUTED SO THAT THE CORRESPONDING 11359C COLUMN INDICES ARE IN NON-DECREASING ORDER. THE COLUMN 11360C INDICES CAN BE RECOVERED FROM THE ARRAY JPNTR. 11361C 11362C INDCOL IS AN INTEGER ARRAY OF LENGTH NPAIRS. ON INPUT INDCOL 11363C MUST CONTAIN THE COLUMN INDICES OF THE NON-ZERO ELEMENTS OF 11364C A. ON OUTPUT INDCOL IS PERMUTED SO THAT THE CORRESPONDING 11365C ROW INDICES ARE IN NON-DECREASING ORDER. THE ROW INDICES 11366C CAN BE RECOVERED FROM THE ARRAY IPNTR. 11367C 11368C NGRP IS AN INTEGER OUTPUT ARRAY OF LENGTH N WHICH SPECIFIES 11369C THE PARTITION OF THE COLUMNS OF A. COLUMN JCOL BELONGS 11370C TO GROUP NGRP(JCOL). 11371C 11372C MAXGRP IS AN INTEGER OUTPUT VARIABLE WHICH SPECIFIES THE 11373C NUMBER OF GROUPS IN THE PARTITION OF THE COLUMNS OF A. 11374C 11375C MINGRP IS AN INTEGER OUTPUT VARIABLE WHICH SPECIFIES A LOWER 11376C BOUND FOR THE NUMBER OF GROUPS IN ANY CONSISTENT PARTITION 11377C OF THE COLUMNS OF A. 11378C 11379C INFO IS AN INTEGER OUTPUT VARIABLE SET AS FOLLOWS. FOR 11380C NORMAL TERMINATION INFO = 1. IF M, N, OR NPAIRS IS NOT 11381C POSITIVE OR LIWA IS LESS THAN MAX(M,6*N), THEN INFO = 0. 11382C IF THE K-TH ELEMENT OF INDROW IS NOT AN INTEGER BETWEEN 11383C 1 AND M OR THE K-TH ELEMENT OF INDCOL IS NOT AN INTEGER 11384C BETWEEN 1 AND N, THEN INFO = -K. 11385C 11386C IPNTR IS AN INTEGER OUTPUT ARRAY OF LENGTH M + 1 WHICH 11387C SPECIFIES THE LOCATIONS OF THE COLUMN INDICES IN INDCOL. 11388C THE COLUMN INDICES FOR ROW I ARE 11389C 11390C INDCOL(K), K = IPNTR(I),...,IPNTR(I+1)-1. 11391C 11392C NOTE THAT IPNTR(M+1)-1 IS THEN THE NUMBER OF NON-ZERO 11393C ELEMENTS OF THE MATRIX A. 11394C 11395C JPNTR IS AN INTEGER OUTPUT ARRAY OF LENGTH N + 1 WHICH 11396C SPECIFIES THE LOCATIONS OF THE ROW INDICES IN INDROW. 11397C THE ROW INDICES FOR COLUMN J ARE 11398C 11399C INDROW(K), K = JPNTR(J),...,JPNTR(J+1)-1. 11400C 11401C NOTE THAT JPNTR(N+1)-1 IS THEN THE NUMBER OF NON-ZERO 11402C ELEMENTS OF THE MATRIX A. 11403C 11404C IWA IS AN INTEGER WORK ARRAY OF LENGTH LIWA. 11405C 11406C LIWA IS A POSITIVE INTEGER INPUT VARIABLE NOT LESS THAN 11407C MAX(M,6*N). 11408C 11409C BWA IS A LOGICAL WORK ARRAY OF LENGTH N. 11410C 11411C SUBPROGRAMS CALLED 11412C 11413C MINPACK-SUPPLIED ...D7EGR,I7DO,N7MSRT,M7SEQ,S7ETR,M7SLO,S7RTDT 11414C 11415C FORTRAN-SUPPLIED ... MAX0 11416C 11417C ARGONNE NATIONAL LABORATORY. MINPACK PROJECT. JUNE 1982. 11418C THOMAS F. COLEMAN, BURTON S. GARBOW, JORGE J. MORE 11419C 11420C ********** 11421 INTEGER I,IR,J,JP,JPL,JPU,K,MAXCLQ,NNZ,NUMGRP 11422C 11423C CHECK THE INPUT DATA. 11424C 11425 INFO = 0 11426 IF (M .LT. 1 .OR. N .LT. 1 .OR. NPAIRS .LT. 1 .OR. 11427 * LIWA .LT. MAX0(M,6*N)) GO TO 130 11428 DO 10 K = 1, NPAIRS 11429 INFO = -K 11430 IF (INDROW(K) .LT. 1 .OR. INDROW(K) .GT. M .OR. 11431 * INDCOL(K) .LT. 1 .OR. INDCOL(K) .GT. N) GO TO 130 11432 10 CONTINUE 11433 INFO = 1 11434C 11435C SORT THE DATA STRUCTURE BY COLUMNS. 11436C 11437 CALL S7RTDT(N,NPAIRS,INDROW,INDCOL,JPNTR,IWA(1)) 11438C 11439C COMPRESS THE DATA AND DETERMINE THE NUMBER OF 11440C NON-ZERO ELEMENTS OF A. 11441C 11442 DO 20 I = 1, M 11443 IWA(I) = 0 11444 20 CONTINUE 11445 NNZ = 0 11446 DO 70 J = 1, N 11447 JPL = JPNTR(J) 11448 JPU = JPNTR(J+1) - 1 11449 JPNTR(J) = NNZ + 1 11450 IF (JPU .LT. JPL) GO TO 60 11451 DO 40 JP = JPL, JPU 11452 IR = INDROW(JP) 11453 IF (IWA(IR) .NE. 0) GO TO 30 11454 NNZ = NNZ + 1 11455 INDROW(NNZ) = IR 11456 IWA(IR) = 1 11457 30 CONTINUE 11458 40 CONTINUE 11459 JPL = JPNTR(J) 11460 DO 50 JP = JPL, NNZ 11461 IR = INDROW(JP) 11462 IWA(IR) = 0 11463 50 CONTINUE 11464 60 CONTINUE 11465 70 CONTINUE 11466 JPNTR(N+1) = NNZ + 1 11467C 11468C EXTEND THE DATA STRUCTURE TO ROWS. 11469C 11470 CALL S7ETR(M,N,NPAIRS,INDROW,JPNTR,INDCOL,IPNTR,IWA(1)) 11471C 11472C DETERMINE A LOWER BOUND FOR THE NUMBER OF GROUPS. 11473C 11474 MINGRP = 0 11475 DO 80 I = 1, M 11476 MINGRP = MAX0(MINGRP,IPNTR(I+1)-IPNTR(I)) 11477 80 CONTINUE 11478C 11479C DETERMINE THE DEGREE SEQUENCE FOR THE INTERSECTION 11480C GRAPH OF THE COLUMNS OF A. 11481C 11482 CALL D7EGR(M,N,NPAIRS,INDROW,JPNTR,INDCOL,IPNTR,IWA(5*N+1), 11483 * IWA(N+1),BWA) 11484C 11485C COLOR THE INTERSECTION GRAPH OF THE COLUMNS OF A 11486C WITH THE SMALLEST-LAST (SL) ORDERING. 11487C 11488 CALL M7SLO(N,INDROW,JPNTR,INDCOL,IPNTR,IWA(5*N+1),IWA(4*N+1), 11489 * MAXCLQ,IWA(1),IWA(N+1),IWA(2*N+1),IWA(3*N+1),BWA) 11490 CALL M7SEQ(N,INDROW,JPNTR,INDCOL,IPNTR,IWA(4*N+1),NGRP,MAXGRP, 11491 * IWA(N+1),BWA) 11492 MINGRP = MAX0(MINGRP,MAXCLQ) 11493 IF (MAXGRP .EQ. MINGRP) GO TO 130 11494C 11495C COLOR THE INTERSECTION GRAPH OF THE COLUMNS OF A 11496C WITH THE INCIDENCE-DEGREE (ID) ORDERING. 11497C 11498 CALL I7DO(M,N,NPAIRS,INDROW,JPNTR,INDCOL,IPNTR,IWA(5*N+1), 11499 * IWA(4*N+1), 11500 * MAXCLQ,IWA(1),IWA(N+1),IWA(2*N+1),IWA(3*N+1),BWA) 11501 CALL M7SEQ(N,INDROW,JPNTR,INDCOL,IPNTR,IWA(4*N+1),IWA(1),NUMGRP, 11502 * IWA(N+1),BWA) 11503 MINGRP = MAX0(MINGRP,MAXCLQ) 11504 IF (NUMGRP .GE. MAXGRP) GO TO 100 11505 MAXGRP = NUMGRP 11506 DO 90 J = 1, N 11507 NGRP(J) = IWA(J) 11508 90 CONTINUE 11509 IF (MAXGRP .EQ. MINGRP) GO TO 130 11510 100 CONTINUE 11511C 11512C COLOR THE INTERSECTION GRAPH OF THE COLUMNS OF A 11513C WITH THE LARGEST-FIRST (LF) ORDERING. 11514C 11515 CALL N7MSRT(N,N-1,IWA(5*N+1),-1,IWA(4*N+1),IWA(2*N+1),IWA(N+1)) 11516 CALL M7SEQ(N,INDROW,JPNTR,INDCOL,IPNTR,IWA(4*N+1),IWA(1),NUMGRP, 11517 * IWA(N+1),BWA) 11518 IF (NUMGRP .GE. MAXGRP) GO TO 120 11519 MAXGRP = NUMGRP 11520 DO 110 J = 1, N 11521 NGRP(J) = IWA(J) 11522 110 CONTINUE 11523 120 CONTINUE 11524C 11525C EXIT FROM PROGRAM. 11526C 11527 130 CONTINUE 11528 RETURN 11529C 11530C LAST CARD OF SUBROUTINE DSM. 11531C 11532 END 11533 SUBROUTINE M7SEQ(N,INDROW,JPNTR,INDCOL,IPNTR,LIST,NGRP,MAXGRP, 11534 * IWA,BWA) 11535 INTEGER N,MAXGRP 11536 INTEGER INDROW(1),JPNTR(1),INDCOL(1),IPNTR(1),LIST(N),NGRP(N), 11537 * IWA(N) 11538 LOGICAL BWA(N) 11539C ********** 11540C 11541C SUBROUTINE M7SEQ 11542C 11543C GIVEN THE SPARSITY PATTERN OF AN M BY N MATRIX A, THIS 11544C SUBROUTINE DETERMINES A CONSISTENT PARTITION OF THE 11545C COLUMNS OF A BY A SEQUENTIAL ALGORITHM. 11546C 11547C A CONSISTENT PARTITION IS DEFINED IN TERMS OF THE LOOPLESS 11548C GRAPH G WITH VERTICES A(J), J = 1,2,...,N WHERE A(J) IS THE 11549C J-TH COLUMN OF A AND WITH EDGE (A(I),A(J)) IF AND ONLY IF 11550C COLUMNS I AND J HAVE A NON-ZERO IN THE SAME ROW POSITION. 11551C 11552C A PARTITION OF THE COLUMNS OF A INTO GROUPS IS CONSISTENT 11553C IF THE COLUMNS IN ANY GROUP ARE NOT ADJACENT IN THE GRAPH G. 11554C IN GRAPH-THEORY TERMINOLOGY, A CONSISTENT PARTITION OF THE 11555C COLUMNS OF A CORRESPONDS TO A COLORING OF THE GRAPH G. 11556C 11557C THE SUBROUTINE EXAMINES THE COLUMNS IN THE ORDER SPECIFIED 11558C BY THE ARRAY LIST, AND ASSIGNS THE CURRENT COLUMN TO THE 11559C GROUP WITH THE SMALLEST POSSIBLE NUMBER. 11560C 11561C NOTE THAT THE VALUE OF M IS NOT NEEDED BY M7SEQ AND IS 11562C THEREFORE NOT PRESENT IN THE SUBROUTINE STATEMENT. 11563C 11564C THE SUBROUTINE STATEMENT IS 11565C 11566C SUBROUTINE M7SEQ(N,INDROW,JPNTR,INDCOL,IPNTR,LIST,NGRP,MAXGRP, 11567C IWA,BWA) 11568C 11569C WHERE 11570C 11571C N IS A POSITIVE INTEGER INPUT VARIABLE SET TO THE NUMBER 11572C OF COLUMNS OF A. 11573C 11574C INDROW IS AN INTEGER INPUT ARRAY WHICH CONTAINS THE ROW 11575C INDICES FOR THE NON-ZEROES IN THE MATRIX A. 11576C 11577C JPNTR IS AN INTEGER INPUT ARRAY OF LENGTH N + 1 WHICH 11578C SPECIFIES THE LOCATIONS OF THE ROW INDICES IN INDROW. 11579C THE ROW INDICES FOR COLUMN J ARE 11580C 11581C INDROW(K), K = JPNTR(J),...,JPNTR(J+1)-1. 11582C 11583C NOTE THAT JPNTR(N+1)-1 IS THEN THE NUMBER OF NON-ZERO 11584C ELEMENTS OF THE MATRIX A. 11585C 11586C INDCOL IS AN INTEGER INPUT ARRAY WHICH CONTAINS THE 11587C COLUMN INDICES FOR THE NON-ZEROES IN THE MATRIX A. 11588C 11589C IPNTR IS AN INTEGER INPUT ARRAY OF LENGTH M + 1 WHICH 11590C SPECIFIES THE LOCATIONS OF THE COLUMN INDICES IN INDCOL. 11591C THE COLUMN INDICES FOR ROW I ARE 11592C 11593C INDCOL(K), K = IPNTR(I),...,IPNTR(I+1)-1. 11594C 11595C NOTE THAT IPNTR(M+1)-1 IS THEN THE NUMBER OF NON-ZERO 11596C ELEMENTS OF THE MATRIX A. 11597C 11598C LIST IS AN INTEGER INPUT ARRAY OF LENGTH N WHICH SPECIFIES 11599C THE ORDER TO BE USED BY THE SEQUENTIAL ALGORITHM. 11600C THE J-TH COLUMN IN THIS ORDER IS LIST(J). 11601C 11602C NGRP IS AN INTEGER OUTPUT ARRAY OF LENGTH N WHICH SPECIFIES 11603C THE PARTITION OF THE COLUMNS OF A. COLUMN JCOL BELONGS 11604C TO GROUP NGRP(JCOL). 11605C 11606C MAXGRP IS AN INTEGER OUTPUT VARIABLE WHICH SPECIFIES THE 11607C NUMBER OF GROUPS IN THE PARTITION OF THE COLUMNS OF A. 11608C 11609C IWA IS AN INTEGER WORK ARRAY OF LENGTH N. 11610C 11611C BWA IS A LOGICAL WORK ARRAY OF LENGTH N. 11612C 11613C ARGONNE NATIONAL LABORATORY. MINPACK PROJECT. JUNE 1982. 11614C THOMAS F. COLEMAN, BURTON S. GARBOW, JORGE J. MORE 11615C 11616C ********** 11617 INTEGER DEG,IC,IP,IPL,IPU,IR,J,JCOL,JP,JPL,JPU,L,NUMGRP 11618C 11619C INITIALIZATION BLOCK. 11620C 11621 MAXGRP = 0 11622 DO 10 JP = 1, N 11623 NGRP(JP) = N 11624 BWA(JP) = .FALSE. 11625 10 CONTINUE 11626 BWA(N) = .TRUE. 11627C 11628C BEGINNING OF ITERATION LOOP. 11629C 11630 DO 100 J = 1, N 11631 JCOL = LIST(J) 11632C 11633C FIND ALL COLUMNS ADJACENT TO COLUMN JCOL. 11634C 11635 DEG = 0 11636C 11637C DETERMINE ALL POSITIONS (IR,JCOL) WHICH CORRESPOND 11638C TO NON-ZEROES IN THE MATRIX. 11639C 11640 JPL = JPNTR(JCOL) 11641 JPU = JPNTR(JCOL+1) - 1 11642 IF (JPU .LT. JPL) GO TO 50 11643 DO 40 JP = JPL, JPU 11644 IR = INDROW(JP) 11645C 11646C FOR EACH ROW IR, DETERMINE ALL POSITIONS (IR,IC) 11647C WHICH CORRESPOND TO NON-ZEROES IN THE MATRIX. 11648C 11649 IPL = IPNTR(IR) 11650 IPU = IPNTR(IR+1) - 1 11651 DO 30 IP = IPL, IPU 11652 IC = INDCOL(IP) 11653 L = NGRP(IC) 11654C 11655C ARRAY BWA MARKS THE GROUP NUMBERS OF THE 11656C COLUMNS WHICH ARE ADJACENT TO COLUMN JCOL. 11657C ARRAY IWA RECORDS THE MARKED GROUP NUMBERS. 11658C 11659 IF (BWA(L)) GO TO 20 11660 BWA(L) = .TRUE. 11661 DEG = DEG + 1 11662 IWA(DEG) = L 11663 20 CONTINUE 11664 30 CONTINUE 11665 40 CONTINUE 11666 50 CONTINUE 11667C 11668C ASSIGN THE SMALLEST UN-MARKED GROUP NUMBER TO JCOL. 11669C 11670 DO 60 JP = 1, N 11671 NUMGRP = JP 11672 IF (.NOT. BWA(JP)) GO TO 70 11673 60 CONTINUE 11674 70 CONTINUE 11675 NGRP(JCOL) = NUMGRP 11676 MAXGRP = MAX0(MAXGRP,NUMGRP) 11677C 11678C UN-MARK THE GROUP NUMBERS. 11679C 11680 IF (DEG .LT. 1) GO TO 90 11681 DO 80 JP = 1, DEG 11682 L = IWA(JP) 11683 BWA(L) = .FALSE. 11684 80 CONTINUE 11685 90 CONTINUE 11686 100 CONTINUE 11687C 11688C END OF ITERATION LOOP. 11689C 11690 RETURN 11691C 11692C LAST CARD OF SUBROUTINE M7SEQ. 11693C 11694 END 11695 SUBROUTINE DL7TSQ(N, A, L) 11696C 11697C *** SET A TO LOWER TRIANGLE OF (L**T) * L *** 11698C 11699C *** L = N X N LOWER TRIANG. MATRIX STORED ROWWISE. *** 11700C *** A IS ALSO STORED ROWWISE AND MAY SHARE STORAGE WITH L. *** 11701C 11702 INTEGER N 11703 DOUBLE PRECISION A(*), L(*) 11704C DIMENSION A(N*(N+1)/2), L(N*(N+1)/2) 11705C 11706 INTEGER I, II, IIM1, I1, J, K, M 11707 DOUBLE PRECISION LII, LJ 11708C 11709 II = 0 11710 DO 50 I = 1, N 11711 I1 = II + 1 11712 II = II + I 11713 M = 1 11714 IF (I .EQ. 1) GO TO 30 11715 IIM1 = II - 1 11716 DO 20 J = I1, IIM1 11717 LJ = L(J) 11718 DO 10 K = I1, J 11719 A(M) = A(M) + LJ*L(K) 11720 M = M + 1 11721 10 CONTINUE 11722 20 CONTINUE 11723 30 LII = L(II) 11724 DO 40 J = I1, II 11725 A(J) = LII * L(J) 11726 40 CONTINUE 11727 50 CONTINUE 11728C 11729 RETURN 11730C *** LAST CARD OF DL7TSQ FOLLOWS *** 11731 END 11732 DOUBLE PRECISION FUNCTION DRLDST(P, D, X, X0) 11733C 11734C *** COMPUTE AND RETURN RELATIVE DIFFERENCE BETWEEN X AND X0 *** 11735C *** NL2SOL VERSION 2.2 *** 11736C 11737 INTEGER P 11738 DOUBLE PRECISION D(P), X(P), X0(P) 11739C 11740 INTEGER I 11741 DOUBLE PRECISION EMAX, T, XMAX, ZERO 11742 PARAMETER (ZERO=0.D+0) 11743C 11744C *** BODY *** 11745C 11746 EMAX = ZERO 11747 XMAX = ZERO 11748 DO 10 I = 1, P 11749 T = DABS(D(I) * (X(I) - X0(I))) 11750 IF (EMAX .LT. T) EMAX = T 11751 T = D(I) * (DABS(X(I)) + DABS(X0(I))) 11752 IF (XMAX .LT. T) XMAX = T 11753 10 CONTINUE 11754 DRLDST = ZERO 11755 IF (XMAX .GT. ZERO) DRLDST = EMAX / XMAX 11756 RETURN 11757C *** LAST CARD OF DRLDST FOLLOWS *** 11758 END 11759 SUBROUTINE DRN2GB(B, D, DR, IV, LIV, LV, N, ND, N1, N2, P, R, 11760 1 RD, V, X) 11761C 11762C *** REVISED ITERATION DRIVER FOR NL2SOL WITH SIMPLE BOUNDS *** 11763C 11764 INTEGER LIV, LV, N, ND, N1, N2, P 11765 INTEGER IV(LIV) 11766 DOUBLE PRECISION B(2,P), D(P), DR(ND,P), R(ND), RD(ND), V(LV), 11767 1 X(P) 11768C 11769C-------------------------- PARAMETER USAGE -------------------------- 11770C 11771C B........ BOUNDS ON X. 11772C D........ SCALE VECTOR. 11773C DR....... DERIVATIVES OF R AT X. 11774C IV....... INTEGER VALUES ARRAY. 11775C LIV...... LENGTH OF IV... LIV MUST BE AT LEAST 4*P + 82. 11776C LV....... LENGTH OF V... LV MUST BE AT LEAST 105 + P*(2*P+20). 11777C N........ TOTAL NUMBER OF RESIDUALS. 11778C ND....... MAX. NO. OF RESIDUALS PASSED ON ONE CALL. 11779C N1....... LOWEST ROW INDEX FOR RESIDUALS SUPPLIED THIS TIME. 11780C N2....... HIGHEST ROW INDEX FOR RESIDUALS SUPPLIED THIS TIME. 11781C P........ NUMBER OF PARAMETERS (COMPONENTS OF X) BEING ESTIMATED. 11782C R........ RESIDUALS. 11783C V........ FLOATING-POINT VALUES ARRAY. 11784C X........ PARAMETER VECTOR BEING ESTIMATED (INPUT = INITIAL GUESS, 11785C OUTPUT = BEST VALUE FOUND). 11786C 11787C *** DISCUSSION *** 11788C 11789C THIS ROUTINE CARRIES OUT ITERATIONS FOR SOLVING NONLINEAR 11790C LEAST SQUARES PROBLEMS. IT IS SIMILAR TO DRN2G, EXCEPT THAT 11791C THIS ROUTINE ENFORCES THE BOUNDS B(1,I) .LE. X(I) .LE. B(2,I), 11792C I = 1(1)P. 11793C 11794C *** GENERAL *** 11795C 11796C CODED BY DAVID M. GAY. 11797C 11798C+++++++++++++++++++++++++++++ DECLARATIONS ++++++++++++++++++++++++++ 11799C 11800C *** EXTERNAL FUNCTIONS AND SUBROUTINES *** 11801C 11802 DOUBLE PRECISION DD7TPR, DV2NRM 11803 EXTERNAL DIVSET, DD7TPR,DD7UPD, DG7ITB,DITSUM,DL7VML, DQ7APL, 11804 1 DQ7RAD, DR7TVM,DV7CPY, DV7SCP, DV2NRM 11805C 11806C DIVSET.... PROVIDES DEFAULT IV AND V INPUT COMPONENTS. 11807C DD7TPR... COMPUTES INNER PRODUCT OF TWO VECTORS. 11808C DD7UPD... UPDATES SCALE VECTOR D. 11809C DG7ITB... PERFORMS BASIC MINIMIZATION ALGORITHM. 11810C DITSUM.... PRINTS ITERATION SUMMARY, INFO ABOUT INITIAL AND FINAL X. 11811C DL7VML.... COMPUTES L * V, V = VECTOR, L = LOWER TRIANGULAR MATRIX. 11812C DQ7APL... APPLIES QR TRANSFORMATIONS STORED BY DQ7RAD. 11813C DQ7RAD.... ADDS A NEW BLOCK OF ROWS TO QR DECOMPOSITION. 11814C DR7TVM... MULT. VECTOR BY TRANS. OF UPPER TRIANG. MATRIX FROM QR FACT. 11815C DV7CPY.... COPIES ONE VECTOR TO ANOTHER. 11816C DV7SCP... SETS ALL ELEMENTS OF A VECTOR TO A SCALAR. 11817C DV2NRM... RETURNS THE 2-NORM OF A VECTOR. 11818C 11819C 11820C *** LOCAL VARIABLES *** 11821C 11822 INTEGER G1, GI, I, IV1, IVMODE, JTOL1, L, LH, NN, QTR1, 11823 1 RD1, RMAT1, YI, Y1 11824 DOUBLE PRECISION T 11825C 11826 DOUBLE PRECISION HALF, ZERO 11827C 11828C *** SUBSCRIPTS FOR IV AND V *** 11829C 11830 INTEGER DINIT, DTYPE, DTINIT, D0INIT, F, G, JCN, JTOL, MODE, 11831 1 NEXTV, NF0, NF00, NF1, NFCALL, NFCOV, NFGCAL, QTR, RDREQ, 11832 1 REGD, RESTOR, RLIMIT, RMAT, TOOBIG, VNEED 11833C 11834C *** IV SUBSCRIPT VALUES *** 11835C 11836 PARAMETER (DTYPE=16, G=28, JCN=66, JTOL=59, MODE=35, NEXTV=47, 11837 1 NF0=68, NF00=81, NF1=69, NFCALL=6, NFCOV=52, NFGCAL=7, 11838 2 QTR=77, RDREQ=57, RESTOR=9, REGD=67, RMAT=78, TOOBIG=2, 11839 3 VNEED=4) 11840C 11841C *** V SUBSCRIPT VALUES *** 11842C 11843 PARAMETER (DINIT=38, DTINIT=39, D0INIT=40, F=10, RLIMIT=46) 11844 PARAMETER (HALF=0.5D+0, ZERO=0.D+0) 11845C 11846C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 11847C 11848 LH = P * (P+1) / 2 11849 IF (IV(1) .EQ. 0) CALL DIVSET(1, IV, LIV, LV, V) 11850 IV1 = IV(1) 11851 IF (IV1 .GT. 2) GO TO 10 11852 NN = N2 - N1 + 1 11853 IV(RESTOR) = 0 11854 I = IV1 + 4 11855 IF (IV(TOOBIG) .EQ. 0) THEN 11856C GO TO (150, 130, 150, 120, 120, 150), I 11857 select case(I) 11858 case(1,3,6) 11859 goto 150 11860 case(2) 11861 goto 130 11862 case(4,5) 11863 goto 120 11864 end select 11865 END IF 11866 IF (I .NE. 5) IV(1) = 2 11867 GO TO 40 11868C 11869C *** FRESH START OR RESTART -- CHECK INPUT INTEGERS *** 11870C 11871 10 IF (ND .LE. 0) GO TO 220 11872 IF (P .LE. 0) GO TO 220 11873 IF (N .LE. 0) GO TO 220 11874 IF (IV1 .EQ. 14) GO TO 30 11875 IF (IV1 .GT. 16) GO TO 270 11876 IF (IV1 .LT. 12) GO TO 40 11877 IF (IV1 .EQ. 12) IV(1) = 13 11878 IF (IV(1) .NE. 13) GO TO 20 11879 IV(VNEED) = IV(VNEED) + P*(P+15)/2 11880 20 CALL DG7ITB(B, D, X, IV, LIV, LV, P, P, V, X, X) 11881 IF (IV(1) .NE. 14) GO TO 999 11882C 11883C *** STORAGE ALLOCATION *** 11884C 11885 IV(G) = IV(NEXTV) 11886 IV(JCN) = IV(G) + 2*P 11887 IV(RMAT) = IV(JCN) + P 11888 IV(QTR) = IV(RMAT) + LH 11889 IV(JTOL) = IV(QTR) + 2*P 11890 IV(NEXTV) = IV(JTOL) + 2*P 11891C *** TURN OFF COVARIANCE COMPUTATION *** 11892 IV(RDREQ) = 0 11893 IF (IV1 .EQ. 13) GO TO 999 11894C 11895 30 JTOL1 = IV(JTOL) 11896 IF (V(DINIT) .GE. ZERO) CALL DV7SCP(P, D, V(DINIT)) 11897 IF (V(DTINIT) .GT. ZERO) CALL DV7SCP(P, V(JTOL1), V(DTINIT)) 11898 I = JTOL1 + P 11899 IF (V(D0INIT) .GT. ZERO) CALL DV7SCP(P, V(I), V(D0INIT)) 11900 IV(NF0) = 0 11901 IV(NF1) = 0 11902 IF (ND .GE. N) GO TO 40 11903C 11904C *** SPECIAL CASE HANDLING OF FIRST FUNCTION AND GRADIENT EVALUATION 11905C *** -- ASK FOR BOTH RESIDUAL AND JACOBIAN AT ONCE 11906C 11907 G1 = IV(G) 11908 Y1 = G1 + P 11909 CALL DG7ITB(B, D, V(G1), IV, LIV, LV, P, P, V, X, V(Y1)) 11910 IF (IV(1) .NE. 1) GO TO 260 11911 V(F) = ZERO 11912 CALL DV7SCP(P, V(G1), ZERO) 11913 IV(1) = -1 11914 QTR1 = IV(QTR) 11915 CALL DV7SCP(P, V(QTR1), ZERO) 11916 IV(REGD) = 0 11917 RMAT1 = IV(RMAT) 11918 GO TO 100 11919C 11920 40 G1 = IV(G) 11921 Y1 = G1 + P 11922 CALL DG7ITB(B, D, V(G1), IV, LIV, LV, P, P, V, X, V(Y1)) 11923 IF (IV(1) .EQ. 2) GO TO 60 11924 IF (IV(1) .GT. 2) GO TO 260 11925C 11926 V(F) = ZERO 11927 IF (IV(NF1) .EQ. 0) GO TO 240 11928 IF (IV(RESTOR) .NE. 2) GO TO 240 11929 IV(NF0) = IV(NF1) 11930 CALL DV7CPY(N, RD, R) 11931 IV(REGD) = 0 11932 GO TO 240 11933C 11934 60 CALL DV7SCP(P, V(G1), ZERO) 11935 IF (IV(MODE) .GT. 0) GO TO 230 11936 RMAT1 = IV(RMAT) 11937 QTR1 = IV(QTR) 11938 RD1 = QTR1 + P 11939 CALL DV7SCP(P, V(QTR1), ZERO) 11940 IV(REGD) = 0 11941 IF (ND .LT. N) GO TO 90 11942 IF (N1 .NE. 1) GO TO 90 11943 IF (IV(MODE) .LT. 0) GO TO 100 11944 IF (IV(NF1) .EQ. IV(NFGCAL)) GO TO 70 11945 IF (IV(NF0) .NE. IV(NFGCAL)) GO TO 90 11946 CALL DV7CPY(N, R, RD) 11947 GO TO 80 11948 70 CALL DV7CPY(N, RD, R) 11949 80 CALL DQ7APL(ND, N, P, DR, RD, 0) 11950 CALL DR7TVM(ND, MIN0(N,P), V(Y1), V(RD1), DR, RD) 11951 IV(REGD) = 0 11952 GO TO 110 11953C 11954 90 IV(1) = -2 11955 IF (IV(MODE) .LT. 0) IV(1) = -3 11956 100 CALL DV7SCP(P, V(Y1), ZERO) 11957 110 CALL DV7SCP(LH, V(RMAT1), ZERO) 11958 GO TO 240 11959C 11960C *** COMPUTE F(X) *** 11961C 11962 120 T = DV2NRM(NN, R) 11963 IF (T .GT. V(RLIMIT)) GO TO 210 11964 V(F) = V(F) + HALF * T**2 11965 IF (N2 .LT. N) GO TO 250 11966 IF (N1 .EQ. 1) IV(NF1) = IV(NFCALL) 11967 GO TO 40 11968C 11969C *** COMPUTE Y *** 11970C 11971 130 Y1 = IV(G) + P 11972 YI = Y1 11973 DO 140 L = 1, P 11974 V(YI) = V(YI) + DD7TPR(NN, DR(1,L), R) 11975 YI = YI + 1 11976 140 CONTINUE 11977 IF (N2 .LT. N) GO TO 250 11978 IV(1) = 2 11979 IF (N1 .GT. 1) IV(1) = -3 11980 GO TO 240 11981C 11982C *** COMPUTE GRADIENT INFORMATION *** 11983C 11984 150 G1 = IV(G) 11985 IVMODE = IV(MODE) 11986 IF (IVMODE .LT. 0) GO TO 170 11987 IF (IVMODE .EQ. 0) GO TO 180 11988 IV(1) = 2 11989C 11990C *** COMPUTE GRADIENT ONLY (FOR USE IN COVARIANCE COMPUTATION) *** 11991C 11992 GI = G1 11993 DO 160 L = 1, P 11994 V(GI) = V(GI) + DD7TPR(NN, R, DR(1,L)) 11995 GI = GI + 1 11996 160 CONTINUE 11997 GO TO 200 11998C 11999C *** COMPUTE INITIAL FUNCTION VALUE WHEN ND .LT. N *** 12000C 12001 170 IF (N .LE. ND) GO TO 180 12002 T = DV2NRM(NN, R) 12003 IF (T .GT. V(RLIMIT)) GO TO 210 12004 V(F) = V(F) + HALF * T**2 12005C 12006C *** UPDATE D IF DESIRED *** 12007C 12008 180 IF (IV(DTYPE) .GT. 0) 12009 1 CALL DD7UPD(D, DR, IV, LIV, LV, N, ND, NN, N2, P, V) 12010C 12011C *** COMPUTE RMAT AND QTR *** 12012C 12013 QTR1 = IV(QTR) 12014 RMAT1 = IV(RMAT) 12015 CALL DQ7RAD(NN, ND, P, V(QTR1), .TRUE., V(RMAT1), DR, R) 12016 IV(NF1) = 0 12017 IF (N1 .GT. 1) GO TO 200 12018 IF (N2 .LT. N) GO TO 250 12019C 12020C *** SAVE DIAGONAL OF R FOR COMPUTING Y LATER *** 12021C 12022 RD1 = QTR1 + P 12023 L = RMAT1 - 1 12024 DO 190 I = 1, P 12025 L = L + I 12026 V(RD1) = V(L) 12027 RD1 = RD1 + 1 12028 190 CONTINUE 12029C 12030 200 IF (N2 .LT. N) GO TO 250 12031 IF (IVMODE .GT. 0) GO TO 40 12032 IV(NF00) = IV(NFGCAL) 12033C 12034C *** COMPUTE G FROM RMAT AND QTR *** 12035C 12036 CALL DL7VML(P, V(G1), V(RMAT1), V(QTR1)) 12037 IV(1) = 2 12038 IF (IVMODE .EQ. 0) GO TO 40 12039 IF (N .LE. ND) GO TO 40 12040C 12041C *** FINISH SPECIAL CASE HANDLING OF FIRST FUNCTION AND GRADIENT 12042C 12043 Y1 = G1 + P 12044 IV(1) = 1 12045 CALL DG7ITB(B, D, V(G1), IV, LIV, LV, P, P, V, X, V(Y1)) 12046 IF (IV(1) .NE. 2) GO TO 260 12047 GO TO 40 12048C 12049C *** MISC. DETAILS *** 12050C 12051C *** X IS OUT OF RANGE (OVERSIZE STEP) *** 12052C 12053 210 IV(TOOBIG) = 1 12054 GO TO 40 12055C 12056C *** BAD N, ND, OR P *** 12057C 12058 220 IV(1) = 66 12059 GO TO 260 12060C 12061C *** RECORD EXTRA EVALUATIONS FOR FINITE-DIFFERENCE HESSIAN *** 12062C 12063 230 IV(NFCOV) = IV(NFCOV) + 1 12064 IV(NFCALL) = IV(NFCALL) + 1 12065 IV(NFGCAL) = IV(NFCALL) 12066 IV(1) = -1 12067C 12068C *** RETURN FOR MORE FUNCTION OR GRADIENT INFORMATION *** 12069C 12070 240 N2 = 0 12071 250 N1 = N2 + 1 12072 N2 = N2 + ND 12073 IF (N2 .GT. N) N2 = N 12074 GO TO 999 12075C 12076C *** PRINT SUMMARY OF FINAL ITERATION AND OTHER REQUESTED ITEMS *** 12077C 12078 260 G1 = IV(G) 12079 270 CALL DITSUM(D, V(G1), IV, LIV, LV, P, V, X) 12080C 12081 999 RETURN 12082C *** LAST CARD OF DRN2GB FOLLOWS *** 12083 END 12084 SUBROUTINE DD7DGB(B, D, DIG, DST, G, IPIV, KA, L, LV, P, PC, 12085 1 NWTST, STEP, TD, TG, V, W, X0) 12086C 12087C *** COMPUTE DOUBLE-DOGLEG STEP, SUBJECT TO SIMPLE BOUNDS ON X *** 12088C 12089 INTEGER LV, KA, P, PC 12090 INTEGER IPIV(P) 12091 DOUBLE PRECISION B(2,P), D(P), DIG(P), DST(P), G(P), L(*), 12092 1 NWTST(P), STEP(P), TD(P), TG(P), V(LV), W(P), 12093 2 X0(P) 12094C 12095C DIMENSION L(P*(P+1)/2) 12096C 12097 DOUBLE PRECISION DD7TPR, DR7MDC, DV2NRM 12098 EXTERNAL DD7DOG, DD7TPR, I7SHFT, DL7ITV, DL7IVM, DL7TVM,DL7VML, 12099 1 DQ7RSH, DR7MDC, DV2NRM,DV2AXY,DV7CPY, DV7IPR, DV7SCP, 12100 2 DV7SHF, DV7VMP 12101C 12102C *** LOCAL VARIABLES *** 12103C 12104 INTEGER I, J, K, P1, P1M1 12105 DOUBLE PRECISION DNWTST, GHINVG, GNORM, GNORM0, NRED, PRED, RAD, 12106 1 T, T1, T2, TI, X0I, XI 12107 DOUBLE PRECISION HALF, MEPS2, ONE, TWO, ZERO 12108C 12109C *** V SUBSCRIPTS *** 12110C 12111 INTEGER DGNORM, DST0, DSTNRM, GRDFAC, GTHG, GTSTEP, NREDUC, 12112 1 NWTFAC, PREDUC, RADIUS, STPPAR 12113C 12114 PARAMETER (DGNORM=1, DST0=3, DSTNRM=2, GRDFAC=45, GTHG=44, 12115 1 GTSTEP=4, NREDUC=6, NWTFAC=46, PREDUC=7, RADIUS=8, 12116 2 STPPAR=5) 12117 PARAMETER (HALF=0.5D+0, ONE=1.D+0, TWO=2.D+0, ZERO=0.D+0) 12118 SAVE MEPS2 12119 DATA MEPS2/0.D+0/ 12120C 12121C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 12122C 12123 IF (MEPS2 .LE. ZERO) MEPS2 = TWO * DR7MDC(3) 12124 GNORM0 = V(DGNORM) 12125 V(DSTNRM) = ZERO 12126 IF (KA .LT. 0) GO TO 10 12127 DNWTST = V(DST0) 12128 NRED = V(NREDUC) 12129 10 PRED = ZERO 12130 V(STPPAR) = ZERO 12131 RAD = V(RADIUS) 12132 IF (PC .GT. 0) GO TO 20 12133 DNWTST = ZERO 12134 CALL DV7SCP(P, STEP, ZERO) 12135 GO TO 140 12136C 12137 20 P1 = PC 12138 CALL DV7CPY(P, TD, D) 12139 CALL DV7IPR(P, IPIV, TD) 12140 CALL DV7SCP(PC, DST, ZERO) 12141 CALL DV7CPY(P, TG, G) 12142 CALL DV7IPR(P, IPIV, TG) 12143C 12144 30 CALL DL7IVM(P1, NWTST, L, TG) 12145 GHINVG = DD7TPR(P1, NWTST, NWTST) 12146 V(NREDUC) = HALF * GHINVG 12147 CALL DL7ITV(P1, NWTST, L, NWTST) 12148 CALL DV7VMP(P1, STEP, NWTST, TD, 1) 12149 V(DST0) = DV2NRM(PC, STEP) 12150 IF (KA .GE. 0) GO TO 40 12151 KA = 0 12152 DNWTST = V(DST0) 12153 NRED = V(NREDUC) 12154 40 V(RADIUS) = RAD - V(DSTNRM) 12155 IF (V(RADIUS) .LE. ZERO) GO TO 100 12156 CALL DV7VMP(P1, DIG, TG, TD, -1) 12157 GNORM = DV2NRM(P1, DIG) 12158 IF (GNORM .LE. ZERO) GO TO 100 12159 V(DGNORM) = GNORM 12160 CALL DV7VMP(P1, DIG, DIG, TD, -1) 12161 CALL DL7TVM(P1, W, L, DIG) 12162 V(GTHG) = DV2NRM(P1, W) 12163 KA = KA + 1 12164 CALL DD7DOG(DIG, LV, P1, NWTST, STEP, V) 12165C 12166C *** FIND T SUCH THAT X - T*STEP IS STILL FEASIBLE. 12167C 12168 T = ONE 12169 K = 0 12170 DO 70 I = 1, P1 12171 J = IPIV(I) 12172 X0I = X0(J) + DST(I)/TD(I) 12173 XI = X0I + STEP(I) 12174 IF (XI .LT. B(1,J)) GO TO 50 12175 IF (XI .LE. B(2,J)) GO TO 70 12176 TI = (B(2,J) - X0I) / STEP(I) 12177 J = I 12178 GO TO 60 12179 50 TI = (B(1,J) - X0I) / STEP(I) 12180 J = -I 12181 60 IF (T .LE. TI) GO TO 70 12182 K = J 12183 T = TI 12184 70 CONTINUE 12185C 12186C *** UPDATE DST, TG, AND PRED *** 12187C 12188 CALL DV7VMP(P1, STEP, STEP, TD, 1) 12189 CALL DV2AXY(P1, DST, T, STEP, DST) 12190 V(DSTNRM) = DV2NRM(PC, DST) 12191 T1 = T * V(GRDFAC) 12192 T2 = T * V(NWTFAC) 12193 PRED = PRED - T1*GNORM * ((T2 + ONE)*GNORM) 12194 1 - T2 * (ONE + HALF*T2)*GHINVG 12195 2 - HALF * (V(GTHG)*T1)**2 12196 IF (K .EQ. 0) GO TO 100 12197 CALL DL7VML(P1, W, L, W) 12198 T2 = ONE - T2 12199 DO 80 I = 1, P1 12200 TG(I) = T2*TG(I) - T1*W(I) 12201 80 CONTINUE 12202C 12203C *** PERMUTE L, ETC. IF NECESSARY *** 12204C 12205 P1M1 = P1 - 1 12206 J = IABS(K) 12207 IF (J .EQ. P1) GO TO 90 12208 CALL DQ7RSH(J, P1, .FALSE., TG, L, W) 12209 CALL I7SHFT(P1, J, IPIV) 12210 CALL DV7SHF(P1, J, TG) 12211 CALL DV7SHF(P1, J, TD) 12212 CALL DV7SHF(P1, J, DST) 12213 90 IF (K .LT. 0) IPIV(P1) = -IPIV(P1) 12214 P1 = P1M1 12215 IF (P1 .GT. 0) GO TO 30 12216C 12217C *** UNSCALE STEP, UPDATE X AND DIHDI *** 12218C 12219 100 CALL DV7SCP(P, STEP, ZERO) 12220 DO 110 I = 1, PC 12221 J = IABS(IPIV(I)) 12222 STEP(J) = DST(I) / TD(I) 12223 110 CONTINUE 12224C 12225C *** FUDGE STEP TO ENSURE THAT IT FORCES APPROPRIATE COMPONENTS 12226C *** TO THEIR BOUNDS *** 12227C 12228 IF (P1 .GE. PC) GO TO 140 12229 CALL DV2AXY(P, TD, ONE, STEP, X0) 12230 K = P1 + 1 12231 DO 130 I = K, PC 12232 J = IPIV(I) 12233 T = MEPS2 12234 IF (J .GT. 0) GO TO 120 12235 T = -T 12236 J = -J 12237 IPIV(I) = J 12238 120 T = T * DMAX1(DABS(TD(J)), DABS(X0(J))) 12239 STEP(J) = STEP(J) + T 12240 130 CONTINUE 12241C 12242 140 V(DGNORM) = GNORM0 12243 V(NREDUC) = NRED 12244 V(PREDUC) = PRED 12245 V(RADIUS) = RAD 12246 V(DST0) = DNWTST 12247 V(GTSTEP) = DD7TPR(P, STEP, G) 12248C 12249 RETURN 12250C *** LAST LINE OF DD7DGB FOLLOWS *** 12251 END 12252 SUBROUTINE DQ7RFH(IERR, IPIVOT, N, NN, NOPIVK, P, Q, R, RLEN, W) 12253C 12254C *** COMPUTE QR FACTORIZATION VIA HOUSEHOLDER TRANSFORMATIONS 12255C *** WITH COLUMN PIVOTING *** 12256C 12257C *** PARAMETER DECLARATIONS *** 12258C 12259 INTEGER IERR, N, NN, NOPIVK, P, RLEN 12260 INTEGER IPIVOT(P) 12261 DOUBLE PRECISION Q(NN,P), R(RLEN), W(P) 12262C DIMENSION R(P*(P+1)/2) 12263C 12264C---------------------------- DESCRIPTION ---------------------------- 12265C 12266C THIS ROUTINE COMPUTES A QR FACTORIZATION (VIA HOUSEHOLDER TRANS- 12267C FORMATIONS) OF THE MATRIX A THAT ON INPUT IS STORED IN Q. 12268C IF NOPIVK ALLOWS IT, THIS ROUTINE DOES COLUMN PIVOTING -- IF 12269C K .GT. NOPIVK, THEN ORIGINAL COLUMN K IS ELIGIBLE FOR PIVOTING. 12270C THE Q AND R RETURNED ARE SUCH THAT COLUMN I OF Q*R EQUALS 12271C COLUMN IPIVOT(I) OF THE ORIGINAL MATRIX A. THE UPPER TRIANGULAR 12272C MATRIX R IS STORED COMPACTLY BY COLUMNS, I.E., THE OUTPUT VECTOR R 12273C CONTAINS R(1,1), R(1,2), R(2,2), R(1,3), R(2,3), ..., R(P,P) (IN 12274C THAT ORDER). IF ALL GOES WELL, THEN THIS ROUTINE SETS IERR = 0. 12275C BUT IF (PERMUTED) COLUMN K OF A IS LINEARLY DEPENDENT ON 12276C (PERMUTED) COLUMNS 1,2,...,K-1, THEN IERR IS SET TO K AND THE R 12277C MATRIX RETURNED HAS R(I,J) = 0 FOR I .GE. K AND J .GE. K. 12278C THE ORIGINAL MATRIX A IS AN N BY P MATRIX. NN IS THE LEAD 12279C DIMENSION OF THE ARRAY Q AND MUST SATISFY NN .GE. N. NO 12280C PARAMETER CHECKING IS DONE. 12281C PIVOTING IS DONE AS THOUGH ALL COLUMNS OF Q WERE FIRST 12282C SCALED TO HAVE THE SAME NORM. IF COLUMN K IS ELIGIBLE FOR 12283C PIVOTING AND ITS (SCALED) NORM**2 LOSS IS MORE THAN THE 12284C MINIMUM SUCH LOSS (OVER COLUMNS K THRU P), THEN COLUMN K IS 12285C SWAPPED WITH THE COLUMN OF LEAST NORM**2 LOSS. 12286C 12287C CODED BY DAVID M. GAY (FALL 1979, SPRING 1984). 12288C 12289C-------------------------- LOCAL VARIABLES -------------------------- 12290C 12291 INTEGER I, II, J, K, KK, KM1, KP1, NK1 12292 DOUBLE PRECISION AK, QKK, S, SINGTL, T, T1, WK 12293 DOUBLE PRECISION DD7TPR, DR7MDC, DV2NRM 12294 EXTERNAL DD7TPR, DR7MDC,DV2AXY, DV7SCL, DV7SCP,DV7SWP, DV2NRM 12295C/+ 12296 DOUBLE PRECISION DSQRT 12297C/ 12298 DOUBLE PRECISION BIG, BIGRT, MEPS10, ONE, TEN, TINY, TINYRT, 12299 1 WTOL, ZERO 12300 PARAMETER (ONE=1.0D+0, TEN=1.D+1, WTOL=0.75D+0, ZERO=0.0D+0) 12301 SAVE BIGRT, MEPS10, TINY, TINYRT 12302 DATA BIGRT/0.0D+0/, MEPS10/0.0D+0/, TINY/0.D+0/, TINYRT/0.D+0/ 12303C 12304C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 12305C 12306 IERR = 0 12307 IF (MEPS10 .GT. ZERO) GO TO 10 12308 BIGRT = DR7MDC(5) 12309 MEPS10 = TEN * DR7MDC(3) 12310 TINYRT = DR7MDC(2) 12311 TINY = DR7MDC(1) 12312 BIG = DR7MDC(6) 12313 IF (TINY*BIG .LT. ONE) TINY = ONE / BIG 12314 10 SINGTL = DBLE(MAX0(N,P)) * MEPS10 12315C 12316C *** INITIALIZE W, IPIVOT, AND DIAG(R) *** 12317C 12318 J = 0 12319 DO 40 I = 1, P 12320 IPIVOT(I) = I 12321 T = DV2NRM(N, Q(1,I)) 12322 IF (T .GT. ZERO) GO TO 20 12323 W(I) = ONE 12324 GO TO 30 12325 20 W(I) = ZERO 12326 30 J = J + I 12327 R(J) = T 12328 40 CONTINUE 12329C 12330C *** MAIN LOOP *** 12331C 12332 KK = 0 12333 NK1 = N + 1 12334 DO 130 K = 1, P 12335 IF (NK1 .LE. 1) GO TO 999 12336 NK1 = NK1 - 1 12337 KK = KK + K 12338 KP1 = K + 1 12339 IF (K .LE. NOPIVK) GO TO 60 12340 IF (K .GE. P) GO TO 60 12341C 12342C *** FIND COLUMN WITH MINIMUM WEIGHT LOSS *** 12343C 12344 T = W(K) 12345 IF (T .LE. ZERO) GO TO 60 12346 J = K 12347 DO 50 I = KP1, P 12348 IF (W(I) .GE. T) GO TO 50 12349 T = W(I) 12350 J = I 12351 50 CONTINUE 12352 IF (J .EQ. K) GO TO 60 12353C 12354C *** INTERCHANGE COLUMNS K AND J *** 12355C 12356 I = IPIVOT(K) 12357 IPIVOT(K) = IPIVOT(J) 12358 IPIVOT(J) = I 12359 W(J) = W(K) 12360 W(K) = T 12361 I = J*(J+1)/2 12362 T1 = R(I) 12363 R(I) = R(KK) 12364 R(KK) = T1 12365 CALL DV7SWP(N, Q(1,K), Q(1,J)) 12366 IF (K .LE. 1) GO TO 60 12367 I = I - J + 1 12368 J = KK - K + 1 12369 CALL DV7SWP(K-1, R(I), R(J)) 12370C 12371C *** COLUMN K OF Q SHOULD BE NEARLY ORTHOGONAL TO THE PREVIOUS 12372C *** COLUMNS. NORMALIZE IT, TEST FOR SINGULARITY, AND DECIDE 12373C *** WHETHER TO REORTHOGONALIZE IT. 12374C 12375 60 AK = R(KK) 12376 IF (AK .LE. ZERO) GO TO 140 12377 WK = W(K) 12378C 12379C *** SET T TO THE NORM OF (Q(K,K),...,Q(N,K)) 12380C *** AND CHECK FOR SINGULARITY. 12381C 12382 IF (WK .LT. WTOL) GO TO 70 12383 T = DV2NRM(NK1, Q(K,K)) 12384 IF (T / AK .LE. SINGTL) GO TO 140 12385 GO TO 80 12386 70 T = DSQRT(ONE - WK) 12387 IF (T .LE. SINGTL) GO TO 140 12388 T = T * AK 12389C 12390C *** DETERMINE HOUSEHOLDER TRANSFORMATION *** 12391C 12392 80 QKK = Q(K,K) 12393 IF (T .LE. TINYRT) GO TO 90 12394 IF (T .GE. BIGRT) GO TO 90 12395 IF (QKK .LT. ZERO) T = -T 12396 QKK = QKK + T 12397 S = DSQRT(T * QKK) 12398 GO TO 110 12399 90 S = DSQRT(T) 12400 IF (QKK .LT. ZERO) GO TO 100 12401 QKK = QKK + T 12402 S = S * DSQRT(QKK) 12403 GO TO 110 12404 100 T = -T 12405 QKK = QKK + T 12406 S = S * DSQRT(-QKK) 12407 110 Q(K,K) = QKK 12408C 12409C *** SCALE (Q(K,K),...,Q(N,K)) TO HAVE NORM SQRT(2) *** 12410C 12411 IF (S .LE. TINY) GO TO 140 12412 CALL DV7SCL(NK1, Q(K,K), ONE/S, Q(K,K)) 12413C 12414 R(KK) = -T 12415C 12416C *** COMPUTE R(K,I) FOR I = K+1,...,P AND UPDATE Q *** 12417C 12418 IF (K .GE. P) GO TO 999 12419 J = KK + K 12420 II = KK 12421 DO 120 I = KP1, P 12422 II = II + I 12423 CALL DV2AXY(NK1, Q(K,I), -DD7TPR(NK1,Q(K,K),Q(K,I)), 12424 1 Q(K,K), Q(K,I)) 12425 T = Q(K,I) 12426 R(J) = T 12427 J = J + I 12428 T1 = R(II) 12429 IF (T1 .GT. ZERO) W(I) = W(I) + (T/T1)**2 12430 120 CONTINUE 12431 130 CONTINUE 12432C 12433C *** SINGULAR Q *** 12434C 12435 140 IERR = K 12436 KM1 = K - 1 12437 J = KK 12438 DO 150 I = K, P 12439 CALL DV7SCP(I-KM1, R(J), ZERO) 12440 J = J + I 12441 150 CONTINUE 12442C 12443 999 RETURN 12444C *** LAST CARD OF DQ7RFH FOLLOWS *** 12445 END 12446 SUBROUTINE DF7DHB(B, D, G, IRT, IV, LIV, LV, P, V, X) 12447C 12448C *** COMPUTE FINITE-DIFFERENCE HESSIAN, STORE IT IN V STARTING 12449C *** AT V(IV(FDH)) = V(-IV(H)). HONOR SIMPLE BOUNDS IN B. 12450C 12451C *** IF IV(COVREQ) .GE. 0 THEN DF7DHB USES GRADIENT DIFFERENCES, 12452C *** OTHERWISE FUNCTION DIFFERENCES. STORAGE IN V IS AS IN DG7LIT. 12453C 12454C IRT VALUES... 12455C 1 = COMPUTE FUNCTION VALUE, I.E., V(F). 12456C 2 = COMPUTE G. 12457C 3 = DONE. 12458C 12459C 12460C *** PARAMETER DECLARATIONS *** 12461C 12462 INTEGER IRT, LIV, LV, P 12463 INTEGER IV(LIV) 12464 DOUBLE PRECISION B(2,P), D(P), G(P), V(LV), X(P) 12465C 12466C *** LOCAL VARIABLES *** 12467C 12468 LOGICAL OFFSID 12469 INTEGER GSAVE1, HES, HMI, HPI, HPM, I, K, KIND, L, M, MM1, MM1O2, 12470 1 NEWM1, PP1O2, STPI, STPM, STP0 12471 DOUBLE PRECISION DEL, DEL0, T, XM, XM1 12472 DOUBLE PRECISION HALF, HLIM, ONE, TWO, ZERO 12473C 12474C *** EXTERNAL SUBROUTINES *** 12475C 12476 EXTERNAL DV7CPY, DV7SCP 12477C 12478C DV7CPY.... COPY ONE VECTOR TO ANOTHER. 12479C DV7SCP... COPY SCALAR TO ALL COMPONENTS OF A VECTOR. 12480C 12481C *** SUBSCRIPTS FOR IV AND V *** 12482C 12483 INTEGER COVREQ, DELTA, DELTA0, DLTFDC, F, FDH, FX, H, KAGQT, MODE, 12484 1 NFGCAL, SAVEI, SWITCH, TOOBIG, W, XMSAVE 12485C 12486 PARAMETER (HALF=0.5D+0, HLIM=0.1D+0, ONE=1.D+0, TWO=2.D+0, 12487 1 ZERO=0.D+0) 12488C 12489 PARAMETER (COVREQ=15, DELTA=52, DELTA0=44, DLTFDC=42, F=10, 12490 1 FDH=74, FX=53, H=56, KAGQT=33, MODE=35, NFGCAL=7, 12491 2 SAVEI=63, SWITCH=12, TOOBIG=2, W=65, XMSAVE=51) 12492C 12493C+++++++++++++++++++++++++++++++ BODY ++++++++++++++++++++++++++++++++ 12494C 12495 IRT = 4 12496 KIND = IV(COVREQ) 12497 M = IV(MODE) 12498 IF (M .GT. 0) GO TO 10 12499 HES = IABS(IV(H)) 12500 IV(H) = -HES 12501 IV(FDH) = 0 12502 IV(KAGQT) = -1 12503 V(FX) = V(F) 12504C *** SUPPLY ZEROS IN CASE B(1,I) = B(2,I) FOR SOME I *** 12505 CALL DV7SCP(P*(P+1)/2, V(HES), ZERO) 12506 10 IF (M .GT. P) GO TO 999 12507 IF (KIND .LT. 0) GO TO 120 12508C 12509C *** COMPUTE FINITE-DIFFERENCE HESSIAN USING BOTH FUNCTION AND 12510C *** GRADIENT VALUES. 12511C 12512 GSAVE1 = IV(W) + P 12513 IF (M .GT. 0) GO TO 20 12514C *** FIRST CALL ON DF7DHB. SET GSAVE = G, TAKE FIRST STEP *** 12515 CALL DV7CPY(P, V(GSAVE1), G) 12516 IV(SWITCH) = IV(NFGCAL) 12517 GO TO 80 12518C 12519 20 DEL = V(DELTA) 12520 X(M) = V(XMSAVE) 12521 IF (IV(TOOBIG) .EQ. 0) GO TO 30 12522C 12523C *** HANDLE OVERSIZE V(DELTA) *** 12524C 12525 DEL0 = V(DELTA0) * DMAX1(ONE/D(M), DABS(X(M))) 12526 DEL = HALF * DEL 12527 IF (DABS(DEL/DEL0) .LE. HLIM) GO TO 140 12528C 12529 30 HES = -IV(H) 12530C 12531C *** SET G = (G - GSAVE)/DEL *** 12532C 12533 DEL = ONE / DEL 12534 DO 40 I = 1, P 12535 G(I) = DEL * (G(I) - V(GSAVE1)) 12536 GSAVE1 = GSAVE1 + 1 12537 40 CONTINUE 12538C 12539C *** ADD G AS NEW COL. TO FINITE-DIFF. HESSIAN MATRIX *** 12540C 12541 K = HES + M*(M-1)/2 12542 L = K + M - 2 12543 IF (M .EQ. 1) GO TO 60 12544C 12545C *** SET H(I,M) = 0.5 * (H(I,M) + G(I)) FOR I = 1 TO M-1 *** 12546C 12547 MM1 = M - 1 12548 DO 50 I = 1, MM1 12549 IF (B(1,I) .LT. B(2,I)) V(K) = HALF * (V(K) + G(I)) 12550 K = K + 1 12551 50 CONTINUE 12552C 12553C *** ADD H(I,M) = G(I) FOR I = M TO P *** 12554C 12555 60 L = L + 1 12556 DO 70 I = M, P 12557 IF (B(1,I) .LT. B(2,I)) V(L) = G(I) 12558 L = L + I 12559 70 CONTINUE 12560C 12561 80 M = M + 1 12562 IV(MODE) = M 12563 IF (M .GT. P) GO TO 340 12564 IF (B(1,M) .GE. B(2,M)) GO TO 80 12565C 12566C *** CHOOSE NEXT FINITE-DIFFERENCE STEP, RETURN TO GET G THERE *** 12567C 12568 DEL = V(DELTA0) * DMAX1(ONE/D(M), DABS(X(M))) 12569 XM = X(M) 12570 IF (XM .LT. ZERO) GO TO 90 12571 XM1 = XM + DEL 12572 IF (XM1 .LE. B(2,M)) GO TO 110 12573 XM1 = XM - DEL 12574 IF (XM1 .GE. B(1,M)) GO TO 100 12575 GO TO 280 12576 90 XM1 = XM - DEL 12577 IF (XM1 .GE. B(1,M)) GO TO 100 12578 XM1 = XM + DEL 12579 IF (XM1 .LE. B(2,M)) GO TO 110 12580 GO TO 280 12581C 12582 100 DEL = -DEL 12583 110 V(XMSAVE) = XM 12584 X(M) = XM1 12585 V(DELTA) = DEL 12586 IRT = 2 12587 GO TO 999 12588C 12589C *** COMPUTE FINITE-DIFFERENCE HESSIAN USING FUNCTION VALUES ONLY. 12590C 12591 120 STP0 = IV(W) + P - 1 12592 MM1 = M - 1 12593 MM1O2 = M*MM1/2 12594 HES = -IV(H) 12595 IF (M .GT. 0) GO TO 130 12596C *** FIRST CALL ON DF7DHB. *** 12597 IV(SAVEI) = 0 12598 GO TO 240 12599C 12600 130 IF (IV(TOOBIG) .EQ. 0) GO TO 150 12601C *** PUNT IN THE EVENT OF AN OVERSIZE STEP *** 12602 140 IV(FDH) = -2 12603 GO TO 350 12604 150 I = IV(SAVEI) 12605 IF (I .GT. 0) GO TO 190 12606C 12607C *** SAVE F(X + STP(M)*E(M)) IN H(P,M) *** 12608C 12609 PP1O2 = P * (P-1) / 2 12610 HPM = HES + PP1O2 + MM1 12611 V(HPM) = V(F) 12612C 12613C *** START COMPUTING ROW M OF THE FINITE-DIFFERENCE HESSIAN H. *** 12614C 12615 NEWM1 = 1 12616 GO TO 260 12617 160 HMI = HES + MM1O2 12618 IF (MM1 .EQ. 0) GO TO 180 12619 HPI = HES + PP1O2 12620 DO 170 I = 1, MM1 12621 T = ZERO 12622 IF (B(1,I) .LT. B(2,I)) T = V(FX) - (V(F) + V(HPI)) 12623 V(HMI) = T 12624 HMI = HMI + 1 12625 HPI = HPI + 1 12626 170 CONTINUE 12627 180 V(HMI) = V(F) - TWO*V(FX) 12628 IF (OFFSID) V(HMI) = V(FX) - TWO*V(F) 12629C 12630C *** COMPUTE FUNCTION VALUES NEEDED TO COMPLETE ROW M OF H. *** 12631C 12632 I = 0 12633 GO TO 200 12634C 12635 190 X(I) = V(DELTA) 12636C 12637C *** FINISH COMPUTING H(M,I) *** 12638C 12639 STPI = STP0 + I 12640 HMI = HES + MM1O2 + I - 1 12641 STPM = STP0 + M 12642 V(HMI) = (V(HMI) + V(F)) / (V(STPI)*V(STPM)) 12643 200 I = I + 1 12644 IF (I .GT. M) GO TO 230 12645 IF (B(1,I) .LT. B(2,I)) GO TO 210 12646 GO TO 200 12647C 12648 210 IV(SAVEI) = I 12649 STPI = STP0 + I 12650 V(DELTA) = X(I) 12651 X(I) = X(I) + V(STPI) 12652 IRT = 1 12653 IF (I .LT. M) GO TO 999 12654 NEWM1 = 2 12655 GO TO 260 12656 220 X(M) = V(XMSAVE) - DEL 12657 IF (OFFSID) X(M) = V(XMSAVE) + TWO*DEL 12658 GO TO 999 12659C 12660 230 IV(SAVEI) = 0 12661 X(M) = V(XMSAVE) 12662C 12663 240 M = M + 1 12664 IV(MODE) = M 12665 IF (M .GT. P) GO TO 330 12666 IF (B(1,M) .LT. B(2,M)) GO TO 250 12667 GO TO 240 12668C 12669C *** PREPARE TO COMPUTE ROW M OF THE FINITE-DIFFERENCE HESSIAN H. 12670C *** COMPUTE M-TH STEP SIZE STP(M), THEN RETURN TO OBTAIN 12671C *** F(X + STP(M)*E(M)), WHERE E(M) = M-TH STD. UNIT VECTOR. 12672C 12673 250 V(XMSAVE) = X(M) 12674 NEWM1 = 3 12675 260 XM = V(XMSAVE) 12676 DEL = V(DLTFDC) * DMAX1(ONE/D(M), DABS(XM)) 12677 XM1 = XM + DEL 12678 OFFSID = .FALSE. 12679 IF (XM1 .LE. B(2,M)) GO TO 270 12680 OFFSID = .TRUE. 12681 XM1 = XM - DEL 12682 IF (XM - TWO*DEL .GE. B(1,M)) GO TO 300 12683 GO TO 280 12684 270 IF (XM-DEL .GE. B(1,M)) GO TO 290 12685 OFFSID = .TRUE. 12686 IF (XM + TWO*DEL .LE. B(2,M)) GO TO 310 12687C 12688 280 IV(FDH) = -2 12689 GO TO 350 12690C 12691 290 IF (XM .GE. ZERO) GO TO 310 12692 XM1 = XM - DEL 12693 300 DEL = -DEL 12694c 310 GO TO (160, 220, 320), NEWM1 12695 310 continue 12696 select case(NEWM1) 12697 case(1) 12698 goto 160 12699 case(2) 12700 goto 220 12701 case(3) 12702 goto 320 12703 end select 12704 320 X(M) = XM1 12705 STPM = STP0 + M 12706 V(STPM) = DEL 12707 IRT = 1 12708 GO TO 999 12709C 12710C *** HANDLE SPECIAL CASE OF B(1,P) = B(2,P) -- CLEAR SCRATCH VALUES 12711C *** FROM LAST ROW OF FDH... 12712C 12713 330 IF (B(1,P) .LT. B(2,P)) GO TO 340 12714 I = HES + P*(P-1)/2 12715 CALL DV7SCP(P, V(I), ZERO) 12716C 12717C *** RESTORE V(F), ETC. *** 12718C 12719 340 IV(FDH) = HES 12720 350 V(F) = V(FX) 12721 IRT = 3 12722 IF (KIND .LT. 0) GO TO 999 12723 IV(NFGCAL) = IV(SWITCH) 12724 GSAVE1 = IV(W) + P 12725 CALL DV7CPY(P, G, V(GSAVE1)) 12726 GO TO 999 12727C 12728 999 RETURN 12729C *** LAST LINE OF DF7DHB FOLLOWS *** 12730 END 12731