rspp 0.1.7

rust probolistic programming.
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

use statrs::distribution::{Continuous, ContinuousCDF, Normal};
use statrs::statistics::Distribution;
pub struct GridMap {
    pub minx: f64,
    pub maxx: f64,
    pub miny: f64,
    pub maxy: f64,
    pub resolution: f64,
    pub std: f64,
}

impl GridMap {
    pub fn width(&self) -> (i64, i64) {
        let x_wid = (self.maxx - self.minx) / self.resolution;
        let y_wid = (self.maxy - self.miny) / self.resolution;
        (x_wid as i64, y_wid as i64)
    }
    pub fn init_gmap(&self) -> Vec<Vec<f64>> {
        let mut gmap = Vec::new();
        let w = self.width();
        for ix in 0..w.0 {
            let mut row = Vec::new();
            for iy in 0..w.1 {
                row.push(0.);
            }
            gmap.push(row);
        }
        gmap
    }
    pub fn gaussina_grid(&self, detect: &Vec<(f64, f64)>) {
        let mut gmap = self.init_gmap();
        let w = self.width();
        for ix in 0..w.0 {
            for iy in 0..w.1 {
                let x = (ix as f64) * self.resolution + self.minx;
                let y = (iy as f64) * self.resolution + self.miny;
                let dis = detect
                    .iter()
                    .map(|v| ((x - v.0).powf(2.) + (y - v.1).powf(2.)).sqrt())
                    .min_by(|a, b| a.total_cmp(b))
                    .unwrap();

                let norm = Normal::new(0., self.std).unwrap();
                gmap[ix as usize][iy as usize] = 1. - norm.cdf(dis);
            }
        }
    }
}

#[test]
fn test_gaussian_map() {
    let map = GridMap {
        minx: -3.,
        miny: -9.,
        maxx: 8.,
        maxy: 4.,
        resolution: 0.5,
        std: 5.,
    };
}