work/smartcore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: cargo fmt

Browse Source
This commit is contained in:
Volodymyr Orlov
2020-06-05 17:52:03 -07:00
parent 685be04488
commit a2784d6345
52 changed files with 3342 additions and 2829 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/linalg/nalgebra_bindings.rs
+185 -217
View File
@@ -1,38 +1,39 @@
use std::ops::{Range, AddAssign, SubAssign, MulAssign, DivAssign};
use std::iter::Sum;
use std::ops::{AddAssign, DivAssign, MulAssign, Range, SubAssign};
use nalgebra::{MatrixMN, DMatrix, Matrix, Scalar, Dynamic, U1, VecStorage};
use nalgebra::{DMatrix, Dynamic, Matrix, MatrixMN, Scalar, VecStorage, U1};
use crate::math::num::FloatExt;
use crate::linalg::{BaseMatrix, BaseVector};
use crate::linalg::Matrix as SmartCoreMatrix;
use crate::linalg::svd::SVDDecomposableMatrix;
use crate::linalg::evd::EVDDecomposableMatrix;
use crate::linalg::qr::QRDecomposableMatrix;
use crate::linalg::lu::LUDecomposableMatrix;
use crate::linalg::qr::QRDecomposableMatrix;
use crate::linalg::svd::SVDDecomposableMatrix;
use crate::linalg::Matrix as SmartCoreMatrix;
use crate::linalg::{BaseMatrix, BaseVector};
use crate::math::num::FloatExt;
impl<T: FloatExt + 'static> BaseVector<T> for MatrixMN<T, U1, Dynamic> {
fn get(&self, i: usize) -> T {
*self.get((0, i)).unwrap()
}
fn set(&mut self, i: usize, x: T){
fn set(&mut self, i: usize, x: T) {
*self.get_mut((0, i)).unwrap() = x;
}
fn len(&self) -> usize{
fn len(&self) -> usize {
self.len()
}
}
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static> BaseMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static>
BaseMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>
{
type RowVector = MatrixMN<T, U1, Dynamic>;
fn from_row_vector(vec: Self::RowVector) -> Self{
fn from_row_vector(vec: Self::RowVector) -> Self {
Matrix::from_rows(&[vec])
}
fn to_row_vector(self) -> Self::RowVector{
fn to_row_vector(self) -> Self::RowVector {
self.row(0).into_owned()
}
@@ -50,13 +51,13 @@ impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum
fn set(&mut self, row: usize, col: usize, x: T) {
*self.get_mut((row, col)).unwrap() = x;
}
}
fn eye(size: usize) -> Self {
DMatrix::identity(size, size)
}
fn zeros(nrows: usize, ncols: usize) -> Self {
fn zeros(nrows: usize, ncols: usize) -> Self {
DMatrix::zeros(nrows, ncols)
}
@@ -70,7 +71,7 @@ impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum
for (i, row) in self.row_iter().enumerate() {
for (j, v) in row.iter().enumerate() {
result[i * ncols + j] = *v;
}
}
}
result
}
@@ -83,25 +84,25 @@ impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum
fn shape(&self) -> (usize, usize) {
self.shape()
}
}
fn v_stack(&self, other: &Self) -> Self {
let mut columns = Vec::new();
for r in 0..self.ncols(){
fn v_stack(&self, other: &Self) -> Self {
let mut columns = Vec::new();
for r in 0..self.ncols() {
columns.push(self.column(r));
}
for r in 0..other.ncols(){
for r in 0..other.ncols() {
columns.push(other.column(r));
}
Matrix::from_columns(&columns)
}
fn h_stack(&self, other: &Self) -> Self {
let mut rows = Vec::new();
for r in 0..self.nrows(){
let mut rows = Vec::new();
for r in 0..self.nrows() {
rows.push(self.row(r));
}
for r in 0..other.nrows(){
for r in 0..other.nrows() {
rows.push(other.row(r));
}
Matrix::from_rows(&rows)
@@ -109,11 +110,11 @@ impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum
fn dot(&self, other: &Self) -> Self {
self * other
}
}
fn vector_dot(&self, other: &Self) -> T {
self.dot(other)
}
}
fn slice(&self, rows: Range<usize>, cols: Range<usize>) -> Self {
self.slice_range(rows, cols).into_owned()
@@ -141,46 +142,44 @@ impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum
self
}
fn div_mut(&mut self, other: &Self) -> &Self{
fn div_mut(&mut self, other: &Self) -> &Self {
self.component_div_assign(other);
self
}
fn add_scalar_mut(&mut self, scalar: T) -> &Self{
fn add_scalar_mut(&mut self, scalar: T) -> &Self {
Matrix::add_scalar_mut(self, scalar);
self
}
fn sub_scalar_mut(&mut self, scalar: T) -> &Self{
fn sub_scalar_mut(&mut self, scalar: T) -> &Self {
Matrix::add_scalar_mut(self, -scalar);
self
}
fn mul_scalar_mut(&mut self, scalar: T) -> &Self{
fn mul_scalar_mut(&mut self, scalar: T) -> &Self {
*self *= scalar;
self
}
fn div_scalar_mut(&mut self, scalar: T) -> &Self{
fn div_scalar_mut(&mut self, scalar: T) -> &Self {
*self /= scalar;
self
}
fn transpose(&self) -> Self{
fn transpose(&self) -> Self {
self.transpose()
}
fn rand(nrows: usize, ncols: usize) -> Self{
DMatrix::from_iterator(nrows, ncols, (0..nrows*ncols).map(|_| {
T::rand()
}))
fn rand(nrows: usize, ncols: usize) -> Self {
DMatrix::from_iterator(nrows, ncols, (0..nrows * ncols).map(|_| T::rand()))
}
fn norm2(&self) -> T{
fn norm2(&self) -> T {
self.iter().map(|x| *x * *x).sum::<T>().sqrt()
}
fn norm(&self, p:T) -> T {
fn norm(&self, p: T) -> T {
if p.is_infinite() && p.is_sign_positive() {
self.iter().fold(T::neg_infinity(), |f, &val| {
let v = val.abs();
@@ -189,7 +188,7 @@ impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum
} else {
v
}
})
})
} else if p.is_infinite() && p.is_sign_negative() {
self.iter().fold(T::infinity(), |f, &val| {
let v = val.abs();
@@ -200,19 +199,17 @@ impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum
}
})
} else {
let mut norm = T::zero();
for xi in self.iter() {
norm = norm + xi.abs().powf(p);
}
norm.powf(T::one()/p)
norm.powf(T::one() / p)
}
}
fn column_mean(&self) -> Vec<T> {
let mut res = Vec::new();
for column in self.column_iter() {
@@ -221,68 +218,71 @@ impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum
for v in column.iter() {
sum += *v;
count += 1;
}
}
res.push(sum / T::from(count).unwrap());
}
res
}
fn div_element_mut(&mut self, row: usize, col: usize, x: T){
fn div_element_mut(&mut self, row: usize, col: usize, x: T) {
*self.get_mut((row, col)).unwrap() = *self.get((row, col)).unwrap() / x;
}
fn mul_element_mut(&mut self, row: usize, col: usize, x: T){
fn mul_element_mut(&mut self, row: usize, col: usize, x: T) {
*self.get_mut((row, col)).unwrap() = *self.get((row, col)).unwrap() * x;
}
fn add_element_mut(&mut self, row: usize, col: usize, x: T){
fn add_element_mut(&mut self, row: usize, col: usize, x: T) {
*self.get_mut((row, col)).unwrap() = *self.get((row, col)).unwrap() + x;
}
fn sub_element_mut(&mut self, row: usize, col: usize, x: T){
fn sub_element_mut(&mut self, row: usize, col: usize, x: T) {
*self.get_mut((row, col)).unwrap() = *self.get((row, col)).unwrap() - x;
}
fn negative_mut(&mut self){
fn negative_mut(&mut self) {
*self *= -T::one();
}
fn reshape(&self, nrows: usize, ncols: usize) -> Self{
fn reshape(&self, nrows: usize, ncols: usize) -> Self {
DMatrix::from_row_slice(nrows, ncols, &self.to_raw_vector())
}
fn copy_from(&mut self, other: &Self){
fn copy_from(&mut self, other: &Self) {
Matrix::copy_from(self, other);
}
fn abs_mut(&mut self) -> &Self{
for v in self.iter_mut(){
fn abs_mut(&mut self) -> &Self {
for v in self.iter_mut() {
*v = v.abs()
}
}
self
}
fn sum(&self) -> T{
fn sum(&self) -> T {
let mut sum = T::zero();
for v in self.iter(){
for v in self.iter() {
sum += *v;
}
}
sum
}
fn max_diff(&self, other: &Self) -> T{
fn max_diff(&self, other: &Self) -> T {
let mut max_diff = T::zero();
for r in 0..self.nrows() {
for c in 0..self.ncols() {
max_diff = max_diff.max((self[(r, c)] - other[(r, c)]).abs());
}
}
max_diff
max_diff
}
fn softmax_mut(&mut self){
let max = self.iter().map(|x| x.abs()).fold(T::neg_infinity(), |a, b| a.max(b));
fn softmax_mut(&mut self) {
let max = self
.iter()
.map(|x| x.abs())
.fold(T::neg_infinity(), |a, b| a.max(b));
let mut z = T::zero();
for r in 0..self.nrows() {
for c in 0..self.ncols() {
@@ -298,14 +298,14 @@ impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum
}
}
fn pow_mut(&mut self, p: T) -> &Self{
for v in self.iter_mut(){
fn pow_mut(&mut self, p: T) -> &Self {
for v in self.iter_mut() {
*v = v.powf(p)
}
self
}
fn argmax(&self) -> Vec<usize>{
fn argmax(&self) -> Vec<usize> {
let mut res = vec![0usize; self.nrows()];
for r in 0..self.nrows() {
@@ -315,16 +315,15 @@ impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum
let v = self[(r, c)];
if max < v {
max = v;
max_pos = c;
max_pos = c;
}
}
res[r] = max_pos;
}
res
}
fn unique(&self) -> Vec<T> {
let mut result: Vec<T> = self.iter().map(|v| *v).collect();
result.sort_by(|a, b| a.partial_cmp(b).unwrap());
@@ -335,95 +334,96 @@ impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum
fn cov(&self) -> Self {
panic!("Not implemented");
}
}
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static> SVDDecomposableMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>> {}
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static>
SVDDecomposableMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>
{
}
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static> EVDDecomposableMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>> {}
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static>
EVDDecomposableMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>
{
}
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static> QRDecomposableMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>> {}
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static>
QRDecomposableMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>
{
}
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static> LUDecomposableMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>> {}
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static>
LUDecomposableMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>
{
}
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static> SmartCoreMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>> {}
impl<T: FloatExt + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Sum + 'static>
SmartCoreMatrix<T> for Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>
{
}
#[cfg(test)]
mod tests {
use super::*;
use nalgebra::{Matrix2x3, DMatrix, RowDVector};
mod tests {
use super::*;
use nalgebra::{DMatrix, Matrix2x3, RowDVector};
#[test]
fn vec_len() {
let v = RowDVector::from_vec(vec!(1., 2., 3.));
assert_eq!(3, v.len());
let v = RowDVector::from_vec(vec![1., 2., 3.]);
assert_eq!(3, v.len());
}
#[test]
fn get_set_vector() {
let mut v = RowDVector::from_vec(vec!(1., 2., 3., 4.));
let mut v = RowDVector::from_vec(vec![1., 2., 3., 4.]);
let expected = RowDVector::from_vec(vec!(1., 5., 3., 4.));
let expected = RowDVector::from_vec(vec![1., 5., 3., 4.]);
v.set(1, 5.);
assert_eq!(v, expected);
assert_eq!(5., BaseVector::get(&v, 1));
assert_eq!(5., BaseVector::get(&v, 1));
}
#[test]
fn get_set_dynamic() {
let mut m = DMatrix::from_row_slice(
2,
3,
&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
);
let mut m = DMatrix::from_row_slice(2, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
let expected = Matrix2x3::new(1., 2., 3., 4.,
10., 6.);
let expected = Matrix2x3::new(1., 2., 3., 4., 10., 6.);
m.set(1, 1, 10.);
assert_eq!(m, expected);
assert_eq!(10., BaseMatrix::get(&m, 1, 1));
}
assert_eq!(10., BaseMatrix::get(&m, 1, 1));
}
#[test]
fn zeros() {
let expected = DMatrix::from_row_slice(
2,
2,
&[0., 0., 0., 0.],
);
let expected = DMatrix::from_row_slice(2, 2, &[0., 0., 0., 0.]);
let m:DMatrix<f64> = BaseMatrix::zeros(2, 2);
let m: DMatrix<f64> = BaseMatrix::zeros(2, 2);
assert_eq!(m, expected);
}
#[test]
fn ones() {
let expected = DMatrix::from_row_slice(
2,
2,
&[1., 1., 1., 1.],
);
let expected = DMatrix::from_row_slice(2, 2, &[1., 1., 1., 1.]);
let m:DMatrix<f64> = BaseMatrix::ones(2, 2);
let m: DMatrix<f64> = BaseMatrix::ones(2, 2);
assert_eq!(m, expected);
}
#[test]
fn eye(){
let expected = DMatrix::from_row_slice(3, 3, &[1., 0., 0., 0., 1., 0., 0., 0., 1.]);
let m: DMatrix<f64> = BaseMatrix::eye(3);
fn eye() {
let expected = DMatrix::from_row_slice(3, 3, &[1., 0., 0., 0., 1., 0., 0., 0., 1.]);
let m: DMatrix<f64> = BaseMatrix::eye(3);
assert_eq!(m, expected);
}
#[test]
fn shape() {
let m:DMatrix<f64> = BaseMatrix::zeros(5, 10);
let m: DMatrix<f64> = BaseMatrix::zeros(5, 10);
let (nrows, ncols) = m.shape();
assert_eq!(nrows, 5);
@@ -431,18 +431,10 @@ mod tests {
}
#[test]
fn scalar_add_sub_mul_div(){
let mut m = DMatrix::from_row_slice(
2,
3,
&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
);
fn scalar_add_sub_mul_div() {
let mut m = DMatrix::from_row_slice(2, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
let expected = DMatrix::from_row_slice(
2,
3,
&[0.6, 0.8, 1., 1.2, 1.4, 1.6],
);
let expected = DMatrix::from_row_slice(2, 3, &[0.6, 0.8, 1., 1.2, 1.4, 1.6]);
m.add_scalar_mut(3.0);
m.sub_scalar_mut(1.0);
@@ -452,79 +444,51 @@ mod tests {
}
#[test]
fn add_sub_mul_div(){
let mut m = DMatrix::from_row_slice(
2,
2,
&[1.0, 2.0, 3.0, 4.0],
);
let a = DMatrix::from_row_slice(
2,
2,
&[1.0, 2.0, 3.0, 4.0],
);
fn add_sub_mul_div() {
let mut m = DMatrix::from_row_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
let a = DMatrix::from_row_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
let b: DMatrix<f64> = BaseMatrix::fill(2, 2, 10.);
let expected = DMatrix::from_row_slice(
2,
2,
&[0.1, 0.6, 1.5, 2.8],
);
let expected = DMatrix::from_row_slice(2, 2, &[0.1, 0.6, 1.5, 2.8]);
m.add_mut(&a);
m.mul_mut(&a);
m.sub_mut(&a);
m.div_mut(&b);
assert_eq!(m, expected);
}
#[test]
fn to_from_row_vector(){
let v = RowDVector::from_vec(vec!(1., 2., 3., 4.));
fn to_from_row_vector() {
let v = RowDVector::from_vec(vec![1., 2., 3., 4.]);
let expected = v.clone();
let m: DMatrix<f64> = BaseMatrix::from_row_vector(v);
assert_eq!(m.to_row_vector(), expected);
assert_eq!(m.to_row_vector(), expected);
}
#[test]
fn get_row_col_as_vec(){
let m = DMatrix::from_row_slice(
3,
3,
&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],
);
fn get_row_col_as_vec() {
let m = DMatrix::from_row_slice(3, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]);
assert_eq!(m.get_row_as_vec(1), vec!(4., 5., 6.));
assert_eq!(m.get_col_as_vec(1), vec!(2., 5., 8.));
}
#[test]
fn to_raw_vector(){
let m = DMatrix::from_row_slice(
2,
3,
&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
);
fn to_raw_vector() {
let m = DMatrix::from_row_slice(2, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
assert_eq!(m.to_raw_vector(), vec!(1., 2., 3., 4., 5., 6.));
}
#[test]
fn element_add_sub_mul_div(){
let mut m = DMatrix::from_row_slice(
2,
2,
&[1.0, 2.0, 3.0, 4.0],
);
fn element_add_sub_mul_div() {
let mut m = DMatrix::from_row_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
let expected = DMatrix::from_row_slice(
2,
2,
&[4., 1., 6., 0.4],
);
let expected = DMatrix::from_row_slice(2, 2, &[4., 1., 6., 0.4]);
m.add_element_mut(0, 0, 3.0);
m.sub_element_mut(0, 1, 1.0);
@@ -534,60 +498,65 @@ mod tests {
}
#[test]
fn vstack_hstack() {
fn vstack_hstack() {
let m1 = DMatrix::from_row_slice(2, 3, &[1., 2., 3., 4., 5., 6.]);
let m2 = DMatrix::from_row_slice(2, 1, &[7., 8.]);
let m1 = DMatrix::from_row_slice(2, 3, &[1., 2., 3., 4., 5., 6.]);
let m2 = DMatrix::from_row_slice(2, 1, &[ 7., 8.]);
let m3 = DMatrix::from_row_slice(1, 4, &[9., 10., 11., 12.]);
let m3 = DMatrix::from_row_slice(1, 4, &[9., 10., 11., 12.]);
let expected =
DMatrix::from_row_slice(3, 4, &[1., 2., 3., 7., 4., 5., 6., 8., 9., 10., 11., 12.]);
let expected = DMatrix::from_row_slice(3, 4, &[1., 2., 3., 7., 4., 5., 6., 8., 9., 10., 11., 12.]);
let result = m1.v_stack(&m2).h_stack(&m3);
assert_eq!(result, expected);
let result = m1.v_stack(&m2).h_stack(&m3);
assert_eq!(result, expected);
}
#[test]
fn dot() {
let a = DMatrix::from_row_slice(2, 3, &[1., 2., 3., 4., 5., 6.]);
let b = DMatrix::from_row_slice(3, 2, &[1., 2., 3., 4., 5., 6.]);
let expected = DMatrix::from_row_slice(2, 2, &[22., 28., 49., 64.]);
let result = BaseMatrix::dot(&a, &b);
assert_eq!(result, expected);
}
#[test]
fn vector_dot() {
let a = DMatrix::from_row_slice(1, 3, &[1., 2., 3.]);
let b = DMatrix::from_row_slice(1, 3, &[1., 2., 3.]);
assert_eq!(14., a.vector_dot(&b));
fn dot() {
let a = DMatrix::from_row_slice(2, 3, &[1., 2., 3., 4., 5., 6.]);
let b = DMatrix::from_row_slice(3, 2, &[1., 2., 3., 4., 5., 6.]);
let expected = DMatrix::from_row_slice(2, 2, &[22., 28., 49., 64.]);
let result = BaseMatrix::dot(&a, &b);
assert_eq!(result, expected);
}
#[test]
fn slice() {
fn vector_dot() {
let a = DMatrix::from_row_slice(1, 3, &[1., 2., 3.]);
let b = DMatrix::from_row_slice(1, 3, &[1., 2., 3.]);
assert_eq!(14., a.vector_dot(&b));
}
let a = DMatrix::from_row_slice(3, 5, &[1., 2., 3., 1., 2., 4., 5., 6., 3., 4., 7., 8., 9., 5., 6.]);
let expected = DMatrix::from_row_slice(2, 2, &[2., 3., 5., 6.]);
let result = BaseMatrix::slice(&a, 0..2, 1..3);
assert_eq!(result, expected);
#[test]
fn slice() {
let a = DMatrix::from_row_slice(
3,
5,
&[1., 2., 3., 1., 2., 4., 5., 6., 3., 4., 7., 8., 9., 5., 6.],
);
let expected = DMatrix::from_row_slice(2, 2, &[2., 3., 5., 6.]);
let result = BaseMatrix::slice(&a, 0..2, 1..3);
assert_eq!(result, expected);
}
#[test]
fn approximate_eq() {
let a = DMatrix::from_row_slice(3, 3, &[1., 2., 3., 4., 5., 6., 7., 8., 9.]);
let noise = DMatrix::from_row_slice(3, 3, &[1e-5, 2e-5, 3e-5, 4e-5, 5e-5, 6e-5, 7e-5, 8e-5, 9e-5]);
let noise = DMatrix::from_row_slice(
3,
3,
&[1e-5, 2e-5, 3e-5, 4e-5, 5e-5, 6e-5, 7e-5, 8e-5, 9e-5],
);
assert!(a.approximate_eq(&(&noise + &a), 1e-4));
assert!(!a.approximate_eq(&(&noise + &a), 1e-5));
}
#[test]
fn negative_mut() {
let mut v = DMatrix::from_row_slice(1, 3, &[3., -2., 6.]);
v.negative_mut();
assert_eq!(v, DMatrix::from_row_slice(1, 3, &[-3., 2., -6.]));
fn negative_mut() {
let mut v = DMatrix::from_row_slice(1, 3, &[3., -2., 6.]);
v.negative_mut();
assert_eq!(v, DMatrix::from_row_slice(1, 3, &[-3., 2., -6.]));
}
#[test]
@@ -595,7 +564,7 @@ mod tests {
let m = DMatrix::from_row_slice(2, 2, &[1.0, 3.0, 2.0, 4.0]);
let expected = DMatrix::from_row_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
let m_transposed = m.transpose();
assert_eq!(m_transposed, expected);
assert_eq!(m_transposed, expected);
}
#[test]
@@ -609,8 +578,8 @@ mod tests {
}
#[test]
fn norm() {
let v = DMatrix::from_row_slice(1, 3, &[3., -2., 6.]);
fn norm() {
let v = DMatrix::from_row_slice(1, 3, &[3., -2., 6.]);
assert_eq!(BaseMatrix::norm(&v, 1.), 11.);
assert_eq!(BaseMatrix::norm(&v, 2.), 7.);
assert_eq!(BaseMatrix::norm(&v, std::f64::INFINITY), 6.);
@@ -618,17 +587,17 @@ mod tests {
}
#[test]
fn col_mean(){
fn col_mean() {
let a = DMatrix::from_row_slice(3, 3, &[1., 2., 3., 4., 5., 6., 7., 8., 9.]);
let res = BaseMatrix::column_mean(&a);
assert_eq!(res, vec![4., 5., 6.]);
let res = BaseMatrix::column_mean(&a);
assert_eq!(res, vec![4., 5., 6.]);
}
#[test]
fn reshape() {
let m_orig = DMatrix::from_row_slice(1, 6, &[1., 2., 3., 4., 5., 6.]);
let m_2_by_3 = m_orig.reshape(2, 3);
let m_result = m_2_by_3.reshape(1, 6);
let m_orig = DMatrix::from_row_slice(1, 6, &[1., 2., 3., 4., 5., 6.]);
let m_2_by_3 = m_orig.reshape(2, 3);
let m_result = m_2_by_3.reshape(1, 6);
assert_eq!(BaseMatrix::shape(&m_2_by_3), (2, 3));
assert_eq!(BaseMatrix::get(&m_2_by_3, 1, 1), 5.);
assert_eq!(BaseMatrix::get(&m_result, 0, 1), 2.);
@@ -653,47 +622,46 @@ mod tests {
#[test]
fn sum() {
let a = DMatrix::from_row_slice(1, 3, &[1., 2., 3.]);
let a = DMatrix::from_row_slice(1, 3, &[1., 2., 3.]);
assert_eq!(a.sum(), 6.);
}
#[test]
fn max_diff() {
let a1 = DMatrix::from_row_slice(2, 3, &[1., 2., 3., 4., -5., 6.]);
let a2 = DMatrix::from_row_slice(2, 3, &[2., 3., 4., 1., 0., -12.]);
let a2 = DMatrix::from_row_slice(2, 3, &[2., 3., 4., 1., 0., -12.]);
assert_eq!(a1.max_diff(&a2), 18.);
assert_eq!(a2.max_diff(&a2), 0.);
}
#[test]
fn softmax_mut(){
let mut prob: DMatrix<f64> = DMatrix::from_row_slice(1, 3, &[1., 2., 3.]);
prob.softmax_mut();
assert!((BaseMatrix::get(&prob, 0, 0) - 0.09).abs() < 0.01);
assert!((BaseMatrix::get(&prob, 0, 1) - 0.24).abs() < 0.01);
assert!((BaseMatrix::get(&prob, 0, 2) - 0.66).abs() < 0.01);
fn softmax_mut() {
let mut prob: DMatrix<f64> = DMatrix::from_row_slice(1, 3, &[1., 2., 3.]);
prob.softmax_mut();
assert!((BaseMatrix::get(&prob, 0, 0) - 0.09).abs() < 0.01);
assert!((BaseMatrix::get(&prob, 0, 1) - 0.24).abs() < 0.01);
assert!((BaseMatrix::get(&prob, 0, 2) - 0.66).abs() < 0.01);
}
#[test]
fn pow_mut(){
let mut a = DMatrix::from_row_slice(1, 3, &[1., 2., 3.]);
fn pow_mut() {
let mut a = DMatrix::from_row_slice(1, 3, &[1., 2., 3.]);
a.pow_mut(3.);
assert_eq!(a, DMatrix::from_row_slice(1, 3, &[1., 8., 27.]));
}
#[test]
fn argmax(){
fn argmax() {
let a = DMatrix::from_row_slice(3, 3, &[1., 2., 3., -5., -6., -7., 0.1, 0.2, 0.1]);
let res = a.argmax();
assert_eq!(res, vec![2, 0, 1]);
}
#[test]
fn unique(){
fn unique() {
let a = DMatrix::from_row_slice(3, 3, &[1., 2., 2., -2., -6., -7., 2., 3., 4.]);
let res = a.unique();
assert_eq!(res.len(), 7);
assert_eq!(res, vec![-7., -6., -2., 1., 2., 3., 4.]);
}
}
}