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

use crate::geometry::ntree::node::{Kind, Node, split::Split};
use std::{array::from_fn, ops::Add};

impl<const D: usize, const M: usize, const N: usize, T, U, V> Node<D, M, N, T, U, V>
where
    T: Add<Output = T> + Copy + Split,
    U: Copy,
    V: Copy,
{
    pub fn subdivide(&self, indices: [U; N]) -> Result<[Self; N], &'static str> {
        match self.kind {
            Kind::Leaf => {
                let corner = self.corner;
                let length = self.length.split();
                Ok(from_fn(|i| Node {
                    corner: from_fn(|axis| {
                        if (i >> axis) & 1 == 1 {
                            corner[axis] + length
                        } else {
                            corner[axis]
                        }
                    }),
                    length,
                    facets: from_fn(|f| {
                        let axis = f / 2;
                        if (i >> axis) & 1 == f % 2 {
                            None
                        } else {
                            Some(indices[i ^ (1 << axis)])
                        }
                    }),
                    kind: Kind::Leaf,
                    value: self.value,
                }))
            }
            Kind::Tree(_) => Err("cannot subdivide a tree"),
        }
    }
}