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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! Borrowed raw rows for faer CSR matrices and views.
//!
//! CSC storage does not provide contiguous rows:
//!
//! ```compile_fail
//! # #[cfg(all(feature = "faer_v0_22", not(any(feature = "faer_v0_23", feature = "faer_v0_24"))))]
//! # use faer_0_22 as faer;
//! # #[cfg(all(feature = "faer_v0_23", not(feature = "faer_v0_24")))]
//! # use faer_0_23 as faer;
//! use lazymatrix::SparseRows;
//! fn needs_rows<M: SparseRows<f64>>() {}
//! needs_rows::<faer::sparse::SparseColMat<usize, f64>>();
//! ```
//!
//! Other index widths cannot provide borrowed `usize` slices:
//!
//! ```compile_fail
//! # #[cfg(all(feature = "faer_v0_22", not(any(feature = "faer_v0_23", feature = "faer_v0_24"))))]
//! # use faer_0_22 as faer;
//! # #[cfg(all(feature = "faer_v0_23", not(feature = "faer_v0_24")))]
//! # use faer_0_23 as faer;
//! use lazymatrix::SparseRows;
//! fn needs_rows<M: SparseRows<f64>>() {}
//! needs_rows::<faer::sparse::SparseRowMat<u32, f64>>();
//! ```

use super::faer;

use faer::prelude::Reborrow;
use faer::sparse::{SparseRowMat, SparseRowMatMut, SparseRowMatRef};

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

impl<F> MatrixShape for SparseRowMat<usize, F> {
    fn nrows(&self) -> usize {
        self.symbolic().nrows()
    }

    fn ncols(&self) -> usize {
        self.symbolic().ncols()
    }
}

impl<F> MatrixShape for SparseRowMatRef<'_, usize, F> {
    fn nrows(&self) -> usize {
        self.symbolic().nrows()
    }

    fn ncols(&self) -> usize {
        self.symbolic().ncols()
    }
}

impl<F> MatrixShape for SparseRowMatMut<'_, usize, F> {
    fn nrows(&self) -> usize {
        self.symbolic().nrows()
    }

    fn ncols(&self) -> usize {
        self.symbolic().ncols()
    }
}

impl<F: Scalar> SparseRows<F> for SparseRowMatRef<'_, usize, F> {
    fn sparse_row(&self, i: usize) -> (&[usize], &[F]) {
        assert!(i < self.nrows(), "row index out of bounds");
        // A row can reserve more capacity than it actually stores.
        let range = self.row_range(i);
        (&self.col_idx()[range.clone()], &self.val()[range])
    }
}

impl<F: Scalar> SparseRows<F> for SparseRowMat<usize, F> {
    fn sparse_row(&self, i: usize) -> (&[usize], &[F]) {
        assert!(i < self.nrows(), "row index out of bounds");
        let range = self.row_range(i);
        (&self.col_idx()[range.clone()], &self.val()[range])
    }
}

impl<F: Scalar> SparseRows<F> for SparseRowMatMut<'_, usize, F> {
    fn sparse_row(&self, i: usize) -> (&[usize], &[F]) {
        assert!(i < self.nrows(), "row index out of bounds");
        let view = self.rb();
        let range = view.row_range(i);
        (&view.col_idx()[range.clone()], &view.val()[range])
    }
}

impl<F> crate::MatrixErrorType for SparseRowMat<usize, F> {
    type Error = std::convert::Infallible;
}

impl<F: Scalar> crate::MaterializeDense<F> for SparseRowMat<usize, F> {
    fn materialize_normalized_into<O: crate::MatrixWrite<F> + ?Sized>(
        &self,
        centers: Option<&[F]>,
        scales: Option<&[F]>,
        out: &mut O,
    ) -> Result<(), Self::Error> {
        crate::materialize::sparse_outer(self, false, centers, scales, out, |outer, visit| {
            let (indices, values) = self.sparse_row(outer);
            for (&index, &value) in indices.iter().zip(values) {
                visit(index, value);
            }
        });
        Ok(())
    }
}

impl<F> crate::MatrixErrorType for SparseRowMatRef<'_, usize, F> {
    type Error = std::convert::Infallible;
}

impl<F: Scalar> crate::MaterializeDense<F> for SparseRowMatRef<'_, usize, F> {
    fn materialize_normalized_into<O: crate::MatrixWrite<F> + ?Sized>(
        &self,
        centers: Option<&[F]>,
        scales: Option<&[F]>,
        out: &mut O,
    ) -> Result<(), Self::Error> {
        crate::materialize::sparse_outer(self, false, centers, scales, out, |outer, visit| {
            let (indices, values) = self.sparse_row(outer);
            for (&index, &value) in indices.iter().zip(values) {
                visit(index, value);
            }
        });
        Ok(())
    }
}

impl<F> crate::MatrixErrorType for SparseRowMatMut<'_, usize, F> {
    type Error = std::convert::Infallible;
}

impl<F: Scalar> crate::MaterializeDense<F> for SparseRowMatMut<'_, usize, F> {
    fn materialize_normalized_into<O: crate::MatrixWrite<F> + ?Sized>(
        &self,
        centers: Option<&[F]>,
        scales: Option<&[F]>,
        out: &mut O,
    ) -> Result<(), Self::Error> {
        crate::materialize::sparse_outer(self, false, centers, scales, out, |outer, visit| {
            let (indices, values) = self.sparse_row(outer);
            for (&index, &value) in indices.iter().zip(values) {
                visit(index, value);
            }
        });
        Ok(())
    }
}