feat: augmented assignment operators

Cargo.toml

@@ -6,9 +6,6 @@ version = "0.0.0"
 [features]
 macros = ["linalg_macros"]
 
-[dependencies.assign]
-git = "https://github.com/japaric/assign.rs"
-
 [dependencies.blas]
 git = "https://github.com/japaric/blas.rs"
 

src/lib.rs

@@ -76,7 +76,7 @@
 //! A[1, :] += 1;
 //!
 //! // Rust
-//! A.row_mut(1).add_assign(1)
+//! A.row_mut(1) += 1;
 //! ```
 //!
 //! Subtract sub-matrices
@@ -86,7 +86,7 @@
 //! A[1:3, 2:4] -= B[:2, 1:3]
 //!
 //! // Rust
-//! A.slice_mut((1..3, 2..4)).sub_assign(B.slice((..2, 1..3)));
+//! A.slice_mut((1..3, 2..4)) -= B.slice((..2, 1..3));
 //! ```
 //!
 //! - Index assignment
@@ -219,7 +219,7 @@
 //!     z.set(y);
 //!
 //!     // z = y - theta * X
-//!     z.sub_assign(theta * X);
+//!     z -= theta * X;
 //!
 //!     ..
 //!
@@ -236,14 +236,14 @@
 #![deny(missing_docs)]
 #![deny(warnings)]
 #![feature(advanced_slice_patterns)]
+#![feature(augmented_assignments)]
 #![feature(collections)]
 #![feature(core)]
 #![feature(filling_drop)]
 #![feature(slice_patterns)]
 #![feature(unique)]
 #![feature(unsafe_no_drop_flag)]
 
-extern crate assign;
 extern crate blas;
 extern crate cast;
 extern crate complex;

src/ops/add/col.rs

@@ -1,6 +1,5 @@
 use std::ops::Add;
 
-use assign::AddAssign;
 use blas::{Axpy, Gemm, Gemv, Transpose};
 use complex::Complex;
 use onezero::{One, Zero};
@@ -238,7 +237,7 @@ macro_rules! scalar {
                 type Output = ColVec<$t>;
 
                 fn add(self, mut rhs: ColVec<$t>) -> ColVec<$t> {
-                    rhs.add_assign(self);
+                    rhs += self;
                     rhs
                 }
             }
@@ -247,7 +246,7 @@ macro_rules! scalar {
                 type Output = ColVec<$t>;
 
                 fn add(self, mut rhs: ColVec<$t>) -> ColVec<$t> {
-                    rhs.add_assign(self);
+                    rhs += self;
                     rhs
                 }
             }

src/ops/add/mat.rs

@@ -1,6 +1,5 @@
 use std::ops::Add;
 
-use assign::AddAssign;
 use blas::{Axpy, Gemm, Transpose};
 use complex::Complex;
 use onezero::{One, Zero};
@@ -185,7 +184,7 @@ macro_rules! scalar {
                 type Output = Mat<$t>;
 
                 fn add(self, mut rhs: Mat<$t>) -> Mat<$t> {
-                    rhs.add_assign(self);
+                    rhs += self;
                     rhs
                 }
             }
@@ -194,7 +193,7 @@ macro_rules! scalar {
                 type Output = Mat<$t>;
 
                 fn add(self, mut rhs: Mat<$t>) -> Mat<$t> {
-                    rhs.add_assign(self);
+                    rhs += self;
                     rhs
                 }
             }
@@ -203,7 +202,7 @@ macro_rules! scalar {
                 type Output = Transposed<Mat<$t>>;
 
                 fn add(self, mut rhs: Transposed<Mat<$t>>) -> Transposed<Mat<$t>> {
-                    rhs.add_assign(self);
+                    rhs += self;
                     rhs
                 }
             }
@@ -212,7 +211,7 @@ macro_rules! scalar {
                 type Output = Transposed<Mat<$t>>;
 
                 fn add(self, mut rhs: Transposed<Mat<$t>>) -> Transposed<Mat<$t>> {
-                    rhs.add_assign(self);
+                    rhs += self;
                     rhs
                 }
             }

src/ops/add/mod.rs

@@ -8,7 +8,7 @@ macro_rules! assign {
                 type Output = $lhs;
 
                 fn add(mut self, rhs: $rhs) -> $lhs {
-                    self.add_assign(rhs);
+                    self += rhs;
                     self
                 }
             }
@@ -17,7 +17,7 @@ macro_rules! assign {
                 type Output = $lhs;
 
                 fn add(self, mut rhs: $lhs) -> $lhs {
-                    rhs.add_assign(self);
+                    rhs += self;
                     rhs
                 }
             }
@@ -29,7 +29,7 @@ macro_rules! assign {
                 type Output = $lhs;
 
                 fn add(mut self, rhs: $rhs) -> $lhs {
-                    self.add_assign(rhs);
+                    self += rhs;
                     self
                 }
             }

src/ops/add/row.rs

@@ -1,6 +1,5 @@
 use std::ops::Add;
 
-use assign::AddAssign;
 use blas::{Axpy, Gemm, Gemv};
 use complex::Complex;
 use onezero::{One, Zero};
@@ -93,7 +92,7 @@ macro_rules! scalar {
                 type Output = RowVec<$t>;
 
                 fn add(self, mut rhs: RowVec<$t>) -> RowVec<$t> {
-                    rhs.add_assign(self);
+                    rhs += self;
                     rhs
                 }
             }
@@ -102,7 +101,7 @@ macro_rules! scalar {
                 type Output = RowVec<$t>;
 
                 fn add(self, mut rhs: RowVec<$t>) -> RowVec<$t> {
-                    rhs.add_assign(self);
+                    rhs += self;
                     rhs
                 }
             }

src/ops/add_assign/col.rs

@@ -1,4 +1,5 @@
-use assign::AddAssign;
+use std::ops::AddAssign;
+
 use blas::{Axpy, Gemm, Gemv, Transpose};
 use onezero::{One, Zero};
 
@@ -112,15 +113,15 @@ impl<'a, 'b, T> AddAssign<Scaled<Col<'a, T>>> for ColMut<'b, T> where T: Axpy {
 // Secondary implementations
 impl<'a, 'b, T> AddAssign<Col<'a, T>> for ColMut<'b, T> where T: Axpy + One {
     fn add_assign(&mut self, rhs: Col<T>) {
-        self.add_assign(Scaled(T::one(), rhs))
+        *self += Scaled(T::one(), rhs)
     }
 }
 
 impl<'a, 'b, 'c, T> AddAssign<Product<Chain<'a, T>, Col<'b, T>>> for ColMut<'c, T> where
     T: Gemm + Gemv + One + Zero,
 {
     fn add_assign(&mut self, rhs: Product<Chain<T>, Col<T>>) {
-        self.add_assign(Scaled(T::one(), rhs))
+        *self += Scaled(T::one(), rhs)
     }
 }
 
@@ -129,15 +130,15 @@ AddAssign<Product<Transposed<SubMat<'a, T>>, Col<'b, T>>> for ColMut<'c, T> wher
     T: Gemv + One,
 {
     fn add_assign(&mut self, rhs: Product<Transposed<SubMat<T>>, Col<T>>) {
-        self.add_assign(Scaled(T::one(), rhs))
+        *self += Scaled(T::one(), rhs)
     }
 }
 
 impl<'a, 'b, 'c, T> AddAssign<Product<SubMat<'a, T>, Col<'b, T>>> for ColMut<'c, T> where
     T: Gemv + One,
 {
     fn add_assign(&mut self, rhs: Product<SubMat<T>, Col<T>>) {
-        self.add_assign(Scaled(T::one(), rhs))
+        *self += Scaled(T::one(), rhs)
     }
 }
 
@@ -146,7 +147,7 @@ macro_rules! forward {
         $(
             impl<'a, 'b, 'c, T> AddAssign<$rhs> for $lhs where $(T: $bound),+ {
                 fn add_assign(&mut self, rhs: $rhs) {
-                    self.slice_mut(..).add_assign(rhs.slice(..))
+                    self.slice_mut(..) += rhs.slice(..)
                 }
             }
          )+
@@ -161,7 +162,7 @@ forward!(ColMut<'a, T> {
 
 impl<'a, T> AddAssign<T> for ColMut<'a, T> where T: Axpy + One {
     fn add_assign(&mut self, rhs: T) {
-        self.add_assign(&rhs)
+        *self += &rhs
     }
 }
 
@@ -181,12 +182,12 @@ forward!(ColVec<T> {
 
 impl<'a, T> AddAssign<&'a T> for ColVec<T> where T: Axpy + One {
     fn add_assign(&mut self, rhs: &T) {
-        self.slice_mut(..).add_assign(rhs)
+        self.slice_mut(..) += rhs
     }
 }
 
 impl<T> AddAssign<T> for ColVec<T> where T: Axpy + One {
     fn add_assign(&mut self, rhs: T) {
-        self.slice_mut(..).add_assign(&rhs)
+        self.slice_mut(..) += &rhs
     }
 }

src/ops/add_assign/diag.rs

@@ -1,4 +1,5 @@
-use assign::AddAssign;
+use std::ops::AddAssign;
+
 use blas::Axpy;
 use onezero::One;
 
@@ -26,6 +27,6 @@ impl<'a, 'b, T> AddAssign<&'a T> for DiagMut<'b, T> where T: Axpy + One {
 // "Forwarding" implementations
 impl<'a, T> AddAssign<T> for DiagMut<'a, T> where T: Axpy + One {
     fn add_assign(&mut self, rhs: T) {
-        self.add_assign(&rhs)
+        *self += &rhs
     }
 }