rao 0.2.2

Robust and scalable Adaptive Optics tools
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

use rayon::prelude::*;
use std::fmt;

/// Convenience trait to standardise interactions with "matrix-like" objects.
pub trait Matrix {
    /// number of rows in the matrix
    fn nrows(&self) -> usize;
    /// number of columns in the matrix
    fn ncols(&self) -> usize;
    /// evaluated value of the matrix at a specified element.
    fn eval(&self, row_index: usize, col_index: usize) -> f64;

    /// Return the (C-format / row-major) flattened matrix, e.g., to
    /// be saved to disk.
    fn flattened_array(&self) -> Vec<f64>
    where
        Self: Sync,
    {
        (0..self.nrows())
            .into_par_iter()
            .map(move |row_index| {
                (0..self.ncols())
                    .into_par_iter()
                    .map(move |col_index| self.eval(row_index, col_index))
                    .collect::<Vec<f64>>()
            })
            .flatten()
            .collect()
    }

    /// Return the (C-format / row-major) interaction matrix as a [Vec<Vec<64>>]
    fn matrix(&self) -> Vec<Vec<f64>>
    where
        Self: Sync,
    {
        (0..self.nrows())
            .into_par_iter()
            .map(|row_index| {
                (0..self.ncols())
                    .into_par_iter()
                    .map(|col_index| self.eval(row_index, col_index))
                    .collect::<Vec<f64>>()
            })
            .collect()
    }

    /// format function, which can be used when implementing Display
    fn format(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        for row_index in 0..self.nrows() {
            match row_index {
                0 => write!(f, "[[")?,
                _ => write!(f, "\n [")?,
            }
            for col_index in 0..self.ncols() {
                write!(f, " {:5.2}", self.eval(row_index, col_index))?;
            }
            write!(f, " ]")?;
        }
        write!(f, "]")?;
        Ok(())
    }

    /// sample the matrix at specified entries (e.g., for efficient sparse
    /// operations). Note that the matrix elements are only evaluated where
    /// the matrix is sampled.
    fn samples(&self, indices: Vec<(usize, usize)>) -> Vec<f64>
    where
        Self: Sync,
    {
        indices
            .into_par_iter()
            .map(|(row_index, col_index)| self.eval(row_index, col_index))
            .collect()
    }
}