rantlib 0.1.0

Analysis Library for Non-linear Dynamical Systems written in Rust
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

use super::{ParallelVectorGenerator, VectorGenerator};

pub struct ScanOptions {
    pub resolutions: Vec<usize>,
}

pub struct VectorGenerator1D {
    pub resolution: usize,
}

impl VectorGenerator for VectorGenerator1D {
    type Vector = (usize, usize);

    fn generate_scan_vectors(self) -> impl Iterator<Item = Self::Vector> {
        (0..=self.resolution).map(move |p| (p, self.resolution))
    }

    fn size_hint(&self) -> usize {
        self.resolution + 1
    }
}

pub struct VectorGenerator2D {
    pub resolution: (usize, usize),
}

impl VectorGenerator for VectorGenerator2D {
    type Vector = [(usize, usize); 2];

    fn generate_scan_vectors(self) -> impl Iterator<Item = Self::Vector> {
        let (resolution_x, resolution_y) = self.resolution;
        (0..=resolution_x).flat_map(move |x| {
            (0..=resolution_y).map(move |y| [(x, resolution_x), (y, resolution_y)])
        })
    }

    fn size_hint(&self) -> usize {
        (self.resolution.0 + 1) * (self.resolution.1 + 1)
    }
}

// TODO: maybe allow chunking by y?
#[derive(Debug, Clone)]
pub struct ParallelVectorGenerator2D {
    pub resolution: (usize, usize),
}

impl ParallelVectorGenerator for ParallelVectorGenerator2D {
    type Vector = [(usize, usize); 2];

    fn generate_scan_vectors(self) -> impl Iterator<Item = impl Iterator<Item = Self::Vector>> {
        let (resolution_chunks, resolution_points) = self.resolution;
        (0..=resolution_chunks).map(move |x| {
            (0..=resolution_points).map(move |y| [(x, resolution_chunks), (y, resolution_points)])
        })
    }

    fn num_chunks(&self) -> usize {
        self.resolution.0 + 1
    }

    fn size_hint(&self) -> usize {
        (self.resolution.0 + 1) * (self.resolution.1 + 1)
    }
}