#[cfg(test)]
mod matrix_tests {
extern crate linearalgebra;
use std::ops::Index;
use linearalgebra::matrix::*;
use linearalgebra::vector::*;
#[test]
fn get_col_success_test() {
let matrix = Matrix::new(3, 3, vec![1, 1, 2, 3, 4, 5, 6, 1, 2]).unwrap();
assert_eq!(matrix.get_col(0).unwrap(), Vector::new(vec![1, 3, 6]))
}
#[test]
fn get_col_fail_test() {
let matrix = Matrix::new(3, 3, vec![1, 1, 2, 3, 4, 5, 6, 1, 2]).unwrap();
assert!(matrix.get_col(6).is_err());
}
#[test]
fn get_cols_test() {
let matrix = Matrix::new(3, 3, vec![1, 1, 2, 3, 4, 5, 6, 1, 2]).unwrap();
assert_eq!(
matrix.get_cols(),
vec![
Vector::new(vec![1, 3, 6]),
Vector::new(vec![1, 4, 1]),
Vector::new(vec![2, 5, 2]),
]
)
}
#[test]
fn get_row_success_test() {
let matrix = Matrix::new(3, 3, vec![1, 1, 2, 3, 4, 5, 6, 1, 2]).unwrap();
assert_eq!(matrix.get_row(0).unwrap(), Vector::new(vec![1, 1, 2]))
}
#[test]
fn get_row_fail_test() {
let matrix = Matrix::new(3, 3, vec![1, 1, 2, 3, 4, 5, 6, 1, 2]).unwrap();
assert!(matrix.get_row(6).is_err());
}
#[test]
fn get_rows_test() {
let matrix = Matrix::new(3, 3, vec![1, 1, 2, 3, 4, 5, 6, 1, 2]).unwrap();
assert_eq!(
matrix.get_rows(),
vec![
Vector::new(vec![1, 1, 2]),
Vector::new(vec![3, 4, 5]),
Vector::new(vec![6, 1, 2]),
]
)
}
#[test]
fn matrix_vector_product_fail_test() {
let matrix = Matrix::new(3, 3, vec![1, 1, 2, 3, 4, 5, 6, 1, 2]).unwrap();
let vector = Vector::new(vec![1, 4, 1, 1]);
assert!(matrix.product_vector(&vector).is_err())
}
#[test]
fn matrix_vector_product_test() {
let matrix = Matrix::new(3, 3, vec![1, 1, 2, 3, 4, 5, 6, 1, 2]).unwrap();
let vector = Vector::new(vec![1, 4, 1]);
assert_eq!(
matrix.product_vector(&vector).unwrap(),
Vector::new(vec![7, 24, 12])
)
}
#[test]
fn matrix_matrix_product_test() {
let matrix = Matrix::new(3, 3, vec![1, 1, 2, 3, 4, 5, 6, 1, 2]).unwrap();
let matrix2 = Matrix::new(3, 3, vec![1, 9, 2, 7, 1, 5, 3, 8, 2]).unwrap();
assert_eq!(
matrix.product_matrix(&matrix2).unwrap().as_vec(),
&vec![14, 26, 11, 46, 71, 36, 19, 71, 21]
)
}
#[test]
fn transpose_nonsquare_test() {
let matrix = Matrix::new(3, 2, vec![1, 2, 3, 4, 5, 6]).unwrap();
assert_eq!(matrix.transpose().as_vec(), &vec![1, 4, 2, 5, 3, 6])
}
#[test]
fn transpose_square_test() {
let matrix = Matrix::new(3, 3, vec![1, 2, 3, 4, 5, 6, 7, 8, 9]).unwrap();
assert_eq!(
matrix.transpose().as_vec(),
&vec![1, 4, 7, 2, 5, 8, 3, 6, 9]
)
}
#[test]
fn display_3x3_test() {
let matrix = Matrix::new(3, 3, vec![1, 1, 2, 3, 4, 5, 6, 1, 2]).unwrap();
assert_eq!(
"┌ ┐\n│ 1 1 2 │\n│ 3 4 5 │\n│ 6 1 2 │\n└ ┘",
matrix.to_string()
)
}
#[test]
fn display_1x1_test() {
let matrix = Matrix::new(1, 1, vec![1]).unwrap();
assert_eq!("┌ ┐\n│ 1 │\n└ ┘", matrix.to_string())
}
#[test]
fn display_1x3_test() {
let matrix = Matrix::new(3, 1, vec![1, 2, 3]).unwrap();
assert_eq!("┌ ┐\n│ 1 2 3 │\n└ ┘", matrix.to_string())
}
#[test]
fn display_3x1_test() {
let matrix = Matrix::new(1, 3, vec![1, 2, 3]).unwrap();
assert_eq!("┌ ┐\n│ 1 │\n│ 2 │\n│ 3 │\n└ ┘", matrix.to_string())
}
#[test]
fn display_unequal_length_3x2_test() {
let matrix = Matrix::new(2, 3, vec![1, 20, 3, 1, 0, 9]).unwrap();
assert_eq!(
"┌ ┐\n│ 1 20 │\n│ 3 1 │\n│ 0 9 │\n└ ┘",
matrix.to_string()
)
}
#[test]
fn display_0_test() {
let matrix: Matrix<i32> = Matrix::new(0, 0, vec![]).unwrap();
assert_eq!("┌ ┐\n└ ┘", matrix.to_string())
}
#[test]
fn indexed_access_test() {
let matrix: Matrix<i32> = Matrix::new(3, 3, vec![4, 5, 1, 2, 3, 1, 5, 1, 9]).unwrap();
assert_eq!(3, matrix[(1, 1)]);
assert_eq!(3, *matrix.index((1, 1)))
}
#[test]
fn indexed_mut_test() {
let mut matrix: Matrix<i32> = Matrix::new(3, 3, vec![4, 5, 1, 2, 3, 1, 5, 1, 9]).unwrap();
matrix[(2, 1)] = 10;
assert_eq!(&vec![4, 5, 1, 2, 3, 1, 5, 10, 9], matrix.as_vec());
}
#[test]
fn apply_test() {
let mut matrix: Matrix<i32> = Matrix::new(3, 3, vec![4, 5, 1, 2, 3, 1, 5, 1, 9]).unwrap();
assert_eq!(3, matrix[(1, 1)]);
matrix.apply(|&x| x * 2);
assert_eq!(6, matrix[(1, 1)]);
}
#[test]
fn supplier_test() {
let matrix: Matrix<i32> = Matrix::new_of_supplier(3, 3, || 10);
assert_eq!(&vec![10; 9], matrix.as_vec())
}
#[test]
fn add_test() {
let matrix: Matrix<i32> = Matrix::new(2, 2, vec![1, 2, 3, 4]).unwrap();
let matrix_2: Matrix<i32> = Matrix::new(2, 2, vec![3, 2, 1, 4]).unwrap();
assert_eq!(&vec![4, 4, 4, 8], matrix.add(&matrix_2).unwrap().as_vec())
}
#[test]
fn sub_test() {
let matrix: Matrix<i32> = Matrix::new(2, 2, vec![1, 2, 3, 4]).unwrap();
let matrix_2: Matrix<i32> = Matrix::new(2, 2, vec![3, 2, 1, 4]).unwrap();
assert_eq!(&vec![-2, 0, 2, 0], matrix.sub(&matrix_2).unwrap().as_vec())
}
#[test]
fn sum_test() {
let matrix: Matrix<i32> = Matrix::new(2, 2, vec![9, 2, 3, 4]).unwrap();
assert_eq!(18, matrix.sum())
}
#[test]
fn sum_columns_test() {
let matrix: Matrix<i32> = Matrix::new(2, 2, vec![9, 2, 3, 4]).unwrap();
let sum = matrix.sum_columns();
assert_eq!(&vec![12, 6], sum.as_vec());
assert_eq!((1, 2), sum.shape())
}
#[test]
fn sum_rows_test() {
let matrix: Matrix<i32> = Matrix::new(2, 2, vec![9, 2, 3, 4]).unwrap();
let sum = matrix.sum_rows();
assert_eq!(&vec![11, 7], sum.as_vec())
}
#[test]
fn scalar_test() {
let matrix: Matrix<f64> = Matrix::new(2, 2, vec![9f64, 2f64, 3f64, 4f64]).unwrap();
let sum: Matrix<f64> = matrix.scale(2.3);
assert_eq!(
&vec![9.0 * 2.3, 2.0 * 2.3, 3.0 * 2.3, 4.0 * 2.3],
sum.as_vec()
)
}
#[test]
fn max_test() {
let matrix: Matrix<i32> = Matrix::new(2, 2, vec![-4, -6, -2, 6]).unwrap();
assert_eq!(6, matrix.max())
}
#[test]
fn min_test() {
let matrix: Matrix<i32> = Matrix::new(2, 2, vec![-4, -6, -2, 6]).unwrap();
assert_eq!(-6, matrix.min())
}
}