Added functions for arith operations +, -, /, *

* added pi example
* cleaned up helloworld example

Author: 9prady9

Cargo.lock

@@ -7,6 +7,7 @@ build = "build.rs"
 [dependencies]
 libc = "*"
 num = "*"
+time = "*"
 
 [build-dependencies.rustc-serialize]
 rustc-serialize = "*"
@@ -18,3 +19,7 @@ path = "src/lib.rs"
 [[example]]
 name = "helloworld"
 path = "examples/helloworld.rs"
+
+[[example]]
+name = "pi"
+path = "examples/pi.rs"

Cargo.toml

@@ -1,4 +1,3 @@
-extern crate libc;
 extern crate arrayfire as af;
 
 use af::Dim4;
@@ -8,18 +7,18 @@ fn main() {
     af::set_device(0);
     af::info();
 
-    let dims: Dim4 = Dim4::new(&[5, 3, 1, 1]);
+    let dims = Dim4::new(&[5, 3, 1, 1]);
 
     println!("Create a 5-by-3 matrix of random floats on the GPU");
-    let a: Array = af::randu(dims, af::Aftype::F32).ok().unwrap();
+    let a = af::randu(dims, af::Aftype::F32).unwrap();
     af::print(&a);
 
     println!("Element-wise arithmetic");
-    let sin_res = af::sin(&a).ok().unwrap();
-    let cos_res = af::cos(&a).ok().unwrap();
-    let b: Array = &sin_res + 1.5;
-    let b2: Array = &sin_res + &cos_res;
-    let b3: Array = ! &a;
+    let sin_res = af::sin(&a).unwrap();
+    let cos_res = af::cos(&a).unwrap();
+    let  b = &sin_res + 1.5;
+    let b2 = &sin_res + &cos_res;
+    let b3 = ! &a;
     println!("sin(a) + 1.5 => "); af::print(&b);
     println!("sin(a) + cos(a) => "); af::print(&b2);
     println!("!a => "); af::print(&b3);
@@ -32,31 +31,31 @@ fn main() {
     // af_print(B);
 
     println!("Fourier transform the result");
-    let c: Array = af::fft(&b, 1.0, 0).ok().unwrap();
+    let c = &af::fft(&b, 1.0, 0).unwrap();
     af::print(&c);
 
     // printf("Grab last row\n");
     // array c = C.row(end);
     // af_print(c);
 
     println!("Create 2-by-3 matrix from host data");
-    let d_dims: Dim4 = Dim4::new(&[2, 3, 1, 1]);
+    let d_dims = Dim4::new(&[2, 3, 1, 1]);
     let d_input: [i32; 6] = [1, 2, 3, 4, 5, 6];
-    let d: Array = Array::new(d_dims, &d_input, af::Aftype::S32).ok().unwrap();
-    af::print(&d);
+    let d = &Array::new(d_dims, &d_input, af::Aftype::S32).unwrap();
+    af::print(d);
 
     // printf("Copy last column onto first\n");
     // D.col(0) = D.col(end);
     // af_print(D);
 
     // // Sort A
     println!("Sort A and print sorted array and corresponding indices");
-    let (vals, inds) = af::sort_index(&a, 0, true).ok().unwrap();
+    let (vals, inds) = af::sort_index(&a, 0, true).unwrap();
     af::print(&vals);
     af::print(&inds);
 
     println!("u8 constant array");
-    let u8_cnst = af::constant(1 as u8, dims).ok().unwrap();
-    af::print(&u8_cnst);
-    println!("Is u8_cnst array float precision type ? {}", u8_cnst.is_single().ok().unwrap());
+    let u8_cnst = &af::constant(1 as u8, dims).unwrap();
+    af::print(u8_cnst);
+    println!("Is u8_cnst array float precision type ? {}", u8_cnst.is_single().unwrap());
 }

examples/helloworld.rs

@@ -0,0 +1,28 @@
+extern crate arrayfire as af;
+extern crate time;
+
+use time::PreciseTime;
+use af::Dim4;
+use af::Aftype;
+
+fn main() {
+    af::set_device(0);
+    af::info();
+    let samples = 20_000_000;
+    let dims = Dim4::new(&[samples, 1, 1, 1]);
+
+    let x = &af::randu(dims, Aftype::F32).unwrap();
+    let y = &af::randu(dims, Aftype::F32).unwrap();
+
+    let start = PreciseTime::now();
+    let pi_val = af::add(&(x*x), &(y*y))
+    //let pi_val = af::sqrt(&(x*x) + &(y*y))
+        .and_then( |z| af::sqrt(&z) )
+        .and_then( |z| af::le(&z, &af::constant(1, dims).unwrap()) )
+        .and_then( |z| af::sum_all(&z) )
+        .map( |z| z.0 * 4.0/(samples as  f64) )
+        .unwrap();
+    let end = PreciseTime::now();
+
+    println!("Estimated Pi Value: {} in {} seconds", pi_val, start.to(end));
+}

examples/pi.rs

@@ -180,6 +180,10 @@ macro_rules! binary_func {
     )
 }
 
+binary_func!(add, af_add);
+binary_func!(sub, af_sub);
+binary_func!(mul, af_mul);
+binary_func!(div, af_div);
 binary_func!(lt, af_lt);
 binary_func!(gt, af_gt);
 binary_func!(le, af_le);
@@ -203,13 +207,14 @@ macro_rules! arith_scalar_func {
             type Output = Array;
 
             fn $fn_name(self, rhs: $rust_type) -> Array {
-                let cnst_arr = constant(rhs, self.dims().ok().unwrap()).ok().unwrap();
+                let cnst_arr = constant(rhs, self.dims().unwrap()).unwrap();
                 unsafe {
                     let mut temp: i64 = 0;
-                    $ffi_fn(&mut temp as MutAfArray,
-                            self.get() as AfArray, cnst_arr.get() as AfArray,
-                            0);
-                    Array::from(temp)
+                    match $ffi_fn(&mut temp as MutAfArray, self.get() as AfArray,
+                                  cnst_arr.get() as AfArray, 0) {
+                        0 => Array::from(temp),
+                        _ => panic!("Arithmetic operator on Array failed with error code"),
+                    }
                 }
             }
         }

src/arith/mod.rs

@@ -10,7 +10,7 @@ pub use algorithm::{accum, locate, diff1, diff2, sort, sort_index, sort_by_key};
 pub use algorithm::{set_unique, set_union, set_intersect};
 mod algorithm;
 
-pub use arith::{lt, gt, le, ge, eq, neq, and, or, minof, maxof};
+pub use arith::{add, sub, div, mul, lt, gt, le, ge, eq, neq, and, or, minof, maxof};
 pub use arith::{abs, sign, round, trunc, floor, ceil, modulo};
 pub use arith::{sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh};
 pub use arith::{atan2, cplx2, arg, cplx, real, imag, conjg, hypot};