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.
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.
#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.
Fortrans uppfinnare John Backus i New Mexico, 1976
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 STOPNotera 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 **.
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 52525Detta 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.
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.
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.
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 TPKI 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!
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 21 om programspråket F finns nu.