Removed Convertable trait for Result<Array, AfError>

Also, made necessary changes to examples

Author: 9prady9

examples/helloworld.rs

@@ -1,38 +1,45 @@
 extern crate arrayfire as af;
 
-use af::Dim4;
-use af::Array;
+use af::*;
 
 #[allow(unused_must_use)]
 fn main() {
-    af::set_device(0);
-    af::info();
+    set_device(0);
+    info();
 
     let dims = Dim4::new(&[5, 3, 1, 1]);
 
     println!("Create a 5-by-3 matrix of random floats on the GPU");
-    let a = af::randu(dims, af::Aftype::F32).unwrap();
-    af::print(&a);
+    let a = randu(dims, Aftype::F32).unwrap();
+    print(&a);
 
     println!("Element-wise arithmetic");
-    let  b = af::add(af::sin(&a), 1.5).unwrap();
-    let b2 = af::add(af::sin(&a), af::cos(&a)).unwrap();
+    let  b = sin(&a)
+        .and_then(|x| add(x, 1.5))
+        .unwrap();
+
+    let b2 = sin(&a).
+        and_then(|x| {
+            cos(&a)
+                .and_then(|y| add(x, y))
+        })
+        .unwrap();
 
     let b3 = ! &a;
-    println!("sin(a) + 1.5 => "); af::print(&b);
-    println!("sin(a) + cos(a) => "); af::print(&b2);
-    println!("!a => "); af::print(&b3);
+    println!("sin(a) + 1.5 => "); print(&b);
+    println!("sin(a) + cos(a) => "); print(&b2);
+    println!("!a => "); print(&b3);
 
     let test = &a + &b;
-    println!("a + b"); af::print(&test);
+    println!("a + b"); print(&test);
 
     // printf("Negate the first three elements of second column\n");
     // B(seq(0, 2), 1) = B(seq(0, 2), 1) * -1;
     // af_print(B);
 
     println!("Fourier transform the result");
-    let c = &af::fft(&b, 1.0, 0).unwrap();
-    af::print(&c);
+    let c = &fft(&b, 1.0, 0).unwrap();
+    print(&c);
 
     // printf("Grab last row\n");
     // array c = C.row(end);
@@ -41,21 +48,21 @@ fn main() {
     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, af::Aftype::S32).unwrap();
-    af::print(d);
+    let d = &Array::new(d_dims, &d_input, Aftype::S32).unwrap();
+    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).unwrap();
-    af::print(&vals);
-    af::print(&inds);
+    let (vals, inds) = sort_index(&a, 0, true).unwrap();
+    print(&vals);
+    print(&inds);
 
     println!("u8 constant array");
-    let u8_cnst = &af::constant(1 as u8, dims).unwrap();
-    af::print(u8_cnst);
+    let u8_cnst = &constant(1 as u8, dims).unwrap();
+    print(u8_cnst);
     println!("Is u8_cnst array float precision type ? {}", u8_cnst.is_single().unwrap());
 }

examples/histogram.rs

@@ -1,14 +1,14 @@
 extern crate arrayfire as af;
 
-use af::Window;
+use af::*;
 use std::env;
 use std::path::PathBuf;
 
 #[allow(unused_variables)]
 #[allow(unused_must_use)]
 fn main() {
-    af::set_device(0);
-    af::info();
+    set_device(0);
+    info();
 
     let assets_dir = PathBuf::from(&env::var("CARGO_MANIFEST_DIR").unwrap())
         .join("arrayfire").join("assets").join("examples").join("images");
@@ -23,17 +23,17 @@ fn main() {
         Err(e)=> panic!("Window creation failed, exiting: {:?}", e),
     };
 
-    let (man, hst) = match af::load_image(format!("{}/man.jpg", assets_dir.display()), false) {
-        Ok(v) => match af::histogram(&v, 256, 0.0, 255.0) {
+    let (man, hst) = match load_image(format!("{}/man.jpg", assets_dir.display()), false) {
+        Ok(v) => match histogram(&v, 256, 0.0, 255.0) {
             Ok(h) => (v, h),
             Err(e)=> panic!("Histogram computation failed, exiting: {:?}", e),
         },
         Err(e)=> panic!("Image loading failed, exiting: {:?}", e),
     };
 
     let disp_img = man.dims()
-        .and_then(|x| af::constant(255 as f32, x))
-        .and_then(|x| af::div(&man, &x))
+        .and_then(|x| constant(255 as f32, x))
+        .and_then(|x| div(man, x))
         .unwrap();
 
     loop {

examples/pi.rs

@@ -2,27 +2,26 @@ extern crate arrayfire as af;
 extern crate time;
 
 use time::PreciseTime;
-use af::Dim4;
-use af::Aftype;
+use af::*;
 
 #[allow(unused_must_use)]
 #[allow(unused_variables)]
 fn main() {
-    af::set_device(0);
-    af::info();
+    set_device(0);
+    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 x = &randu(dims, Aftype::F32).unwrap();
+    let y = &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) )
+        let pi_val = add(x*x, y*y)
+            .and_then( |z| sqrt(&z) )
+            .and_then( |z| le(z, constant(1, dims).unwrap()) )
+            .and_then( |z| sum_all(&z) )
             .map( |z| z.0 * 4.0/(samples as  f64) )
             .unwrap();
     }

examples/snow.rs

@@ -1,13 +1,12 @@
 extern crate arrayfire as af;
 
-use af::Dim4;
-use af::Window;
+use af::*;
 
 #[allow(unused_variables)]
 #[allow(unused_must_use)]
 fn main() {
-    af::set_device(0);
-    af::info();
+    set_device(0);
+    info();
 
     let wnd = match Window::new(1280, 720, String::from("Snow")) {
         Ok(v) => v,
@@ -17,7 +16,7 @@ fn main() {
     let dims = Dim4::new(&[1280, 720, 3, 1]);
 
     loop {
-        af::randu(dims, af::Aftype::F32).as_ref()
+        randu(dims, Aftype::F32).as_ref()
             .map(|arr| wnd.draw_image(arr, None));
 
         if wnd.is_closed().unwrap() == true { break; }

src/arith/mod.rs

@@ -221,12 +221,6 @@ impl Convertable for Array {
     }
 }
 
-impl Convertable for Result<Array, AfError> {
-    fn convert(&self) -> Array {
-        self.clone().unwrap()
-    }
-}
-
 macro_rules! overloaded_binary_func {
     ($fn_name: ident, $help_name: ident, $ffi_name: ident) => (
         fn $help_name(lhs: &Array, rhs: &Array) -> Result<Array, AfError> {