[RUST] argmin and argmax kernel for numeric array

[eddyxu]

No description provided.

[changhiskhan]

arrow has "sort_valids" like

fn sort_valids<T, U>(
    descending: bool,
    valids: &mut [(u32, T)],
    nulls: &mut [U],
    len: usize,
    mut cmp: impl FnMut(T, T) -> Ordering,
) where
    T: ?Sized + Copy,
{
    let valids_len = valids.len();
    if !descending {
        sort_unstable_by(valids, len.min(valids_len), |a, b| cmp(a.1, b.1));
    } else {
        sort_unstable_by(valids, len.min(valids_len), |a, b| cmp(a.1, b.1).reverse());
        // reverse to keep a stable ordering
        nulls.reverse();
    }
}

fn sort_valids_array<T>(
    descending: bool,
    valids: &mut [(u32, ArrayRef)],
    nulls: &mut [T],
    len: usize,
) {
    let valids_len = valids.len();
    if !descending {
        sort_unstable_by(valids, len.min(valids_len), |a, b| {
            cmp_array(a.1.as_ref(), b.1.as_ref())
        });
    } else {
        sort_unstable_by(valids, len.min(valids_len), |a, b| {
            cmp_array(a.1.as_ref(), b.1.as_ref()).reverse()
        });
        // reverse to keep a stable ordering
        nulls.reverse();
    }
}

does it make sense to do the same here? curious what the perf difference is

[eddyxu]

I feel that we can add validity check later if we (lance) have a use case. For one, we are not using it as general purpose kernel yet. The second, this code does not have memory copy/allocation, which supposes to be faster.

     // create tuples that are used for sorting
    let valids = {
        let values = as_primitive_array::<T>(values);
        value_indices
            .into_iter()
            .map(|index| (index, values.value(index as usize)))
            .collect::<Vec<(u32, T::Native)>>(). <----- HERE
    };
    sort_primitive_inner(values.len(), null_indices, cmp, options, limit, valids)