harmos-storage 0.1.4

Harmos storage: durable journals, snapshots and Arrow-backed stream storage.
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
115
116
117
118
119
120
121
122
123
124

/* ***
 *
 * Harmos
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * ***
 */

/* === Modules === */

/* === Re-Exports === */

/* === Imports === */

// Standard Library Imports

// Third Party Imports

// Local Imports

/* === Constants === */

/* === Macros === */

/* === Type Aliases === */

/* === Structs === */

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Edge {
    pub at: f64,
    pub rising: bool,
}

/* === Enums === */

#[derive(Clone, Copy)]
enum Level {
    Beneath,
    Between,
    Above,
}

/* === Traits === */

/* === Implementations === */

/* === Public Functions === */

#[must_use]
pub fn edges(x: &[f64], y: &[f64], low: f64, high: f64) -> Vec<Edge> {
    let length = x.len().min(y.len());
    if length < 2 {
        return Vec::new();
    }

    let lowest = y[..length].iter().copied().fold(f64::INFINITY, f64::min);
    let highest = y[..length].iter().copied().fold(f64::NEG_INFINITY, f64::max);
    let range = highest - lowest;
    if !range.is_finite() || range < f64::EPSILON {
        return Vec::new();
    }

    let (low, high) = (lowest + range * low, lowest + range * high);
    let mut state = level(y[0], low, high);
    let mut found = Vec::new();

    for index in 1..length {
        let (previous, current) = (y[index - 1], y[index]);

        match state {
            Level::Beneath if current > high => {
                found.push(Edge { at: crossed(x, index, high, previous, current), rising: true });
                state = Level::Above;
            }
            Level::Above if current < low => {
                found.push(Edge { at: crossed(x, index, low, previous, current), rising: false });
                state = Level::Beneath;
            }
            Level::Between => state = level(current, low, high),
            Level::Beneath | Level::Above => {}
        }
    }

    found
}

#[must_use]
pub fn crossing(x: &[f64], y: &[f64], target: f64) -> Option<f64> {
    let length = x.len().min(y.len());

    (1..length).find_map(|index| {
        let (previous, current) = (y[index - 1], y[index]);
        let straddles = (previous <= target && target <= current) || (current <= target && target <= previous);

        straddles.then(|| crossed(x, index, target, previous, current))
    })
}

/* === Private Functions === */

fn level(value: f64, low: f64, high: f64) -> Level {
    if value > high {
        Level::Above
    } else if value < low {
        Level::Beneath
    } else {
        Level::Between
    }
}

fn crossed(x: &[f64], index: usize, target: f64, previous: f64, current: f64) -> f64 {
    let (before, after) = (x[index - 1], x[index]);
    let rise = current - previous;

    if rise.abs() < f64::EPSILON {
        return before;
    }

    before + (target - previous) / rise * (after - before)
}

/* === Tests === */