paraxis 0.9.2

A simple rock-solid mathematics library.
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

use bitvec::{array::BitArray, order::Msb0};
use num_traits::Float;

use crate::maths::vec::Vector;

pub struct MortonCode<T: Float, const N: usize> {
    pub bits: BitArray<[u32; N], Msb0>,
    pub position: Vector<T, N>,
}
impl<'a, T: Float, const N: usize> MortonCode<T, N> {
    pub fn from_vector(position: Vector<T, N>, min: &Vector<T, N>) -> Self {
        let mut quantized = [0u64; N];
        let mut bits = BitArray::<[u32; N], Msb0>::ZERO;
        for i in 0..N {
            let axis_diff = position.inner[i] - min.inner[i];
            quantized[i] = axis_diff.to_u64().unwrap_or(0u64);
        }
        let mut current_bit = 0;
        for bit in (0..32).rev() {
            for axis in 0..N {
                let is_set = (quantized[axis] >> bit) & 1 == 1;
                if is_set {
                    bits.set(current_bit, true);
                }
                current_bit += 1;
                if current_bit >= N * 32 {
                    break;
                }
            }
        }
        Self { bits, position }
    }
}
impl<T: Float> MortonCode<T, 3> {
    pub fn to_u64(&self) -> u64 {
        let mut out = 0u64;
        // We want to capture the 'most detailed' bits.
        // If the bitset is long, the detail is usually at the end.
        let len = self.bits.len();
        let take = len.min(64);
        for i in 0..take {
            // Try reading from the end of the bit array
            if self.bits[len - 1 - i] {
                out |= 1u64 << i;
            }
        }
        out
    }
}