Improved data generation API and Array creation API

Defined and implemented a trait `HasAfEnum` for the types
supported by ArrayFire. This trait is used by the Array creation
and data generation functions now making the function API more
terse. Changed the examples to reflect the new modifications.

Author: 9prady9

examples/helloworld.rs

@@ -10,7 +10,7 @@ fn main() {
     let num_rows: u64 = 5;
     let num_cols: u64 = 3;
     let values: &[f32] = &[1.0, 2.0, 3.0];
-    let indices = Array::new(Dim4::new(&[3, 1, 1, 1]), values, Aftype::F32).unwrap();
+    let indices = Array::new(values, Dim4::new(&[3, 1, 1, 1])).unwrap();
 
     let dims = Dim4::new(&[num_rows, num_cols, 1, 1]);
 
@@ -74,13 +74,13 @@ fn main() {
     println!("Set last row to 1's");
     let r_dims = Dim4::new(&[3, 1, 1, 1]);
     let r_input: [f32; 3] = [1.0, 1.0, 1.0];
-    let r = Array::new(r_dims, &r_input, Aftype::F32).unwrap();
+    let r = Array::new(&r_input, r_dims).unwrap();
     print(&set_row(&a, &r, num_rows - 1).unwrap());
 
     println!("Create 2-by-3 matrix from host data");
     let d_dims = Dim4::new(&[2, 3, 1, 1]);
     let d_input: [i32; 6] = [1, 2, 3, 4, 5, 6];
-    let d = &Array::new(d_dims, &d_input, Aftype::S32).unwrap();
+    let d = &Array::new(&d_input, d_dims).unwrap();
     print(d);
 
     // printf("Copy last column onto first\n");

examples/pi.rs

@@ -12,8 +12,8 @@ fn main() {
     let samples = 20_000_000;
     let dims = Dim4::new(&[samples, 1, 1, 1]);
 
-    let x = &randu(dims, Aftype::F32).unwrap();
-    let y = &randu(dims, Aftype::F32).unwrap();
+    let x = &randu::<f32>(dims).unwrap();
+    let y = &randu::<f32>(dims).unwrap();
 
     let start = PreciseTime::now();
 

examples/snow.rs

@@ -16,7 +16,7 @@ fn main() {
     let dims = Dim4::new(&[1280, 720, 3, 1]);
 
     loop {
-        randu(dims, Aftype::F32).as_ref()
+        randu::<f32>(dims).as_ref()
             .map(|arr| wnd.draw_image(arr, None));
 
         if wnd.is_closed().unwrap() == true { break; }

examples/unified.rs

@@ -11,7 +11,7 @@ fn test_backend(){
   let dims = Dim4::new(&[num_rows, num_cols, 1, 1]);
 
   println!("Create a 10-by-10 matrix of random floats on the compute device");
-  let a = match randu(dims, Aftype::F32) {
+  let a = match randu::<f32>(dims) {
     Ok(value) => value,
     Err(error) => panic!("{}", error),
   };

src/array.rs

@@ -2,6 +2,7 @@ extern crate libc;
 
 use dim4::Dim4;
 use defines::{AfError, Aftype, Backend};
+use util::HasAfEnum;
 use self::libc::{uint8_t, c_void, c_int, c_uint, c_longlong};
 
 type MutAfArray = *mut self::libc::c_longlong;
@@ -119,11 +120,12 @@ impl Array {
     ///
     /// ```
     /// let values: &[f32] = &[1.0, 2.0, 3.0];
-    /// let indices = Array::new(Dim4::new(&[3, 1, 1, 1]), values, Aftype::F32).unwrap();
+    /// let indices = Array::new(values, Dim4::new(&[3, 1, 1, 1])).unwrap();
     /// ```
     #[allow(unused_mut)]
-    pub fn new<T>(dims: Dim4, slice: &[T], aftype: Aftype) -> Result<Array, AfError> {
+    pub fn new<T: HasAfEnum>(slice: &[T], dims: Dim4) -> Result<Array, AfError> {
         unsafe {
+            let aftype = T::get_af_dtype();
             let mut temp: i64 = 0;
             let err_val = af_create_array(&mut temp as MutAfArray,
                                           slice.as_ptr() as *const c_void,
@@ -140,18 +142,11 @@ impl Array {
     /// Constructs a new Array object from strided data
     ///
     /// This data can possiblly offseted using an additiona `offset` parameter.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let values: &[f32] = &[1.0, 2.0, 3.0];
-    /// let indices = Array::new(Dim4::new(&[3, 1, 1, 1]), values, Aftype::F32).unwrap();
-    /// ```
     #[allow(unused_mut)]
-    pub fn new_strided<T>(slice: &[T], offset: i64,
-                          dims: Dim4, strides: Dim4,
-                          aftype: Aftype) -> Result<Array, AfError> {
+    pub fn new_strided<T: HasAfEnum>(slice: &[T], offset: i64,
+                                     dims: Dim4, strides: Dim4) -> Result<Array, AfError> {
         unsafe {
+            let aftype = T::get_af_dtype();
             let mut temp: i64 = 0;
             let err_val = af_create_strided_array(&mut temp as MutAfArray,
                                                   slice.as_ptr() as *const c_void,
@@ -342,10 +337,11 @@ impl Array {
     is_func!(is_owner, af_is_owner);
 
     /// Cast the Array data type to `target_type`
-    pub fn cast(&self, target_type: Aftype) -> Result<Array, AfError> {
+    pub fn cast<T: HasAfEnum>(&self) -> Result<Array, AfError> {
         unsafe {
+            let trgt_type = T::get_af_dtype();
             let mut temp: i64 = 0;
-            let err_val = af_cast(&mut temp as MutAfArray, self.handle as AfArray, target_type as uint8_t);
+            let err_val = af_cast(&mut temp as MutAfArray, self.handle as AfArray, trgt_type as uint8_t);
             match err_val {
                 0 => Ok(Array::from(temp)),
                 _ => Err(AfError::from(err_val)),
@@ -394,7 +390,7 @@ impl Drop for Array {
 ///
 ///  ```
 /// println!("Create a 5-by-3 matrix of random floats on the GPU");
-/// let a = match randu(dims, Aftype::F32) {
+/// let a = match randu::<f32>(dims) {
 ///     Ok(value) => value,
 ///     Err(error) => panic!("{}", error),
 /// };

src/data/mod.rs

@@ -4,10 +4,9 @@ extern crate num;
 use array::Array;
 use dim4::Dim4;
 use defines::AfError;
-use defines::Aftype;
 use self::libc::{uint8_t, c_int, c_uint, c_double};
 use self::num::Complex;
-
+use util::HasAfEnum;
 use std::vec::Vec;
 
 type MutAfArray = *mut self::libc::c_longlong;
@@ -220,15 +219,15 @@ pub fn constant<T : ConstGenerator>(cnst: T, dims: Dim4) -> Result<Array, AfErro
 /// - `dims` is the size of Array
 /// - `seq_dim` is the dimension along which range values are populated, all values along other
 /// dimensions are just repeated
-/// - `aftype` is the type of the Array.
 ///
 /// # Return Values
 /// Array
 #[allow(unused_mut)]
-pub fn range(dims: Dim4, seq_dim: i32, aftype: Aftype) -> Result<Array, AfError> {
+pub fn range<T: HasAfEnum>(dims: Dim4, seq_dim: i32) -> Result<Array, AfError> {
     unsafe {
+        let aftype = T::get_af_dtype();
         let mut temp: i64 = 0;
-        let err_val =af_range(&mut temp as MutAfArray,
+        let err_val = af_range(&mut temp as MutAfArray,
                               dims.ndims() as c_uint, dims.get().as_ptr() as *const DimT,
                               seq_dim as c_int, aftype as uint8_t);
         match err_val {
@@ -246,14 +245,14 @@ pub fn range(dims: Dim4, seq_dim: i32, aftype: Aftype) -> Result<Array, AfError>
 ///
 /// - `dims` is the dimensions of the sequence to be generated
 /// - `tdims` is the number of repitions of the unit dimensions
-/// - `aftype` is the type of Array to generate
 ///
 /// # Return Values
 ///
 /// Array
 #[allow(unused_mut)]
-pub fn iota(dims: Dim4, tdims: Dim4, aftype: Aftype) -> Result<Array, AfError> {
+pub fn iota<T: HasAfEnum>(dims: Dim4, tdims: Dim4) -> Result<Array, AfError> {
     unsafe {
+        let aftype = T::get_af_dtype();
         let mut temp: i64 = 0;
         let err_val =af_iota(&mut temp as MutAfArray,
                              dims.ndims() as c_uint, dims.get().as_ptr() as *const DimT,
@@ -293,8 +292,9 @@ pub fn get_seed() -> Result<u64, AfError> {
 macro_rules! data_gen_def {
     ($fn_name:ident, $ffi_name: ident) => (
         #[allow(unused_mut)]
-        pub fn $fn_name(dims: Dim4, aftype: Aftype) -> Result<Array, AfError> {
+        pub fn $fn_name<T: HasAfEnum>(dims: Dim4) -> Result<Array, AfError> {
             unsafe {
+                let aftype = T::get_af_dtype();
                 let mut temp: i64 = 0;
                 let err_val = $ffi_name(&mut temp as MutAfArray,
                                         dims.ndims() as c_uint, dims.get().as_ptr() as *const DimT,
@@ -412,9 +412,9 @@ pub fn join_many(dim: i32, inputs: Vec<&Array>) -> Result<Array, AfError> {
 /// ```
 /// # #[macro_use] extern crate arrayfire;
 /// # fn main() {
-/// let a = randu(Dim4::new(&[5, 3, 1, 1]), Aftype::F32).unwrap();
-/// let b = randu(Dim4::new(&[5, 3, 1, 1]), Aftype::F32).unwrap();
-/// let c = randu(Dim4::new(&[5, 3, 1, 1]), Aftype::F32).unwrap();
+/// let a = randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
+/// let b = randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
+/// let c = randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
 /// let d = join_many![2, a, b, c];
 /// # }
 /// ```

src/defines.rs

@@ -49,6 +49,7 @@ pub enum AfError {
     ERR_UNKNOWN        = 999
 }
 
+/// Compute/Acceleration Backend
 #[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum Backend {

src/image/mod.rs

@@ -2,12 +2,12 @@ extern crate libc;
 
 use array::Array;
 use defines::AfError;
-use defines::Aftype;
 use defines::BorderType;
 use defines::ColorSpace;
 use defines::Connectivity;
 use defines::InterpType;
 use defines::YCCStd;
+use util::HasAfEnum;
 use self::libc::{uint8_t, c_uint, c_int, c_float, c_double};
 
 type MutAfArray = *mut self::libc::c_longlong;
@@ -812,14 +812,14 @@ pub fn color_space(input: &Array,
 ///
 /// - `input` is the input image
 /// - `conn` can take one of the values of [Connectivity](./enum.Connectivity.html)
-/// - `aftype` can take one of the values of [Aftype](./enum.Aftype.html)
 ///
 /// # Return Values
 ///
 /// Array with labels indicating different regions
 #[allow(unused_mut)]
-pub fn regions(input: &Array, conn: Connectivity, aftype: Aftype) -> Result<Array, AfError> {
+pub fn regions<T: HasAfEnum>(input: &Array, conn: Connectivity) -> Result<Array, AfError> {
     unsafe {
+        let aftype = T::get_af_dtype();
         let mut temp: i64 = 0;
         let err_val = af_regions(&mut temp as MutAfArray, input.get() as AfArray,
                                  conn as uint8_t, aftype as uint8_t);

src/index.rs

@@ -125,7 +125,7 @@ impl Drop for Indexer {
 /// # Examples
 ///
 /// ```
-/// let a = randu(dims, Aftype::F32).unwrap();
+/// let a = randu::<f32>(dims).unwrap();
 /// let seqs = &[Seq::new(1.0, 3.0, 1.0), Seq::default()];
 /// let sub  = index(&a, seqs).unwrap();
 /// println!("a(seq(1, 3, 1), span)");
@@ -153,7 +153,7 @@ pub fn index<T: Copy>(input: &Array, seqs: &[Seq<T>]) -> Result<Array, AfError>
 /// # Examples
 ///
 /// ```
-/// let a = randu(dims, Aftype::F32).unwrap();
+/// let a = randu::<f32>(dims).unwrap();
 /// println!("Grab last row of the random matrix");
 /// print(&a);
 /// print(&row(&a, num_rows - 1).unwrap());
@@ -189,7 +189,7 @@ pub fn set_rows(input: &Array, new_rows: &Array, first: u64, last: u64) -> Resul
 /// # Examples
 ///
 /// ```
-/// let a = randu(dims, Aftype::F32).unwrap();
+/// let a = randu::<f32>(dims).unwrap();
 /// println!("Grab last col of the random matrix");
 /// print(&a);
 /// print(&row(&a, num_cols - 1).unwrap());
@@ -328,9 +328,9 @@ pub fn assign_seq<T: Copy>(lhs: &Array, seqs: &[Seq<T>], rhs: &Array) -> Result<
 ///
 /// ```
 /// let values: &[f32] = &[1.0, 2.0, 3.0];
-/// let indices = Array::new(Dim4::new(&[3, 1, 1, 1]), values, Aftype::F32).unwrap();
+/// let indices = Array::new(values, Dim4::new(&[3, 1, 1, 1])).unwrap();
 /// let seq4gen = Seq::new(0.0, 2.0, 1.0);
-/// let a = randu(Dim4::new(&[5, 3, 1, 1]), Aftype::F32).unwrap();
+/// let a = randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
 /// // [5 3 1 1]
 /// //     0.0000     0.2190     0.3835
 /// //     0.1315     0.0470     0.5194
@@ -371,9 +371,9 @@ pub fn index_gen(input: &Array, indices: Indexer) -> Result<Array, AfError> {
 ///
 /// ```
 /// let values: &[f32] = &[1.0, 2.0, 3.0];
-/// let indices = Array::new(Dim4::new(&[3, 1, 1, 1]), values, Aftype::F32).unwrap();
+/// let indices = Array::new(values, Dim4::new(&[3, 1, 1, 1])).unwrap();
 /// let seq4gen = Seq::new(0.0, 2.0, 1.0);
-/// let a = randu(Dim4::new(&[5, 3, 1, 1]), Aftype::F32).unwrap();
+/// let a = randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
 /// // [5 3 1 1]
 /// //     0.0000     0.2190     0.3835
 /// //     0.1315     0.0470     0.5194

src/lib.rs

@@ -91,6 +91,7 @@ pub use statistics::{var_all, mean_all, stdev_all, median_all};
 pub use statistics::{mean_all_weighted, var_all_weighted};
 mod statistics;
 
+pub use util::{HasAfEnum};
 mod util;
 
 pub use vision::Features;