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 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
**.
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.
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 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!
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.
