Appendix 8. Fortrans utveckling

A 8.0 Inledning

Följande enkla program, vilket utnyttjar många olika vanliga koncept inom programmering, är baserat på ``The Early Development of Programming Languages'' av Donald E. Knuth och Luis Trabb Pardo, publicerat i ``A History of Computing in the Twentieth Century'', redigerad av N. Metropolis, J. Howlett, och Gian-Carlo Rota, Academic Press, New York 1980, sid 197 - 273. De gav ett exempel i Algol 60 och översatt till några mycket gamla språk som Zuse's Plankalkül, Goldstine's Flow diagrams, Mauchly's Short Code, Burks' Intermediate PL, Rutishauser's Klammerausdrücke, Böhm's Formules, Hopper's A-2, Laning och Zierler's Algebraic interpreter, Backus' FORTRAN 0, och Brooker's AUTOCODE.

Programmet ges här i Pascal, C och i fem varianter av Fortran, i första hand för att visa hur Fortran utvecklats från ett kryptiskt närmast maskinberoende språk till ett modernt strukturerat högnivåspråk.

Slutligen behandlas även det nya språket F, främst avsett för utbildning.

A 8.1 Program TPK i Pascal för UNIX

program tpk(input,output);
(*  Pascal program for Unix  *)
var     i : integer;
        y : real;
        a : array [0..10] of real;
        function f ( t : real) : real;
           begin
                f := sqrt(abs(t)) + 5*t*t*t
           end;
begin
        for i := 0 to 10 do read(a[i]);
        for i := 10 downto 0 do
        begin
          y := f(a[i]);
          if y  >  400 then 
                writeln(i,' TOO LARGE')
          else 
                writeln(i,y);
        end
end.
Detta program innehåller variabler av typ heltal och flyttal samt en vektor av flyttal. Det innehåller vidare inbyggda matematiska funktioner och en funktion f(t) skriven av användaren, upprepningssatser både framlänges och baklänges, villkorssats samt utmatning av både flyttal och text.

Notera att exponentiering ej finns i Pascal, varför t^3 måste skrivas t*t*t.

A 8.2 Program TPK i ANSI C

#include <stdio.h>
#include <math.h>
/*  Program TPK in ANSI C       */
double f (double t);
main()
{
        int i;
        double y;
        double a[11];
        for ( i = 0; i <= 10; ++i)
                scanf("%lf", &a[i]);
        for ( i = 10; i >= 0; i = i - 1 )
        {
                y = f(a[i]);
                if ( y > 400 )
                        {printf(" %d",i); 
                         printf(" TOO LARGE\n");}
                else 
                        {printf(" %d",i); 
                         printf(" %lf",y); 
                         printf(" \n");}
        }
        return 0; 
}
/*  Function */
double f (double t)
{
        double temp;
        temp = sqrt(fabs(t)) + 5*pow(t,3);
        return temp;
}
Språket C har i den traditionella varianten den egenheten att funktionsanrop normalt sker i dubbel precision, varför hela programmet här är i dubbel precision. I ANSI C är det dock tillåtet med enkel precision. Exponentiering kan ske med en inbyggd funktion pow.

A 8.3 Fortran

Fortran 90 är faktiskt den första som stavas Fortran, alla de tidigare hette egentligen FORTRAN. På 1960-talet rekommenderade dock IBM stavningen FØRTRAN.

Fortrans uppfinnare John Backus i New Mexico, 1976

A 8.3.1 FORTRAN 0

        DIMENSION A(11)
        READ A
2       DO 3,8,11 J=1,11
3       I=11-J
        Y=SQRT(ABS(A(I+1)))+5*A(I+1)**3
        IF (400>=Y) 8,4
4       PRINT I,999.
        GOTO 2
8       PRINT I,Y
11      STOP
Notera den eleganta behandlingen av inläsningen av vektorn A och att symbolen > fanns med från början. Utmatning av text fanns ej, varför 999 användes för att markera ett för stort tal. DO-slingan var mindre elegant, siffrorna anger startrad och slutrad för slingan samt vart exekveringen skulle hoppa när slingan var avslutad. Inte heller villkorssatsen kan sägas vara användarvänlig. Exponentiering kan ske med **.

A 8.3.2 FORTRAN I

C       THE TPK ALGORITHM
C       FORTRAN I STYLE
        FUNF(T)=SQRTF(ABSF(T))+5.0*T**3
        DIMENSION A(11)
    1   FORMAT(6F12.4)
        READ 1,A
        DO 10 J=1,11
        I=11-J
        Y=FUNF(A(I+1))
        IF(400.0-Y)4,8,8
    4   PRINT 5,I
    5   FORMAT(I10,10H TOO LARGE)
        GOTO 10
    8   PRINT 9,I,Y
    9   FORMAT(I10,F12.7)
   10   CONTINUE
        STOP 52525
Detta var det första programspråket med kommentarer! I övrigt användes en satsfunktion, och baklängesslingan är simulerad eftersom en DO-slinga ej fick gå baklänges och index noll var förbjudet. Villkorssatsen är den aritmetiska med hopp till tre olika ställen beroende på om uttrycket är mindre än noll, lika med noll eller större än noll. Alla funktionsnamn slutar på F. Text går att mata ut om man kan räkna på fingrarna (10H anger att tio tecken följer). Strukturerad layout var ännu ej uppfunnen, den var dessutom bökig på hålkort.

A 8.3.3 FORTRAN IV eller Fortran 66

C       THE TPK ALGORITHM
C       FORTRAN IV STYLE
        DIMENSION A(11)
        FUN(T) = SQRT(ABS(T)) + 5.0*T**3
        READ (5,1) A
    1   FORMAT(5F10.2)
        DO 10 J = 1, 11
                I = 11 - J
                Y = FUN(A(I+1))
                IF (400.0-Y) 4, 8, 8
    4                    WRITE (6,5) I
    5                    FORMAT(I10, 10H TOO LARGE)
                GO TO 10
    8                    WRITE(6,9) I, Y
    9                    FORMAT(I10, F12.6)
   10   CONTINUE
        STOP
        END
Även här användes en satsfunktion och baklängesslingan är fortfarande simulerad. Strukturerad layout användes. Benämningen Fortran 66 började användas först efter 1978, dessförinnan var IBM-beteckningen FORTRAN IV den vanliga.

A 8.3.4 Fortran 77

        PROGRAM TPK
C       THE TPK ALGORITHM
C       FORTRAN 77 STYLE
        REAL A(0:10)
        READ (5,*) A
        DO 10 I = 10, 0, -1
                Y = FUN(A(I))
                IF ( Y .LT. 400) THEN
                        WRITE(6,9) I, Y
    9                   FORMAT(I10, F12.6)
                ELSE
                        WRITE (6,5) I
    5                   FORMAT(I10,' TOO LARGE')
                ENDIF
   10   CONTINUE
        END 

        REAL FUNCTION FUN(T)
        REAL T
        FUN = SQRT(ABS(T)) + 5.0*T**3
        END
Även här borde en satsfunktion ha använts, men det hade nu blivit omodernt, varför en extern funktion användes. Baklängesslingan behöver inte längre simuleras och villkorssatsen kan nu ges på ett naturligt sätt. Strukturerad layout användes nu normalt. Texten kan ges inom apostrofer, dvs man behöver inte längre manuellt räkna antalet tecken i textsträngen. Satsen END i huvudprogrammet tjänstgör även som exekveringsslut, dvs STOP behövs ej. På motsvarande sätt behövs ej RETURN i funktionen FUN.

A 8.3.5 Fortran 90

        PROGRAM TPK
!       The TPK Algorithm
!       Fortran 90 style
        IMPLICIT NONE
        INTEGER               :: I
        REAL                  :: Y
        REAL, DIMENSION(0:10) :: A
        READ (*,*) A
        DO I = 10, 0, -1        ! Backwards
                Y = FUN(A(I))
                IF ( Y < 400.0 ) THEN
                        WRITE (*,*) I, Y
                ELSE
                        WRITE (*,*) I, ' Too large'
                END IF
        END DO
        CONTAINS                ! Local function
                FUNCTION FUN(T)
                REAL :: FUN
                REAL, INTENT(IN) :: T
                FUN = SQRT(ABS(T)) + 5.0*T**3
                END FUNCTION FUN
        END PROGRAM TPK
I stället för en extern funktion användes nu en intern funktion. Baklängesslingan behöver naturligtvis inte simuleras. Villkorssatsen kan nu ges på ett naturligt sätt och symbolen < har återkommit från FORTRAN 0. Deklarationerna har ett nytt utseende. Strukturerad layout användes nu alltid, alla satsnummer är borta. Texten ges inom apostrofer, och standardformat och standardenheter utnyttjas. Kommentarer kan ges även direkt på raden. Ny symbol ! som inleder kommentarer. Implicit deklaration är lämpligen avstängd.

Detta exempel är oförändrat under Fortran 95!

A 8.4 F

      module Functions
      public :: fun
      contains
         function fun(t) result (r)
            real, intent(in) :: t
            real  :: r
            r = sqrt(abs(t)) + 5.0*t**3
         end function fun
      end module Functions

      program TPK
!     The TPK Algorithm
!     F style
      use Functions
      integer		    :: i
      real                  :: y
      real, dimension(0:10) :: a
      read *, a
      do i = 10, 0, -1      ! Backwards
         y = fun(a(i))
         if ( y < 400.0 ) then
            print *, i, y
         else
            print *, i, " Too large"
         end if
      end do
      end program TPK

Det nya språket F har utvecklats som en möjlig ersättare för Pascal vid programmeringsutbildning, men det är samtidigt en äkta delmängd av Fortran 90 och Fortran 95.

En F-kompilator är gratis tillgänglig.

Nyckelord är reserverade ord och måste ges med små bokstäver (gemener), andra identifierare kan vara blandat stora och små bokstäver (men bara i en kombination per variabel, och på grund av att det är en delmängd av Fortran kan inte Var och vaR avse olika variabler). Funktioner och subrutiner tillåtes enbart via moduler, funktioner måste ha en resultatvariabel. Alla variabler måste deklareras explicit (satsen IMPLICIT NONE är därför implicit, och fick tidigare inte förekomma explicit, numera är den dock tillåten av kompatibilitetsskäl).

När den är tillgänglig är därför kompilatorväljaren -u mycket användbar vid test av F program med en Fortran 90 kompilator.

Detta exempel är ett första försök att skriva i F!

Ett kapitel 22 om programspråket F finns nu.

Andra Fortran 90/95 system Innehåll Hög-Prestanda Fortran


Senast modifierad: 23 maj 2007
boein@nsc.liu.se