agentbible 0.1.0

Language-agnostic correctness checker for scientific numerical code
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

#[macro_export]
macro_rules! validate_finite {
    ($x:expr) => {
        if let Err(error) = $crate::check::check_finite($x) {
            $crate::check::fail_with_provenance("finite", 0.0, 0.0, "n/a", &error.to_string());
        }
    };
}

#[macro_export]
macro_rules! validate_finite_array {
    ($arr:expr) => {
        if let Err(error) = $crate::check::check_finite_array($arr) {
            $crate::check::fail_with_provenance(
                "finite_array",
                0.0,
                0.0,
                "n/a",
                &error.to_string(),
            );
        }
    };
}

#[macro_export]
macro_rules! validate_positive {
    ($x:expr) => {
        if let Err(error) = $crate::check::check_positive($x) {
            $crate::check::fail_with_provenance("positive", 0.0, 0.0, "n/a", &error.to_string());
        }
    };
}

#[macro_export]
macro_rules! validate_probability {
    ($x:expr) => {
        if let Err(error) = $crate::check::check_probability($x) {
            $crate::check::fail_with_provenance("probability", 0.0, 0.0, "n/a", &error.to_string());
        }
    };
}

#[macro_export]
macro_rules! validate_normalized_l1 {
    ($arr:expr, $atol:expr) => {
        if let Err(error) = $crate::check::check_normalized_l1($arr, $atol) {
            $crate::check::fail_with_provenance(
                "normalized_l1",
                0.0,
                $atol,
                "l1",
                &error.to_string(),
            );
        }
    };
}

#[macro_export]
macro_rules! validate_unitary {
    ($matrix:expr) => {
        if let Err(error) = $crate::check::check_unitary($matrix) {
            $crate::check::fail_with_provenance(
                "unitary",
                1e-10,
                1e-12,
                "frobenius",
                &error.to_string(),
            );
        }
    };
}

#[macro_export]
macro_rules! validate_unitary_tol {
    ($matrix:expr, $rtol:expr, $atol:expr) => {
        if let Err(error) = $crate::check::check_unitary_tol($matrix, $rtol, $atol) {
            $crate::check::fail_with_provenance(
                "unitary",
                $rtol,
                $atol,
                "frobenius",
                &error.to_string(),
            );
        }
    };
}

#[macro_export]
macro_rules! validate_positive_definite {
    ($matrix:expr) => {
        if let Err(error) = $crate::check::check_positive_definite($matrix) {
            $crate::check::fail_with_provenance(
                "positive_definite",
                0.0,
                0.0,
                "n/a",
                &error.to_string(),
            );
        }
    };
}