score-set 3.0.0

A Rust library for building static weighted scoring operator sets
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

mod support;

use score_set::{
    DynScoreSet32, DynScoreSet64, metric32, metric64,
    traits::{EvalF32, EvalF64},
    weight32, weight64,
};
use support::{
    Context32, Context64, CpuUsage32, CpuUsage64, Identity32, Identity64, Latency32, Latency64,
    LowerIsBetter32, LowerIsBetter64,
};

#[test]
fn f64_dyn_score_set_sums_heterogeneous_metrics() {
    let score_set = DynScoreSet64::<Context64>::builder()
        .append(metric64(
            Latency64,
            LowerIsBetter64 { limit: 100.0 },
            weight64(0.7).unwrap(),
        ))
        .append(metric64(CpuUsage64, Identity64, weight64(0.3).unwrap()))
        .build();

    let cases = [
        (
            Context64 {
                latency_ms: 40.0,
                cpu_usage: 0.25,
            },
            0.495,
        ),
        (
            Context64 {
                latency_ms: 0.0,
                cpu_usage: 1.0,
            },
            1.0,
        ),
        (
            Context64 {
                latency_ms: 200.0,
                cpu_usage: -1.0,
            },
            0.0,
        ),
    ];

    for (ctx, expected) in cases {
        let actual = score_set.eval(&ctx);
        assert!(
            (actual - expected).abs() < 1e-12,
            "expected {expected}, got {actual}",
        );
    }
}

#[test]
fn f32_dyn_score_set_sums_heterogeneous_metrics() {
    let score_set = DynScoreSet32::<Context32>::builder()
        .append(metric32(
            Latency32,
            LowerIsBetter32 { limit: 100.0 },
            weight32(0.7).unwrap(),
        ))
        .append(metric32(CpuUsage32, Identity32, weight32(0.3).unwrap()))
        .build();

    let cases = [
        (
            Context32 {
                latency_ms: 40.0,
                cpu_usage: 0.25,
            },
            0.495,
        ),
        (
            Context32 {
                latency_ms: 0.0,
                cpu_usage: 1.0,
            },
            1.0,
        ),
        (
            Context32 {
                latency_ms: 200.0,
                cpu_usage: -1.0,
            },
            0.0,
        ),
    ];

    for (ctx, expected) in cases {
        let actual = score_set.eval(&ctx);
        assert!(
            (actual - expected).abs() < 1e-6,
            "expected {expected}, got {actual}",
        );
    }
}

#[test]
fn empty_f64_dyn_score_set_evaluates_to_zero() {
    let score_set = DynScoreSet64::<Context64>::builder().build();
    let ctx = Context64 {
        latency_ms: 40.0,
        cpu_usage: 0.25,
    };

    assert_eq!(score_set.eval(&ctx), 0.0);
}

#[test]
fn empty_f32_dyn_score_set_evaluates_to_zero() {
    let score_set = DynScoreSet32::<Context32>::builder().build();
    let ctx = Context32 {
        latency_ms: 40.0,
        cpu_usage: 0.25,
    };

    assert_eq!(score_set.eval(&ctx), 0.0);
}