APL
Uit Wikipedia, de vrije encyclopedie
APL is een programmeertaal. De taal is ontstaan uit een boek dat in 1962 werd geschreven door Ken Iverson en waarin een wiskundige notatiewijze werd geïntroduceerd. Met enkele aanpassingen werd uit dit voorstel de programmeertaal ontworpen. De naam APL is ontleend aan de titel van het boek: A Programming Language.
Inhoud |
[bewerk] Korte geschiedenis
[bewerk] Ontwikkelingen in de tijd
Zoals gezegd, de taal is ontstaan naar aanleiding van de publicatie van Kenneth E. Iverson. Hoewel zijn boek in 1962 uitkwam, ontdekte en ontwikkelde hij de taal al in 1957. Als programmeertaal werd APL al snel populair in vooral de wetenschappelijke en financiële wereld vanwege de krachtige mogelijkheden die de taal biedt om om te gaan met meer-dimensionale array's met data. Oorspronkelijk draaide APL op (IBM)-mainframes en over de loop van jaren ontstonden er verschillende dialecten van de taal. Na de opkomst van de PC begin jaren 80 van de twintigste eeuw, en de afname van de populariteit van mainframes kwam er een versie van APL uit voor de PC onder de naam APL*Plus/PC van ontwikkelaar STSC (zie eventueel: STSC (engels)). De eeste versie voor de PC kwam in 1982 op de markt en in het midden van de jaren 80 kwam er ook een 32-bit versie voor de Unix systemen op de markt als APL*Plus/Unix). Tot 1995 bleef STSC APL*Plus verder ontwikkelen, maar verkocht de rechten in dat jaar aan LEX2000 Inc. wat vervolgens in 1999 weer in handen kwam van Cognos. De belangstelling en het gebruik van APL is de laatste jaren erg teruggelopen, natuurlijk mede onder invloed van de komst van nieuwe ontwikkelomgevingen als C (en de opvolgers C+ / C++) en later Java). Er bestaat nog wel een groep die-hards die APL en varianten/dialecten als A+[1] gebruiken en ontwikkelen.
[bewerk] van mainframe naar PC
De overgang naar de nieuwe PC-omgeving vereiste natuurlijk wel wat toevoegingen om op een nieuwe manier om te gaan met -vooral- de uitvoer van gegevens en andere specifieke eigenaardigheden van de PC. De eerste versies draaiden (uiteraard) onder MS-DOS en dat waren specifiek single-user- en single-taskomgevingen. Dit vraagt een heel andere benadering van geheugengebruik, en commando's die verband houden met je rechten hoeveel gebruik jouw programma mag maken van de CPU hebben weinig nut. Om portering van bestaande programma's van mainframeomgevingen naar de PC te vereenvoudigen bleven in de PC-versie commando's en functies bestaan die feitelijk niets deden, maar wel de compabiliteit van workspaces verhoogden. (Na de overstap van MS-DOS naar Windows kwam je weer terug in een multi-user- en multi-taskingomgeving; maar wel op een andere wijze dan bij mainframesystemen.)
[bewerk] huidige situatie
Hoewel het gebruik sterk is teruggelopen blijft er toch nog steeds een enthousiaste groep gebruikers die via internet nieuwe ontwikkelingen gebaseerd op APL ontwikkelt.
- Vanaf 2001 bestaat het project Aplus of A+ dat vrij verkrijgbaar is onder de GNU General Public License. Het is in 1998 ontwikkeld door Arthur Whitney [2] werkzaam bij de bank Morgan Stanley. Dit bedrijf had over de jaren - zoals veel vergelijkbare bedrijven - veel programmatuur ontwikkeld in APL. Omdat de banken afscheid namen van hun mainframes en gebruik gingen maken van systemen onder SunOS/Solaris zocht men een geschikte APL-omgeving daarvoor, maar die was niet beschikbaar. Omdat het bedrijf de bestaande tools in APL liever niet zou moeten afschaffen danwel geheel opnieuw zouden moeten schrijven in een andere taal faciliteerden zij de ontwikkeling van A+ door Arthur Whitney en is de bank nog steeds sponsor van het project.[3]
- VisualAPL en APLNext: nieuwe versies van APL speciaal geschikt voor .NET omgevingen.[4]
- DialogAPL, een moderne versie van APL voor verschillende Windows en Linux/Unix platformen.[5]
- IBM APL2: een interpreter voor IBM systemen[6]
-
- Een uitgebreider overzicht kun je vinden op de engelse Wiki over APL
[bewerk] Verschillen
De programmeertaal verschilt in veel opzichten van andere talen.
- Alle ingebouwde functies worden voorgesteld door een teken. De gebruikelijke tekens
en
voor optellen en aftrekken zijn normaal aanwezig, maar ook voor andere functies, zoals faculteit, logaritme en sinus, worden tekens gebruikt. - Er zijn geen sleutelwoorden zoals if en for. Alle voorwaardelijke instructies worden uitgedrukt met de sprongopdracht (voorgesteld door het teken
) met daarachter een expressie die geëvalueerd wordt naar een regelnummer. - Letters worden alleen gebruikt om identifiers te maken. De enige uitzondering is de letter
, die ook wordt gebruikt in een getal met drijvende komma. Verder worden letters gebruikt voor systeemopdrachten, zoals LOAD en SAVE, maar die maken geen deel uit van de taal. - Er is een apart minteken
voor negatieve getallen, terwijl voor aftrekken en negatie het gewone minteken
wordt gebruikt. Wellicht is APL de enige programmeertaal waarin een negatief getal niet als expressie wordt ingevoerd. er is verschil tussen 


en 


, het eerste is
, het tweede 

. - Er geldt geen volgorde van bewerkingen. Een expressie wordt strikt van rechts naar links uitgevoerd (tenzij er haakjes zijn gebruikt). Vermenigvuldigen heeft geen voorrang boven optellen en aftrekken.
- Er zijn geen expliciete declaraties. Door een hele array toe te kennen aan een identifier, wordt er geheugenruimte voor die identifier gereserveerd, voldoende ruimte voor de hele array.
- Hele arrays worden ineens verwerkt. Er zijn functies die een hele array kunnen maken of kopiëren, of die een bewerking kunnen uitvoeren op een array als geheel.
- De taal is niet gestructureerd. Dat wordt tegenwoordig als een nadeel gezien. De beginselen van het gestructureerd programmeren waren nog niet gebruikelijk in de tijd dat de taal ontworpen werd. Evenwel, doordat de taal hele arrays ineens verwerkt, is het zelden nodig een for- of while-statement te gebruiken.
Een groot voordeel van APL is dus dat er heel compact en snel gecodeerd kan worden. Tegelijkertijd is dat een nadeel. Een APL-source is vaak lastig te lezen vanwege de vele vreemde tekens.
[bewerk] Invoer
Voor het invoeren van APL-symbolen is een speciaal toetsenbord nodig. Het getoonde toetsenbord heeft geen aparte hoofd- en kleine letters: de lettertoetsen geven in combinatie met Shift een symbool.
En nog heeft het toetsenbord te weinig toetsen. Daarom kunnen er ook combinaties (overstrikes) worden gemaakt. Wenst met bijvoorbeeld een uitroepteken om de functie faculteit uit te voeren, dan typt men een aanhalingsteken (shift K), een backspace en een punt. Op dezelfde wijze kunnen ook de letters (andere tekens niet) onderstreept worden.
Er zijn verder diverse APL-editors. Om invoer te vergemakkelijken kan men van veel symbolen de naam invoeren.
[bewerk] Gegevens
Gegevens kunnen, zoals bij elke programmeertaal, uit arrays bestaan. Maar bij APL wordt een array als eenheid beschouwd. Een array kan een willekeurig aantal dimensies hebben. Een array van twee dimensies heet 'matrix', een array van een dimensie heet 'vector'. Een array van nul dimensies bestaat ook, dat is een scalar.
De dimensie van een array kan desnoods de lengte nul of één hebben. Dat lijkt niet erg zinvol, maar een array met een dergelijke dimensie kan door een programma uitgebreid worden.
Een vector (2 of langer) kan als constante worden ingevoerd als een reeks getallen met spaties ertussen, bijvoorbeeld ![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
. Geeft men een enkel getal op, dan is dat een scalar. Wil men een andere array, dan zal men een functie moeten gebruiken.
De bekendste functie om een array te maken is reshape {
. Bijvoorbeeld, de expressie ![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
![]()
maakt een matrix van 2 bij 4, met de daarachter opgegeven getallen als waarden.
Een andere veel gebruikte functie is de indexgenerator ((APL|iota}} die een vctor van natuurlijke getallen maakt. ![]()
levert dus de vector ![]()
![]()
![]()
![]()
. Het ziet er niet erg zinvol uit, maar deze functie is vaak heel handig.
De meeste functies zijn erg vergevingsgezind als een argument de verkeerde vorm heeft. Bijvoorbeeld, de hierboven genoemde functie {
heeft als linkerargument in principe een vector nodig, maar een scalar is ook goed.
Een array kan, zoals in elke programmeertaal, geïndiceerd worden: ![]()
![]()
![]()
. Zijn er twee of meer indexen, dan worden ze gescheiden door
. Het is beslist niet nodig dat op deze wijze een enkele waarde uit een array wordt gehaald: door een array als index te gebruiken of een index weg te laten is het mogelijk een deel uit een array te selecteren: de expressie![]()
![]()
![]()
![]()
![]()
![]()
heeft als resultaat een matrix bestaande uit de derde en de vierde kolom van de matrix
- de hele kolommen omdat de eerste index, tussen
en
is weggelaten.
[bewerk] Voorbeeld
Onderstaande regel is een programma dat alle priemgetallen van 1 tot R vindt:
en de beschrijving van rechts naar links:

maakt een vector met gehele getallen van
t/m
, dus 







als 



'drop' laat eerste getal weg: 






assignment operator: dus
is nu 








uitproduct van
en
: dit resulteert in de matrix:


















































onderzoekt van elk getal in de linker parameter 





of het in de rechter parameter (de matrix) voorkomt. Alleen de
komt voor, dus het resultaat is: false false true false (in werkelijkheid 





)
, negatie: dus 






: selecteer: aan de hand van de vector 





worden getallen geselecteerd uit de vector
, dus 





. Het resultaat is de vector 



. Daarmee is het probleem opgelost.
[bewerk] Functies
Er zijn monadische functies met één argument en diadische functies met twee argumenten. De syntaxis is zoals gebruikelijk bij de klassieke wiskundige functies, bijvoorbeeld ![]()
![]()
en ![]()
. Deze syntaxis is consequent doorgevoord voor alle functies, ook voo faculteit (uitroepteken links van de operand, niet rechts) en absolute waarde (verticale streep links van de operand, niet aan weerszijden).
Verder worden de functies onderscheiden in scalaire functies en gemengde functies. De laatste zijn in het bijzonder bedoeld voor het werken met arrays.
[bewerk] Scalaire functies
Worden scalaire functies op een array toegepast, dan werken ze op ieder element van de array apart. Men kan bijvoorbeeld twee arrays bij elkaar optellen, mits beide arrays dezelfde vorm hebben, dus arrays van evenveel dimensies met dezelfde waarden. Het rsultaat heeft weer dezelfde vorm. Bijvoorbeeld: 3 5 4 + 2 4 6 geeft 5 9 10. Hierop geldt een uitzondering: men kan een scalaire dyadische functie uitvoeren op twee arrays waarvan een een enkel getal is. Bijvoorbeeld: 3 + 2 4 6 geeft 5 7 9.
[bewerk] Gemengde functies
Gemengde functies zijn speciaal voor het bewerken van arrays. Sommige functies kunnen zelfs van een index worden voorzien. Bijvoorbeeld ![]()
![]()
![]()
![]()
![]()
. In dit geval wordt de functie ![]()
![]()
langs de index
uitgevoerd. Wordt er geen index opgegeven, dan wordt de functie langs de laatste dimensie uitgevoerd.
[bewerk] Gecombineerde functies
Verder zijn er gecombineerde functies. Hierbij wordt uit een scalaire dyadische functie (of twee scalaire dyadische functies) een nieuwe gemengde functie gemaakt. In de voorbeelden hieronder kan
worden vervangen dooe een willekeurige scalaire dyadische functie.
[bewerk] Oneigenlijke functies
[bewerk] In- en uitvoer
De laatste bewerking die op een regel wordt uitgevoerd, is vrijwel steeds
(sprongopdracht) of
(toekenning).
