Harrison 1967 Fortran

[JohnNichols]

            Do 610 I=1,L
                  IP1 = I + 1
                  TEMP = ABS(ASAT(I,I))
                  K = I
                  Do 520 J = I,L
                        DUM = ABS(ASAT(J,I)) - TEMP
                        IF(DUM)520,520,510
510                     K = J
                        TEMP = ABS(ASAT(J,I))
520               Continue
                  IF(K - I) 530, 550,530
530               DO 540 J = I,KJ
                        TEMP = ASAT(I,J)
                        ASAT(I,J) = ASAT(K,J)
                        ASAT(K,J) = TEMP
540               END Do


550               IF(ASAT(I,I)) 570, 1000, 570
570               TEMP = 1.0/ASAT(I,I)
                  do 580 J = I,KJ
                        ASAT(I,J) = ASAT(I,J)*TEMP
580               END DO

                  do 610 J = 1,L
                        IF(I-J)590,610,590
590                     TEMP = ASAT(J,I)
                        DO 600 K = IP1,KJ
                              ASAT(J,K) = ASAT(J,K) -TEMP*ASAT(I,K)
600                     END DO
610         END DO


            DO 650 I = 1,M3
                  CSAT(I) = 0.0
                  DO 651 J = 1,L
                        CSAT(I) = CSAT(I) + A(J,I)*ASAT(J,L+1)
651               END DO
650         END DO!

            DO 660 I = 1,M2
                  K = ((I+1)/2)*2-1
                  SATX(I) = SF(I,1)*CSAT(K) + SF(I,2)*CSAT(K + 1)
660         END DO

This comes from some Harrison Fortran Code in 1967 for second order elastic analysis, he says that it ran on a CD 3600 computer in 17 minutes for 17 cycles,  the code write-up does not really discuss this section, after playing with it for a while, I think this is the earliest inverter I have ever found.  

What was a CD 3600 computer? It was at Le High University and would 17 minutes be the limit they were allowed for time.   I put in a separate inverter just to make sure from Conte and De Boore,  as I tried to work out the code.  They really worked to use limited memory.  

Why is this important, running on modern computers it allows us to do major structural problems not constrained by the annoyances in the major programs. I was reading Strand7 stuff on this type of program and it was so close to some of the stuff Harrison wrote it was eerie. 

It runs in a few seconds.  

Editing out the arithmetic ifs is fun. 

[thismarkjohnson]

That’s classic CDC 3600 code — a Control Data Corporation mainframe from the 1960s, typically shared time with strict job limits, so 17 minutes was likely the allotted batch runtime. What’s impressive is how much linear algebra they squeezed out with minimal memory; that hand-rolled pivoting/inversion is very much of its era. Seeing the same ideas resurface in modern solvers just shows how solid those fundamentals were — they optimized for constraints we no longer think about.