Changed arith operator overloads

From now on, do the arith operations, users have to do the following
```
let a = randu(Dim4::new(&[4,4,1,1]));
let b = &a + 3.5;
let c = &a - &b;
```
We can't do just `a+b` because of move semantics limitation. This
may be improved later when `Copy` trait can be implemented on
Objects with `Drop` trait implemented.

Author: 9prady9

src/arith/mod.rs

@@ -92,7 +92,7 @@ extern {
     fn af_isnan(out: MutAfArray, arr: AfArray) -> c_int;
 }
 
-impl Not for Array {
+impl<'f> Not for &'f Array {
     type Output = Array;
 
     fn not(self) -> Array {
@@ -190,7 +190,7 @@ binary_func!(pow, af_pow);
 
 macro_rules! arith_scalar_func {
     ($rust_type: ty, $op_name:ident, $fn_name: ident, $ffi_fn: ident) => (
-        impl $op_name<$rust_type> for Array {
+        impl<'f> $op_name<$rust_type> for &'f Array {
             type Output = Array;
 
             fn $fn_name(self, rhs: $rust_type) -> Array {
@@ -228,10 +228,10 @@ arith_scalar_spec!(u8);
 
 macro_rules! arith_func {
     ($op_name:ident, $fn_name:ident, $ffi_fn: ident) => (
-        impl $op_name<Array> for Array {
+        impl<'f> $op_name<&'f Array> for &'f Array {
             type Output = Array;
 
-            fn $fn_name(self, rhs: Array) -> Array {
+            fn $fn_name(self, rhs:&'f Array) -> Array {
                 unsafe {
                     let mut temp: i64 = 0;
                     $ffi_fn(&mut temp as MutAfArray,

tests/hello_world.rs

@@ -16,10 +16,14 @@ fn main() {
     af::print(&a);
 
     println!("Element-wise arithmetic");
-    let b: Array = af::sin(&a) + 1.5;
-    af::print(&b);
-
-    let test = a.clone() + b.clone();
+    let b: Array = &af::sin(&a) + 1.5;
+    let b2: Array = &af::sin(&a) + &af::cos(&a);
+    let b3: Array = ! &a;
+    println!("sin(a) + 1.5 => "); af::print(&b);
+    println!("sin(a) + cos(a) => "); af::print(&b2);
+    println!("!a => "); af::print(&b3);
+
+    let test = &a + &b;
     af::print(&test);
 
     // printf("Negate the first three elements of second column\n");