mesh-sieve 4.0.2

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

use crate::mesh_error::{MeshSieveError, RelationConflictKind};
use crate::topology::orientation::Sign;
use crate::topology::sieve::in_memory_oriented::InMemoryOrientedSieve;
use crate::topology::sieve::{InMemorySieve, Sieve};
use crate::topology::stack::{InMemoryStack, Stack};

#[test]
fn add_arrow_rejects_conflicting_payload() {
    let mut s = InMemorySieve::<u32, i32>::default();
    s.add_arrow(1, 2, 10).unwrap();
    let err = s.add_arrow(1, 2, 20).unwrap_err();
    assert!(matches!(
        err,
        MeshSieveError::RelationConflict {
            kind: RelationConflictKind::Payload,
            ..
        }
    ));
    let outs: Vec<_> = s.cone(1).collect();
    assert_eq!(outs.len(), 1);
    assert_eq!(outs[0], (2, 10));
    let ins: Vec<_> = s.support(2).collect();
    assert_eq!(ins, vec![(1, 10)]);
}

#[test]
fn add_cone_dedups() {
    let mut s = InMemorySieve::<u32, i32>::default();
    s.add_cone(1, vec![(2, 1), (2, 2), (3, 3)]);
    let mut cone: Vec<_> = s.cone(1).collect();
    cone.sort_by_key(|(d, _)| *d);
    assert_eq!(cone, vec![(2, 2), (3, 3)]);
}

#[test]
fn set_cone_last_wins_and_mirrors() {
    let mut s = InMemorySieve::<u32, i32>::default();
    s.set_cone(1, vec![(2, 1), (2, 9), (3, 3)]);
    let outs: Vec<_> = s.cone(1).collect();
    assert_eq!(outs.len(), 2);
    assert!(outs.contains(&(2, 9)));
    assert!(outs.contains(&(3, 3)));
    let ins: Vec<_> = s.support(2).collect();
    assert_eq!(ins, vec![(1, 9)]);
}

#[test]
fn oriented_add_rejects_payload_and_orientation_conflicts() {
    let mut s = InMemoryOrientedSieve::<u32, i32>::default();
    s.add_arrow_o(1, 2, 10, Sign(true)).unwrap();
    let err = s.add_arrow_o(1, 2, 20, Sign(false)).unwrap_err();
    assert!(matches!(
        err,
        MeshSieveError::RelationConflict {
            kind: RelationConflictKind::PayloadAndOrientation,
            ..
        }
    ));
    let outs: Vec<_> = s.cone(1).collect();
    assert_eq!(outs, vec![(2, 10)]);
    let outs_o: Vec<_> = s.cone_o(1).collect();
    assert_eq!(outs_o, vec![(2, Sign(true))]);
}

#[test]
fn stack_add_rejects_conflicting_payload() {
    let mut st = InMemoryStack::<u32, u32, i32>::default();
    st.add_arrow(1, 100, 7).unwrap();
    let err = st.add_arrow(1, 100, 9).unwrap_err();
    assert!(matches!(
        err,
        MeshSieveError::RelationConflict {
            kind: RelationConflictKind::Payload,
            ..
        }
    ));
    let ups: Vec<_> = st.lift(1).collect();
    assert_eq!(ups, vec![(100, 7)]);
    let downs: Vec<_> = st.drop(100).collect();
    assert_eq!(downs, vec![(1, 7)]);
}