Trait basic_dsp::MapAggregateOps

pub trait MapAggregateOps<T, R>: Sized
where
    R: Send,
{
    type Output;

    // Required method
    fn map_aggregate<'a, A, FMap, FAggr>(
        &self,
        argument: A,
        map: &FMap,
        aggregate: &FAggr
    ) -> Self::Output
       where A: Sync + Copy + Send,
             FMap: Fn(T, usize, A) -> R + 'a + Sync,
             FAggr: Fn(R, R) -> R + 'a + Sync + Send;
}

Operations which allow to iterate over the vector and to derive results.

Required Associated Types

type Output

Required Methods

fn map_aggregate<'a, A, FMap, FAggr>( &self, argument: A, map: &FMap, aggregate: &FAggr ) -> Self::Output

where A: Sync + Copy + Send, FMap: Fn(T, usize, A) -> R + 'a + Sync, FAggr: Fn(R, R) -> R + 'a + Sync + Send,

Transforms all vector elements using the function map and then aggregates all the results with aggregate. aggregate must be a commutativity and associativity; that’s because there is no guarantee that the numbers will be aggregated in any deterministic order.

Object Safety

This trait is not object safe.

Implementors

impl<S, T, N, D, R> MapAggregateOps<Complex<T>, R> for DspVec<S, T, N, D>

where S: ToSlice<T>, T: RealNumber, N: ComplexNumberSpace, D: Domain, R: Send,

type Output = Result<R, ErrorReason>

impl<S, T, N, D, R> MapAggregateOps<T, R> for DspVec<S, T, N, D>

where S: ToSlice<T>, T: RealNumber, N: RealNumberSpace, D: Domain, R: Send,

type Output = Result<R, ErrorReason>

impl<S, V, T, R> MapAggregateOps<T, R> for Matrix2xN<V, S, T>

where S: ToSlice<T>, V: Vector<T> + MapAggregateOps<T, R, Output = Result<R, ErrorReason>>, T: RealNumber, R: Send,

type Output = Result<[R; 2], ErrorReason>

impl<S, V, T, R> MapAggregateOps<T, R> for Matrix3xN<V, S, T>

where S: ToSlice<T>, V: Vector<T> + MapAggregateOps<T, R, Output = Result<R, ErrorReason>>, T: RealNumber, R: Send,

type Output = Result<[R; 3], ErrorReason>

impl<S, V, T, R> MapAggregateOps<T, R> for Matrix4xN<V, S, T>

where S: ToSlice<T>, V: Vector<T> + MapAggregateOps<T, R, Output = Result<R, ErrorReason>>, T: RealNumber, R: Send,

type Output = Result<[R; 4], ErrorReason>

impl<S, V, T, R> MapAggregateOps<T, R> for MatrixMxN<V, S, T>

where S: ToSlice<T>, V: Vector<T> + MapAggregateOps<T, R, Output = Result<R, ErrorReason>>, T: RealNumber, R: Send,

type Output = Result<Vec<R>, ErrorReason>