Fixed documentation tests(example code stubs)

Author: 9prady9

examples/helloworld.rs

@@ -15,7 +15,7 @@ fn main() {
     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) {
+    let a = match randu::<f32>(dims) {
         Ok(value) => value,
         Err(error) => panic!("{}", error),
     };

src/array.rs

@@ -119,6 +119,7 @@ impl Array {
     /// # Examples
     ///
     /// ```
+    /// use arrayfire::{Array, Dim4};
     /// let values: &[f32] = &[1.0, 2.0, 3.0];
     /// let indices = Array::new(values, Dim4::new(&[3, 1, 1, 1])).unwrap();
     /// ```
@@ -388,25 +389,27 @@ impl Drop for Array {
 ///
 /// # Examples
 ///
-///  ```
+/// ```
+/// use arrayfire::{Dim4, print, randu};
 /// println!("Create a 5-by-3 matrix of random floats on the GPU");
+/// let dims = Dim4::new(&[3, 1, 1, 1]);
 /// let a = match randu::<f32>(dims) {
 ///     Ok(value) => value,
 ///     Err(error) => panic!("{}", error),
 /// };
 /// print(&a);
-///  ```
+/// ```
 ///
-///  The sample output will look like below:
+/// The sample output will look like below:
 ///
-///  ```
-///  [5 3 1 1]
-///      0.7402     0.4464     0.7762
-///      0.9210     0.6673     0.2948
-///      0.0390     0.1099     0.7140
-///      0.9690     0.4702     0.3585
-///      0.9251     0.5132     0.6814
-///  ```
+/// ```bash
+/// [5 3 1 1]
+///     0.7402     0.4464     0.7762
+///     0.9210     0.6673     0.2948
+///     0.0390     0.1099     0.7140
+///     0.9690     0.4702     0.3585
+///     0.9251     0.5132     0.6814
+/// ```
 pub fn print(input: &Array) -> Result<(), AfError> {
     unsafe {
         let ret_val = af_print_array(input.get() as AfArray);

src/data/mod.rs

@@ -537,7 +537,7 @@ pub fn upper(input: &Array, is_unit_diag: bool) -> Result<Array, AfError> {
 /// This function does the C-equivalent of the following statement, except that the operation
 /// happens on a GPU for all elements simultaneously.
 ///
-/// ```
+/// ```ignore
 /// c = cond ? a : b; /// where cond, a & b are all objects of type Array
 /// ```
 ///
@@ -570,7 +570,7 @@ pub fn select(a: &Array, cond: &Array, b: &Array) -> Result<Array, AfError> {
 /// This function does the C-equivalent of the following statement, except that the operation
 /// happens on a GPU for all elements simultaneously.
 ///
-/// ```
+/// ```ignore
 /// c = cond ? a : b; /// where  a is a scalar(f64) and b is Array
 /// ```
 ///
@@ -603,7 +603,7 @@ pub fn selectl(a: f64, cond: &Array, b: &Array) -> Result<Array, AfError> {
 /// This function does the C-equivalent of the following statement, except that the operation
 /// happens on a GPU for all elements simultaneously.
 ///
-/// ```
+/// ```ignore
 /// c = cond ? a : b; /// where a is Array and b is a scalar(f64)
 /// ```
 ///
@@ -636,7 +636,7 @@ pub fn selectr(a: &Array, cond: &Array, b: f64) -> Result<Array, AfError> {
 /// This function does the C-equivalent of the following statement, except that the operation
 /// happens on a GPU for all elements simultaneously.
 ///
-/// ```
+/// ```ignore
 /// a = cond ? a : b; /// where cond, a & b are all objects of type Array
 /// ```
 ///
@@ -666,7 +666,7 @@ pub fn replace(a: &mut Array, cond: &Array, b: &Array) -> Result<(), AfError> {
 /// This function does the C-equivalent of the following statement, except that the operation
 /// happens on a GPU for all elements simultaneously.
 ///
-/// ```
+/// ```ignore
 /// a = cond ? a : b; /// where cond, a are Arrays and b is scalar(f64)
 /// ```
 ///

src/device/mod.rs

@@ -45,7 +45,7 @@ pub fn get_version() -> Result<(i32, i32, i32), AfError> {
 ///
 /// An example output of `af::info` call looks like below
 ///
-/// ```
+/// ```ignore
 /// ArrayFire v3.0.0 (CUDA, 64-bit Mac OSX, build d8d4b38)
 /// Platform: CUDA Toolkit 7, Driver: CUDA Driver Version: 7000
 /// [0] GeForce GT 750M, 2048 MB, CUDA Compute 3.0

src/dim4.rs

@@ -19,6 +19,8 @@ impl Default for Dim4 {
 /// # Examples
 ///
 /// ```
+/// use arrayfire::Dim4;
+///
 /// let dims = Dim4::new(&[4, 4, 2, 1]);
 /// println!("0th Dimension length is {}", dims[0]); // -> 4
 /// println!("1th Dimension length is {}", dims[1]); // -> 4
@@ -38,6 +40,8 @@ impl Index<usize> for Dim4 {
 /// # Examples
 ///
 /// ```
+/// use arrayfire::Dim4;
+///
 /// let dims = Dim4::new(&[4, 4, 2, 1]);
 /// println!("0th Dimension length is {}", dims[0]); // -> 4
 /// ```
@@ -53,6 +57,7 @@ impl Dim4 {
     /// # Examples
     ///
     /// ```
+    /// use arrayfire::Dim4;
     /// let dims = Dim4::new(&[4, 4, 2, 1]);
     /// ```
     pub fn new(dims: &[u64; 4]) -> Dim4 {

src/graphics.rs

@@ -54,22 +54,23 @@ pub struct Cell {
 ///
 /// # Examples
 ///
-/// ```
-/// let wnd = Window::new(1280, 720, String::from("Image Histogram")).unwrap();
-/// let img = match load_image("Path to image", true/*If color image, 'false' otherwise*/) {
+/// ```no_run
+/// use arrayfire::{histogram, load_image, Window};
+/// let mut wnd = Window::new(1280, 720, String::from("Image Histogram")).unwrap();
+/// let img = match load_image("Path to image".to_string(), true/*If color image, 'false' otherwise*/) {
 ///     Ok(img) => img,
 ///     Err(err) => panic!("Image loading failed with error code {}", err),
 /// };
-/// let hst = histogram(img, 256, 0, 255).unwrap();
+/// let hst = histogram(&img, 256, 0 as f64, 255 as f64).unwrap();
 ///
 /// loop {
 ///     wnd.grid(2, 1);
 ///
 ///     wnd.set_view(0, 0);
-///     wnd.draw_image(img, Some("Input Image"));
+///     wnd.draw_image(&img, Some("Input Image".to_string()));
 ///
 ///     wnd.set_view(1, 0);
-///     wnd.draw_histogram(hst, 0.0, 255.0, Some("Input Image Histogram"));
+///     wnd.draw_hist(&hst, 0.0, 255.0, Some("Input Image Histogram".to_string()));
 ///
 ///     wnd.show();
 ///

src/image/mod.rs

@@ -968,7 +968,7 @@ hsvrgb_func_def!(rgb2hsv, af_rgb2hsv);
 ///
 /// # Examples
 ///
-/// ```
+/// ```ignore
 /// A [5 5 1 1]
 /// 10 15 20 25 30
 /// 11 16 21 26 31

src/index.rs

@@ -125,6 +125,8 @@ impl Drop for Indexer {
 /// # Examples
 ///
 /// ```
+/// use arrayfire::{Dim4, Seq, index, randu, print};
+/// let dims = Dim4::new(&[5, 5, 1, 1]);
 /// let a = randu::<f32>(dims).unwrap();
 /// let seqs = &[Seq::new(1.0, 3.0, 1.0), Seq::default()];
 /// let sub  = index(&a, seqs).unwrap();
@@ -153,10 +155,12 @@ pub fn index<T: Copy>(input: &Array, seqs: &[Seq<T>]) -> Result<Array, AfError>
 /// # Examples
 ///
 /// ```
+/// use arrayfire::{Dim4, randu, row, print};
+/// let dims = Dim4::new(&[5, 5, 1, 1]);
 /// let a = randu::<f32>(dims).unwrap();
 /// println!("Grab last row of the random matrix");
 /// print(&a);
-/// print(&row(&a, num_rows - 1).unwrap());
+/// print(&row(&a, 4).unwrap());
 /// ```
 #[allow(dead_code)]
 pub fn row(input: &Array, row_num: u64) -> Result<Array, AfError> {
@@ -189,10 +193,12 @@ pub fn set_rows(input: &Array, new_rows: &Array, first: u64, last: u64) -> Resul
 /// # Examples
 ///
 /// ```
+/// use arrayfire::{Dim4, randu, col, print};
+/// let dims = Dim4::new(&[5, 5, 1, 1]);
 /// let a = randu::<f32>(dims).unwrap();
 /// println!("Grab last col of the random matrix");
 /// print(&a);
-/// print(&row(&a, num_cols - 1).unwrap());
+/// print(&col(&a, 4).unwrap());
 /// ```
 #[allow(dead_code)]
 pub fn col(input: &Array, col_num: u64) -> Result<Array, AfError> {
@@ -287,6 +293,7 @@ pub fn lookup(input: &Array, indices: &Array, seq_dim: i32) -> Result<Array, AfE
 /// # Examples
 ///
 /// ```
+/// use arrayfire::{constant, Dim4, Seq, assign_seq, print};
 /// let a    = constant(2.0 as f32, Dim4::new(&[5, 3, 1, 1])).unwrap();
 /// let b    = constant(1.0 as f32, Dim4::new(&[3, 3, 1, 1])).unwrap();
 /// let seqs = &[Seq::new(1.0, 3.0, 1.0), Seq::default()];
@@ -327,6 +334,7 @@ pub fn assign_seq<T: Copy>(lhs: &Array, seqs: &[Seq<T>], rhs: &Array) -> Result<
 /// # Examples
 ///
 /// ```
+/// use arrayfire::{Array, Dim4, Seq, print, randu, index_gen, Indexer};
 /// let values: &[f32] = &[1.0, 2.0, 3.0];
 /// let indices = Array::new(values, Dim4::new(&[3, 1, 1, 1])).unwrap();
 /// let seq4gen = Seq::new(0.0, 2.0, 1.0);
@@ -370,6 +378,7 @@ pub fn index_gen(input: &Array, indices: Indexer) -> Result<Array, AfError> {
 /// # Examples
 ///
 /// ```
+/// use arrayfire::{Array, Dim4, Seq, print, randu, constant, Indexer, assign_gen};
 /// let values: &[f32] = &[1.0, 2.0, 3.0];
 /// let indices = Array::new(values, Dim4::new(&[3, 1, 1, 1])).unwrap();
 /// let seq4gen = Seq::new(0.0, 2.0, 1.0);
@@ -390,7 +399,7 @@ pub fn index_gen(input: &Array, indices: Indexer) -> Result<Array, AfError> {
 /// idxrs.set_index(&indices, 0, None); // 2nd parameter is indexing dimension
 /// idxrs.set_index(&seq4gen, 1, Some(false)); // 3rd parameter indicates batch operation
 ///
-/// let sub2 = assign_gen(&a, idxrs, &b).unwrap();
+/// let sub2 = assign_gen(&a, &idxrs, &b).unwrap();
 /// println!("a(indices, seq(0, 2, 1))"); print(&sub2);
 /// // [5 3 1 1]
 /// //     0.0000     0.2190     0.3835

src/macros.rs

@@ -36,12 +36,20 @@
 /// # Examples
 ///
 /// ```
-/// mem_info!("Here");
+/// # #[macro_use(mem_info)] extern crate arrayfire;
+/// # fn main() {
+///     use arrayfire::{Dim4, device_mem_info, print, randu};
+///
+///     let dims = Dim4::new(&[5, 5, 1, 1]);
+///     let a = randu::<f32>(dims).unwrap();
+///     print(&a);
+///     mem_info!("Hello!");
+/// # }
 /// ```
 ///
 /// Sample Output:
 ///
-/// ```
+/// ```ignore
 /// AF Memory: Here
 /// Allocated [ Bytes | Buffers ] = [ 4096 | 4 ]
 /// In Use    [ Bytes | Buffers ] = [ 2048 | 2 ]
@@ -66,11 +74,15 @@ macro_rules! mem_info {
 ///
 /// ```
 /// # #[macro_use] extern crate arrayfire;
+///
 /// # fn main() {
-/// let a = &randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
-/// let b = &randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
-/// let c = &randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
-/// let d = join_many![2; a, b, c];
+///     use arrayfire::{Dim4, join_many, print, randu};
+///
+///     let a = &randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
+///     let b = &randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
+///     let c = &randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
+///     let d = join_many![2; a, b, c];
+///     print(&d.unwrap());
 /// # }
 /// ```
 ///