ferray-core 0.2.8

N-dimensional array type and foundational primitives for ferray
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// ferray-core: Type aliases for common array types (REQ-2)

use num_complex::Complex;

use super::arc::ArcArray;
use super::cow::CowArray;
use super::owned::Array;
use super::view::ArrayView;
use super::view_mut::ArrayViewMut;
use crate::dimension::{Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn};

// ---------------------------------------------------------------------------
// Generic aliases by rank
// ---------------------------------------------------------------------------

/// 1-dimensional owned array.
pub type Array1<T> = Array<T, Ix1>;
/// 2-dimensional owned array.
pub type Array2<T> = Array<T, Ix2>;
/// 3-dimensional owned array.
pub type Array3<T> = Array<T, Ix3>;
/// 4-dimensional owned array.
pub type Array4<T> = Array<T, Ix4>;
/// 5-dimensional owned array.
pub type Array5<T> = Array<T, Ix5>;
/// 6-dimensional owned array.
pub type Array6<T> = Array<T, Ix6>;
/// Dynamic-rank owned array.
pub type ArrayD<T> = Array<T, IxDyn>;

// ---------------------------------------------------------------------------
// Generic view aliases by rank
// ---------------------------------------------------------------------------

/// 1-dimensional immutable view.
pub type ArrayView1<'a, T> = ArrayView<'a, T, Ix1>;
/// 2-dimensional immutable view.
pub type ArrayView2<'a, T> = ArrayView<'a, T, Ix2>;
/// 3-dimensional immutable view.
pub type ArrayView3<'a, T> = ArrayView<'a, T, Ix3>;
/// Dynamic-rank immutable view.
pub type ArrayViewD<'a, T> = ArrayView<'a, T, IxDyn>;

/// 1-dimensional mutable view.
pub type ArrayViewMut1<'a, T> = ArrayViewMut<'a, T, Ix1>;
/// 2-dimensional mutable view.
pub type ArrayViewMut2<'a, T> = ArrayViewMut<'a, T, Ix2>;
/// 3-dimensional mutable view.
pub type ArrayViewMut3<'a, T> = ArrayViewMut<'a, T, Ix3>;
/// Dynamic-rank mutable view.
pub type ArrayViewMutD<'a, T> = ArrayViewMut<'a, T, IxDyn>;

// ---------------------------------------------------------------------------
// ArcArray aliases
// ---------------------------------------------------------------------------

/// 1-dimensional reference-counted array.
pub type ArcArray1<T> = ArcArray<T, Ix1>;
/// 2-dimensional reference-counted array.
pub type ArcArray2<T> = ArcArray<T, Ix2>;
/// Dynamic-rank reference-counted array.
pub type ArcArrayD<T> = ArcArray<T, IxDyn>;

// ---------------------------------------------------------------------------
// CowArray aliases
// ---------------------------------------------------------------------------

/// 1-dimensional copy-on-write array.
pub type CowArray1<'a, T> = CowArray<'a, T, Ix1>;
/// 2-dimensional copy-on-write array.
pub type CowArray2<'a, T> = CowArray<'a, T, Ix2>;
/// Dynamic-rank copy-on-write array.
pub type CowArrayD<'a, T> = CowArray<'a, T, IxDyn>;

// ---------------------------------------------------------------------------
// Float-specialized aliases (REQ-2)
// ---------------------------------------------------------------------------

/// `Array1<f32>`
pub type F32Array1 = Array1<f32>;
/// `Array2<f32>`
pub type F32Array2 = Array2<f32>;
/// `Array3<f32>`
pub type F32Array3 = Array3<f32>;
/// `ArrayD<f32>`
pub type F32ArrayD = ArrayD<f32>;

/// `Array1<f64>`
pub type F64Array1 = Array1<f64>;
/// `Array2<f64>`
pub type F64Array2 = Array2<f64>;
/// `Array3<f64>`
pub type F64Array3 = Array3<f64>;
/// `ArrayD<f64>`
pub type F64ArrayD = ArrayD<f64>;

// ---------------------------------------------------------------------------
// Integer-specialized aliases
// ---------------------------------------------------------------------------

/// `Array1<i32>`
pub type I32Array1 = Array1<i32>;
/// `Array2<i32>`
pub type I32Array2 = Array2<i32>;
/// `Array1<i64>`
pub type I64Array1 = Array1<i64>;
/// `Array2<i64>`
pub type I64Array2 = Array2<i64>;

/// `Array1<u8>`
pub type U8Array1 = Array1<u8>;
/// `Array2<u8>`
pub type U8Array2 = Array2<u8>;

// ---------------------------------------------------------------------------
// Complex-specialized aliases
// ---------------------------------------------------------------------------

/// `Array1<Complex<f32>>`
pub type C32Array1 = Array1<Complex<f32>>;
/// `Array2<Complex<f32>>`
pub type C32Array2 = Array2<Complex<f32>>;
/// `Array1<Complex<f64>>`
pub type C64Array1 = Array1<Complex<f64>>;
/// `Array2<Complex<f64>>`
pub type C64Array2 = Array2<Complex<f64>>;

// ---------------------------------------------------------------------------
// Bool aliases
// ---------------------------------------------------------------------------

/// `Array1<bool>`
pub type BoolArray1 = Array1<bool>;
/// `Array2<bool>`
pub type BoolArray2 = Array2<bool>;
/// `ArrayD<bool>`
pub type BoolArrayD = ArrayD<bool>;