Merge pull request #17 from 9prady9/err_handling

Err handling

Author: umar456

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,16 +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);
+    let a = af::randu(dims, af::Aftype::F32).unwrap();
     af::print(&a);
 
     println!("Element-wise arithmetic");
-    let b: Array = &af::sin(&a) + 1.5;
-    let b2: Array = &af::sin(&a) + &af::cos(&a);
-    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);
@@ -30,31 +31,31 @@ fn main() {
     // af_print(B);
 
     println!("Fourier transform the result");
-    let c: Array = af::fft(&b, 1.0, 0);
+    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);
-    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);
+    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);
-    af::print(&u8_cnst);
-    println!("Is u8_cnst array float precision type ? {}", u8_cnst.is_single());
+    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,33 @@
+extern crate arrayfire as af;
+extern crate time;
+
+use time::PreciseTime;
+use af::Dim4;
+use af::Aftype;
+
+#[allow(unused_must_use)]
+#[allow(unused_variables)]
+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();
+
+    for bench_iter in 0..100 {
+        let pi_val = af::add(&(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", start.to(end) / 100);
+}