FEATURE: generalized scan functions

* scan
* scan_by_key

Author: 9prady9

src/algorithm/mod.rs

@@ -1,9 +1,9 @@
 extern crate libc;
 
 use array::Array;
-use defines::AfError;
+use defines::{AfError, BinaryOp};
 use error::HANDLE_ERROR;
-use self::libc::{c_int, c_uint, c_double};
+use self::libc::{c_int, uint8_t, c_uint, c_double};
 
 type MutAfArray = *mut self::libc::c_longlong;
 type MutDouble  = *mut self::libc::c_double;
@@ -46,6 +46,10 @@ extern {
 
     fn af_sort_by_key(out_keys: MutAfArray, out_vals: MutAfArray,
                       in_keys: AfArray, in_vals: AfArray, dim: c_uint, ascend: c_int) -> c_int;
+
+    fn af_scan(out: MutAfArray, inp: AfArray, dim: c_int, op: uint8_t, inclusive: c_int) -> c_int;
+    fn af_scan_by_key(out: MutAfArray, key: AfArray, inp: AfArray,
+                      dim: c_int, op: uint8_t, inclusive: c_int) -> c_int;
 }
 
 macro_rules! dim_reduce_func_def {
@@ -855,3 +859,51 @@ pub fn set_intersect(first: &Array, second: &Array, is_unique: bool) -> Array {
         Array::from(temp)
     }
 }
+
+/// Generalized scan
+///
+/// # Parameters
+///
+/// - `input` is the data on which scan is to be performed
+/// - `dim` is the dimension along which scan operation is to be performed
+/// - `op` takes value of [BinaryOp](./enum.BinaryOp.html) enum indicating
+///    the type of scan operation
+/// - `inclusive` says if inclusive/exclusive scan is to be performed
+///
+/// # Return Values
+///
+/// Output Array of scanned input
+pub fn scan(input: &Array, dim: i32, op: BinaryOp, inclusive: bool) -> Array {
+    unsafe {
+        let mut temp : i64 = 0;
+        let err_val = af_scan(&mut temp as MutAfArray, input.get() as AfArray, dim as c_int,
+                              op as uint8_t, inclusive as c_int);
+        HANDLE_ERROR(AfError::from(err_val));
+        Array::from(temp)
+    }
+}
+
+/// Generalized scan by key
+///
+/// # Parameters
+///
+/// - `key` is the key Array
+/// - `input` is the data on which scan is to be performed
+/// - `dim` is the dimension along which scan operation is to be performed
+/// - `op` takes value of [BinaryOp](./enum.BinaryOp.html) enum indicating
+///    the type of scan operation
+/// - `inclusive` says if inclusive/exclusive scan is to be performed
+///
+/// # Return Values
+///
+/// Output Array of scanned input
+pub fn scan_by_key(key: &Array, input: &Array, dim: i32, op: BinaryOp, inclusive: bool) -> Array {
+    unsafe {
+        let mut temp : i64 = 0;
+        let err_val = af_scan_by_key(&mut temp as MutAfArray,
+                                     key.get() as AfArray, input.get() as AfArray, dim as c_int,
+                                     op as uint8_t, inclusive as c_int);
+        HANDLE_ERROR(AfError::from(err_val));
+        Array::from(temp)
+    }
+}

src/defines.rs

@@ -370,3 +370,13 @@ pub enum SparseFormat {
     /// Coordinate list (row, coloumn, value) tuples.
     COO   = 3
 }
+
+/// Binary operation types for generalized scan functions
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum BinaryOp {
+    ADD = 0,
+    MUL = 1,
+    MIN = 2,
+    MAX = 3
+}

src/lib.rs

@@ -14,7 +14,7 @@ pub use algorithm::{sum, product, min, max, all_true, any_true, count, sum_nan,
 pub use algorithm::{sum_all, product_all, min_all, max_all, sum_nan_all, product_nan_all};
 pub use algorithm::{all_true_all, any_true_all, count_all, imin, imax, imin_all, imax_all};
 pub use algorithm::{accum, locate, diff1, diff2, sort, sort_index, sort_by_key};
-pub use algorithm::{set_unique, set_union, set_intersect};
+pub use algorithm::{set_unique, set_union, set_intersect, scan, scan_by_key};
 mod algorithm;
 
 pub use arith::{add, sub, div, mul, lt, gt, le, ge, eq, neq, and, or, minof, maxof, rem};
@@ -47,7 +47,7 @@ mod device;
 pub use defines::{DType, AfError, Backend, ColorMap, YCCStd, HomographyType};
 pub use defines::{InterpType, BorderType, MatchType, NormType};
 pub use defines::{Connectivity, ConvMode, ConvDomain, ColorSpace, MatProp};
-pub use defines::{MarkerType, MomentType, SparseFormat};
+pub use defines::{MarkerType, MomentType, SparseFormat, BinaryOp};
 mod defines;
 
 pub use dim4::Dim4;

src/util.rs

@@ -2,7 +2,7 @@ extern crate libc;
 extern crate num;
 
 use defines::{AfError, ColorMap, ConvDomain, ConvMode, DType, InterpType, MatProp, MatchType};
-use defines::{SparseFormat};
+use defines::{SparseFormat, BinaryOp};
 use error::HANDLE_ERROR;
 use std::mem;
 use self::num::Complex;
@@ -143,3 +143,10 @@ impl From<i32> for SparseFormat {
         unsafe { mem::transmute(t) }
     }
 }
+
+impl From<i32> for BinaryOp {
+    fn from(t: i32) -> BinaryOp {
+        assert!(BinaryOp::ADD as i32 <= t && t <= BinaryOp::MAX as i32);
+        unsafe { mem::transmute(t) }
+    }
+}