#include "sve/sve.hpp"
#include <arm_neon.h>
namespace sve::neon {
std::size_t count_gt_i32(std::span<const std::int32_t> d, std::int32_t thr) {
const auto* p = d.data();
const auto n = d.size();
const int32x4_t vthr = vdupq_n_s32(thr);
int32x4_t a0 = vdupq_n_s32(0), a1 = vdupq_n_s32(0);
int32x4_t a2 = vdupq_n_s32(0), a3 = vdupq_n_s32(0);
std::size_t i = 0, block = n & ~std::size_t{15};
for (; i < block; i += 16) {
int32x4_t v0 = vld1q_s32(p + i);
int32x4_t v1 = vld1q_s32(p + i + 4);
int32x4_t v2 = vld1q_s32(p + i + 8);
int32x4_t v3 = vld1q_s32(p + i + 12);
a0 = vsubq_s32(a0, vreinterpretq_s32_u32(vcgtq_s32(v0, vthr)));
a1 = vsubq_s32(a1, vreinterpretq_s32_u32(vcgtq_s32(v1, vthr)));
a2 = vsubq_s32(a2, vreinterpretq_s32_u32(vcgtq_s32(v2, vthr)));
a3 = vsubq_s32(a3, vreinterpretq_s32_u32(vcgtq_s32(v3, vthr)));
}
int32x4_t acc = vaddq_s32(vaddq_s32(a0, a1), vaddq_s32(a2, a3));
auto total = static_cast<std::size_t>(vaddvq_s32(acc));
for (; i < n; ++i) total += static_cast<std::size_t>(p[i] > thr);
return total;
}
std::size_t count_gt_f32(std::span<const float> d, float thr) {
const auto* p = d.data();
const auto n = d.size();
const float32x4_t vthr = vdupq_n_f32(thr);
int32x4_t a0 = vdupq_n_s32(0), a1 = vdupq_n_s32(0);
std::size_t i = 0, block = n & ~std::size_t{7};
for (; i < block; i += 8) {
float32x4_t v0 = vld1q_f32(p + i);
float32x4_t v1 = vld1q_f32(p + i + 4);
a0 = vsubq_s32(a0, vreinterpretq_s32_u32(vcgtq_f32(v0, vthr)));
a1 = vsubq_s32(a1, vreinterpretq_s32_u32(vcgtq_f32(v1, vthr)));
}
auto total = static_cast<std::size_t>(vaddvq_s32(vaddq_s32(a0, a1)));
for (; i < n; ++i) total += static_cast<std::size_t>(p[i] > thr);
return total;
}
std::int64_t sum_i32(std::span<const std::int32_t> d) {
const auto* p = d.data();
const auto n = d.size();
int64x2_t a0 = vdupq_n_s64(0), a1 = vdupq_n_s64(0);
std::size_t i = 0, block = n & ~std::size_t{7};
for (; i < block; i += 8) {
int32x4_t v0 = vld1q_s32(p + i);
int32x4_t v1 = vld1q_s32(p + i + 4);
a0 = vaddq_s64(a0, vpaddlq_s32(v0));
a1 = vaddq_s64(a1, vpaddlq_s32(v1));
}
std::int64_t total = vaddvq_s64(vaddq_s64(a0, a1)); for (; i < n; ++i) total += p[i];
return total;
}
std::optional<size_t> find_i32(std::span<const std::int32_t> d, std::int32_t needle) {
const auto* p = d.data();
const auto n = d.size();
const int32x4_t key = vdupq_n_s32(needle);
std::size_t i = 0, block = n & ~std::size_t{15};
for (; i < block; i += 16) {
uint32x4_t m0 = vceqq_s32(vld1q_s32(p + i), key);
uint32x4_t m1 = vceqq_s32(vld1q_s32(p + i + 4), key);
uint32x4_t m2 = vceqq_s32(vld1q_s32(p + i + 8), key);
uint32x4_t m3 = vceqq_s32(vld1q_s32(p + i + 12), key);
uint32x4_t any = vorrq_u32(vorrq_u32(m0, m1), vorrq_u32(m2, m3));
if (vmaxvq_u32(any) != 0) {
const uint32x4_t ms[4] = {m0, m1, m2, m3};
for (int k = 0; k < 4; ++k) {
alignas(16) std::uint32_t lanes[4];
vst1q_u32(lanes, ms[k]);
for (int lane = 0; lane < 4; ++lane)
if (lanes[lane])
return i + static_cast<std::size_t>(k) * 4 + static_cast<std::size_t>(lane);
}
}
}
for (; i < n; ++i)
if (p[i] == needle) return i;
return std::nullopt;
}
std::size_t filter_into_i32(std::span<const std::int32_t> d, std::int32_t thr,
std::span<std::int32_t> out) {
const auto* p = d.data();
auto* o = out.data();
const auto n = d.size();
const int32x4_t vthr = vdupq_n_s32(thr);
std::size_t w = 0, i = 0, block = n & ~std::size_t{3};
for (; i < block; i += 4) {
int32x4_t v = vld1q_s32(p + i);
uint32x4_t m = vcgtq_s32(v, vthr);
if (vminvq_u32(m) == 0xFFFFFFFFu) {
vst1q_s32(o + w, v);
w += 4;
continue;
}
if (vmaxvq_u32(m) == 0) continue;
alignas(16) std::uint32_t lanes[4];
alignas(16) std::int32_t vals[4];
vst1q_u32(lanes, m);
vst1q_s32(vals, v);
for (int lane = 0; lane < 4; ++lane)
if (lanes[lane]) o[w++] = vals[lane];
}
for (; i < n; ++i)
if (p[i] > thr) o[w++] = p[i];
return w;
}
}