Programovací jazyky odvozené od APL: BQN a ivy aneb 1~×`1↓↕10

Obsah

1. Programovací jazyky odvozené od APL

2. Programovací jazyk BQN – Big Questions Notation

3. Webová a terminálová varianta BQN

4. Základní vlastnosti jazyka BQN

5. Ilustrace pořadí vykonávání operací funkcí Explain

6. Porušení mantry „vše je pole“

7. Seznamy, konstrukce polí, způsob zobrazení polí

8. Tabulka se všemi základními funkcemi jazyka BQN

9. Modifikátor table

10. Další modifikátory jazyka BQN

11. Modifikátor scan

12. Výpočet tabulky faktoriálu s využitím modifikátoru scan

13. Kombinátory

14. Tacit programming

15. Shrnutí

16. Programovací jazyk ivy

17. Instalace jazyka ivy

18. První seznámení s možnostmi jazyka ivy

19. Výpočet prvočísel v jazyku ivy

20. Odkazy na Internetu

1. Programovací jazyky odvozené od APL

Joel Moses: “APL is like a beautiful diamond – flawless, beautifully symmetrical. But you can’t add anything to it. If you try to glue on another diamond, you don’t get a bigger diamond. Lisp is like a ball of mud. Add more and it’s still a ball of mud – it still looks like Lisp.”

Na úvodní dvojici článků [1] [2] o programovacích jazycích určených a mnohdy i přímo optimalizovaných pro provádění operací s N-dimenzionálními poli dnes navážeme. Připomeňme si, že v úvodním článku jsme se zabývali především univerzálními programovacími jazyky podporujícími (kromě dalších operací) i „nativní“ zpracování vícerozměrných polí, v článku druhém jsme se pak podrobněji věnovali programovacímu jazyku nazvanému J, jenž je přímo odvozen od v mnoha ohledech přelomového programovacího jazyka APL (i když to na první pohled nemusí být patrné kvůli zcela odlišné sadě symbolů, z nichž se programy skládají). Do této série článků ovšem nepřímo patří i článek o historii vzniku a dalšího vývoje programovacího jazyka APL.

Na všechny tři výše zmíněné články dnes navážeme, protože si popíšeme další dva zajímavé programovací jazyky, které jsou do značné míry inspirovány právě programovacím jazykem APL. Nejdříve se budeme zabývat jazykem nazvaným poněkud neobvykle BQN, za jehož vývojem stojí programátor, který se APL jazykům věnuje již velmi dlouho a tudíž poměrně do hloubky zná i jejich limity a pochopitelně i jejich nedokonalosti (ostatně který programovací jazyk je dokonalý?). Druhým jazykem, na který se dnes zaměříme, je jazyk nazvaný ivy. Ten je zajímavý mj. i kvůli tomu, že je naprogramován v Go a za jeho vývojem stojí přímo Rob Pike, tedy jeden ze spoluautorů Go. Současně dnes již téma programovacích jazyků odvozených od APL opustíme, a to mj. i z toho důvodu, že práce s vícerozměrnými poli (a zejména pak s jednorozměrnými vektory a dvourozměrnými maticemi) je dobře rozpracována i v dalších jazycích, které jsou přece jen více mainstreamové – jedná se v první řadě o Fortran, ale taktéž o programovací jazyk C++.

2. Programovací jazyk BQN – Big Questions Notation

„BQN: finally, an APL for your flying saucer“

Nejprve se budeme zabývat programovacím jazykem, který se jmenuje BQN a za jehož vývojem stojí především Marshall Lochbaum. Tento autor se dlouhodobě zabývá programovacími jazyky z rodiny APL (a částečně i Scheme) a před BQN vytvořil programovací jazyk pojmenovaný jednoduše I, který je do značné míry inspirován jazykem J, jímž jsme se zabývali minule. Vraťme se ovšem k jazyku BQN. Jedná se o programovací jazyk, jenž je do značné míry inspirován jazykem APL, ovšem některé (i poměrně základní) operace jsou v BQN prováděny odlišně. Odlišnosti nalezneme již u způsobu implementace n-dimenzionálních polí, kde se BQN vrací k původnímu APL (a nikoli k APL modernímu). Liší se ovšem i základní symboly, z nichž se skládají větší celky a z nich pak ucelené algoritmy i celé programy.

Obrázek 1: Logo programovacího jazyka BQN.

3. Webová a terminálová varianta BQN

Programovací jazyk BQN v současnosti existuje ve dvou variantách. První variantu lze spustit přímo ve webovém prohlížeči. Tuto variantu můžeme najít na stránce https://mlochbaum.github.io/BQN/ a její výhodou je, že obsahuje volbu Explain, kterou si ukážeme dále. Navíc dostaneme „zadarmo“ podporu všech potřebných znaků Unicode, na nichž je jazyk BQN postaven. Druhá varianta se jmenuje CBQN. Tato varianta, jejíž repositář je umístěn na adrese https://github.com/dzaima/CBQN, je naprogramována v čistém C (což ostatně naznačuje již její název) a lze ji přeložit a spustit přímo z terminálu.

Obrázek 2: Webové rozhraní programovacího jazyka BQN.

Překlad a slinkování CBQN je snadný a rychlý. Nejprve je nutné naklonovat repositář s touto variantou jazyka BQN:

$ git clone git@github.com:dzaima/CBQN.git
 
Cloning into 'CBQN'...
remote: Enumerating objects: 5753, done.
remote: Counting objects: 100% (4177/4177), done.
remote: Compressing objects: 100% (3078/3078), done.
remote: Total 5753 (delta 3342), reused 1905 (delta 1084), pack-reused 1576
Receiving objects: 100% (5753/5753), 1.07 MiB | 3.77 MiB/s, done.
Resolving deltas: 100% (4592/4592), done.

Ve druhém kroku provedeme překlad s volbou překladače, který se má použít:

$ cd CBQN/
$ make CC=gcc

Výsledkem překladu je spustitelný soubor „BQN“, který se v případě potřeby vejde na disketu:

$ ls -l
 
-rwxrwxr-x. 1 ptisnovs ptisnovs 1027984 Dec 25 20:13 BQN
-rwxrwxr-x. 1 ptisnovs ptisnovs    2779 Dec 25 20:12 cc.bqn
-rwxrwxr-x. 1 ptisnovs ptisnovs     442 Dec 25 20:12 genRuntime
-rwxrwxr-x. 1 ptisnovs ptisnovs     354 Dec 25 20:12 genRuntimeSrc
-rw-rw-r--. 1 ptisnovs ptisnovs   35148 Dec 25 20:12 LICENSE
-rw-rw-r--. 1 ptisnovs ptisnovs    4665 Dec 25 20:12 makefile
drwxrwxr-x. 3 ptisnovs ptisnovs      60 Dec 25 20:13 obj
-rwxrwxr-x. 1 ptisnovs ptisnovs    1120 Dec 25 20:12 precompiled.bqn
-rw-rw-r--. 1 ptisnovs ptisnovs    2283 Dec 25 20:12 README.md
drwxrwxr-x. 2 ptisnovs ptisnovs      40 Dec 25 20:12 SingeliClone
-rwxrwxr-x. 1 ptisnovs ptisnovs     688 Dec 25 20:12 SingeliMake.bqn
drwxrwxr-x. 9 ptisnovs ptisnovs     440 Dec 25 20:12 src
-rwxrwxr-x. 1 ptisnovs ptisnovs    1188 Dec 25 20:12 test.bqn

Otestujeme, zda je možné BQN spustit:

$ ./BQN --help
 
Usage: ./BQN [options] [file.bqn [arguments]]
Options:
-f file: execute the contents of the file with all further arguments as •args
-e code: execute the argument as BQN
-p code: execute the argument as BQN and print its result pretty-printed
-o code: execute the argument as BQN and print its raw result
-M num : set maximum heap size to num megabytes
-r     : start the REPL after executing all arguments
-s     : start a silent REPL

Spuštění v režimu interpretru:

$ ./BQN
 
   1+1
2
 
   π
3.141592653589793
 
   ∞
∞

4. Základní vlastnosti jazyka BQN

Jazyk BQN, podobně jako jeho ideový předchůdce APL, podporuje infixovou notaci zápisu výrazů. To znamená, že jméno či symbol funkce (nebo, chcete-li, operátoru) se zapisuje mezi oba operandy. Příkladem může být funkce/operátor pro podíl dvou hodnot:

10 ÷ 4
2.5

Mnoho funkcí akceptuje pouze jediný operand. Příkladem může být opět funkce zapisovaná znakem „÷“, jejíž jednooperandová podoba slouží pro výpočet převrácené hodnoty:

÷ 4
0.25

Operátory/funkce nemají stanovenou prioritu (přesněji řečeno mají shodnou prioritu) a vyhodnocují se zprava doleva, tedy stejně, jako je tomu v APL:

7 × 4 + 2
42
 
4 + 5 × 6
34

Pořadí výpočtů lze ovlivnit závorkami:

(4 + 5) × 6
54
 
(1 + (2 + 3) × 4) × 2
42

Popř.:

(((10 ÷ 9) ÷ 8) ÷ 7) + (100 ÷ ((4 + 3) ÷ (2 + 1)))

Existuje i mnoho dalších funkcí majících monadickou a současně i dyadickou podobu reprezentovanou jediným symbolem. Příkladem může být funkce pro výpočet druhé odmocniny (monadická podoba) nebo n-té odmocniny (dyadická podoba):

√2
1.4142135623730951
 
4√81
3
 
8√65536
4

Popř. výpočet e^x nebo x^y:

⋆1
2.718281828459045
 
2⋆8
256

5. Ilustrace pořadí vykonávání operací funkcí Explain

V některých případech nemusí být jednoduché pravidlo „funkce mají shodné priority a vyhodnocují se zprava doleva“ zcela zřejmé v případě složitějších výrazů, zejména při použití takzvaných manipulátorů. V takových případech lze použít funkci Explain dostupnou z webového prostředí, která kromě vlastního výpočtu zobrazí i pořadí vyhodnocování jednotlivých částí výrazů. Podívejme se na několik jednoduchých ukázek, v nichž budeme používat základní funkce:

Obrázek 3: Ukázka vyhodnocení výrazu 1+2.

Obrázek 4: Ukázka vyhodnocení výrazu 6×3+4 (3+4 se vyhodnotí dříve).

Obrázek 5: Ukázka vyhodnocení výrazu s několika podvýrazy v závorkách.

Obrázek 6: Ukázka vyhodnocení výrazu s několika podvýrazy v závorkách.

Obrázek 7: Ukázka vyhodnocení výrazu s několika podvýrazy v závorkách.

6. Porušení mantry „vše je pole“

V prvních variantách programovacího jazyka APL se používala takzvaná „plochá“ pole neboli flat arrays. Jednalo se (poněkud zjednodušeně řečeno) o pole, jejichž prvky mohly být skalární hodnoty (skaláry), tj. typicky buď hodnoty typu float nebo znaky. Okolo roku 1981 však došlo k rozšíření sémantiky datového typu pole – nyní mohla pole obsahovat jako své prvky další pole. První komerčně dostupná varianta APL, která tato rozšířená pole implementovala, se jmenovala APL*PLUS a nová vlastnost se označovala zkratkou NARS neboli Nested Array Research System.

Později se tento koncept „vše je pole“ začal používat i v dalších variantách programovacího jazyka APL. Kromě několika výhod se ovšem ukázalo, že tento koncept může mít i nevýhody. Ty vyplývají z „podivné“, přesněji řečeno neintuitivní sémantiky některých operací, kdy se skalární hodnota někdy považuje za pole 1×1 prvek a jindy nikoli (navíc se zde objevuje nová vlastnost „hloubka“ pole; dále se jednoprvkové pole rovná tomuto prvku při porovnávání). Z tohoto důvodu se BQN vrací k myšlence původní varianty APL – pole zde pochopitelně stále existují, mohou mít libovolný počet dimenzí i libovolný tvar, ovšem prvky polí jsou skalární hodnoty a nikoli další pole.

V BQN se hodnoty rozdělují do dvou hlavních kategorií:

1. atomy: čísla, znaky, funkce, modifikátory, jmenné prostory
2. pole

Přitom platí, že atomy mají vždy hloubku (depth) rovnou nule a nemají tvar (shape). Pole naproti tomu mají tvar a jejich identita je odvozena právě z tvaru a navíc z typu elementů.

Rozdíl mezi atomem a jednotkovým polem je vidět ihned na výstupu:

Atom:

3
3

Pole s jediným prvkem:

<3
 
┌·
· 3
    ┘

Mezi další vlastnosti polí v BQN patří, že pole jsou neměnná (immutable) v tom smyslu, že nelze měnit jejich tvar ani typ elementů. Ovšem hodnoty elementů (prvků) již měnit lze.

7. Seznamy, konstrukce polí, způsob zobrazení polí

Na rozdíl od jazyka APL či J, v němž existuje způsob konstrukce literálu představujícího pole, je nutné v BQN pole vytvářet nepřímo; typicky přes seznamy. Literál představující celý seznam totiž existuje – jedná se o hodnoty prvků, které jsou propojeny znakem „‿“. Následuje příklad seznamu se třemi prvky s hodnotami 1, 2 a 3:

1‿2‿3
 
⟨ 1 2 3 ⟩

Existuje taktéž funkce nazvaná range, která vrací seznam (ne vektor!) s prvky od 0 omezené zadanou hodnotou. Jedná se tedy o obdobu funkce iota z klasického APL:

↕ 6
⟨ 0 1 2 3 4 5 ⟩

Další užitečná funkce se jmenuje reshape a slouží k vytvoření pole o zadaném tvaru. Prvky pole lze získat například z vektoru, samotný tvar pak taktéž typicky bývá představován seznamem:

1‿12 ⥊ ↕ 12
 
┌─
╵ 0 1 2 3 4 5 6 7 8 9 10 11
                            ┘

vracející vektor a posléze funkce reshape se dvěma parametry – samotný 1‿12 je v tomto případě skutečně literálem a nijak nemění pořadí prováděných operací.

Konstrukce sloupcového vektoru:

12‿1 ⥊ ↕ 12
 
┌─
╵  0
   1
   2
   3
   4
   5
   6
   7
   8
   9
  10
  11
     ┘

Konstrukce pole 2×6 prvků:

2‿6 ⥊ ↕ 12
 
┌─
╵ 0 1 2 3  4  5
  6 7 8 9 10 11
                ┘

Konstrukce pole 3×4 prvků:

3‿4 ⥊ ↕ 12
 
┌─
╵ 0 1  2  3
  4 5  6  7
  8 9 10 11
            ┘

Konstrukce pole 2×3×4 prvků:

2‿3‿4 ⥊ ↕ 12
 
┌─
╎ 0 1  2  3
  4 5  6  7
  8 9 10 11
 
  0 1  2  3
  4 5  6  7
  8 9 10 11
            ┘

Čtyřrozměrné pole:

2‿2‿2‿3 ⥊ ↕ 12
 
┌─
┆ 0  1  2
  3  4  5
 
  6  7  8
  9 10 11
 
 
  0  1  2
  3  4  5
  
  6  7  8
  9 10 11
          ┘

Šestirozměrné pole:

2‿2‿2‿2‿2‿2 ⥊ ↕ 32
 
┌6
┊  0  1
   2  3
 
   4  5
   6  7
 
...
...
...

Povšimněte si, že počet rozměrů pole je zakódován tvarem levého horního rohu pole. Pouze u polí s šesti a více rozměry už musí být zapsán počet dimenzí číselně:

 0     1     2     3     4     5
┌·    ┌─    ┌─    ┌─    ┌─    ┌─    ┌6    ┌7  …
·     ·     ╵     ╎     ┆     ┊     ┊     ┊   …

Boxing atomu do pole:

<3
 
┌·
· 3
    ┘

Konstrukce pole, jehož všechny prvky mají shodnou hodnotu:

5‿5 ⥊ <1
 
┌─
╵ 1 1 1 1 1
  1 1 1 1 1
  1 1 1 1 1
  1 1 1 1 1
  1 1 1 1 1
            ┘

V tomto konkrétním případě však můžeme boxing vynechat:

5‿5 ⥊ 1
 
┌─
╵ 1 1 1 1 1
  1 1 1 1 1
  1 1 1 1 1
  1 1 1 1 1
  1 1 1 1 1
            ┘

8. Tabulka se všemi základními funkcemi jazyka BQN

V této kapitole je uvedena tabulka obsahující všechny základní funkce jazyka BQN. Originál tabulky je dostupný na adrese https://pastebin.com/raw/ynsghrHM:

9. Modifikátor table

V článku o programovacím jazyku APL jsme se zmínili o operátoru nazvaném „outer product“. Podobný koncept existuje i v jazyku BQN, ovšem namísto pojmu „operátor“ se zde používá pojem „modifikátor“ a z „outer product“ se stal modifikátor „table“. Tento modifikátor dokáže aplikovat zvolenou dyadickou funkci (například +) na všechny kombinace prvků vstupních vektorů nebo polí. Můžeme si například vytvořit pole s malou násobilkou (prozatím v nedokonalé podobě):

(↕ 10) ×⌜ (↕ 10)
 
┌─
╵ 0 0  0  0  0  0  0  0  0  0
  0 1  2  3  4  5  6  7  8  9
  0 2  4  6  8 10 12 14 16 18
  0 3  6  9 12 15 18 21 24 27
  0 4  8 12 16 20 24 28 32 36
  0 5 10 15 20 25 30 35 40 45
  0 6 12 18 24 30 36 42 48 54
  0 7 14 21 28 35 42 49 56 63
  0 8 16 24 32 40 48 56 64 72
  0 9 18 27 36 45 54 63 72 81
                              ┘

Funkcí drop odstraníme ze vstupních vektorů nuly:

(1↓ (↕ 10)) ×⌜ (1↓ (↕ 10))
 
┌─
╵ 1  2  3  4  5  6  7  8  9
  2  4  6  8 10 12 14 16 18
  3  6  9 12 15 18 21 24 27
  4  8 12 16 20 24 28 32 36
  5 10 15 20 25 30 35 40 45
  6 12 18 24 30 36 42 48 54
  7 14 21 28 35 42 49 56 63
  8 16 24 32 40 48 56 64 72
  9 18 27 36 45 54 63 72 81
                            ┘

Ještě lepší je však vytvořit vektory s hodnotami od 1 do 10 (včetně):

(1 + (↕ 10)) ×⌜ (1 + (↕ 10))
 
┌─
╵  1  2  3  4  5  6  7  8  9  10
   2  4  6  8 10 12 14 16 18  20
   3  6  9 12 15 18 21 24 27  30
   4  8 12 16 20 24 28 32 36  40
   5 10 15 20 25 30 35 40 45  50
   6 12 18 24 30 36 42 48 54  60
   7 14 21 28 35 42 49 56 63  70
   8 16 24 32 40 48 56 64 72  80
   9 18 27 36 45 54 63 72 81  90
  10 20 30 40 50 60 70 80 90 100
                                 ┘

Obrázek 8: Postup provádění výpočtu.

Většina závorek je zbytečná, pochopitelně za předpokladu, že dodržíme pravidlo vyhodnocování funkcí zprava doleva:

(1+↕10)×⌜1+↕10
 
┌─
╵  1  2  3  4  5  6  7  8  9  10
   2  4  6  8 10 12 14 16 18  20
   3  6  9 12 15 18 21 24 27  30
   4  8 12 16 20 24 28 32 36  40
   5 10 15 20 25 30 35 40 45  50
   6 12 18 24 30 36 42 48 54  60
   7 14 21 28 35 42 49 56 63  70
   8 16 24 32 40 48 56 64 72  80
   9 18 27 36 45 54 63 72 81  90
  10 20 30 40 50 60 70 80 90 100
                                 ┘

10. Další modifikátory jazyka BQN

Operátor table popsaný v předchozí kapitole je ve skutečnosti pouze jedním z mnoha modifikátorů, které programovací jazyk BQN programátorům nabízí. Obecně je možné říci, že modifikátory umožňují určit způsob iterace nad prvky seznamů nebo polí i to, jaký má být výsledek aplikace tohoto manipulátoru. Modifikátorů existuje v jazyce BQN větší množství. Kromě vykonávané operace se liší i tím, kolik funkcí dokážou na prvky seznamu či polí aplikovat a jakým způsobem. Poměrně dobrým příkladem může být modifikátor nazvaný scan, který postupně prochází všemi prvky, aplikuje zvolenou funkci na aktuální prvek a akumulátor a na vstup posílá výsledek zvolené funkce. Jedná se tedy o obdobu funkce reduction z jazyka APL.

11. Modifikátor scan

Podívejme se na jednoduchý příklad použití tohoto modifikátoru. Nejprve si řekněme, že funkce maximum vrací větší z obou předaných prvků:

2 ⌈ 3
3
 
3 ⌈ 2
3

Nyní můžeme tuto funkci postupně aplikovat na prvky seznamu. Výsledkem bude seznam o stejné délce, který ovšem bude na i-té pozici obsahovat maximální hodnotu prvních i prvků seznamu:

⌈` 1‿3‿0‿5‿3‿2‿1‿0‿9
⟨ 1 3 3 5 5 5 5 5 9 ⟩

Postupný součet prvků seznamu se všemi mezivýsledky:

+` 1‿3‿0‿5‿3‿2‿1‿0‿9
⟨ 1 4 4 9 12 14 15 15 24 ⟩

12. Výpočet tabulky faktoriálu s využitím modifikátoru scan

Modifikátor scan můžeme využít například při výpočtu tabulky faktoriálů. Předpokládejme, že budeme chtít vypočítat tabulku faktoriálů pro vstupy 1 až 10. Tento výpočet je možné zapsat pouhými deseti znaky (sémantická síla APL i BQN je v těchto oblastech obrovská), ovšem my si celý výpočet rozdělíme na víc částí. Nejprve získáme vstupní vektor:

↕10
⟨ 0 1 2 3 4 5 6 7 8 9 ⟩

Tento vektor ještě neodpovídá požadovanému vstupu, protože budeme muset zvýšit všechny hodnoty o jedničku:

1+↕10
⟨ 1 2 3 4 5 6 7 8 9 10 ⟩

Nyní již můžeme přistoupit k použití modifikátoru scan a postupně násobit prvky vstupního vektoru s akumulátorem, jehož počáteční hodnota je nastavena na hodnotu prvního prvku:

×`1+↕10
⟨ 1 2 6 24 120 720 5040 40320 362880 3628800 ⟩

Graf s vizualizací způsobu výpočtu bude vypadat následovně:

Obrázek 9: Způsob vyhodnocení výrazů při výpočtu tabulky faktoriálů.

V případě potřeby můžeme na začátek přidat chybějící jedničku pro 0!, a to operací join:

1~×`1+↕10
⟨ 1 1 2 6 24 120 720 5040 40320 362880 3628800 ⟩

×´1+↕10
3628800

13. Kombinátory

Dalším důležitým prvkem programovacího jazyka BQN jsou takzvané kombinátory. Kombinátory nějakým způsobem modifikují výraz zapsaný programátorem; teprve poté je daný výraz skutečně vykonán. To je velmi silná programovací technika, která odpovídá lepším makrosystémům (ne ovšem tomu céčkovému – ten je totiž realizován ještě před lexikální analýzou a nikoli až po konstrukci AST), protože manipulací se zapsaným výrazem je možné dosáhnout užitečných efektů. Právě kombinátory umožňují i v jazyce BQN realizovat tacit programming, což je technika, které jsme se již na stránkách Roota (prozatím jen ve stručnosti) věnovali v článku Programovací technika nazvaná tacit programming.

Kombinátor swap přehazuje operandy předané funkci. Výpočet 1–2 je triviální:

1 - 2
¯1

Přidáním kombinátoru swap otočíme operandy a budeme tedy počítat 2–1:

1 ˜- 2
1

Vyzkoušejme si nyní jeden z nejjednodušších kombinátorů nazvaný atop. Ten se zapisuje následujícím způsobem:

f∘g

Kde f a g jsou libovolné funkce, přičemž f je funkce monadická a g funkce dyadická. Společně s parametry x a y vypadá zápis takto:

x f∘g y

Kombinátor atop tento zápis ztransformuje na:

f x g y

což díky asociativitě operací vlastně znamená:

f (x g y)

14. Tacit programming

Nyní si ukažme poněkud praktičtější příklad, který byl získán modifikací příkladu z oficiální dokumentace k programovacímu jazyku BQN. Vytvoříme v něm novou funkci, která vypočte absolutní odchylku ze dvou zadaných hodnot. To vlastně znamená, že se hodnoty od sebe odečtou a posléze se vypočte absolutní hodnota tohoto rozdílu.

Samotný výpočet rozdílu je v BQN až trapně jednoduchý:

1 - 2
¯1

Triviální je i výpočet absolutní hodnoty:

|-10
10

Celý výpočet by tedy vypadal takto:

|1-2
1

Nyní se pokusíme obě funkce zkombinovat, a to právě s využitím kombinátoru atop, kterým vlastně vytvoříme novou dyadickou funkci nazvanou například „absolutní odchylka“. Využijeme toho, že platí ekvivalence mezi:

x f∘g y

a:

f (x g y)

V našem konkrétním případě tedy:

1 |∘- 10
9

Verze s opačnými parametry:

10 |∘- 1
9

Nyní se již dostáváme k závěrečné části. Definujeme novou funkci, která ovšem bude obsahovat pouze kombinátor a dvě další funkce – nevyskytuje se zde tedy žádný parametr (resp. dva parametry, protože výsledkem je dyadická funkce). Jedná se o typický příklad použití tacit programmingu:

ABS_DIFF ← |∘-

Nově definovanou funkci už můžeme snadno otestovat na dvojici vstupů:

10 ABS_DIFF 4
6

15. Shrnutí

V předchozím textu jsme si přiblížili pouze relativně malé množství technik, které v jazyku BQN nalezneme. BQN nijak nezastírá, že je založen na APL, ovšem přináší některá zjednodušení (plochá pole), odděluje funkce od operátorů a kombinátorů, nabízí možnost zvýraznění operací technikou explain atd. Nejedná se však o APL, protože sada symbolů je zcela odlišná a zejména sémantika kombinátorů se od APL v mnoha ohledech odlišuje. Taktéž se v mnohem větší míře používají seznamy namísto vektorů.

16. Programovací jazyk ivy

V závěrečné části dnešního článku si ve stručnosti popíšeme další programovací jazyk inspirovaný původním APL. Tento jazyk se jmenuje ivy a zajímavé na něm je, že jeho autorem je Rob Pike a naprogramován je v jazyce Go. Na rozdíl od klasického APL je ivy založen na znakové sadě ASCII a nikoli na specializovaných znacích. Taktéž umožňuje práci se zlomky (typ rational) a celočíselné hodnoty nemají (prakticky) omezený rozsah. Dnes si představíme pouze základy tohoto jazyka, ovšem někdy se k němu vrátíme, protože i způsob jeho implementace je velmi zajímavý, efektivní a navíc Rob Pike díky elegantnímu návrhu obešel nutnost použití generik (které v jazyce Go v té době ještě neexistovaly). V dalších třech kapitolách ukážeme jen několik příkladů použití ivy, ale k tomuto jazyku se ještě vrátíme v souvislosti s články o lexikální a syntaktické analýze.

17. Instalace jazyka ivy

Pro instalaci jazyka ivy je vyžadováno Go verze 1.17. Pokud je Go této verze dostupné, je instalace snadná:

$ go install robpike.io/ivy@latest
go: downloading robpike.io/ivy v0.1.10

Výsledný spustitelný soubor je umístěn do $GOPATH/bin, typicky do ~/go/bin.

18. První seznámení s možnostmi jazyka ivy

Nejprve spustíme interpret jazyka ivy:

$ ivy

Funkce se zapisují v běžné infixové podobě:

1+2
3
 
2*3
6

Priorita funkcí je stejná, asociativita zprava:

1+2*3
7
 
2*3+1
8

Výpočty nad vektory:

1 2 3 + 3 4 5
4 6 8

Výpočty se zlomky:

1/3 + 1/4
7/12

Operace reduce převzatá z APL:

*/+ 1 2 3 4 5
120

Výpočet faktoriálu 10:

*/ iota 10
3628800

Prakticky neomezený rozsah celých čísel:

*/ iota 100
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Převod na zlomek (se zjednodušením):

3 / */ iota 10
1/1209600

atd.

19. Výpočet prvočísel v jazyku ivy

V článku o programovacím jazyku APL jsme si ukázali, jakým způsobem je možné vypočítat prvočísla od 2 do zadané hodnoty x. Celý výpočet lze zapsat na jediný řádek, a to následovně:

(~R∊R∘.×R)/R←1↓⍳x

Jednotlivé kroky si postupně rozepíšeme:

Tento algoritmus lze přepsat do jazyka ivy relativně jednoduše – náhradou speciálních symbolů APL za názvy funkcí. Nejprve celý výpočet postupně provedeme v interaktivním prostředí:

Určíme meze výpočtu:

x=10

Vytvoření sekvence hodnot:

iota x
1 2 3 4 5 6 7 8 9 10

Odstranění prvního čísla, tedy jedničky:

1 drop iota x
2 3 4 5 6 7 8 9 10

Uložení mezivýsledku do proměnné R:

R = 1 drop iota x
 
R
2 3 4 5 6 7 8 9 10

Výpočet matice s násobky všech kombinací R:

R o.* R
  4   6   8  10  12  14  16  18  20
  6   9  12  15  18  21  24  27  30
  8  12  16  20  24  28  32  36  40
 10  15  20  25  30  35  40  45  50
 12  18  24  30  36  42  48  54  60
 14  21  28  35  42  49  56  63  70
 16  24  32  40  48  56  64  72  80
 18  27  36  45  54  63  72  81  90
 20  30  40  50  60  70  80  90 100

Test, která čísla jsou nalezena v matici násobků:

R in R o.* R
0 0 1 0 1 0 1 1 1

Negace předchozího testu – vyberou se tedy čísla, která v matici nejsou:

not R in R o.* R
1 1 0 1 0 1 0 0 0

Použití předchozího vektoru s 0/1 pro výběr z mezivýsledku (vektoru čísel):

(not R in R o.* R) sel R
2 3 5 7

Dostali jsme tedy kýžený výsledek.

Vše si můžeme zapsat na jediný řádek a vypočítat tak prvočísla od 2 do 100:

(not R in R o.* R) sel R = 1 drop iota 100
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Porovnání verze v APL a v ivy ukazuje pouze syntaktické rozdíly, nikoli rozdíly v sémantice:

20. Odkazy na Internetu

1. BQN: An APL Variant from Marshall Lochbaum (mlochbaum.github.io)
   https://news.ycombinator.com/i­tem?id=24167804
2. Marshall Lochbaum
   https://www.aplwiki.com/wi­ki/Marshall_Lochbaum
3. BQN
   https://www.aplwiki.com/wiki/BQN
4. Co-dfns
   https://www.aplwiki.com/wiki/Co-dfns
5. Array model
   https://www.aplwiki.com/wi­ki/Array_model#Based_arra­y_theory
6. Fonts for BQN
   https://mlochbaum.github.i­o/BQN/fonts.html
7. Leading axis theory
   https://www.aplwiki.com/wi­ki/Leading_axis_theory
8. A based system for general arrays
   https://dl.acm.org/doi/ab­s/10.1145/586656.586663
9. APL – A Glimpse of Heaven (2006)
   https://news.ycombinator.com/i­tem?id=19325361
10. APL and J
    https://crypto.stanford.e­du/~blynn/c/apl.html
11. ivy (dokumentace)
    https://pkg.go.dev/robpike­.io/ivy#section-readme
12. ivy na GitHubu
    https://github.com/robpike/ivy/
13. Ivy na APL wiki
    https://aplwiki.com/wiki/Ivy
14. Implementing a bignum calculator (slajdy)
    https://talks.godoc.org/git­hub.com/robpike/ivy/talks/i­vy.slide#1
15. Implementing a bignum calculator – Rob Pike – golang-syd November 2014
    https://www.youtube.com/wat­ch?v=PXoG0WX0r_E
16. Rob Pike na Wikipedii
    https://en.wikipedia.org/wi­ki/Rob_Pike
17. Rob Pike na cat-v
    http://genius.cat-v.org/rob-pike/
18. Jazyky umožňující operace s poli aneb rozsáhlý svět „array programmingu“
    https://www.root.cz/clanky/jazyky-umoznujici-operace-s-poli-aneb-rozsahly-svet-bdquo-array-programmingu-ldquo/
19. Programovací technika nazvaná tacit programming
    https://www.root.cz/clanky/pro­gramovaci-technika-nazvana-tacit-programming/
20. Oslava 55 let od vzniku první implementace jazyka APL
    https://www.root.cz/clanky/oslava-55-let-od-vzniku-prvni-implementace-programovaciho-jazyka-apl/
21. NuVoc
    https://code.jsoftware.com/wiki/NuVoc
22. J (programming language) [Wikipedia]
    https://en.wikipedia.org/wi­ki/J_%28programming_langu­age%29
23. J – Absolutely Essential Terms
    https://code.jsoftware.com/wi­ki/Vocabulary/AET
24. J – Atoms and Arrays
    https://code.jsoftware.com/wi­ki/Vocabulary/Nouns#Atom
25. Why J
    https://www.jsoftware.com/hel­p/primer/why_j.htm
26. What is an Array?
    https://vector.org.uk/what-is-an-array/
27. Comments
    http://www.gavilan.edu/csis/lan­guages/comments.html
28. Vector (Wolfram MathWorld)
    https://mathworld.wolfram­.com/Vector.html
29. n-Tuple (Wolfram MathWorld)
    https://mathworld.wolfram.com/n-Tuple.html
30. n-Vector (Wolfram MathWorld)
    https://mathworld.wolfram.com/n-Vector.html
31. Matrix (Wolfram MathWorld)
    https://mathworld.wolfram­.com/Matrix.html
32. Array (Wolfram MathWorld)
    https://mathworld.wolfram­.com/Array.html
33. ND Arrays (Tensors) in different languages
    https://www.youtube.com/wat­ch?v=WbpbEilgQBc
34. Extending APL to Infinity\
    https://www.jsoftware.com/pa­pers/eem/infinity.htm
35. Vector Library (R7RS-compatible)
    https://srfi.schemers.org/srfi-133/srfi-133.html
36. Vectors (pro Gauche)
    https://practical-scheme.net/gauche/man/gauche-refe/Vectors.html
37. Kawa: Compiling Scheme to Java
    https://www.mit.edu/afs.new/sip­b/project/kawa/doc/kawa-tour.html
38. Kawa in Languages shootout
    http://per.bothner.com/blog/2010/Kawa-in-shootout/
39. Kawa 2.0 Supports Scheme R7RS
    https://developers.slashdot­.org/story/14/12/13/2259225/ka­wa-20-supports-scheme-r7rs/
40. Kawa — fast scripting on the Java platform
    https://lwn.net/Articles/623349/
41. Incanter is a Clojure-based, R-like platform for statistical computing and graphics.
    http://incanter.org/
42. Evolution of incanter (Gource Visualization)
    https://www.youtube.com/wat­ch?v=TVfL5nPELr4
43. Questions tagged [incanter] (na Stack Overflow)
    https://stackoverflow.com/qu­estions/tagged/incanter?sor­t=active
44. Data Sorcery with Clojure
    https://data-sorcery.org/contents/
45. Back to the Future: Lisp as a Base for a Statistical Computing System
    https://rd.springer.com/chap­ter/10.1007/978–3–7908–2084–3_2
46. Incanter Cheat Sheet
    http://incanter.org/docs/incanter-cheat-sheet.pdf
47. Back to the Future: Lisp as a Base for a Statistical Computing System (celá verze článku)
    https://www.researchgate.net/pu­blication/227019917_Back_to_the_Fu­ture_Lisp_as_a_Base_for_a_Sta­tistical_Computing_System
48. BQN: finally, an APL for your flying saucer
    https://mlochbaum.github.io/BQN/
49. Is BQN stable?
    https://mlochbaum.github.i­o/BQN/commentary/stability­.html
50. Specification: BQN system-provided values
    https://mlochbaum.github.i­o/BQN/spec/system.html
51. Tutorial: BQN expressions
    https://mlochbaum.github.i­o/BQN/tutorial/expression­.html
52. BQN primitives
    https://mlochbaum.github.i­o/BQN/doc/primitive.html
53. Function trains
    https://mlochbaum.github.i­o/BQN/doc/train.html
54. BQN community links
    https://mlochbaum.github.i­o/BQN/community/index.html
55. BQN UV
    https://observablehq.com/@lsh/bqn-uv
56. APL Wiki
    https://aplwiki.com/wiki/
57. The Array Cast
    https://www.arraycast.com/e­pisodes/episode-03-what-is-an-array
58. EnthusiastiCon 2019 – An Introduction to APL
    https://www.youtube.com/wat­ch?v=UltnvW83_CQ
59. Dyalog
    https://www.dyalog.com/
60. Try APL!
    https://tryapl.org/
61. Lisp-Stat Information
    http://homepage.cs.uiowa.e­du/~luke/xls/xlsinfo/
62. Sample Plots in Incanter
    https://github.com/incanter/in­canter/wiki/Sample-Plots-in-Incanter#line
63. vectorz-clj
    https://github.com/mikera/vectorz-clj
64. vectorz – Examples
    https://github.com/mikera/vectorz-clj/wiki/Examples
65. Basic Vector and Matrix Operations in Julia: Quick Reference and Examples
    https://queirozf.com/entries/basic-vector-and-matrix-operations-in-julia-quick-reference-and-examples
66. Vectors and matrices in Julia
    https://fncbook.github.io/v1­.0/linsys/demos/matrices-julia.html
67. Array vs Matrix in R Programming
    https://www.geeksforgeeks.org/array-vs-matrix-in-r-programming/
68. Concurrency (computer science)
    https://en.wikipedia.org/wi­ki/Category:Concurrency_%28com­puter_science%29
69. Koprogram
    https://cs.wikipedia.org/wi­ki/Koprogram
70. Coroutine
    https://en.wikipedia.org/wi­ki/Coroutine
71. Coroutines in C
    http://www.chiark.greenen­d.org.uk/~sgtatham/corouti­nes.html
72. S-expression (Wikipedia)
    https://en.wikipedia.org/wiki/S-expression
73. S-Expressions (Rosetta Code)
    http://rosettacode.org/wiki/S-Expressions
74. Introducing Julia/Metaprogramming
    https://en.wikibooks.org/wi­ki/Introducing_Julia/Meta­programming
75. Tutorial for the Common Lisp Loop Macro
    http://www.ai.sri.com/pkarp/loop.html
76. Clojure Macro Tutorial (Part I, Getting the Compiler to Write Your Code For You)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-i-getting.html
77. Clojure Macro Tutorial (Part II: The Compiler Strikes Back)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-compiler.html
78. Clojure Macro Tutorial (Part III: Syntax Quote)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-syntax.html
79. Clojure Macros and Metaprogramming
    http://clojure-doc.org/articles/language/macros.html
80. Fatvat – Exploring functional programming: Clojure Macros
    http://www.fatvat.co.uk/2009/02/clo­jure-macros.html
81. CS 2101 Parallel Computing with Julia
    https://www.coursehero.com/fi­le/11508091/CS-2101-Parallel-Computing-with-Julia/
82. Julia By Example
    https://samuelcolvin.github­.io/JuliaByExample/
83. Array Programming
    https://en.wikipedia.org/wi­ki/Array_programming
84. Discovering Array Languages
    http://archive.vector.org­.uk/art10008110
85. no stinking loops – Kalothi
    http://www.nsl.com/
86. Vector (obsahuje odkazy na články, knihy a blogy o programovacích jazycích APL, J a K)
    http://www.vector.org.uk/
87. APL Interpreters
    http://www.vector.org.uk/?a­rea=interpreters
88. APL_(programming_language
    http://en.wikipedia.org/wi­ki/APL_(programming_langu­age
89. APL FAQ
    http://www.faqs.org/faqs/apl-faq/
90. APL FAQ (nejnovější verze)
    http://home.earthlink.net/~swsir­lin/apl.faq.html
91. A+
    http://www.aplusdev.org/
92. APLX
    http://www.microapl.co.uk/
93. FreeAPL
    http://www.pyr.fi/apl/index.htm
94. Learning J (Roger Stokes)
    http://www.jsoftware.com/hel­p/learning/contents.htm
95. J: a modern, high-level, general-purpose, high-performance programming language
    http://www.jsoftware.com/
96. K, Kdb: an APL derivative for Solaris, Linux, Windows
    http://www.kx.com
97. openAPL (GPL)
    http://sourceforge.net/pro­jects/openapl
98. Parrot APL (GPL)
    http://www.parrotcode.org/
99. Learning J (Roger Stokes)
    http://www.jsoftware.com/hel­p/learning/contents.htm
100. Rosetta Code
     http://rosettacode.org/wiki/Main_Page
101. Why APL
     http://www.acm.org/sigapl/whyapl.htm
102. Introducing Julia/Functions
     https://en.wikibooks.org/wi­ki/Introducing_Julia/Functi­ons
103. Functions (Julia documentation)
     https://docs.julialang.or­g/en/v1/manual/functions/
104. Evaluate binomial coefficients
     http://rosettacode.org/wi­ki/Evaluate_binomial_coef­ficients
105. Ackermann function
     http://rosettacode.org/wi­ki/Ackermann_function
106. Julia (front page)
     http://julialang.org/
107. Julia – dokumentace
     http://docs.julialang.org/
108. Julia – repositář na GitHubu
     https://github.com/JuliaLang/julia
109. Julia (programming language)
     https://en.wikipedia.org/wi­ki/Julia_%28programming_lan­guage%29
110. IJulia
     https://github.com/JuliaLan­g/IJulia.jl
111. Introducing Julia
     https://en.wikibooks.org/wi­ki/Introducing_Julia
112. Julia: the REPL
     https://en.wikibooks.org/wi­ki/Introducing_Julia/The_REPL
113. Month of Julia
     https://github.com/DataWo­okie/MonthOfJulia
114. Learn X in Y minutes (where X=Julia)
     https://learnxinyminutes.com/doc­s/julia/
115. New Julia language seeks to be the C for scientists
     http://www.infoworld.com/ar­ticle/2616709/application-development/new-julia-language-seeks-to-be-the-c-for-scientists.html
116. Julia: A Fast Dynamic Language for Technical Computing
     http://karpinski.org/publi­cations/2012/julia-a-fast-dynamic-language
117. The LLVM Compiler Infrastructure
     http://llvm.org/
118. Julia: benchmarks
     http://julialang.org/benchmarks/
119. Type system
     https://en.wikipedia.org/wi­ki/Type_system
120. Half-precision floating-point format
     https://en.wikipedia.org/wiki/Half-precision_floating-point_format
121. Dartmouth BASIC
     https://en.wikipedia.org/wi­ki/Dartmouth_BASIC
122. BASIC 4th Edition
     http://www.bitsavers.org/pdf/dar­tmouth/BASIC_4th_Edition_Jan68­.pdf
123. VECTRAN
     https://encyclopedia2.the­freedictionary.com/VECTRAN
124. Comparison of programming languages (array)
     https://en.wikipedia.org/wi­ki/Comparison_of_programmin­g_languages_(array)
125. BASIC at 50
     https://www.dartmouth.edu/ba­sicfifty/commands.html
126. BBC Basic – arrays
     http://www.riscos.com/sup­port/developers/bbcbasic/par­t2/arrays.html
127. Datová struktura
     https://cs.wikipedia.org/wi­ki/Datov%C3%A1_struktura
128. SIMD instrukce využívané v moderních mikroprocesorech řady x86
     https://www.root.cz/clanky/simd-instrukce-vyuzivane-v-modernich-mikroprocesorech-rady-x86/
129. SIMD instrukce v moderních mikroprocesorech řady x86 (2.část: SSE)
     https://www.root.cz/clanky/simd-instrukce-v-modernich-mikroprocesorech-rady-x86–2-cast-sse/
130. SIMD instrukce v moderních mikroprocesorech řady x86 (3.část: SSE2)
     https://www.root.cz/clanky/simd-instrukce-v-modernich-mikroprocesorech-rady-x86–3-cast-sse2/
131. Inductive type
     https://en.wikipedia.org/wi­ki/Inductive_type
132. JuliaMono, a font for programming
     https://github.com/cormulli­on/juliamono
133. It’s arrays all the way down
     https://xpqz.github.io/le­arnapl/array.html