New functions to modules algorithm, arith, data, device, image

Also includes some documentation additions and corrections

Author: 9prady9

arrayfire

@@ -2,7 +2,7 @@ extern crate libc;
 
 use array::Array;
 use defines::AfError;
-use self::libc::{c_int, c_uint};
+use self::libc::{c_int, c_uint, c_double};
 
 type MutAfArray = *mut self::libc::c_longlong;
 type MutDouble  = *mut self::libc::c_double;
@@ -12,18 +12,18 @@ type AfArray    = self::libc::c_longlong;
 #[allow(dead_code)]
 extern {
     fn af_sum(out: MutAfArray, input: AfArray, dim: c_int) -> c_int;
-    //fn af_sum_nan(out: MutAfArray, input: AfArray, dim: c_int, nanval: c_double) -> c_int;
+    fn af_sum_nan(out: MutAfArray, input: AfArray, dim: c_int, nanval: c_double) -> c_int;
     fn af_product(out: MutAfArray, input: AfArray, dim: c_int) -> c_int;
-    //fn af_product_nan(out: MutAfArray, input: AfArray, dim: c_int, val: c_double) -> c_int;
+    fn af_product_nan(out: MutAfArray, input: AfArray, dim: c_int, val: c_double) -> c_int;
     fn af_min(out: MutAfArray, input: AfArray, dim: c_int) -> c_int;
     fn af_max(out: MutAfArray, input: AfArray, dim: c_int) -> c_int;
     fn af_all_true(out: MutAfArray, input: AfArray, dim: c_int) -> c_int;
     fn af_any_true(out: MutAfArray, input: AfArray, dim: c_int) -> c_int;
     fn af_count(out: MutAfArray, input: AfArray, dim: c_int) -> c_int;
     fn af_sum_all(r: MutDouble, i: MutDouble, input: AfArray) -> c_int;
-    //fn af_sum_nan_all(r: MutDouble, i: MutDouble, input: AfArray, val: c_double) -> c_int;
+    fn af_sum_nan_all(r: MutDouble, i: MutDouble, input: AfArray, val: c_double) -> c_int;
     fn af_product_all(r: MutDouble, i: MutDouble, input: AfArray) -> c_int;
-    //fn af_product_nan_all(r: MutDouble, i: MutDouble, input: AfArray, val: c_double) -> c_int;
+    fn af_product_nan_all(r: MutDouble, i: MutDouble, input: AfArray, val: c_double) -> c_int;
     fn af_min_all(r: MutDouble, i: MutDouble, input: AfArray) -> c_int;
     fn af_max_all(r: MutDouble, i: MutDouble, input: AfArray) -> c_int;
     fn af_all_true_all(r: MutDouble, i: MutDouble, input: AfArray) -> c_int;
@@ -85,31 +85,64 @@ dim_reduce_func_def!(accum, af_accum);
 dim_reduce_func_def!(diff1, af_diff1);
 dim_reduce_func_def!(diff2, af_diff2);
 
-//pub fn sum_nan(input: &Array, dim: i32, nanval: f64) -> Array {
-//    unsafe {
-//        let mut temp: i64 = 0;
-//        af_sum_nan(&mut temp as MutAfArray, input.get() as AfArray,
-//                   dim as c_int, nanval as c_double);
-//        Array {handle: temp}
-//    }
-//}
+/// Reduction operation along specific dimension
+///
+/// Sum values of the `input` Array along `dim` dimension after replacing any `NAN` values in the
+/// Array with `nanval` value.
+///
+/// # Parameters
+///
+/// - `input` is the input Array
+/// - `dim` is reduction dimension
+/// - `nanval` is value with which all the `NAN` values of Array are replaced with
+///
+/// # Return Values
+///
+/// Reduced Array
+pub fn sum_nan(input: &Array, dim: i32, nanval: f64) -> Result<Array, AfError> {
+    unsafe {
+        let mut temp: i64 = 0;
+        let err_val = af_sum_nan(&mut temp as MutAfArray, input.get() as AfArray,
+                                 dim as c_int, nanval as c_double);
+        match err_val {
+            0 => Ok(Array::from(temp)),
+            _ => Err(AfError::from(err_val)),
+        }
+    }
+}
 
-//pub fn product_nan(input: &Array, dim: i32, nanval: f64) -> Array {
-//    unsafe {
-//        let mut temp: i64 = 0;
-//        af_product_nan(&mut temp as MutAfArray, input.get() as AfArray,
-//                       dim as c_int, nanval as c_double);
-//        Array {handle: temp}
-//    }
-//}
+/// Reduction operation along specific dimension
+///
+/// Compute product of the values of the `input` Array along `dim` dimension after replacing any `NAN` values in the Array with `nanval` value.
+///
+/// # Parameters
+///
+/// - `input` is the input Array
+/// - `dim` is reduction dimension
+/// - `nanval` is value with which all the `NAN` values of Array are replaced with
+///
+/// # Return Values
+///
+/// Reduced Array
+pub fn product_nan(input: &Array, dim: i32, nanval: f64) -> Result<Array, AfError> {
+    unsafe {
+        let mut temp: i64 = 0;
+        let err_val = af_product_nan(&mut temp as MutAfArray, input.get() as AfArray,
+                                     dim as c_int, nanval as c_double);
+        match err_val {
+            0 => Ok(Array::from(temp)),
+            _ => Err(AfError::from(err_val)),
+        }
+    }
+}
 
 macro_rules! all_reduce_func_def {
     ($fn_name: ident, $ffi_name: ident) => (
         /// Reduction operation of all values
         ///
         /// # Parameters
         ///
-        /// `input` - Input Array
+        /// - `input` is the input Array
         ///
         /// # Return Values
         ///
@@ -139,25 +172,59 @@ all_reduce_func_def!(all_true_all, af_all_true_all);
 all_reduce_func_def!(any_true_all, af_any_true_all);
 all_reduce_func_def!(count_all, af_count_all);
 
-//pub fn sum_nan_all(input: &Array, val: f64) -> (f64, f64) {
-//    unsafe {
-//        let mut real: f64 = 0.0;
-//        let mut imag: f64 = 0.0;
-//        af_sum_nan_all(&mut real as MutDouble, &mut imag as MutDouble,
-//                       input.get() as AfArray, val as c_double);
-//        (real, imag)
-//    }
-//}
+/// Reduction operation of all values
+///
+/// Sum all the values of the `input` Array after replacing any `NAN` values with `val`.
+///
+/// # Parameters
+///
+/// - `input` is the input Array
+/// - `val` is the val that replaces all `NAN` values of the Array before reduction operation is
+/// performed.
+///
+/// # Return Values
+///
+/// A tuple of reduction result. For non-complex data type Arrays, second value of tuple is
+/// zero.
+pub fn sum_nan_all(input: &Array, val: f64) -> Result<(f64, f64), AfError> {
+    unsafe {
+        let mut real: f64 = 0.0;
+        let mut imag: f64 = 0.0;
+        let err_val = af_sum_nan_all(&mut real as MutDouble, &mut imag as MutDouble,
+                                     input.get() as AfArray, val as c_double);
+        match err_val {
+            0 => Ok((real, imag)),
+            _ => Err(AfError::from(err_val)),
+        }
+    }
+}
 
-//pub fn product_nan_all(input: &Array, val: f64) -> (f64, f64) {
-//    unsafe {
-//        let mut real: f64 = 0.0;
-//        let mut imag: f64 = 0.0;
-//        af_product_nan_all(&mut real as MutDouble, &mut imag as MutDouble,
-//                           input.get() as AfArray, val as c_double);
-//        (real, imag)
-//    }
-//}
+/// Reduction operation of all values
+///
+/// Compute the product of all the values of the `input` Array after replacing any `NAN` values with `val`.
+///
+/// # Parameters
+///
+/// - `input` is the input Array
+/// - `val` is the val that replaces all `NAN` values of the Array before reduction operation is
+/// performed.
+///
+/// # Return Values
+///
+/// A tuple of reduction result. For non-complex data type Arrays, second value of tuple is
+/// zero.
+pub fn product_nan_all(input: &Array, val: f64) -> Result<(f64, f64), AfError> {
+    unsafe {
+        let mut real: f64 = 0.0;
+        let mut imag: f64 = 0.0;
+        let err_val = af_product_nan_all(&mut real as MutDouble, &mut imag as MutDouble,
+                                         input.get() as AfArray, val as c_double);
+        match err_val {
+            0 => Ok((real, imag)),
+            _ => Err(AfError::from(err_val)),
+        }
+    }
+}
 
 macro_rules! dim_ireduce_func_def {
     ($fn_name: ident, $ffi_name: ident) => (

src/algorithm/mod.rs

@@ -77,6 +77,7 @@ extern {
     fn af_atanh(out: MutAfArray, arr: AfArray) -> c_int;
     fn af_pow2(out: MutAfArray, arr: AfArray) -> c_int;
     fn af_exp(out: MutAfArray, arr: AfArray) -> c_int;
+    fn af_sigmoid(out: MutAfArray, arr: AfArray) -> c_int;
     fn af_expm1(out: MutAfArray, arr: AfArray) -> c_int;
     fn af_erf(out: MutAfArray, arr: AfArray) -> c_int;
     fn af_erfc(out: MutAfArray, arr: AfArray) -> c_int;
@@ -150,6 +151,7 @@ unary_func!(acosh, af_acosh);
 unary_func!(atanh, af_atanh);
 unary_func!(pow2, af_pow2);
 unary_func!(exp, af_exp);
+unary_func!(sigmoid, af_sigmoid);
 unary_func!(expm1, af_expm1);
 unary_func!(erf, af_erf);
 unary_func!(erfc, af_erfc);
@@ -237,7 +239,7 @@ macro_rules! overloaded_binary_func {
             }
         }
 
-        pub fn $fn_name<T: Convertable, U: Convertable> (arg1: &T, arg2: &U, batch: bool) -> Result<Array, AfError> {
+        pub fn $fn_name<T, U> (arg1: &T, arg2: &U, batch: bool) -> Result<Array, AfError> where T: Convertable, U: Convertable {
             let lhs = arg1.convert();
             let rhs = arg2.convert();
             match (lhs.is_scalar().unwrap(), rhs.is_scalar().unwrap()) {

src/arith/mod.rs

@@ -62,6 +62,8 @@ extern {
     fn af_release_array(arr: AfArray) -> c_int;
 
     fn af_print_array(arr: AfArray) -> c_int;
+
+    fn af_cast(out: MutAfArray, arr: AfArray, aftype: uint8_t) -> c_int;
 }
 
 /// A multidimensional data container
@@ -218,6 +220,18 @@ impl Array {
     is_func!(is_floating, af_is_floating);
     is_func!(is_integer, af_is_integer);
     is_func!(is_bool, af_is_bool);
+
+    /// Cast the Array data type to `target_type`
+    pub fn cast(&self, target_type: Aftype) -> Result<Array, AfError> {
+        unsafe {
+            let mut temp: i64 = 0;
+            let err_val = af_cast(&mut temp as MutAfArray, self.handle as AfArray, target_type as uint8_t);
+            match err_val {
+                0 => Ok(Array::from(temp)),
+                _ => Err(AfError::from(err_val)),
+            }
+        }
+    }
 }
 
 /// Used for creating Array object from native resource id

src/array.rs

@@ -176,6 +176,18 @@ cnst!(u8  , 7);
 
 /// Create an Array with constant value
 ///
+/// The trait ConstGenerator has been defined internally for the following types:
+///
+/// - i64
+/// - u64
+/// - num::Complex\<f32\>
+/// - num::Complex\<f64\>
+/// - f32
+/// - f64
+/// - i32
+/// - u32
+/// - u8
+///
 /// # Parameters
 ///
 /// - `cnst` is the constant value to be filled in the Array

src/data/mod.rs

@@ -254,3 +254,15 @@ pub enum ColorMap {
     /// Blue hue map
     BLUE    = 6,
 }
+
+/// YCbCr Standards
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub enum YCCStd {
+    /// ITU-R BT.601 (formerly CCIR 601) standard
+    YCC_601 = 601,
+    /// ITU-R BT.709 standard
+    YCC_709 = 709,
+    /// ITU-R BT.2020 standard
+    YCC_2020 = 2020,
+}

src/defines.rs

@@ -8,7 +8,15 @@ extern {
 
     fn af_info() -> c_int;
 
+    fn af_get_device_count(nDevices: *mut c_int) -> c_int;
+
+    fn af_get_dbl_support(available: *mut c_int, device: c_int) -> c_int;
+
     fn af_set_device(device: c_int) -> c_int;
+
+    fn af_get_device(device: *mut c_int) -> c_int;
+
+    fn af_sync(device: c_int) -> c_int;
 }
 
 /// Get ArrayFire Version Number
@@ -30,6 +38,16 @@ pub fn get_version() -> Result<(i32, i32, i32), AfError> {
 }
 
 /// Print library meta-info
+///
+/// # Examples
+///
+/// An example output of `af::info` call looks like below
+///
+/// ```
+/// ArrayFire v3.0.0 (CUDA, 64-bit Mac OSX, build d8d4b38)
+/// Platform: CUDA Toolkit 7, Driver: CUDA Driver Version: 7000
+/// [0] GeForce GT 750M, 2048 MB, CUDA Compute 3.0
+/// ```
 pub fn info() -> Result<(), AfError> {
     unsafe {
         let err_val = af_info();
@@ -40,6 +58,38 @@ pub fn info() -> Result<(), AfError> {
     }
 }
 
+/// Get total number of available devices
+pub fn device_count() -> Result<i32, AfError> {
+    unsafe {
+        let mut temp: i32 = 0;
+        let err_val = af_get_device_count(&mut temp as *mut c_int);
+        match err_val {
+            0 => Ok(temp),
+            _ => Err(AfError::from(err_val)),
+        }
+    }
+}
+
+/// Check if a device has double support
+///
+/// # Parameters
+///
+/// - `device` is the device for which double support is checked for
+///
+/// # Return Values
+///
+/// `True` if `device` device has double support, `False` otherwise.
+pub fn is_double_available(device: i32) -> Result<bool, AfError> {
+    unsafe {
+        let mut temp: i32 = 0;
+        let err_val = af_get_dbl_support(&mut temp as *mut c_int, device as c_int);
+        match err_val {
+            0 => Ok(temp > 0),
+            _ => Err(AfError::from(err_val)),
+        }
+    }
+}
+
 /// Set active device
 ///
 /// # Parameters
@@ -54,3 +104,34 @@ pub fn set_device(device: i32) -> Result<(), AfError> {
         }
     }
 }
+
+/// Get the current active device id
+pub fn get_device() -> Result<i32, AfError> {
+    unsafe {
+        let mut temp: i32 = 0;
+        let err_val = af_get_device(&mut temp as *mut c_int);
+        match err_val {
+            0 => Ok(temp),
+            _ => Err(AfError::from(err_val)),
+        }
+    }
+}
+
+/// Sync all operations on given device
+///
+/// # Parameters
+///
+/// - `device` on which the operations are to be synced
+///
+/// # Return Values
+///
+/// None
+pub fn sync(device: i32) -> Result<(), AfError> {
+    unsafe {
+        let err_val = af_sync(device as c_int);
+        match err_val {
+            0 => Ok(()),
+            _ => Err(AfError::from(err_val)),
+        }
+    }
+}