-37-



	Wij zullen nu, compleet met in- en uitvoer van gegevens, 
een matrix A, bestaande uit 20 kolommen, elk van zes elementen,
vermenigvuldigen met een kolomvector B van dus 20 elementen en
de antwoordvector (van dus 6 elementen) uittypen. Wij nemen aan,
dat de elementen van A kolomsgewijs op een band geponst staan en
dat na de laatste kolom van A op diezelfde band de elementen van
vector B staan. Om de informatie, die op een band geponst staat,
in een werkend ALGOL-programma op te kunnen nemen, is het _NA_voca-
bulaire_NA_ van de MC-vertaler uitgebreid met de speciale functie
_NA_read_NA_. De waarde hiervan is gelijk aan die van _NA_het volgende
getal op de band_NA_; uit de aard der zaak moet, voordat een ALGOL-
programma om getallen van een band vraagt, deze band met zijn
begin in de bandlezer van de X1 gelegd zijn.


begin     integer i, j; real s; array A[1:6, 1:20], B[1:20];
	  NLCR;
	  for j:= 1 step 1 until 20 do
	     for i:= 1 step 1 until 6 do A[i,j]:= read;
	  for i:= 1 step 1 until 20 do B[i]:= read;
	  for i:=  1 step 1 until 6 do
	  begin   s:= 0;
		for j:= 1 step 1 until 20 do s:= A[i,j] * B[j] + s;
		print(s)
	  end
end

	Het programma bestaat primair uit vier statements, nl. NLCR,
gevolgd door drie for-statements. Bij de eerste hiervan zien we,
dat de statement, die volgt op een for clause, zelf weer een for-
statement mag zijn; bij de laatste hiervan, waarin de eigenlijke
berekening is beschreven, hebben we van de statement-haken begin
en end gebruik moeten maken.


	De vorm van dit programma werd gedicteerd door de wijze,
waarop de getallen op de band stonden. Had op deze band eerst de
vector B gestaan en dan de matrix A, maar nu rijgewijs , dan hadden
we met een veel eenvoudiger programma kunnen volstaan, nl.

begin     integer i, j; real s; array B[1:20];
	  NLCR;
	  for j:= 1 step 1 until 20 do B[j]:= read;
	  for i:= 1 step 1 until 6 do
	  begin   s:= 0;
	  	  for j:= 1 step 1 until 20 do s:= read * B[j] + s;
		  print(s)
	  end
end

				-38-




EENDUIDIGHEID VAN NAMEN

	Wij hebben nu inmiddels _NA_namen_NA_ ontmoet voor een aantal
verschillende objecten:
	
	scalairen
	labels
	speciale functies en standaard handelingen
	arrays .

Het is verboden eenzelfde naam in een bepaald bestek met een
dubbele betekenis te gebruiken, ook al zou hierdoor geen
dubbelzinnigheid optreden, omdat in de tekst duidelijk is, van
welke aard het benoemde objec t is. Zo mogen we niet tegelijker-
tijd willen kunnen praten over:

	de scalar _NA_sin_NA_ (in expressie of links van _NA_:=_NA_)
	de label _NA_sin_NA_ (in goto-statement of links van _NA_:_NA_)
	de functie _NA_sin_NA_ (gevolgd door _NA_(_NA_ )
	het array _NA_sin_NA_ (gevolgd door _NA_[_NA_)  .

Dit verbod is kort en cryptisch uitgedrukt in het principe
_NA_identifier identifies_NA_, dat een van de hoekstenen van ALGOL 60
is. Dit verbod strekt zich ook uit over de namen van de nog onbe-
sproken objecten (de Boolean, de switch en de procedure).

				-39-



DE PROCEDURE

	Ons voorbeeld van de vermenigvuldiging _NA_matrix maal vector_NA_
hebben we gegeven als illustratie van het gebruik van arrays; het
toonde daarnaast de for-statement in al zijn glorie. Zo liet het
duidelijk zien, dat het for-mechanisme niet enkel een telling is,
die zorgt, dat een statement een aantal malen herhaald wordt, maar
dat in deze statement met vrucht gebruik gemaakt kan worden van 
de waarde van de _NA_lopende variabele_NA_. Verder is dit voorbeeld, een
programma, waardoor o.a. 120 vermenigvuldigingen uitgevoerd zullen
worden, een treffend bewijs van de compactheid van beschrijvingen
in ALGOL. De for-statement is niet de enige methode, waardoor we
de programmatekst kunnen verkorten: een zeker zo belangrijke mo-
gelijkheid is het bijzonder flexibele afkortingsmechanisme, dat
ons ter beschikking staat in de vorm van de z.g. _NA_procedure_NA_.


	In een programma komt een variabele voor, genaamd _NA_cosphi_NA_,
die op een groot aantal verschillende plaatsen in het programma
een wijziging moet ondergaan, die beschreven kan worden door de
assignment statement

	_NA_cosphi:= 2 * cosphi * cosphi - 1_NA_   .

In plaats van nu deze statement op alle plaatsen, waar cosphi
aldus gewijzigd moet worden, voluit neer te schrijven, kunnen
wij deze handeling een naam geven; dit eenmaal gebeurd zijnde
hoeven wij daar waar deze handeling plaats moet vinden, slechts
deze naam te vermelden.


	Wij kiezen voor deze handeling een naam, die in dit bestek
geen andere betekenis heeft; dit zij de naam _NA_DUB_NA_. Deze keuze
leggen wij vast in een z.g. _NA_procedure declaratie_NA_. In zijn
eenvoudigste vorm bestaat deze uit het hierbij te introduceren
nieuwe symbool _NA_procedure_NA_, onmiddellijk gevolgd door de
gekozen naam; deze wordt dan afgesloten door een puntkomma en
hierna volgt de statement, die deze naam gekregen heeft. (Hiermee
is de declaratie ten einde. Aangezien de declaraties in de regel
gevolgd worden door andere declaraties of door een statement,
volgt er na de benoemde statement dus een puntkomma.)


	In ons voorbeeld zou de procedure declaratie geluid hebben:

	_NA_procedure DUB; cosphi:= 2 * cosphi * cosphi - 1_NA_   .

Hierna mogen we overal in de tekst, waar deze statement uitgevoerd moet
worden, in plaats daarvan _NA_DUB_NA_ schrijven. Dit is dan een zelf-
standige statement - dit soort heet _NA_een procedure statement_NA_ - ,
die normaal als alle andere statements met behulp van puntkomma#s
van voorganger en volgeling gescheiden moet worden.

				-40-




In gebruik onderscheidt de procedure DUB zich niet van de reeds
eerder genoemde standaard handeling NLCR; het enige verschil is,
dat de naam NLCR behoort tot het primitieve vocabulaire van de
MC-vertaler en daardoor zonder voorafgaande declaratie gebruikt
mag worden. En nu is het ook duidelijk, hoe de statement NLCR,
die we eerder min of meer als extra#tje invoerden, syntactisch
volledig in ALGOL 60 past: het is in het gebruik een procedure
statement, net als ieder ander. Voor een klein aantal procedures
(waaronder NLCR) is de functie eens en voor al afgesproken; 
daarnaast heeft de programmeur de vrijheid om met behulp van een
procedure declaratie naar behoefte nieuwe procedures te definieren.


	Nu beschouwen we het geval, dat op vele plaatsen in het pro-
gramma twee variabelen genaamd _NA_a_NA_ en _NA_2verwisseld moeten
worden. Dit vergt, zoals gemakkelijk is na te gaan, drie state-
ments en er is dus reden genoeg, om deze handeling als procedure
te behandelen. Dat de procedure declaratie de naam hecht aan _NA_de
erin voorkomende statement_NA_, deert ons niet, want we kennen in-
middels de geijkte methode om een aantal statementnaar buiten als
een enkel te laten fungeren: de statementhaken begin en end. De
procedure declaratie voor de