New fns to create arrays using Dim4 and DType params

* create_constant
* create_constant_i64
* create_constant_u64
* create_range
* create_range
* create_iota

Author: 9prady9

src/arith/mod.rs

@@ -3,10 +3,10 @@ extern crate num;
 
 use dim4::Dim4;
 use array::Array;
-use defines::AfError;
+use defines::{AfError, DType};
 use error::HANDLE_ERROR;
 use self::libc::{c_int};
-use data::{constant, constant_like, tile};
+use data::{constant, create_constant, create_constant_i64, create_constant_u64, tile};
 use self::num::Complex;
 
 use std::ops::Neg;
@@ -493,6 +493,10 @@ impl Neg for Array {
     type Output = Array;
 
     fn neg(self) -> Self::Output {
-        constant_like(0.0, &self) - self
+        match self.get_type() {
+            DType::S64 => (create_constant_i64(0, self.dims()) - self),
+            DType::U64 => (create_constant_u64(0, self.dims()) - self),
+            _ => (create_constant(0.0, 0.0, self.dims(), self.get_type()) - self)
+        }
     }
 }

src/data/mod.rs

@@ -3,7 +3,7 @@ extern crate num;
 
 use array::Array;
 use dim4::Dim4;
-use defines::AfError;
+use defines::{AfError, DType};
 use error::HANDLE_ERROR;
 use self::libc::{uint8_t, c_int, c_uint, c_double};
 use self::num::Complex;
@@ -623,24 +623,170 @@ pub fn replace_scalar(a: &mut Array, cond: &Array, b: f64) {
     }
 }
 
-/// Create an array filled with given constant retaining type/shape of another Array.
+/// Create an Array of particular shape filled with given constant.
+///
+/// You can use this function to create arrays of the following types only.
+/// - DType::F32
+/// - DType::C32
+/// - DType::F64
+/// - DType::C64
+/// - DType::B8
+/// - DType::S32
+/// - DType::U32
+/// - DType::U8
+/// - DType::S16
+/// - DType::U16
+///
+/// # Parameters
+///
+/// - `real` is the constant with which output Array is to be filled
+/// - `imag` is the constant with which imaginary part of a complex Array will be filed.
+/// - `dims` is the size of Array
+/// - `dtype` indicates whats the type of the Array to be created
+///
+/// # Return Values
+///
+/// Array of `dims` shape and filed with given constant `value`.
+pub fn create_constant(real: f64, imag: f64, dims: Dim4, dtype: DType) -> Array {
+    unsafe {
+        let mut temp: i64 = 0;
+        let err_val = match dtype {
+            DType::S64 => { AfError::ERR_TYPE as i32 },
+            DType::U64 => { AfError::ERR_TYPE as i32 },
+            DType::C32 => {
+                af_constant_complex(&mut temp as MutAfArray,
+                                    real as c_double, imag as c_double,
+                                    dims.ndims() as c_uint,
+                                    dims.get().as_ptr() as *const DimT, 1)
+            },
+            DType::C64 => {
+                af_constant_complex(&mut temp as MutAfArray,
+                                    real as c_double, imag as c_double,
+                                    dims.ndims() as c_uint,
+                                    dims.get().as_ptr() as *const DimT, 3)
+            },
+            _ => {
+                af_constant(&mut temp as MutAfArray, real as c_double,
+                            dims.ndims() as c_uint,
+                            dims.get().as_ptr() as *const DimT,
+                            dtype as c_int)
+            }
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        Array::from(temp)
+    }
+}
+
+/// Create an array filled with i64 constant
+///
+/// # Parameters
+///
+/// - `value` is the constant with which output Array is to be filled
+/// - `dims` is the size of Array
+///
+/// # Return Values
+///
+/// Array filled with `value` and `dims` shape.
+pub fn create_constant_i64(value: i64, dims: Dim4) -> Array {
+    unsafe {
+        let mut temp: i64 = 0;
+        let err_val = af_constant_long(&mut temp as MutAfArray, value as Intl,
+                                       dims.ndims() as c_uint,
+                                       dims.get().as_ptr() as *const DimT);
+        HANDLE_ERROR(AfError::from(err_val));
+        Array::from(temp)
+    }
+}
+
+/// Create an array filled with u64 constant
 ///
 /// # Parameters
 ///
 /// - `value` is the constant with which output Array is to be filled
-/// - `input` is the Array whose shape the output Array has to maintain
+/// - `dims` is the size of Array
+///
+/// # Return Values
+///
+/// Array filled with `value` and `dims` shape.
+pub fn create_constant_u64(value: u64, dims: Dim4) -> Array {
+    unsafe {
+        let mut temp: i64 = 0;
+        let err_val = af_constant_ulong(&mut temp as MutAfArray, value as Uintl,
+                                        dims.ndims() as c_uint,
+                                        dims.get().as_ptr() as *const DimT);
+        HANDLE_ERROR(AfError::from(err_val));
+        Array::from(temp)
+    }
+}
+
+/// Create a Range of values
+///
+/// Creates an array with [0, n] values along the `seq_dim` which is tiled across other dimensions.
+///
+/// # Parameters
+///
+/// - `dims` is the size of Array
+/// - `seq_dim` is the dimension along which range values are populated, all values along other
+/// dimensions are just repeated
+/// - `dtype` indicates whats the type of the Array to be created
+///
+/// # Return Values
+/// Array
+#[allow(unused_mut)]
+pub fn create_range(dims: Dim4, seq_dim: i32, dtype: DType) -> Array {
+    unsafe {
+        let mut temp: i64 = 0;
+        let err_val = af_range(&mut temp as MutAfArray,
+                              dims.ndims() as c_uint, dims.get().as_ptr() as *const DimT,
+                              seq_dim as c_int, dtype as uint8_t);
+        HANDLE_ERROR(AfError::from(err_val));
+        Array::from(temp)
+    }
+}
+
+/// Create a range of values
+///
+/// Create an sequence [0, dims.elements() - 1] and modify to specified dimensions dims and then tile it according to tile_dims.
+///
+/// # Parameters
+///
+/// - `dims` is the dimensions of the sequence to be generated
+/// - `tdims` is the number of repitions of the unit dimensions
+/// - `dtype` indicates whats the type of the Array to be created
 ///
 /// # Return Values
 ///
-/// Array with given constant value and input Array's shape and similar internal data type.
-pub fn constant_like(value: f64, input: &Array) -> Array {
-    let dims = input.dims();
+/// Array
+#[allow(unused_mut)]
+pub fn create_iota(dims: Dim4, tdims: Dim4, dtype: DType) -> Array {
+    unsafe {
+        let mut temp: i64 = 0;
+        let err_val =af_iota(&mut temp as MutAfArray,
+                             dims.ndims() as c_uint, dims.get().as_ptr() as *const DimT,
+                             tdims.ndims() as c_uint, tdims.get().as_ptr() as *const DimT,
+                             dtype as uint8_t);
+        HANDLE_ERROR(AfError::from(err_val));
+        Array::from(temp)
+    }
+}
+
+/// Create an identity array with 1's in diagonal
+///
+/// # Parameters
+///
+/// - `dims` is the output Array dimensions
+/// - `dtype` indicates whats the type of the Array to be created
+///
+/// # Return Values
+///
+/// Identity matrix
+#[allow(unused_mut)]
+pub fn create_identity(dims: Dim4, dtype: DType) -> Array {
     unsafe {
         let mut temp: i64 = 0;
-        let err_val = af_constant(&mut temp as MutAfArray, value as c_double,
-                                  dims.ndims() as c_uint,
-                                  dims.get().as_ptr() as *const DimT,
-                                  input.get_type() as c_int);
+        let err_val = af_identity(&mut temp as MutAfArray,
+                                  dims.ndims() as c_uint, dims.get().as_ptr() as *const DimT,
+                                  dtype as uint8_t);
         HANDLE_ERROR(AfError::from(err_val));
         Array::from(temp)
     }

src/lib.rs

@@ -32,11 +32,13 @@ mod backend;
 pub use blas::{matmul, dot, transpose, transpose_inplace};
 mod blas;
 
-pub use data::{constant, constant_like, range, iota};
-pub use data::{identity, diag_create, diag_extract, lower, upper};
+pub use data::{constant, range, iota, identity};
+pub use data::{diag_create, diag_extract, lower, upper};
 pub use data::{join, join_many, tile};
 pub use data::{reorder, shift, moddims, flat, flip};
 pub use data::{select, selectl, selectr, replace, replace_scalar};
+pub use data::{create_constant, create_range, create_iota, create_identity};
+pub use data::{create_constant_i64, create_constant_u64};
 mod data;
 
 pub use device::{get_version, info, init, device_count, is_double_available, set_device, get_device};