API for util header from arrayfire

Also, implemented `Copy` trait for `Aftype` and `Dim4` structs.

Author: 9prady9

src/array.rs

@@ -27,6 +27,32 @@ extern {
 
     fn af_get_numdims(result: *mut c_uint, arr: AfArray) -> c_int;
 
+    fn af_is_empty(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_scalar(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_row(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_column(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_vector(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_complex(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_real(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_double(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_single(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_realfloating(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_floating(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_integer(result: *mut c_int, arr: AfArray) -> c_int;
+
+    fn af_is_bool(result: *mut c_int, arr: AfArray) -> c_int;
+
     fn af_get_data_ptr(data: *mut c_void, arr: AfArray) -> c_int;
 
     fn af_eval(arr: AfArray) -> c_int;
@@ -36,34 +62,42 @@ extern {
     fn af_print_array(arr: AfArray) -> c_int;
 }
 
+macro_rules! is_func {
+    ($fn_name: ident, $ffi_fn: ident) => (
+        pub fn $fn_name(&self) -> bool {
+            unsafe {
+                let mut ret_val: i32 = 0;
+                $ffi_fn(&mut ret_val as *mut c_int, self.handle as AfArray);
+                ret_val > 0
+            }
+        }
+    )
+}
+
 impl Array {
     #[allow(unused_mut)]
     pub fn new<T>(dims: Dim4, slice: &[T], aftype: Aftype) -> Array {
         unsafe {
             let mut temp: i64 = 0;
-            af_create_array(&mut temp as *mut c_longlong,
-                            slice.as_ptr() as *const c_void,
-                            dims.ndims() as c_uint,
-                            dims.get().as_ptr() as * const c_longlong,
-                            get_ffi_type(aftype.clone()) as c_int);
-            Array { handle: temp }
+            af_create_array(&mut temp as MutAfArray, slice.as_ptr() as *const c_void,
+                            dims.ndims() as c_uint, dims.get().as_ptr() as * const c_longlong,
+                            get_ffi_type(aftype) as c_int);
+            Array {handle: temp}
         }
     }
 
     pub fn elements(&self) -> i64 {
         unsafe {
             let mut ret_val: i64 = 0;
-            af_get_elements(&mut ret_val as *mut c_longlong,
-                            self.handle as c_longlong);
+            af_get_elements(&mut ret_val as MutAfArray, self.handle as AfArray);
             ret_val
         }
     }
 
     pub fn get_type(&self) -> Aftype {
         unsafe {
             let mut ret_val: i32 = 0;
-            af_get_type(&mut ret_val as *mut c_int,
-                        self.handle as c_longlong);
+            af_get_type(&mut ret_val as *mut c_int, self.handle as AfArray);
             get_af_type(ret_val)
         }
     }
@@ -74,20 +108,17 @@ impl Array {
             let mut ret1: i64 = 0;
             let mut ret2: i64 = 0;
             let mut ret3: i64 = 0;
-            af_get_dims(&mut ret0 as *mut c_longlong,
-                        &mut ret1 as *mut c_longlong,
-                        &mut ret2 as *mut c_longlong,
-                        &mut ret3 as *mut c_longlong,
-                        self.handle as c_longlong);
-            Dim4 { dims: [ret0 as u64, ret1 as u64, ret2 as u64, ret3 as u64] }
+            af_get_dims(&mut ret0 as *mut c_longlong, &mut ret1 as *mut c_longlong,
+                        &mut ret2 as *mut c_longlong, &mut ret3 as *mut c_longlong,
+                        self.handle as AfArray);
+            Dim4 {dims: [ret0 as u64, ret1 as u64, ret2 as u64, ret3 as u64]}
         }
     }
 
     pub fn numdims(&self) -> u32 {
         unsafe {
             let mut ret_val: u32 = 0;
-            af_get_numdims(&mut ret_val as *mut c_uint,
-                           self.handle as c_longlong);
+            af_get_numdims(&mut ret_val as *mut c_uint, self.handle as AfArray);
             ret_val
         }
     }
@@ -98,16 +129,28 @@ impl Array {
 
     pub fn host(&self, data:&mut [f64]) {
         unsafe {
-            af_get_data_ptr(data.as_mut_ptr() as *mut c_void,
-                            self.handle as c_longlong);
+            af_get_data_ptr(data.as_mut_ptr() as *mut c_void, self.handle as AfArray);
         }
     }
 
     pub fn eval(&self) {
         unsafe {
-            af_eval(self.handle as c_longlong);
+            af_eval(self.handle as AfArray);
         }
     }
+
+    is_func!(is_empty, af_is_empty);
+    is_func!(is_scalar, af_is_scalar);
+    is_func!(is_row, af_is_row);
+    is_func!(is_column, af_is_column);
+    is_func!(is_vector, af_is_vector);
+    is_func!(is_complex, af_is_complex);
+    is_func!(is_double, af_is_double);
+    is_func!(is_single, af_is_single);
+    is_func!(is_real, af_is_real);
+    is_func!(is_floating, af_is_floating);
+    is_func!(is_integer, af_is_integer);
+    is_func!(is_bool, af_is_bool);
 }
 
 impl Drop for Array {

src/data/mod.rs

@@ -136,7 +136,7 @@ pub fn range(dims: Dim4, seq_dim: i32, aftype: Aftype) -> Array {
         af_range(&mut temp as MutAfArray,
                  dims.ndims() as c_uint, dims.get().as_ptr() as *const DimT,
                  seq_dim as c_int,
-                 get_ffi_type(aftype.clone()) as c_int);
+                 get_ffi_type(aftype) as c_int);
         Array {handle: temp}
     }
 }
@@ -148,7 +148,7 @@ pub fn iota(dims: Dim4, tdims: Dim4, aftype: Aftype) -> Array {
         af_iota(&mut temp as MutAfArray,
                 dims.ndims() as c_uint, dims.get().as_ptr() as *const DimT,
                 tdims.ndims() as c_uint, tdims.get().as_ptr() as *const DimT,
-                get_ffi_type(aftype.clone()) as c_int);
+                get_ffi_type(aftype) as c_int);
         Array {handle: temp}
     }
 }
@@ -172,7 +172,7 @@ pub fn randu(dims: Dim4, aftype: Aftype) -> Array {
         let mut temp: i64 = 0;
         af_randu(&mut temp as MutAfArray,
                  dims.ndims() as c_uint, dims.get().as_ptr() as *const DimT,
-                 get_ffi_type(aftype.clone()) as c_int);
+                 get_ffi_type(aftype) as c_int);
         Array {handle: temp}
     }
 }
@@ -183,7 +183,7 @@ pub fn randn(dims: Dim4, aftype: Aftype) -> Array {
         let mut temp: i64 = 0;
         af_randn(&mut temp as MutAfArray,
                  dims.ndims() as c_uint, dims.get().as_ptr() as *const DimT,
-                 get_ffi_type(aftype.clone()) as c_int);
+                 get_ffi_type(aftype) as c_int);
         Array {handle: temp}
     }
 }

src/device/mod.rs

@@ -3,11 +3,23 @@ extern crate libc;
 use self::libc::c_int;
 
 extern {
+    fn af_get_version(major: *mut c_int, minor: *mut c_int, patch: *mut c_int) -> c_int;
+
     fn af_info() -> c_int;
 
     fn af_set_device(device: c_int) -> c_int;
 }
 
+pub fn get_version() -> (i32, i32, i32) {
+    unsafe {
+        let mut maj: i32 = 0;
+        let mut min: i32 = 0;
+        let mut pat: i32 = 0;
+        af_get_version(&mut maj as *mut c_int, &mut min as *mut c_int, &mut pat as *mut c_int);
+        (maj, min, pat)
+    }
+}
+
 pub fn info() {
     unsafe { af_info(); }
 }

src/lib.rs

@@ -1,4 +1,4 @@
-#[derive(Clone)]
+#[derive(Copy, Clone)]
 pub enum Aftype {
     F32,
     C32,
@@ -12,7 +12,7 @@ pub enum Aftype {
     U64,
 }
 
-#[derive(Clone)]
+#[derive(Copy, Clone)]
 pub struct Dim4 {
     dims: [u64; 4],
 }
@@ -28,7 +28,7 @@ mod dim4;
 
 mod util;
 
-pub use device::{info, set_device};
+pub use device::{get_version, info, set_device};
 mod device;
 
 //pub use algorithm::{sum_nan, product_nan, sum_nan_all, product_nan_all};

tests/hello_world.rs

@@ -48,6 +48,7 @@ fn main() {
     af::print(&inds);
 
     println!("u8 constant array");
-    let u8_cnst = af::constant(1 as u8, Dim4::new(&[4,4,1,1]));
+    let u8_cnst = af::constant(1 as u8, dims);
     af::print(&u8_cnst);
+    println!("Is u8_cnst array float precision type ? {}", u8_cnst.is_single());
 }