Implement Neg and Not for &ArrayBase

Author: jturner314

src/impl_ops.rs

@@ -292,6 +292,19 @@ mod arithmetic_ops {
         }
     }
 
+    impl<'a, A, S, D> Neg for &'a ArrayBase<S, D>
+        where A: Clone + Neg<Output=A>,
+              S: Data<Elem=A>,
+              D: Dimension
+    {
+        type Output = Array<A, D>;
+        /// Perform an elementwise negation of reference `self` and return the
+        /// result as a new `Array`.
+        fn neg(self) -> Array<A, D> {
+            self.to_owned().neg()
+        }
+    }
+
     impl<A, S, D> Not for ArrayBase<S, D>
         where A: Clone + Not<Output=A>,
               S: DataOwned<Elem=A> + DataMut,
@@ -306,6 +319,19 @@ mod arithmetic_ops {
             self
         }
     }
+
+    impl<'a, A, S, D> Not for &'a ArrayBase<S, D>
+        where A: Clone + Not<Output=A>,
+              S: Data<Elem=A>,
+              D: Dimension
+    {
+        type Output = Array<A, D>;
+        /// Perform an elementwise unary not of reference `self` and return the
+        /// result as a new `Array`.
+        fn not(self) -> Array<A, D> {
+            self.to_owned().not()
+        }
+    }
 }
 
 mod assign_ops {

src/lib.rs

@@ -529,6 +529,8 @@ pub type Ixs = isize;
 ///
 /// Since the trait implementations are hard to overview, here is a summary.
 ///
+/// ### Binary Operators with Two Arrays
+///
 /// Let `A` be an array or view of any kind. Let `B` be an array
 /// with owned storage (either `Array` or `RcArray`).
 /// Let `C` be an array with mutable data (either `Array`, `RcArray`
@@ -542,6 +544,8 @@ pub type Ixs = isize;
 /// - `B @ &A` which consumes `B`, updates it with the result, and returns it
 /// - `C @= &A` which performs an arithmetic operation in place
 ///
+/// ### Binary Operators with Array and Scalar
+///
 /// The trait [`ScalarOperand`](trait.ScalarOperand.html) marks types that can be used in arithmetic
 /// with arrays directly. For a scalar `K` the following combinations of operands
 /// are supported (scalar can be on either the left or right side, but
@@ -551,6 +555,15 @@ pub type Ixs = isize;
 /// - `B @ K` or `K @ B` which consumes `B`, updates it with the result and returns it
 /// - `C @= K` which performs an arithmetic operation in place
 ///
+/// ### Unary Operators
+///
+/// Let `A` be an array or view of any kind. Let `B` be an array with owned
+/// storage (either `Array` or `RcArray`). The following operands are supported
+/// for an arbitrary unary operator denoted by `@` (it can be `-` or `!`).
+///
+/// - `@&A` which produces a new `Array`
+/// - `@B` which consumes `B`, updates it with the result, and returns it
+///
 /// ## Broadcasting
 ///
 /// Arrays support limited *broadcasting*, where arithmetic operations with

tests/oper.rs

@@ -61,6 +61,7 @@ fn test_oper_arr<A: NdFloat + fmt::Debug, D: ndarray::Dimension>
             assert_eq!(aa, cc);
         },
         "neg" => {
+            assert_eq!(-&aa, cc);
             assert_eq!(-aa.clone(), cc);
         },
         _ => panic!()