Function unpack_arithmetic_less_than

src/pack.rs:253–336

`FACTOR_POW_DIVISOR == (FACTOR as usize).pow(factor_to_divisor:: () as u32)` but as a constant.

(
        input: &mut &[u8],
        length: usize,
        out: &mut Vec<u8>,
    )

    /// `FACTOR_POW_DIVISOR == (FACTOR as usize).pow(factor_to_divisor::<FACTOR>() as u32)` but as a constant.
    fn unpack_arithmetic_less_than<
        const N: usize,
        const HISTOGRAM: usize,
        const FACTOR: usize,
        const FACTOR_POW_DIVISOR: usize,
    >(
        input: &mut &[u8],
        length: usize,
        out: &mut Vec<u8>,
    ) -> Result<[usize; HISTOGRAM]> {
        assert!(HISTOGRAM == N || HISTOGRAM == 0);
        assert!(FACTOR >= 2 && FACTOR >= N);
        let divisor = factor_to_divisor::<FACTOR>();
        assert_eq!(FACTOR.pow(divisor as u32), FACTOR_POW_DIVISOR);

        let original_input = *input;
        unpack_arithmetic::<FACTOR>(input, length, out)?;
        if HISTOGRAM == 0 {
            check_less_than::<N, HISTOGRAM, FACTOR>(out)
        } else {
            let floor = length / divisor;
            let ceil = crate::nightly::div_ceil_usize(length, divisor);
            let whole = &original_input[..floor];

            // Can only `partial_with_garbage % FACTOR` partial_length times as the rest are undefined garbage.
            let partial_length = length - floor * divisor;
            let partial_with_garbage = original_input[floor..ceil].first().copied();

            // POPCNT is much faster than histogram.
            let histogram = if FACTOR == 2 {
                assert_eq!(N, 2);
                assert_eq!(divisor, 8);
                let mut one_count = 0;
                let mut whole = whole;
                while let Ok(chunk) = consume_byte_arrays(&mut whole, 1) {
                    one_count += u64::from_ne_bytes(chunk[0]).count_ones() as usize;
                }
                for &byte in whole {
                    one_count += byte.count_ones() as usize;
                }
                if let Some(partial_with_garbage) = partial_with_garbage {
                    // Set undefined garbage bits to zero.
                    let partial = partial_with_garbage << (divisor - partial_length);
                    one_count += partial.count_ones() as usize;
                }
                Ok(std::array::from_fn(|i| match i {
                    0 => length - one_count,
                    1 => one_count,
                    _ => unreachable!(),
                }))
            } else {
                check_histogram(if whole.len() < 100 {
                    // Simple path: histogram of unpacked bytes.
                    let mut histogram = [0; FACTOR];
                    for &v in out.iter() {
                        // Safety: unpack_arithmetic::<FACTOR> returns bytes < FACTOR.
                        unsafe { *histogram.get_unchecked_mut(v as usize) += 1 };
                    }