@@ -72,6 +72,21 @@ extern {
7272 fn af_cast ( out : MutAfArray , arr : AfArray , aftype : uint8_t ) -> c_int ;
7373
7474 fn af_get_backend_id ( backend : * mut c_int , input : AfArray ) -> c_int ;
75+
76+ fn af_get_device_id ( device : * mut c_int , input : AfArray ) -> c_int ;
77+
78+ fn af_create_strided_array ( arr : MutAfArray , data : * const c_void , offset : DimT ,
79+ ndims : c_uint , dims : * const DimT , strides : * const DimT ,
80+ aftype : uint8_t ) -> c_int ;
81+
82+ fn af_get_strides ( s0 : * mut DimT , s1 : * mut DimT , s2 : * mut DimT , s3 : * mut DimT ,
83+ arr : AfArray ) -> c_int ;
84+
85+ fn af_get_offset ( offset : * mut DimT , arr : AfArray ) -> c_int ;
86+
87+ fn af_is_linear ( result : * mut c_int , arr : AfArray ) -> c_int ;
88+
89+ fn af_is_owner ( result : * mut c_int , arr : AfArray ) -> c_int ;
7590}
7691
7792/// A multidimensional data container
@@ -122,21 +137,68 @@ impl Array {
122137 }
123138 }
124139
140+ /// Constructs a new Array object from strided data
141+ ///
142+ /// This data can possiblly offseted using an additiona `offset` parameter.
143+ ///
144+ /// # Examples
145+ ///
146+ /// ```
147+ /// let values: &[f32] = &[1.0, 2.0, 3.0];
148+ /// let indices = Array::new(Dim4::new(&[3, 1, 1, 1]), values, Aftype::F32).unwrap();
149+ /// ```
150+ #[ allow( unused_mut) ]
151+ pub fn new_strided < T > ( slice : & [ T ] , offset : i64 ,
152+ dims : Dim4 , strides : Dim4 ,
153+ aftype : Aftype ) -> Result < Array , AfError > {
154+ unsafe {
155+ let mut temp: i64 = 0 ;
156+ let err_val = af_create_strided_array ( & mut temp as MutAfArray ,
157+ slice. as_ptr ( ) as * const c_void ,
158+ offset as DimT ,
159+ dims. ndims ( ) as c_uint ,
160+ dims. get ( ) . as_ptr ( ) as * const c_longlong ,
161+ strides. get ( ) . as_ptr ( ) as * const c_longlong ,
162+ aftype as uint8_t ) ;
163+ match err_val {
164+ 0 => Ok ( Array { handle : temp} ) ,
165+ _ => Err ( AfError :: from ( err_val) ) ,
166+ }
167+ }
168+ }
169+
125170 /// Returns the backend of the Array
126171///
127172/// # Return Values
128173///
129174/// Returns an value of type `Backend` which indicates which backend
130175/// was active when Array was created.
131- pub fn get_backend ( & self ) -> Backend {
176+ pub fn get_backend ( & self ) -> Result < Backend , AfError > {
132177 unsafe {
133178 let mut ret_val: i32 = 0 ;
134- af_get_backend_id ( & mut ret_val as * mut c_int , self . handle as AfArray ) ;
135- match ret_val {
136- 1 => Backend :: AF_BACKEND_CPU ,
137- 2 => Backend :: AF_BACKEND_CUDA ,
138- 3 => Backend :: AF_BACKEND_OPENCL ,
139- _ => Backend :: AF_BACKEND_DEFAULT ,
179+ let err_val = af_get_backend_id ( & mut ret_val as * mut c_int , self . handle as AfArray ) ;
180+ match ( err_val, ret_val) {
181+ ( 0 , 1 ) => Ok ( Backend :: CPU ) ,
182+ ( 0 , 2 ) => Ok ( Backend :: CUDA ) ,
183+ ( 0 , 3 ) => Ok ( Backend :: OPENCL ) ,
184+ _ => Err ( AfError :: from ( err_val) ) ,
185+ }
186+ }
187+ }
188+
189+ /// Returns the device identifier(integer) on which the Array was created
190+ ///
191+ /// # Return Values
192+ ///
193+ /// Return the device id on which Array was created.
194+ pub fn get_device_id ( & self ) -> Result < i32 , AfError > {
195+ unsafe {
196+ let mut ret_val: i32 = 0 ;
197+ let err_val = af_get_device_id ( & mut ret_val as * mut c_int , self . handle as AfArray ) ;
198+ match err_val {
199+ 0 => Ok ( ret_val) ,
200+ _ => Err ( AfError :: from ( err_val) ) ,
201+
140202 }
141203 }
142204 }
@@ -172,8 +234,8 @@ impl Array {
172234 let mut ret1: i64 = 0 ;
173235 let mut ret2: i64 = 0 ;
174236 let mut ret3: i64 = 0 ;
175- let err_val = af_get_dims ( & mut ret0 as * mut c_longlong , & mut ret1 as * mut c_longlong ,
176- & mut ret2 as * mut c_longlong , & mut ret3 as * mut c_longlong ,
237+ let err_val = af_get_dims ( & mut ret0 as * mut DimT , & mut ret1 as * mut DimT ,
238+ & mut ret2 as * mut DimT , & mut ret3 as * mut DimT ,
177239 self . handle as AfArray ) ;
178240 match err_val {
179241 0 => Ok ( Dim4 :: new ( & [ ret0 as u64 , ret1 as u64 , ret2 as u64 , ret3 as u64 ] ) ) ,
@@ -182,6 +244,23 @@ impl Array {
182244 }
183245 }
184246
247+ /// Returns the strides of the Array
248+ pub fn strides ( & self ) -> Result < Dim4 , AfError > {
249+ unsafe {
250+ let mut ret0: i64 = 0 ;
251+ let mut ret1: i64 = 0 ;
252+ let mut ret2: i64 = 0 ;
253+ let mut ret3: i64 = 0 ;
254+ let err_val = af_get_strides ( & mut ret0 as * mut DimT , & mut ret1 as * mut DimT ,
255+ & mut ret2 as * mut DimT , & mut ret3 as * mut DimT ,
256+ self . handle as AfArray ) ;
257+ match err_val {
258+ 0 => Ok ( Dim4 :: new ( & [ ret0 as u64 , ret1 as u64 , ret2 as u64 , ret3 as u64 ] ) ) ,
259+ _ => Err ( AfError :: from ( err_val) ) ,
260+ }
261+ }
262+ }
263+
185264 /// Returns the number of dimensions of the Array
186265pub fn numdims ( & self ) -> Result < u32 , AfError > {
187266 unsafe {
@@ -194,6 +273,18 @@ impl Array {
194273 }
195274 }
196275
276+ /// Returns the offset to the pointer from where data begins
277+ pub fn offset ( & self ) -> Result < i64 , AfError > {
278+ unsafe {
279+ let mut ret_val: i64 = 0 ;
280+ let err_val = af_get_offset ( & mut ret_val as * mut DimT , self . handle as AfArray ) ;
281+ match err_val {
282+ 0 => Ok ( ret_val) ,
283+ _ => Err ( AfError :: from ( err_val) ) ,
284+ }
285+ }
286+ }
287+
197288 /// Returns the native FFI handle for Rust object `Array`
198289pub fn get ( & self ) -> i64 {
199290 self . handle
@@ -247,6 +338,8 @@ impl Array {
247338 is_func ! ( is_floating, af_is_floating) ;
248339 is_func ! ( is_integer, af_is_integer) ;
249340 is_func ! ( is_bool, af_is_bool) ;
341+ is_func ! ( is_linear, af_is_linear) ;
342+ is_func ! ( is_owner, af_is_owner) ;
250343
251344 /// Cast the Array data type to `target_type`
252345pub fn cast ( & self , target_type : Aftype ) -> Result < Array , AfError > {
0 commit comments