conspire 0.7.1

The Rust interface to conspire.
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
115
116
117
118
119
120
121

use crate::geometry::ntree::{
    Orthotree,
    node::{Kind, Node},
    subdivide::insert_bit,
};
use std::array::from_fn;

impl<const D: usize, const L: usize, const M: usize, const N: usize, T, U>
    Orthotree<D, L, M, N, T, U>
where
    T: Copy + Into<usize>,
    U: Copy + Into<usize>,
{
    pub fn all_leaves<'a>(&self, node: &'a Node<D, M, N, T, U>) -> Option<&'a [U; N]> {
        match &node.kind {
            Kind::Leaf => None,
            Kind::Tree(orthants) => {
                if orthants.iter().any(|&orthant| self[orthant].is_tree()) {
                    None
                } else {
                    Some(orthants)
                }
            }
        }
    }
    pub fn leaves(&self, node: &Node<D, M, N, T, U>) -> [Option<U>; N] {
        match &node.kind {
            Kind::Leaf => [None; N],
            Kind::Tree(orthants) => from_fn(|i| {
                if self[orthants[i]].is_leaf() {
                    Some(orthants[i])
                } else {
                    None
                }
            }),
        }
    }
    pub fn leaves_on_facet(&self, node: &Node<D, M, N, T, U>, facet: usize) -> [Option<U>; L] {
        let (axis, side) = (facet >> 1, facet & 1);
        match &node.kind {
            Kind::Leaf => from_fn(|_| None),
            Kind::Tree(orthants) => from_fn(|i| {
                let orthant = orthants[insert_bit(i, axis, side)];
                self[orthant].is_leaf().then_some(orthant)
            }),
        }
    }
    pub fn leaves_and_facets(
        &self,
        node: &Node<D, M, N, T, U>,
    ) -> [Option<(U, [Option<U>; D])>; N] {
        match &node.kind {
            Kind::Leaf => from_fn(|_| None),
            Kind::Tree(orthants) => from_fn(|i| {
                let orthant = orthants[i];
                if self[orthant].is_leaf() {
                    let facets = &self[orthant].facets;
                    let external: [Option<U>; D] = from_fn(|b| facets[2 * b + ((i >> b) & 1)]);
                    Some((orthant, external))
                } else {
                    None
                }
            }),
        }
    }
    pub fn orthants_leaves(&self, node: &Node<D, M, N, T, U>) -> [Option<[Option<U>; N]>; N] {
        match &node.kind {
            Kind::Leaf => from_fn(|_| None),
            Kind::Tree(orthants) => from_fn(|i| match &self[orthants[i]].kind {
                Kind::Leaf => None,
                Kind::Tree(sub_orthants) => {
                    let inner: [Option<U>; N] = from_fn(|j| {
                        if self[sub_orthants[j]].is_leaf() {
                            Some(sub_orthants[j])
                        } else {
                            None
                        }
                    });
                    if inner.iter().any(|x| x.is_some()) {
                        Some(inner)
                    } else {
                        None
                    }
                }
            }),
        }
    }
    pub fn orthants_leaves_on_facet(
        &self,
        node: &Node<D, M, N, T, U>,
        face: usize,
    ) -> [Option<[Option<U>; L]>; L] {
        let (axis, side) = (face >> 1, face & 1);
        match &node.kind {
            Kind::Leaf => from_fn(|_| None),
            Kind::Tree(orthants) => {
                from_fn(|i| match &self[orthants[insert_bit(i, axis, side)]].kind {
                    Kind::Leaf => None,
                    Kind::Tree(sub_orthants) => {
                        let inner: [Option<U>; L] = from_fn(|j| {
                            let leaf = sub_orthants[insert_bit(j, axis, side)];
                            self[leaf].is_leaf().then_some(leaf)
                        });
                        inner.iter().any(|x| x.is_some()).then_some(inner)
                    }
                })
            }
        }
    }
    pub fn orthants_all_leaves_on_facet(
        &self,
        node: &Node<D, M, N, T, U>,
        face: usize,
    ) -> Option<[[U; L]; L]> {
        let orthants_leaves = self.orthants_leaves_on_facet(node, face);
        orthants_leaves
            .iter()
            .all(|&orthant| orthant.is_some_and(|leaves| leaves.iter().all(Option::is_some)))
            .then(|| from_fn(|i| from_fn(|j| orthants_leaves[i].unwrap()[j].unwrap())))
    }
}