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

//! Vector implementations for the nalgebra backend.

use super::nalgebra;

use nalgebra::DVector;

use crate::traits::{
    DotProduct, DotSlice, ElemDivAssign, L2Norm, Scalar, ScaleAssign, ScaledAddAssign,
    ScaledSubSlice, SubScalarAssign, SumEntries,
};

// --- vector traits on DVector<F> ---------------------------------------------

impl<F> DotProduct<F> for DVector<F>
where
    F: Scalar + nalgebra::RealField,
{
    fn dot(&self, other: &Self) -> F {
        DVector::dot(self, other)
    }
}

impl<F> L2Norm<F> for DVector<F>
where
    F: Scalar + nalgebra::RealField,
{
    fn norm_l2(&self) -> F {
        self.norm()
    }
}

impl<F> ScaledAddAssign<F> for DVector<F>
where
    F: Scalar + nalgebra::RealField,
{
    fn scaled_add_assign(&mut self, alpha: F, other: &Self) {
        self.axpy(alpha, other, F::one());
    }
}

impl<F> ScaleAssign<F> for DVector<F>
where
    F: Scalar + nalgebra::RealField,
{
    fn scale_assign(&mut self, alpha: F) {
        self.scale_mut(alpha);
    }
}

impl<F: Scalar + nalgebra::Scalar> ElemDivAssign<F> for DVector<F> {
    fn elem_div_assign(&mut self, coeffs: &[F]) {
        let s = self.as_mut_slice();
        assert_eq!(s.len(), coeffs.len(), "elem_div_assign: length mismatch");
        for (a, &c) in s.iter_mut().zip(coeffs) {
            *a = *a / c;
        }
    }
}

impl<F: Scalar + nalgebra::Scalar> DotSlice<F> for DVector<F> {
    fn dot_slice(&self, coeffs: &[F]) -> F {
        let s = self.as_slice();
        assert_eq!(s.len(), coeffs.len(), "dot_slice: length mismatch");
        s.iter().zip(coeffs).map(|(&a, &c)| a * c).sum()
    }
}

impl<F: Scalar + nalgebra::Scalar> SubScalarAssign<F> for DVector<F> {
    fn sub_scalar_assign(&mut self, k: F) {
        for a in self.as_mut_slice() {
            *a = *a - k;
        }
    }
}

impl<F: Scalar + nalgebra::Scalar> SumEntries<F> for DVector<F> {
    fn sum_entries(&self) -> F {
        self.as_slice().iter().copied().sum()
    }
}

impl<F: Scalar + nalgebra::Scalar> ScaledSubSlice<F> for DVector<F> {
    fn scaled_sub_slice(&mut self, k: F, coeffs: &[F]) {
        let s = self.as_mut_slice();
        assert_eq!(s.len(), coeffs.len(), "scaled_sub_slice: length mismatch");
        for (a, &c) in s.iter_mut().zip(coeffs) {
            *a = *a - k * c;
        }
    }
}

impl<F, R, S> crate::VectorOwned<F> for nalgebra::Matrix<F, R, nalgebra::U1, S>
where
    F: Scalar + nalgebra::Scalar,
    R: nalgebra::Dim,
    S: nalgebra::RawStorage<F, R, nalgebra::U1>,
{
    type Owned = DVector<F>;
    fn owned_from_fn(len: usize, mut value: impl FnMut(usize) -> F) -> Self::Owned {
        DVector::from_fn(len, |i, _| value(i))
    }
}