Trait basic_dsp::MapAggregateOps

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

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

Associated Types

type Output

Loading content...

Required methods

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

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.

Loading content...

Implementors

impl<S, T, N, D, R> MapAggregateOps<Complex<T>, R> for DspVec<S, T, N, D> where     D: Domain,     N: ComplexNumberSpace,     R: Send,     S: ToSlice<T>,     T: RealNumber,

type Output = Result<R, ErrorReason>

fn map_aggregate<'a, A, FMap, FAggr>(     &self,     argument: A,     map: &FMap,     aggregate: &FAggr ) -> Result<R, ErrorReason> where     A: Sync + Copy + Send,     FAggr: Fn(R, R) -> R + 'a + Sync + Send,     FMap: Fn(Complex<T>, usize, A) -> R + 'a + Sync,

impl<S, T, N, D, R> MapAggregateOps<T, R> for DspVec<S, T, N, D> where     D: Domain,     N: RealNumberSpace,     R: Send,     S: ToSlice<T>,     T: RealNumber,

type Output = Result<R, ErrorReason>

fn map_aggregate<'a, A, FMap, FAggr>(     &self,     argument: A,     map: &FMap,     aggregate: &FAggr ) -> Result<R, ErrorReason> where     A: Sync + Copy + Send,     FAggr: Fn(R, R) -> R + 'a + Sync + Send,     FMap: Fn(T, usize, A) -> R + 'a + Sync,

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

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

fn map_aggregate<'a, A, FMap, FAggr>(     &self,     argument: A,     map: &FMap,     aggregate: &FAggr ) -> Result<[R; 2], ErrorReason> where     A: Sync + Copy + Send,     FAggr: Fn(R, R) -> R + 'a + Sync + Send,     FMap: Fn(T, usize, A) -> R + 'a + Sync,     R: Send,

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

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

fn map_aggregate<'a, A, FMap, FAggr>(     &self,     argument: A,     map: &FMap,     aggregate: &FAggr ) -> Result<[R; 3], ErrorReason> where     A: Sync + Copy + Send,     FAggr: Fn(R, R) -> R + 'a + Sync + Send,     FMap: Fn(T, usize, A) -> R + 'a + Sync,     R: Send,

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

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

fn map_aggregate<'a, A, FMap, FAggr>(     &self,     argument: A,     map: &FMap,     aggregate: &FAggr ) -> Result<[R; 4], ErrorReason> where     A: Sync + Copy + Send,     FAggr: Fn(R, R) -> R + 'a + Sync + Send,     FMap: Fn(T, usize, A) -> R + 'a + Sync,     R: Send,

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

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

fn map_aggregate<'a, A, FMap, FAggr>(     &self,     argument: A,     map: &FMap,     aggregate: &FAggr ) -> Result<Vec<R>, ErrorReason> where     A: Sync + Copy + Send,     FAggr: Fn(R, R) -> R + 'a + Sync + Send,     FMap: Fn(T, usize, A) -> R + 'a + Sync,     R: Send,

Loading content...