vortex-array 0.62.0

Vortex in memory columnar data format
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

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

use vortex_error::VortexResult;
use vortex_mask::Mask;

use crate::arrays::BoolArray;
use crate::arrays::BoolVTable;
use crate::compute::IsSortedIteratorExt;
use crate::compute::IsSortedKernel;
use crate::compute::IsSortedKernelAdapter;
use crate::register_kernel;

impl IsSortedKernel for BoolVTable {
    fn is_sorted(&self, array: &BoolArray) -> VortexResult<Option<bool>> {
        match array.validity_mask()? {
            Mask::AllFalse(_) => Ok(Some(true)),
            Mask::AllTrue(_) => Ok(Some(array.to_bit_buffer().iter().is_sorted())),
            Mask::Values(mask_values) => {
                let set_indices = mask_values.bit_buffer().set_indices();
                let values = array.to_bit_buffer();
                let values_iter = set_indices.map(|idx|
                    // Safety:
                    // All idxs are in-bounds for the array.
                    unsafe {
                        values.value_unchecked(idx)
                    });

                Ok(Some(values_iter.is_sorted()))
            }
        }
    }

    fn is_strict_sorted(&self, array: &BoolArray) -> VortexResult<Option<bool>> {
        match array.validity_mask()? {
            Mask::AllFalse(_) => Ok(Some(false)),
            Mask::AllTrue(_) => Ok(Some(array.to_bit_buffer().iter().is_strict_sorted())),
            Mask::Values(mask_values) => {
                let validity_buffer = mask_values.bit_buffer();
                let values = array.to_bit_buffer();

                Ok(Some(
                    validity_buffer
                        .iter()
                        .zip(values.iter())
                        .map(|(is_valid, value)| is_valid.then_some(value))
                        .is_strict_sorted(),
                ))
            }
        }
    }
}

register_kernel!(IsSortedKernelAdapter(BoolVTable).lift());