sparse_matrix 0.6.3

A library to do linear algebra with sparse matrix
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

use std::ops::Mul;

use crate::vector::Vector;
use serde::{Serialize, Deserialize};

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
pub struct CsrMat {
    pub rows            : usize,
    pub columns         : usize,
    pub values          : Vec<f64>,
    pub columns_index   : Vec<usize>,
    pub rows_index      : Vec<usize> 
}

impl CsrMat {
    pub fn minres(&self, b : &Vector, relative_eps : f64) -> Result<Vector, &'static str> {
        let mut r = b.clone();
        let eps = relative_eps * b.norm();
        let mut x = Vector::null(b.len());
        let mut alpha;
        let mut ar;
        let mut arnorm;
        while r.norm() > eps {
            ar = (self * &r)?;
            arnorm = ar.norm();
            alpha = (&r * &ar)? / arnorm / arnorm;
            x = (&x + &(&r * alpha))?;
            r = (b - &(self * &x)?)?;
        }
        Ok(x)
    }
}

impl Mul<&Vector> for &CsrMat {
    type Output = Result<Vector, &'static str>;

    fn mul(self, rhs: &Vector) -> Self::Output {
        if self.columns != rhs.values.len() {
            Err("Invalid shapes")
        } else {
            let mut result = vec![0.; self.columns];
            for i in 0..self.rows_index.len()-1{
                let mut sum = 0.;
                for j in self.rows_index[i]..self.rows_index[i+1] {
                    sum += self.values[j] * rhs.values[self.columns_index[j]];
                }
                result[i] = sum;
            }
            Ok(Vector { values : result})
        }
    }
}