Hlavní navigace

Uiua: nevšední kombinace zásobníkového jazyka s jazykem pro práci s poli

30. 11. 2023
Doba čtení: 29 minut

Sdílet

 Autor: Root.cz s využitím DALL-E
Dnes se ve stručnosti seznámíme s programovacím jazykem, který lze zařadit jak mezi jazyky zásobníkové („forthovská“ skupina), tak i mezi jazyky určené pro práci s n-rozměrnými poli („APL“ skupina).

Obsah

1. Mainstreamové, ne-mainstreamové a esoterické programovací jazyky

2. Uiua: nevšední kombinace zásobníkového jazyka s jazykem pro práci s poli

3. Základní koncepty, na nichž je programovací jazyk Uiua postaven

4. Programovací jazyky založené na zásobníku operandů a RPN

5. Použití zásobníku v programovacím jazyku Uiua

6. Funkce pro manipulace s prvky uloženými na zásobníku

7. Základní monadické funkce pro zpracování skalárních hodnot

8. Základní dyadické funkce pro zpracování skalárních hodnot

9. Pole

10. Konstrukce polí

11. Zpracování polí prvek po prvku

12. Monadické funkce pro operace nad celými poli

13. Ukázka použití vybraných monadických funkcí

14. Dyadické funkce pro operace nad celými poli

15. Ukázka použití vybraných dyadických funkcí

16. Agregační operace

17. Iterace nad prvky polí

18. Závěr

19. Předchozí články o rozsáhlém světu „array programmingu“

20. Odkazy na Internetu

1. Mainstreamové, ne-mainstreamové a esoterické programovací jazyky

Na stránkách Roota jsme se již mohli seznámit s různými programovacími jazyky. Jednalo se jak o programovací jazyky patřící spíše do mainstreamu (do této kategorie si v současnosti dovolím zařadit RustGo), tak i o programovací jazyky velmi specializované (Julia či R). A zapomenout nesmíme ani na různé více či méně esoterické programovací jazyky, o nichž jsme psali v seriálu Programovací jazyky z vývojářského pekla.

Minimálně dvě skupiny programovacích jazyků, s nimiž jsme se prozatím seznámili, nepatří (alespoň nikoli v současnosti) mezi mainstream. V první skupině nalezneme jazyky založené na použití dvojice zásobníků (konkrétně na zásobníku operandů a na zásobníku návratových hodnot). Mezi tyto jazyky patří především programovací jazyk Forth, ale například taktéž jazyky Joy a Factor, které jsou Forthem jasně inspirovány. A druhou skupinou ne-mainstreamových programovacích jazyků tvoří jazyky specializované pro práci s n-rozměrnými poli, tedy zejména APL, J, BQN, K, Q či jazyk Nial.

2. Uiua: nevšední kombinace zásobníkového jazyka s jazykem pro práci s poli

V dnešním článku se ve stručnosti seznámíme s programovacím jazykem, který je možné zařadit jak mezi jazyky zásobníkové (tedy patřící do „Forthovské“ skupiny), tak i mezi jazyky určené pro práci s n-rozměrnými poli (jde tedy o „APL“ skupinu). Tento neobvyklý programovací jazyk, jehož syntaxe a sémantika je poněkud esoterická, má i dosti prapodivné jméno – Uiua (vyslovováno má být jako wee-wuh). Mohlo by se zdát, že propojení zásobníkového jazyka s jazykem pro práci s n-rozměrnými poli je poněkud umělé, ale výsledek je až překvapivě konzistentní, i když bez předchozího tréninku pochopitelně velmi špatně čitelný. Navíc je díky syntaxi zápisu umožněn a podporován tacit programming neboli point-free style, což je způsob programování bez nutnosti explicitního pojmenovávání předávaných parametrů, jemuž jsme se věnovali v článku Jazyk APL, kombinátory, vláčky a point-free style (a který je vlastně implicitně podporován prakticky všemi zásobníkovými jazyky).

3. Základní koncepty, na nichž je programovací jazyk Uiua postaven

Programovací jazyk Uiua je postaven na několika konceptech, s nimiž se podrobněji setkáme v navazujících kapitolách:

  1. Prvním konceptem je fakt, že operandy jsou ukládány na zásobník (stack). Zásobník zde funguje stejně, jako je tomu v mnoha klasických zásobníkových jazycích, tj. poslední prvek vložený na zásobník je umístěn na vrchol zásobníku (TOS – Top of Stack) a taktéž je jako první ze zásobníku vyjmut. Jinými slovy – jedná se o datovou struktury typu LIFO – Last In, First Out.
  2. Další koncept spočívá ve způsobu zpracování jednotlivých programových řádků po jejich parsingu. Operandy, funkce a modifikátory, jsou totiž čteny zprava doleva (ano, čtete správně – zprava doleva). Pokud je nalezen operand (hodnota), je uložen na zásobník, funkce své operandy čtou ze zásobníku a modifikátory mění chování funkcí. Tím je vlastně popsána celá sémantika :-)
  3. Operandy jsou jen dvou typů – skaláry a pole.
  4. Funkce mohou být monadické (s jedním operandem) nebo dyadické (se dvěma operandy). Ovšem teoreticky lze díky použití zásobníku mít i funkce s větším počtem operandů (na rozdíl od APL, kde je to minimálně problematické až nemožné).
  5. Funkce, které pracují se skaláry, dokážou postupně zpracovat i prvky pole či odpovídající si prvky pole (například součet polí je realizován prvek po prvku).
  6. Poté existují funkce pracující pouze s poli. Příkladem je funkcereshape, kterou nemá smysl aplikovat na skalární hodnotu.
  7. V jazyku lze nalézt i takzvané modifikátory, kam spadají například operace reduce, fold či scan apod. Jedná se o nejsilnější koncept tohoto jazyka (převzatý z APL).
  8. A nakonec se v jazyku nachází „podivnosti“ nazvané Planet a Ocean (viz závěrečné kapitoly).

Obrázek 1: Interaktivní webové prostředí programovacího jazyka Uiua. V současnosti si lze základní vlastnosti většiny programovacích jazyků ověřit právě v různých webových prostředích, takže není vyžadována (mnohdy zbytečně komplikovaná) instalace.

4. Programovací jazyky založené na zásobníku operandů a RPN

V úvodním textu jsme se zmínili o programovacích jazycích Forth, Joy, Factor (ale patří sem například i PostScript). I přesto, že se tyto programovací jazyky od sebe v mnoha ohledech odlišují, mají jednu důležitou vlastnost společnou – výpočty, tj. aritmetické operace, logické operace a v neposlední řadě i rozhodovací (řídicí) konstrukce jsou prováděny s hodnotami uloženými na zásobníku (ten je z tohoto důvodu nazýván zásobník operandů). Díky tomu bylo možné tyto programovací jazyky interně značně zjednodušit, protože se o transformaci výrazů z dnes běžné infixové podoby do podoby postfixové (jinak známé pod názvem převrácená polská notace/Reverse Polish Notation, Reverse Polish Notation – RPN) musí postarat sám programátor. To ve skutečnosti není nijak složité, ostatně s prakticky stejným (pseudo)problémem se musí potýkat i ti uživatelé, kteří například používají kalkulačky vyráběné společností Hewlett-Packard.

Obrázek 2: I moderní kalkulačky vyráběné společností Hewlett-Packard podporují převrácenou polskou notaci.

Poznámka: mimochodem – podle názoru některých vývojářů se všechny čtyři výše zmíněné programovací jazyky už nachází na hranici mezi „civilizovanými“ programovacími jazyky a jazyky esoterickými, i když autor článku je velkým fandou zásobníkových jazyků, takže tento názor plně nesdílí :-).

V této kapitole si jen v krátkosti připomeňme, že při použití zásobníku operandů přímo v programovacím jazyku jsou hodnoty na zásobník ukládány explicitně (zápis 42 tedy většinou znamená uložení této hodnoty na vrchol zásobníku operandů), aritmetické a logické operace používají implicitní adresování operandů (vždy se totiž jedná o hodnotu uloženou na vrcholu zásobníku či těsně pod ním) a kromě toho se většinou setkáme i s několika pomocnými operacemi určenými pro manipulaci s obsahem zásobníku. Tyto operace bývají nazývány dup (zduplikování hodnoty uložené na vrcholu zásobníku, zásobník se o jeden prvek zvětší), drop (odstranění hodnoty z vrcholu zásobníku operandů, zásobník se o jeden prvek zmenší), swap (prohození dvou nejvyšších prvků uložených na zásobníku, velikost zásobníku se nezmění) a rot (rotace tří nejvyšších prvků, velikost zásobníku se opět nezmění). Tyto názvy mají dnes již vlastně historický původ, protože byly použity v programovacím jazyku Forth; později se začaly používat například i v zásobníkových virtuálních strojích.

Poznámka: vrchol zásobníku operandů se označuje zkratkou TOS neboli Top Of Stack. Někdy se setkáme i se zkratkou TOS1 (popř.s dalšími čísly), které určují prvky uložené těsně pod TOS. Tyto zkratky se používají například v bajtkódu programovacího jazyka Python.

Nicméně se vraťme k zásobníku operandů a k tacit programmingu. Ve Forthu je možné napsat například následující funkci:

:foo + * ;

Tato funkce na zásobníku očekává alespoň tři číselné hodnoty, které ovšem uvnitř funkce nejsou nikde explicitně pojmenovány ani (explicitně) použity. Použití této funkce je stejně snadné jako její zápis, pochopitelně pokud si zvyknete na RPN:

3 2 1 foo .
9

Nejprve jsme na zásobník uložili tři hodnoty. Posléze se zavolala funkce foo, která tyto hodnoty nějakým způsobem zpracovala. Na nakonec byla hodnota umístěná na TOS vypsána další funkcí se jménem . (ano, tečka je ve Forthu skutečně zcela legitimní jméno funkce).

Povšimněte si, že nyní těla funkce foo:

+ *

Tělo této funkce obsahuje pouze dvě tzv. slova „+“ a „*“. Každé z těchto slov očekává na zásobníku operandů dvojici hodnot, které jsou sečteny, popř. vynásobeny a výsledek je uložen zpět na zásobník operandů. Nikde tedy není nutné psát, jak se operandy jmenují a už vůbec ne, jak se jmenuje výsledná hodnota. Navíc ani funkce foo tyto údaje neobsahuje.

Poznámka: a právě zápis :foo + * ; ukazuje typické znaky tacit programmingu. Na jednu stranu je tento zápis velmi úsporný a v mnoha případech i idiomatický. Na stranu druhou může být tento zápis dosti těžko rozluštitelný, a to právě díky jeho úspornosti – všechny nepodstatné detaily byly vynechány, takže kód prakticky postrádá redundanci (která je například v hovorovém jazyce užitečná, neboť usnadňuje porozumění zprávě i při jejím „zašumění“ či nedokonalé znalosti jazyka).

5. Použití zásobníku v programovacím jazyku Uiua

Všechny dále uvedené příklady si můžeme vyzkoušet na adrese https://www.uiua.org/ přímo v interaktivním prostředí pracujícím ve webovém prohlížeči.

Poznámka: ve všech následujících demonstračních příkladech bude prostředí programovacího jazyka Uiua zobrazovat obsah zásobníku operandů. Přitom je použit takový způsob zobrazení, aby byl nejvyšší prvek zásobníku operandů (TOS – Top Of Stack) zobrazen na nejvyšším řádku (zásobník tedy v tomto pojetí poroste zdola nahoru, což ostatně odpovídá i chování běžných mikroprocesorů). Toto chování je ovšem nutné v interaktivním prostředí jazyka Uiua explicitně nastavit po kliknutí na ikonu ozubeného kolečka (show settings) a výběrem položky „Top at Top“ ve výběrovém boxu Stack. V implicitním nastavení jsou totiž prvky zásobníku zobrazeny v opačném pořadí, což však znamená, že označení Top Of Stack nebude mít svoji vizuální obdobu.

Obrázek 3: Nastavení, které je nutné provést v interaktivním vývojovém prostředí jazyka Uiua tak, aby se obsah zásobníku zobrazoval způsobem, který dává zkratce TOS význam.

V programovacím jazyku Uiua se nepoužívá klasická a standardní převrácená polská notace (tedy již popsaná RPN) ale určitá obdoba (přímé) polské notace, což může být poměrně matoucí. Navíc se operátory a operandy zapsané na řádku zpracovávají zprava doleva. To má sice své logické důvody, o nichž se zmíníme dále, ovšem opět se jedná o koncept, který může být dosti nezvyklý. Jak se ale tyto dvě vlastnosti, resp. jejich kombinace, projeví v praxi? Pokud například na jediný řádek zapíšeme trojici číselných hodnot, budou tyto hodnoty uloženy na zásobník (až potud je vše očekávatelné). Ovšem číselné hodnoty jsou zpracovávány zprava doleva a právě v tomto pořadí jsou uloženy na zásobník. Výsledkem tedy bude, že první zapsaná hodnota bude uložena na vrchol zásobníku operandů, tedy zcela opačně, než je tomu v klasické RPN:

1 2 3
 
1
2
3

Povšimněte si, že po spuštění výše uvedeného programu (ten je zapsán tučně) se v interaktivním prostředí pod programem zobrazí trojice hodnot tak, jak jsou uloženy na zásobníku. Vzhledem ke způsobu vyhodnocování zprava doleva se tedy na zásobník nejprve uloží hodnota 3, poté hodnota 2 a nakonec bude na vrchol zásobníku bude uložena hodnota 1.

Můžeme si otestovat i nepatrně odlišný program, po jehož spuštění se nejdříve na zásobník uloží hodnoty 2 a 1 (přesně v tomto pořadí) a následně se tyto hodnoty sečtou spuštěním operace +, která ze zásobníku vyjme dva prvky, sečte je a na zásobník vrátí výsledek součtu:

+ 1 2
 
3

Operace + ovšem ve skutečnosti pracuje pouze se dvěma nejvyššími prvky uloženými na zásobníku. Případné další prvky nejsou dotčeny:

+ 1 2 100 100
 
3
100
100

Operátor zapsaný zcela nalevo bude proveden nejpozději, což zde konkrétně znamená, že vynásobí hodnoty 3 a 100, přičemž výsledek opět uloží zpět na zásobník:

× + 1 2 100 100
 
300
100
Poznámka: povšimněte si, jak se kombinace obou výše uvedených vlastností projevuje na způsobu seřazení operátorů a operandů.

Infixově zapsaná operace (1+2)×3 vypadá v pojetí programovacího jazyka Uiua následovně:

× + 1 2 3
 
9

Nebo též:

× 3 + 1 2
 
9

Ovšem nic nám nebrání v zápisu přes více řádků:

+ 1 2
× 3
 
9

nebo:

1 2 3
×+
 
9

či dokonce:

1 2 3
+
×
 
9

6. Funkce pro manipulace s prvky uloženými na zásobníku

V programovacím jazyku Uiua existuje šest funkcí, které jsou určeny pro manipulace s prvky uloženými na zásobníku. Některé z těchto funkcí známe již z popisu zásobníkových programovacích jazyků, ovšem poslední dvě funkce jsou specifické pro Uiua. A pochopitelně, díky tomu, že se jedná o jazyk odvozený od APL, jsou všechny funkce reprezentovány jednoznakovými symboly (z Unicode):

Symbol Jméno Stručný popis
. duplicate duplikace prvku na TOS
, over duplikace prvku pod TOS
: flip prohození dvou nejvyšších prvků na zásobníku
; pop odstranění prvku z TOS
both zavolá monadickou funkci na dva operandy (nebo dyadickou funkci na dvojici operandů)
trace vypíše (pretty print) prvek na TOS, ovšem bez jeho odstranění ze zásobníku

Otestování základního chování těchto funkcí:

Duplikace prvku na TOS:

. 1 2 3
 
1
1
2
3

Duplikace prvku pod TOS:

, 1 2 3
 
2
1
2
3

Prohození dvou nejvyšších prvků na zásobníku:

: 1 2 3
 
2
1
3

Odstranění nejvyššího prvku z TOS:

; 1 2 3
 
2
3

Změna znaménka u prvních dvou prvků:

∩¯ 1 2 3
 
¯1
¯2
3

Výpis podrobnějších informací o prvku s hodnotou –1:

⸮∩¯ 1 2 3
 
┌╴1:1
├╴¯1
└╴╴╴╴
¯1
¯2
3

7. Základní monadické funkce pro zpracování skalárních hodnot

Připomeňme si, že v programovacích jazycích odvozených od APL se rozlišuje mezi funkcemi monadickými a dyadickými. Monadické funkce mají pouze jeden operand (či parametr), kdežto dyadické funkce mají dva operandy (parametry). Nejprve si tedy popišme tu nejjednodušší skupinu funkcí. Jedná se o monadické funkce určené pro zpracování skalárních hodnot:

Symbol Jméno Stručný popis
¬ not logická negace
± sign vrací –1, 0 či +1 podle znaménka operandu
¯ negate změna znaménka
absolute value výpočet absolutní hodnoty
sqrt výpočet druhé odmocniny
sine výpočet goniometrické funkce sin
floor zaokrouhlení směrem dolů
ceiling zaokrouhlení směrem nahoru
round zaokrouhlení

Několik příkladů (již bez popisu):

± 42
 
1
¯ 42
 
¯42
⌵¯42
 
42
√⌵¯100
 
10
⌊1.5
 
1
⌈1.5⌊
 
2

8. Základní dyadické funkce pro zpracování skalárních hodnot

V programovacím jazyku Uiua nalezneme i dyadické funkce, které jsou určené pro zpracování skalárních hodnot. Tyto funkce ze zásobníku získají dva prvky, provedou s nimi vybranou operaci a výsledek nebo výsledky uloží zpět na zásobník. Jedná se o následující funkce:

Symbol Jméno Stručný popis
= equals test na rovnost dvou prvků
not equals test na nerovnost dvou prkvů
< less than test na relaci dvou prvků
less or equal test na relaci dvou prvků
> greater than test na relaci dvou prvků
greater or equal test na relaci dvou prvků
     
+ add součet
subtract rozdíl
× multiply součin
÷ divide podíl
     
modulus zbytek po dělení
power x^y
logarithm logaritmus o zvoleném základu
minimum menší hodnota
maximum větší hodnota
atangent arctan pro (dvě) přepony trojúhelníku
     
complex konstrukce komplexního čísla z reálné a imaginární složky

U některých výše zmíněných operací je nutné si dát pozor na pořadí operandů uložených na zásobníku:

÷ 1 2
 
2
÷ 2 1
 
0.5

Logaritmus o zvoleném základu:

ₙ 10 10000
 
4
ₙ 10000 10
 
0.25

9. Pole

V programovacím jazyku Uiua se primárně rozlišují dvě skupiny typů hodnot. První skupinu tvoří atomy (atom), druhou skupinu pak pole (array). Na pole se můžeme dívat jako na skupinu atomů organizovaných podél os (axes), přičemž počet os určuje dimenzi pole. Každé pole má svůj tvar, který popisuje velikost pole měřenou podél jednotlivých os (tedy pole s tvarem [2 3 4] má rozměry 2×3×4 prvky). Os přitom může být (prakticky) libovolný počet. Další důležitou vlastností polí je, že jsou homogenní, tj. obsahují prvky stejného typu.

Pole lze ukládat na zásobník, stejně jako skalární hodnoty. A navíc platí, že monadické a dyadické funkce popsané v předchozích kapitolách, lze aplikovat i na pole – potom se takové funkce buď aplikují na všechny prvky pole (monadické funkce) nebo na všechny odpovídající si prvky ze dvou polí (dyadické funkce).

10. Konstrukce polí

V programovacím jazyku Uiua existuje literál představující celé pole. Tento literál se zapisuje formou hodnot jednotlivých prvků (musí se jednat o hodnoty), které jsou spojeny (či odděleny – záleží na úhlu pohledu) podtržítkem. Literál představující jednorozměrné pole se čtyřmi prvky se zapíše takto:

1_2_3_4
 
[1 2 3 4]

Můžeme také použít konstruktor pole, v němž se jednotlivé prvky zapisují do hranatých závorek a odděleny jsou nějakým bílým znakem:

[1 2 3 4]
 
[1 2 3 4]

V tomto případě jsou ovšem prvky vyhodnocovány (nejde o literál) a to nám například umožňuje provést výpočet 1+2 a 3+4 s tím, že výsledky těchto výpočtů budou zapsány do nově zkonstruovaného pole:

[+ 1 2 + 3 4]
 
[3 7]

Konstrukce vícerozměrného pole je snadná – prvky n-rozměrného pole jsou totiž n-1 rozměrná pole, takže použijeme konstruktor, kterému tato menší pole předáme:

[[1 2][3 4]]
 
╭─
╷ 1 2
  3 4
      ╯

A takto vypadá konstrukce trojrozměrného pole:

[[[0 0][0 0]][[1 2][3 4]]]
 
╭─
╷ 0 0
╷ 0 0

  1 2
  3 4
      ╯

Jazyk Uiua pracuje i s řetězci. Řetězcový skalár se zapíše následovně:

"Hello world"
 
"Hello world"

Literál představující pole obsahující řetězce:

"Hello"_"world"
 
╭─
╷ "Hello"
  "world"
          ╯

Výsledné pole ovšem musí být homogenní – všechny prvky musí být stejného typu:

"Hello"_"world"_42
 
Error: Cannot append character array to number array
  at 1:1
1 | "Hello"_"world"_4

11. Zpracování polí prvek po prvku

Jak již víme z předchozího textu, lze všechny monadické a dyadické funkce určené pro práci se skaláry použít i pro dvojici stejně velkých polí (tedy polí se shodným tvarem). Takové funkce jsou aplikovány na odpovídající si prvky polí.

Součet dvou polí prvek po prvku:

+ [1 2 3] [4 5 6]
 
[5 7 9]

Takzvaný broadcasting umožňující přičíst hodnotu 10 ke každému prvku pole:

+ [1 2 3] 10
 
[11 12 13]

Výsledkem této operace je pole s pravdivostními hodnotami reprezentovanými jako 1 a 0:

≠ [1 2 3] 2
 
[1 0 1]

Porovnání polí prvek po prvku, výsledkem je opět pole (se shodným tvarem) obsahující výsledky porovnání:

≤ [1 2 3 4] [4 3 2 1]
 
[0 0 1 1]

Tvary polí (shape) ovšem musí být shodné:

≤ [1 2 3 4] [4 3 2 1 0]
 
Error: Shapes [4] and [5] do not match
  at 1:1
1 | ≤ [1 2 3 4] [4 3 2 1 0]

Součet dvou (dvourozměrných) matic:

+ [[1 2][3 4]] [[5 6][7 8]]
 
╭─
╷  6  8
  10 12
        ╯

12. Monadické funkce pro operace nad celými poli

V jazyku Uiua jsou realizovány i funkce, které pracují nad celými poli (nikoli tedy nutně prvek po prvku). Tyto funkce jsou vypsány v následující tabulce:

Symbol Jméno Stručný popis
length vrací délku pole (v první dimenzi)
shape vrací tvar pole (což je taktéž pole)
range generátor pole se sekvencí hodnot
first vrací první prvek pole
reverse otočí celé pole (resp. prvky v něm)
deshape konverze pole o libovolném počtu dimenzí na pole s jednou dimenzí (vektorem)
¤ fix přidá další dimenzi (vlastně uzavře pole do dalšího pole s jediným prvkem)
bits každý prvek pole se převede na pole bitů, které reprezentují jeho hodnotu
transpose rotace pole
rise vytvoří pole s indexy původních prvků tak, aby bylo pole seřaditelné
fall dtto, ale pro opačné řazení
where získání indexů těch prvků, které jsou nenulové (lze tím nahradit programovou smyčku)
classify každému unikátnímu prvku pole přiřadí unikátní index (stejné prvky budou mít shodné indexy)
deduplicate odstraní z pole duplikátní prvky
box vloží pole do takzvaného boxu, který umožní tvorbu de facto heterogenních polí (jako v jazyku K)
unbox opak předchozí operace – vyjme pole z boxu
Poznámka: ve skutečnosti není možné používat skutečná heterogenní pole. Ovšem můžeme použít pole boxů (tedy prvky jsou typu box) a poté již můžeme do boxů vkládat (zabalit?) libovolné hodnoty.

13. Ukázka použití vybraných monadických funkcí

Podívejme se nyní na způsob použití několika vybraných monadických funkcí určených pro zpracování celých polí.

Délka pole – počet prvků v nejvyšší dimenzi:

⧻ [[1 2][3 4]]
 
2

Získání tvaru (shape) pole:

△ [[1 2][3 4]]
 
[2 2]

Vygenerování vektoru obsahujícího sekvenci hodnot od 0 do 9:

⇡ 10
 
[0 1 2 3 4 5 6 7 8 9]

Získání pole pravdivostních hodnot (reprezentovaných nulami a jedničkami) na základě porovnání prvku každého pole s konstantou 4:

≤ 4 ⇡ 10
 
[1 1 1 1 1 0 0 0 0 0]

Otočení pole vytvořeného funkcí range:

⇌ ⇡ 10
 
[9 8 7 6 5 4 3 2 1 0]

Deshape pole – převod na jednorozměrný vektor:

♭ [[1 2][3 4][5 6]]
 
[1 2 3 4 5 6]

Kombinace funkce pro převod pole na jednorozměrný vektor s funkcí pro otočení prvků pole:

⇌♭ [[1 2][3 4][5 6]]
 
[6 5 4 3 2 1]

14. Dyadické funkce pro operace nad celými poli

Další funkce jsou dyadické, přičemž jedním z parametrů je v tomto případě pole (a druhým parametrem může být skalár nebo taktéž pole). Jedná se o následující funkce:

Symbol Jméno Stručný popis
match test, zda jsou pole totožná
couple spojení dvou polí (viz příklady)
join spojení dvou polí (viz příklady)
select výběr většího množství prvků na základě selektorů
pick výběr celých řádků na základě selektorů
reshape změna tvaru pole (přeskupení prvků)
rerank změna počtu dimenzí pole
take přečtení prvních n prvků z pole
drop pole bez prvních n prvků
rotate rotace prvků v poli
keep zachová prvky s indexy, které jsou předány v prvním parametru
find vyhledání prvků z jednoho pole v jiném poli (výsledkem je pole s 0 a 1)
member test, zda je zadaný řádek součástí pole
indexof vyhledání prvku (prvků) s vrácením indexů
Poznámka: některé z těchto funkcí sice na první pohled vypadají nepoužitelně, ovšem jejich kombinací lze realizovat prakticky jakoukoli (rozumnou) operaci nad polem a vyhnout se tak nutnosti explicitního zápisu programové smyčky.

15. Ukázka použití vybraných dyadických funkcí

Opět se podívejme na využití vybraných dyadických funkcí určených pro práci s poli.

Spojení dvou polí funkcí couple:

⊟ [1 2 3 4] [5 6 7 8]
 
╭─
╷ 1 2 3 4
  5 6 7 8
          ╯

Spojení dvou polí funkcí join:

⊂ [1 2 3 4] [5 6 7 8]
 
[1 2 3 4 5 6 7 8]

Výběr prvků ze druhého pole pomocí indexů v poli prvním:

⊏ [1 2 3 1 2 3] [5 6 7 8]
 
[6 7 8 6 7 8]

Změna tvaru pole (reshape):

↯ [2 3] [1 2 3 4 5 6]
 
╭─
╷ 1 2 3
  4 5 6
        ╯

Změna tvaru pole (reshape):

↯ [3 2] [1 2 3 4 5 6]
 
╭─
╷ 1 2
  3 4
  5 6
      ╯

16. Agregační operace

Programovací jazyk Uiua však kromě poměrně rozsáhlé řady primitivních funkcí obsahuje, ostatně podobně jako již popsaný jazyk APL, několik operátorů, pomocí nichž jsou funkce aplikovány nikoli na jeden či dva parametry, ale postupně na celé vektory nebo matice (proto se nazývají agregační operace). Díky operátorům (význam tohoto slova je odlišný od významu, který toto slovo má v jiných programovacích jazycích!) je možné eliminovat velké množství programových smyček a mnohdy tak například několikařádkovou proceduru zapsat pomocí jediného výrazu:

Symbol Jméno Stručný popis
/ reduce postupná aplikace funkce na prvek a akumulátor
fold jako reduce, ovšem se specifikací hodnoty akumulátoru na začátku
\ scan jako reduce, ovšem generuje pole se všemi mezivýsledky
group výběr prvků z pole na základě zadaných indexů (tyto prvky se dostanou na stejný řádek)
table v APL známý pod pojmem outer product (aplikace funkce na všechny možné kombinace prvků dvou polí)

17. Ukázka použití základních agregačních operací

Jedním z nejdůležitějších operátorů jazyka Uiua je operátor /, který jsme si již v jednodušší podobě představili při popisu jazyka APL. Tento operátor, který se zapisuje před identifikátor primitivní či uživatelské funkce, postupně danou funkci aplikuje na první dva prvky argumentu, dále ji aplikuje na průběžný výsledek a třetí prvek atd., do doby, než jsou všechny prvky argumentu zpracovány (jinými slovy – daná dyadická funkce je jakoby zapsána mezi všechny prvky předané datové struktury, počet operací je roven n-1 v případě, že předaný vektor má počet prvků n):

Součet všech prvků pole:

/+ [1 2 3 4]
 
10

Součet hodnot od 1 do 9:

/+ ⇡10
 
45

Výpočet faktoriálu 10:

/× +1 ⇡10
 

Mezery nejsou nezbytné:

/×+1⇡10
 
3628800

Ovšem v některých případech může být lepší použití fold se specifikací prvního prvku:

∧× [1 2 3 4] 10
 
240

Lze zkombinovat s počátečním prvkem, který je polem:

∧× [1 2 3 4] [1 2 10]
 
[24 48 240]

Dalším 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.

Výčet tabulky faktoriálů operátorem scan (opět zapsáno bez mezer):

\×+1⇡10
 
[1 2 6 24 120 720 5040 40320 362880 3628800]

A konečně si ukažme outer product. S využitím tohoto operátoru je možné zkonstruovat velké množství matic se speciálními vlastnostmi; tyto matice mohou mít samozřejmě téměř libovolnou velikost. Jedná se například o jednotkové matice (obsahují jedničky v diagonále, ostatní prvky jsou nulové), trojúhelníkové matice různého typu (jedničky se nachází pod či nad diagonálou, ostatní prvky jsou nulové) atd. Tvorba těchto matic je ilustrována na následujících příkladech, ve kterých se často používají porovnávací (relační) funkce:

⊞= ⇡10 ⇡10
 
╭─
╷ 1 0 0 0 0 0 0 0 0 0
  0 1 0 0 0 0 0 0 0 0
  0 0 1 0 0 0 0 0 0 0
  0 0 0 1 0 0 0 0 0 0
  0 0 0 0 1 0 0 0 0 0
  0 0 0 0 0 1 0 0 0 0
  0 0 0 0 0 0 1 0 0 0
  0 0 0 0 0 0 0 1 0 0
  0 0 0 0 0 0 0 0 1 0
  0 0 0 0 0 0 0 0 0 1
                      ╯
⊞≤ ⇡10 ⇡10
 
╭─
╷ 1 0 0 0 0 0 0 0 0 0
  1 1 0 0 0 0 0 0 0 0
  1 1 1 0 0 0 0 0 0 0
  1 1 1 1 0 0 0 0 0 0
  1 1 1 1 1 0 0 0 0 0
  1 1 1 1 1 1 0 0 0 0
  1 1 1 1 1 1 1 0 0 0
  1 1 1 1 1 1 1 1 0 0
  1 1 1 1 1 1 1 1 1 0
  1 1 1 1 1 1 1 1 1 1
                      ╯

Malá násobilka:

root_podpora

⊞× +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
                                 ╯
Poznámka: reduce, fold, scan a table (nebo outer product) jsou pravděpodobně nejsilnějšími zbraněmi jazyků odvozených od APL.

18. Závěr

Už z předchozího popisu je pravděpodobně zřejmé, že se programovací jazyk Uiua pravděpodobně nedostane do mainstreamu a dokonce je nepravděpodobné, že začne být ve větší míře používán v nice array programmingu (kde se dnes používá především Dyalog APL a poté jazyky K a Q, jenž jsou vyvíjeny společností Kx pro sice poměrně velký, ale dosti specifický sektor). Na druhou stranu je zajímavé, jak lze s využitím zásobníku a operací nad poli vytvořit programovací jazyk, v němž lze velmi snadno realizovat point-free styl (tacit programming). A jen na okraj: poslední dobou vznikly minimálně dva jazyky pro niku array programmingu. Je to právě Uiua, ale taktéž programovací jazyk BQN, který je postaven na myšlenkách APL, ovšem má některé základní koncepty promyšlenější (a možná tak představuje nejlepší cestu do světa array processingu).

19. Předchozí články o rozsáhlém světu „array programmingu“

Programovacími jazyky, které jsou z větší či menší míry odvozeny od programovacího jazyka APL, jsme se již na stránkách Roota zabývali v několika článcích (a samozřejmě i v dnešním článku). Odkazy na tyto články naleznete pod odstavcem:

  1. 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/
  2. Specializované jazyky pro práci s N-dimenzionálními poli: jazyk J
    https://www.root.cz/clanky/spe­cializovane-jazyky-pro-praci-s-n-dimenzionalnimi-poli-jazyk-j/
  3. Programovací jazyky odvozené od APL: BQN a ivy aneb 1~×`1↓↕10
    https://www.root.cz/clanky/pro­gramovaci-jazyky-odvozene-od-apl-bqn-a-ivy-aneb-1–1–10/
  4. Programovací jazyk K: důkaz, že mezi námi žijí mimozemšťané
    https://www.root.cz/clanky/pro­gramovaci-jazyk-k-dukaz-ze-mezi-nami-ziji-mimozemstane/
  5. Programovací jazyk K: důkaz, že mezi námi žijí mimozemšťané (dokončení)
    https://www.root.cz/clanky/pro­gramovaci-jazyk-k-dukaz-ze-mezi-nami-ziji-mimozemstane-dokonceni/
  6. Nial Array Language: další z jazyků inspirovaných APL
    https://www.root.cz/clanky/nial-array-language-dalsi-z-jazyku-inspirovanych-apl/
  7. Programování mainframů: jazyk APL
    https://www.root.cz/clanky/pro­gramovani-mainframu-jazyk-apl/
  8. Programovací jazyk APL: programování bez smyček
    https://www.root.cz/clanky/pro­gramovaci-jazyk-apl-programovani-bez-smycek/
  9. Programovací jazyk APL – dokončení
    https://www.root.cz/clanky/pro­gramovaci-jazyk-apl-dokonceni/
  10. Oslava 55 let od vzniku první implementace jazyka APL
    https://www.root.cz/clanky/oslava-55-let-od-vzniku-prvni-implementace-programovaciho-jazyka-apl/
  11. Jazyk APL, kombinátory, vláčky a point-free style
    https://www.root.cz/clanky/jazyk-apl-kombinatory-vlacky-a-point-free-style/

20. Odkazy na Internetu

  1. Seriál: programovací jazyk Rust
    https://www.root.cz/seria­ly/programovaci-jazyk-rust/
  2. Seriál: programovací jazyk Go
    https://www.root.cz/seria­ly/programovaci-jazyk-go/
  3. Seriál: programovací jazyk Julia
    https://www.root.cz/seria­ly/programovaci-jazyk-julia/
  4. Seriál: programovací jazyk R
    https://www.root.cz/seria­ly/programovaci-jazyk-r/
  5. Uiua: A stack-based array programming language
    https://www.uiua.org/
  6. uiua na GitHubu
    https://github.com/uiua-lang/uiua
  7. Nial: A powerful, interactive array language with support for flexible multiparadigm code
    https://www.nial-array-language.org/
  8. Nial: dokumentace
    https://www.nial-array-language.org/ndocs/
  9. Nial na GitHubu
    https://github.com/niallan­g/Nial_Development
  10. Nial na Rosetta Code
    https://rosettacode.org/wi­ki/Category:Nial
  11. Array language comparisons
    https://github.com/codereport/array-language-comparisons
  12. K language – an introduction
    http://www.math.bas.bg/ban­tchev/place/k.html
  13. K7 Tutorial
    https://cs.nyu.edu/~shasha/pa­pers/tutorial
  14. An Interview with Arthur Whitney, Kx CEO and Developer of Kx Technology, January 4, 2004
    https://web.archive.org/web/20150813004101/htt­p://kx.com/arthur-interview.php
  15. A Shallow Introduction to the K Programming Language
    https://web.archive.org/web/20130801233812/htt­p://www.kuro5hin.org/story/2002/11/14/22741/791
  16. A Conversation with Arthur Whitney
    https://queue.acm.org/deta­il.cfm?id=1531242
  17. Anecdote about Arthur Whitney
    https://news.ycombinator.com/i­tem?id=13590065
  18. K – list of idioms
    https://github.com/kevinlaw­ler/kona/wiki/Idioms
  19. Appendix A. Incunabulum
    http://keiapl.org/rhui/re­member.htm#incunabulum
  20. K code study
    https://docs.google.com/do­cument/d/1W83ME5JecI2hd5hA­UqQ1BVF32wtCel8zxb7WPq-D4f8/edit
  21. K tutorial
    https://github.com/kevinlaw­ler/kona/wiki/Tutorial
  22. K by EXAMPLE
    http://vrabi.web.elte.hu/k/kbyeg.k
  23. BQN: An APL Variant from Marshall Lochbaum (mlochbaum.github.io)
    https://news.ycombinator.com/i­tem?id=24167804
  24. Raytracer in 7 lines in K
    http://www.nsl.com/k/ray/ray.k
  25. Marshall Lochbaum
    https://www.aplwiki.com/wi­ki/Marshall_Lochbaum
  26. BQN
    https://www.aplwiki.com/wiki/BQN
  27. Co-dfns
    https://www.aplwiki.com/wiki/Co-dfns
  28. Array model
    https://www.aplwiki.com/wi­ki/Array_model#Based_arra­y_theory
  29. Fonts for BQN
    https://mlochbaum.github.i­o/BQN/fonts.html
  30. Leading axis theory
    https://www.aplwiki.com/wi­ki/Leading_axis_theory
  31. A based system for general arrays
    https://dl.acm.org/doi/ab­s/10.1145/586656.586663
  32. APL – A Glimpse of Heaven (2006)
    https://news.ycombinator.com/i­tem?id=19325361
  33. APL and J
    https://crypto.stanford.e­du/~blynn/c/apl.html
  34. ivy (dokumentace)
    https://pkg.go.dev/robpike­.io/ivy#section-readme
  35. ivy na GitHubu
    https://github.com/robpike/ivy/
  36. Ivy na APL wiki
    https://aplwiki.com/wiki/Ivy
  37. Implementing a bignum calculator (slajdy)
    https://talks.godoc.org/git­hub.com/robpike/ivy/talks/i­vy.slide#1
  38. Implementing a bignum calculator – Rob Pike – golang-syd November 2014
    https://www.youtube.com/wat­ch?v=PXoG0WX0r_E
  39. Rob Pike na Wikipedii
    https://en.wikipedia.org/wi­ki/Rob_Pike
  40. Rob Pike na cat-v
    http://genius.cat-v.org/rob-pike/
  41. NuVoc
    https://code.jsoftware.com/wiki/NuVoc
  42. J (programming language) [Wikipedia]
    https://en.wikipedia.org/wi­ki/J_%28programming_langu­age%29
  43. J – Absolutely Essential Terms
    https://code.jsoftware.com/wi­ki/Vocabulary/AET
  44. J – Atoms and Arrays
    https://code.jsoftware.com/wi­ki/Vocabulary/Nouns#Atom
  45. Why J
    https://www.jsoftware.com/hel­p/primer/why_j.htm
  46. What is an Array?
    https://vector.org.uk/what-is-an-array/
  47. Comments
    http://www.gavilan.edu/csis/lan­guages/comments.html
  48. Vector (Wolfram MathWorld)
    https://mathworld.wolfram­.com/Vector.html
  49. n-Tuple (Wolfram MathWorld)
    https://mathworld.wolfram.com/n-Tuple.html
  50. n-Vector (Wolfram MathWorld)
    https://mathworld.wolfram.com/n-Vector.html
  51. Matrix (Wolfram MathWorld)
    https://mathworld.wolfram­.com/Matrix.html
  52. Array (Wolfram MathWorld)
    https://mathworld.wolfram­.com/Array.html
  53. ND Arrays (Tensors) in different languages
    https://www.youtube.com/wat­ch?v=WbpbEilgQBc
  54. Extending APL to Infinity\
    https://www.jsoftware.com/pa­pers/eem/infinity.htm
  55. Vector Library (R7RS-compatible)
    https://srfi.schemers.org/srfi-133/srfi-133.html
  56. Vectors (pro Gauche)
    https://practical-scheme.net/gauche/man/gauche-refe/Vectors.html
  57. Kawa: Compiling Scheme to Java
    https://www.mit.edu/afs.new/sip­b/project/kawa/doc/kawa-tour.html
  58. Kawa in Languages shootout
    http://per.bothner.com/blog/2010/Kawa-in-shootout/
  59. Kawa 2.0 Supports Scheme R7RS
    https://developers.slashdot­.org/story/14/12/13/2259225/ka­wa-20-supports-scheme-r7rs/
  60. Kawa — fast scripting on the Java platform
    https://lwn.net/Articles/623349/
  61. Incanter is a Clojure-based, R-like platform for statistical computing and graphics.
    http://incanter.org/
  62. Evolution of incanter (Gource Visualization)
    https://www.youtube.com/wat­ch?v=TVfL5nPELr4
  63. Questions tagged [incanter] (na Stack Overflow)
    https://stackoverflow.com/qu­estions/tagged/incanter?sor­t=active
  64. Data Sorcery with Clojure
    https://data-sorcery.org/contents/
  65. 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
  66. Incanter Cheat Sheet
    http://incanter.org/docs/incanter-cheat-sheet.pdf
  67. 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
  68. BQN: finally, an APL for your flying saucer
    https://mlochbaum.github.io/BQN/
  69. Is BQN stable?
    https://mlochbaum.github.i­o/BQN/commentary/stability­.html
  70. Specification: BQN system-provided values
    https://mlochbaum.github.i­o/BQN/spec/system.html
  71. Tutorial: BQN expressions
    https://mlochbaum.github.i­o/BQN/tutorial/expression­.html
  72. BQN primitives
    https://mlochbaum.github.i­o/BQN/doc/primitive.html
  73. Function trains
    https://mlochbaum.github.i­o/BQN/doc/train.html
  74. BQN community links
    https://mlochbaum.github.i­o/BQN/community/index.html
  75. BQN UV
    https://observablehq.com/@lsh/bqn-uv
  76. APL Wiki
    https://aplwiki.com/wiki/
  77. The Array Cast
    https://www.arraycast.com/e­pisodes/episode-03-what-is-an-array
  78. EnthusiastiCon 2019 – An Introduction to APL
    https://www.youtube.com/wat­ch?v=UltnvW83_CQ
  79. Dyalog
    https://www.dyalog.com/
  80. Try APL!
    https://tryapl.org/
  81. Lisp-Stat Information
    http://homepage.cs.uiowa.e­du/~luke/xls/xlsinfo/
  82. Sample Plots in Incanter
    https://github.com/incanter/in­canter/wiki/Sample-Plots-in-Incanter#line
  83. vectorz-clj
    https://github.com/mikera/vectorz-clj
  84. vectorz – Examples
    https://github.com/mikera/vectorz-clj/wiki/Examples
  85. 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
  86. Vectors and matrices in Julia
    https://fncbook.github.io/v1­.0/linsys/demos/matrices-julia.html
  87. Array vs Matrix in R Programming
    https://www.geeksforgeeks.org/array-vs-matrix-in-r-programming/
  88. Concurrency (computer science)
    https://en.wikipedia.org/wi­ki/Category:Concurrency_%28com­puter_science%29
  89. Koprogram
    https://cs.wikipedia.org/wi­ki/Koprogram
  90. Coroutine
    https://en.wikipedia.org/wi­ki/Coroutine
  91. Coroutines in C
    http://www.chiark.greenen­d.org.uk/~sgtatham/corouti­nes.html
  92. S-expression (Wikipedia)
    https://en.wikipedia.org/wiki/S-expression
  93. S-Expressions (Rosetta Code)
    http://rosettacode.org/wiki/S-Expressions
  94. Introducing Julia/Metaprogramming
    https://en.wikibooks.org/wi­ki/Introducing_Julia/Meta­programming
  95. Tutorial for the Common Lisp Loop Macro
    http://www.ai.sri.com/pkarp/loop.html
  96. 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
  97. Clojure Macro Tutorial (Part II: The Compiler Strikes Back)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-compiler.html
  98. Clojure Macro Tutorial (Part III: Syntax Quote)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-syntax.html
  99. Clojure Macros and Metaprogramming
    http://clojure-doc.org/articles/language/macros.html
  100. Fatvat – Exploring functional programming: Clojure Macros
    http://www.fatvat.co.uk/2009/02/clo­jure-macros.html
  101. CS 2101 Parallel Computing with Julia
    https://www.coursehero.com/fi­le/11508091/CS-2101-Parallel-Computing-with-Julia/
  102. Julia By Example
    https://samuelcolvin.github­.io/JuliaByExample/
  103. Array Programming
    https://en.wikipedia.org/wi­ki/Array_programming
  104. Discovering Array Languages
    http://archive.vector.org­.uk/art10008110
  105. no stinking loops – Kalothi
    http://www.nsl.com/
  106. Vector (obsahuje odkazy na články, knihy a blogy o programovacích jazycích APL, J a K)
    http://www.vector.org.uk/
  107. APL Interpreters
    http://www.vector.org.uk/?a­rea=interpreters
  108. APL_(programming_language
    http://en.wikipedia.org/wi­ki/APL_(programming_langu­age
  109. APL FAQ
    http://www.faqs.org/faqs/apl-faq/
  110. APL FAQ (nejnovější verze)
    http://home.earthlink.net/~swsir­lin/apl.faq.html
  111. A+
    http://www.aplusdev.org/
  112. APLX
    http://www.microapl.co.uk/
  113. FreeAPL
    http://www.pyr.fi/apl/index.htm
  114. Learning J (Roger Stokes)
    http://www.jsoftware.com/hel­p/learning/contents.htm
  115. J: a modern, high-level, general-purpose, high-performance programming language
    http://www.jsoftware.com/
  116. K, Kdb: an APL derivative for Solaris, Linux, Windows
    http://www.kx.com
  117. openAPL (GPL)
    http://sourceforge.net/pro­jects/openapl
  118. Parrot APL (GPL)
    http://www.parrotcode.org/
  119. Learning J (Roger Stokes)
    http://www.jsoftware.com/hel­p/learning/contents.htm
  120. Rosetta Code
    http://rosettacode.org/wiki/Main_Page
  121. Why APL
    http://www.acm.org/sigapl/whyapl.htm
  122. Introducing Julia/Functions
    https://en.wikibooks.org/wi­ki/Introducing_Julia/Functi­ons
  123. Functions (Julia documentation)
    https://docs.julialang.or­g/en/v1/manual/functions/
  124. Evaluate binomial coefficients
    http://rosettacode.org/wi­ki/Evaluate_binomial_coef­ficients
  125. Ackermann function
    http://rosettacode.org/wi­ki/Ackermann_function
  126. Julia (front page)
    http://julialang.org/
  127. Julia – dokumentace
    http://docs.julialang.org/
  128. Julia – repositář na GitHubu
    https://github.com/JuliaLang/julia
  129. Julia (programming language)
    https://en.wikipedia.org/wi­ki/Julia_%28programming_lan­guage%29
  130. IJulia
    https://github.com/JuliaLan­g/IJulia.jl
  131. Introducing Julia
    https://en.wikibooks.org/wi­ki/Introducing_Julia
  132. Julia: the REPL
    https://en.wikibooks.org/wi­ki/Introducing_Julia/The_REPL
  133. Month of Julia
    https://github.com/DataWo­okie/MonthOfJulia
  134. Learn X in Y minutes (where X=Julia)
    https://learnxinyminutes.com/doc­s/julia/
  135. 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
  136. Julia: A Fast Dynamic Language for Technical Computing
    http://karpinski.org/publi­cations/2012/julia-a-fast-dynamic-language
  137. The LLVM Compiler Infrastructure
    http://llvm.org/
  138. Julia: benchmarks
    http://julialang.org/benchmarks/
  139. Type system
    https://en.wikipedia.org/wi­ki/Type_system
  140. Half-precision floating-point format
    https://en.wikipedia.org/wiki/Half-precision_floating-point_format
  141. Dartmouth BASIC
    https://en.wikipedia.org/wi­ki/Dartmouth_BASIC
  142. BASIC 4th Edition
    http://www.bitsavers.org/pdf/dar­tmouth/BASIC_4th_Edition_Jan68­.pdf
  143. VECTRAN
    https://encyclopedia2.the­freedictionary.com/VECTRAN
  144. Comparison of programming languages (array)
    https://en.wikipedia.org/wi­ki/Comparison_of_programmin­g_languages_(array)
  145. BASIC at 50
    https://www.dartmouth.edu/ba­sicfifty/commands.html
  146. BBC Basic – arrays
    http://www.riscos.com/sup­port/developers/bbcbasic/par­t2/arrays.html
  147. Datová struktura
    https://cs.wikipedia.org/wi­ki/Datov%C3%A1_struktura
  148. SIMD instrukce využívané v moderních mikroprocesorech řady x86
    https://www.root.cz/clanky/simd-instrukce-vyuzivane-v-modernich-mikroprocesorech-rady-x86/
  149. 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/
  150. 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/
  151. Inductive type
    https://en.wikipedia.org/wi­ki/Inductive_type
  152. JuliaMono, a font for programming
    https://github.com/cormulli­on/juliamono
  153. It’s arrays all the way down
    https://xpqz.github.io/le­arnapl/array.html
  154. APL vs BQN vs J vs Q vs NumPy vs Julia vs R
    https://www.youtube.com/wat­ch?v=8ynsN4nJxzU
  155. Trainspotting (APL)
    https://xpqz.github.io/le­arnapl/tacit.html
  156. Train Spotting in Dyalog APL – Dyalog Webinar with Richard Park
    https://www.youtube.com/wat­ch?v=Enlh5qwwDuY

Byl pro vás článek přínosný?