lazymatrix 0.6.0

Lazy normalized design matrices: apply column centering/scaling without materializing (X - 1cᵀ)S⁻¹, preserving sparsity.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use crate::{MatrixShape, MatrixWrite, Scalar};

pub(crate) fn validate_allocation<F>(nrows: usize, ncols: usize) {
    assert!(
        nrows
            .checked_mul(ncols)
            .and_then(|len| len.checked_mul(std::mem::size_of::<F>()))
            .is_some_and(|bytes| bytes <= isize::MAX as usize),
        "dense allocation size overflow"
    );
}

pub(crate) fn validate_output<F: Scalar>(
    source: &(impl MatrixShape + ?Sized),
    out: &(impl MatrixWrite<F> + ?Sized),
    centers: Option<&[F]>,
    scales: Option<&[F]>,
) {
    assert_eq!(
        (out.nrows(), out.ncols()),
        (source.nrows(), source.ncols()),
        "materialization output shape must match input"
    );
    crate::gram::validate_normalization(source.ncols(), centers, scales);
}

#[cfg(any(
    feature = "faer_all",
    feature = "nalgebra_all",
    feature = "ndarray_all",
    feature = "sprs_all",
    feature = "zarrs_all"
))]
pub(crate) fn normalized<F: Scalar>(
    mut value: F,
    column: usize,
    centers: Option<&[F]>,
    scales: Option<&[F]>,
) -> F {
    if let Some(centers) = centers {
        value = value - centers[column];
    }
    if let Some(scales) = scales {
        value = value / scales[column];
    }
    value
}

#[cfg(any(feature = "faer_all", feature = "nalgebra_all", feature = "sprs_all"))]
pub(crate) fn sparse_outer<F: Scalar, O: MatrixWrite<F> + ?Sized>(
    shape: &impl MatrixShape,
    csc: bool,
    centers: Option<&[F]>,
    scales: Option<&[F]>,
    out: &mut O,
    mut visit: impl FnMut(usize, &mut dyn FnMut(usize, F)),
) {
    validate_output(shape, out, centers, scales);
    let (outer_len, inner_len) = if csc {
        (shape.ncols(), shape.nrows())
    } else {
        (shape.nrows(), shape.ncols())
    };
    if inner_len == 0 || outer_len == 0 {
        return;
    }
    let mut values = vec![F::zero(); inner_len];
    let mut seen = vec![false; inner_len];
    for outer in 0..outer_len {
        values.fill(F::zero());
        seen.fill(false);
        visit(outer, &mut |inner, value| {
            // Assign the first value directly to preserve explicitly stored negative zero.
            values[inner] = if seen[inner] {
                values[inner] + value
            } else {
                value
            };
            seen[inner] = true;
        });
        for (inner, &value) in values.iter().enumerate() {
            let (row, col) = if csc { (inner, outer) } else { (outer, inner) };
            out.set(row, col, normalized(value, col, centers, scales));
        }
    }
}