mesh-sieve 4.0.1

Modular, high-performance Rust library for mesh and data management, designed for scientific computing and PDE codes.
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

#![allow(dead_code)]

use std::collections::{HashMap, HashSet};

/// `inv_assert*` fire in debug builds and whenever the `strict-invariants`
/// feature is enabled; they compile to no-ops otherwise.
#[cfg(any(debug_assertions, feature = "strict-invariants"))]
macro_rules! inv_assert {
    ($($tt:tt)*) => { assert!($($tt)*); };
}
#[cfg(any(debug_assertions, feature = "strict-invariants"))]
macro_rules! inv_assert_eq {
    ($($tt:tt)*) => { assert_eq!($($tt)*); };
}
#[cfg(not(any(debug_assertions, feature = "strict-invariants")))]
macro_rules! inv_assert {
    ($($tt:tt)*) => {
        ()
    };
}
#[cfg(not(any(debug_assertions, feature = "strict-invariants")))]
macro_rules! inv_assert_eq {
    ($($tt:tt)*) => {
        ()
    };
}
pub(crate) use inv_assert;
pub(crate) use inv_assert_eq;

#[inline]
pub fn count_pairs<P: Copy + Eq + std::hash::Hash>(
    it: impl IntoIterator<Item = (P, P)>,
) -> HashMap<(P, P), u32> {
    let mut m = HashMap::new();
    for e in it {
        *m.entry(e).or_insert(0) += 1;
    }
    m
}

#[inline]
pub fn assert_no_dups_per_src<P, D>(out: &HashMap<P, Vec<(P, D)>>)
where
    P: Copy + Eq + std::hash::Hash + std::fmt::Debug,
    D: std::fmt::Debug,
{
    for (src, vec) in out {
        let mut seen = HashSet::with_capacity(vec.len());
        for (dst, _) in vec {
            let fresh = seen.insert(*dst);
            inv_assert!(fresh, "duplicate edge detected: src={src:?} dst={dst:?}");
        }
    }
}

#[inline]
pub fn counts_equal<P>(
    a: &HashMap<(P, P), u32>,
    b: &HashMap<(P, P), u32>,
    label_a: &str,
    label_b: &str,
) where
    P: Copy + Eq + std::hash::Hash + std::fmt::Debug,
{
    inv_assert_eq!(
        a.len(),
        b.len(),
        "edge multiset cardinality mismatch ({label_a} vs {label_b})",
    );
    for (k, va) in a {
        let Some(vb) = b.get(k) else {
            inv_assert!(
                false,
                "edge present in {label_a} but missing in {label_b}: {k:?}"
            );
            continue;
        };
        inv_assert_eq!(
            va,
            vb,
            "edge multiplicity mismatch for {k:?}: {label_a}={va}, {label_b}={vb}"
        );
    }
}

#[cfg(any(debug_assertions, feature = "strict-invariants"))]
macro_rules! debug_invariants {
    ($s:expr) => {
        $s.debug_assert_invariants();
    };
}

#[cfg(not(any(debug_assertions, feature = "strict-invariants")))]
macro_rules! debug_invariants {
    ($s:expr) => {
        ()
    };
}

pub(crate) use debug_invariants;