Master Update

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name          = "arrayfire"
 description   = "ArrayFire is a high performance software library for parallel computing with an easy-to-use API. Its array based function set makes parallel programming simple. ArrayFire's multiple backends (CUDA, OpenCL and native CPU) make it platform independent and highly portable. A few lines of code in ArrayFire can replace dozens of lines of parallel computing code, saving you valuable time and lowering development costs. This crate provides Rust bindings for ArrayFire library."
-version       = "3.2.0"
+version       = "3.3.2"
 documentation = "http://arrayfire.github.io/arrayfire-rust/arrayfire/index.html"
 homepage      = "https://github.com/arrayfire/arrayfire"
 repository    = "https://github.com/arrayfire/arrayfire-rust"
@@ -10,14 +10,18 @@ readme        = "./README.md"
 keywords      = ["CUDA", "OpenCL", "ArrayFire", "Compute"]
 license       = "BSD-3-Clause"
 build         = "build.rs"
+exclude = [
+    "arrayfire/*",
+]
 
 [dependencies]
-libc = "0.1.10"
-num  = "0.1.27"
-time = "0.1.32"
+libc = "0.2.11"
+num  = "0.1.32"
+lazy_static = "0.2.1"
 
-[build-dependencies.rustc-serialize]
-rustc-serialize = "0.3.16"
+[build-dependencies]
+rustc-serialize = "0.3.19"
+rustc_version = "0.1.7"
 
 [lib]
 name = "arrayfire"

README.md

@@ -1,6 +1,9 @@
-# Arrayfire Rust Bindings
+# Arrayfire Rust Bindings [![Join the chat at https://gitter.im/arrayfire/arrayfire-rust](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/arrayfire/arrayfire-rust?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+| Linux   | Windows | OSX |
+|:-------:|:-------:|:---:|
+| [![Build Status](http://ci.arrayfire.org/buildStatus/icon?job=arrayfire-wrappers/rust-linux)](http://ci.arrayfire.org/view/All/job/arrayfire-wrappers/job/rust-linux/) | [![Build Status](http://ci.arrayfire.org/buildStatus/icon?job=arrayfire-wrappers/rust-windows)](http://ci.arrayfire.org/view/All/job/arrayfire-wrappers/job/rust-windows/) | [![Build Status](http://ci.arrayfire.org/buildStatus/icon?job=arrayfire-wrappers/rust-osx)](http://ci.arrayfire.org/view/All/job/arrayfire-wrappers/job/rust-osx/) |
 
-[ArrayFire](https://github.com/arrayfire/arrayfire) is a high performance library for parallel computing with an easy-to-use API. It enables users to write scientific computing code that is portable across CUDA, OpenCL and CPU devices. This project provides Rust bindings for the ArrayFire library. The wrapper is currently compliant with ArrayFire 3.2 API.  If you find any bugs, please report them [here](https://github.com/arrayfire/arrayfire-rust/issues).
+[ArrayFire](https://github.com/arrayfire/arrayfire) is a high performance library for parallel computing with an easy-to-use API. It enables users to write scientific computing code that is portable across CUDA, OpenCL and CPU devices. This project provides Rust bindings for the ArrayFire library. The wrapper is currently compliant with ArrayFire 3.3 API.  If you find any bugs, please report them [here](https://github.com/arrayfire/arrayfire-rust/issues).
 
 ## Documentation
 
@@ -13,6 +16,9 @@ You can find the most recent updated documentation [here](http://arrayfire.githu
 
 We recommend using Rust 1.5 and higher.
 
+Rust 1.8 stabilized the traits for compound assignment operations. These are automatically enabled
+based on the rust version you are using.
+
 ## Use from Crates.io [![](http://meritbadge.herokuapp.com/arrayfire)](https://crates.io/crates/arrayfire)
 
 To use the rust bindings for ArrayFire from crates.io, the following requirements are to be met
@@ -24,7 +30,7 @@ first.
 3. Make sure you add the path to library files to your path environment variables.
     - On Linux & OSX: do `export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$AF_PATH/lib`
     - On Windows: Add `%AF_PATH%\lib` to your PATH environment variable.
-4. Add `arrayfire = "3.2.0"` to the dependencies section of your project's Cargo.toml file.
+4. Add `arrayfire = "3.3.2"` to the dependencies section of your project's Cargo.toml file.
 
 Once step (4) is over, you should be able to use ArrayFire in your Rust project. If you find any bugs, please report them [here](https://github.com/arrayfire/arrayfire-rust/issues).
 
@@ -80,20 +86,6 @@ Create a 5-by-3 matrix of random floats on the GPU
 ...
 ```
 
-## Issues
-
-You might see something along the lines of :
-
-```bash
-dyld: Library not loaded: @rpath/libafopencl.3.dylib
-```
-
-You need to add the location of libaf.{dylib, so, dll} to your LD_LIBRARY_PATH.
-
-## Note
-
-This is a work in progress and is not intended for production use.
-
 ## Acknowledgements
 
 The ArrayFire library is written by developers at [ArrayFire](http://arrayfire.com) LLC

build.rs

@@ -1,5 +1,6 @@
 /* -- Lots of reuse from: https://github.com/alexcrichton/git2-rs/blob/master/libgit2-sys/build.rs */
 extern crate rustc_serialize;
+extern crate rustc_version;
 
 use std::env;
 use std::fs;
@@ -450,4 +451,8 @@ fn main() {
     for backend_dir in backend_dirs.iter() {
         println!("cargo:rustc-link-search=native={}", backend_dir);
     }
+    // Directly check a semver version requirment
+    if rustc_version::version_matches(">= 1.8.0") {
+        println!("cargo:rustc-cfg=op_assign");
+    }
 }

examples/helloworld.rs

@@ -1,3 +1,4 @@
+#[macro_use(af_print)]
 extern crate arrayfire as af;
 
 use af::*;
@@ -9,94 +10,76 @@ fn main() {
 
     let num_rows: u64 = 5;
     let num_cols: u64 = 3;
-    let values: &[f32] = &[1.0, 2.0, 3.0];
-    let indices = Array::new(Dim4::new(&[3, 1, 1, 1]), values, Aftype::F32).unwrap();
+    let values: [f32; 3] = [1.0, 2.0, 3.0];
+    let indices = Array::new(&values, Dim4::new(&[3, 1, 1, 1]));
 
     let dims = Dim4::new(&[num_rows, num_cols, 1, 1]);
 
-    println!("Create a 5-by-3 matrix of random floats on the GPU");
-    let a = match randu(dims, Aftype::F32) {
-        Ok(value) => value,
-        Err(error) => panic!("{}", error),
-    };
-    print(&a);
+    let a = randu::<f32>(dims);
+    af_print!("Create a 5-by-3 matrix of random floats on the GPU", a);
 
     println!("Element-wise arithmetic");
-    let  b = sin(&a)
-        .and_then(|x| add(&x, &1.5, false))
-        .unwrap();
+    let  b = add(&sin(&a), &1.5f32, false);
 
-    let b2 = sin(&a).
-        and_then(|x| {
-            cos(&a)
-                .and_then(|y| add(&x, &y, false))
-        })
-        .unwrap();
+    let b2 = add(&sin(&a), &cos(&a), false);
 
     let b3 = ! &a;
-    println!("sin(a) + 1.5 => "); print(&b);
-    println!("sin(a) + cos(a) => "); print(&b2);
-    println!("!a => "); print(&b3);
+    af_print!("sin(a) + 1.5 => ", b);
+    af_print!("sin(a) + cos(a) => ", b2);
+    af_print!("!a => ", b3);
 
-    let test = &a + &b;
-    println!("a + b"); print(&test);
+    let test = a.clone() + b.clone();
+    af_print!("a + b", test);
 
     // Index array using sequences
-    let seqs = &[Seq::new(1.0, 3.0, 1.0), Seq::default()];
-    let sub = index(&a, seqs).unwrap();
-    println!("a(seq(1,3,1), span)"); print(&sub);
+    let seqs = &[Seq::new(1u32, 3, 1), Seq::default()];
+    let sub = index(&a, seqs);
+    af_print!("a(seq(1,3,1), span)", sub);
 
     //Index array using array and sequence
-    let seq4gen = Seq::new(0.0, 2.0, 1.0);
+    let seq4gen = Seq::new(0u32, 2, 1);
 
-    let mut idxrs = match Indexer::new() {
-        Ok(v) => v,
-        Err(e) => panic!("{}",e),
-    };
+    let mut idxrs = Indexer::new();
     idxrs.set_index(&indices, 0, None);
     idxrs.set_index(&seq4gen, 1, Some(false));
 
-    let sub2 = index_gen(&a, idxrs).unwrap();
-    println!("a(indices, seq(0, 2, 1))"); print(&sub2);
+    let sub2 = index_gen(&a, idxrs);
+    af_print!("a(indices, seq(0, 2, 1))", sub2);
 
     // 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");
-    fft(&b, 1.0, 0).map(|x| print(&x));
+    print(&fft(&b, 1.0, 0));
 
     println!("Grab last row & col of the random matrix");
     print(&a);
-    print(&row(&a, num_rows - 1).unwrap());
-    print(&col(&a, num_cols - 1).unwrap());
+    print(&row(&a, num_rows - 1));
+    print(&col(&a, num_cols - 1));
 
-    println!("Set last row to 1's");
     let r_dims = Dim4::new(&[3, 1, 1, 1]);
     let r_input: [f32; 3] = [1.0, 1.0, 1.0];
-    let r = Array::new(r_dims, &r_input, Aftype::F32).unwrap();
-    print(&set_row(&a, &r, num_rows - 1).unwrap());
+    let r = Array::new(&r_input, r_dims);
+    let ur = set_row(&a, &r, num_rows - 1);
+    af_print!("Set last row to 1's", ur);
 
-    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, Aftype::S32).unwrap();
-    print(d);
+    let d = Array::new(&d_input, d_dims);
+    af_print!("Create 2-by-3 matrix from host data", 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");
-    sort_index(&a, 0, true)
-        .map(| x | {
-            print(&x.0);
-            print(&x.1);
-        });
-
-    println!("u8 constant array");
-    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());
+    let x = sort_index(&a, 0, true);
+    print(&x.0);
+    print(&x.1);
+
+    let u8_cnst = &constant(1 as u8, dims);
+    af_print!("u8 constant array", u8_cnst);
+    println!("Is u8_cnst array float precision type ? {}", u8_cnst.is_single());
 }

examples/histogram.rs

@@ -13,34 +13,22 @@ fn main() {
     let assets_dir = PathBuf::from(&env::var("CARGO_MANIFEST_DIR").unwrap())
         .join("arrayfire").join("assets").join("examples").join("images");
 
-    let img_wnd = match Window::new(480, 640, String::from("Input Image")) {
-        Ok(v) => { v.set_position(100, 100).unwrap(); v },
-        Err(e)=> panic!("Window creation failed, exiting: {}", e),
-    };
-
-    let hst_wnd = match Window::new(512, 512, String::from("Input Image Histogram")) {
-        Ok(v) => { v.set_position(600, 100).unwrap(); v },
-        Err(e)=> panic!("Window creation failed, exiting: {}", e),
-    };
-
-    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| constant(255 as f32, x))
-        .and_then(|x| div(&man, &x, false))
-        .unwrap();
+    let img_wnd = Window::new(480, 640, String::from("Input Image"));
+    img_wnd.set_position(100, 100);
+
+    let hst_wnd = Window::new(512, 512, String::from("Input Image Histogram"));
+    hst_wnd.set_position(600, 100);
+
+    let man = load_image(format!("{}/man.jpg", assets_dir.display()), false);
+    let hst = histogram(&man, 256, 0.0, 255.0);
+
+    let disp_img = div(&man, &constant(255 as f32, man.dims()), false);
 
     loop {
         img_wnd.draw_image(&disp_img, None);
         hst_wnd.draw_hist(&hst, 0.0, 255.0, None);
 
-        if img_wnd.is_closed().unwrap() == true { break; }
-        if hst_wnd.is_closed().unwrap() == true { break; }
+        if img_wnd.is_closed() == true { break; }
+        if hst_wnd.is_closed() == true { break; }
     }
 }

examples/pi.rs

@@ -1,7 +1,7 @@
+#[macro_use(mem_info)]
 extern crate arrayfire as af;
-extern crate time;
 
-use time::PreciseTime;
+use std::time::Instant;
 use af::*;
 
 #[allow(unused_must_use)]
@@ -12,21 +12,24 @@ fn main() {
     let samples = 20_000_000;
     let dims = Dim4::new(&[samples, 1, 1, 1]);
 
-    let x = &randu(dims, Aftype::F32).unwrap();
-    let y = &randu(dims, Aftype::F32).unwrap();
+    let x = &randu::<f32>(dims);
+    let y = &randu::<f32>(dims);
 
-    let start = PreciseTime::now();
+    let start = Instant::now();
+
+    mem_info!("Before benchmark");
 
     for bench_iter in 0..100 {
-        let pi_val = add(&mul(x, x, false).unwrap(), &mul(y, y, false).unwrap(), false)
-            .and_then( |z| sqrt(&z) )
-            .and_then( |z| le(&z, &constant(1, dims).unwrap(), false) )
-            .and_then( |z| sum_all(&z) )
-            .map( |z| z.0 * 4.0/(samples as  f64) )
-            .unwrap();
+        let xsqrd = &mul(x, x, false);
+        let ysqrd = &mul(y, y, false);
+        let xplusy = &add(xsqrd, ysqrd, false);
+        let root = &sqrt(xplusy);
+        let cnst = &constant(1, dims);
+        let (real, imag) = sum_all(&le(root, cnst, false)); 
+        let pi_val = real*4.0/(samples as f64);
     }
 
-    let end = PreciseTime::now();
+    println!("Estimated Pi Value in {:?}", start.elapsed());
 
-    println!("Estimated Pi Value in {} seconds", start.to(end) / 100);
+    mem_info!("After benchmark");
 }

examples/snow.rs

@@ -8,17 +8,13 @@ fn main() {
     set_device(0);
     info();
 
-    let wnd = match Window::new(1280, 720, String::from("Snow")) {
-        Ok(v) => v,
-        Err(e)=> panic!("Window creation failed, exiting"),
-    };
+    let wnd = Window::new(1280, 720, String::from("Snow"));
 
     let dims = Dim4::new(&[1280, 720, 3, 1]);
 
     loop {
-        randu(dims, Aftype::F32).as_ref()
-            .map(|arr| wnd.draw_image(arr, None));
+        wnd.draw_image(&randu::<f32>(dims), None);
 
-        if wnd.is_closed().unwrap() == true { break; }
+        if wnd.is_closed() == true { break; }
     }
 }