use core::arch::aarch64::*;
#[target_feature(enable = "neon")]
pub unsafe fn count_gt_i32(data: &[i32], threshold: i32) -> usize {
let n = data.len();
let p = data.as_ptr();
let thr = vdupq_n_s32(threshold); let mut a0 = vdupq_n_s32(0);
let mut a1 = vdupq_n_s32(0);
let mut a2 = vdupq_n_s32(0);
let mut a3 = vdupq_n_s32(0);
let mut i = 0usize;
let block = n & !15usize;
while i < block {
let v0 = vld1q_s32(p.add(i));
let v1 = vld1q_s32(p.add(i + 4));
let v2 = vld1q_s32(p.add(i + 8));
let v3 = vld1q_s32(p.add(i + 12));
let m0 = vreinterpretq_s32_u32(vcgtq_s32(v0, thr));
let m1 = vreinterpretq_s32_u32(vcgtq_s32(v1, thr));
let m2 = vreinterpretq_s32_u32(vcgtq_s32(v2, thr));
let m3 = vreinterpretq_s32_u32(vcgtq_s32(v3, thr));
a0 = vsubq_s32(a0, m0);
a1 = vsubq_s32(a1, m1);
a2 = vsubq_s32(a2, m2);
a3 = vsubq_s32(a3, m3);
i += 16;
}
let acc = vaddq_s32(vaddq_s32(a0, a1), vaddq_s32(a2, a3));
let mut total = vaddvq_s32(acc) as usize;
while i < n {
total += (*p.add(i) > threshold) as usize;
i += 1;
}
total
}
#[target_feature(enable = "neon")]
pub unsafe fn count_gt_f32(data: &[f32], threshold: f32) -> usize {
let n = data.len();
let p = data.as_ptr();
let thr = vdupq_n_f32(threshold);
let mut a0 = vdupq_n_s32(0);
let mut a1 = vdupq_n_s32(0);
let mut i = 0usize;
let block = n & !7usize;
while i < block {
let v0 = vld1q_f32(p.add(i));
let v1 = vld1q_f32(p.add(i + 4));
let m0 = vreinterpretq_s32_u32(vcgtq_f32(v0, thr));
let m1 = vreinterpretq_s32_u32(vcgtq_f32(v1, thr));
a0 = vsubq_s32(a0, m0);
a1 = vsubq_s32(a1, m1);
i += 8;
}
let mut total = vaddvq_s32(vaddq_s32(a0, a1)) as usize;
while i < n {
total += (*p.add(i) > threshold) as usize;
i += 1;
}
total
}
#[target_feature(enable = "neon")]
pub unsafe fn sum_i32(data: &[i32]) -> i64 {
let n = data.len();
let p = data.as_ptr();
let mut a0 = vdupq_n_s64(0);
let mut a1 = vdupq_n_s64(0);
let mut i = 0usize;
let block = n & !7usize;
while i < block {
let v0 = vld1q_s32(p.add(i));
let v1 = vld1q_s32(p.add(i + 4));
a0 = vaddq_s64(a0, vpaddlq_s32(v0));
a1 = vaddq_s64(a1, vpaddlq_s32(v1));
i += 8;
}
let mut total = vaddvq_s64(vaddq_s64(a0, a1));
while i < n {
total += *p.add(i) as i64;
i += 1;
}
total
}
#[target_feature(enable = "neon")]
pub unsafe fn find_i32(data: &[i32], needle: i32) -> Option<usize> {
let n = data.len();
let p = data.as_ptr();
let key = vdupq_n_s32(needle);
let mut i = 0usize;
let block = n & !15usize;
while i < block {
let v0 = vld1q_s32(p.add(i));
let v1 = vld1q_s32(p.add(i + 4));
let v2 = vld1q_s32(p.add(i + 8));
let v3 = vld1q_s32(p.add(i + 12));
let e0 = vceqq_s32(v0, key);
let e1 = vceqq_s32(v1, key);
let e2 = vceqq_s32(v2, key);
let e3 = vceqq_s32(v3, key);
let any = vorrq_u32(vorrq_u32(e0, e1), vorrq_u32(e2, e3));
if vmaxvq_u32(any) != 0 {
for (k, e) in [e0, e1, e2, e3].into_iter().enumerate() {
let mut lanes = [0u32; 4];
vst1q_u32(lanes.as_mut_ptr(), e);
for (l, &val) in lanes.iter().enumerate() {
if val != 0 {
return Some(i + k * 4 + l);
}
}
}
}
i += 16;
}
while i < n {
if *p.add(i) == needle {
return Some(i);
}
i += 1;
}
None
}
#[target_feature(enable = "neon")]
pub unsafe fn filter_into_i32(data: &[i32], threshold: i32, out: &mut [i32]) -> usize {
debug_assert!(data.is_empty() || !out.is_empty());
let n = data.len();
let p = data.as_ptr();
let o = out.as_mut_ptr();
let thr = vdupq_n_s32(threshold);
let mut w = 0usize;
let mut i = 0usize;
let block = n & !3usize;
while i < block {
let v = vld1q_s32(p.add(i));
let m = vcgtq_s32(v, thr);
if vmaxvq_u32(m) != 0 {
let mut lanes = [0i32; 4];
let mut flags = [0u32; 4];
vst1q_s32(lanes.as_mut_ptr(), v);
vst1q_u32(flags.as_mut_ptr(), m);
for l in 0..4 {
if flags[l] != 0 {
*o.add(w) = lanes[l];
w += 1;
}
}
}
i += 4;
}
while i < n {
let x = *p.add(i);
if x > threshold {
*o.add(w) = x;
w += 1;
}
i += 1;
}
w
}