arr_rs/core/operations/
meta.rs

1use crate::{
2    core::prelude::*,
3    errors::prelude::*,
4};
5
6/// `ArrayTrait` - Array Metadata functions
7pub trait ArrayMeta<T: Clone> where Self: Sized + Clone {
8
9    /// Obtain the vector containing array elements
10    ///
11    /// # Examples
12    ///
13    /// ```
14    /// use arr_rs::prelude::*;
15    ///
16    /// let arr = Array::new(vec![1,2,3,4], vec![4]).unwrap();
17    /// assert_eq!(vec![1, 2, 3, 4], arr.get_elements().unwrap());
18    /// ```
19    ///
20    /// # Errors
21    ///
22    /// may returns `ArrayError`
23    fn get_elements(&self) -> Result<Vec<T>, ArrayError>;
24
25    /// Obtain the vector containing array shape
26    ///
27    /// # Examples
28    ///
29    /// ```
30    /// use arr_rs::prelude::*;
31    ///
32    /// let arr = Array::new(vec![1,2,3,4], vec![4]).unwrap();
33    /// assert_eq!(vec![4], arr.get_shape().unwrap());
34    /// ```
35    ///
36    /// # Errors
37    ///
38    /// may returns `ArrayError`
39    fn get_shape(&self) -> Result<Vec<usize>, ArrayError>;
40
41    /// Count of array dimensions
42    ///
43    /// # Examples
44    ///
45    /// ```
46    /// use arr_rs::prelude::*;
47    ///
48    /// let arr_1 = Array::new(vec![1,2,3,4], vec![4]).unwrap();
49    /// let ndim_1 = arr_1.ndim().unwrap();
50    /// assert_eq!(1, ndim_1);
51    ///
52    /// let arr_2 = Array::new(vec![1,2,3,4], vec![2, 2]).unwrap();
53    /// let ndim_2 = arr_2.ndim().unwrap();
54    /// assert_eq!(2, ndim_2);
55    /// ```
56    ///
57    /// # Errors
58    ///
59    /// may returns `ArrayError`
60    fn ndim(&self) -> Result<usize, ArrayError>;
61
62    /// Count of array elements
63    ///
64    /// # Examples
65    ///
66    /// ```
67    /// use arr_rs::prelude::*;
68    ///
69    /// let arr = Array::new(vec![1,2,3,4], vec![4]).unwrap();
70    /// let len = arr.len().unwrap();
71    /// assert_eq!(4, len);
72    /// ```
73    ///
74    /// # Errors
75    ///
76    /// may returns `ArrayError`
77    fn len(&self) -> Result<usize, ArrayError>;
78
79    /// Check if array element count equals zero
80    ///
81    /// # Examples
82    ///
83    /// ```
84    /// use arr_rs::prelude::*;
85    ///
86    /// let arr_1 = Array::new(vec![1,2,3,4], vec![4]).unwrap();
87    /// let empty_1 = arr_1.is_empty().unwrap();
88    /// assert_eq!(false, empty_1);
89    ///
90    /// let arr_2: Array<f64> = Array::empty().unwrap();
91    /// let empty_2 = arr_2.is_empty().unwrap();
92    /// assert_eq!(true, empty_2);
93    /// ```
94    ///
95    /// # Errors
96    ///
97    /// may returns `ArrayError`
98    fn is_empty(&self) -> Result<bool, ArrayError>;
99}
100
101impl <T: ArrayElement> ArrayMeta<T> for Array<T> {
102
103    fn get_elements(&self) -> Result<Vec<T>, ArrayError> {
104        Ok(self.elements.clone())
105    }
106
107    fn get_shape(&self) -> Result<Vec<usize>, ArrayError> {
108        Ok(self.shape.clone())
109    }
110
111    fn ndim(&self) -> Result<usize, ArrayError> {
112        Ok(self.shape.len())
113    }
114
115    fn len(&self) -> Result<usize, ArrayError> {
116        Ok(self.elements.len())
117    }
118
119    fn is_empty(&self) -> Result<bool, ArrayError> {
120        Ok(self.len()? == 0)
121    }
122}
123
124impl <T: ArrayElement> ArrayMeta<T> for Result<Array<T>, ArrayError> {
125
126    fn get_elements(&self) -> Result<Vec<T>, ArrayError> {
127        self.clone()?.get_elements()
128    }
129
130    fn get_shape(&self) -> Result<Vec<usize>, ArrayError> {
131        self.clone()?.get_shape()
132    }
133
134    fn ndim(&self) -> Result<usize, ArrayError> {
135        self.clone()?.ndim()
136    }
137
138    fn len(&self) -> Result<usize, ArrayError> {
139        self.clone()?.len()
140    }
141
142    fn is_empty(&self) -> Result<bool, ArrayError> {
143        self.clone()?.is_empty()
144    }
145}