pelt 0.3.1

Changepoint detection with Pruned Exact Linear Time
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
109
110
111
112
113
114

//! Array dimensions-specific implementation.

use std::ops::Range;

use ndarray::{ArrayView, ArrayView1, ArrayView2, Dimension, Ix1, Ix2};

use crate::{
    SegmentCostFunction,
    cost::{Cost1D, Cost2D},
};

/// Don't allow other crates to implement this.
mod sealed {
    use ndarray::{Ix1, Ix2};

    /// Don't allow other crates to implement this.
    pub trait Sealed {}

    impl Sealed for Ix1 {}
    impl Sealed for Ix2 {}
}

/// Trait allowing the input array to be both 1 and two dimensional.
pub trait OneOrTwoDimensions: Dimension + sealed::Sealed {
    type PrecalculationOutput;

    /// Amount of rows.
    #[doc(hidden)]
    fn len_or_nrows(array: &ArrayView<f64, Self>) -> usize;

    /// Precalculate function.
    #[doc(hidden)]
    fn precalculate(
        cost: SegmentCostFunction,
        signal: &ArrayView<f64, Self>,
    ) -> Self::PrecalculationOutput;

    /// Calculate the loss.
    #[doc(hidden)]
    fn loss(
        cost: &Self::PrecalculationOutput,
        total_loss: &mut f64,
        signal: &ArrayView<f64, Self>,
        range: Range<usize>,
    );

    /// Convert to 1D if possible.
    #[doc(hidden)]
    fn try_as_1d<'a>(array: &'a ArrayView<f64, Self>) -> Option<ArrayView1<'a, f64>>;
}

impl OneOrTwoDimensions for Ix1 {
    type PrecalculationOutput = Cost1D;

    #[inline]
    fn len_or_nrows(array: &ArrayView1<f64>) -> usize {
        array.len()
    }

    #[inline]
    fn precalculate(
        cost: SegmentCostFunction,
        signal: &ArrayView1<f64>,
    ) -> Self::PrecalculationOutput {
        Self::PrecalculationOutput::precalculate(cost, signal)
    }

    #[inline]
    fn loss(
        cost: &Self::PrecalculationOutput,
        total_loss: &mut f64,
        signal: &ArrayView1<f64>,
        range: Range<usize>,
    ) {
        cost.loss(total_loss, signal, range)
    }

    #[inline]
    fn try_as_1d<'a>(_array: &'a ArrayView1<f64>) -> Option<ArrayView1<'a, f64>> {
        None
    }
}

impl OneOrTwoDimensions for Ix2 {
    type PrecalculationOutput = Cost2D;

    #[inline]
    fn len_or_nrows(array: &ArrayView2<f64>) -> usize {
        array.nrows()
    }

    #[inline]
    fn precalculate(
        cost: SegmentCostFunction,
        signal: &ArrayView2<f64>,
    ) -> Self::PrecalculationOutput {
        Self::PrecalculationOutput::precalculate(cost, signal)
    }

    #[inline]
    fn loss(
        cost: &Self::PrecalculationOutput,
        total_loss: &mut f64,
        signal: &ArrayView2<f64>,
        range: Range<usize>,
    ) {
        cost.loss(total_loss, signal, range)
    }

    #[inline]
    fn try_as_1d<'a>(array: &'a ArrayView<f64, Self>) -> Option<ArrayView1<'a, f64>> {
        (array.ncols() == 1).then(|| array.column(0))
    }
}