use deep_causality_linear::utils_tests::fixtures_matrix::*;
use deep_causality_linear::{
DenseMatrix, LinearError, LinearErrorEnum, determinant_exact, rank_exact,
};
fn dense_i64(f: (Vec<i64>, usize, usize)) -> DenseMatrix<i64> {
let (d, r, c) = f;
DenseMatrix::from_vec(d, r, c).unwrap()
}
#[test]
fn test_an_integer_determinant_is_an_integer() {
let m = dense_i64(integer_determinant_4x4());
let det: i64 = determinant_exact(&m).unwrap();
assert_eq!(det, INTEGER_DETERMINANT_4X4);
assert_eq!(det, 5);
}
#[test]
fn test_the_integer_determinant_matches_the_recurrence() {
let m = dense_i64(integer_determinant_4x4());
let (mut prev, mut cur) = (1i64, 2i64);
for _ in 2..=4 {
let next = 2 * cur - prev;
prev = cur;
cur = next;
}
assert_eq!(determinant_exact(&m).unwrap(), cur);
}
#[test]
fn test_the_integer_determinant_agrees_with_the_float_path() {
use deep_causality_linear::determinant;
let (d, r, c) = integer_determinant_4x4();
let exact = determinant_exact(&dense_i64((d.clone(), r, c))).unwrap();
let as_float: Vec<f64> = d.iter().map(|&v| v as f64).collect();
let float = determinant(&DenseMatrix::from_vec(as_float, r, c).unwrap()).unwrap();
assert!(
(float - exact as f64).abs() < 1e-9,
"exact {exact}, float {float}"
);
}
#[test]
fn test_the_integer_determinant_of_a_singular_matrix_is_zero() {
let m = DenseMatrix::from_vec(vec![1i64, 2, 2, 4], 2, 2).unwrap();
assert_eq!(determinant_exact(&m).unwrap(), 0);
}
#[test]
fn test_the_integer_determinant_rejects_a_non_square_matrix() {
let m = DenseMatrix::from_vec(vec![1i64, 2, 3, 4, 5, 6], 2, 3).unwrap();
assert!(matches!(
determinant_exact(&m),
Err(LinearError(LinearErrorEnum::NotSquare { .. }))
));
}
#[test]
fn test_exact_rank_of_the_boundary_alphabet() {
let m = dense_i64(boundary_alphabet_3x3());
assert_eq!(rank_exact(&m).unwrap(), BOUNDARY_ALPHABET_3X3_RANK);
}
#[test]
fn test_exact_rank_carries_no_tolerance_and_gets_the_hard_case_right() {
let m = DenseMatrix::from_vec(vec![1i64, 0, 0, 0, 1, 0, 0, 0, 1], 3, 3).unwrap();
assert_eq!(rank_exact(&m).unwrap(), 3);
}
#[test]
fn test_the_integer_and_rational_ranks_agree() {
use deep_causality_num_rational::Rational;
let (d, r, c) = ranks_disagree_3x3();
let integer = rank_exact(&dense_i64((d.clone(), r, c))).unwrap();
let as_rational: Vec<Rational<i64>> = d.iter().map(|&v| Rational::new(v, 1)).collect();
let mut rational_m = DenseMatrix::from_vec(as_rational, r, c).unwrap();
let rational = deep_causality_linear::rref(&mut rational_m).unwrap().rank();
assert_eq!(integer, rational);
assert_eq!(integer, RANKS_DISAGREE_RATIONAL_RANK);
}
#[test]
fn test_the_integer_rank_and_the_mod_two_rank_differ_on_the_same_matrix() {
use deep_causality_linear::{PackedGf2, rank_gf2};
let (d, r, c) = ranks_disagree_3x3();
let over_z = rank_exact(&dense_i64((d.clone(), r, c))).unwrap();
let packed: PackedGf2<u64> = PackedGf2::from_i64_mod2(&d, r, c).unwrap();
let over_f2 = rank_gf2(&packed).unwrap();
assert_eq!(over_z, RANKS_DISAGREE_RATIONAL_RANK);
assert_eq!(over_f2, RANKS_DISAGREE_GF2_RANK);
assert_ne!(over_z, over_f2, "the two ranks are different questions");
}
#[test]
fn test_exact_rank_reduces_a_row_by_its_content_before_eliminating() {
let m = DenseMatrix::from_vec(
vec![
3_000_000_000i64,
3_000_000_001,
9_000_000_000,
9_000_000_003,
],
2,
2,
)
.unwrap();
assert_eq!(rank_exact(&m).unwrap(), 1);
}
#[test]
fn test_exact_rank_of_a_matrix_with_a_zero_row_and_an_off_diagonal_pivot() {
let m = DenseMatrix::from_vec(vec![0i64, 0, 0, 1, 2, 3, 2, 4, 7], 3, 3).unwrap();
assert_eq!(rank_exact(&m).unwrap(), 2);
}
#[test]
fn test_exact_rank_of_rectangular_and_empty_shapes() {
let wide = DenseMatrix::from_vec(vec![1i64, 2, 3, 4, 5, 2, 4, 6, 8, 11], 2, 5).unwrap();
assert_eq!(rank_exact(&wide).unwrap(), 2);
let tall = DenseMatrix::from_vec(vec![1i64, 2, 2, 4, 3, 7, 0, 0, 5, 10], 5, 2).unwrap();
assert_eq!(rank_exact(&tall).unwrap(), 2);
for (r, c) in [(0usize, 0usize), (0, 3), (3, 0)] {
let empty: DenseMatrix<i64> = DenseMatrix::from_vec(Vec::new(), r, c).unwrap();
assert_eq!(rank_exact(&empty).unwrap(), 0, "shape {r}x{c}");
}
}
#[test]
fn test_exact_rank_of_dense_four_by_four_matrices() {
#[rustfmt::skip]
let deficient = DenseMatrix::from_vec(
vec![
12i64, 18, 24, 30,
7, 11, 13, 17,
19, 23, 29, 31,
26, 40, 50, 64,
],
4, 4,
).unwrap();
assert_eq!(rank_exact(&deficient).unwrap(), 3);
#[rustfmt::skip]
let full = DenseMatrix::from_vec(
vec![
-5i64, -13, -26, 0,
-13, 13, -10, -16,
26, 26, -30, 32,
30, -23, 0, -7,
],
4, 4,
).unwrap();
assert_eq!(rank_exact(&full).unwrap(), 4);
}
#[test]
fn test_the_integer_determinant_pivots_when_a_later_diagonal_entry_is_zero() {
let m = DenseMatrix::from_vec(vec![2i64, 3, 5, 4, 6, 7, 1, 4, 9], 3, 3).unwrap();
assert_eq!(determinant_exact(&m).unwrap(), 15);
}
#[test]
fn test_the_integer_determinant_of_a_dense_four_by_four() {
#[rustfmt::skip]
let m = DenseMatrix::from_vec(
vec![
-9i64, -6, -3, 3,
2, 6, -6, 9,
4, 5, -2, 1,
4, 7, -8, 0,
],
4, 4,
).unwrap();
assert_eq!(determinant_exact(&m).unwrap(), 330);
}
#[test]
fn test_exact_rank_when_the_second_pivot_needs_a_swap() {
#[rustfmt::skip]
let m = DenseMatrix::from_vec(
vec![
-6i64, 0, -1, 7,
9, 0, -7, 2,
-9, -2, -1, 3,
9, 0, 2, 3,
],
4, 4,
).unwrap();
assert_eq!(rank_exact(&m).unwrap(), 4);
}