use crate::application::index::{unit_stride_row_slice, RowMajorTraversal};
use crate::domain::real::RealScalar;
use leto::{Array, ArrayView, ArrayViewMut, LetoError, Result, VecStorage};
pub trait NormKind<T: RealScalar>: Copy + Send + Sync + 'static {
#[inline]
fn accumulate_slice(_slice: &[T]) -> Option<T> {
None
}
fn accumulate(acc: T, x: T) -> T;
#[inline]
fn combine(acc: T, row_acc: T) -> T {
Self::accumulate(acc, Self::finish(row_acc))
}
fn finish(acc: T) -> T;
}
#[derive(Clone, Copy, Debug, Default)]
pub struct NormL1;
#[derive(Clone, Copy, Debug, Default)]
pub struct NormL2;
#[derive(Clone, Copy, Debug, Default)]
pub struct NormMax;
impl<T: RealScalar> NormKind<T> for NormL1 {
#[inline]
fn accumulate_slice(slice: &[T]) -> Option<T> {
Some(T::abs_sum_slice(slice))
}
#[inline(always)]
fn accumulate(acc: T, x: T) -> T {
acc.add(x.abs())
}
#[inline(always)]
fn combine(acc: T, row_acc: T) -> T {
acc.add(row_acc)
}
#[inline(always)]
fn finish(acc: T) -> T {
acc
}
}
impl<T: RealScalar> NormKind<T> for NormL2 {
#[inline]
fn accumulate_slice(slice: &[T]) -> Option<T> {
Some(T::dot_slice(slice, slice))
}
#[inline(always)]
fn accumulate(acc: T, x: T) -> T {
acc.add(x.mul(x))
}
#[inline(always)]
fn combine(acc: T, row_acc: T) -> T {
acc.add(row_acc)
}
#[inline(always)]
fn finish(acc: T) -> T {
acc.sqrt()
}
}
impl<T: RealScalar> NormKind<T> for NormMax {
#[inline]
fn accumulate_slice(slice: &[T]) -> Option<T> {
Some(T::abs_max_slice(slice))
}
#[inline(always)]
fn accumulate(acc: T, x: T) -> T {
let magnitude = x.abs();
if magnitude > acc {
magnitude
} else {
acc
}
}
#[inline(always)]
fn combine(acc: T, row_acc: T) -> T {
if row_acc > acc {
row_acc
} else {
acc
}
}
#[inline(always)]
fn finish(acc: T) -> T {
acc
}
}
pub fn norm<K, T, const N: usize>(view: &ArrayView<'_, T, N>) -> Result<T>
where
K: NormKind<T>,
T: RealScalar,
{
view.layout().validate_storage_len(view.data().len())?;
if let Some(slice) = view.as_slice_memory_order() {
if let Some(acc) = K::accumulate_slice(slice) {
return Ok(K::finish(acc));
}
let mut acc = T::ZERO;
for &x in slice {
acc = K::accumulate(acc, x);
}
return Ok(K::finish(acc));
}
let size = view.layout().checked_size()?;
let shape = view.shape();
let layout = view.layout();
let data = view.data();
let mut acc = T::ZERO;
if let Some(traversal) = RowMajorTraversal::new(size, shape) {
let step = traversal.last_axis_stride(layout);
for row in 0..traversal.rows() {
let base_idx = traversal.base_index(row);
let mut offset = layout.offset_of(base_idx)? as isize;
if let Some(slice) = unit_stride_row_slice(data, offset, step, traversal.inner()) {
if let Some(row_acc) = K::accumulate_slice(slice) {
acc = K::combine(acc, row_acc);
continue;
}
}
for _ in 0..traversal.inner() {
acc = K::accumulate(acc, data[offset as usize]);
offset += step;
}
}
}
Ok(K::finish(acc))
}
#[inline]
pub fn norm_l1<T: RealScalar, const N: usize>(view: &ArrayView<'_, T, N>) -> Result<T> {
norm::<NormL1, T, N>(view)
}
#[inline]
pub fn norm_l2<T: RealScalar, const N: usize>(view: &ArrayView<'_, T, N>) -> Result<T> {
norm::<NormL2, T, N>(view)
}
#[inline]
pub fn norm_max<T: RealScalar, const N: usize>(view: &ArrayView<'_, T, N>) -> Result<T> {
norm::<NormMax, T, N>(view)
}
pub fn l2_normalize_into<T: RealScalar, const N: usize>(
input: &ArrayView<'_, T, N>,
output: &mut ArrayViewMut<'_, T, N>,
epsilon: T,
) -> Result<()> {
if input.shape() != output.shape() {
return Err(LetoError::ShapeMismatch {
lhs: input.shape().to_vec(),
rhs: output.shape().to_vec(),
});
}
input.layout().validate_storage_len(input.data().len())?;
output.layout().validate_storage_len(output.data().len())?;
let l2 = norm_l2(input)?;
let denom = l2.add(epsilon);
if denom == T::ZERO {
crate::application::unary::map_into(input, output, |_| T::ZERO)?;
return Ok(());
}
let scale = T::ONE.div(denom);
crate::application::unary::map_into(input, output, move |val| val.mul(scale))?;
Ok(())
}
pub fn l2_normalize<T: RealScalar, const N: usize>(
input: &ArrayView<'_, T, N>,
epsilon: T,
) -> Result<Array<T, VecStorage<T>, N>> {
let mut output = Array::from_elem(input.shape(), T::ZERO);
l2_normalize_into(input, &mut output.view_mut(), epsilon)?;
Ok(output)
}