Run: cargo clippy --fix -Z unstable-options and cargo fmt
This commit is contained in:
@@ -46,10 +46,7 @@ pub struct Cholesky<T: RealNumber, M: BaseMatrix<T>> {
|
||||
|
||||
impl<T: RealNumber, M: BaseMatrix<T>> Cholesky<T, M> {
|
||||
pub(crate) fn new(R: M) -> Cholesky<T, M> {
|
||||
Cholesky {
|
||||
R: R,
|
||||
t: PhantomData,
|
||||
}
|
||||
Cholesky { R, t: PhantomData }
|
||||
}
|
||||
|
||||
/// Get lower triangular matrix.
|
||||
@@ -90,7 +87,8 @@ impl<T: RealNumber, M: BaseMatrix<T>> Cholesky<T, M> {
|
||||
if bn != rn {
|
||||
return Err(Failed::because(
|
||||
FailedError::SolutionFailed,
|
||||
&format!("Can't solve Ax = b for x. Number of rows in b != number of rows in R."),
|
||||
&"Can\'t solve Ax = b for x. Number of rows in b != number of rows in R."
|
||||
.to_string(),
|
||||
));
|
||||
}
|
||||
|
||||
@@ -130,7 +128,7 @@ pub trait CholeskyDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
if m != n {
|
||||
return Err(Failed::because(
|
||||
FailedError::DecompositionFailed,
|
||||
&format!("Can't do Cholesky decomposition on a non-square matrix"),
|
||||
&"Can\'t do Cholesky decomposition on a non-square matrix".to_string(),
|
||||
));
|
||||
}
|
||||
|
||||
@@ -143,14 +141,14 @@ pub trait CholeskyDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
}
|
||||
s = (self.get(j, k) - s) / self.get(k, k);
|
||||
self.set(j, k, s);
|
||||
d = d + s * s;
|
||||
d += s * s;
|
||||
}
|
||||
d = self.get(j, j) - d;
|
||||
|
||||
if d < T::zero() {
|
||||
return Err(Failed::because(
|
||||
FailedError::DecompositionFailed,
|
||||
&format!("The matrix is not positive definite."),
|
||||
&"The matrix is not positive definite.".to_string(),
|
||||
));
|
||||
}
|
||||
|
||||
|
||||
+45
-45
@@ -93,7 +93,7 @@ pub trait EVDDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
sort(&mut d, &mut e, &mut V);
|
||||
}
|
||||
|
||||
Ok(EVD { V: V, d: d, e: e })
|
||||
Ok(EVD { V, d, e })
|
||||
}
|
||||
}
|
||||
|
||||
@@ -107,7 +107,7 @@ fn tred2<T: RealNumber, M: BaseMatrix<T>>(V: &mut M, d: &mut Vec<T>, e: &mut Vec
|
||||
let mut scale = T::zero();
|
||||
let mut h = T::zero();
|
||||
for k in 0..i {
|
||||
scale = scale + d[k].abs();
|
||||
scale += d[k].abs();
|
||||
}
|
||||
if scale == T::zero() {
|
||||
e[i] = d[i - 1];
|
||||
@@ -118,8 +118,8 @@ fn tred2<T: RealNumber, M: BaseMatrix<T>>(V: &mut M, d: &mut Vec<T>, e: &mut Vec
|
||||
}
|
||||
} else {
|
||||
for k in 0..i {
|
||||
d[k] = d[k] / scale;
|
||||
h = h + d[k] * d[k];
|
||||
d[k] /= scale;
|
||||
h += d[k] * d[k];
|
||||
}
|
||||
let mut f = d[i - 1];
|
||||
let mut g = h.sqrt();
|
||||
@@ -127,7 +127,7 @@ fn tred2<T: RealNumber, M: BaseMatrix<T>>(V: &mut M, d: &mut Vec<T>, e: &mut Vec
|
||||
g = -g;
|
||||
}
|
||||
e[i] = scale * g;
|
||||
h = h - f * g;
|
||||
h -= f * g;
|
||||
d[i - 1] = f - g;
|
||||
for j in 0..i {
|
||||
e[j] = T::zero();
|
||||
@@ -138,19 +138,19 @@ fn tred2<T: RealNumber, M: BaseMatrix<T>>(V: &mut M, d: &mut Vec<T>, e: &mut Vec
|
||||
V.set(j, i, f);
|
||||
g = e[j] + V.get(j, j) * f;
|
||||
for k in j + 1..=i - 1 {
|
||||
g = g + V.get(k, j) * d[k];
|
||||
e[k] = e[k] + V.get(k, j) * f;
|
||||
g += V.get(k, j) * d[k];
|
||||
e[k] += V.get(k, j) * f;
|
||||
}
|
||||
e[j] = g;
|
||||
}
|
||||
f = T::zero();
|
||||
for j in 0..i {
|
||||
e[j] = e[j] / h;
|
||||
f = f + e[j] * d[j];
|
||||
e[j] /= h;
|
||||
f += e[j] * d[j];
|
||||
}
|
||||
let hh = f / (h + h);
|
||||
for j in 0..i {
|
||||
e[j] = e[j] - hh * d[j];
|
||||
e[j] -= hh * d[j];
|
||||
}
|
||||
for j in 0..i {
|
||||
f = d[j];
|
||||
@@ -176,7 +176,7 @@ fn tred2<T: RealNumber, M: BaseMatrix<T>>(V: &mut M, d: &mut Vec<T>, e: &mut Vec
|
||||
for j in 0..=i {
|
||||
let mut g = T::zero();
|
||||
for k in 0..=i {
|
||||
g = g + V.get(k, i + 1) * V.get(k, j);
|
||||
g += V.get(k, i + 1) * V.get(k, j);
|
||||
}
|
||||
for k in 0..=i {
|
||||
V.sub_element_mut(k, j, g * d[k]);
|
||||
@@ -239,9 +239,9 @@ fn tql2<T: RealNumber, M: BaseMatrix<T>>(V: &mut M, d: &mut Vec<T>, e: &mut Vec<
|
||||
let dl1 = d[l + 1];
|
||||
let mut h = g - d[l];
|
||||
for i in l + 2..n {
|
||||
d[i] = d[i] - h;
|
||||
d[i] -= h;
|
||||
}
|
||||
f = f + h;
|
||||
f += h;
|
||||
|
||||
p = d[m];
|
||||
let mut c = T::one();
|
||||
@@ -278,7 +278,7 @@ fn tql2<T: RealNumber, M: BaseMatrix<T>>(V: &mut M, d: &mut Vec<T>, e: &mut Vec<
|
||||
}
|
||||
}
|
||||
}
|
||||
d[l] = d[l] + f;
|
||||
d[l] += f;
|
||||
e[l] = T::zero();
|
||||
}
|
||||
|
||||
@@ -321,8 +321,8 @@ fn balance<T: RealNumber, M: BaseMatrix<T>>(A: &mut M) -> Vec<T> {
|
||||
let mut c = T::zero();
|
||||
for j in 0..n {
|
||||
if j != i {
|
||||
c = c + A.get(j, i).abs();
|
||||
r = r + A.get(i, j).abs();
|
||||
c += A.get(j, i).abs();
|
||||
r += A.get(i, j).abs();
|
||||
}
|
||||
}
|
||||
if c != T::zero() && r != T::zero() {
|
||||
@@ -330,18 +330,18 @@ fn balance<T: RealNumber, M: BaseMatrix<T>>(A: &mut M) -> Vec<T> {
|
||||
let mut f = T::one();
|
||||
let s = c + r;
|
||||
while c < g {
|
||||
f = f * radix;
|
||||
c = c * sqrdx;
|
||||
f *= radix;
|
||||
c *= sqrdx;
|
||||
}
|
||||
g = r * radix;
|
||||
while c > g {
|
||||
f = f / radix;
|
||||
c = c / sqrdx;
|
||||
f /= radix;
|
||||
c /= sqrdx;
|
||||
}
|
||||
if (c + r) / f < t * s {
|
||||
done = false;
|
||||
g = T::one() / f;
|
||||
scale[i] = scale[i] * f;
|
||||
scale[i] *= f;
|
||||
for j in 0..n {
|
||||
A.mul_element_mut(i, j, g);
|
||||
}
|
||||
@@ -353,7 +353,7 @@ fn balance<T: RealNumber, M: BaseMatrix<T>>(A: &mut M) -> Vec<T> {
|
||||
}
|
||||
}
|
||||
|
||||
return scale;
|
||||
scale
|
||||
}
|
||||
|
||||
fn elmhes<T: RealNumber, M: BaseMatrix<T>>(A: &mut M) -> Vec<usize> {
|
||||
@@ -386,7 +386,7 @@ fn elmhes<T: RealNumber, M: BaseMatrix<T>>(A: &mut M) -> Vec<usize> {
|
||||
for i in (m + 1)..n {
|
||||
let mut y = A.get(i, m - 1);
|
||||
if y != T::zero() {
|
||||
y = y / x;
|
||||
y /= x;
|
||||
A.set(i, m - 1, y);
|
||||
for j in m..n {
|
||||
A.sub_element_mut(i, j, y * A.get(m, j));
|
||||
@@ -399,7 +399,7 @@ fn elmhes<T: RealNumber, M: BaseMatrix<T>>(A: &mut M) -> Vec<usize> {
|
||||
}
|
||||
}
|
||||
|
||||
return perm;
|
||||
perm
|
||||
}
|
||||
|
||||
fn eltran<T: RealNumber, M: BaseMatrix<T>>(A: &M, V: &mut M, perm: &Vec<usize>) {
|
||||
@@ -430,7 +430,7 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
|
||||
for i in 0..n {
|
||||
for j in i32::max(i as i32 - 1, 0)..n as i32 {
|
||||
anorm = anorm + A.get(i, j as usize).abs();
|
||||
anorm += A.get(i, j as usize).abs();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -467,7 +467,7 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
p = T::half() * (y - x);
|
||||
q = p * p + w;
|
||||
z = q.abs().sqrt();
|
||||
x = x + t;
|
||||
x += t;
|
||||
A.set(nn, nn, x);
|
||||
A.set(nn - 1, nn - 1, y + t);
|
||||
if q >= T::zero() {
|
||||
@@ -482,8 +482,8 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
p = x / s;
|
||||
q = z / s;
|
||||
r = (p * p + q * q).sqrt();
|
||||
p = p / r;
|
||||
q = q / r;
|
||||
p /= r;
|
||||
q /= r;
|
||||
for j in nn - 1..n {
|
||||
z = A.get(nn - 1, j);
|
||||
A.set(nn - 1, j, q * z + p * A.get(nn, j));
|
||||
@@ -516,7 +516,7 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
panic!("Too many iterations in hqr");
|
||||
}
|
||||
if its == 10 || its == 20 {
|
||||
t = t + x;
|
||||
t += x;
|
||||
for i in 0..nn + 1 {
|
||||
A.sub_element_mut(i, i, x);
|
||||
}
|
||||
@@ -535,9 +535,9 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
q = A.get(m + 1, m + 1) - z - r - s;
|
||||
r = A.get(m + 2, m + 1);
|
||||
s = p.abs() + q.abs() + r.abs();
|
||||
p = p / s;
|
||||
q = q / s;
|
||||
r = r / s;
|
||||
p /= s;
|
||||
q /= s;
|
||||
r /= s;
|
||||
if m == l {
|
||||
break;
|
||||
}
|
||||
@@ -565,9 +565,9 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
}
|
||||
x = p.abs() + q.abs() + r.abs();
|
||||
if x != T::zero() {
|
||||
p = p / x;
|
||||
q = q / x;
|
||||
r = r / x;
|
||||
p /= x;
|
||||
q /= x;
|
||||
r /= x;
|
||||
}
|
||||
}
|
||||
let s = (p * p + q * q + r * r).sqrt().copysign(p);
|
||||
@@ -579,16 +579,16 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
} else {
|
||||
A.set(k, k - 1, -s * x);
|
||||
}
|
||||
p = p + s;
|
||||
p += s;
|
||||
x = p / s;
|
||||
y = q / s;
|
||||
z = r / s;
|
||||
q = q / p;
|
||||
r = r / p;
|
||||
q /= p;
|
||||
r /= p;
|
||||
for j in k..n {
|
||||
p = A.get(k, j) + q * A.get(k + 1, j);
|
||||
if k + 1 != nn {
|
||||
p = p + r * A.get(k + 2, j);
|
||||
p += r * A.get(k + 2, j);
|
||||
A.sub_element_mut(k + 2, j, p * z);
|
||||
}
|
||||
A.sub_element_mut(k + 1, j, p * y);
|
||||
@@ -603,7 +603,7 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
for i in 0..mmin + 1 {
|
||||
p = x * A.get(i, k) + y * A.get(i, k + 1);
|
||||
if k + 1 != nn {
|
||||
p = p + z * A.get(i, k + 2);
|
||||
p += z * A.get(i, k + 2);
|
||||
A.sub_element_mut(i, k + 2, p * r);
|
||||
}
|
||||
A.sub_element_mut(i, k + 1, p * q);
|
||||
@@ -612,7 +612,7 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
for i in 0..n {
|
||||
p = x * V.get(i, k) + y * V.get(i, k + 1);
|
||||
if k + 1 != nn {
|
||||
p = p + z * V.get(i, k + 2);
|
||||
p += z * V.get(i, k + 2);
|
||||
V.sub_element_mut(i, k + 2, p * r);
|
||||
}
|
||||
V.sub_element_mut(i, k + 1, p * q);
|
||||
@@ -642,7 +642,7 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
let w = A.get(i, i) - p;
|
||||
r = T::zero();
|
||||
for j in m..=nn {
|
||||
r = r + A.get(i, j) * A.get(j, nn);
|
||||
r += A.get(i, j) * A.get(j, nn);
|
||||
}
|
||||
if e[i] < T::zero() {
|
||||
z = w;
|
||||
@@ -701,8 +701,8 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
let mut ra = T::zero();
|
||||
let mut sa = T::zero();
|
||||
for j in m..=nn {
|
||||
ra = ra + A.get(i, j) * A.get(j, na);
|
||||
sa = sa + A.get(i, j) * A.get(j, nn);
|
||||
ra += A.get(i, j) * A.get(j, na);
|
||||
sa += A.get(i, j) * A.get(j, nn);
|
||||
}
|
||||
if e[i] < T::zero() {
|
||||
z = w;
|
||||
@@ -766,7 +766,7 @@ fn hqr2<T: RealNumber, M: BaseMatrix<T>>(A: &mut M, V: &mut M, d: &mut Vec<T>, e
|
||||
for i in 0..n {
|
||||
z = T::zero();
|
||||
for k in 0..=j {
|
||||
z = z + V.get(i, k) * A.get(k, j);
|
||||
z += V.get(i, k) * A.get(k, j);
|
||||
}
|
||||
V.set(i, j, z);
|
||||
}
|
||||
|
||||
+7
-9
@@ -63,10 +63,10 @@ impl<T: RealNumber, M: BaseMatrix<T>> LU<T, M> {
|
||||
}
|
||||
|
||||
LU {
|
||||
LU: LU,
|
||||
pivot: pivot,
|
||||
pivot_sign: pivot_sign,
|
||||
singular: singular,
|
||||
LU,
|
||||
pivot,
|
||||
pivot_sign,
|
||||
singular,
|
||||
phantom: PhantomData,
|
||||
}
|
||||
}
|
||||
@@ -220,10 +220,10 @@ pub trait LUDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
let kmax = usize::min(i, j);
|
||||
let mut s = T::zero();
|
||||
for k in 0..kmax {
|
||||
s = s + self.get(i, k) * LUcolj[k];
|
||||
s += self.get(i, k) * LUcolj[k];
|
||||
}
|
||||
|
||||
LUcolj[i] = LUcolj[i] - s;
|
||||
LUcolj[i] -= s;
|
||||
self.set(i, j, LUcolj[i]);
|
||||
}
|
||||
|
||||
@@ -239,9 +239,7 @@ pub trait LUDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
self.set(p, k, self.get(j, k));
|
||||
self.set(j, k, t);
|
||||
}
|
||||
let k = piv[p];
|
||||
piv[p] = piv[j];
|
||||
piv[j] = k;
|
||||
piv.swap(p, j);
|
||||
pivsign = -pivsign;
|
||||
}
|
||||
|
||||
|
||||
+1
-1
@@ -517,7 +517,7 @@ pub trait Matrix<T: RealNumber>:
|
||||
|
||||
pub(crate) fn row_iter<F: RealNumber, M: BaseMatrix<F>>(m: &M) -> RowIter<F, M> {
|
||||
RowIter {
|
||||
m: m,
|
||||
m,
|
||||
pos: 0,
|
||||
max_pos: m.shape().0,
|
||||
phantom: PhantomData,
|
||||
|
||||
@@ -53,7 +53,7 @@ impl<T: RealNumber> BaseVector<T> for Vec<T> {
|
||||
|
||||
let mut result = T::zero();
|
||||
for i in 0..self.len() {
|
||||
result = result + self[i] * other[i];
|
||||
result += self[i] * other[i];
|
||||
}
|
||||
|
||||
result
|
||||
@@ -63,7 +63,7 @@ impl<T: RealNumber> BaseVector<T> for Vec<T> {
|
||||
let mut norm = T::zero();
|
||||
|
||||
for xi in self.iter() {
|
||||
norm = norm + *xi * *xi;
|
||||
norm += *xi * *xi;
|
||||
}
|
||||
|
||||
norm.sqrt()
|
||||
@@ -82,7 +82,7 @@ impl<T: RealNumber> BaseVector<T> for Vec<T> {
|
||||
let mut norm = T::zero();
|
||||
|
||||
for xi in self.iter() {
|
||||
norm = norm + xi.abs().powf(p);
|
||||
norm += xi.abs().powf(p);
|
||||
}
|
||||
|
||||
norm.powf(T::one() / p)
|
||||
@@ -90,19 +90,19 @@ impl<T: RealNumber> BaseVector<T> for Vec<T> {
|
||||
}
|
||||
|
||||
fn div_element_mut(&mut self, pos: usize, x: T) {
|
||||
self[pos] = self[pos] / x;
|
||||
self[pos] /= x;
|
||||
}
|
||||
|
||||
fn mul_element_mut(&mut self, pos: usize, x: T) {
|
||||
self[pos] = self[pos] * x;
|
||||
self[pos] *= x;
|
||||
}
|
||||
|
||||
fn add_element_mut(&mut self, pos: usize, x: T) {
|
||||
self[pos] = self[pos] + x
|
||||
self[pos] += x
|
||||
}
|
||||
|
||||
fn sub_element_mut(&mut self, pos: usize, x: T) {
|
||||
self[pos] = self[pos] - x;
|
||||
self[pos] -= x;
|
||||
}
|
||||
|
||||
fn add_mut(&mut self, other: &Self) -> &Self {
|
||||
@@ -165,7 +165,7 @@ impl<T: RealNumber> BaseVector<T> for Vec<T> {
|
||||
fn sum(&self) -> T {
|
||||
let mut sum = T::zero();
|
||||
for i in 0..self.len() {
|
||||
sum = sum + self[i];
|
||||
sum += self[i];
|
||||
}
|
||||
sum
|
||||
}
|
||||
@@ -216,15 +216,15 @@ impl<T: RealNumber> DenseMatrix<T> {
|
||||
/// `values` should be in column-major order.
|
||||
pub fn new(nrows: usize, ncols: usize, values: Vec<T>) -> Self {
|
||||
DenseMatrix {
|
||||
ncols: ncols,
|
||||
nrows: nrows,
|
||||
values: values,
|
||||
ncols,
|
||||
nrows,
|
||||
values,
|
||||
}
|
||||
}
|
||||
|
||||
/// New instance of `DenseMatrix` from 2d array.
|
||||
pub fn from_2d_array(values: &[&[T]]) -> Self {
|
||||
DenseMatrix::from_2d_vec(&values.into_iter().map(|row| Vec::from(*row)).collect())
|
||||
DenseMatrix::from_2d_vec(&values.iter().map(|row| Vec::from(*row)).collect())
|
||||
}
|
||||
|
||||
/// New instance of `DenseMatrix` from 2d vector.
|
||||
@@ -235,8 +235,8 @@ impl<T: RealNumber> DenseMatrix<T> {
|
||||
.unwrap_or_else(|| panic!("Cannot create 2d matrix from an empty vector"))
|
||||
.len();
|
||||
let mut m = DenseMatrix {
|
||||
ncols: ncols,
|
||||
nrows: nrows,
|
||||
ncols,
|
||||
nrows,
|
||||
values: vec![T::zero(); ncols * nrows],
|
||||
};
|
||||
for row in 0..nrows {
|
||||
@@ -261,8 +261,8 @@ impl<T: RealNumber> DenseMatrix<T> {
|
||||
/// * `values` - values to initialize the matrix.
|
||||
pub fn from_vec(nrows: usize, ncols: usize, values: &Vec<T>) -> DenseMatrix<T> {
|
||||
let mut m = DenseMatrix {
|
||||
ncols: ncols,
|
||||
nrows: nrows,
|
||||
ncols,
|
||||
nrows,
|
||||
values: vec![T::zero(); ncols * nrows],
|
||||
};
|
||||
for row in 0..nrows {
|
||||
@@ -285,7 +285,7 @@ impl<T: RealNumber> DenseMatrix<T> {
|
||||
DenseMatrix {
|
||||
ncols: values.len(),
|
||||
nrows: 1,
|
||||
values: values,
|
||||
values,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -301,7 +301,7 @@ impl<T: RealNumber> DenseMatrix<T> {
|
||||
DenseMatrix {
|
||||
ncols: 1,
|
||||
nrows: values.len(),
|
||||
values: values,
|
||||
values,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -412,7 +412,7 @@ impl<'de, T: RealNumber + fmt::Debug + Deserialize<'de>> Deserialize<'de> for De
|
||||
}
|
||||
}
|
||||
|
||||
const FIELDS: &'static [&'static str] = &["nrows", "ncols", "values"];
|
||||
const FIELDS: &[&str] = &["nrows", "ncols", "values"];
|
||||
deserializer.deserialize_struct(
|
||||
"DenseMatrix",
|
||||
FIELDS,
|
||||
@@ -562,7 +562,7 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
|
||||
matrix.set(i, i, T::one());
|
||||
}
|
||||
|
||||
return matrix;
|
||||
matrix
|
||||
}
|
||||
|
||||
fn shape(&self) -> (usize, usize) {
|
||||
@@ -614,7 +614,7 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
|
||||
for c in 0..other.ncols {
|
||||
let mut s = T::zero();
|
||||
for i in 0..inner_d {
|
||||
s = s + self.get(r, i) * other.get(i, c);
|
||||
s += self.get(r, i) * other.get(i, c);
|
||||
}
|
||||
result.set(r, c, s);
|
||||
}
|
||||
@@ -633,7 +633,7 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
|
||||
|
||||
let mut result = T::zero();
|
||||
for i in 0..(self.nrows * self.ncols) {
|
||||
result = result + self.values[i] * other.values[i];
|
||||
result += self.values[i] * other.values[i];
|
||||
}
|
||||
|
||||
result
|
||||
@@ -727,19 +727,19 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
|
||||
}
|
||||
|
||||
fn div_element_mut(&mut self, row: usize, col: usize, x: T) {
|
||||
self.values[col * self.nrows + row] = self.values[col * self.nrows + row] / x;
|
||||
self.values[col * self.nrows + row] /= x;
|
||||
}
|
||||
|
||||
fn mul_element_mut(&mut self, row: usize, col: usize, x: T) {
|
||||
self.values[col * self.nrows + row] = self.values[col * self.nrows + row] * x;
|
||||
self.values[col * self.nrows + row] *= x;
|
||||
}
|
||||
|
||||
fn add_element_mut(&mut self, row: usize, col: usize, x: T) {
|
||||
self.values[col * self.nrows + row] = self.values[col * self.nrows + row] + x
|
||||
self.values[col * self.nrows + row] += x
|
||||
}
|
||||
|
||||
fn sub_element_mut(&mut self, row: usize, col: usize, x: T) {
|
||||
self.values[col * self.nrows + row] = self.values[col * self.nrows + row] - x;
|
||||
self.values[col * self.nrows + row] -= x;
|
||||
}
|
||||
|
||||
fn transpose(&self) -> Self {
|
||||
@@ -759,9 +759,9 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
|
||||
fn rand(nrows: usize, ncols: usize) -> Self {
|
||||
let values: Vec<T> = (0..nrows * ncols).map(|_| T::rand()).collect();
|
||||
DenseMatrix {
|
||||
ncols: ncols,
|
||||
nrows: nrows,
|
||||
values: values,
|
||||
ncols,
|
||||
nrows,
|
||||
values,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -769,7 +769,7 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
|
||||
let mut norm = T::zero();
|
||||
|
||||
for xi in self.values.iter() {
|
||||
norm = norm + *xi * *xi;
|
||||
norm += *xi * *xi;
|
||||
}
|
||||
|
||||
norm.sqrt()
|
||||
@@ -790,7 +790,7 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
|
||||
let mut norm = T::zero();
|
||||
|
||||
for xi in self.values.iter() {
|
||||
norm = norm + xi.abs().powf(p);
|
||||
norm += xi.abs().powf(p);
|
||||
}
|
||||
|
||||
norm.powf(T::one() / p)
|
||||
@@ -802,12 +802,12 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
|
||||
|
||||
for r in 0..self.nrows {
|
||||
for c in 0..self.ncols {
|
||||
mean[c] = mean[c] + self.get(r, c);
|
||||
mean[c] += self.get(r, c);
|
||||
}
|
||||
}
|
||||
|
||||
for i in 0..mean.len() {
|
||||
mean[i] = mean[i] / T::from(self.nrows).unwrap();
|
||||
mean[i] /= T::from(self.nrows).unwrap();
|
||||
}
|
||||
|
||||
mean
|
||||
@@ -815,28 +815,28 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
|
||||
|
||||
fn add_scalar_mut(&mut self, scalar: T) -> &Self {
|
||||
for i in 0..self.values.len() {
|
||||
self.values[i] = self.values[i] + scalar;
|
||||
self.values[i] += scalar;
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
fn sub_scalar_mut(&mut self, scalar: T) -> &Self {
|
||||
for i in 0..self.values.len() {
|
||||
self.values[i] = self.values[i] - scalar;
|
||||
self.values[i] -= scalar;
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
fn mul_scalar_mut(&mut self, scalar: T) -> &Self {
|
||||
for i in 0..self.values.len() {
|
||||
self.values[i] = self.values[i] * scalar;
|
||||
self.values[i] *= scalar;
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
fn div_scalar_mut(&mut self, scalar: T) -> &Self {
|
||||
for i in 0..self.values.len() {
|
||||
self.values[i] = self.values[i] / scalar;
|
||||
self.values[i] /= scalar;
|
||||
}
|
||||
self
|
||||
}
|
||||
@@ -902,7 +902,7 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
|
||||
fn sum(&self) -> T {
|
||||
let mut sum = T::zero();
|
||||
for i in 0..self.values.len() {
|
||||
sum = sum + self.values[i];
|
||||
sum += self.values[i];
|
||||
}
|
||||
sum
|
||||
}
|
||||
@@ -934,7 +934,7 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
|
||||
for c in 0..self.ncols {
|
||||
let p = (self.get(r, c) - max).exp();
|
||||
self.set(r, c, p);
|
||||
z = z + p;
|
||||
z += p;
|
||||
}
|
||||
}
|
||||
for r in 0..self.nrows {
|
||||
@@ -1058,7 +1058,7 @@ mod tests {
|
||||
DenseMatrix::new(1, 3, vec![1., 2., 3.])
|
||||
);
|
||||
assert_eq!(
|
||||
DenseMatrix::from_row_vector(vec.clone()).to_row_vector(),
|
||||
DenseMatrix::from_row_vector(vec).to_row_vector(),
|
||||
vec![1., 2., 3.]
|
||||
);
|
||||
}
|
||||
|
||||
+6
-10
@@ -51,11 +51,7 @@ impl<T: RealNumber, M: BaseMatrix<T>> QR<T, M> {
|
||||
}
|
||||
}
|
||||
|
||||
QR {
|
||||
QR: QR,
|
||||
tau: tau,
|
||||
singular: singular,
|
||||
}
|
||||
QR { QR, tau, singular }
|
||||
}
|
||||
|
||||
/// Get upper triangular matrix.
|
||||
@@ -68,7 +64,7 @@ impl<T: RealNumber, M: BaseMatrix<T>> QR<T, M> {
|
||||
R.set(i, j, self.QR.get(i, j));
|
||||
}
|
||||
}
|
||||
return R;
|
||||
R
|
||||
}
|
||||
|
||||
/// Get an orthogonal matrix.
|
||||
@@ -82,7 +78,7 @@ impl<T: RealNumber, M: BaseMatrix<T>> QR<T, M> {
|
||||
if self.QR.get(k, k) != T::zero() {
|
||||
let mut s = T::zero();
|
||||
for i in k..m {
|
||||
s = s + self.QR.get(i, k) * Q.get(i, j);
|
||||
s += self.QR.get(i, k) * Q.get(i, j);
|
||||
}
|
||||
s = -s / self.QR.get(k, k);
|
||||
for i in k..m {
|
||||
@@ -96,7 +92,7 @@ impl<T: RealNumber, M: BaseMatrix<T>> QR<T, M> {
|
||||
k -= 1;
|
||||
}
|
||||
}
|
||||
return Q;
|
||||
Q
|
||||
}
|
||||
|
||||
fn solve(&self, mut b: M) -> Result<M, Failed> {
|
||||
@@ -118,7 +114,7 @@ impl<T: RealNumber, M: BaseMatrix<T>> QR<T, M> {
|
||||
for j in 0..b_ncols {
|
||||
let mut s = T::zero();
|
||||
for i in k..m {
|
||||
s = s + self.QR.get(i, k) * b.get(i, j);
|
||||
s += self.QR.get(i, k) * b.get(i, j);
|
||||
}
|
||||
s = -s / self.QR.get(k, k);
|
||||
for i in k..m {
|
||||
@@ -175,7 +171,7 @@ pub trait QRDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
for j in k + 1..n {
|
||||
let mut s = T::zero();
|
||||
for i in k..m {
|
||||
s = s + self.get(i, k) * self.get(i, j);
|
||||
s += self.get(i, k) * self.get(i, j);
|
||||
}
|
||||
s = -s / self.get(k, k);
|
||||
for i in k..m {
|
||||
|
||||
+20
-20
@@ -106,13 +106,13 @@ pub trait SVDDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
|
||||
if i < m {
|
||||
for k in i..m {
|
||||
scale = scale + U.get(k, i).abs();
|
||||
scale += U.get(k, i).abs();
|
||||
}
|
||||
|
||||
if scale.abs() > T::epsilon() {
|
||||
for k in i..m {
|
||||
U.div_element_mut(k, i, scale);
|
||||
s = s + U.get(k, i) * U.get(k, i);
|
||||
s += U.get(k, i) * U.get(k, i);
|
||||
}
|
||||
|
||||
let mut f = U.get(i, i);
|
||||
@@ -122,7 +122,7 @@ pub trait SVDDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
for j in l - 1..n {
|
||||
s = T::zero();
|
||||
for k in i..m {
|
||||
s = s + U.get(k, i) * U.get(k, j);
|
||||
s += U.get(k, i) * U.get(k, j);
|
||||
}
|
||||
f = s / h;
|
||||
for k in i..m {
|
||||
@@ -140,15 +140,15 @@ pub trait SVDDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
let mut s = T::zero();
|
||||
scale = T::zero();
|
||||
|
||||
if i + 1 <= m && i + 1 != n {
|
||||
if i < m && i + 1 != n {
|
||||
for k in l - 1..n {
|
||||
scale = scale + U.get(i, k).abs();
|
||||
scale += U.get(i, k).abs();
|
||||
}
|
||||
|
||||
if scale.abs() > T::epsilon() {
|
||||
for k in l - 1..n {
|
||||
U.div_element_mut(i, k, scale);
|
||||
s = s + U.get(i, k) * U.get(i, k);
|
||||
s += U.get(i, k) * U.get(i, k);
|
||||
}
|
||||
|
||||
let f = U.get(i, l - 1);
|
||||
@@ -163,7 +163,7 @@ pub trait SVDDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
for j in l - 1..m {
|
||||
s = T::zero();
|
||||
for k in l - 1..n {
|
||||
s = s + U.get(j, k) * U.get(i, k);
|
||||
s += U.get(j, k) * U.get(i, k);
|
||||
}
|
||||
|
||||
for k in l - 1..n {
|
||||
@@ -189,7 +189,7 @@ pub trait SVDDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
for j in l..n {
|
||||
let mut s = T::zero();
|
||||
for k in l..n {
|
||||
s = s + U.get(i, k) * v.get(k, j);
|
||||
s += U.get(i, k) * v.get(k, j);
|
||||
}
|
||||
for k in l..n {
|
||||
v.add_element_mut(k, j, s * v.get(k, i));
|
||||
@@ -218,7 +218,7 @@ pub trait SVDDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
for j in l..n {
|
||||
let mut s = T::zero();
|
||||
for k in l..m {
|
||||
s = s + U.get(k, i) * U.get(k, j);
|
||||
s += U.get(k, i) * U.get(k, j);
|
||||
}
|
||||
let f = (s / U.get(i, i)) * g;
|
||||
for k in i..m {
|
||||
@@ -316,7 +316,7 @@ pub trait SVDDecomposableMatrix<T: RealNumber>: BaseMatrix<T> {
|
||||
f = x * c + g * s;
|
||||
g = g * c - x * s;
|
||||
h = y * s;
|
||||
y = y * c;
|
||||
y *= c;
|
||||
|
||||
for jj in 0..n {
|
||||
x = v.get(jj, j);
|
||||
@@ -431,13 +431,13 @@ impl<T: RealNumber, M: SVDDecomposableMatrix<T>> SVD<T, M> {
|
||||
let full = s.len() == m.min(n);
|
||||
let tol = T::half() * (T::from(m + n).unwrap() + T::one()).sqrt() * s[0] * T::epsilon();
|
||||
SVD {
|
||||
U: U,
|
||||
V: V,
|
||||
s: s,
|
||||
full: full,
|
||||
m: m,
|
||||
n: n,
|
||||
tol: tol,
|
||||
U,
|
||||
V,
|
||||
s,
|
||||
full,
|
||||
m,
|
||||
n,
|
||||
tol,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -458,9 +458,9 @@ impl<T: RealNumber, M: SVDDecomposableMatrix<T>> SVD<T, M> {
|
||||
let mut r = T::zero();
|
||||
if self.s[j] > self.tol {
|
||||
for i in 0..self.m {
|
||||
r = r + self.U.get(i, j) * b.get(i, k);
|
||||
r += self.U.get(i, j) * b.get(i, k);
|
||||
}
|
||||
r = r / self.s[j];
|
||||
r /= self.s[j];
|
||||
}
|
||||
tmp[j] = r;
|
||||
}
|
||||
@@ -468,7 +468,7 @@ impl<T: RealNumber, M: SVDDecomposableMatrix<T>> SVD<T, M> {
|
||||
for j in 0..self.n {
|
||||
let mut r = T::zero();
|
||||
for jj in 0..self.n {
|
||||
r = r + self.V.get(j, jj) * tmp[jj];
|
||||
r += self.V.get(j, jj) * tmp[jj];
|
||||
}
|
||||
b.set(j, k, r);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user