relax4 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/ext/relax4.c ADDED
@@ -0,0 +1,3935 @@
1
+ /**
2
+ * This file was translated by f2c (FORTRAN to C) (version 20090411) from
3
+ * relax4.f (see http://www.netlib.org/f2c).
4
+ *
5
+ * It has been modified (JLM) for use as a library (see relax4.h).
6
+ *
7
+ * The f2c linkage dependencies have been removed, but the FORTRAN character of
8
+ * the code has been largely preserved -- you have been warned.
9
+ */
10
+
11
+ #include "stdlib.h"
12
+ /*#include "stdio.h" */ /* just for tracing*/
13
+ #include "assert.h"
14
+ #include "relax4_f2c.h"
15
+ #include "relax4.h"
16
+
17
+ /* Common Block Declarations */
18
+
19
+ struct {
20
+ integer n, na, large;
21
+ } input_;
22
+
23
+ #define input_1 input_
24
+
25
+ struct {
26
+ integer *startn;
27
+ } arrays_;
28
+
29
+ #define arrays_1 arrays_
30
+
31
+ struct {
32
+ integer *endn;
33
+ } arraye_;
34
+
35
+ #define arraye_1 arraye_
36
+
37
+ struct {
38
+ integer *c__;
39
+ } arrayc_;
40
+
41
+ #define arrayc_1 arrayc_
42
+
43
+ struct {
44
+ integer *u;
45
+ } arrayu_;
46
+
47
+ #define arrayu_1 arrayu_
48
+
49
+ union {
50
+ struct {
51
+ integer *b;
52
+ } _1;
53
+ struct {
54
+ integer *dfct;
55
+ } _2;
56
+ } arrayb_;
57
+
58
+ #define arrayb_1 (arrayb_._1)
59
+ #define arrayb_2 (arrayb_._2)
60
+
61
+ struct {
62
+ integer *x;
63
+ } arrayx_;
64
+
65
+ #define arrayx_1 arrayx_
66
+
67
+ struct {
68
+ integer *rc;
69
+ } arrayrc_;
70
+
71
+ #define arrayrc_1 arrayrc_
72
+
73
+ struct {
74
+ integer nmultinode, iter, num_augm__, num_ascnt__, nsp;
75
+ } output_;
76
+
77
+ #define output_1 output_
78
+
79
+ union {
80
+ struct {
81
+ integer *i1;
82
+ } _1;
83
+ struct {
84
+ integer *tempin;
85
+ } _2;
86
+ struct {
87
+ integer *label;
88
+ } _3;
89
+ struct {
90
+ integer *p;
91
+ } _4;
92
+ } blk1_;
93
+
94
+ #define blk1_1 (blk1_._1)
95
+ #define blk1_2 (blk1_._2)
96
+ #define blk1_3 (blk1_._3)
97
+ #define blk1_4 (blk1_._4)
98
+
99
+ union {
100
+ struct {
101
+ integer *i2;
102
+ } _1;
103
+ struct {
104
+ integer *tempou;
105
+ } _2;
106
+ struct {
107
+ integer *prdcsr;
108
+ } _3;
109
+ struct {
110
+ integer *price;
111
+ } _4;
112
+ } blk2_;
113
+
114
+ #define blk2_1 (blk2_._1)
115
+ #define blk2_2 (blk2_._2)
116
+ #define blk2_3 (blk2_._3)
117
+ #define blk2_4 (blk2_._4)
118
+
119
+ union {
120
+ struct {
121
+ integer *i3;
122
+ } _1;
123
+ struct {
124
+ integer *fou;
125
+ } _2;
126
+ } blk3_;
127
+
128
+ #define blk3_1 (blk3_._1)
129
+ #define blk3_2 (blk3_._2)
130
+
131
+ union {
132
+ struct {
133
+ integer *i4;
134
+ } _1;
135
+ struct {
136
+ integer *nxtou;
137
+ } _2;
138
+ } blk4_;
139
+
140
+ #define blk4_1 (blk4_._1)
141
+ #define blk4_2 (blk4_._2)
142
+
143
+ union {
144
+ struct {
145
+ integer *i5;
146
+ } _1;
147
+ struct {
148
+ integer *fin;
149
+ } _2;
150
+ } blk5_;
151
+
152
+ #define blk5_1 (blk5_._1)
153
+ #define blk5_2 (blk5_._2)
154
+
155
+ union {
156
+ struct {
157
+ integer *i6;
158
+ } _1;
159
+ struct {
160
+ integer *nxtin;
161
+ } _2;
162
+ } blk6_;
163
+
164
+ #define blk6_1 (blk6_._1)
165
+ #define blk6_2 (blk6_._2)
166
+
167
+ union {
168
+ struct {
169
+ integer *i7;
170
+ } _1;
171
+ struct {
172
+ integer *save;
173
+ } _2;
174
+ } blk7_;
175
+
176
+ #define blk7_1 (blk7_._1)
177
+ #define blk7_2 (blk7_._2)
178
+
179
+ struct {
180
+ logical1 *scan;
181
+ } blk8_;
182
+
183
+ #define blk8_1 blk8_
184
+
185
+ union {
186
+ struct {
187
+ logical1 *mark;
188
+ } _1;
189
+ struct {
190
+ logical1 *path_id__;
191
+ } _2;
192
+ } blk9_;
193
+
194
+ #define blk9_1 (blk9_._1)
195
+ #define blk9_2 (blk9_._2)
196
+
197
+ union {
198
+ struct {
199
+ integer *tfstou; /* AKA ddpos */
200
+ } _1;
201
+ struct {
202
+ integer *fpushf;
203
+ } _2;
204
+ } blk10_;
205
+
206
+ #define blk10_1 (blk10_._1)
207
+ #define blk10_2 (blk10_._2)
208
+
209
+ union {
210
+ struct {
211
+ integer *tnxtou;
212
+ } _1;
213
+ struct {
214
+ integer *nxtpushf;
215
+ } _2;
216
+ } blk11_;
217
+
218
+ #define blk11_1 (blk11_._1)
219
+ #define blk11_2 (blk11_._2)
220
+
221
+ union {
222
+ struct {
223
+ integer *tfstin; /* AKA ddneg */
224
+ } _1;
225
+ struct {
226
+ integer *fpushb;
227
+ } _2;
228
+ } blk12_;
229
+
230
+ #define blk12_1 (blk12_._1)
231
+ #define blk12_2 (blk12_._2)
232
+
233
+ union {
234
+ struct {
235
+ integer *tnxtin;
236
+ } _1;
237
+ struct {
238
+ integer *nxtpushb;
239
+ } _2;
240
+ } blk13_;
241
+
242
+ #define blk13_1 (blk13_._1)
243
+ #define blk13_2 (blk13_._2)
244
+
245
+ union {
246
+ struct {
247
+ integer *i14;
248
+ } _1;
249
+ struct {
250
+ integer *nxtqueue;
251
+ } _2;
252
+ } blk14_;
253
+
254
+ #define blk14_1 (blk14_._1)
255
+ #define blk14_2 (blk14_._2)
256
+
257
+ union {
258
+ struct {
259
+ integer *i15;
260
+ } _1;
261
+ struct {
262
+ integer *extend_arc__;
263
+ } _2;
264
+ } blk15_;
265
+
266
+ #define blk15_1 (blk15_._1)
267
+ #define blk15_2 (blk15_._2)
268
+
269
+ union {
270
+ struct {
271
+ integer *i16;
272
+ } _1;
273
+ struct {
274
+ integer *sb_level__;
275
+ } _2;
276
+ } blk16_;
277
+
278
+ #define blk16_1 (blk16_._1)
279
+ #define blk16_2 (blk16_._2)
280
+
281
+ union {
282
+ struct {
283
+ integer *i17;
284
+ } _1;
285
+ struct {
286
+ integer *sb_arc__;
287
+ } _2;
288
+ } blk17_;
289
+
290
+ #define blk17_1 (blk17_._1)
291
+ #define blk17_2 (blk17_._2)
292
+
293
+ struct {
294
+ integer crash;
295
+ } cr_;
296
+
297
+ #define cr_1 cr_
298
+
299
+ /* Subroutine */ int inidat_(void)
300
+ {
301
+ /* System generated locals */
302
+ integer i__1;
303
+
304
+ /* Local variables */
305
+ static integer i__, i1, i2;
306
+
307
+
308
+ /* --------------------------------------------------------------- */
309
+
310
+ /* PURPOSE - THIS ROUTINE CONSTRUCTS TWO LINKED LISTS FOR */
311
+ /* THE NETWORK TOPOLOGY: ONE LIST (GIVEN BY FOU, NXTOU) FOR */
312
+ /* THE OUTGOING ARCS OF NODES AND ONE LIST (GIVEN BY FIN, */
313
+ /* NXTIN) FOR THE INCOMING ARCS OF NODES. THESE TWO LISTS */
314
+ /* ARE REQUIRED BY RELAX4. */
315
+
316
+ /* --------------------------------------------------------------- */
317
+
318
+ /* MAXNN = DIMENSION OF NODE-LENGTH ARRAYS */
319
+ /* MAXNA = DIMENSION OF ARC-LENGTH ARRAYS */
320
+
321
+
322
+ /* INPUT PARAMETERS */
323
+
324
+ /* N = NUMBER OF NODES */
325
+ /* NA = NUMBER OF ARCS */
326
+ /* STARTN(J) = STARTING NODE FOR ARC J, J = 1,...,NA */
327
+ /* ENDN(J) = ENDING NODE FOR ARC J, J = 1,...,NA */
328
+
329
+
330
+ /* OUTPUT PARAMETERS */
331
+
332
+ /* FOU(I) = FIRST ARC OUT OF NODE I, I = 1,...,N */
333
+ /* NXTOU(J) = NEXT ARC OUT OF THE STARTING NODE OF ARC J, */
334
+ /* J = 1,...,NA */
335
+ /* FIN(I) = FIRST ARC INTO NODE I, I = 1,...,N */
336
+ /* NXTIN(J) = NEXT ARC INTO THE ENDING NODE OF ARC J, */
337
+ /* J = 1,...,NA */
338
+
339
+
340
+ /* WORKING PARAMETERS */
341
+
342
+
343
+ /* --------------------------------------------------------------- */
344
+
345
+ i__1 = input_1.n;
346
+ for (i__ = 1; i__ <= i__1; ++i__) {
347
+ blk5_2.fin[i__ - 1] = 0;
348
+ blk3_2.fou[i__ - 1] = 0;
349
+ blk1_2.tempin[i__ - 1] = 0;
350
+ /* L10: */
351
+ blk2_2.tempou[i__ - 1] = 0;
352
+ }
353
+ i__1 = input_1.na;
354
+ for (i__ = 1; i__ <= i__1; ++i__) {
355
+ blk6_2.nxtin[i__ - 1] = 0;
356
+ blk4_2.nxtou[i__ - 1] = 0;
357
+ i1 = arrays_1.startn[i__ - 1];
358
+ i2 = arraye_1.endn[i__ - 1];
359
+ if (blk3_2.fou[i1 - 1] != 0) {
360
+ blk4_2.nxtou[blk2_2.tempou[i1 - 1] - 1] = i__;
361
+ } else {
362
+ blk3_2.fou[i1 - 1] = i__;
363
+ }
364
+ blk2_2.tempou[i1 - 1] = i__;
365
+ if (blk5_2.fin[i2 - 1] != 0) {
366
+ blk6_2.nxtin[blk1_2.tempin[i2 - 1] - 1] = i__;
367
+ } else {
368
+ blk5_2.fin[i2 - 1] = i__;
369
+ }
370
+ /* L20: */
371
+ blk1_2.tempin[i2 - 1] = i__;
372
+ }
373
+ return 0;
374
+ } /* inidat_ */
375
+
376
+ /* See NOTE 5; these are required in initialization phases 1 and 2. */
377
+ #define ddneg (blk12_1.tfstin)
378
+ #define ddpos (blk10_1.tfstou)
379
+
380
+ /*
381
+ * THIS PHASE AND PHASE II (FROM HERE UP TO LINE LABELED 90) CAN BE SKIPPED (BY
382
+ * SETTING REPEAT TO .TRUE.) IF THE CALLING PROGRAM PLACES IN COMMON USER-CHOSEN
383
+ * VALUES FOR THE ARC FLOWS, THE RESIDUAL ARC CAPACITIES, AND THE NODAL DEFICITS.
384
+ * WHEN THIS IS DONE, IT IS CRITICAL THAT THE FLOW AND THE REDUCED COST FOR EACH
385
+ * ARC SATISFY COMPLEMENTARY SLACKNESS AND THE DFCT ARRAY PROPERLY CORRESPOND TO
386
+ * THE INITIAL ARC/FLOWS.
387
+ */
388
+ int relax4_init_phase_1(void) {
389
+
390
+ integer i__1, i__2;
391
+ integer node, arc, node_def__, maxcap, scapou, scapin, capout, capin;
392
+
393
+ /* CONSTRUCT LINKED LISTS FOR THE PROBLEM */
394
+ inidat_();
395
+
396
+ i__1 = input_1.n;
397
+ for (node = 1; node <= i__1; ++node) {
398
+ node_def__ = arrayb_2.dfct[node - 1];
399
+ ddpos[node - 1] = node_def__;
400
+ ddneg[node - 1] = -node_def__;
401
+ maxcap = 0;
402
+ scapou = 0;
403
+ arc = blk3_2.fou[node - 1];
404
+ L11:
405
+ if (arc > 0) {
406
+ if (scapou <= input_1.large - arrayu_1.u[arc - 1]) {
407
+ scapou += arrayu_1.u[arc - 1];
408
+ } else {
409
+ goto L10;
410
+ }
411
+ arc = blk4_2.nxtou[arc - 1];
412
+ goto L11;
413
+ }
414
+ if (scapou <= input_1.large - node_def__) {
415
+ capout = scapou + node_def__;
416
+ } else {
417
+ goto L10;
418
+ }
419
+ if (capout < 0) {
420
+ /*printf("PHASE 1: EXOGENOUS IN FLOW > OUT CAP AT %ld\n", node);*/
421
+ return RELAX4_INFEASIBLE;
422
+ }
423
+
424
+ scapin = 0;
425
+ arc = blk5_2.fin[node - 1];
426
+ L12:
427
+ if (arc > 0) {
428
+ /* Computing MIN */
429
+ i__2 = arrayu_1.u[arc - 1];
430
+ arrayu_1.u[arc - 1] = min(i__2,capout);
431
+ if (maxcap < arrayu_1.u[arc - 1]) {
432
+ maxcap = arrayu_1.u[arc - 1];
433
+ }
434
+ if (scapin <= input_1.large - arrayu_1.u[arc - 1]) {
435
+ scapin += arrayu_1.u[arc - 1];
436
+ } else {
437
+ goto L10;
438
+ }
439
+ arc = blk6_2.nxtin[arc - 1];
440
+ goto L12;
441
+ }
442
+ if (scapin <= input_1.large + node_def__) {
443
+ capin = scapin - node_def__;
444
+ } else {
445
+ goto L10;
446
+ }
447
+ if (capin < 0) {
448
+ /*printf("PHASE 1: EXOGENOUS OUT FLOW > IN CAP AT %ld\n", node);*/
449
+ return RELAX4_INFEASIBLE;
450
+ }
451
+
452
+ arc = blk3_2.fou[node - 1];
453
+ L15:
454
+ if (arc > 0) {
455
+ /* Computing MIN */
456
+ i__2 = arrayu_1.u[arc - 1];
457
+ arrayu_1.u[arc - 1] = min(i__2,capin);
458
+ arc = blk4_2.nxtou[arc - 1];
459
+ goto L15;
460
+ }
461
+ L10:
462
+ ;
463
+ }
464
+
465
+ /* INITIALIZE DUAL PRICES */
466
+ /* (DEFAULT: ALL DUAL PRICES = 0, SO REDUCED COST IS SET EQUAL TO COST) */
467
+ for (arc = 1; arc <= input_1.na; ++arc) {
468
+ /* L60: */
469
+ arrayrc_1.rc[arc - 1] = arrayc_1.c__[arc - 1];
470
+ }
471
+
472
+ return RELAX4_OK;
473
+ }
474
+
475
+ /* INITIALIZE THE ARC FLOWS TO SATISFY COMPLEMENTARY SLACKNESS WITH THE */
476
+ /* PRICES. U(ARC) IS THE RESIDUAL CAPACITY OF ARC, AND X(ARC) IS THE FLOW. */
477
+ /* THESE TWO ALWAYS ADD UP TO THE TOTAL CAPACITY FOR ARC. */
478
+ /* ALSO COMPUTE THE DIRECTIONAL DERIVATIVES FOR EACH COORDINATE */
479
+ /* AND COMPUTE THE ACTUAL DEFICITS. */
480
+ int relax4_init_phase_2(void) {
481
+ integer i__1, i__2;
482
+ integer numpasses, node, arc, t, t1, t2, passes, delprc, trc, nxtbrk;
483
+
484
+ i__1 = input_1.na;
485
+ for (arc = 1; arc <= i__1; ++arc) {
486
+ arrayx_1.x[arc - 1] = 0;
487
+ if (arrayrc_1.rc[arc - 1] <= 0) {
488
+ t = arrayu_1.u[arc - 1];
489
+ t1 = arrays_1.startn[arc - 1];
490
+ t2 = arraye_1.endn[arc - 1];
491
+ ddpos[t1 - 1] += t;
492
+ ddneg[t2 - 1] += t;
493
+ if (arrayrc_1.rc[arc - 1] < 0) {
494
+ arrayx_1.x[arc - 1] = t;
495
+ arrayu_1.u[arc - 1] = 0;
496
+ arrayb_2.dfct[t1 - 1] += t;
497
+ arrayb_2.dfct[t2 - 1] -= t;
498
+ ddneg[t1 - 1] -= t;
499
+ ddpos[t2 - 1] -= t;
500
+ }
501
+ }
502
+ /* L20: */
503
+ }
504
+
505
+ /* MAKE 2 OR 3 PASSES THROUGH ALL NODES, PERFORMING ONLY */
506
+ /* SINGLE NODE RELAXATION ITERATIONS. THE NUMBER OF */
507
+ /* PASSES DEPENDS ON THE DENSITY OF THE NETWORK */
508
+
509
+ if (input_1.na > input_1.n * 10) {
510
+ numpasses = 2;
511
+ } else {
512
+ numpasses = 3;
513
+ }
514
+
515
+ i__1 = numpasses;
516
+ for (passes = 1; passes <= i__1; ++passes) {
517
+ i__2 = input_1.n;
518
+ for (node = 1; node <= i__2; ++node) {
519
+ if (arrayb_2.dfct[node - 1] == 0) {
520
+ goto L40;
521
+ }
522
+ if (ddpos[node - 1] <= 0) {
523
+
524
+ /* COMPUTE DELPRC, THE STEPSIZE TO THE NEXT BREAKPOINT */
525
+ /* IN THE DUAL COST AS THE PRICE OF NODE IS INCREASED. */
526
+ /* [SINCE THE REDUCED COST OF ALL OUTGOING (RESP., */
527
+ /* INCOMING) ARCS WILL DECREASE (RESP., INCREASE) AS */
528
+ /* THE PRICE OF NODE IS INCREASED, THE NEXT BREAKPOINT IS */
529
+ /* THE MINIMUM OF THE POSITIVE REDUCED COST ON OUTGOING */
530
+ /* ARCS AND OF THE NEGATIVE REDUCED COST ON INCOMING ARCS.] */
531
+
532
+ delprc = input_1.large;
533
+ arc = blk3_2.fou[node - 1];
534
+ L51:
535
+ if (arc > 0) {
536
+ trc = arrayrc_1.rc[arc - 1];
537
+ if (trc > 0 && trc < delprc) {
538
+ delprc = trc;
539
+ }
540
+ arc = blk4_2.nxtou[arc - 1];
541
+ goto L51;
542
+ }
543
+ arc = blk5_2.fin[node - 1];
544
+ L52:
545
+ if (arc > 0) {
546
+ trc = arrayrc_1.rc[arc - 1];
547
+ if (trc < 0 && trc > -delprc) {
548
+ delprc = -trc;
549
+ }
550
+ arc = blk6_2.nxtin[arc - 1];
551
+ goto L52;
552
+ }
553
+
554
+ /* IF NO BREAKPOINT IS LEFT AND DUAL ASCENT IS STILL */
555
+ /* POSSIBLE, THE PROBLEM IS INFEASIBLE. */
556
+
557
+ if (delprc >= input_1.large) {
558
+ if (ddpos[node - 1] == 0) {
559
+ goto L40;
560
+ } else {
561
+ return RELAX4_INFEASIBLE;
562
+ }
563
+ }
564
+
565
+ /* DELPRC IS THE STEPSIZE TO NEXT BREAKPOINT. INCREASE */
566
+ /* PRICE OF NODE BY DELPRC AND COMPUTE THE STEPSIZE TO */
567
+ /* THE NEXT BREAKPOINT IN THE DUAL COST. */
568
+
569
+ L53:
570
+ nxtbrk = input_1.large;
571
+
572
+ /* LOOK AT ALL ARCS OUT OF NODE. */
573
+
574
+ arc = blk3_2.fou[node - 1];
575
+ L54:
576
+ if (arc > 0) {
577
+ trc = arrayrc_1.rc[arc - 1];
578
+ if (trc == 0) {
579
+ t1 = arraye_1.endn[arc - 1];
580
+ t = arrayu_1.u[arc - 1];
581
+ if (t > 0) {
582
+ arrayb_2.dfct[node - 1] += t;
583
+ arrayb_2.dfct[t1 - 1] -= t;
584
+ arrayx_1.x[arc - 1] = t;
585
+ arrayu_1.u[arc - 1] = 0;
586
+ } else {
587
+ t = arrayx_1.x[arc - 1];
588
+ }
589
+ ddneg[node - 1] -= t;
590
+ ddpos[t1 - 1] -= t;
591
+ }
592
+
593
+ /* DECREASE THE REDUCED COST ON ALL OUTGOING ARCS. */
594
+
595
+ trc -= delprc;
596
+ if (trc > 0 && trc < nxtbrk) {
597
+ nxtbrk = trc;
598
+ } else if (trc == 0) {
599
+
600
+ /* ARC GOES FROM INACTIVE TO BALANCED. UPDATE THE */
601
+ /* RATE OF DUAL ASCENT AT NODE AND AT ITS NEIGHBOR. */
602
+
603
+ ddpos[node - 1] += arrayu_1.u[arc - 1];
604
+ ddneg[arraye_1.endn[arc - 1] - 1] += arrayu_1.u[arc -
605
+ 1];
606
+ }
607
+ arrayrc_1.rc[arc - 1] = trc;
608
+ arc = blk4_2.nxtou[arc - 1];
609
+ goto L54;
610
+ }
611
+
612
+ /* LOOK AT ALL ARCS INTO NODE. */
613
+
614
+ arc = blk5_2.fin[node - 1];
615
+ L55:
616
+ if (arc > 0) {
617
+ trc = arrayrc_1.rc[arc - 1];
618
+ if (trc == 0) {
619
+ t1 = arrays_1.startn[arc - 1];
620
+ t = arrayx_1.x[arc - 1];
621
+ if (t > 0) {
622
+ arrayb_2.dfct[node - 1] += t;
623
+ arrayb_2.dfct[t1 - 1] -= t;
624
+ arrayu_1.u[arc - 1] = t;
625
+ arrayx_1.x[arc - 1] = 0;
626
+ } else {
627
+ t = arrayu_1.u[arc - 1];
628
+ }
629
+ ddpos[t1 - 1] -= t;
630
+ ddneg[node - 1] -= t;
631
+ }
632
+
633
+ /* INCREASE THE REDUCED COST ON ALL INCOMING ARCS. */
634
+
635
+ trc += delprc;
636
+ if (trc < 0 && trc > -nxtbrk) {
637
+ nxtbrk = -trc;
638
+ } else if (trc == 0) {
639
+
640
+ /* ARC GOES FROM ACTIVE TO BALANCED. UPDATE THE */
641
+ /* RATE OF DUAL ASCENT AT NODE AND AT ITS NEIGHBOR. */
642
+
643
+ ddneg[arrays_1.startn[arc - 1] - 1] += arrayx_1.x[arc
644
+ - 1];
645
+ ddpos[node - 1] += arrayx_1.x[arc - 1];
646
+ }
647
+ arrayrc_1.rc[arc - 1] = trc;
648
+ arc = blk6_2.nxtin[arc - 1];
649
+ goto L55;
650
+ }
651
+
652
+ /* IF PRICE OF NODE CAN BE INCREASED FURTHER WITHOUT DECREASING */
653
+ /* THE DUAL COST (EVEN IF THE DUAL COST DOESN'T INCREASE), */
654
+ /* RETURN TO INCREASE THE PRICE FURTHER. */
655
+
656
+ if (ddpos[node - 1] <= 0 && nxtbrk < input_1.large) {
657
+ delprc = nxtbrk;
658
+ goto L53;
659
+ }
660
+ } else if (ddneg[node - 1] <= 0) {
661
+
662
+ /* COMPUTE DELPRC, THE STEPSIZE TO THE NEXT BREAKPOINT */
663
+ /* IN THE DUAL COST AS THE PRICE OF NODE IS DECREASED. */
664
+ /* [SINCE THE REDUCED COST OF ALL OUTGOING (RESP., */
665
+ /* INCOMING) ARCS WILL INCREASE (RESP., DECREASE) AS */
666
+ /* THE PRICE OF NODE IS DECREASED, THE NEXT BREAKPOINT IS */
667
+ /* THE MINIMUM OF THE NEGATIVE REDUCED COST ON OUTGOING */
668
+ /* ARCS AND OF THE POSITIVE REDUCED COST ON INCOMING ARCS.] */
669
+
670
+ delprc = input_1.large;
671
+ arc = blk3_2.fou[node - 1];
672
+ L61:
673
+ if (arc > 0) {
674
+ trc = arrayrc_1.rc[arc - 1];
675
+ if (trc < 0 && trc > -delprc) {
676
+ delprc = -trc;
677
+ }
678
+ arc = blk4_2.nxtou[arc - 1];
679
+ goto L61;
680
+ }
681
+ arc = blk5_2.fin[node - 1];
682
+ L62:
683
+ if (arc > 0) {
684
+ trc = arrayrc_1.rc[arc - 1];
685
+ if (trc > 0 && trc < delprc) {
686
+ delprc = trc;
687
+ }
688
+ arc = blk6_2.nxtin[arc - 1];
689
+ goto L62;
690
+ }
691
+
692
+ /* IF NO BREAKPOINT IS LEFT AND DUAL ASCENT IS STILL */
693
+ /* POSSIBLE, THE PROBLEM IS INFEASIBLE. */
694
+
695
+ if (delprc == input_1.large) {
696
+ if (ddneg[node - 1] == 0) {
697
+ goto L40;
698
+ } else {
699
+ return RELAX4_INFEASIBLE;
700
+ }
701
+ }
702
+
703
+ /* DELPRC IS THE STEPSIZE TO NEXT BREAKPOINT. DECREASE */
704
+ /* PRICE OF NODE BY DELPRC AND COMPUTE THE STEPSIZE TO */
705
+ /* THE NEXT BREAKPOINT IN THE DUAL COST. */
706
+
707
+ L63:
708
+ nxtbrk = input_1.large;
709
+
710
+ /* LOOK AT ALL ARCS OUT OF NODE. */
711
+
712
+ arc = blk3_2.fou[node - 1];
713
+ L64:
714
+ if (arc > 0) {
715
+ trc = arrayrc_1.rc[arc - 1];
716
+ if (trc == 0) {
717
+ t1 = arraye_1.endn[arc - 1];
718
+ t = arrayx_1.x[arc - 1];
719
+ if (t > 0) {
720
+ arrayb_2.dfct[node - 1] -= t;
721
+ arrayb_2.dfct[t1 - 1] += t;
722
+ arrayu_1.u[arc - 1] = t;
723
+ arrayx_1.x[arc - 1] = 0;
724
+ } else {
725
+ t = arrayu_1.u[arc - 1];
726
+ }
727
+ ddpos[node - 1] -= t;
728
+ ddneg[t1 - 1] -= t;
729
+ }
730
+
731
+ /* INCREASE THE REDUCED COST ON ALL OUTGOING ARCS. */
732
+
733
+ trc += delprc;
734
+ if (trc < 0 && trc > -nxtbrk) {
735
+ nxtbrk = -trc;
736
+ } else if (trc == 0) {
737
+
738
+ /* ARC GOES FROM ACTIVE TO BALANCED. UPDATE THE */
739
+ /* RATE OF DUAL ASCENT AT NODE AND AT ITS NEIGHBOR. */
740
+
741
+ ddneg[node - 1] += arrayx_1.x[arc - 1];
742
+ ddpos[arraye_1.endn[arc - 1] - 1] += arrayx_1.x[arc -
743
+ 1];
744
+ }
745
+ arrayrc_1.rc[arc - 1] = trc;
746
+ arc = blk4_2.nxtou[arc - 1];
747
+ goto L64;
748
+ }
749
+
750
+ /* LOOK AT ALL ARCS INTO NODE. */
751
+
752
+ arc = blk5_2.fin[node - 1];
753
+ L65:
754
+ if (arc > 0) {
755
+ trc = arrayrc_1.rc[arc - 1];
756
+ if (trc == 0) {
757
+ t1 = arrays_1.startn[arc - 1];
758
+ t = arrayu_1.u[arc - 1];
759
+ if (t > 0) {
760
+ arrayb_2.dfct[node - 1] -= t;
761
+ arrayb_2.dfct[t1 - 1] += t;
762
+ arrayx_1.x[arc - 1] = t;
763
+ arrayu_1.u[arc - 1] = 0;
764
+ } else {
765
+ t = arrayx_1.x[arc - 1];
766
+ }
767
+ ddneg[t1 - 1] -= t;
768
+ ddpos[node - 1] -= t;
769
+ }
770
+
771
+ /* DECREASE THE REDUCED COST ON ALL INCOMING ARCS. */
772
+
773
+ trc -= delprc;
774
+ if (trc > 0 && trc < nxtbrk) {
775
+ nxtbrk = trc;
776
+ } else if (trc == 0) {
777
+
778
+ /* ARC GOES FROM INACTIVE TO BALANCED. UPDATE THE */
779
+ /* RATE OF DUAL ASCENT AT NODE AND AT ITS NEIGHBOR. */
780
+
781
+ ddpos[arrays_1.startn[arc - 1] - 1] += arrayu_1.u[arc
782
+ - 1];
783
+ ddneg[node - 1] += arrayu_1.u[arc - 1];
784
+ }
785
+ arrayrc_1.rc[arc - 1] = trc;
786
+ arc = blk6_2.nxtin[arc - 1];
787
+ goto L65;
788
+ }
789
+
790
+ /* IF PRICE OF NODE CAN BE DECREASED FURTHER WITHOUT DECREASING */
791
+ /* THE DUAL COST (EVEN IF THE DUAL COST DOESN'T INCREASE), */
792
+ /* RETURN TO DECREASE THE PRICE FURTHER. */
793
+
794
+ if (ddneg[node - 1] <= 0 && nxtbrk < input_1.large) {
795
+ delprc = nxtbrk;
796
+ goto L63;
797
+ }
798
+ }
799
+ L40:
800
+ ;
801
+ }
802
+ /* L30: */
803
+ }
804
+
805
+ return RELAX4_OK;
806
+ }
807
+
808
+ /* Subroutine */ int relax4_(void)
809
+ {
810
+ /* System generated locals */
811
+ integer i__1, i__2, i__3;
812
+
813
+ /* Local variables */
814
+ static integer prevnode, i__, j, t1, t2, lastqueue,
815
+ numnz_new__, ib, nb, dp, dm, dx, tp, ts, num_passes__,
816
+ arc;
817
+ static integer narc, node, delx;
818
+ static logical1 quit;
819
+ static integer node2;
820
+ static integer indef;
821
+ static integer nscan;
822
+ static logical1 posit;
823
+ static integer numnz;
824
+ extern /* Subroutine */ int ascnt1_(integer *, integer *, integer *,
825
+ logical1 *, logical1 *, integer *, integer *, integer *), ascnt2_(
826
+ integer *, integer *, integer *, logical1 *, logical1 *, integer *
827
+ , integer *, integer *);
828
+ static logical1 feasbl;
829
+ static integer nlabel, defcit, delprc, augnod, tmparc,
830
+ rdcost, nxtarc;
831
+ static logical1 switch__;
832
+ static integer prvarc;
833
+ static logical1 pchange;
834
+ static integer naugnod;
835
+ static integer nxtnode;
836
+
837
+ /* --------------------------------------------------------------- */
838
+
839
+ /* RELAX-IV (VERSION OF OCTOBER 1994) */
840
+
841
+ /* RELEASE NOTE - THIS VERSION OF RELAXATION CODE HAS OPTION FOR */
842
+ /* A SPECIAL CRASH PROCEDURE FOR */
843
+ /* THE INITIAL PRICE-FLOW PAIR. THIS IS RECOMMENDED FOR DIFFICULT */
844
+ /* PROBLEMS WHERE THE DEFAULT INITIALIZATION */
845
+ /* RESULTS IN LONG RUNNING TIMES. */
846
+ /* CRASH =1 CORRESPONDS TO AN AUCTION/SHORTEST PATH METHOD */
847
+
848
+ /* THESE INITIALIZATIONS ARE RECOMMENDED IN THE ABSENCE OF ANY */
849
+ /* PRIOR INFORMATION ON A FAVORABLE INITIAL FLOW-PRICE VECTOR PAIR */
850
+ /* THAT SATISFIES COMPLEMENTARY SLACKNESS */
851
+
852
+ /* THE RELAXATION PORTION OF THE CODE DIFFERS FROM THE CODE RELAXT-III */
853
+ /* AND OTHER EARLIER RELAXATION CODES IN THAT IT MAINTAINS */
854
+ /* THE SET OF NODES WITH NONZERO DEFICIT IN A FIFO QUEUE. */
855
+ /* LIKE ITS PREDECESSOR RELAXT-III, THIS CODE MAINTAINS A LINKED LIST */
856
+ /* OF BALANCED (I.E., OF ZERO REDUCED COST) ARCS SO TO REDUCE */
857
+ /* THE WORK IN LABELING AND SCANNING. */
858
+ /* UNLIKE RELAXT-III, IT DOES NOT USE SELECTIVELY */
859
+ /* SHORTEST PATH ITERATIONS FOR INITIALIZATION. */
860
+
861
+ /* --------------------------------------------------------------- */
862
+
863
+ /* PURPOSE - THIS ROUTINE IMPLEMENTS THE RELAXATION METHOD */
864
+ /* OF BERTSEKAS AND TSENG (SEE [1], [2]) FOR LINEAR */
865
+ /* COST ORDINARY NETWORK FLOW PROBLEMS. */
866
+
867
+ /* [1] BERTSEKAS, D. P., "A UNIFIED FRAMEWORK FOR PRIMAL-DUAL METHODS ..." */
868
+ /* MATHEMATICAL PROGRAMMING, VOL. 32, 1985, PP. 125-145. */
869
+ /* [2] BERTSEKAS, D. P., AND TSENG, P., "RELAXATION METHODS FOR */
870
+ /* MINIMUM COST ..." OPERATIONS RESEARCH, VOL. 26, 1988, PP. 93-114. */
871
+
872
+ /* THE RELAXATION METHOD IS ALSO DESCRIBED IN THE BOOKS: */
873
+
874
+ /* [3] BERTSEKAS, D. P., "LINEAR NETWORK OPTIMIZATION: ALGORITHMS AND CODES" */
875
+ /* MIT PRESS, 1991. */
876
+ /* [4] BERTSEKAS, D. P. AND TSITSIKLIS, J. N., "PARALLEL AND DISTRIBUTED */
877
+ /* COMPUTATION: NUMERICAL METHODS", PRENTICE-HALL, 1989. */
878
+
879
+
880
+
881
+ /* --------------------------------------------------------------- */
882
+
883
+ /* SOURCE - THIS CODE WAS WRITTEN BY DIMITRI P. BERTSEKAS */
884
+ /* AND PAUL TSENG, WITH A CONTRIBUTION BY JONATHAN ECKSTEIN */
885
+ /* IN THE PHASE II INITIALIZATION. THE ROUTINE AUCTION WAS WRITTEN */
886
+ /* BY DIMITRI P. BERTSEKAS AND IS BASED ON THE METHOD DESCRIBED IN */
887
+ /* THE PAPER: */
888
+
889
+ /* [5] BERTSEKAS, D. P., "AN AUCTION/SEQUENTIAL SHORTEST PATH ALGORITHM */
890
+ /* FOR THE MINIMUM COST FLOW PROBLEM", LIDS REPORT P-2146, MIT, NOV. 1992. */
891
+
892
+ /* FOR INQUIRIES ABOUT THE CODE, PLEASE CONTACT: */
893
+
894
+ /* DIMITRI P. BERTSEKAS */
895
+ /* LABORATORY FOR INFORMATION AND DECISION SYSTEMS */
896
+ /* MASSACHUSETTS INSTITUTE OF TECHNOLOGY */
897
+ /* CAMBRIDGE, MA 02139 */
898
+ /* (617) 253-7267, DIMITRIB@MIT.EDU */
899
+
900
+ /* --------------------------------------------------------------- */
901
+
902
+ /* USER GUIDELINES - */
903
+
904
+ /* THIS ROUTINE IS IN THE PUBLIC DOMAIN TO BE USED ONLY FOR RESEARCH */
905
+ /* PURPOSES. IT CANNOT BE USED AS PART OF A COMMERCIAL PRODUCT, OR */
906
+ /* TO SATISFY IN ANY PART COMMERCIAL DELIVERY REQUIREMENTS TO */
907
+ /* GOVERNMENT OR INDUSTRY, WITHOUT PRIOR AGREEMENT WITH THE AUTHORS. */
908
+ /* USERS ARE REQUESTED TO ACKNOWLEDGE THE AUTHORSHIP OF THE CODE, */
909
+ /* AND THE RELAXATION METHOD. THEY SHOULD ALSO REGISTER WITH THE */
910
+ /* AUTHORS TO RECEIVE UPDATES AND SUBSEQUENT RELEASES. */
911
+
912
+ /* NO MODIFICATION SHOULD BE MADE TO THIS CODE OTHER */
913
+ /* THAN THE MINIMAL NECESSARY */
914
+ /* TO MAKE IT COMPATIBLE WITH THE FORTRAN COMPILERS OF SPECIFIC */
915
+ /* MACHINES. WHEN REPORTING COMPUTATIONAL RESULTS PLEASE BE SURE */
916
+ /* TO DESCRIBE THE MEMORY LIMITATIONS OF YOUR MACHINE. GENERALLY */
917
+ /* RELAX4 REQUIRES MORE MEMORY THAN PRIMAL SIMPLEX CODES AND MAY */
918
+ /* BE PENALIZED SEVERELY BY LIMITED MACHINE MEMORY. */
919
+
920
+ /* --------------------------------------------------------------- */
921
+
922
+ /* MAXNN = DIMENSION OF NODE-LENGTH ARRAYS */
923
+ /* MAXNA = DIMENSION OF ARC-LENGTH ARRAYS */
924
+
925
+
926
+ /* INPUT PARAMETERS (SEE NOTES 1, 2, 4) */
927
+
928
+ /* N = NUMBER OF NODES */
929
+ /* NA = NUMBER OF ARCS */
930
+ /* LARGE = A VERY LARGE INTEGER TO REPRESENT INFINITY */
931
+ /* (SEE NOTE 3) */
932
+ /* REPEAT = .TRUE. IF INITIALIZATION IS TO BE SKIPPED */
933
+ /* (.FALSE. OTHERWISE) */
934
+ /* CRASH = 0 IF DEFAULT INITIALIZATION IS USED */
935
+ /* 1 IF AUCTION INITIALIZATION IS USED */
936
+ /* STARTN(J) = STARTING NODE FOR ARC J, J = 1,...,NA */
937
+ /* ENDN(J) = ENDING NODE FOR ARC J, J = 1,...,NA */
938
+ /* FOU(I) = FIRST ARC OUT OF NODE I, I = 1,...,N */
939
+ /* NXTOU(J) = NEXT ARC OUT OF THE STARTING NODE OF ARC J, */
940
+ /* J = 1,...,NA */
941
+ /* FIN(I) = FIRST ARC INTO NODE I, I = 1,...,N */
942
+ /* NXTIN(J) = NEXT ARC INTO THE ENDING NODE OF ARC J, */
943
+ /* J = 1,...,NA */
944
+
945
+
946
+ /* UPDATED PARAMETERS (SEE NOTES 1, 3, 4) */
947
+
948
+ /* RC(J) = REDUCED COST OF ARC J, J = 1,...,NA */
949
+ /* U(J) = CAPACITY OF ARC J ON INPUT */
950
+ /* AND (CAPACITY OF ARC J) - X(J) ON OUTPUT, */
951
+ /* J = 1,...,NA */
952
+ /* DFCT(I) = DEMAND AT NODE I ON INPUT */
953
+ /* AND ZERO ON OUTPUT, I = 1,...,N */
954
+
955
+
956
+ /* OUTPUT PARAMETERS (SEE NOTES 1, 3, 4) */
957
+
958
+ /* X(J) = FLOW ON ARC J, J = 1,...,NA */
959
+ /* NMULTINODE = NUMBER OF MULTINODE RELAXATION ITERATIONS IN RELAX4 */
960
+ /* ITER = NUMBER OF RELAXATION ITERATIONS IN RELAX4 */
961
+ /* NUM_AUGM = NUMBER OF FLOW AUGMENTATION STEPS IN RELAX4 */
962
+ /* NUM_ASCNT = NUMBER OF MULTINODE ASCENT STEPS IN RELAX4 */
963
+ /* NSP = NUMBER OF AUCTION/SHORTEST PATH ITERATIONS */
964
+
965
+
966
+ /* WORKING PARAMETERS (SEE NOTES 1, 4, 5) */
967
+
968
+
969
+ /* TIMING PARAMETERS */
970
+
971
+ /* COMMON /T/TIME0,TIME1 */
972
+
973
+ /* NOTE 1 - */
974
+ /* TO RUN IN LIMITED MEMORY SYSTEMS, DECLARE THE ARRAYS */
975
+ /* STARTN, ENDN, NXTIN, NXTOU, FIN, FOU, LABEL, */
976
+ /* PRDCSR, SAVE, TFSTOU, TNXTOU, TFSTIN, TNXTIN, */
977
+ /* DDPOS,DDNEG,NXTQUEUE AS INTEGER*2 INSTEAD. */
978
+
979
+ /* NOTE 2 - */
980
+ /* THIS ROUTINE MAKES NO EFFORT TO INITIALIZE WITH A FAVORABLE X */
981
+ /* FROM AMONGST THOSE FLOW VECTORS THAT SATISFY COMPLEMENTARY SLACKNESS */
982
+ /* WITH THE INITIAL REDUCED COST VECTOR RC. */
983
+ /* IF A FAVORABLE X IS KNOWN, THEN IT CAN BE PASSED, TOGETHER */
984
+ /* WITH THE CORRESPONDING ARRAYS U AND DFCT, TO THIS ROUTINE */
985
+ /* DIRECTLY. THIS, HOWEVER, REQUIRES THAT THE CAPACITY */
986
+ /* TIGHTENING PORTION AND THE FLOW INITIALIZATION PORTION */
987
+ /* OF THIS ROUTINE (UP TO LINE LABELED 90) BE SKIPPED. */
988
+
989
+ /* NOTE 3 - */
990
+ /* ALL PROBLEM DATA SHOULD BE LESS THAN LARGE IN MAGNITUDE, */
991
+ /* AND LARGE SHOULD BE LESS THAN, SAY, 1/4 THE LARGEST INTEGER*4 */
992
+ /* OF THE MACHINE USED. THIS WILL GUARD PRIMARILY AGAINST */
993
+ /* OVERFLOW IN UNCAPACITATED PROBLEMS WHERE THE ARC CAPACITIES */
994
+ /* ARE TAKEN FINITE BUT VERY LARGE. NOTE, HOWEVER, THAT AS IN */
995
+ /* ALL CODES OPERATING WITH INTEGERS, OVERFLOW MAY OCCUR IF SOME */
996
+ /* OF THE PROBLEM DATA TAKES VERY LARGE VALUES. */
997
+
998
+ /* NOTE 4 - */
999
+ /* EACH COMMON BLOCK CONTAINS JUST ONE ARRAY, SO THE ARRAYS IN RELAX4 */
1000
+ /* CAN BE DIMENSIONED TO 1 AND TAKE THEIR DIMENSION FROM THE */
1001
+ /* MAIN CALLING ROUTINE. WITH THIS TRICK, RELAX4 NEED NOT BE RECOMPILED */
1002
+ /* IF THE ARRAY DIMENSIONS IN THE CALLING ROUTINE CHANGE. */
1003
+ /* IF YOUR FORTRAN COMPILER DOES NOT SUPPORT THIS FEATURE, THEN */
1004
+ /* CHANGE THE DIMENSION OF ALL THE ARRAYS TO BE THE SAME AS THE ONES */
1005
+ /* DECLARED IN THE MAIN CALLING PROGRAM. */
1006
+
1007
+ /* NOTE 5 - */
1008
+ /* DDPOS AND DDNEG ARE ARRAYS THAT GIVE THE DIRECTIONAL DERIVATIVES FOR */
1009
+ /* ALL POSITIVE AND NEGATIVE SINGLE-NODE PRICE CHANGES. THESE ARE USED */
1010
+ /* ONLY IN PHASE II OF THE INITIALIZATION PROCEDURE, BEFORE THE */
1011
+ /* LINKED LIST OF BALANCED ARCS COMES TO PLAY. THEREFORE, TO REDUCE */
1012
+ /* STORAGE, THEY ARE EQUIVALENCE TO TFSTOU AND TFSTIN, */
1013
+ /* WHICH ARE OF THE SAME SIZE (NUMBER OF NODES) AND ARE USED */
1014
+ /* ONLY AFTER THE TREE COMES INTO USE. */
1015
+
1016
+ /* INITIALIZE TREE DATA STRUCTURE. */
1017
+ i__1 = input_1.n;
1018
+ for (i__ = 1; i__ <= i__1; ++i__) {
1019
+ blk10_1.tfstou[i__ - 1] = 0;
1020
+ blk12_1.tfstin[i__ - 1] = 0;
1021
+ /* L80: */
1022
+ }
1023
+ i__1 = input_1.na;
1024
+ for (i__ = 1; i__ <= i__1; ++i__) {
1025
+ blk13_1.tnxtin[i__ - 1] = -1;
1026
+ blk11_1.tnxtou[i__ - 1] = -1;
1027
+ if (arrayrc_1.rc[i__ - 1] == 0) {
1028
+ blk11_1.tnxtou[i__ - 1] = blk10_1.tfstou[arrays_1.startn[i__ - 1]
1029
+ - 1];
1030
+ blk10_1.tfstou[arrays_1.startn[i__ - 1] - 1] = i__;
1031
+ blk13_1.tnxtin[i__ - 1] = blk12_1.tfstin[arraye_1.endn[i__ - 1] -
1032
+ 1];
1033
+ blk12_1.tfstin[arraye_1.endn[i__ - 1] - 1] = i__;
1034
+ }
1035
+ /* L81: */
1036
+ }
1037
+
1038
+ /* INITIALIZE OTHER VARIABLES. */
1039
+
1040
+ /* L90: */
1041
+ feasbl = TRUE_;
1042
+ output_1.iter = 0;
1043
+ output_1.nmultinode = 0;
1044
+ output_1.num_augm__ = 0;
1045
+ output_1.num_ascnt__ = 0;
1046
+ num_passes__ = 0;
1047
+ numnz = input_1.n;
1048
+ numnz_new__ = 0;
1049
+ switch__ = FALSE_;
1050
+ i__1 = input_1.n;
1051
+ for (i__ = 1; i__ <= i__1; ++i__) {
1052
+ blk9_1.mark[i__ - 1] = FALSE_;
1053
+ blk8_1.scan[i__ - 1] = FALSE_;
1054
+ /* L91: */
1055
+ }
1056
+ nlabel = 0;
1057
+
1058
+ /* RELAX4 USES AN ADAPTIVE STRATEGY TO DECIDE WHETHER TO */
1059
+ /* CONTINUE THE SCANNING PROCESS AFTER A MULTINODE PRICE CHANGE. */
1060
+ /* THE THRESHOLD PARAMETER TP AND TS THAT CONTROL */
1061
+ /* THIS STRATEGY ARE SET IN THE NEXT TWO LINES. */
1062
+
1063
+ tp = 10;
1064
+ ts = input_1.n / 15;
1065
+
1066
+ /* INITIALIZE THE QUEUE OF NODES WITH NONZERO DEFICIT */
1067
+
1068
+ i__1 = input_1.n - 1;
1069
+ for (node = 1; node <= i__1; ++node) {
1070
+ blk14_2.nxtqueue[node - 1] = node + 1;
1071
+ /* L92: */
1072
+ }
1073
+ blk14_2.nxtqueue[input_1.n - 1] = 1;
1074
+ node = input_1.n;
1075
+ lastqueue = input_1.n;
1076
+
1077
+ /* --------------------------------------------------------------- */
1078
+
1079
+ /* START THE RELAXATION ALGORITHM. */
1080
+
1081
+ L100:
1082
+
1083
+ /* CODE FOR ADVANCING THE QUEUE OF NONZERO DEFICIT NODES */
1084
+
1085
+ prevnode = node;
1086
+ node = blk14_2.nxtqueue[node - 1];
1087
+ defcit = arrayb_2.dfct[node - 1];
1088
+ if (node == lastqueue) {
1089
+ numnz = numnz_new__;
1090
+ numnz_new__ = 0;
1091
+ lastqueue = prevnode;
1092
+ ++num_passes__;
1093
+ }
1094
+
1095
+ /* CODE FOR DELETING A NODE FROM THE QUEUE */
1096
+
1097
+ if (defcit == 0) {
1098
+ nxtnode = blk14_2.nxtqueue[node - 1];
1099
+ if (node == nxtnode) {
1100
+ /* DONE */
1101
+ return RELAX4_OK;
1102
+ } else {
1103
+ blk14_2.nxtqueue[prevnode - 1] = nxtnode;
1104
+ blk14_2.nxtqueue[node - 1] = 0;
1105
+ node = nxtnode;
1106
+ goto L100;
1107
+ }
1108
+ } else {
1109
+ posit = defcit > 0;
1110
+ }
1111
+
1112
+ ++output_1.iter;
1113
+ ++numnz_new__;
1114
+
1115
+ if (posit) {
1116
+
1117
+ /* ATTEMPT A SINGLE NODE ITERATION FROM NODE WITH POSITIVE DEFICIT */
1118
+
1119
+ pchange = FALSE_;
1120
+ indef = defcit;
1121
+ delx = 0;
1122
+ nb = 0;
1123
+
1124
+ /* CHECK OUTGOING (PROBABLY) BALANCED ARCS FROM NODE. */
1125
+
1126
+ arc = blk10_1.tfstou[node - 1];
1127
+ L4500:
1128
+ if (arc > 0) {
1129
+ if (arrayrc_1.rc[arc - 1] == 0 && arrayx_1.x[arc - 1] > 0) {
1130
+ delx += arrayx_1.x[arc - 1];
1131
+ ++nb;
1132
+ blk7_2.save[nb - 1] = arc;
1133
+ }
1134
+ arc = blk11_1.tnxtou[arc - 1];
1135
+ goto L4500;
1136
+ }
1137
+
1138
+ /* CHECK INCOMING ARCS. */
1139
+
1140
+ arc = blk12_1.tfstin[node - 1];
1141
+ L4501:
1142
+ if (arc > 0) {
1143
+ if (arrayrc_1.rc[arc - 1] == 0 && arrayu_1.u[arc - 1] > 0) {
1144
+ delx += arrayu_1.u[arc - 1];
1145
+ ++nb;
1146
+ blk7_2.save[nb - 1] = -arc;
1147
+ }
1148
+ arc = blk13_1.tnxtin[arc - 1];
1149
+ goto L4501;
1150
+ }
1151
+
1152
+ /* END OF INITIAL NODE SCAN. */
1153
+
1154
+ L4018:
1155
+
1156
+ /* IF NO PRICE CHANGE IS POSSIBLE, EXIT. */
1157
+
1158
+ if (delx > defcit) {
1159
+ quit = defcit < indef;
1160
+ goto L4016;
1161
+ }
1162
+
1163
+ /* RELAX4 SEARCHES ALONG THE ASCENT DIRECTION FOR THE */
1164
+ /* BEST PRICE BY CHECKING THE SLOPE OF THE DUAL COST */
1165
+ /* AT SUCCESSIVE BREAK POINTS. FIRST, WE */
1166
+ /* COMPUTE THE DISTANCE TO THE NEXT BREAK POINT. */
1167
+
1168
+ delprc = input_1.large;
1169
+ arc = blk3_2.fou[node - 1];
1170
+ L4502:
1171
+ if (arc > 0) {
1172
+ rdcost = arrayrc_1.rc[arc - 1];
1173
+ if (rdcost < 0 && rdcost > -delprc) {
1174
+ delprc = -rdcost;
1175
+ }
1176
+ arc = blk4_2.nxtou[arc - 1];
1177
+ goto L4502;
1178
+ }
1179
+ arc = blk5_2.fin[node - 1];
1180
+ L4503:
1181
+ if (arc > 0) {
1182
+ rdcost = arrayrc_1.rc[arc - 1];
1183
+ if (rdcost > 0 && rdcost < delprc) {
1184
+ delprc = rdcost;
1185
+ }
1186
+ arc = blk6_2.nxtin[arc - 1];
1187
+ goto L4503;
1188
+ }
1189
+
1190
+ /* CHECK IF PROBLEM IS INFEASIBLE. */
1191
+
1192
+ if (delx < defcit && delprc == input_1.large) {
1193
+
1194
+ /* THE DUAL COST CAN BE DECREASED WITHOUT BOUND. */
1195
+
1196
+ goto L4400;
1197
+ }
1198
+
1199
+ /* SKIP FLOW ADJUSTEMT IF THERE IS NO FLOW TO MODIFY. */
1200
+
1201
+ if (delx == 0) {
1202
+ goto L4014;
1203
+ }
1204
+
1205
+ /* ADJUST THE FLOW ON THE BALANCED ARCS INCIDENT TO NODE TO */
1206
+ /* MAINTAIN COMPLEMENTARY SLACKNESS AFTER THE PRICE CHANGE. */
1207
+
1208
+ i__1 = nb;
1209
+ for (j = 1; j <= i__1; ++j) {
1210
+ arc = blk7_2.save[j - 1];
1211
+ if (arc > 0) {
1212
+ node2 = arraye_1.endn[arc - 1];
1213
+ t1 = arrayx_1.x[arc - 1];
1214
+ arrayb_2.dfct[node2 - 1] += t1;
1215
+ if (blk14_2.nxtqueue[node2 - 1] == 0) {
1216
+ blk14_2.nxtqueue[prevnode - 1] = node2;
1217
+ blk14_2.nxtqueue[node2 - 1] = node;
1218
+ prevnode = node2;
1219
+ }
1220
+ arrayu_1.u[arc - 1] += t1;
1221
+ arrayx_1.x[arc - 1] = 0;
1222
+ } else {
1223
+ narc = -arc;
1224
+ node2 = arrays_1.startn[narc - 1];
1225
+ t1 = arrayu_1.u[narc - 1];
1226
+ arrayb_2.dfct[node2 - 1] += t1;
1227
+ if (blk14_2.nxtqueue[node2 - 1] == 0) {
1228
+ blk14_2.nxtqueue[prevnode - 1] = node2;
1229
+ blk14_2.nxtqueue[node2 - 1] = node;
1230
+ prevnode = node2;
1231
+ }
1232
+ arrayx_1.x[narc - 1] += t1;
1233
+ arrayu_1.u[narc - 1] = 0;
1234
+ }
1235
+ /* L4013: */
1236
+ }
1237
+ defcit -= delx;
1238
+ L4014:
1239
+ if (delprc == input_1.large) {
1240
+ quit = TRUE_;
1241
+ goto L4019;
1242
+ }
1243
+
1244
+ /* NODE CORRESPONDS TO A DUAL ASCENT DIRECTION. DECREASE */
1245
+ /* THE PRICE OF NODE BY DELPRC AND COMPUTE THE STEPSIZE TO THE */
1246
+ /* NEXT BREAKPOINT IN THE DUAL COST. */
1247
+
1248
+ nb = 0;
1249
+ pchange = TRUE_;
1250
+ dp = delprc;
1251
+ delprc = input_1.large;
1252
+ delx = 0;
1253
+ arc = blk3_2.fou[node - 1];
1254
+ L4504:
1255
+ if (arc > 0) {
1256
+ rdcost = arrayrc_1.rc[arc - 1] + dp;
1257
+ arrayrc_1.rc[arc - 1] = rdcost;
1258
+ if (rdcost == 0) {
1259
+ ++nb;
1260
+ blk7_2.save[nb - 1] = arc;
1261
+ delx += arrayx_1.x[arc - 1];
1262
+ }
1263
+ if (rdcost < 0 && rdcost > -delprc) {
1264
+ delprc = -rdcost;
1265
+ }
1266
+ arc = blk4_2.nxtou[arc - 1];
1267
+ goto L4504;
1268
+ }
1269
+ arc = blk5_2.fin[node - 1];
1270
+ L4505:
1271
+ if (arc > 0) {
1272
+ rdcost = arrayrc_1.rc[arc - 1] - dp;
1273
+ arrayrc_1.rc[arc - 1] = rdcost;
1274
+ if (rdcost == 0) {
1275
+ ++nb;
1276
+ blk7_2.save[nb - 1] = -arc;
1277
+ delx += arrayu_1.u[arc - 1];
1278
+ }
1279
+ if (rdcost > 0 && rdcost < delprc) {
1280
+ delprc = rdcost;
1281
+ }
1282
+ arc = blk6_2.nxtin[arc - 1];
1283
+ goto L4505;
1284
+ }
1285
+
1286
+ /* RETURN TO CHECK IF ANOTHER PRICE CHANGE IS POSSIBLE. */
1287
+
1288
+ goto L4018;
1289
+
1290
+ /* PERFORM FLOW AUGMENTATION AT NODE. */
1291
+
1292
+ L4016:
1293
+ i__1 = nb;
1294
+ for (j = 1; j <= i__1; ++j) {
1295
+ arc = blk7_2.save[j - 1];
1296
+ if (arc > 0) {
1297
+
1298
+ /* ARC IS AN OUTGOING ARC FROM NODE. */
1299
+
1300
+ node2 = arraye_1.endn[arc - 1];
1301
+ t1 = arrayb_2.dfct[node2 - 1];
1302
+ if (t1 < 0) {
1303
+
1304
+ /* DECREASE THE TOTAL DEFICIT BY DECREASING FLOW OF ARC. */
1305
+
1306
+ quit = TRUE_;
1307
+ t2 = arrayx_1.x[arc - 1];
1308
+ /* Computing MIN */
1309
+ i__2 = defcit, i__3 = -t1, i__2 = min(i__2,i__3);
1310
+ dx = min(i__2,t2);
1311
+ defcit -= dx;
1312
+ arrayb_2.dfct[node2 - 1] = t1 + dx;
1313
+ if (blk14_2.nxtqueue[node2 - 1] == 0) {
1314
+ blk14_2.nxtqueue[prevnode - 1] = node2;
1315
+ blk14_2.nxtqueue[node2 - 1] = node;
1316
+ prevnode = node2;
1317
+ }
1318
+ arrayx_1.x[arc - 1] = t2 - dx;
1319
+ arrayu_1.u[arc - 1] += dx;
1320
+ if (defcit == 0) {
1321
+ goto L4019;
1322
+ }
1323
+ }
1324
+ } else {
1325
+
1326
+ /* -ARC IS AN INCOMING ARC TO NODE. */
1327
+
1328
+ narc = -arc;
1329
+ node2 = arrays_1.startn[narc - 1];
1330
+ t1 = arrayb_2.dfct[node2 - 1];
1331
+ if (t1 < 0) {
1332
+
1333
+ /* DECREASE THE TOTAL DEFICIT BY INCREASING FLOW OF -ARC. */
1334
+
1335
+ quit = TRUE_;
1336
+ t2 = arrayu_1.u[narc - 1];
1337
+ /* Computing MIN */
1338
+ i__2 = defcit, i__3 = -t1, i__2 = min(i__2,i__3);
1339
+ dx = min(i__2,t2);
1340
+ defcit -= dx;
1341
+ arrayb_2.dfct[node2 - 1] = t1 + dx;
1342
+ if (blk14_2.nxtqueue[node2 - 1] == 0) {
1343
+ blk14_2.nxtqueue[prevnode - 1] = node2;
1344
+ blk14_2.nxtqueue[node2 - 1] = node;
1345
+ prevnode = node2;
1346
+ }
1347
+ arrayx_1.x[narc - 1] += dx;
1348
+ arrayu_1.u[narc - 1] = t2 - dx;
1349
+ if (defcit == 0) {
1350
+ goto L4019;
1351
+ }
1352
+ }
1353
+ }
1354
+ /* L4011: */
1355
+ }
1356
+ L4019:
1357
+ arrayb_2.dfct[node - 1] = defcit;
1358
+
1359
+ /* RECONSTRUCT THE LINKED LIST OF BALANCE ARCS INCIDENT TO THIS NODE. */
1360
+ /* FOR EACH ADJACENT NODE, WE ADD ANY NEWLY BLANCED ARCS */
1361
+ /* TO THE LIST, BUT DO NOT BOTHER REMOVING FORMERLY BALANCED ONES */
1362
+ /* (THEY WILL BE REMOVED THE NEXT TIME EACH ADJACENT NODE IS SCANNED). */
1363
+
1364
+ if (pchange) {
1365
+ arc = blk10_1.tfstou[node - 1];
1366
+ blk10_1.tfstou[node - 1] = 0;
1367
+ L4506:
1368
+ if (arc > 0) {
1369
+ nxtarc = blk11_1.tnxtou[arc - 1];
1370
+ blk11_1.tnxtou[arc - 1] = -1;
1371
+ arc = nxtarc;
1372
+ goto L4506;
1373
+ }
1374
+ arc = blk12_1.tfstin[node - 1];
1375
+ blk12_1.tfstin[node - 1] = 0;
1376
+ L4507:
1377
+ if (arc > 0) {
1378
+ nxtarc = blk13_1.tnxtin[arc - 1];
1379
+ blk13_1.tnxtin[arc - 1] = -1;
1380
+ arc = nxtarc;
1381
+ goto L4507;
1382
+ }
1383
+
1384
+ /* NOW ADD THE CURRENTLY BALANCED ARCS TO THE LIST FOR THIS NODE */
1385
+ /* (WHICH IS NOW EMPTY), AND THE APPROPRIATE ADJACENT ONES. */
1386
+
1387
+ i__1 = nb;
1388
+ for (j = 1; j <= i__1; ++j) {
1389
+ arc = blk7_2.save[j - 1];
1390
+ if (arc <= 0) {
1391
+ arc = -arc;
1392
+ }
1393
+ if (blk11_1.tnxtou[arc - 1] < 0) {
1394
+ blk11_1.tnxtou[arc - 1] = blk10_1.tfstou[arrays_1.startn[
1395
+ arc - 1] - 1];
1396
+ blk10_1.tfstou[arrays_1.startn[arc - 1] - 1] = arc;
1397
+ }
1398
+ if (blk13_1.tnxtin[arc - 1] < 0) {
1399
+ blk13_1.tnxtin[arc - 1] = blk12_1.tfstin[arraye_1.endn[
1400
+ arc - 1] - 1];
1401
+ blk12_1.tfstin[arraye_1.endn[arc - 1] - 1] = arc;
1402
+ }
1403
+ /* L4508: */
1404
+ }
1405
+ }
1406
+
1407
+ /* END OF SINGLE NODE ITERATION FOR POSITIVE DEFICIT NODE. */
1408
+
1409
+ } else {
1410
+
1411
+ /* ATTEMPT A SINGLE NODE ITERATION FROM NODE WITH NEGATIVE DEFICIT */
1412
+
1413
+ pchange = FALSE_;
1414
+ defcit = -defcit;
1415
+ indef = defcit;
1416
+ delx = 0;
1417
+ nb = 0;
1418
+
1419
+ arc = blk12_1.tfstin[node - 1];
1420
+ L4509:
1421
+ if (arc > 0) {
1422
+ if (arrayrc_1.rc[arc - 1] == 0 && arrayx_1.x[arc - 1] > 0) {
1423
+ delx += arrayx_1.x[arc - 1];
1424
+ ++nb;
1425
+ blk7_2.save[nb - 1] = arc;
1426
+ }
1427
+ arc = blk13_1.tnxtin[arc - 1];
1428
+ goto L4509;
1429
+ }
1430
+ arc = blk10_1.tfstou[node - 1];
1431
+ L4510:
1432
+ if (arc > 0) {
1433
+ if (arrayrc_1.rc[arc - 1] == 0 && arrayu_1.u[arc - 1] > 0) {
1434
+ delx += arrayu_1.u[arc - 1];
1435
+ ++nb;
1436
+ blk7_2.save[nb - 1] = -arc;
1437
+ }
1438
+ arc = blk11_1.tnxtou[arc - 1];
1439
+ goto L4510;
1440
+ }
1441
+
1442
+ L4028:
1443
+ if (delx >= defcit) {
1444
+ quit = defcit < indef;
1445
+ goto L4026;
1446
+ }
1447
+
1448
+ /* COMPUTE DISTANCE TO NEXT BREAKPOINT. */
1449
+
1450
+ delprc = input_1.large;
1451
+ arc = blk5_2.fin[node - 1];
1452
+ L4511:
1453
+ if (arc > 0) {
1454
+ rdcost = arrayrc_1.rc[arc - 1];
1455
+ if (rdcost < 0 && rdcost > -delprc) {
1456
+ delprc = -rdcost;
1457
+ }
1458
+ arc = blk6_2.nxtin[arc - 1];
1459
+ goto L4511;
1460
+ }
1461
+ arc = blk3_2.fou[node - 1];
1462
+ L4512:
1463
+ if (arc > 0) {
1464
+ rdcost = arrayrc_1.rc[arc - 1];
1465
+ if (rdcost > 0 && rdcost < delprc) {
1466
+ delprc = rdcost;
1467
+ }
1468
+ arc = blk4_2.nxtou[arc - 1];
1469
+ goto L4512;
1470
+ }
1471
+
1472
+ /* CHECK IF PROBLEM IS INFEASIBLE. */
1473
+
1474
+ if (delx < defcit && delprc == input_1.large) {
1475
+ goto L4400;
1476
+ }
1477
+ if (delx == 0) {
1478
+ goto L4024;
1479
+ }
1480
+
1481
+ /* FLOW AUGMENTATION IS POSSIBLE. */
1482
+
1483
+ i__1 = nb;
1484
+ for (j = 1; j <= i__1; ++j) {
1485
+ arc = blk7_2.save[j - 1];
1486
+ if (arc > 0) {
1487
+ node2 = arrays_1.startn[arc - 1];
1488
+ t1 = arrayx_1.x[arc - 1];
1489
+ arrayb_2.dfct[node2 - 1] -= t1;
1490
+ if (blk14_2.nxtqueue[node2 - 1] == 0) {
1491
+ blk14_2.nxtqueue[prevnode - 1] = node2;
1492
+ blk14_2.nxtqueue[node2 - 1] = node;
1493
+ prevnode = node2;
1494
+ }
1495
+ arrayu_1.u[arc - 1] += t1;
1496
+ arrayx_1.x[arc - 1] = 0;
1497
+ } else {
1498
+ narc = -arc;
1499
+ node2 = arraye_1.endn[narc - 1];
1500
+ t1 = arrayu_1.u[narc - 1];
1501
+ arrayb_2.dfct[node2 - 1] -= t1;
1502
+ if (blk14_2.nxtqueue[node2 - 1] == 0) {
1503
+ blk14_2.nxtqueue[prevnode - 1] = node2;
1504
+ blk14_2.nxtqueue[node2 - 1] = node;
1505
+ prevnode = node2;
1506
+ }
1507
+ arrayx_1.x[narc - 1] += t1;
1508
+ arrayu_1.u[narc - 1] = 0;
1509
+ }
1510
+ /* L4023: */
1511
+ }
1512
+ defcit -= delx;
1513
+ L4024:
1514
+ if (delprc == input_1.large) {
1515
+ quit = TRUE_;
1516
+ goto L4029;
1517
+ }
1518
+
1519
+ /* PRICE INCREASE AT NODE IS POSSIBLE. */
1520
+
1521
+ nb = 0;
1522
+ pchange = TRUE_;
1523
+ dp = delprc;
1524
+ delprc = input_1.large;
1525
+ delx = 0;
1526
+ arc = blk5_2.fin[node - 1];
1527
+ L4513:
1528
+ if (arc > 0) {
1529
+ rdcost = arrayrc_1.rc[arc - 1] + dp;
1530
+ arrayrc_1.rc[arc - 1] = rdcost;
1531
+ if (rdcost == 0) {
1532
+ ++nb;
1533
+ blk7_2.save[nb - 1] = arc;
1534
+ delx += arrayx_1.x[arc - 1];
1535
+ }
1536
+ if (rdcost < 0 && rdcost > -delprc) {
1537
+ delprc = -rdcost;
1538
+ }
1539
+ arc = blk6_2.nxtin[arc - 1];
1540
+ goto L4513;
1541
+ }
1542
+ arc = blk3_2.fou[node - 1];
1543
+ L4514:
1544
+ if (arc > 0) {
1545
+ rdcost = arrayrc_1.rc[arc - 1] - dp;
1546
+ arrayrc_1.rc[arc - 1] = rdcost;
1547
+ if (rdcost == 0) {
1548
+ ++nb;
1549
+ blk7_2.save[nb - 1] = -arc;
1550
+ delx += arrayu_1.u[arc - 1];
1551
+ }
1552
+ if (rdcost > 0 && rdcost < delprc) {
1553
+ delprc = rdcost;
1554
+ }
1555
+ arc = blk4_2.nxtou[arc - 1];
1556
+ goto L4514;
1557
+ }
1558
+ goto L4028;
1559
+
1560
+ /* PERFORM FLOW AUGMENTATION AT NODE. */
1561
+
1562
+ L4026:
1563
+ i__1 = nb;
1564
+ for (j = 1; j <= i__1; ++j) {
1565
+ arc = blk7_2.save[j - 1];
1566
+ if (arc > 0) {
1567
+
1568
+ /* ARC IS AN INCOMING ARC TO NODE. */
1569
+
1570
+ node2 = arrays_1.startn[arc - 1];
1571
+ t1 = arrayb_2.dfct[node2 - 1];
1572
+ if (t1 > 0) {
1573
+ quit = TRUE_;
1574
+ t2 = arrayx_1.x[arc - 1];
1575
+ /* Computing MIN */
1576
+ i__2 = min(defcit,t1);
1577
+ dx = min(i__2,t2);
1578
+ defcit -= dx;
1579
+ arrayb_2.dfct[node2 - 1] = t1 - dx;
1580
+ if (blk14_2.nxtqueue[node2 - 1] == 0) {
1581
+ blk14_2.nxtqueue[prevnode - 1] = node2;
1582
+ blk14_2.nxtqueue[node2 - 1] = node;
1583
+ prevnode = node2;
1584
+ }
1585
+ arrayx_1.x[arc - 1] = t2 - dx;
1586
+ arrayu_1.u[arc - 1] += dx;
1587
+ if (defcit == 0) {
1588
+ goto L4029;
1589
+ }
1590
+ }
1591
+ } else {
1592
+
1593
+ /* -ARC IS AN OUTGOING ARC FROM NODE. */
1594
+
1595
+ narc = -arc;
1596
+ node2 = arraye_1.endn[narc - 1];
1597
+ t1 = arrayb_2.dfct[node2 - 1];
1598
+ if (t1 > 0) {
1599
+ quit = TRUE_;
1600
+ t2 = arrayu_1.u[narc - 1];
1601
+ /* Computing MIN */
1602
+ i__2 = min(defcit,t1);
1603
+ dx = min(i__2,t2);
1604
+ defcit -= dx;
1605
+ arrayb_2.dfct[node2 - 1] = t1 - dx;
1606
+ if (blk14_2.nxtqueue[node2 - 1] == 0) {
1607
+ blk14_2.nxtqueue[prevnode - 1] = node2;
1608
+ blk14_2.nxtqueue[node2 - 1] = node;
1609
+ prevnode = node2;
1610
+ }
1611
+ arrayx_1.x[narc - 1] += dx;
1612
+ arrayu_1.u[narc - 1] = t2 - dx;
1613
+ if (defcit == 0) {
1614
+ goto L4029;
1615
+ }
1616
+ }
1617
+ }
1618
+ /* L4021: */
1619
+ }
1620
+ L4029:
1621
+ arrayb_2.dfct[node - 1] = -defcit;
1622
+
1623
+ /* RECONSTRUCT THE LIST OF BALANCED ARCS INCIDENT TO NODE. */
1624
+
1625
+ if (pchange) {
1626
+ arc = blk10_1.tfstou[node - 1];
1627
+ blk10_1.tfstou[node - 1] = 0;
1628
+ L4515:
1629
+ if (arc > 0) {
1630
+ nxtarc = blk11_1.tnxtou[arc - 1];
1631
+ blk11_1.tnxtou[arc - 1] = -1;
1632
+ arc = nxtarc;
1633
+ goto L4515;
1634
+ }
1635
+ arc = blk12_1.tfstin[node - 1];
1636
+ blk12_1.tfstin[node - 1] = 0;
1637
+ L4516:
1638
+ if (arc > 0) {
1639
+ nxtarc = blk13_1.tnxtin[arc - 1];
1640
+ blk13_1.tnxtin[arc - 1] = -1;
1641
+ arc = nxtarc;
1642
+ goto L4516;
1643
+ }
1644
+
1645
+ /* NOW ADD THE CURRENTLY BALANCED ARCS TO THE LIST FOR THIS NODE */
1646
+ /* (WHICH IS NOW EMPTY), AND THE APPROPRIATE ADJACENT ONES. */
1647
+
1648
+ i__1 = nb;
1649
+ for (j = 1; j <= i__1; ++j) {
1650
+ arc = blk7_2.save[j - 1];
1651
+ if (arc <= 0) {
1652
+ arc = -arc;
1653
+ }
1654
+ if (blk11_1.tnxtou[arc - 1] < 0) {
1655
+ blk11_1.tnxtou[arc - 1] = blk10_1.tfstou[arrays_1.startn[
1656
+ arc - 1] - 1];
1657
+ blk10_1.tfstou[arrays_1.startn[arc - 1] - 1] = arc;
1658
+ }
1659
+ if (blk13_1.tnxtin[arc - 1] < 0) {
1660
+ blk13_1.tnxtin[arc - 1] = blk12_1.tfstin[arraye_1.endn[
1661
+ arc - 1] - 1];
1662
+ blk12_1.tfstin[arraye_1.endn[arc - 1] - 1] = arc;
1663
+ }
1664
+ /* L4517: */
1665
+ }
1666
+ }
1667
+
1668
+ /* END OF SINGLE NODE ITERATION FOR A NEGATIVE DEFICIT NODE. */
1669
+
1670
+ }
1671
+
1672
+ if (quit || num_passes__ <= 3) {
1673
+ goto L100;
1674
+ }
1675
+
1676
+ /* DO A MULTINODE ITERATION FROM NODE. */
1677
+
1678
+ ++output_1.nmultinode;
1679
+
1680
+ /* IF NUMBER OF NONZERO DEFICIT NODES IS SMALL, CONTINUE */
1681
+ /* LABELING UNTIL A FLOW AUGMENTATION IS DONE. */
1682
+
1683
+ switch__ = numnz < tp;
1684
+
1685
+ /* UNMARK NODES LABELED EARLIER. */
1686
+
1687
+ i__1 = nlabel;
1688
+ for (j = 1; j <= i__1; ++j) {
1689
+ node2 = blk1_3.label[j - 1];
1690
+ blk9_1.mark[node2 - 1] = FALSE_;
1691
+ blk8_1.scan[node2 - 1] = FALSE_;
1692
+ /* L4090: */
1693
+ }
1694
+
1695
+ /* INITIALIZE LABELING. */
1696
+
1697
+ nlabel = 1;
1698
+ blk1_3.label[0] = node;
1699
+ blk9_1.mark[node - 1] = TRUE_;
1700
+ blk2_3.prdcsr[node - 1] = 0;
1701
+
1702
+ /* SCAN STARTING NODE. */
1703
+
1704
+ blk8_1.scan[node - 1] = TRUE_;
1705
+ nscan = 1;
1706
+ dm = arrayb_2.dfct[node - 1];
1707
+ delx = 0;
1708
+ i__1 = nb;
1709
+ for (j = 1; j <= i__1; ++j) {
1710
+ arc = blk7_2.save[j - 1];
1711
+ if (arc > 0) {
1712
+ if (posit) {
1713
+ node2 = arraye_1.endn[arc - 1];
1714
+ } else {
1715
+ node2 = arrays_1.startn[arc - 1];
1716
+ }
1717
+ if (! blk9_1.mark[node2 - 1]) {
1718
+ ++nlabel;
1719
+ blk1_3.label[nlabel - 1] = node2;
1720
+ blk2_3.prdcsr[node2 - 1] = arc;
1721
+ blk9_1.mark[node2 - 1] = TRUE_;
1722
+ delx += arrayx_1.x[arc - 1];
1723
+ }
1724
+ } else {
1725
+ narc = -arc;
1726
+ if (posit) {
1727
+ node2 = arrays_1.startn[narc - 1];
1728
+ } else {
1729
+ node2 = arraye_1.endn[narc - 1];
1730
+ }
1731
+ if (! blk9_1.mark[node2 - 1]) {
1732
+ ++nlabel;
1733
+ blk1_3.label[nlabel - 1] = node2;
1734
+ blk2_3.prdcsr[node2 - 1] = arc;
1735
+ blk9_1.mark[node2 - 1] = TRUE_;
1736
+ delx += arrayu_1.u[narc - 1];
1737
+ }
1738
+ }
1739
+ /* L4095: */
1740
+ }
1741
+
1742
+ /* START SCANNING A LABELED BUT UNSCANNED NODE. */
1743
+
1744
+ L4120:
1745
+ ++nscan;
1746
+
1747
+ /* CHECK TO SEE IF SWITCH NEEDS TO BE SET TO TRUE SO TO */
1748
+ /* CONTINUE SCANNING EVEN AFTER A PRICE CHANGE. */
1749
+
1750
+ /* Originally read "switch__ || nscan > ts && numnz < ts;" but gcc gave a
1751
+ * "suggest parentheses" warning. */
1752
+ switch__ = switch__ || (nscan > ts && numnz < ts);
1753
+
1754
+ /* SCANNING WILL CONTINUE UNTIL EITHER AN OVERESTIMATE OF THE RESIDUAL */
1755
+ /* CAPACITY ACROSS THE CUT CORRESPONDING TO THE SCANNED SET OF NODES (CALLED */
1756
+ /* DELX) EXCEEDS THE ABSOLUTE VALUE OF THE TOTAL DEFICIT OF THE SCANNED */
1757
+ /* NODES (CALLED DM), OR ELSE AN AUGMENTING PATH IS FOUND. ARCS THAT ARE */
1758
+ /* IN THE TREE BUT ARE NOT BALANCED ARE REMOVED AS PART OF THE SCANNING */
1759
+ /* PROCESS. */
1760
+
1761
+ i__ = blk1_3.label[nscan - 1];
1762
+ blk8_1.scan[i__ - 1] = TRUE_;
1763
+ naugnod = 0;
1764
+ if (posit) {
1765
+
1766
+ /* SCANNING NODE I IN CASE OF POSITIVE DEFICIT. */
1767
+
1768
+ prvarc = 0;
1769
+ arc = blk10_1.tfstou[i__ - 1];
1770
+ L4518:
1771
+ if (arc > 0) {
1772
+
1773
+ /* ARC IS AN OUTGOING ARC FROM NODE. */
1774
+
1775
+ if (arrayrc_1.rc[arc - 1] == 0) {
1776
+ if (arrayx_1.x[arc - 1] > 0) {
1777
+ node2 = arraye_1.endn[arc - 1];
1778
+ if (! blk9_1.mark[node2 - 1]) {
1779
+
1780
+ /* NODE2 IS NOT LABELED, SO ADD NODE2 TO THE LABELED SET. */
1781
+
1782
+ blk2_3.prdcsr[node2 - 1] = arc;
1783
+ if (arrayb_2.dfct[node2 - 1] < 0) {
1784
+ ++naugnod;
1785
+ blk7_2.save[naugnod - 1] = node2;
1786
+ }
1787
+ ++nlabel;
1788
+ blk1_3.label[nlabel - 1] = node2;
1789
+ blk9_1.mark[node2 - 1] = TRUE_;
1790
+ delx += arrayx_1.x[arc - 1];
1791
+ }
1792
+ }
1793
+ prvarc = arc;
1794
+ arc = blk11_1.tnxtou[arc - 1];
1795
+ } else {
1796
+ tmparc = arc;
1797
+ arc = blk11_1.tnxtou[arc - 1];
1798
+ blk11_1.tnxtou[tmparc - 1] = -1;
1799
+ if (prvarc == 0) {
1800
+ blk10_1.tfstou[i__ - 1] = arc;
1801
+ } else {
1802
+ blk11_1.tnxtou[prvarc - 1] = arc;
1803
+ }
1804
+ }
1805
+ goto L4518;
1806
+ }
1807
+ prvarc = 0;
1808
+ arc = blk12_1.tfstin[i__ - 1];
1809
+ L4519:
1810
+ if (arc > 0) {
1811
+
1812
+ /* ARC IS AN INCOMING ARC INTO NODE. */
1813
+
1814
+ if (arrayrc_1.rc[arc - 1] == 0) {
1815
+ if (arrayu_1.u[arc - 1] > 0) {
1816
+ node2 = arrays_1.startn[arc - 1];
1817
+ if (! blk9_1.mark[node2 - 1]) {
1818
+
1819
+ /* NODE2 IS NOT LABELED, SO ADD NODE2 TO THE LABELED SET. */
1820
+
1821
+ blk2_3.prdcsr[node2 - 1] = -arc;
1822
+ if (arrayb_2.dfct[node2 - 1] < 0) {
1823
+ ++naugnod;
1824
+ blk7_2.save[naugnod - 1] = node2;
1825
+ }
1826
+ ++nlabel;
1827
+ blk1_3.label[nlabel - 1] = node2;
1828
+ blk9_1.mark[node2 - 1] = TRUE_;
1829
+ delx += arrayu_1.u[arc - 1];
1830
+ }
1831
+ }
1832
+ prvarc = arc;
1833
+ arc = blk13_1.tnxtin[arc - 1];
1834
+ } else {
1835
+ tmparc = arc;
1836
+ arc = blk13_1.tnxtin[arc - 1];
1837
+ blk13_1.tnxtin[tmparc - 1] = -1;
1838
+ if (prvarc == 0) {
1839
+ blk12_1.tfstin[i__ - 1] = arc;
1840
+ } else {
1841
+ blk13_1.tnxtin[prvarc - 1] = arc;
1842
+ }
1843
+ }
1844
+ goto L4519;
1845
+ }
1846
+
1847
+ /* CORRECT THE RESIDUAL CAPACITY OF THE SCANNED NODE CUT. */
1848
+
1849
+ arc = blk2_3.prdcsr[i__ - 1];
1850
+ if (arc > 0) {
1851
+ delx -= arrayx_1.x[arc - 1];
1852
+ } else {
1853
+ delx -= arrayu_1.u[-arc - 1];
1854
+ }
1855
+
1856
+ /* END OF SCANNING OF NODE I FOR POSITIVE DEFICIT CASE. */
1857
+
1858
+ } else {
1859
+
1860
+ /* SCANNING NODE I FOR NEGATIVE DEFICIT CASE. */
1861
+
1862
+ prvarc = 0;
1863
+ arc = blk12_1.tfstin[i__ - 1];
1864
+ L4520:
1865
+ if (arc > 0) {
1866
+ if (arrayrc_1.rc[arc - 1] == 0) {
1867
+ if (arrayx_1.x[arc - 1] > 0) {
1868
+ node2 = arrays_1.startn[arc - 1];
1869
+ if (! blk9_1.mark[node2 - 1]) {
1870
+ blk2_3.prdcsr[node2 - 1] = arc;
1871
+ if (arrayb_2.dfct[node2 - 1] > 0) {
1872
+ ++naugnod;
1873
+ blk7_2.save[naugnod - 1] = node2;
1874
+ }
1875
+ ++nlabel;
1876
+ blk1_3.label[nlabel - 1] = node2;
1877
+ blk9_1.mark[node2 - 1] = TRUE_;
1878
+ delx += arrayx_1.x[arc - 1];
1879
+ }
1880
+ }
1881
+ prvarc = arc;
1882
+ arc = blk13_1.tnxtin[arc - 1];
1883
+ } else {
1884
+ tmparc = arc;
1885
+ arc = blk13_1.tnxtin[arc - 1];
1886
+ blk13_1.tnxtin[tmparc - 1] = -1;
1887
+ if (prvarc == 0) {
1888
+ blk12_1.tfstin[i__ - 1] = arc;
1889
+ } else {
1890
+ blk13_1.tnxtin[prvarc - 1] = arc;
1891
+ }
1892
+ }
1893
+ goto L4520;
1894
+ }
1895
+
1896
+ prvarc = 0;
1897
+ arc = blk10_1.tfstou[i__ - 1];
1898
+ L4521:
1899
+ if (arc > 0) {
1900
+ if (arrayrc_1.rc[arc - 1] == 0) {
1901
+ if (arrayu_1.u[arc - 1] > 0) {
1902
+ node2 = arraye_1.endn[arc - 1];
1903
+ if (! blk9_1.mark[node2 - 1]) {
1904
+ blk2_3.prdcsr[node2 - 1] = -arc;
1905
+ if (arrayb_2.dfct[node2 - 1] > 0) {
1906
+ ++naugnod;
1907
+ blk7_2.save[naugnod - 1] = node2;
1908
+ }
1909
+ ++nlabel;
1910
+ blk1_3.label[nlabel - 1] = node2;
1911
+ blk9_1.mark[node2 - 1] = TRUE_;
1912
+ delx += arrayu_1.u[arc - 1];
1913
+ }
1914
+ }
1915
+ prvarc = arc;
1916
+ arc = blk11_1.tnxtou[arc - 1];
1917
+ } else {
1918
+ tmparc = arc;
1919
+ arc = blk11_1.tnxtou[arc - 1];
1920
+ blk11_1.tnxtou[tmparc - 1] = -1;
1921
+ if (prvarc == 0) {
1922
+ blk10_1.tfstou[i__ - 1] = arc;
1923
+ } else {
1924
+ blk11_1.tnxtou[prvarc - 1] = arc;
1925
+ }
1926
+ }
1927
+ goto L4521;
1928
+ }
1929
+
1930
+ arc = blk2_3.prdcsr[i__ - 1];
1931
+ if (arc > 0) {
1932
+ delx -= arrayx_1.x[arc - 1];
1933
+ } else {
1934
+ delx -= arrayu_1.u[-arc - 1];
1935
+ }
1936
+ }
1937
+
1938
+ /* ADD DEFICIT OF NODE SCANNED TO DM. */
1939
+
1940
+ dm += arrayb_2.dfct[i__ - 1];
1941
+
1942
+ /* CHECK IF THE SET OF SCANNED NODES CORRESPOND */
1943
+ /* TO A DUAL ASCENT DIRECTION; IF YES, PERFORM A */
1944
+ /* PRICE ADJUSTMENT STEP, OTHERWISE CONTINUE LABELING. */
1945
+
1946
+ if (nscan < nlabel) {
1947
+ if (switch__) {
1948
+ goto L4210;
1949
+ }
1950
+ if (delx >= dm && delx >= -dm) {
1951
+ goto L4210;
1952
+ }
1953
+ }
1954
+
1955
+ /* TRY A PRICE CHANGE. */
1956
+ /* [NOTE THAT SINCE DELX-ABS(DM) IS AN OVERESTIMATE OF ASCENT SLOPE, WE */
1957
+ /* MAY OCCASIONALLY TRY A DIRECTION THAT IS NOT AN ASCENT DIRECTION. */
1958
+ /* IN THIS CASE, THE ASCNT ROUTINES RETURN WITH QUIT=.FALSE., */
1959
+ /* SO WE CONTINUE LABELING NODES. */
1960
+
1961
+ if (posit) {
1962
+ ascnt1_(&dm, &delx, &nlabel, &feasbl, &switch__, &nscan, &node, &
1963
+ prevnode);
1964
+ ++output_1.num_ascnt__;
1965
+ } else {
1966
+ ascnt2_(&dm, &delx, &nlabel, &feasbl, &switch__, &nscan, &node, &
1967
+ prevnode);
1968
+ ++output_1.num_ascnt__;
1969
+ }
1970
+ if (! feasbl) {
1971
+ goto L4400;
1972
+ }
1973
+ if (! switch__) {
1974
+ goto L100;
1975
+ }
1976
+
1977
+ /* STORE THOSE NEWLY LABELED NODES TO WHICH FLOW AUGMENTATION IS POSSIBLE. */
1978
+
1979
+ naugnod = 0;
1980
+ i__1 = nlabel;
1981
+ for (j = nscan + 1; j <= i__1; ++j) {
1982
+ node2 = blk1_3.label[j - 1];
1983
+ if (posit && arrayb_2.dfct[node2 - 1] < 0) {
1984
+ ++naugnod;
1985
+ blk7_2.save[naugnod - 1] = node2;
1986
+ } else if (! posit && arrayb_2.dfct[node2 - 1] > 0) {
1987
+ ++naugnod;
1988
+ blk7_2.save[naugnod - 1] = node2;
1989
+ }
1990
+ /* L530: */
1991
+ }
1992
+
1993
+ /* CHECK IF FLOW AUGMENTATION IS POSSIBLE. */
1994
+ /* IF NOT, RETURN TO SCAN ANOTHER NODE. */
1995
+
1996
+ L4210:
1997
+
1998
+ if (naugnod == 0) {
1999
+ goto L4120;
2000
+ }
2001
+
2002
+ i__1 = naugnod;
2003
+ for (j = 1; j <= i__1; ++j) {
2004
+ ++output_1.num_augm__;
2005
+ augnod = blk7_2.save[j - 1];
2006
+ if (posit) {
2007
+
2008
+ /* DO THE AUGMENTATION FROM NODE WITH POSITIVE DEFICIT. */
2009
+
2010
+ dx = -arrayb_2.dfct[augnod - 1];
2011
+ ib = augnod;
2012
+ L1500:
2013
+ if (ib != node) {
2014
+ arc = blk2_3.prdcsr[ib - 1];
2015
+ if (arc > 0) {
2016
+ /* Computing MIN */
2017
+ i__2 = dx, i__3 = arrayx_1.x[arc - 1];
2018
+ dx = min(i__2,i__3);
2019
+ ib = arrays_1.startn[arc - 1];
2020
+ } else {
2021
+ /* Computing MIN */
2022
+ i__2 = dx, i__3 = arrayu_1.u[-arc - 1];
2023
+ dx = min(i__2,i__3);
2024
+ ib = arraye_1.endn[-arc - 1];
2025
+ }
2026
+ goto L1500;
2027
+ }
2028
+ /* Computing MIN */
2029
+ i__2 = dx, i__3 = arrayb_2.dfct[node - 1];
2030
+ dx = min(i__2,i__3);
2031
+ if (dx > 0) {
2032
+
2033
+ /* INCREASE (DECREASE) THE FLOW OF ALL FORWARD (BACKWARD) */
2034
+ /* ARCS IN THE FLOW AUGMENTING PATH. ADJUST NODE DEFICIT ACCORDINGLY. */
2035
+
2036
+ if (blk14_2.nxtqueue[augnod - 1] == 0) {
2037
+ blk14_2.nxtqueue[prevnode - 1] = augnod;
2038
+ blk14_2.nxtqueue[augnod - 1] = node;
2039
+ prevnode = augnod;
2040
+ }
2041
+ arrayb_2.dfct[augnod - 1] += dx;
2042
+ arrayb_2.dfct[node - 1] -= dx;
2043
+ ib = augnod;
2044
+ L1501:
2045
+ if (ib != node) {
2046
+ arc = blk2_3.prdcsr[ib - 1];
2047
+ if (arc > 0) {
2048
+ arrayx_1.x[arc - 1] -= dx;
2049
+ arrayu_1.u[arc - 1] += dx;
2050
+ ib = arrays_1.startn[arc - 1];
2051
+ } else {
2052
+ narc = -arc;
2053
+ arrayx_1.x[narc - 1] += dx;
2054
+ arrayu_1.u[narc - 1] -= dx;
2055
+ ib = arraye_1.endn[narc - 1];
2056
+ }
2057
+ goto L1501;
2058
+ }
2059
+ }
2060
+ } else {
2061
+
2062
+ /* DO THE AUGMENTATION FROM NODE WITH NEGATIVE DEFICIT. */
2063
+
2064
+ dx = arrayb_2.dfct[augnod - 1];
2065
+ ib = augnod;
2066
+ L1502:
2067
+ if (ib != node) {
2068
+ arc = blk2_3.prdcsr[ib - 1];
2069
+ if (arc > 0) {
2070
+ /* Computing MIN */
2071
+ i__2 = dx, i__3 = arrayx_1.x[arc - 1];
2072
+ dx = min(i__2,i__3);
2073
+ ib = arraye_1.endn[arc - 1];
2074
+ } else {
2075
+ /* Computing MIN */
2076
+ i__2 = dx, i__3 = arrayu_1.u[-arc - 1];
2077
+ dx = min(i__2,i__3);
2078
+ ib = arrays_1.startn[-arc - 1];
2079
+ }
2080
+ goto L1502;
2081
+ }
2082
+ /* Computing MIN */
2083
+ i__2 = dx, i__3 = -arrayb_2.dfct[node - 1];
2084
+ dx = min(i__2,i__3);
2085
+ if (dx > 0) {
2086
+
2087
+ /* UPDATE THE FLOW AND DEFICITS. */
2088
+
2089
+ if (blk14_2.nxtqueue[augnod - 1] == 0) {
2090
+ blk14_2.nxtqueue[prevnode - 1] = augnod;
2091
+ blk14_2.nxtqueue[augnod - 1] = node;
2092
+ prevnode = augnod;
2093
+ }
2094
+ arrayb_2.dfct[augnod - 1] -= dx;
2095
+ arrayb_2.dfct[node - 1] += dx;
2096
+ ib = augnod;
2097
+ L1503:
2098
+ if (ib != node) {
2099
+ arc = blk2_3.prdcsr[ib - 1];
2100
+ if (arc > 0) {
2101
+ arrayx_1.x[arc - 1] -= dx;
2102
+ arrayu_1.u[arc - 1] += dx;
2103
+ ib = arraye_1.endn[arc - 1];
2104
+ } else {
2105
+ narc = -arc;
2106
+ arrayx_1.x[narc - 1] += dx;
2107
+ arrayu_1.u[narc - 1] -= dx;
2108
+ ib = arrays_1.startn[narc - 1];
2109
+ }
2110
+ goto L1503;
2111
+ }
2112
+ }
2113
+ }
2114
+ if (arrayb_2.dfct[node - 1] == 0) {
2115
+ goto L100;
2116
+ }
2117
+ if (arrayb_2.dfct[augnod - 1] != 0) {
2118
+ switch__ = FALSE_;
2119
+ }
2120
+ /* L4096: */
2121
+ }
2122
+
2123
+ /* IF NODE STILL HAS NONZERO DEFICIT AND ALL NEWLY */
2124
+ /* LABELED NODES HAVE SAME SIGN FOR THEIR DEFICIT AS */
2125
+ /* NODE, WE CAN CONTINUE LABELING. IN THIS CASE, CONTINUE */
2126
+ /* LABELING ONLY WHEN FLOW AUGMENTATION IS DONE */
2127
+ /* RELATIVELY INFREQUENTLY. */
2128
+
2129
+ if (switch__ && output_1.iter > output_1.num_augm__ << 3) {
2130
+ goto L4120;
2131
+ }
2132
+
2133
+ /* RETURN TO DO ANOTHER RELAXATION ITERATION. */
2134
+
2135
+ goto L100;
2136
+
2137
+ /* PROBLEM IS FOUND TO BE INFEASIBLE */
2138
+
2139
+ L4400:
2140
+ return RELAX4_INFEASIBLE;
2141
+ } /* relax4_ */
2142
+
2143
+ #undef ddpos
2144
+ #undef ddneg
2145
+
2146
+
2147
+ /* Subroutine */ int auction_(void)
2148
+ {
2149
+ /* System generated locals */
2150
+ integer i__1;
2151
+
2152
+ /* Subroutine */ int s_stop(char *, ftnlen);
2153
+
2154
+ /* Local variables */
2155
+ static integer seclevel, red_cost__, bstlevel, prevnode, i__, new_level__,
2156
+ prevlevel, lastqueue, num_passes__, arc, end, nas, prd, eps,
2157
+ thresh_dfct__, node, pend, naug, incr, last, pass, term, flow,
2158
+ root, resid, pterm, start, secarc, factor, extarc, rdcost, nolist,
2159
+ pstart, prevarc, pr_term__, mincost, maxcost, nxtnode;
2160
+
2161
+ /* --------------------------------------------------------------- */
2162
+
2163
+ /* PURPOSE - THIS SUBROUTINE USES A VERSION OF THE AUCTION */
2164
+ /* ALGORITHM FOR MIN COST NETWORK FLOW TO COMPUTE A */
2165
+ /* GOOD INITIAL FLOW AND PRICES FOR THE PROBLEM. */
2166
+
2167
+ /* --------------------------------------------------------------- */
2168
+
2169
+ /* MAXNN = DIMENSION OF NODE-LENGTH ARRAYS */
2170
+ /* MAXNA = DIMENSION OF ARC-LENGTH ARRAYS */
2171
+
2172
+
2173
+ /* INPUT PARAMETERS */
2174
+
2175
+ /* N = NUMBER OF NODES */
2176
+ /* NA = NUMBER OF ARCS */
2177
+ /* LARGE = A VERY LARGE INTEGER TO REPRESENT INFINITY */
2178
+ /* (SEE NOTE 3) */
2179
+ /* STARTN(I) = STARTING NODE FOR THE I-TH ARC, I = 1,...,NA */
2180
+ /* ENDN(I) = ENDING NODE FOR THE I-TH ARC, I = 1,...,NA */
2181
+ /* FOU(I) = FIRST ARC LEAVING I-TH NODE, I = 1,...,N */
2182
+ /* NXTOU(I) = NEXT ARC LEAVING THE STARTING NODE OF J-TH ARC, */
2183
+ /* I = 1,...,NA */
2184
+ /* FIN(I) = FIRST ARC ENTERING I-TH NODE, I = 1,...,N */
2185
+ /* NXTIN(I) = NEXT ARC ENTERING THE ENDING NODE OF J-TH ARC, */
2186
+ /* I = 1,...,NA */
2187
+
2188
+
2189
+ /* UPDATED PARAMETERS */
2190
+
2191
+ /* RC(J) = REDUCED COST OF ARC J, J = 1,...,NA */
2192
+ /* U(J) = RESIDUAL CAPACITY OF ARC J, */
2193
+ /* J = 1,...,NA */
2194
+ /* X(J) = FLOW ON ARC J, J = 1,...,NA */
2195
+ /* DFCT(I) = DEFICIT AT NODE I, I = 1,...,N */
2196
+
2197
+
2198
+ /* OUTPUT PARAMETERS */
2199
+
2200
+
2201
+ /* WORKING PARAMETERS */
2202
+
2203
+
2204
+ /* START INITIALIZATION USING AUCTION */
2205
+
2206
+ naug = 0;
2207
+ pass = 0;
2208
+ thresh_dfct__ = 0;
2209
+
2210
+ /* FACTOR DETERMINES BY HOW MUCH EPSILON IS REDUCED AT EACH MINIMIZATION */
2211
+
2212
+ factor = 3;
2213
+
2214
+ /* NUM_PASSES DETERMINES HOW MANY AUCTION SCALING PHASES ARE PERFORMED */
2215
+
2216
+ num_passes__ = 1;
2217
+ /* SET ARC FLOWS TO SATISFY CS AND CALCULATE MAXCOST AND MINCOST */
2218
+ maxcost = -input_1.large;
2219
+ mincost = input_1.large;
2220
+ i__1 = input_1.na;
2221
+ for (arc = 1; arc <= i__1; ++arc) {
2222
+ start = arrays_1.startn[arc - 1];
2223
+ end = arraye_1.endn[arc - 1];
2224
+ rdcost = arrayrc_1.rc[arc - 1];
2225
+ if (maxcost < rdcost) {
2226
+ maxcost = rdcost;
2227
+ }
2228
+ if (mincost > rdcost) {
2229
+ mincost = rdcost;
2230
+ }
2231
+ if (rdcost < 0) {
2232
+ arrayb_2.dfct[start - 1] += arrayu_1.u[arc - 1];
2233
+ arrayb_2.dfct[end - 1] -= arrayu_1.u[arc - 1];
2234
+ arrayx_1.x[arc - 1] = arrayu_1.u[arc - 1];
2235
+ arrayu_1.u[arc - 1] = 0;
2236
+ } else {
2237
+ arrayx_1.x[arc - 1] = 0;
2238
+ }
2239
+ /* L49: */
2240
+ }
2241
+
2242
+ /* SET INITIAL EPSILON */
2243
+
2244
+ if (maxcost - mincost >= 8) {
2245
+ eps = (maxcost - mincost) / 8;
2246
+ } else {
2247
+ eps = 1;
2248
+ }
2249
+
2250
+ /* SET INITIAL PRICES TO ZERO */
2251
+
2252
+ i__1 = input_1.n;
2253
+ for (node = 1; node <= i__1; ++node) {
2254
+ blk1_4.p[node - 1] = 0;
2255
+ /* L48: */
2256
+ }
2257
+
2258
+ /* INITIALIZATION USING AUCTION/SHORTEST PATHS. */
2259
+ /* START OF THE FIRST SCALING PHASE. */
2260
+
2261
+ L100:
2262
+ ++pass;
2263
+ if (pass == num_passes__ || eps == 1) {
2264
+ cr_1.crash = 0;
2265
+ }
2266
+ nolist = 0;
2267
+
2268
+ /* CONSTRUCT LIST OF POSITIVE SURPLUS NODES AND QUEUE OF NEGATIVE SURPLUS */
2269
+ /* NODES */
2270
+
2271
+ i__1 = input_1.n;
2272
+ for (node = 1; node <= i__1; ++node) {
2273
+ blk2_3.prdcsr[node - 1] = 0;
2274
+ blk9_2.path_id__[node - 1] = FALSE_;
2275
+ blk15_2.extend_arc__[node - 1] = 0;
2276
+ blk16_2.sb_level__[node - 1] = -input_1.large;
2277
+ blk14_2.nxtqueue[node - 1] = node + 1;
2278
+ if (arrayb_2.dfct[node - 1] > 0) {
2279
+ ++nolist;
2280
+ blk7_2.save[nolist - 1] = node;
2281
+ }
2282
+ /* L110: */
2283
+ }
2284
+
2285
+ /* HACK: -O2 or -O3 with -Wall on 4.4.3 gives an "array subscript is below
2286
+ * array bounds" warning here, but I can't work out why. It seems to think
2287
+ * that input_1.n < 1, but this is not plausible. So, I've put in an
2288
+ * assertion; will see if other versions of gcc also complain.
2289
+ */
2290
+ assert(input_1.n > 0);
2291
+ blk14_2.nxtqueue[input_1.n - 1] = 1;
2292
+ root = 1;
2293
+ prevnode = input_1.n;
2294
+ lastqueue = input_1.n;
2295
+
2296
+ /* INITIALIZATION WITH DOWN ITERATIONS FOR NEGATIVE SURPLUS NODES */
2297
+
2298
+ i__1 = nolist;
2299
+ for (i__ = 1; i__ <= i__1; ++i__) {
2300
+ node = blk7_2.save[i__ - 1];
2301
+ ++output_1.nsp;
2302
+
2303
+ /* BUILD THE LIST OF ARCS W/ ROOM FOR PUSHING FLOW */
2304
+ /* AND FIND PROPER PRICE FOR DOWN ITERATION */
2305
+
2306
+ bstlevel = -input_1.large;
2307
+ blk10_2.fpushf[node - 1] = 0;
2308
+ arc = blk3_2.fou[node - 1];
2309
+ L152:
2310
+ if (arc > 0) {
2311
+ if (arrayu_1.u[arc - 1] > 0) {
2312
+ if (blk10_2.fpushf[node - 1] == 0) {
2313
+ blk10_2.fpushf[node - 1] = arc;
2314
+ blk11_2.nxtpushf[arc - 1] = 0;
2315
+ last = arc;
2316
+ } else {
2317
+ blk11_2.nxtpushf[last - 1] = arc;
2318
+ blk11_2.nxtpushf[arc - 1] = 0;
2319
+ last = arc;
2320
+ }
2321
+ }
2322
+ if (arrayx_1.x[arc - 1] > 0) {
2323
+ new_level__ = blk1_4.p[arraye_1.endn[arc - 1] - 1] +
2324
+ arrayrc_1.rc[arc - 1];
2325
+ if (new_level__ > bstlevel) {
2326
+ bstlevel = new_level__;
2327
+ extarc = arc;
2328
+ }
2329
+ }
2330
+ arc = blk4_2.nxtou[arc - 1];
2331
+ goto L152;
2332
+ }
2333
+
2334
+ blk12_2.fpushb[node - 1] = 0;
2335
+ arc = blk5_2.fin[node - 1];
2336
+ L154:
2337
+ if (arc > 0) {
2338
+ if (arrayx_1.x[arc - 1] > 0) {
2339
+ if (blk12_2.fpushb[node - 1] == 0) {
2340
+ blk12_2.fpushb[node - 1] = arc;
2341
+ blk13_2.nxtpushb[arc - 1] = 0;
2342
+ last = arc;
2343
+ } else {
2344
+ blk13_2.nxtpushb[last - 1] = arc;
2345
+ blk13_2.nxtpushb[arc - 1] = 0;
2346
+ last = arc;
2347
+ }
2348
+ }
2349
+ if (arrayu_1.u[arc - 1] > 0) {
2350
+ new_level__ = blk1_4.p[arrays_1.startn[arc - 1] - 1] -
2351
+ arrayrc_1.rc[arc - 1];
2352
+ if (new_level__ > bstlevel) {
2353
+ bstlevel = new_level__;
2354
+ extarc = -arc;
2355
+ }
2356
+ }
2357
+ arc = blk6_2.nxtin[arc - 1];
2358
+ goto L154;
2359
+ }
2360
+ blk15_2.extend_arc__[node - 1] = extarc;
2361
+ blk1_4.p[node - 1] = bstlevel - eps;
2362
+ /* L150: */
2363
+ }
2364
+
2365
+ /* START THE AUGMENTATION CYCLES OF THE NEW SCALING PHASE. */
2366
+
2367
+ L200:
2368
+ if (arrayb_2.dfct[root - 1] >= thresh_dfct__) {
2369
+ goto L3000;
2370
+ }
2371
+ term = root;
2372
+ blk9_2.path_id__[root - 1] = TRUE_;
2373
+
2374
+ /* MAIN FORWARD ALGORITHM WITH ROOT AS ORIGIN. */
2375
+
2376
+ L500:
2377
+ /* START OF A NEW FORWARD ITERATION */
2378
+
2379
+ pterm = blk1_4.p[term - 1];
2380
+ extarc = blk15_2.extend_arc__[term - 1];
2381
+ if (extarc == 0) {
2382
+
2383
+ /* BUILD THE LIST OF ARCS W/ ROOM FOR PUSHING FLOW */
2384
+
2385
+ blk10_2.fpushf[term - 1] = 0;
2386
+ arc = blk3_2.fou[term - 1];
2387
+ L502:
2388
+ if (arc > 0) {
2389
+ if (arrayu_1.u[arc - 1] > 0) {
2390
+ if (blk10_2.fpushf[term - 1] == 0) {
2391
+ blk10_2.fpushf[term - 1] = arc;
2392
+ blk11_2.nxtpushf[arc - 1] = 0;
2393
+ last = arc;
2394
+ } else {
2395
+ blk11_2.nxtpushf[last - 1] = arc;
2396
+ blk11_2.nxtpushf[arc - 1] = 0;
2397
+ last = arc;
2398
+ }
2399
+ }
2400
+ arc = blk4_2.nxtou[arc - 1];
2401
+ goto L502;
2402
+ }
2403
+
2404
+ blk12_2.fpushb[term - 1] = 0;
2405
+ arc = blk5_2.fin[term - 1];
2406
+ L504:
2407
+ if (arc > 0) {
2408
+ if (arrayx_1.x[arc - 1] > 0) {
2409
+ if (blk12_2.fpushb[term - 1] == 0) {
2410
+ blk12_2.fpushb[term - 1] = arc;
2411
+ blk13_2.nxtpushb[arc - 1] = 0;
2412
+ last = arc;
2413
+ } else {
2414
+ blk13_2.nxtpushb[last - 1] = arc;
2415
+ blk13_2.nxtpushb[arc - 1] = 0;
2416
+ last = arc;
2417
+ }
2418
+ }
2419
+ arc = blk6_2.nxtin[arc - 1];
2420
+ goto L504;
2421
+ }
2422
+ goto L600;
2423
+ }
2424
+
2425
+ /* SPECULATIVE PATH EXTENSION ATTEMPT */
2426
+ /* NOTE: ARC>0 MEANS THAT ARC IS ORIENTED FROM THE ROOT TO THE DESTINATIONS */
2427
+ /* ARC<0 MEANS THAT ARC IS ORIENTED FROM THE DESTINATIONS TO THE ROOT */
2428
+ /* EXTARC=0 OR PRDARC=0, MEANS THE EXTENSION ARC OR THE PREDECESSOR ARC, */
2429
+ /* RESPECTIVELY, HAS NOT BEEN ESTABLISHED */
2430
+
2431
+ /* L510: */
2432
+ if (extarc > 0) {
2433
+ if (arrayu_1.u[extarc - 1] == 0) {
2434
+ seclevel = blk16_2.sb_level__[term - 1];
2435
+ goto L580;
2436
+ }
2437
+ end = arraye_1.endn[extarc - 1];
2438
+ bstlevel = blk1_4.p[end - 1] + arrayrc_1.rc[extarc - 1];
2439
+ if (pterm >= bstlevel) {
2440
+ if (blk9_2.path_id__[end - 1]) {
2441
+ goto L1200;
2442
+ }
2443
+ term = end;
2444
+ blk2_3.prdcsr[term - 1] = extarc;
2445
+ blk9_2.path_id__[term - 1] = TRUE_;
2446
+
2447
+ /* IF NEGATIVE SURPLUS NODE IS FOUND, DO AN AUGMENTATION */
2448
+
2449
+ if (arrayb_2.dfct[term - 1] > 0) {
2450
+ goto L2000;
2451
+ }
2452
+
2453
+ /* RETURN FOR ANOTHER ITERATION */
2454
+
2455
+ goto L500;
2456
+ }
2457
+ } else {
2458
+ extarc = -extarc;
2459
+ if (arrayx_1.x[extarc - 1] == 0) {
2460
+ seclevel = blk16_2.sb_level__[term - 1];
2461
+ goto L580;
2462
+ }
2463
+ start = arrays_1.startn[extarc - 1];
2464
+ bstlevel = blk1_4.p[start - 1] - arrayrc_1.rc[extarc - 1];
2465
+ if (pterm >= bstlevel) {
2466
+ if (blk9_2.path_id__[start - 1]) {
2467
+ goto L1200;
2468
+ }
2469
+ term = start;
2470
+ blk2_3.prdcsr[term - 1] = -extarc;
2471
+ blk9_2.path_id__[term - 1] = TRUE_;
2472
+
2473
+ /* IF NEGATIVE SURPLUS NODE IS FOUND, DO AN AUGMENTATION */
2474
+
2475
+ if (arrayb_2.dfct[term - 1] > 0) {
2476
+ goto L2000;
2477
+ }
2478
+
2479
+ /* RETURN FOR ANOTHER ITERATION */
2480
+
2481
+ goto L500;
2482
+ }
2483
+ }
2484
+
2485
+ /* SECOND BEST LOGIC TEST APPLIED TO SAVE A FULL NODE SCAN */
2486
+ /* IF OLD BEST LEVEL CONTINUES TO BE BEST GO FOR ANOTHER CONTRACTION */
2487
+
2488
+ L550:
2489
+ seclevel = blk16_2.sb_level__[term - 1];
2490
+ if (bstlevel <= seclevel) {
2491
+ goto L800;
2492
+ }
2493
+
2494
+ /* IF SECOND BEST CAN BE USED DO EITHER A CONTRACTION */
2495
+ /* OR START OVER WITH A SPECULATIVE EXTENSION */
2496
+
2497
+ L580:
2498
+ if (seclevel > -input_1.large) {
2499
+ extarc = blk17_2.sb_arc__[term - 1];
2500
+ if (extarc > 0) {
2501
+ if (arrayu_1.u[extarc - 1] == 0) {
2502
+ goto L600;
2503
+ }
2504
+ bstlevel = blk1_4.p[arraye_1.endn[extarc - 1] - 1] + arrayrc_1.rc[
2505
+ extarc - 1];
2506
+ } else {
2507
+ if (arrayx_1.x[-extarc - 1] == 0) {
2508
+ goto L600;
2509
+ }
2510
+ bstlevel = blk1_4.p[arrays_1.startn[-extarc - 1] - 1] -
2511
+ arrayrc_1.rc[-extarc - 1];
2512
+ }
2513
+ if (bstlevel == seclevel) {
2514
+ blk16_2.sb_level__[term - 1] = -input_1.large;
2515
+ blk15_2.extend_arc__[term - 1] = extarc;
2516
+ goto L800;
2517
+ }
2518
+ }
2519
+
2520
+ /* EXTENSION/CONTRACTION ATTEMPT WAS UNSUCCESSFUL, SO SCAN TERMINAL NODE */
2521
+
2522
+ L600:
2523
+ ++output_1.nsp;
2524
+ bstlevel = input_1.large;
2525
+ seclevel = input_1.large;
2526
+ arc = blk10_2.fpushf[term - 1];
2527
+ L700:
2528
+ if (arc > 0) {
2529
+ new_level__ = blk1_4.p[arraye_1.endn[arc - 1] - 1] + arrayrc_1.rc[arc
2530
+ - 1];
2531
+ if (new_level__ < seclevel) {
2532
+ if (new_level__ < bstlevel) {
2533
+ seclevel = bstlevel;
2534
+ bstlevel = new_level__;
2535
+ secarc = extarc;
2536
+ extarc = arc;
2537
+ } else {
2538
+ seclevel = new_level__;
2539
+ secarc = arc;
2540
+ }
2541
+ }
2542
+ arc = blk11_2.nxtpushf[arc - 1];
2543
+ goto L700;
2544
+ }
2545
+ arc = blk12_2.fpushb[term - 1];
2546
+ L710:
2547
+ if (arc > 0) {
2548
+ new_level__ = blk1_4.p[arrays_1.startn[arc - 1] - 1] - arrayrc_1.rc[
2549
+ arc - 1];
2550
+ if (new_level__ < seclevel) {
2551
+ if (new_level__ < bstlevel) {
2552
+ seclevel = bstlevel;
2553
+ bstlevel = new_level__;
2554
+ secarc = extarc;
2555
+ extarc = -arc;
2556
+ } else {
2557
+ seclevel = new_level__;
2558
+ secarc = -arc;
2559
+ }
2560
+ }
2561
+ arc = blk13_2.nxtpushb[arc - 1];
2562
+ goto L710;
2563
+ }
2564
+ blk16_2.sb_level__[term - 1] = seclevel;
2565
+ blk17_2.sb_arc__[term - 1] = secarc;
2566
+ blk15_2.extend_arc__[term - 1] = extarc;
2567
+
2568
+ /* END OF NODE SCAN. */
2569
+ /* IF THE TERMINAL NODE IS THE ROOT, ADJUST ITS PRICE AND CHANGE ROOT */
2570
+
2571
+ L800:
2572
+ if (term == root) {
2573
+ blk1_4.p[term - 1] = bstlevel + eps;
2574
+ if (pterm >= input_1.large) {
2575
+ return RELAX4_INFEASIBLE;
2576
+ }
2577
+ blk9_2.path_id__[root - 1] = FALSE_;
2578
+ prevnode = root;
2579
+ root = blk14_2.nxtqueue[root - 1];
2580
+ goto L200;
2581
+ }
2582
+
2583
+ /* CHECK WHETHER EXTENSION OR CONTRACTION */
2584
+
2585
+ prd = blk2_3.prdcsr[term - 1];
2586
+ if (prd > 0) {
2587
+ pr_term__ = arrays_1.startn[prd - 1];
2588
+ prevlevel = blk1_4.p[pr_term__ - 1] - arrayrc_1.rc[prd - 1];
2589
+ } else {
2590
+ pr_term__ = arraye_1.endn[-prd - 1];
2591
+ prevlevel = blk1_4.p[pr_term__ - 1] + arrayrc_1.rc[-prd - 1];
2592
+ }
2593
+
2594
+ if (prevlevel > bstlevel) {
2595
+
2596
+ /* PATH EXTENSION */
2597
+
2598
+ if (prevlevel >= bstlevel + eps) {
2599
+ blk1_4.p[term - 1] = bstlevel + eps;
2600
+ } else {
2601
+ blk1_4.p[term - 1] = prevlevel;
2602
+ }
2603
+ if (extarc > 0) {
2604
+ end = arraye_1.endn[extarc - 1];
2605
+ if (blk9_2.path_id__[end - 1]) {
2606
+ goto L1200;
2607
+ }
2608
+ term = end;
2609
+ } else {
2610
+ start = arrays_1.startn[-extarc - 1];
2611
+ if (blk9_2.path_id__[start - 1]) {
2612
+ goto L1200;
2613
+ }
2614
+ term = start;
2615
+ }
2616
+ blk2_3.prdcsr[term - 1] = extarc;
2617
+ blk9_2.path_id__[term - 1] = TRUE_;
2618
+
2619
+ /* IF NEGATIVE SURPLUS NODE IS FOUND, DO AN AUGMENTATION */
2620
+
2621
+ if (arrayb_2.dfct[term - 1] > 0) {
2622
+ goto L2000;
2623
+ }
2624
+
2625
+ /* RETURN FOR ANOTHER ITERATION */
2626
+
2627
+ goto L500;
2628
+ } else {
2629
+
2630
+ /* PATH CONTRACTION. */
2631
+
2632
+ blk1_4.p[term - 1] = bstlevel + eps;
2633
+ blk9_2.path_id__[term - 1] = FALSE_;
2634
+ term = pr_term__;
2635
+ if (pr_term__ != root) {
2636
+ if (bstlevel <= pterm + eps) {
2637
+ goto L2000;
2638
+ }
2639
+ }
2640
+ pterm = blk1_4.p[term - 1];
2641
+ extarc = prd;
2642
+ if (prd > 0) {
2643
+ bstlevel = bstlevel + eps + arrayrc_1.rc[prd - 1];
2644
+ } else {
2645
+ bstlevel = bstlevel + eps - arrayrc_1.rc[-prd - 1];
2646
+ }
2647
+
2648
+ /* DO A SECOND BEST TEST AND IF THAT FAILS, DO A FULL NODE SCAN */
2649
+
2650
+ goto L550;
2651
+ }
2652
+
2653
+ /* A CYCLE IS ABOUT TO FORM; DO A RETREAT SEQUENCE. */
2654
+
2655
+ L1200:
2656
+
2657
+ node = term;
2658
+ L1600:
2659
+ if (node != root) {
2660
+ blk9_2.path_id__[node - 1] = FALSE_;
2661
+ prd = blk2_3.prdcsr[node - 1];
2662
+ if (prd > 0) {
2663
+ pr_term__ = arrays_1.startn[prd - 1];
2664
+ if (blk1_4.p[pr_term__ - 1] == blk1_4.p[node - 1] + arrayrc_1.rc[
2665
+ prd - 1] + eps) {
2666
+ node = pr_term__;
2667
+ goto L1600;
2668
+ }
2669
+ } else {
2670
+ pr_term__ = arraye_1.endn[-prd - 1];
2671
+ if (blk1_4.p[pr_term__ - 1] == blk1_4.p[node - 1] - arrayrc_1.rc[
2672
+ -prd - 1] + eps) {
2673
+ node = pr_term__;
2674
+ goto L1600;
2675
+ }
2676
+ }
2677
+
2678
+ /* DO A FULL SCAN AND PRICE RISE AT PR_TERM */
2679
+
2680
+ ++output_1.nsp;
2681
+ bstlevel = input_1.large;
2682
+ seclevel = input_1.large;
2683
+ arc = blk10_2.fpushf[pr_term__ - 1];
2684
+ L1700:
2685
+ if (arc > 0) {
2686
+ new_level__ = blk1_4.p[arraye_1.endn[arc - 1] - 1] + arrayrc_1.rc[
2687
+ arc - 1];
2688
+ if (new_level__ < seclevel) {
2689
+ if (new_level__ < bstlevel) {
2690
+ seclevel = bstlevel;
2691
+ bstlevel = new_level__;
2692
+ secarc = extarc;
2693
+ extarc = arc;
2694
+ } else {
2695
+ seclevel = new_level__;
2696
+ secarc = arc;
2697
+ }
2698
+ }
2699
+ arc = blk11_2.nxtpushf[arc - 1];
2700
+ goto L1700;
2701
+ }
2702
+
2703
+ arc = blk12_2.fpushb[pr_term__ - 1];
2704
+ L1710:
2705
+ if (arc > 0) {
2706
+ new_level__ = blk1_4.p[arrays_1.startn[arc - 1] - 1] -
2707
+ arrayrc_1.rc[arc - 1];
2708
+ if (new_level__ < seclevel) {
2709
+ if (new_level__ < bstlevel) {
2710
+ seclevel = bstlevel;
2711
+ bstlevel = new_level__;
2712
+ secarc = extarc;
2713
+ extarc = -arc;
2714
+ } else {
2715
+ seclevel = new_level__;
2716
+ secarc = -arc;
2717
+ }
2718
+ }
2719
+ arc = blk13_2.nxtpushb[arc - 1];
2720
+ goto L1710;
2721
+ }
2722
+ blk16_2.sb_level__[pr_term__ - 1] = seclevel;
2723
+ blk17_2.sb_arc__[pr_term__ - 1] = secarc;
2724
+ blk15_2.extend_arc__[pr_term__ - 1] = extarc;
2725
+ blk1_4.p[pr_term__ - 1] = bstlevel + eps;
2726
+ if (pr_term__ == root) {
2727
+ prevnode = root;
2728
+ blk9_2.path_id__[root - 1] = FALSE_;
2729
+ root = blk14_2.nxtqueue[root - 1];
2730
+ goto L200;
2731
+ }
2732
+ blk9_2.path_id__[pr_term__ - 1] = FALSE_;
2733
+ prd = blk2_3.prdcsr[pr_term__ - 1];
2734
+ if (prd > 0) {
2735
+ term = arrays_1.startn[prd - 1];
2736
+ } else {
2737
+ term = arraye_1.endn[-prd - 1];
2738
+ }
2739
+ if (term == root) {
2740
+ prevnode = root;
2741
+ blk9_2.path_id__[root - 1] = FALSE_;
2742
+ root = blk14_2.nxtqueue[root - 1];
2743
+ goto L200;
2744
+ } else {
2745
+ goto L2000;
2746
+ }
2747
+ }
2748
+
2749
+ /* END OF AUCTION/SHORTEST PATH ROUTINE. */
2750
+ /* DO AUGMENTATION FROM ROOT AND CORRECT THE PUSH LISTS */
2751
+
2752
+ L2000:
2753
+ incr = -arrayb_2.dfct[root - 1];
2754
+ node = root;
2755
+ L2050:
2756
+ extarc = blk15_2.extend_arc__[node - 1];
2757
+ blk9_2.path_id__[node - 1] = FALSE_;
2758
+ if (extarc > 0) {
2759
+ node = arraye_1.endn[extarc - 1];
2760
+ if (incr > arrayu_1.u[extarc - 1]) {
2761
+ incr = arrayu_1.u[extarc - 1];
2762
+ }
2763
+ } else {
2764
+ node = arrays_1.startn[-extarc - 1];
2765
+ if (incr > arrayx_1.x[-extarc - 1]) {
2766
+ incr = arrayx_1.x[-extarc - 1];
2767
+ }
2768
+ }
2769
+ if (node != term) {
2770
+ goto L2050;
2771
+ }
2772
+ blk9_2.path_id__[term - 1] = FALSE_;
2773
+ if (arrayb_2.dfct[term - 1] > 0) {
2774
+ if (incr > arrayb_2.dfct[term - 1]) {
2775
+ incr = arrayb_2.dfct[term - 1];
2776
+ }
2777
+ }
2778
+
2779
+ node = root;
2780
+ L2100:
2781
+ extarc = blk15_2.extend_arc__[node - 1];
2782
+ if (extarc > 0) {
2783
+ end = arraye_1.endn[extarc - 1];
2784
+
2785
+ /* ADD ARC TO THE REDUCED GRAPH */
2786
+
2787
+ if (arrayx_1.x[extarc - 1] == 0) {
2788
+ blk13_2.nxtpushb[extarc - 1] = blk12_2.fpushb[end - 1];
2789
+ blk12_2.fpushb[end - 1] = extarc;
2790
+ new_level__ = blk1_4.p[node - 1] - arrayrc_1.rc[extarc - 1];
2791
+ if (blk16_2.sb_level__[end - 1] > new_level__) {
2792
+ blk16_2.sb_level__[end - 1] = new_level__;
2793
+ blk17_2.sb_arc__[end - 1] = -extarc;
2794
+ }
2795
+ }
2796
+ arrayx_1.x[extarc - 1] += incr;
2797
+ arrayu_1.u[extarc - 1] -= incr;
2798
+
2799
+ /* REMOVE ARC FROM THE REDUCED GRAPH */
2800
+
2801
+ if (arrayu_1.u[extarc - 1] == 0) {
2802
+ ++nas;
2803
+ arc = blk10_2.fpushf[node - 1];
2804
+ if (arc == extarc) {
2805
+ blk10_2.fpushf[node - 1] = blk11_2.nxtpushf[arc - 1];
2806
+ } else {
2807
+ prevarc = arc;
2808
+ arc = blk11_2.nxtpushf[arc - 1];
2809
+ L2200:
2810
+ if (arc > 0) {
2811
+ if (arc == extarc) {
2812
+ blk11_2.nxtpushf[prevarc - 1] = blk11_2.nxtpushf[arc
2813
+ - 1];
2814
+ goto L2250;
2815
+ }
2816
+ prevarc = arc;
2817
+ arc = blk11_2.nxtpushf[arc - 1];
2818
+ goto L2200;
2819
+ }
2820
+ }
2821
+ }
2822
+ L2250:
2823
+ node = end;
2824
+ } else {
2825
+ extarc = -extarc;
2826
+ start = arrays_1.startn[extarc - 1];
2827
+
2828
+ /* ADD ARC TO THE REDUCED GRAPH */
2829
+
2830
+ if (arrayu_1.u[extarc - 1] == 0) {
2831
+ blk11_2.nxtpushf[extarc - 1] = blk10_2.fpushf[start - 1];
2832
+ blk10_2.fpushf[start - 1] = extarc;
2833
+ new_level__ = blk1_4.p[node - 1] + arrayrc_1.rc[extarc - 1];
2834
+ if (blk16_2.sb_level__[start - 1] > new_level__) {
2835
+ blk16_2.sb_level__[start - 1] = new_level__;
2836
+ blk17_2.sb_arc__[start - 1] = extarc;
2837
+ }
2838
+ }
2839
+ arrayu_1.u[extarc - 1] += incr;
2840
+ arrayx_1.x[extarc - 1] -= incr;
2841
+
2842
+ /* REMOVE ARC FROM THE REDUCED GRAPH */
2843
+
2844
+ if (arrayx_1.x[extarc - 1] == 0) {
2845
+ ++nas;
2846
+ arc = blk12_2.fpushb[node - 1];
2847
+ if (arc == extarc) {
2848
+ blk12_2.fpushb[node - 1] = blk13_2.nxtpushb[arc - 1];
2849
+ } else {
2850
+ prevarc = arc;
2851
+ arc = blk13_2.nxtpushb[arc - 1];
2852
+ L2300:
2853
+ if (arc > 0) {
2854
+ if (arc == extarc) {
2855
+ blk13_2.nxtpushb[prevarc - 1] = blk13_2.nxtpushb[arc
2856
+ - 1];
2857
+ goto L2350;
2858
+ }
2859
+ prevarc = arc;
2860
+ arc = blk13_2.nxtpushb[arc - 1];
2861
+ goto L2300;
2862
+ }
2863
+ }
2864
+ }
2865
+ L2350:
2866
+ node = start;
2867
+ }
2868
+ if (node != term) {
2869
+ goto L2100;
2870
+ }
2871
+ arrayb_2.dfct[term - 1] -= incr;
2872
+ arrayb_2.dfct[root - 1] += incr;
2873
+
2874
+ /* INSERT TERM IN THE QUEUE IF IT HAS A LARGE ENOUGH SURPLUS */
2875
+
2876
+ if (arrayb_2.dfct[term - 1] < thresh_dfct__) {
2877
+ if (blk14_2.nxtqueue[term - 1] == 0) {
2878
+ nxtnode = blk14_2.nxtqueue[root - 1];
2879
+ if (blk1_4.p[term - 1] >= blk1_4.p[nxtnode - 1] && root !=
2880
+ nxtnode) {
2881
+ blk14_2.nxtqueue[root - 1] = term;
2882
+ blk14_2.nxtqueue[term - 1] = nxtnode;
2883
+ } else {
2884
+ blk14_2.nxtqueue[prevnode - 1] = term;
2885
+ blk14_2.nxtqueue[term - 1] = root;
2886
+ prevnode = term;
2887
+ }
2888
+ }
2889
+ }
2890
+
2891
+ /* IF ROOT HAS A LARGE ENOUGH SURPLUS, KEEP IT */
2892
+ /* IN THE QUEUE AND RETURN FOR ANOTHER ITERATION */
2893
+
2894
+ if (arrayb_2.dfct[root - 1] < thresh_dfct__) {
2895
+ prevnode = root;
2896
+ root = blk14_2.nxtqueue[root - 1];
2897
+ goto L200;
2898
+ }
2899
+
2900
+ /* END OF AUGMENTATION CYCLE */
2901
+
2902
+ L3000:
2903
+
2904
+ /* CHECK FOR TERMINATION OF SCALING PHASE. IF SCALING PHASE IS */
2905
+ /* NOT FINISHED, ADVANCE THE QUEUE AND RETURN TO TAKE ANOTHER NODE. */
2906
+
2907
+ nxtnode = blk14_2.nxtqueue[root - 1];
2908
+ if (root != nxtnode) {
2909
+ blk14_2.nxtqueue[root - 1] = 0;
2910
+ blk14_2.nxtqueue[prevnode - 1] = nxtnode;
2911
+ root = nxtnode;
2912
+ goto L200;
2913
+ }
2914
+
2915
+ /* END OF SUBPROBLEM (SCALING PHASE). */
2916
+
2917
+ /* L3600: */
2918
+
2919
+ /* REDUCE EPSILON. */
2920
+
2921
+ eps /= factor;
2922
+ if (eps < 1) {
2923
+ eps = 1;
2924
+ }
2925
+ thresh_dfct__ /= factor;
2926
+ if (eps == 1) {
2927
+ thresh_dfct__ = 0;
2928
+ }
2929
+
2930
+ /* IF ANOTHER AUCTION SCALING PHASE REMAINS, RESET THE FLOWS & THE PUSH LISTS */
2931
+ /* ELSE RESET ARC FLOWS TO SATISFY CS AND COMPUTE REDUCED COSTS */
2932
+
2933
+ if (cr_1.crash == 1) {
2934
+ i__1 = input_1.na;
2935
+ for (arc = 1; arc <= i__1; ++arc) {
2936
+ start = arrays_1.startn[arc - 1];
2937
+ end = arraye_1.endn[arc - 1];
2938
+ pstart = blk1_4.p[start - 1];
2939
+ pend = blk1_4.p[end - 1];
2940
+ if (pstart > pend + eps + arrayrc_1.rc[arc - 1]) {
2941
+ resid = arrayu_1.u[arc - 1];
2942
+ if (resid > 0) {
2943
+ arrayb_2.dfct[start - 1] += resid;
2944
+ arrayb_2.dfct[end - 1] -= resid;
2945
+ arrayx_1.x[arc - 1] += resid;
2946
+ arrayu_1.u[arc - 1] = 0;
2947
+ }
2948
+ } else {
2949
+ if (pstart < pend - eps + arrayrc_1.rc[arc - 1]) {
2950
+ flow = arrayx_1.x[arc - 1];
2951
+ if (flow > 0) {
2952
+ arrayb_2.dfct[start - 1] -= flow;
2953
+ arrayb_2.dfct[end - 1] += flow;
2954
+ arrayx_1.x[arc - 1] = 0;
2955
+ arrayu_1.u[arc - 1] += flow;
2956
+ }
2957
+ }
2958
+ }
2959
+ /* L3800: */
2960
+ }
2961
+
2962
+ /* RETURN FOR ANOTHER PHASE */
2963
+
2964
+ /* L3850: */
2965
+ goto L100;
2966
+ } else {
2967
+ cr_1.crash = 1;
2968
+ i__1 = input_1.na;
2969
+ for (arc = 1; arc <= i__1; ++arc) {
2970
+ start = arrays_1.startn[arc - 1];
2971
+ end = arraye_1.endn[arc - 1];
2972
+ red_cost__ = arrayrc_1.rc[arc - 1] + blk1_4.p[end - 1] - blk1_4.p[
2973
+ start - 1];
2974
+ if (red_cost__ < 0) {
2975
+ resid = arrayu_1.u[arc - 1];
2976
+ if (resid > 0) {
2977
+ arrayb_2.dfct[start - 1] += resid;
2978
+ arrayb_2.dfct[end - 1] -= resid;
2979
+ arrayx_1.x[arc - 1] += resid;
2980
+ arrayu_1.u[arc - 1] = 0;
2981
+ }
2982
+ } else {
2983
+ if (red_cost__ > 0) {
2984
+ flow = arrayx_1.x[arc - 1];
2985
+ if (flow > 0) {
2986
+ arrayb_2.dfct[start - 1] -= flow;
2987
+ arrayb_2.dfct[end - 1] += flow;
2988
+ arrayx_1.x[arc - 1] = 0;
2989
+ arrayu_1.u[arc - 1] += flow;
2990
+ }
2991
+ }
2992
+ }
2993
+ arrayrc_1.rc[arc - 1] = red_cost__;
2994
+ /* L3900: */
2995
+ }
2996
+ }
2997
+ return 0;
2998
+ } /* auction_ */
2999
+
3000
+
3001
+
3002
+ /* Subroutine */ int ascnt1_(integer *dm, integer *delx, integer *nlabel,
3003
+ logical1 *feasbl, logical1 *switch__, integer *nscan, integer *
3004
+ curnode, integer *prevnode)
3005
+ {
3006
+ /* System generated locals */
3007
+ integer i__1;
3008
+
3009
+ /* Local variables */
3010
+ static integer i__, j, t1, t2, t3, nb, arc, dlx, node, node2, nsave,
3011
+ delprc, rdcost;
3012
+
3013
+
3014
+ /* --------------------------------------------------------------- */
3015
+
3016
+ /* PURPOSE - THIS SUBROUTINE PERFORMS THE MULTI-NODE PRICE */
3017
+ /* ADJUSTMENT STEP FOR THE CASE WHERE THE SCANNED NODES */
3018
+ /* HAVE POSITIVE DEFICIT. IT FIRST CHECKS IF DECREASING */
3019
+ /* THE PRICE OF THE SCANNED NODES INCREASES THE DUAL COST. */
3020
+ /* IF YES, THEN IT DECREASES THE PRICE OF ALL SCANNED NODES. */
3021
+ /* THERE ARE TWO POSSIBILITIES FOR PRICE DECREASE: */
3022
+ /* IF SWITCH=.TRUE., THEN THE SET OF SCANNED NODES */
3023
+ /* CORRESPONDS TO AN ELEMENTARY DIRECTION OF MAXIMAL */
3024
+ /* RATE OF ASCENT, IN WHICH CASE THE PRICE OF ALL SCANNED */
3025
+ /* NODES ARE DECREASED UNTIL THE NEXT BREAKPOINT IN THE */
3026
+ /* DUAL COST IS ENCOUNTERED. AT THIS POINT, SOME ARC */
3027
+ /* BECOMES BALANCED AND MORE NODE(S) ARE ADDED TO THE */
3028
+ /* LABELED SET AND THE SUBROUTINE IS EXITED. */
3029
+ /* IF SWITCH=.FALSE., THEN THE PRICE OF ALL SCANNED NODES */
3030
+ /* ARE DECREASED UNTIL THE RATE OF ASCENT BECOMES */
3031
+ /* NEGATIVE (THIS CORRESPONDS TO THE PRICE ADJUSTMENT */
3032
+ /* STEP IN WHICH BOTH THE LINE SEARCH AND THE DEGENERATE */
3033
+ /* ASCENT ITERATION ARE IMPLEMENTED). */
3034
+
3035
+ /* --------------------------------------------------------------- */
3036
+
3037
+ /* MAXNN = DIMENSION OF NODE-LENGTH ARRAYS */
3038
+ /* MAXNA = DIMENSION OF ARC-LENGTH ARRAYS */
3039
+
3040
+
3041
+ /* INPUT PARAMETERS */
3042
+
3043
+ /* DM = TOTAL DEFICIT OF SCANNED NODES */
3044
+ /* SWITCH = .TRUE. IF LABELING IS TO CONTINUE AFTER PRICE CHANGE */
3045
+ /* NSCAN = NUMBER OF SCANNED NODES */
3046
+ /* CURNODE = MOST RECENTLY SCANNED NODE */
3047
+ /* N = NUMBER OF NODES */
3048
+ /* NA = NUMBER OF ARCS */
3049
+ /* LARGE = A VERY LARGE INTEGER TO REPRESENT INFINITY */
3050
+ /* (SEE NOTE 3) */
3051
+ /* STARTN(I) = STARTING NODE FOR THE I-TH ARC, I = 1,...,NA */
3052
+ /* ENDN(I) = ENDING NODE FOR THE I-TH ARC, I = 1,...,NA */
3053
+ /* FOU(I) = FIRST ARC LEAVING I-TH NODE, I = 1,...,N */
3054
+ /* NXTOU(I) = NEXT ARC LEAVING THE STARTING NODE OF J-TH ARC, */
3055
+ /* I = 1,...,NA */
3056
+ /* FIN(I) = FIRST ARC ENTERING I-TH NODE, I = 1,...,N */
3057
+ /* NXTIN(I) = NEXT ARC ENTERING THE ENDING NODE OF J-TH ARC, */
3058
+ /* I = 1,...,NA */
3059
+
3060
+
3061
+ /* UPDATED PARAMETERS */
3062
+
3063
+ /* DELX = A LOWER ESTIMATE OF THE TOTAL FLOW ON BALANCED ARCS */
3064
+ /* IN THE SCANNED-NODES CUT */
3065
+ /* NLABEL = NUMBER OF LABELED NODES */
3066
+ /* FEASBL = .FALSE. IF PROBLEM IS FOUND TO BE INFEASIBLE */
3067
+ /* PREVNODE = THE NODE BEFORE CURNODE IN QUEUE */
3068
+ /* RC(J) = REDUCED COST OF ARC J, J = 1,...,NA */
3069
+ /* U(J) = RESIDUAL CAPACITY OF ARC J, */
3070
+ /* J = 1,...,NA */
3071
+ /* X(J) = FLOW ON ARC J, J = 1,...,NA */
3072
+ /* DFCT(I) = DEFICIT AT NODE I, I = 1,...,N */
3073
+ /* LABEL(K) = K-TH NODE LABELED, K = 1,NLABEL */
3074
+ /* PRDCSR(I) = PREDECESSOR OF NODE I IN TREE OF LABELED NODES */
3075
+ /* (O IF I IS UNLABELED), I = 1,...,N */
3076
+ /* TFSTOU(I) = FIRST BALANCED ARC OUT OF NODE I, I = 1,...,N */
3077
+ /* TNXTOU(J) = NEXT BALANCED ARC OUT OF THE STARTING NODE OF ARC J, */
3078
+ /* J = 1,...,NA */
3079
+ /* TFSTIN(I) = FIRST BALANCED ARC INTO NODE I, I = 1,...,N */
3080
+ /* TNXTIN(J) = NEXT BALANCED ARC INTO THE ENDING NODE OF ARC J, */
3081
+ /* J = 1,...,NA */
3082
+ /* NXTQUEUE(I) = NODE FOLLOWING NODE I IN THE FIFO QUEUE */
3083
+ /* (0 IF NODE IS NOT IN THE QUEUE), I = 1,...,N */
3084
+ /* SCAN(I) = .TRUE. IF NODE I IS SCANNED, I = 1,...,N */
3085
+ /* MARK(I) = .TRUE. IF NODE I IS LABELED, I = 1,...,N */
3086
+
3087
+
3088
+ /* WORKING PARAMETERS */
3089
+
3090
+
3091
+ /* STORE THE ARCS BETWEEN THE SET OF SCANNED NODES AND */
3092
+ /* ITS COMPLEMENT IN SAVE AND COMPUTE DELPRC, THE STEPSIZE */
3093
+ /* TO THE NEXT BREAKPOINT IN THE DUAL COST IN THE DIRECTION */
3094
+ /* OF DECREASING PRICES OF THE SCANNED NODES. */
3095
+ /* [THE ARCS ARE STORED INTO SAVE BY LOOKING AT THE ARCS */
3096
+ /* INCIDENT TO EITHER THE SET OF SCANNED NODES OR ITS */
3097
+ /* COMPLEMENT, DEPENDING ON WHETHER NSCAN>N/2 OR NOT. */
3098
+ /* THIS IMPROVES THE EFFICIENCY OF STORING.] */
3099
+
3100
+ delprc = input_1.large;
3101
+ dlx = 0;
3102
+ nsave = 0;
3103
+ if (*nscan <= input_1.n / 2) {
3104
+ i__1 = *nscan;
3105
+ for (i__ = 1; i__ <= i__1; ++i__) {
3106
+ node = blk1_3.label[i__ - 1];
3107
+ arc = blk3_2.fou[node - 1];
3108
+ L500:
3109
+ if (arc > 0) {
3110
+
3111
+ /* ARC POINTS FROM SCANNED NODE TO AN UNSCANNED NODE. */
3112
+
3113
+ node2 = arraye_1.endn[arc - 1];
3114
+ if (! blk8_1.scan[node2 - 1]) {
3115
+ ++nsave;
3116
+ blk7_2.save[nsave - 1] = arc;
3117
+ rdcost = arrayrc_1.rc[arc - 1];
3118
+ if (rdcost == 0 && blk2_3.prdcsr[node2 - 1] != arc) {
3119
+ dlx += arrayx_1.x[arc - 1];
3120
+ }
3121
+ if (rdcost < 0 && rdcost > -delprc) {
3122
+ delprc = -rdcost;
3123
+ }
3124
+ }
3125
+ arc = blk4_2.nxtou[arc - 1];
3126
+ goto L500;
3127
+ }
3128
+ arc = blk5_2.fin[node - 1];
3129
+ L501:
3130
+ if (arc > 0) {
3131
+
3132
+ /* ARC POINTS FROM UNSCANNED NODE TO SCANNED NODE. */
3133
+
3134
+ node2 = arrays_1.startn[arc - 1];
3135
+ if (! blk8_1.scan[node2 - 1]) {
3136
+ ++nsave;
3137
+ blk7_2.save[nsave - 1] = -arc;
3138
+ rdcost = arrayrc_1.rc[arc - 1];
3139
+ if (rdcost == 0 && blk2_3.prdcsr[node2 - 1] != -arc) {
3140
+ dlx += arrayu_1.u[arc - 1];
3141
+ }
3142
+ if (rdcost > 0 && rdcost < delprc) {
3143
+ delprc = rdcost;
3144
+ }
3145
+ }
3146
+ arc = blk6_2.nxtin[arc - 1];
3147
+ goto L501;
3148
+ }
3149
+ /* L1: */
3150
+ }
3151
+ } else {
3152
+ i__1 = input_1.n;
3153
+ for (node = 1; node <= i__1; ++node) {
3154
+ if (blk8_1.scan[node - 1]) {
3155
+ goto L2;
3156
+ }
3157
+ arc = blk5_2.fin[node - 1];
3158
+ L502:
3159
+ if (arc > 0) {
3160
+ node2 = arrays_1.startn[arc - 1];
3161
+ if (blk8_1.scan[node2 - 1]) {
3162
+ ++nsave;
3163
+ blk7_2.save[nsave - 1] = arc;
3164
+ rdcost = arrayrc_1.rc[arc - 1];
3165
+ if (rdcost == 0 && blk2_3.prdcsr[node - 1] != arc) {
3166
+ dlx += arrayx_1.x[arc - 1];
3167
+ }
3168
+ if (rdcost < 0 && rdcost > -delprc) {
3169
+ delprc = -rdcost;
3170
+ }
3171
+ }
3172
+ arc = blk6_2.nxtin[arc - 1];
3173
+ goto L502;
3174
+ }
3175
+ arc = blk3_2.fou[node - 1];
3176
+ L503:
3177
+ if (arc > 0) {
3178
+ node2 = arraye_1.endn[arc - 1];
3179
+ if (blk8_1.scan[node2 - 1]) {
3180
+ ++nsave;
3181
+ blk7_2.save[nsave - 1] = -arc;
3182
+ rdcost = arrayrc_1.rc[arc - 1];
3183
+ if (rdcost == 0 && blk2_3.prdcsr[node - 1] != -arc) {
3184
+ dlx += arrayu_1.u[arc - 1];
3185
+ }
3186
+ if (rdcost > 0 && rdcost < delprc) {
3187
+ delprc = rdcost;
3188
+ }
3189
+ }
3190
+ arc = blk4_2.nxtou[arc - 1];
3191
+ goto L503;
3192
+ }
3193
+ L2:
3194
+ ;
3195
+ }
3196
+ }
3197
+
3198
+ /* CHECK IF THE SET OF SCANNED NODES TRULY CORRESPONDS */
3199
+ /* TO A DUAL ASCENT DIRECTION. [HERE DELX+DLX IS THE EXACT */
3200
+ /* SUM OF THE FLOW ON ARCS FROM THE SCANNED SET TO THE */
3201
+ /* UNSCANNED SET PLUS THE (CAPACITY - FLOW) ON ARCS FROM */
3202
+ /* THE UNSCANNED SET TO THE SCANNED SET.] */
3203
+ /* IF THIS WERE NOT THE CASE, SET SWITCH TO .TRUE. */
3204
+ /* AND EXIT SUBROUTINE. */
3205
+
3206
+ if (! (*switch__) && *delx + dlx >= *dm) {
3207
+ *switch__ = TRUE_;
3208
+ return 0;
3209
+ }
3210
+ *delx += dlx;
3211
+
3212
+ /* CHECK THAT THE PROBLEM IS FEASIBLE. */
3213
+
3214
+ L4:
3215
+ if (delprc == input_1.large) {
3216
+
3217
+ /* WE CAN INCREASE THE DUAL COST WITHOUT BOUND, SO */
3218
+ /* THE PRIMAL PROBLEM IS INFEASIBLE. */
3219
+
3220
+ *feasbl = FALSE_;
3221
+ return 0;
3222
+ }
3223
+
3224
+ /* DECREASE THE PRICES OF THE SCANNED NODES, ADD MORE */
3225
+ /* NODES TO THE LABELED SET AND CHECK IF A NEWLY LABELED NODE */
3226
+ /* HAS NEGATIVE DEFICIT. */
3227
+
3228
+ if (*switch__) {
3229
+ i__1 = nsave;
3230
+ for (i__ = 1; i__ <= i__1; ++i__) {
3231
+ arc = blk7_2.save[i__ - 1];
3232
+ if (arc > 0) {
3233
+ arrayrc_1.rc[arc - 1] += delprc;
3234
+ if (arrayrc_1.rc[arc - 1] == 0) {
3235
+ node2 = arraye_1.endn[arc - 1];
3236
+ if (blk11_1.tnxtou[arc - 1] < 0) {
3237
+ blk11_1.tnxtou[arc - 1] = blk10_1.tfstou[
3238
+ arrays_1.startn[arc - 1] - 1];
3239
+ blk10_1.tfstou[arrays_1.startn[arc - 1] - 1] = arc;
3240
+ }
3241
+ if (blk13_1.tnxtin[arc - 1] < 0) {
3242
+ blk13_1.tnxtin[arc - 1] = blk12_1.tfstin[node2 - 1];
3243
+ blk12_1.tfstin[node2 - 1] = arc;
3244
+ }
3245
+ if (! blk9_1.mark[node2 - 1]) {
3246
+ blk2_3.prdcsr[node2 - 1] = arc;
3247
+ ++(*nlabel);
3248
+ blk1_3.label[*nlabel - 1] = node2;
3249
+ blk9_1.mark[node2 - 1] = TRUE_;
3250
+ }
3251
+ }
3252
+ } else {
3253
+ arc = -arc;
3254
+ arrayrc_1.rc[arc - 1] -= delprc;
3255
+ if (arrayrc_1.rc[arc - 1] == 0) {
3256
+ node2 = arrays_1.startn[arc - 1];
3257
+ if (blk11_1.tnxtou[arc - 1] < 0) {
3258
+ blk11_1.tnxtou[arc - 1] = blk10_1.tfstou[node2 - 1];
3259
+ blk10_1.tfstou[node2 - 1] = arc;
3260
+ }
3261
+ if (blk13_1.tnxtin[arc - 1] < 0) {
3262
+ blk13_1.tnxtin[arc - 1] = blk12_1.tfstin[
3263
+ arraye_1.endn[arc - 1] - 1];
3264
+ blk12_1.tfstin[arraye_1.endn[arc - 1] - 1] = arc;
3265
+ }
3266
+ if (! blk9_1.mark[node2 - 1]) {
3267
+ blk2_3.prdcsr[node2 - 1] = -arc;
3268
+ ++(*nlabel);
3269
+ blk1_3.label[*nlabel - 1] = node2;
3270
+ blk9_1.mark[node2 - 1] = TRUE_;
3271
+ }
3272
+ }
3273
+ }
3274
+ /* L7: */
3275
+ }
3276
+ return 0;
3277
+ } else {
3278
+
3279
+ /* DECREASE THE PRICES OF THE SCANNED NODES BY DELPRC. */
3280
+ /* ADJUST FLOW TO MAINTAIN COMPLEMENTARY SLACKNESS WITH */
3281
+ /* THE PRICES. */
3282
+
3283
+ nb = 0;
3284
+ i__1 = nsave;
3285
+ for (i__ = 1; i__ <= i__1; ++i__) {
3286
+ arc = blk7_2.save[i__ - 1];
3287
+ if (arc > 0) {
3288
+ t1 = arrayrc_1.rc[arc - 1];
3289
+ if (t1 == 0) {
3290
+ t2 = arrayx_1.x[arc - 1];
3291
+ t3 = arrays_1.startn[arc - 1];
3292
+ arrayb_2.dfct[t3 - 1] -= t2;
3293
+ if (blk14_2.nxtqueue[t3 - 1] == 0) {
3294
+ blk14_2.nxtqueue[*prevnode - 1] = t3;
3295
+ blk14_2.nxtqueue[t3 - 1] = *curnode;
3296
+ *prevnode = t3;
3297
+ }
3298
+ t3 = arraye_1.endn[arc - 1];
3299
+ arrayb_2.dfct[t3 - 1] += t2;
3300
+ if (blk14_2.nxtqueue[t3 - 1] == 0) {
3301
+ blk14_2.nxtqueue[*prevnode - 1] = t3;
3302
+ blk14_2.nxtqueue[t3 - 1] = *curnode;
3303
+ *prevnode = t3;
3304
+ }
3305
+ arrayu_1.u[arc - 1] += t2;
3306
+ arrayx_1.x[arc - 1] = 0;
3307
+ }
3308
+ arrayrc_1.rc[arc - 1] = t1 + delprc;
3309
+ if (arrayrc_1.rc[arc - 1] == 0) {
3310
+ *delx += arrayx_1.x[arc - 1];
3311
+ ++nb;
3312
+ blk2_3.prdcsr[nb - 1] = arc;
3313
+ }
3314
+ } else {
3315
+ arc = -arc;
3316
+ t1 = arrayrc_1.rc[arc - 1];
3317
+ if (t1 == 0) {
3318
+ t2 = arrayu_1.u[arc - 1];
3319
+ t3 = arrays_1.startn[arc - 1];
3320
+ arrayb_2.dfct[t3 - 1] += t2;
3321
+ if (blk14_2.nxtqueue[t3 - 1] == 0) {
3322
+ blk14_2.nxtqueue[*prevnode - 1] = t3;
3323
+ blk14_2.nxtqueue[t3 - 1] = *curnode;
3324
+ *prevnode = t3;
3325
+ }
3326
+ t3 = arraye_1.endn[arc - 1];
3327
+ arrayb_2.dfct[t3 - 1] -= t2;
3328
+ if (blk14_2.nxtqueue[t3 - 1] == 0) {
3329
+ blk14_2.nxtqueue[*prevnode - 1] = t3;
3330
+ blk14_2.nxtqueue[t3 - 1] = *curnode;
3331
+ *prevnode = t3;
3332
+ }
3333
+ arrayx_1.x[arc - 1] += t2;
3334
+ arrayu_1.u[arc - 1] = 0;
3335
+ }
3336
+ arrayrc_1.rc[arc - 1] = t1 - delprc;
3337
+ if (arrayrc_1.rc[arc - 1] == 0) {
3338
+ *delx += arrayu_1.u[arc - 1];
3339
+ ++nb;
3340
+ blk2_3.prdcsr[nb - 1] = arc;
3341
+ }
3342
+ }
3343
+ /* L6: */
3344
+ }
3345
+ }
3346
+
3347
+ if (*delx <= *dm) {
3348
+
3349
+ /* THE SET OF SCANNED NODES STILL CORRESPONDS TO A */
3350
+ /* DUAL (POSSIBLY DEGENERATE) ASCENT DIRECTON. COMPUTE */
3351
+ /* THE STEPSIZE DELPRC TO THE NEXT BREAKPOINT IN THE */
3352
+ /* DUAL COST. */
3353
+
3354
+ delprc = input_1.large;
3355
+ i__1 = nsave;
3356
+ for (i__ = 1; i__ <= i__1; ++i__) {
3357
+ arc = blk7_2.save[i__ - 1];
3358
+ if (arc > 0) {
3359
+ rdcost = arrayrc_1.rc[arc - 1];
3360
+ if (rdcost < 0 && rdcost > -delprc) {
3361
+ delprc = -rdcost;
3362
+ }
3363
+ } else {
3364
+ arc = -arc;
3365
+ rdcost = arrayrc_1.rc[arc - 1];
3366
+ if (rdcost > 0 && rdcost < delprc) {
3367
+ delprc = rdcost;
3368
+ }
3369
+ }
3370
+ /* L10: */
3371
+ }
3372
+ if (delprc != input_1.large || *delx < *dm) {
3373
+ goto L4;
3374
+ }
3375
+ }
3376
+
3377
+ /* ADD NEW BALANCED ARCS TO THE SUPERSET OF BALANCED ARCS. */
3378
+
3379
+ i__1 = nb;
3380
+ for (i__ = 1; i__ <= i__1; ++i__) {
3381
+ arc = blk2_3.prdcsr[i__ - 1];
3382
+ if (blk13_1.tnxtin[arc - 1] == -1) {
3383
+ j = arraye_1.endn[arc - 1];
3384
+ blk13_1.tnxtin[arc - 1] = blk12_1.tfstin[j - 1];
3385
+ blk12_1.tfstin[j - 1] = arc;
3386
+ }
3387
+ if (blk11_1.tnxtou[arc - 1] == -1) {
3388
+ j = arrays_1.startn[arc - 1];
3389
+ blk11_1.tnxtou[arc - 1] = blk10_1.tfstou[j - 1];
3390
+ blk10_1.tfstou[j - 1] = arc;
3391
+ }
3392
+ /* L9: */
3393
+ }
3394
+ return 0;
3395
+ } /* ascnt1_ */
3396
+
3397
+
3398
+
3399
+ /* Subroutine */ int ascnt2_(integer *dm, integer *delx, integer *nlabel,
3400
+ logical1 *feasbl, logical1 *switch__, integer *nscan, integer *
3401
+ curnode, integer *prevnode)
3402
+ {
3403
+ /* System generated locals */
3404
+ integer i__1;
3405
+
3406
+ /* Local variables */
3407
+ static integer i__, j, t1, t2, t3, nb, arc, dlx, node, node2, nsave,
3408
+ delprc, rdcost;
3409
+
3410
+
3411
+ /* --------------------------------------------------------------- */
3412
+
3413
+ /* PURPOSE - THIS ROUTINE IS ANALOGOUS TO ASCNT BUT FOR */
3414
+ /* THE CASE WHERE THE SCANNED NODES HAVE NEGATIVE DEFICIT. */
3415
+
3416
+ /* --------------------------------------------------------------- */
3417
+
3418
+ /* MAXNN = DIMENSION OF NODE-LENGTH ARRAYS */
3419
+ /* MAXNA = DIMENSION OF ARC-LENGTH ARRAYS */
3420
+
3421
+
3422
+
3423
+ /* STORE THE ARCS BETWEEN THE SET OF SCANNED NODES AND */
3424
+ /* ITS COMPLEMENT IN SAVE AND COMPUTE DELPRC, THE STEPSIZE */
3425
+ /* TO THE NEXT BREAKPOINT IN THE DUAL COST IN THE DIRECTION */
3426
+ /* OF INCREASING PRICES OF THE SCANNED NODES. */
3427
+
3428
+ delprc = input_1.large;
3429
+ dlx = 0;
3430
+ nsave = 0;
3431
+ if (*nscan <= input_1.n / 2) {
3432
+ i__1 = *nscan;
3433
+ for (i__ = 1; i__ <= i__1; ++i__) {
3434
+ node = blk1_3.label[i__ - 1];
3435
+ arc = blk5_2.fin[node - 1];
3436
+ L500:
3437
+ if (arc > 0) {
3438
+ node2 = arrays_1.startn[arc - 1];
3439
+ if (! blk8_1.scan[node2 - 1]) {
3440
+ ++nsave;
3441
+ blk7_2.save[nsave - 1] = arc;
3442
+ rdcost = arrayrc_1.rc[arc - 1];
3443
+ if (rdcost == 0 && blk2_3.prdcsr[node2 - 1] != arc) {
3444
+ dlx += arrayx_1.x[arc - 1];
3445
+ }
3446
+ if (rdcost < 0 && rdcost > -delprc) {
3447
+ delprc = -rdcost;
3448
+ }
3449
+ }
3450
+ arc = blk6_2.nxtin[arc - 1];
3451
+ goto L500;
3452
+ }
3453
+ arc = blk3_2.fou[node - 1];
3454
+ L501:
3455
+ if (arc > 0) {
3456
+ node2 = arraye_1.endn[arc - 1];
3457
+ if (! blk8_1.scan[node2 - 1]) {
3458
+ ++nsave;
3459
+ blk7_2.save[nsave - 1] = -arc;
3460
+ rdcost = arrayrc_1.rc[arc - 1];
3461
+ if (rdcost == 0 && blk2_3.prdcsr[node2 - 1] != -arc) {
3462
+ dlx += arrayu_1.u[arc - 1];
3463
+ }
3464
+ if (rdcost > 0 && rdcost < delprc) {
3465
+ delprc = rdcost;
3466
+ }
3467
+ }
3468
+ arc = blk4_2.nxtou[arc - 1];
3469
+ goto L501;
3470
+ }
3471
+ /* L1: */
3472
+ }
3473
+ } else {
3474
+ i__1 = input_1.n;
3475
+ for (node = 1; node <= i__1; ++node) {
3476
+ if (blk8_1.scan[node - 1]) {
3477
+ goto L2;
3478
+ }
3479
+ arc = blk3_2.fou[node - 1];
3480
+ L502:
3481
+ if (arc > 0) {
3482
+ node2 = arraye_1.endn[arc - 1];
3483
+ if (blk8_1.scan[node2 - 1]) {
3484
+ ++nsave;
3485
+ blk7_2.save[nsave - 1] = arc;
3486
+ rdcost = arrayrc_1.rc[arc - 1];
3487
+ if (rdcost == 0 && blk2_3.prdcsr[node - 1] != arc) {
3488
+ dlx += arrayx_1.x[arc - 1];
3489
+ }
3490
+ if (rdcost < 0 && rdcost > -delprc) {
3491
+ delprc = -rdcost;
3492
+ }
3493
+ }
3494
+ arc = blk4_2.nxtou[arc - 1];
3495
+ goto L502;
3496
+ }
3497
+ arc = blk5_2.fin[node - 1];
3498
+ L503:
3499
+ if (arc > 0) {
3500
+ node2 = arrays_1.startn[arc - 1];
3501
+ if (blk8_1.scan[node2 - 1]) {
3502
+ ++nsave;
3503
+ blk7_2.save[nsave - 1] = -arc;
3504
+ rdcost = arrayrc_1.rc[arc - 1];
3505
+ if (rdcost == 0 && blk2_3.prdcsr[node - 1] != -arc) {
3506
+ dlx += arrayu_1.u[arc - 1];
3507
+ }
3508
+ if (rdcost > 0 && rdcost < delprc) {
3509
+ delprc = rdcost;
3510
+ }
3511
+ }
3512
+ arc = blk6_2.nxtin[arc - 1];
3513
+ goto L503;
3514
+ }
3515
+ L2:
3516
+ ;
3517
+ }
3518
+ }
3519
+
3520
+ if (! (*switch__) && *delx + dlx >= -(*dm)) {
3521
+ *switch__ = TRUE_;
3522
+ return 0;
3523
+ }
3524
+ *delx += dlx;
3525
+
3526
+ /* CHECK THAT THE PROBLEM IS FEASIBLE. */
3527
+
3528
+ L4:
3529
+ if (delprc == input_1.large) {
3530
+ *feasbl = FALSE_;
3531
+ return 0;
3532
+ }
3533
+
3534
+ /* INCREASE THE PRICES OF THE SCANNED NODES, ADD MORE */
3535
+ /* NODES TO THE LABELED SET AND CHECK IF A NEWLY LABELED NODE */
3536
+ /* HAS POSITIVE DEFICIT. */
3537
+
3538
+ if (*switch__) {
3539
+ i__1 = nsave;
3540
+ for (i__ = 1; i__ <= i__1; ++i__) {
3541
+ arc = blk7_2.save[i__ - 1];
3542
+ if (arc > 0) {
3543
+ arrayrc_1.rc[arc - 1] += delprc;
3544
+ if (arrayrc_1.rc[arc - 1] == 0) {
3545
+ node2 = arrays_1.startn[arc - 1];
3546
+ if (blk11_1.tnxtou[arc - 1] < 0) {
3547
+ blk11_1.tnxtou[arc - 1] = blk10_1.tfstou[node2 - 1];
3548
+ blk10_1.tfstou[node2 - 1] = arc;
3549
+ }
3550
+ if (blk13_1.tnxtin[arc - 1] < 0) {
3551
+ blk13_1.tnxtin[arc - 1] = blk12_1.tfstin[
3552
+ arraye_1.endn[arc - 1] - 1];
3553
+ blk12_1.tfstin[arraye_1.endn[arc - 1] - 1] = arc;
3554
+ }
3555
+ if (! blk9_1.mark[node2 - 1]) {
3556
+ blk2_3.prdcsr[node2 - 1] = arc;
3557
+ ++(*nlabel);
3558
+ blk1_3.label[*nlabel - 1] = node2;
3559
+ blk9_1.mark[node2 - 1] = TRUE_;
3560
+ }
3561
+ }
3562
+ } else {
3563
+ arc = -arc;
3564
+ arrayrc_1.rc[arc - 1] -= delprc;
3565
+ if (arrayrc_1.rc[arc - 1] == 0) {
3566
+ node2 = arraye_1.endn[arc - 1];
3567
+ if (blk11_1.tnxtou[arc - 1] < 0) {
3568
+ blk11_1.tnxtou[arc - 1] = blk10_1.tfstou[
3569
+ arrays_1.startn[arc - 1] - 1];
3570
+ blk10_1.tfstou[arrays_1.startn[arc - 1] - 1] = arc;
3571
+ }
3572
+ if (blk13_1.tnxtin[arc - 1] < 0) {
3573
+ blk13_1.tnxtin[arc - 1] = blk12_1.tfstin[node2 - 1];
3574
+ blk12_1.tfstin[node2 - 1] = arc;
3575
+ }
3576
+ if (! blk9_1.mark[node2 - 1]) {
3577
+ blk2_3.prdcsr[node2 - 1] = -arc;
3578
+ ++(*nlabel);
3579
+ blk1_3.label[*nlabel - 1] = node2;
3580
+ blk9_1.mark[node2 - 1] = TRUE_;
3581
+ }
3582
+ }
3583
+ }
3584
+ /* L7: */
3585
+ }
3586
+ return 0;
3587
+ } else {
3588
+ nb = 0;
3589
+ i__1 = nsave;
3590
+ for (i__ = 1; i__ <= i__1; ++i__) {
3591
+ arc = blk7_2.save[i__ - 1];
3592
+ if (arc > 0) {
3593
+ t1 = arrayrc_1.rc[arc - 1];
3594
+ if (t1 == 0) {
3595
+ t2 = arrayx_1.x[arc - 1];
3596
+ t3 = arrays_1.startn[arc - 1];
3597
+ arrayb_2.dfct[t3 - 1] -= t2;
3598
+ if (blk14_2.nxtqueue[t3 - 1] == 0) {
3599
+ blk14_2.nxtqueue[*prevnode - 1] = t3;
3600
+ blk14_2.nxtqueue[t3 - 1] = *curnode;
3601
+ *prevnode = t3;
3602
+ }
3603
+ t3 = arraye_1.endn[arc - 1];
3604
+ arrayb_2.dfct[t3 - 1] += t2;
3605
+ if (blk14_2.nxtqueue[t3 - 1] == 0) {
3606
+ blk14_2.nxtqueue[*prevnode - 1] = t3;
3607
+ blk14_2.nxtqueue[t3 - 1] = *curnode;
3608
+ *prevnode = t3;
3609
+ }
3610
+ arrayu_1.u[arc - 1] += t2;
3611
+ arrayx_1.x[arc - 1] = 0;
3612
+ }
3613
+ arrayrc_1.rc[arc - 1] = t1 + delprc;
3614
+ if (arrayrc_1.rc[arc - 1] == 0) {
3615
+ *delx += arrayx_1.x[arc - 1];
3616
+ ++nb;
3617
+ blk2_3.prdcsr[nb - 1] = arc;
3618
+ }
3619
+ } else {
3620
+ arc = -arc;
3621
+ t1 = arrayrc_1.rc[arc - 1];
3622
+ if (t1 == 0) {
3623
+ t2 = arrayu_1.u[arc - 1];
3624
+ t3 = arrays_1.startn[arc - 1];
3625
+ arrayb_2.dfct[t3 - 1] += t2;
3626
+ if (blk14_2.nxtqueue[t3 - 1] == 0) {
3627
+ blk14_2.nxtqueue[*prevnode - 1] = t3;
3628
+ blk14_2.nxtqueue[t3 - 1] = *curnode;
3629
+ *prevnode = t3;
3630
+ }
3631
+ t3 = arraye_1.endn[arc - 1];
3632
+ arrayb_2.dfct[t3 - 1] -= t2;
3633
+ if (blk14_2.nxtqueue[t3 - 1] == 0) {
3634
+ blk14_2.nxtqueue[*prevnode - 1] = t3;
3635
+ blk14_2.nxtqueue[t3 - 1] = *curnode;
3636
+ *prevnode = t3;
3637
+ }
3638
+ arrayx_1.x[arc - 1] += t2;
3639
+ arrayu_1.u[arc - 1] = 0;
3640
+ }
3641
+ arrayrc_1.rc[arc - 1] = t1 - delprc;
3642
+ if (arrayrc_1.rc[arc - 1] == 0) {
3643
+ *delx += arrayu_1.u[arc - 1];
3644
+ ++nb;
3645
+ blk2_3.prdcsr[nb - 1] = arc;
3646
+ }
3647
+ }
3648
+ /* L6: */
3649
+ }
3650
+ }
3651
+
3652
+ if (*delx <= -(*dm)) {
3653
+ delprc = input_1.large;
3654
+ i__1 = nsave;
3655
+ for (i__ = 1; i__ <= i__1; ++i__) {
3656
+ arc = blk7_2.save[i__ - 1];
3657
+ if (arc > 0) {
3658
+ rdcost = arrayrc_1.rc[arc - 1];
3659
+ if (rdcost < 0 && rdcost > -delprc) {
3660
+ delprc = -rdcost;
3661
+ }
3662
+ } else {
3663
+ arc = -arc;
3664
+ rdcost = arrayrc_1.rc[arc - 1];
3665
+ if (rdcost > 0 && rdcost < delprc) {
3666
+ delprc = rdcost;
3667
+ }
3668
+ }
3669
+ /* L10: */
3670
+ }
3671
+ if (delprc != input_1.large || *delx < -(*dm)) {
3672
+ goto L4;
3673
+ }
3674
+ }
3675
+
3676
+ /* ADD NEW BALANCED ARCS TO THE SUPERSET OF BALANCED ARCS. */
3677
+
3678
+ i__1 = nb;
3679
+ for (i__ = 1; i__ <= i__1; ++i__) {
3680
+ arc = blk2_3.prdcsr[i__ - 1];
3681
+ if (blk13_1.tnxtin[arc - 1] == -1) {
3682
+ j = arraye_1.endn[arc - 1];
3683
+ blk13_1.tnxtin[arc - 1] = blk12_1.tfstin[j - 1];
3684
+ blk12_1.tfstin[j - 1] = arc;
3685
+ }
3686
+ if (blk11_1.tnxtou[arc - 1] == -1) {
3687
+ j = arrays_1.startn[arc - 1];
3688
+ blk11_1.tnxtou[arc - 1] = blk10_1.tfstou[j - 1];
3689
+ blk10_1.tfstou[j - 1] = arc;
3690
+ }
3691
+ /* L9: */
3692
+ }
3693
+ return 0;
3694
+ } /* ascnt2_ */
3695
+
3696
+ /* Subroutine */ int addtr_(integer *arc)
3697
+ {
3698
+ static integer arc1, node;
3699
+
3700
+
3701
+ /* --------------------------------------------------------------- */
3702
+
3703
+ /* PURPOSE - THIS SUBROUTINE CHECKS IF ARC IS IN THE ARRAYS TFSTOU, TNXTOU, */
3704
+ /* TFSTIN, TNXTIN AND, IF NOT, ADDS ARC TO THEM. */
3705
+
3706
+ /* --------------------------------------------------------------- */
3707
+
3708
+ /* MAXNN = DIMENSION OF NODE-LENGTH ARRAYS */
3709
+ /* MAXNA = DIMENSION OF ARC-LENGTH ARRAYS */
3710
+
3711
+
3712
+
3713
+ node = arrays_1.startn[*arc - 1];
3714
+ arc1 = blk10_1.tfstou[node - 1];
3715
+ L10:
3716
+ if (arc1 > 0) {
3717
+ if (arc1 == *arc) {
3718
+ goto L20;
3719
+ }
3720
+ arc1 = blk11_1.tnxtou[arc1 - 1];
3721
+ goto L10;
3722
+ }
3723
+ blk11_1.tnxtou[*arc - 1] = blk10_1.tfstou[node - 1];
3724
+ blk10_1.tfstou[node - 1] = *arc;
3725
+ L20:
3726
+ node = arraye_1.endn[*arc - 1];
3727
+ arc1 = blk12_1.tfstin[node - 1];
3728
+ L30:
3729
+ if (arc1 > 0) {
3730
+ if (arc1 == *arc) {
3731
+ return 0;
3732
+ }
3733
+ arc1 = blk13_1.tnxtin[arc1 - 1];
3734
+ goto L30;
3735
+ }
3736
+ blk13_1.tnxtin[*arc - 1] = blk12_1.tfstin[node - 1];
3737
+ blk12_1.tfstin[node - 1] = *arc;
3738
+ return 0;
3739
+ } /* addtr_ */
3740
+
3741
+ int relax4_init(integer num_nodes, integer num_arcs,
3742
+ integer start_nodes[],
3743
+ integer end_nodes[],
3744
+ integer costs[],
3745
+ integer capacities[],
3746
+ integer demands[],
3747
+ integer flows[],
3748
+ integer large)
3749
+ {
3750
+ /* Set input/output pointers. */
3751
+ input_1.n = num_nodes;
3752
+ input_1.na = num_arcs;
3753
+ arrays_1.startn = start_nodes;
3754
+ arraye_1.endn = end_nodes;
3755
+ arrayc_1.c__ = costs;
3756
+ arrayu_1.u = capacities;
3757
+ arrayb_1.b = demands;
3758
+ arrayx_1.x = flows;
3759
+
3760
+ /* Set parameters. */
3761
+ input_1.large = large;
3762
+ cr_1.crash = 0;
3763
+
3764
+ /* Allocate working arrays (one per block). */
3765
+ arrayrc_1.rc = NULL;
3766
+ blk1_1.i1 = NULL;
3767
+ blk2_1.i2 = NULL;
3768
+ blk3_1.i3 = NULL;
3769
+ blk4_1.i4 = NULL;
3770
+ blk5_1.i5 = NULL;
3771
+ blk6_1.i6 = NULL;
3772
+ blk7_1.i7 = NULL;
3773
+ blk8_1.scan = NULL;
3774
+ blk9_1.mark = NULL;
3775
+ blk10_1.tfstou = NULL;
3776
+ blk11_1.tnxtou = NULL;
3777
+ blk12_1.tfstin = NULL;
3778
+ blk13_1.tnxtin = NULL;
3779
+ blk14_1.i14 = NULL;
3780
+ blk15_1.i15 = NULL;
3781
+ blk16_1.i16 = NULL;
3782
+ blk17_1.i17 = NULL;
3783
+
3784
+ arrayrc_1.rc = malloc(num_arcs*sizeof(integer));
3785
+ blk1_1.i1 = malloc(num_nodes*sizeof(integer));
3786
+ blk2_1.i2 = malloc(num_nodes*sizeof(integer));
3787
+ blk3_1.i3 = malloc(num_nodes*sizeof(integer));
3788
+ blk4_1.i4 = malloc(num_arcs*sizeof(integer));
3789
+ blk5_1.i5 = malloc(num_nodes*sizeof(integer));
3790
+ blk6_1.i6 = malloc(num_arcs*sizeof(integer));
3791
+ blk7_1.i7 = malloc(num_arcs*sizeof(integer));
3792
+ blk8_1.scan = malloc(num_nodes*sizeof(logical1));
3793
+ blk9_1.mark = malloc(num_nodes*sizeof(logical1));
3794
+ blk10_1.tfstou = malloc(num_nodes*sizeof(integer));
3795
+ blk11_1.tnxtou = malloc(num_arcs*sizeof(integer));
3796
+ blk12_1.tfstin = malloc(num_nodes*sizeof(integer));
3797
+ blk13_1.tnxtin = malloc(num_arcs*sizeof(integer));
3798
+ blk14_1.i14 = malloc(num_nodes*sizeof(integer));
3799
+ blk15_1.i15 = malloc(num_nodes*sizeof(integer));
3800
+ blk16_1.i16 = malloc(num_nodes*sizeof(integer));
3801
+ blk17_1.i17 = malloc(num_nodes*sizeof(integer));
3802
+
3803
+ if (arrayrc_1.rc == NULL ||
3804
+ blk1_1.i1 == NULL ||
3805
+ blk2_1.i2 == NULL ||
3806
+ blk3_1.i3 == NULL ||
3807
+ blk4_1.i4 == NULL ||
3808
+ blk5_1.i5 == NULL ||
3809
+ blk6_1.i6 == NULL ||
3810
+ blk7_1.i7 == NULL ||
3811
+ blk8_1.scan == NULL ||
3812
+ blk9_1.mark == NULL ||
3813
+ blk10_1.tfstou == NULL ||
3814
+ blk11_1.tnxtou == NULL ||
3815
+ blk12_1.tfstin == NULL ||
3816
+ blk13_1.tnxtin == NULL ||
3817
+ blk14_1.i14 == NULL ||
3818
+ blk15_1.i15 == NULL ||
3819
+ blk16_1.i16 == NULL ||
3820
+ blk17_1.i17 == NULL) {
3821
+ relax4_free();
3822
+ return RELAX4_FAIL_OUT_OF_MEMORY;
3823
+ }
3824
+
3825
+ return RELAX4_OK;
3826
+ }
3827
+
3828
+ int relax4_check_inputs(int max_cost)
3829
+ {
3830
+ integer i;
3831
+
3832
+ if (input_1.n < 1 || input_1.na < 1) {
3833
+ return RELAX4_FAIL_BAD_SIZE;
3834
+ }
3835
+
3836
+ /* start nodes */
3837
+ for (i = 1; i <= input_1.na; ++i) {
3838
+ if (arrays_1.startn[i-1] < 1 || arrays_1.startn[i-1] > input_1.n)
3839
+ return RELAX4_FAIL_BAD_NODE;
3840
+ }
3841
+
3842
+ /* end nodes */
3843
+ for (i = 1; i <= input_1.na; ++i) {
3844
+ if (arraye_1.endn[i-1] < 1 || arraye_1.endn[i-1] > input_1.n)
3845
+ return RELAX4_FAIL_BAD_NODE;
3846
+ }
3847
+
3848
+ /* costs */
3849
+ for (i = 1; i <= input_1.na; ++i) {
3850
+ if (abs(arrayc_1.c__[i-1]) > max_cost)
3851
+ return RELAX4_FAIL_BAD_COST;
3852
+ }
3853
+
3854
+ /* capacities */
3855
+ for (i = 1; i <= input_1.na; ++i) {
3856
+ if (arrayu_1.u[i-1] < 0 || arrayu_1.u[i-1] > input_1.large)
3857
+ return RELAX4_FAIL_BAD_CAPACITY;
3858
+ }
3859
+
3860
+ return RELAX4_OK;
3861
+ }
3862
+
3863
+ int relax4_auction()
3864
+ {
3865
+ /* SET CRASH EQUAL TO 1 TO ACTIVATE AN AUCTION/SHORTEST PATH SUBROUTINE FOR */
3866
+ /* GETTING THE INITIAL PRICE-FLOW PAIR. THIS IS RECOMMENDED FOR DIFFICULT */
3867
+ /* PROBLEMS WHERE THE DEFAULT INITIALIZATION YIELDS LONG SOLUTION TIMES. */
3868
+ cr_1.crash = 1;
3869
+ output_1.nsp = 0;
3870
+ return auction_();
3871
+ }
3872
+
3873
+ int relax4_run()
3874
+ {
3875
+ /* CALL RELAX4 TO SOLVE THE PROBLEM */
3876
+ int result = relax4_();
3877
+
3878
+ /* DISPLAY RELAX4 STATISTICS */
3879
+ /*
3880
+ if (cr_1.crash == 1) {
3881
+ printf("NUMBER OF AUCTION/SHORTEST PATH ITERATIONS = %ld\n", output_1.nsp);
3882
+ }
3883
+ printf("NUMBER OF ITERATIONS = %ld\n", output_1.iter);
3884
+ printf("NUMBER OF MULTINODE ITERATIONS = %ld\n", output_1.nmultinode);
3885
+ printf("NUMBER OF MULTINODE ASCENT STEPS = %ld\n", output_1.num_ascnt__);
3886
+ printf("NUMBER OF REGULAR AUGMENTATIONS = %ld\n", output_1.num_augm__);
3887
+ */
3888
+
3889
+ return result;
3890
+ }
3891
+
3892
+ int relax4_check_output()
3893
+ {
3894
+ integer i;
3895
+
3896
+ for (i = 1; i <= input_1.n; ++i) {
3897
+ if (arrayb_1.b[i - 1] != 0)
3898
+ return RELAX4_OUTPUT_FAIL_NONZERO_DEMAND;
3899
+ }
3900
+
3901
+ for (i = 1; i <= input_1.na; ++i) {
3902
+ if (arrayx_1.x[i - 1] > 0 && arrayrc_1.rc[i - 1] > 0)
3903
+ return RELAX4_OUTPUT_FAIL_COMPLEMENTARY_SLACKNESS;
3904
+ }
3905
+
3906
+ for (i = 1; i <= input_1.na; ++i) {
3907
+ if (arrayu_1.u[i - 1] > 0 && arrayrc_1.rc[i - 1] < 0)
3908
+ return RELAX4_OUTPUT_FAIL_COMPLEMENTARY_SLACKNESS;
3909
+ }
3910
+
3911
+ return RELAX4_OK;
3912
+ }
3913
+
3914
+ void relax4_free()
3915
+ {
3916
+ if(arrayrc_1.rc ) free(arrayrc_1.rc );
3917
+ if(blk1_1.i1 ) free(blk1_1.i1 );
3918
+ if(blk2_1.i2 ) free(blk2_1.i2 );
3919
+ if(blk3_1.i3 ) free(blk3_1.i3 );
3920
+ if(blk4_1.i4 ) free(blk4_1.i4 );
3921
+ if(blk5_1.i5 ) free(blk5_1.i5 );
3922
+ if(blk6_1.i6 ) free(blk6_1.i6 );
3923
+ if(blk7_1.i7 ) free(blk7_1.i7 );
3924
+ if(blk8_1.scan ) free(blk8_1.scan );
3925
+ if(blk9_1.mark ) free(blk9_1.mark );
3926
+ if(blk10_1.tfstou) free(blk10_1.tfstou);
3927
+ if(blk11_1.tnxtou) free(blk11_1.tnxtou);
3928
+ if(blk12_1.tfstin) free(blk12_1.tfstin);
3929
+ if(blk13_1.tnxtin) free(blk13_1.tnxtin);
3930
+ if(blk14_1.i14 ) free(blk14_1.i14 );
3931
+ if(blk15_1.i15 ) free(blk15_1.i15 );
3932
+ if(blk16_1.i16 ) free(blk16_1.i16 );
3933
+ if(blk17_1.i17 ) free(blk17_1.i17 );
3934
+ }
3935
+