fanova 0.3.0

A Rust implementation of fANOVA (functional analysis of variance)
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 crate::decision_tree::DecisionTreeRegressor;
use crate::space::FeatureSpace;

#[derive(Debug)]
pub struct Partition {
    pub value: f64,
    pub space: FeatureSpace,
}

#[derive(Debug)]
pub struct TreePartitions {
    partitions: Vec<Partition>,
    space: FeatureSpace,
}

impl TreePartitions {
    pub fn new(regressor: &DecisionTreeRegressor, space: FeatureSpace) -> Self {
        let partitions = regressor.fold(
            space.clone(),
            |space, split| space.split(split.column, split.threshold),
            Vec::new(),
            |mut acc, space, value| {
                acc.push(Partition { value, space });
                acc
            },
        );
        Self { partitions, space }
    }

    pub fn mean_and_variance(&self) -> (f64, f64) {
        let overall_size = self.space.size();
        let weights = self
            .iter()
            .map(|p| p.space.size() / overall_size)
            .collect::<Vec<_>>();
        let mean = self
            .iter()
            .zip(weights.iter())
            .map(|(p, w)| w * p.value)
            .sum::<f64>();
        let variance = self
            .iter()
            .zip(weights.iter())
            .map(|(p, w)| w * (p.value - mean).powi(2))
            .sum::<f64>();
        (mean, variance)
    }

    pub fn iter(&self) -> impl Iterator<Item = &Partition> {
        self.partitions.iter()
    }
}