kryst 4.0.4

Krylov subspace and preconditioned iterative solvers for dense and sparse linear systems, with shared and distributed memory parallelism.
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

//! Reusable verification-state modeling for optional direct reference checks.

/// Normalized verification status for reporting direct reference checks.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VerificationStatus {
    Yes,
    No,
    Skip,
    Unavailable,
}

impl VerificationStatus {
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Yes => "yes",
            Self::No => "no",
            Self::Skip => "skip",
            Self::Unavailable => "unavailable",
        }
    }
}

/// Lightweight abstraction for direct-reference comparison payloads.
pub trait DirectReferenceLike {
    fn matches_verified_answer(&self) -> bool;
    fn policy_note(&self) -> &str;
}

/// Maps direct-reference comparison output and policy note into a normalized status.
pub fn verification_status_from_direct_reference<T: DirectReferenceLike>(
    comparison: Option<&T>,
) -> VerificationStatus {
    let Some(comparison) = comparison else {
        return VerificationStatus::Unavailable;
    };

    let note = comparison.policy_note().to_ascii_lowercase();
    let is_skip = note.starts_with("skip:")
        || note.contains("auto skip")
        || note.contains("forced off")
        || note.contains("policy skip");
    if is_skip {
        return VerificationStatus::Skip;
    }

    let is_unavailable = note.contains("feature is disabled")
        || note.contains("not enabled")
        || note.contains("unavailable")
        || note.contains("prevented")
        || note.contains("direct lu failed");
    if is_unavailable {
        return VerificationStatus::Unavailable;
    }

    if comparison.matches_verified_answer() {
        VerificationStatus::Yes
    } else {
        VerificationStatus::No
    }
}

#[cfg(test)]
mod tests {
    use super::{
        DirectReferenceLike, VerificationStatus, verification_status_from_direct_reference,
    };

    struct MockCmp {
        matches: bool,
        note: &'static str,
    }

    impl DirectReferenceLike for MockCmp {
        fn matches_verified_answer(&self) -> bool {
            self.matches
        }

        fn policy_note(&self) -> &str {
            self.note
        }
    }

    #[test]
    fn maps_yes_no_skip_and_unavailable() {
        let yes = MockCmp {
            matches: true,
            note: "auto: density 1.0e-1 >= 1.0e-1 and size gate passed",
        };
        assert_eq!(
            verification_status_from_direct_reference(Some(&yes)),
            VerificationStatus::Yes
        );

        let no = MockCmp {
            matches: false,
            note: "env override: forced on",
        };
        assert_eq!(
            verification_status_from_direct_reference(Some(&no)),
            VerificationStatus::No
        );

        let skip = MockCmp {
            matches: false,
            note: "auto skip: density 2.1e-3 < 1.0e-1 (size gate passed)",
        };
        assert_eq!(
            verification_status_from_direct_reference(Some(&skip)),
            VerificationStatus::Skip
        );

        let unavailable = MockCmp {
            matches: false,
            note: "env override: forced on; direct LU failed (dense-direct feature is disabled)",
        };
        assert_eq!(
            verification_status_from_direct_reference(Some(&unavailable)),
            VerificationStatus::Unavailable
        );
    }
}