Change Array to generic to support type checks

All functions in all modules have been changed to
accept the new generic Array objects.

* Fixed typos in ifft2 and iff3 documentation
* Fixed/Added `mut` qualifier for inplace fft transform arguments
* Minor modifications to examples to use generic Array types

Author: 9prady9

examples/acoustic_wave.rs

@@ -6,24 +6,24 @@ use std::f64::consts::*;
 fn main() {
     set_device(0);
     info();
-
     acoustic_wave_simulation();
 }
 
-fn normalise(a: &Array) -> Array {
+fn normalise(a: &Array<f32>) -> Array<f32> {
     (a/(max_all(&abs(a)).0 as f32 * 2.0f32)) + 0.5f32
 }
+
 fn acoustic_wave_simulation() {
     // Speed of sound
-    let c = 0.1;
+    let c  :f32 = 0.1;
     // Distance step
-    let dx = 0.5;
+    let dx :f32 = 0.5;
     // Time step
-    let dt = 1.0;
+    let dt :f32 = 1.0;
 
     // Grid size.
-    let nx = 1500;
-    let ny = 1500;
+    let nx : u64 = 1500;
+    let ny : u64 = 1500;
 
     // Grid dimensions.
     let dims = Dim4::new(&[nx, ny, 1, 1]);
@@ -34,26 +34,27 @@ fn acoustic_wave_simulation() {
     let mut p_dot = p.clone();
 
     // Laplacian (Del^2) convolution kernel.
-    let laplacian_values = [0.0f32, 1.0, 0.0,
-                        1.0, -4.0, 1.0,
-                        0.0, 1.0, 0.0];
+    let laplacian_values: [f32; 9] = [0.0,  1.0, 0.0,
+                                      1.0, -4.0, 1.0,
+                                      0.0,  1.0, 0.0];
     let laplacian_kernel = Array::new(&laplacian_values, Dim4::new(&[3, 3, 1, 1])) / (dx * dx);
 
     // Create a window to show the waves.
     let mut win = Window::new(1000, 1000, "Waves".to_string());
 
     // Hann windowed pulse.
-    let pulse_time = 100.0f64;
-    let centre_freq = 0.05;
+    let pulse_time :f32  = 100.0;
+    let centre_freq :f32 = 0.05;
+    let twopi  = PI as f32 * 2.0;
 
     // Number of samples in pulse.
     let pulse_n = (pulse_time/dt).floor() as u64;
 
-    let i = range::<f32>(Dim4::new(&[pulse_n, 1, 1, 1]), 0);
-    let t = i.clone() * dt;
-    let hamming_window = cos(&(i * (2.0 * PI / pulse_n as f64))) * -0.46 + 0.54;
-    let wave = sin(&(&t * centre_freq * 2.0 * PI));
-    let pulse = wave * hamming_window;
+    let i       = range::<f32>(Dim4::new(&[pulse_n, 1, 1, 1]), 0);
+    let t       = i.clone() * dt;
+    let hmg_wnd = cos(&(i * (twopi / pulse_n as f32))) * -0.46f32 + 0.54f32;
+    let wave    = sin(&(&t * centre_freq * twopi));
+    let pulse   = wave * hmg_wnd;
 
     // Iteration count.
     let mut it = 0;

examples/helloworld.rs

@@ -1,5 +1,6 @@
 #[macro_use(af_print)]
 extern crate arrayfire as af;
+extern crate num;
 
 use af::*;
 
@@ -18,24 +19,29 @@ fn main() {
     let values: [f32; 3] = [1.0, 2.0, 3.0];
     let indices = Array::new(&values, Dim4::new(&[3, 1, 1, 1]));
 
+    af_print!("Indices ", indices);
+
     let dims = Dim4::new(&[num_rows, num_cols, 1, 1]);
 
     let a = randu::<f32>(dims);
-    af_print!("Create a 5-by-3 matrix of random floats on the GPU", a);
+    af_print!("Create a 5-by-3 float   matrix on the GPU", a);
 
     println!("Element-wise arithmetic");
     let  b = add(&sin(&a), &1.5f32, false);
 
     let b2 = add(&sin(&a), &cos(&a), false);
 
     let b3 = ! &a;
-    af_print!("sin(a) + 1.5 => ", b);
+    af_print!("sin(a) + 1.5 a.k.a b => ", b);
     af_print!("sin(a) + cos(a) => ", b2);
     af_print!("!a => ", b3);
 
     let test = a.clone() + b.clone();
     af_print!("a + b", test);
 
+    let negation = -(a.clone());
+    af_print!("-a ", negation);
+
     // Index array using sequences
     let seqs = &[Seq::new(1u32, 3, 1), Seq::default()];
     let sub = index(&a, seqs);
@@ -51,10 +57,6 @@ fn main() {
     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");
     print(&fft(&b, 1.0, 0));
 
@@ -74,15 +76,11 @@ fn main() {
     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");
-    let x = sort_index(&a, 0, true);
-    print(&x.0);
-    print(&x.1);
+    //// // Sort A
+    //println!("Sort A and print sorted array and corresponding indices");
+    //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);

examples/histogram.rs

@@ -19,7 +19,7 @@ fn main() {
     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 man = load_image::<f32>(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);