sparsemat 0.2.0

A simple sparse matrix library
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

use std::vec::Vec;
use crate::types::ValueType;

// Common interface for vectors
pub trait Vector<'a>
where Self: Sized + Clone {
    type Value: 'a + ValueType;
    type IterVal: Iterator<Item = Self::Value>;

    fn iter(&'a self) -> Self::IterVal;

    // Returns an empty vector with capacity
    fn with_capacity(cap: usize) -> Self;

    // Constructs a dense vector from an actual std::vec::Vec
    fn from_vec(vec: Vec<Self::Value>) -> Self;

    // Returns a new and empty vector
    fn new() -> Self {
        Self::with_capacity(0)
    }

    // Return the dimension of the vector
    fn dim(&self) -> usize;

    // Returns the value at position i
    fn get(&self, i: usize) -> Self::Value;

    // Returns the value at position i mutably
    // Appends entry if it does not exist yet
    fn get_mut(&mut self, i: usize) -> &mut Self::Value;

    fn add(&'a mut self, rhs: &Self);

    fn sub(&'a mut self, rhs: &Self);

    fn scale(&'a mut self, rhs: Self::Value);

    // Sets value at position i to val
    fn set(&mut self, i: usize, val: Self::Value) {
        *self.get_mut(i) = val;
    }

    // Adds value to entry at position i
    fn add_to(&mut self, i: usize, val: Self::Value) {
        *self.get_mut(i) += val;
    }

    // Computes the inner product with another vector
    fn inner_prod<V>(&'a self, rhs: &'a V) -> Self::Value
    where V: Vector<'a, Value = Self::Value> {
        self.iter().zip(rhs.iter()).map(|(x, y)| x * y).sum()
    }

    // Computes the squared L2 norm of the vector
    fn norm_squared(&'a self) -> Self::Value {
        self.iter().map(|x| x * x).sum()
    }

    // Computes the L2 norm of the vector
    fn norm(&'a self) -> f64 {
        f64::sqrt(self.norm_squared().into())
    }
}