Update ndarray to version 0.13 (#172)

stefan-k · jturner314 · commit bf5ab89bb6fb · 2019-10-09T13:46:09.000-04:00
* Update ndarray to version 0.13

* Apply suggestions from code review

Co-Authored-By: Jim Turner &lt;github@turner.link&gt;

* revert back to &amp;mut *a in azip! macros of krylov/mgs.rs
diff --git a/Cargo.toml b/Cargo.toml
@@ -30,7 +30,7 @@ num-complex = "0.2.1"
 rand = "0.5"
 
 [dependencies.ndarray]
-version = "0.12"
+version = "0.13"
 features = ["blas"]
 default-features = false
 
diff --git a/src/convert.rs b/src/convert.rs
@@ -113,14 +113,14 @@ where
     assert!(a.is_square());
     match uplo {
         UPLO::Upper => {
-            for row in 0..a.rows() {
+            for row in 0..a.nrows() {
                 for col in 0..row {
                     a[(row, col)] = a[(col, row)].conj();
                 }
             }
         }
         UPLO::Lower => {
-            for col in 0..a.cols() {
+            for col in 0..a.ncols() {
                 for row in 0..col {
                     a[(row, col)] = a[(col, row)].conj();
                 }
diff --git a/src/eigh.rs b/src/eigh.rs
@@ -8,6 +8,7 @@ use crate::layout::*;
 use crate::operator::LinearOperator;
 use crate::types::*;
 use crate::UPLO;
+use std::iter::FromIterator;
 
 /// Eigenvalue decomposition of Hermite matrix reference
 pub trait Eigh {
@@ -70,7 +71,7 @@ where
             MatrixLayout::F(_) => {}
         }
         let s = unsafe { A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)? };
-        Ok((ArrayBase::from_vec(s), self))
+        Ok((ArrayBase::from(s), self))
     }
 }
 
@@ -126,7 +127,7 @@ where
 
     fn eigvalsh_inplace(&mut self, uplo: UPLO) -> Result<Self::EigVal> {
         let s = unsafe { A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)? };
-        Ok(ArrayBase::from_vec(s))
+        Ok(ArrayBase::from(s))
     }
 }
 
@@ -164,7 +165,7 @@ where
 
     fn ssqrt_into(self, uplo: UPLO) -> Result<Self::Output> {
         let (e, v) = self.eigh_into(uplo)?;
-        let e_sqrt = Array1::from_iter(e.iter().map(|r| Scalar::from_real(r.sqrt())));
+        let e_sqrt = Array::from_iter(e.iter().map(|r| Scalar::from_real(r.sqrt())));
         let ev = e_sqrt.into_diagonal().apply2(&v.t());
         Ok(v.apply2(&ev))
     }
diff --git a/src/krylov/arnoldi.rs b/src/krylov/arnoldi.rs
@@ -38,7 +38,7 @@ where
         assert!(ortho.tolerance() < One::one());
         // normalize before append because |v| may be smaller than ortho.tolerance()
         let norm = v.norm_l2();
-        azip!(mut v(&mut v) in { *v = v.div_real(norm) });
+        azip!((v in &mut v)  *v = v.div_real(norm));
         ortho.append(v.view());
         Arnoldi {
             a,
@@ -82,7 +82,7 @@ where
         self.a.apply_mut(&mut self.v);
         let result = self.ortho.div_append(&mut self.v);
         let norm = self.v.norm_l2();
-        azip!(mut v(&mut self.v) in { *v = v.div_real(norm) });
+        azip!((v in &mut self.v) *v = v.div_real(norm));
         match result {
             AppendResult::Added(coef) => {
                 self.h.push(coef.clone());
diff --git a/src/krylov/householder.rs b/src/krylov/householder.rs
@@ -18,7 +18,7 @@ where
     let alpha = -x[0].mul_real(norm / x[0].abs());
     x[0] -= alpha;
     let inv_rev_norm = A::Real::one() / x.norm_l2();
-    azip!(mut a(x) in { *a = a.mul_real(inv_rev_norm)});
+    azip!((a in x) *a = a.mul_real(inv_rev_norm));
 }
 
 /// Take a reflection `P = I - 2ww^T`
@@ -107,7 +107,7 @@ impl<A: Scalar + Lapack> Householder<A> {
         let k = self.len();
         let res = a.slice(s![k..]).norm_l2();
         let mut c = Array1::zeros(k + 1);
-        azip!(mut c(c.slice_mut(s![..k])), a(a.slice(s![..k])) in { *c = a });
+        azip!((c in c.slice_mut(s![..k]), &a in a.slice(s![..k])) *c = a);
         if k < a.len() {
             let ak = a[k];
             c[k] = -ak.mul_real(res / ak.abs());
@@ -123,7 +123,7 @@ impl<A: Scalar + Lapack> Householder<A> {
         S: DataMut<Elem = A>,
     {
         let k = self.len();
-        azip!(mut a( a.slice_mut(s![..k])) in { *a = A::zero() });
+        azip!((a in a.slice_mut(s![..k])) *a = A::zero());
         self.backward_reflection(a);
     }
 }
diff --git a/src/krylov/mgs.rs b/src/krylov/mgs.rs
@@ -51,7 +51,7 @@ impl<A: Scalar + Lapack> Orthogonalizer for MGS<A> {
         for i in 0..self.len() {
             let q = &self.q[i];
             let c = q.inner(&a);
-            azip!(mut a (&mut *a), q (q) in { *a = *a - c * q } );
+            azip!((a in &mut *a, &q in q) *a = *a - c * q);
             coef[i] = c;
         }
         let nrm = a.norm_l2();
@@ -88,7 +88,7 @@ impl<A: Scalar + Lapack> Orthogonalizer for MGS<A> {
             // Linearly dependent
             return AppendResult::Dependent(coef);
         }
-        azip!(mut a(&mut *a) in { *a = *a / A::from_real(nrm) });
+        azip!((a in &mut *a) *a = *a / A::from_real(nrm));
         self.q.push(a.to_owned());
         AppendResult::Added(coef)
     }
diff --git a/src/layout.rs b/src/layout.rs
@@ -96,10 +96,10 @@ where
         let shape = self.shape();
         let strides = self.strides();
         if shape[0] == strides[1] as usize {
-            return Ok(MatrixLayout::F((self.cols() as i32, self.rows() as i32)));
+            return Ok(MatrixLayout::F((self.ncols() as i32, self.nrows() as i32)));
         }
         if shape[1] == strides[0] as usize {
-            return Ok(MatrixLayout::C((self.rows() as i32, self.cols() as i32)));
+            return Ok(MatrixLayout::C((self.nrows() as i32, self.ncols() as i32)));
         }
         Err(LinalgError::InvalidStride {
             s0: strides[0],
@@ -122,8 +122,8 @@ where
             Ok(())
         } else {
             Err(LinalgError::NotSquare {
-                rows: self.rows() as i32,
-                cols: self.cols() as i32,
+                rows: self.nrows() as i32,
+                cols: self.ncols() as i32,
             })
         }
     }
diff --git a/src/operator.rs b/src/operator.rs
@@ -25,7 +25,7 @@ pub trait LinearOperator {
         S: DataMut<Elem = Self::Elem>,
     {
         let b = self.apply(a);
-        azip!(mut a(a), b in { *a = b });
+        azip!((a in a, &b in &b) *a = b);
     }
 
     /// Apply operator with move
diff --git a/src/qr.rs b/src/qr.rs
@@ -103,8 +103,8 @@ where
     type R = Array2<A>;
 
     fn qr_into(mut self) -> Result<(Self::Q, Self::R)> {
-        let n = self.rows();
-        let m = self.cols();
+        let n = self.nrows();
+        let m = self.ncols();
         let k = ::std::cmp::min(n, m);
         let l = self.layout()?;
         let r = unsafe { A::qr(l, self.as_allocated_mut()?)? };
diff --git a/src/solveh.rs b/src/solveh.rs
@@ -309,7 +309,7 @@ where
     let mut ln_det = A::Real::zero();
     let mut ipiv_enum = ipiv_iter.enumerate();
     while let Some((k, ipiv_k)) = ipiv_enum.next() {
-        debug_assert!(k < a.rows() && k < a.cols());
+        debug_assert!(k < a.nrows() && k < a.ncols());
         if ipiv_k > 0 {
             // 1x1 block at k, must be real.
             let elem = unsafe { a.uget((k, k)) }.re();
diff --git a/src/svd.rs b/src/svd.rs
@@ -81,7 +81,7 @@ where
         let vt = svd_res
             .vt
             .map(|vt| into_matrix(l.resized(m, m), vt).expect("Size of VT mismatches"));
-        let s = ArrayBase::from_vec(svd_res.s);
+        let s = ArrayBase::from(svd_res.s);
         Ok((u, s, vt))
     }
 }
diff --git a/src/svddc.rs b/src/svddc.rs
@@ -28,21 +28,15 @@ pub trait SVDDCInto {
     type U;
     type VT;
     type Sigma;
-    fn svddc_into(
-        self,
-        uvt_flag: UVTFlag,
-    ) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)>;
+    fn svddc_into(self, uvt_flag: UVTFlag) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)>;
 }
 
 /// Singular-value decomposition of matrix reference by divide-and-conquer
 pub trait SVDDCInplace {
     type U;
     type VT;
     type Sigma;
-    fn svddc_inplace(
-        &mut self,
-        uvt_flag: UVTFlag,
-    ) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)>;
+    fn svddc_inplace(&mut self, uvt_flag: UVTFlag) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)>;
 }
 
 impl<A, S> SVDDC for ArrayBase<S, Ix2>
@@ -68,10 +62,7 @@ where
     type VT = Array2<A>;
     type Sigma = Array1<A::Real>;
 
-    fn svddc_into(
-        mut self,
-        uvt_flag: UVTFlag,
-    ) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
+    fn svddc_into(mut self, uvt_flag: UVTFlag) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
         self.svddc_inplace(uvt_flag)
     }
 }
@@ -85,10 +76,7 @@ where
     type VT = Array2<A>;
     type Sigma = Array1<A::Real>;
 
-    fn svddc_inplace(
-        &mut self,
-        uvt_flag: UVTFlag,
-    ) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
+    fn svddc_inplace(&mut self, uvt_flag: UVTFlag) -> Result<(Option<Self::U>, Self::Sigma, Option<Self::VT>)> {
         let l = self.layout()?;
         let svd_res = unsafe { A::svddc(l, uvt_flag, self.as_allocated_mut()?)? };
         let (m, n) = l.size();
@@ -104,7 +92,7 @@ where
         let vt = svd_res
             .vt
             .map(|vt| into_matrix(l.resized(ldvt, tdvt), vt).expect("Size of VT mismatches"));
-        let s = ArrayBase::from_vec(svd_res.s);
+        let s = ArrayBase::from(svd_res.s);
         Ok((u, s, vt))
     }
 }
diff --git a/tests/det.rs b/tests/det.rs
@@ -8,9 +8,9 @@ where
     A: Scalar,
     S: Data<Elem = A>,
 {
-    let mut select_rows = (0..a.rows()).collect::<Vec<_>>();
+    let mut select_rows = (0..a.nrows()).collect::<Vec<_>>();
     select_rows.remove(row);
-    let mut select_cols = (0..a.cols()).collect::<Vec<_>>();
+    let mut select_cols = (0..a.ncols()).collect::<Vec<_>>();
     select_cols.remove(col);
     a.select(Axis(0), &select_rows).select(Axis(1), &select_cols)
 }
@@ -24,8 +24,8 @@ where
     A: Scalar,
     S: Data<Elem = A>,
 {
-    assert_eq!(a.rows(), a.cols());
-    match a.cols() {
+    assert_eq!(a.nrows(), a.ncols());
+    match a.ncols() {
         0 => A::one(),
         1 => a[(0, 0)],
         cols => (0..cols)
diff --git a/tests/triangular.rs b/tests/triangular.rs
@@ -20,7 +20,7 @@ fn test2d<A, Sa, Sb>(uplo: UPLO, a: &ArrayBase<Sa, Ix2>, b: &ArrayBase<Sb, Ix2>,
 where
     A: Scalar + Lapack,
     Sa: Data<Elem = A>,
-    Sb: DataMut<Elem = A> + DataOwned + DataClone,
+    Sb: DataMut<Elem = A> + DataOwned + Data + RawDataClone,
 {
     println!("a = {:?}", a);
     println!("b = {:?}", b);

Original file line number	Diff line number	Diff line change
`@@ -113,14 +113,14 @@ where`
`113`	`113`	`assert!(a.is_square());`
`114`	`114`	`match uplo {`
`115`	`115`	`UPLO::Upper => {`
`116`		`- for row in 0..a.rows() {`
	`116`	`+ for row in 0..a.nrows() {`
`117`	`117`	`for col in 0..row {`
`118`	`118`	`a[(row, col)] = a[(col, row)].conj();`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`	`}`
`122`	`122`	`UPLO::Lower => {`
`123`		`- for col in 0..a.cols() {`
	`123`	`+ for col in 0..a.ncols() {`
`124`	`124`	`for row in 0..col {`
`125`	`125`	`a[(row, col)] = a[(col, row)].conj();`
`126`	`126`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@ use crate::layout::*;`
`8`	`8`	`use crate::operator::LinearOperator;`
`9`	`9`	`use crate::types::*;`
`10`	`10`	`use crate::UPLO;`
	`11`	`+use std::iter::FromIterator;`
`11`	`12`
`12`	`13`	`/// Eigenvalue decomposition of Hermite matrix reference`
`13`	`14`	`pub trait Eigh {`
`@@ -70,7 +71,7 @@ where`
`70`	`71`	`MatrixLayout::F(_) => {}`
`71`	`72`	`}`
`72`	`73`	`let s = unsafe { A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)? };`
`73`		`- Ok((ArrayBase::from_vec(s), self))`
	`74`	`+ Ok((ArrayBase::from(s), self))`
`74`	`75`	`}`
`75`	`76`	`}`
`76`	`77`
`@@ -126,7 +127,7 @@ where`
`126`	`127`
`127`	`128`	`fn eigvalsh_inplace(&mut self, uplo: UPLO) -> Result<Self::EigVal> {`
`128`	`129`	`let s = unsafe { A::eigh(true, self.square_layout()?, uplo, self.as_allocated_mut()?)? };`
`129`		`- Ok(ArrayBase::from_vec(s))`
	`130`	`+ Ok(ArrayBase::from(s))`
`130`	`131`	`}`
`131`	`132`	`}`
`132`	`133`
`@@ -164,7 +165,7 @@ where`
`164`	`165`
`165`	`166`	`fn ssqrt_into(self, uplo: UPLO) -> Result<Self::Output> {`
`166`	`167`	`let (e, v) = self.eigh_into(uplo)?;`
`167`		`- let e_sqrt = Array1::from_iter(e.iter().map(\|r\| Scalar::from_real(r.sqrt())));`
	`168`	`+ let e_sqrt = Array::from_iter(e.iter().map(\|r\| Scalar::from_real(r.sqrt())));`
`168`	`169`	`let ev = e_sqrt.into_diagonal().apply2(&v.t());`
`169`	`170`	`Ok(v.apply2(&ev))`
`170`	`171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ where`
`18`	`18`	`let alpha = -x[0].mul_real(norm / x[0].abs());`
`19`	`19`	`x[0] -= alpha;`
`20`	`20`	`let inv_rev_norm = A::Real::one() / x.norm_l2();`
`21`		`- azip!(mut a(x) in { *a = a.mul_real(inv_rev_norm)});`
	`21`	`+ azip!((a in x) *a = a.mul_real(inv_rev_norm));`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	/// Take a reflection `P = I - 2ww^T`
`@@ -107,7 +107,7 @@ impl<A: Scalar + Lapack> Householder<A> {`
`107`	`107`	`let k = self.len();`
`108`	`108`	`let res = a.slice(s![k..]).norm_l2();`
`109`	`109`	`let mut c = Array1::zeros(k + 1);`
`110`		`- azip!(mut c(c.slice_mut(s![..k])), a(a.slice(s![..k])) in { *c = a });`
	`110`	`+ azip!((c in c.slice_mut(s![..k]), &a in a.slice(s![..k])) *c = a);`
`111`	`111`	`if k < a.len() {`
`112`	`112`	`let ak = a[k];`
`113`	`113`	`c[k] = -ak.mul_real(res / ak.abs());`
`@@ -123,7 +123,7 @@ impl<A: Scalar + Lapack> Householder<A> {`
`123`	`123`	`S: DataMut<Elem = A>,`
`124`	`124`	`{`
`125`	`125`	`let k = self.len();`
`126`		`- azip!(mut a( a.slice_mut(s![..k])) in { *a = A::zero() });`
	`126`	`+ azip!((a in a.slice_mut(s![..k])) *a = A::zero());`
`127`	`127`	`self.backward_reflection(a);`
`128`	`128`	`}`
`129`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ impl<A: Scalar + Lapack> Orthogonalizer for MGS<A> {`
`51`	`51`	`for i in 0..self.len() {`
`52`	`52`	`let q = &self.q[i];`
`53`	`53`	`let c = q.inner(&a);`
`54`		`- azip!(mut a (&mut a), q (q) in { a = a - c q } );`
	`54`	`+ azip!((a in &mut a, &q in q) a = a - c q);`
`55`	`55`	`coef[i] = c;`
`56`	`56`	`}`
`57`	`57`	`let nrm = a.norm_l2();`
`@@ -88,7 +88,7 @@ impl<A: Scalar + Lapack> Orthogonalizer for MGS<A> {`
`88`	`88`	`// Linearly dependent`
`89`	`89`	`return AppendResult::Dependent(coef);`
`90`	`90`	`}`
`91`		`- azip!(mut a(&mut a) in { a = *a / A::from_real(nrm) });`
	`91`	`+ azip!((a in &mut a) a = *a / A::from_real(nrm));`
`92`	`92`	`self.q.push(a.to_owned());`
`93`	`93`	`AppendResult::Added(coef)`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -96,10 +96,10 @@ where`
`96`	`96`	`let shape = self.shape();`
`97`	`97`	`let strides = self.strides();`
`98`	`98`	`if shape[0] == strides[1] as usize {`
`99`		`- return Ok(MatrixLayout::F((self.cols() as i32, self.rows() as i32)));`
	`99`	`+ return Ok(MatrixLayout::F((self.ncols() as i32, self.nrows() as i32)));`
`100`	`100`	`}`
`101`	`101`	`if shape[1] == strides[0] as usize {`
`102`		`- return Ok(MatrixLayout::C((self.rows() as i32, self.cols() as i32)));`
	`102`	`+ return Ok(MatrixLayout::C((self.nrows() as i32, self.ncols() as i32)));`
`103`	`103`	`}`
`104`	`104`	`Err(LinalgError::InvalidStride {`
`105`	`105`	`s0: strides[0],`
`@@ -122,8 +122,8 @@ where`
`122`	`122`	`Ok(())`
`123`	`123`	`} else {`
`124`	`124`	`Err(LinalgError::NotSquare {`
`125`		`- rows: self.rows() as i32,`
`126`		`- cols: self.cols() as i32,`
	`125`	`+ rows: self.nrows() as i32,`
	`126`	`+ cols: self.ncols() as i32,`
`127`	`127`	`})`
`128`	`128`	`}`
`129`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ pub trait LinearOperator {`
`25`	`25`	`S: DataMut<Elem = Self::Elem>,`
`26`	`26`	`{`
`27`	`27`	`let b = self.apply(a);`
`28`		`- azip!(mut a(a), b in { *a = b });`
	`28`	`+ azip!((a in a, &b in &b) *a = b);`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`/// Apply operator with move`