changeforest 1.2.1

Random Forests for Change Point Detection
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use ndarray::{Array1, Array2};
use std::clone::Clone;
use std::fmt;

#[derive(Debug, Clone)]
/// Container to hold results of the `gain_approx` method of the `GainApprox` trait.
pub struct ApproxGainResult {
    pub start: usize,
    pub stop: usize,
    pub guess: usize,
    pub gain: Array1<f64>,
    pub max_gain: Option<f64>,
    pub best_split: Option<usize>,
    pub likelihoods: Array2<f64>,
    pub predictions: Array1<f64>,
}

#[derive(Debug, Clone)]
/// Container to hold results of the `gain_full` method of the `Gain` trait.
pub struct FullGainResult {
    pub start: usize,
    pub stop: usize,
    pub max_gain: Option<f64>,
    pub best_split: Option<usize>,
    pub gain: Array1<f64>,
}

#[derive(Debug, Clone)]
pub enum GainResult {
    ApproxGainResult(ApproxGainResult),
    FullGainResult(FullGainResult),
}

impl GainResult {
    pub fn start(&self) -> usize {
        match self {
            GainResult::ApproxGainResult(result) => result.start,
            GainResult::FullGainResult(result) => result.start,
        }
    }

    pub fn stop(&self) -> usize {
        match self {
            GainResult::ApproxGainResult(result) => result.stop,
            GainResult::FullGainResult(result) => result.stop,
        }
    }

    pub fn max_gain(&self) -> Option<f64> {
        match self {
            GainResult::ApproxGainResult(result) => result.max_gain,
            GainResult::FullGainResult(result) => result.max_gain,
        }
    }

    pub fn best_split(&self) -> Option<usize> {
        match self {
            GainResult::ApproxGainResult(result) => result.best_split,
            GainResult::FullGainResult(result) => result.best_split,
        }
    }

    pub fn gain(&self) -> &Array1<f64> {
        match self {
            GainResult::ApproxGainResult(result) => &result.gain,
            GainResult::FullGainResult(result) => &result.gain,
        }
    }

    pub fn guess(&self) -> Option<usize> {
        match self {
            GainResult::ApproxGainResult(result) => Some(result.guess),
            GainResult::FullGainResult(_) => None,
        }
    }

    pub fn likelihoods(&self) -> Option<&Array2<f64>> {
        match self {
            GainResult::ApproxGainResult(result) => Some(&result.likelihoods),
            GainResult::FullGainResult(_) => None,
        }
    }

    pub fn predictions(&self) -> Option<&Array1<f64>> {
        match self {
            GainResult::ApproxGainResult(result) => Some(&result.predictions),
            GainResult::FullGainResult(_) => None,
        }
    }
}

// https://doc.rust-lang.org/rust-by-example/hello/print/print_display.html
impl fmt::Display for GainResult {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            GainResult::ApproxGainResult(result) => write!(
                f,
                "ApproxGainResult(start={}, stop={}, guess={}, gain={})",
                result.start, result.stop, result.guess, result.gain
            ),
            GainResult::FullGainResult(result) => write!(
                f,
                "FullGainResult(start={}, stop={}, gain={})",
                result.start, result.stop, result.gain
            ),
        }
    }
}