use crate::backend_ops::BackendOps;
use coeus_core::{CpuAddressableStorage, CpuAddressableStorageMut, Scalar};
use coeus_tensor::Tensor;
#[inline]
pub fn repeat_interleave<T: Scalar, B: BackendOps<T> + Default>(
input: &Tensor<T, B>,
repeats: usize,
dim: usize,
_backend: &B,
) -> Tensor<T, B>
where
B::DeviceBuffer<T>: CpuAddressableStorage<T> + CpuAddressableStorageMut<T>,
{
assert!(repeats > 0, "repeat_interleave: repeats must be > 0");
let ndim = input.ndim();
assert!(
dim < ndim,
"repeat_interleave: dim {dim} out of range for {ndim}-D tensor"
);
let in_shape = input.shape();
let mut out_shape = in_shape.to_vec();
out_shape[dim] *= repeats;
let in_cont = input.to_contiguous();
let in_s = in_cont.as_slice();
let mut in_strides = vec![1usize; ndim];
for d in (0..ndim - 1).rev() {
in_strides[d] = in_strides[d + 1] * in_shape[d + 1];
}
let mut out_strides = vec![1usize; ndim];
for d in (0..ndim - 1).rev() {
out_strides[d] = out_strides[d + 1] * out_shape[d + 1];
}
let out_numel: usize = out_shape.iter().product();
let out_data: Vec<T> = (0..out_numel)
.map(|flat_out| {
let mut rem = flat_out;
let mut in_flat = 0usize;
for d in 0..ndim {
let coord = rem / out_strides[d];
rem %= out_strides[d];
let c = if d == dim { coord / repeats } else { coord };
in_flat += c * in_strides[d];
}
in_s[in_flat]
})
.collect();
Tensor::from_slice(out_shape, &out_data)
}