V dnešním článku o jazyku Rust a knihovnách, které pro tento jazyk vznikly, se budeme zabývat knihovnou určenou pro práci s n-rozměrnými poli, samozřejmě včetně běžných vektorů a matic. Tato knihovna se jmenuje příhodně ndarray.
1. Programovací jazyk Rust: knihovna ndarray pro práci s n-rozměrnými poli
2. Základní datový typ, na němž je postavena knihovna ndarray
4. Konverze vektoru na pole, vytvoření pole z iterátoru
5. Konstruktory pro nulové vektory a matice
6. Vytvoření jednotkové matice
7. Vytvoření jednorozměrného pole funkcí Array::range()
8. Vytvoření jednorozměrného pole funkcí Array::linspace()
11. Změna tvaru při konverzi polí
12. Zjištění délky, dimenze, tvaru a kroku mezi jednotlivými prvky pole
13. Repositář s demonstračními příklady
Jednou poměrně rozsáhlou oblastí v IT je zpracování vektorů a matic, protože s těmito strukturami se můžeme setkat v různých disciplínách, například ve finančnictví, pojišťovnictví, statistice, zpracování numerických dat, simulacích atd. Současně se jedná i o velmi zajímavou oblast, neboť právě kvůli co nejrychlejší práci s velkými maticemi byly vytvořeny speciální výpočetní bloky v některých superpočítačích (příkladem mohou být superpočítače Cray). Současné knihovny dokážou v případě potřeby využít jak některé rozšíření instrukčních sad (SIMD instrukce typu SSE, původně též MMX či 3DNow!, viz též úterní článek na toto téma), tak i programovatelné grafické akcelerátory (GPU). Práce s vektory a maticemi byla (a samozřejmě doposud je) podporována v překladačích FORTRANu, které začaly být po vzniku superpočítačů vybaveny algoritmy, které dokázaly převést některé typy programových smyček na „vektorové operace“. Paralelně vznikly i specializované jazyky určené téměř výhradně pro práci s vektory i maticemi – příkladem jsou jazyky APL a J.
V současnosti je používáno relativně velké množství programovacích jazyků popř. specializovaných knihoven orientovaných na práci s vektory a poli. Z komerčních nástrojů je zapotřebí jmenovat především známý MATLAB vydávaný společností MathWorks, nativní práci s maticemi a vektory ovšem velmi dobře podporuje také nástroj GNU Octave (https://gnu.org/software/octave/), jazyk R (http://www.r-project.org/) a také relativně nový jazyk Julia (http://julialang.org/, zajímavé výsledky benchmarků lze najít na adrese http://julialang.org/benchmarks/). Z knihoven jmenujme především oblíbenou a dnes dosti intenzivně využívanou Pythonovskou knihovnu NumPy (http://www.numpy.org/).
V knihovně ndarray se základní datová struktura taktéž jmenuje ndarray. Tato struktura ve své základní podobě reprezentuje pole o prakticky libovolném počtu dimenzí (ostatně „nd“ ve jménu „ndarray“ je odvozeno od N-dimensional). Tato pole se v některých ohledech odlišují od běžných rustovských polí, řezů i vektorů, což poznáme zejména ve chvíli, kdy se pokusíme změnit „tvar“ (shape) pole popř. z pole získat řez (slice). Ve skutečnosti se v knihovně ndarray setkáme i s takzvaným pohledem (view) na pole, který může být určen buď pouze pro čtení či pro čtení i zápis (což mj. v Rustu znamená, že i pole musí být měnitelné neboli mutable – tato podmínka je kontrolovaná překladačem). Samotná datová struktura ndarray je vždy homogenní, tj. může obsahovat pouze prvky stejného typu, ovšem tento typ může být prakticky libovolný. Tím se knihovna ndarray poněkud odlišuje například od známé knihovny Numpy určené pro Python, v níž je typ prvků n-dimenzionálních polí omezen.
Aby bylo možné používat dále popsané funkce, makra a traity, je nutné do projektového souboru (spravovaného systémem Cargo) přidat do sekce [dependencies] řádek s verzí knihovny ndarray. Současná verze je sice teprve 0.9.1, ovšem projekt se dostal do stabilního stavu:
[dependencies] ndarray = "0.9.1"
Dále na začátek všech zdrojových kódů přidejte následujících pět programových řádků, aby došlo k importu funkcí, struktur a traitů ze všech používaných modulů. Povšimněte si, že pro jednorozměrná, dvourozměrná, trojrozměrná atd. pole existují speciální moduly, které někdy nabízí unikátní funkce (eye() atd.):
extern crate ndarray; use ndarray::Array; use ndarray::Array1; use ndarray::Array2; use ndarray::Array3;
Poznámka: podobné moduly existují i pro čtyřrozměrná až pětirozměrná pole:
use ndarray::Array4; use ndarray::Array5; use ndarray::Array6;
Pokud navíc budete potřebovat použít dále popsané makro array!, je nutné toto makro povolit následující deklarací:
#[macro_use(array)]
V této kapitole i kapitolách navazujících si ukážeme, jakými způsoby se n-dimenzionální pole vytváří.
Pole typu ndarray je možné vytvořit několika různými způsoby. Základní funkcí sloužící k převodu z vektoru (ve smyslu programovacího jazyka Rust) na pole typu ndarray je funkce nazvaná jednoduše Array::from_vec(). Výsledkem bude pole, jehož prvky budou mít stejný typ, jako prvky zdrojového vektoru:
let array1 = Array::from_vec(vec![10, 9, 8, 1]); let array2 = Array::from_vec(vec![10.0, 9.0, 8.0, 1.0]);
Obě vzniklá pole vypadají na první pohled stejně, ovšem typy prvků jsou odlišné (celá čísla versus čísla s plovoucí řádovou čárkou):
[10, 9, 8, 1] [10, 9, 8, 1]
K prvkům polí se přistupuje běžným zápisem indexů do hranatých závorek:
println!("{}", array_c[5]);
Samozřejmě je možné pracovat i s vektory řetězců:
let array3 = Array::from_vec(vec!["www", "root", "cz"]);
S výsledkem:
[www, root, cz]
Dalším užitečným konstruktorem jednorozměrných polí je funkce nazvaná Array::from_iter(), která pole vytvoří z předaného iterátoru. Připomeňme si, že v programovacím jazyku Rust je nejjednodušším iterátorem range, který je možné zapsat přímo:
let array = Array::from_iter(0..10);
Výsledek:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Při povolení (stále ještě nestabilní) volby #![feature(inclusive_range_syntax)] lze u iterátoru použít z obou stran uzavřený interval namísto intervalu polouzavřeného. Povšimněte si použití tří teček namísto teček dvou:
let array_b = Array::from_iter(0...10);
Výsledné pole v tomto případě obsahuje i prvek 10:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
I funkce vyššího řádu, mezi něž patří zejména filter() a map(), dokážou zpracovat iterátory, takže lze napsat:
let array_c = Array::from_iter((0...100).filter(|x| (x % 3 == 0))); let array_d = Array::from_iter((0...10).map(|x| (x * 42)));
S očekávaným výsledkem:
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99] [0, 42, 84, 126, 168, 210, 252, 294, 336, 378, 420]
Poznámka: funkcím filter() a map() jsem předal anonymní funkci, ale samozřejmě lze v případě potřeby použít i běžnou funkci odpovídající požadovanému rozhraní.
Poměrně často se setkáme s nutností vytvořit vektor či matici s nulovými prvky. V tomto případě samozřejmě není nutné složitě konstruovat a předávat rustovskévektory, ale lze namísto toho lze využít funkci nazvanou zeros deklarovanou pro jednorozměrná, dvourozměrná … atd. pole, což je rychlejší i méně paměťově náročnější. Pro jednorozměrné pole je nutné jen specifikovat typ prvků a požadovaný tvar (shape) pole, který v tomto případě odpovídá počtu prvků. Tvar se zadává n-ticí, v tomto případě obsahující jedinou hodnotu (10):
let array = Array1::<f32>::zeros((10));
Výsledek – jednorozměrné pole s deseti nulami:
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Vzhledem k tomu, že tvar je u jednorozměrných polí představován jediným celým číslem, lze zápis zkrátit (o dvě závorky okolo desítky):
let array = Array1::<i8>::zeros(10);
Výsledek je v tomto případě naprosto stejný:
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
U dvourozměrných polí se zadává počet řádků následovaný počtem prvků na řádku:
let array = Array2::<f32>::zeros((4, 3));
Výsledek:
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
U trojrozměrného pole musí mít n-tice specifikující tvar tři prvky – počet submatic, počet řádků každé matice a počet sloupců matice (tedy současně počet prvků na řádku):
let array = Array3::<f32>::zeros((4, 3, 2));
Výsledek:
[[[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]]]
Pozor – u dvou a vícerozměrných polí se při indexaci prvků používají dvojité závorky:
println!("{}", array[[0,0]]);
Speciální a často používanou maticí (tedy dvourozměrným polem se shodným počtem řádků a sloupců) je jednotková matice, pro jejíž konstrukci slouží funkce eye(), které se pouze předá velikost matice a navíc se specifikuje typ prvků vytvářeného pole. Výsledkem je pochopitelně pole se stejným počtem řádků i sloupců:
let array = Array2::<f32>::eye(4);
Výsledek:
[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
Použití jiného datového typu:
let array = Array2::<i8>::eye(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]]
Použít lze jakýkoli datový typ implementující traity Zero a One.
Jednorozměrné pole je možné vytvořit i s využitím funkce Array::range(), které se předávají tři parametry: počáteční mez intervalu (který je z levé strany uzavřen, tedy „včetně“), koncová mez intervalu (zde je otevřen, tedy „kromě“) a krok:
let array1 = Array::range(0.0, 10.0, 1.0); let array2 = Array::range(0.0, 10.0, 2.0); let array3 = Array::range(0.0, 10.0, 1.5);
Výsledek je předvídatelný:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [0, 2, 4, 6, 8] [0, 1.5, 3, 4.5, 6, 7.5, 9]
V případě potřeby je možné zvolit i záporný krok; potom se samozřejmě musí prohodit i horní a dolní mez. Povšimněte si, že se stále jedná o polouzavřený interval, tj. pole nebude obsahovat prvek s druhou mezní hodnotou:
let array1 = Array::range(10.0, 0.0, -1.0); let array2 = Array::range(10.0, 0.0, -2.0); let array3 = Array::range(10.0, 0.0, -1.5);
Výsledky:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1] [10, 8, 6, 4, 2] [10, 8.5, 7, 5.5, 4, 2.5, 1]
V některých případech nemusí být použití výše popsané funkce Array::range() tím nejlepším řešením při vytváření vektoru obsahujícího sekvenci číselných hodnot. Typickým příkladem je sekvence generovaná s krokem 0.1, protože hodnotu 0.1 není možné formáty IEEE 754 single ani double přesně reprezentovat. Tím pádem nemusí být z volání funkce Array::range() ihned zřejmé, kolik prvků se nakonec vygeneruje (typická chyba ±1). Pokud je nutné vytvořit vektor s přesným počtem prvků, může se namísto Array::range() hodit spíše funkce Array::linspace(), které se předá počáteční hodnota, koncová hodnota a popř. i počet prvků vektoru. Použití funkce Array::linspace je tak ve skutečnosti velmi jednoduché a přirozené:
let array1 = Array::linspace(1.0, 10.0, 10); let array2 = Array::linspace(1.0, 10.0, 5); let array3 = Array::linspace(1.0, 10.0, 3);
S výsledky:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [1, 3.25, 5.5, 7.75, 10] [1, 5.5, 10]
Hodnoty prvního a posledního prvku můžeme klidně prohodit, na rozdíl od Array::range(), kde se současně musel změnit i krok:
let array1 = Array::linspace(10.0, 1.0, 10); let array2 = Array::linspace(10.0, 1.0, 5); let array3 = Array::linspace(10.0, 1.0, 3);
S výsledky:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1] [10, 7.75, 5.5, 3.25, 1] [10, 5.5, 1]
Při vytváření pole z vektoru (ve smyslu programovacího jazyka Rust) je možné specifikovat tvar výsledného pole. Je ovšem nutné namísto funkce from_vec() použít funkci from_shape_vec(), které se navíc předá n-tice s požadovaným tvarem pole:
let array = Array::from_shape_vec((6), vec![1,2,3,4,5,6]).unwrap();
Tímto konstruktorem získáme jednorozměrné pole se šesti prvky:
[1, 2, 3, 4, 5, 6]
let array_b = Array::from_shape_vec((2,3), vec![1,2,3,4,5,6]).unwrap();
Nyní jsme získali dvourozměrné pole, opět se šesti prvky:
[[1, 2, 3], [4, 5, 6]]
let array_c = Array::from_shape_vec((3,2), vec![1,2,3,4,5,6]).unwrap();
Další pole, tentokrát se třemi řádky a jen dvěma sloupci:
[[1, 2], [3, 4], [5, 6]]
let array_d = Array::from_shape_vec((1,6), vec![1,2,3,4,5,6]).unwrap();
Nyní jsme požadovali pole s jedním řádkem a šesti sloupci – nejedná se však o 1D vektor:
[[1, 2, 3, 4, 5, 6]]
let array_e = Array::from_shape_vec((2,2,2), vec![1,2,3,4,5,6,7,8]).unwrap();
Trojrozměrné pole 2×2×2 prvky:
[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
Další možností, jak vytvořit pole libovolného rozměru (a typu), představuje použití makra array!, je však nutné toto makro povolit následující deklarací:
#[macro_use(array)]
Jakým způsobem se makro array! používá, je patrné z následujícího úryvku zdrojového kódu, v němž se postupně vytvoří jednorozměrné pole, dvourozměrné pole a nakonec i pole trojrozměrné:
let array_a = array![1, 2, 3, 4];
let array_b = array![[1, 2],
[3, 4]];
let array_c = array![[[1, 2], [3, 4]],
[[5, 6], [7, 8]]];
Výsledkem by měla být následující trojice polí:
[1, 2, 3, 4] [[1, 2], [3, 4]] [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
Tvar pole je možné změnit i jeho konverzí, konkrétně funkcí into_shape(). Výsledkem je typ Result, takže musíme zavolat funkci unwrap() pro získání výsledku (důvod je jednoduchý – počet prvků zdrojového a cílového pole musí odpovídat novému tvaru). Nejprve si vytvořme zdrojové jednorozměrné pole – vektor:
let array = Array::from_iter(0..12);
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
Konverzí vytvoříme dvourozměrné pole o třech řádcích a čtyřech sloupcích:
let array_b = Array::from_iter(0..12).into_shape((3,4)).unwrap();
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]
Další konverzí vytvoříme pole a čtyřech řádcích a třech sloupcích, stále s dvanácti prvky:
let array_c = Array::from_iter(0..12).into_shape((4,3)).unwrap();
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
A další varianta, tentokrát s polem o dvanácti řádcích, ovšem s jediným sloupcem:
let array_d = Array::from_iter(0..12).into_shape((12,1)).unwrap();
[[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11]]
Různé varianty trojrozměrných polí, vždy o dvanácti prvcích:
let array_e = Array::from_iter(0..12).into_shape((2,2,3)).unwrap();
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
let array_f = Array::from_iter(0..12).into_shape((2,3,2)).unwrap();
[[[0, 1], [2, 3], [4, 5]], [[6, 7], [8, 9], [10, 11]]]
let array_g = Array::from_iter(0..12).into_shape((3,2,2)).unwrap();
[[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[8, 9], [10, 11]]]
Čtyřrozměrné pole 2×2×2×2 prvky:
let array_h = Array::from_iter(0..16).into_shape((2, 2, 2, 2)).unwrap();
[[[[0, 1], [2, 3]], [[4, 5], [6, 7]]], [[[8, 9], [10, 11]], [[12, 13], [14, 15]]]]
O již existujících polích je možné získat poměrně mnoho užitečných informací – celkový počet prvků, počet dimenzí, počet prvků v osách jednotlivých dimenzí, samozřejmě tvar pole a offsety mezi jednotlivými prvky (opět s ohledem na osy).
Příkladem může být jednorozměrné pole:
let array = Array::from_iter(0..12);
println!("length: {}", array.len());
println!("dimensions: {}", array.ndim());
println!("dimension: {:?}", array.dim());
println!("shape: {:?}", array.shape());
println!("strides: {:?}\n", array.strides());
Počet prvků je zde pochopitelně dvanáct, pole má jedinou dimenzi, počet prvků v ose této dimenze je taktéž dvanáct a offset mezi prvky je roven jedné:
length: 12 dimensions: 1 dimension: 12 shape: [12] strides: [1]
Pro dvourozměrné pole s dvanácti řádky získáme odlišné informace:
let array_b = Array::from_iter(0..12).into_shape((1,12)).unwrap();
println!("length: {}", array_b.len());
println!("dimensions: {}", array_b.ndim());
println!("dimension: {:?}", array_b.dim());
println!("shape: {:?}", array_b.shape());
println!("strides: {:?}\n", array_b.strides());
length: 12 dimensions: 2 dimension: (1, 12) shape: [1, 12] strides: [12, 1]
Další dvourozměrné pole:
let array_c = Array::from_iter(0..12).into_shape((4,3)).unwrap();
println!("length: {}", array_c.len());
println!("dimensions: {}", array_c.ndim());
println!("dimension: {:?}", array_c.dim());
println!("shape: {:?}", array_c.shape());
println!("strides: {:?}\n", array_c.strides());
Povšimněte si zde zejména hodnoty strides, která zhruba říká, že mezi dvěma prvky ve stejném sloupci, ale na jiném řádku, je offset roven třem:
length: 12 dimensions: 2 dimension: (4, 3) shape: [4, 3] strides: [3, 1]
Trojrozměrné pole s dvanácti prvky:
let array_d = Array::from_iter(0..12).into_shape((2,3,2)).unwrap();
println!("length: {}", array_d.len());
println!("dimensions: {}", array_d.ndim());
println!("dimension: {:?}", array_d.dim());
println!("shape: {:?}", array_d.shape());
println!("strides: {:?}\n", array_d.strides());
length: 12 dimensions: 3 dimension: (2, 3, 2) shape: [2, 3, 2] strides: [6, 2, 1]
Čtyřrozměrné pole se šestnácti prvky:
let array_e = Array::from_iter(0..16).into_shape((2,2,2,2)).unwrap();
println!("length: {}", array_e.len());
println!("dimensions: {}", array_e.ndim());
println!("dimension: {:?}", array_e.dim());
println!("shape: {:?}", array_e.shape());
println!("strides: {:?}\n", array_e.strides());
Zde je asi nejlépe patrný význam hodnot strides, když si uvědomíme, jak je toto čtyřrozměrné pole zkonstruováno (stačí si představit hyperkostku, v jejíchž vrcholech jsou uloženy hodnoty prvků):
length: 16 dimensions: 4 dimension: (2, 2, 2, 2) shape: [2, 2, 2, 2] strides: [8, 4, 2, 1]
Všechny dnes popisované demonstrační příklady (Rustovské projekty) byly, ostatně podobně jako ve všech předchozích částech tohoto seriálu, uloženy do Git repositáře dostupného na adrese https://github.com/tisnik/presentations. Demonstrační příklady si můžete v případě potřeby stáhnout i jednotlivě bez nutnosti klonovat celý repositář (ovšem u projektů je lepší mít celý repositář, abyste nemuseli pracně stahovat všechny potřebné soubory):
| Příklad | Adresa |
|---|---|
| První projekt | ndarray-constructors |
| Cargo.toml | https://github.com/tisnik/presentations/blob/master/rust/projects/ndarray-constructors/Cargo.toml |
| main.rs | https://github.com/tisnik/presentations/blob/master/rust/projects/ndarray-constructors/src/main.rs |
| Druhý projekt | ndarray-shape |
| Cargo.toml | https://github.com/tisnik/presentations/blob/master/rust/projects/ndarray-shape/Cargo.toml |
| main.rs | https://github.com/tisnik/presentations/blob/master/rust/projects/ndarray-shape/src/main.rs |
| Třetí projekt | ndarray-info |
| Cargo.toml | https://github.com/tisnik/presentations/blob/master/rust/projects/ndarray-info/Cargo.toml |
| main.rs | https://github.com/tisnik/presentations/blob/master/rust/projects/ndarray-info/src/main.rs |
