score-set 0.1.1

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

use crate::lab::gc_ratio;
use crate::*;

#[test]
fn metric_builder_eval() {
    let m = metric("gc")
        .measure()
        .by(|dna: &&str| gc_ratio(dna))
        .map01()
        .by(|raw: &f64, _: &&str| Value01::witness(*raw).unwrap());

    assert_eq!(m.name(), "gc");

    let result = m.eval(&"ACGT");
    assert!((*result - 0.5).abs() < 1e-10);
}

#[test]
fn metric_with_empty_input() {
    let m = metric("gc-empty")
        .measure()
        .by(|dna: &&str| gc_ratio(dna))
        .map01()
        .by(|raw: &f64, _: &&str| Value01::witness(*raw).unwrap());

    let result = m.eval(&"");
    assert!((*result - 0.0).abs() < 1e-10);
}

#[test]
fn metric_usize_input() {
    let m = metric("len")
        .measure()
        .by(|len: &usize| *len)
        .map01()
        .by(|raw: &usize, _: &usize| {
            Value01::witness((*raw as f64 / 100.0).min(1.0)).unwrap()
        });

    assert_eq!(m.name(), "len");

    let result = m.eval(&50);
    assert!((*result - 0.5).abs() < 1e-10);

    let result2 = m.eval(&200);
    assert!((*result2 - 1.0).abs() < 1e-10);
}

#[test]
fn map01_identity() {
    let m = metric("id")
        .measure()
        .by(|v: &f64| *v)
        .map01()
        .identity();

    assert!((*m.eval(&0.5) - 0.5).abs() < 1e-10);
    assert!((*m.eval(&1.5) - 1.0).abs() < 1e-10);
    assert!((*m.eval(&-0.5) - 0.0).abs() < 1e-10);
}

#[test]
fn map01_linear() {
    let m = metric("lin")
        .measure()
        .by(|v: &f64| *v)
        .map01()
        .linear(200.0);

    assert!((*m.eval(&100.0) - 0.5).abs() < 1e-10);
    assert!((*m.eval(&300.0) - 1.0).abs() < 1e-10);
}

#[test]
fn map01_sigmoid() {
    let m = metric("sig")
        .measure()
        .by(|v: &f64| *v)
        .map01()
        .sigmoid(-5.0, 5.0);

    let mid = m.eval(&0.0);
    assert!((*mid - 0.5).abs() < 1e-3);

    let low = m.eval(&-5.0);
    assert!(*low < 0.01);

    let high = m.eval(&5.0);
    assert!(*high > 0.99);
}

#[test]
fn map01_cauchy() {
    let m = metric("cauchy")
        .measure()
        .by(|v: &f64| *v)
        .map01()
        .cauchy(1.0, 1.0);

    let result = m.eval(&1.0);
    assert!((*result - 0.5).abs() < 1e-6);
}

#[test]
fn map01_cauchy_asymmetric() {
    let m = metric("cauchy-asym")
        .measure()
        .by(|v: &f64| *v)
        .map01()
        .cauchy(0.5, 2.0);

    assert!((*m.eval(&-0.5) - 0.5).abs() < 1e-6);
    assert!((*m.eval(&2.0) - 0.5).abs() < 1e-6);
}