auslander 0.10.0

Computational representation theory of finite-dimensional bound quiver algebras
Documentation
use super::support::{dense, dense_vec, f, sparse_vec};
use crate::linalg::SparseRow;

#[test]
fn sparse_row_from_entries_merges_duplicates() {
    let fp = f(7);
    let row = SparseRow::from_entries(vec![(2, fp.elem(5)), (0, fp.elem(3)), (0, fp.elem(4))], &fp);
    assert_eq!(row.nnz(), 1);
    assert_eq!(row.get(0), fp.zero());
    assert_eq!(row.get(2), fp.elem(5));
}

#[test]
fn sparse_row_add_scaled_merges_and_cancels() {
    let fp = f(7);
    let mut a = SparseRow::from_entries(vec![(0, fp.elem(3)), (2, fp.elem(5))], &fp);
    let b = SparseRow::from_entries(vec![(1, fp.elem(2)), (2, fp.elem(1))], &fp);
    a.add_scaled(&b, fp.elem(2), &fp);
    assert_eq!(a.get(0), fp.elem(3));
    assert_eq!(a.get(1), fp.elem(4));
    assert_eq!(a.get(2), fp.zero());
    assert_eq!(a.nnz(), 2);
}

#[test]
fn sparse_row_dot_matches_hand_computation() {
    let fp = f(7);
    let a = SparseRow::from_entries(vec![(0, fp.elem(3)), (2, fp.elem(5))], &fp);
    let b = SparseRow::from_entries(vec![(1, fp.elem(4)), (2, fp.elem(2))], &fp);
    assert_eq!(a.dot(&b, &fp), fp.elem(3));
}

#[test]
fn sparse_solve_matches_hand_computation() {
    let fp = f(7);
    let a = dense(&fp, &[&[1, 2], &[3, 4]]).to_sparse();
    let b = sparse_vec(&[fp.elem(5), fp.elem(6)]);
    let x = a.solve(&b, &fp).unwrap();
    assert_eq!(dense_vec(&x, 2), vec![fp.elem(3), fp.elem(1)]);
    assert_eq!(a.mul_vec(&x, &fp), b);
}

#[test]
fn sparse_solve_detects_inconsistency() {
    let fp = f(7);
    let a = dense(&fp, &[&[1, 0], &[0, 0]]).to_sparse();
    let b = sparse_vec(&[fp.elem(1), fp.elem(1)]);
    assert!(a.solve(&b, &fp).is_none());
}

#[test]
fn sparse_kernel_spans_the_null_space() {
    let fp = f(7);
    let a = dense(&fp, &[&[1, 2], &[2, 4]]).to_sparse();
    let k = a.kernel_basis(&fp);
    assert_eq!(k.rows(), 1);
    assert!(a.mul_vec(k.row(0), &fp).is_zero());
}

#[test]
fn conversions_round_trip() {
    let fp = f(7);
    let a = dense(&fp, &[&[0, 2, 0], &[3, 0, 4]]);
    assert_eq!(a.to_sparse().to_dense(), a);
    let s = a.to_sparse();
    assert_eq!(s.to_dense().to_sparse(), s);
    assert_eq!(s.transpose().to_dense(), a.transpose());
}