Struct signal_processing::ProductSequence

pub struct ProductSequence<T, S>where
    S: MaybeList<T>,
{ /* private fields */ }

Implementations§

impl<T, S> ProductSequence<T, S>
where S: MaybeList<T>,

pub fn new(s: S) -> Self

pub type View<'a> = ProductSequence<T, <S as MaybeContainer<T>>::View<'a>> where S::View<'a>: MaybeList<T>, Self: 'a

pub type Owned = ProductSequence<T, <S as MaybeContainer<T>>::Owned> where S::Owned: MaybeList<T>

pub fn as_view<'a>(&'a self) -> ProductSequence<T, S::View<'a>>
where S::View<'a>: MaybeList<T>,

pub fn to_owned(&self) -> ProductSequence<T, S::Owned>
where S::Owned: MaybeList<T>, T: Clone,

pub fn into_owned(self) -> ProductSequence<T, S::Owned>
where S::Owned: MaybeList<T>, T: Clone,

pub fn into_inner(self) -> S

pub fn one() -> Self
where ProductSequence<T, ()>: Into<Self>,

pub fn is_one(&self) -> bool
where T: Clone + Product + One + PartialEq,

Trait Implementations§

impl<T, S> Borrow<S> for ProductSequence<T, S>
where S: MaybeList<T>,

fn borrow(&self) -> &S

Immutably borrows from an owned value. Read more

impl<T, S> BorrowMut<S> for ProductSequence<T, S>
where S: MaybeList<T>,

fn borrow_mut(&mut self) -> &mut S

Mutably borrows from an owned value. Read more

impl<T: Clone, S> Clone for ProductSequence<T, S>
where S: MaybeList<T> + Clone,

fn clone(&self) -> ProductSequence<T, S>

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl<T, S> Debug for ProductSequence<T, S>
where S: MaybeList<T> + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl<T, S> Default for ProductSequence<T, S>
where S: MaybeList<T>, ProductSequence<T, ()>: Into<Self>,

fn default() -> Self

Returns the “default value” for a type. Read more

impl<T, S> Deref for ProductSequence<T, S>
where S: MaybeList<T>,

type Target = S

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, S> DerefMut for ProductSequence<T, S>
where S: MaybeList<T>,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T, const M: usize> From<ProductSequence<T, &'a [T; M]>> for ProductSequence<T, &'a [T]>

fn from(s: ProductSequence<T, &'a [T; M]>) -> Self

Converts to this type from the input type.

impl<T1, T2> From<ProductSequence<T1, &[T1]>> for ProductSequence<T2, Vec<T2>>
where T1: Clone + Into<T2>,

fn from(s: ProductSequence<T1, &[T1]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize> From<ProductSequence<T1, &[T1; M]>> for ProductSequence<T2, [T2; M]>
where T1: Clone + Into<T2>,

fn from(s: ProductSequence<T1, &[T1; M]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize> From<ProductSequence<T1, &[T1; M]>> for ProductSequence<T2, Vec<T2>>
where T1: Clone + Into<T2>,

fn from(s: ProductSequence<T1, &[T1; M]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize> From<ProductSequence<T1, [T1; M]>> for ProductSequence<T2, Vec<T2>>
where T1: Into<T2>,

fn from(s: ProductSequence<T1, [T1; M]>) -> Self

Converts to this type from the input type.

impl<T1, T2> From<ProductSequence<T1, ()>> for ProductSequence<T2, &[T2]>

fn from(_: ProductSequence<T1, ()>) -> Self

Converts to this type from the input type.

impl<T1, T2> From<ProductSequence<T1, ()>> for ProductSequence<T2, &[T2; 0]>

fn from(_: ProductSequence<T1, ()>) -> Self

Converts to this type from the input type.

impl<T1, T2> From<ProductSequence<T1, ()>> for ProductSequence<T2, [T2; 0]>

fn from(_: ProductSequence<T1, ()>) -> Self

Converts to this type from the input type.

impl<T1, T2> From<ProductSequence<T1, ()>> for ProductSequence<T2, Vec<T2>>

fn from(_: ProductSequence<T1, ()>) -> Self

Converts to this type from the input type.

impl<T, S1, S2> Mul<ProductSequence<T, S2>> for ProductSequence<T, S1>
where S1: MaybeList<T> + Chain<S2, Output: MaybeList<T>>, S2: MaybeList<T>,

type Output = ProductSequence<T, <S1 as Chain<S2>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: ProductSequence<T, S2>) -> Self::Output

Performs the * operation. Read more

impl<T, S> One for ProductSequence<T, S>
where T: Clone + Product + One + PartialEq, S: MaybeList<T>, Self: Mul<Output = Self>, ProductSequence<T, ()>: Into<Self>,

fn one() -> Self

Returns the multiplicative identity element of Self, 1. Read more

fn is_one(&self) -> bool
where Self: PartialEq,

Returns true if self is equal to the multiplicative identity. Read more

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<T, S, I> Pow<I> for ProductSequence<T, S>
where T: Clone, S: MaybeList<T>, I: Unsigned + Integer + BitAnd<I, Output = I> + Shr<usize, Output = I> + Copy, Self: Into<ProductSequence<T, Vec<T>>>,

type Output = ProductSequence<T, Vec<T>>

The result after applying the operator.

fn pow(self, n: I) -> Self::Output

Returns self to the power rhs. Read more

impl<T, S1, S2> Product<ProductSequence<T, S1>> for ProductSequence<T, S2>
where S1: MaybeList<T>, S2: MaybeList<T>, ProductSequence<T, S1>: Into<ProductSequence<T, S2>>, ProductSequence<T, S2>: One,

fn product<I: Iterator<Item = ProductSequence<T, S1>>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, T, const M: usize> TryFrom<ProductSequence<T, &'a [T]>> for ProductSequence<T, &'a [T; M]>

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(s: ProductSequence<T, &'a [T]>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1, T2, const M: usize> TryFrom<ProductSequence<T1, &[T1]>> for ProductSequence<T2, [T2; M]>
where T1: Clone + Into<T2>,

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(s: ProductSequence<T1, &[T1]>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1, T2, const M: usize> TryFrom<ProductSequence<T1, Vec<T1>>> for ProductSequence<T2, [T2; M]>
where T1: Into<T2>,

type Error = Vec<T1>

The type returned in the event of a conversion error.

fn try_from(s: ProductSequence<T1, Vec<T1>>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Copy, S> Copy for ProductSequence<T, S>
where S: MaybeList<T> + Copy,

impl<T, S> NotVoid for ProductSequence<T, S>
where S: MaybeList<T>,

Auto Trait Implementations§

impl<T, S> Freeze for ProductSequence<T, S>
where S: Freeze,

impl<T, S> NotPolynomial for ProductSequence<T, S>
where S: NotPolynomial, T: NotPolynomial,

impl<T, S> NotRange for ProductSequence<T, S>
where S: NotRange, T: NotRange,

impl<T, S> RefUnwindSafe for ProductSequence<T, S>
where S: RefUnwindSafe, T: RefUnwindSafe,

impl<T, S> Send for ProductSequence<T, S>
where S: Send, T: Send,

impl<T, S> Sync for ProductSequence<T, S>
where S: Sync, T: Sync,

impl<T, S> Unpin for ProductSequence<T, S>
where S: Unpin, T: Unpin,

impl<T, S> UnwindSafe for ProductSequence<T, S>
where S: UnwindSafe, T: UnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ListOrSingle<T> for T

type Length = usize

const LENGTH: usize = 1usize

type Resized<const M: usize> = [T; M]

fn length(&self) -> usize

fn as_view_slice(&self) -> &[T]

fn to_vec(&self) -> Vec<T>
where T: Clone,

fn into_vec(self) -> Vec<T>
where T: Clone,

impl<Some> Maybe<Some> for Some
where Some: ?Sized,

fn into_option(self) -> Option<Some>

fn as_option(&self) -> Option<&Some>

fn as_option_mut(&mut self) -> Option<&mut Some>

impl<T> MaybeAnd<T, ()> for T
where T: NotVoid + ?Sized,

type Output = ()

impl<T> MaybeAnd<T, T> for T
where T: NotVoid + ?Sized,

type Output = T

impl<T> MaybeNand<T, ()> for T
where T: NotVoid + ?Sized,

type Output = T

impl<T> MaybeNand<T, T> for T
where T: NotVoid + ?Sized,

type Output = ()

impl<T> MaybeNor<T, ()> for T
where T: NotVoid + ?Sized,

type Output = ()

impl<T> MaybeNor<T, T> for T
where T: NotVoid + ?Sized,

type Output = ()

impl<T> MaybeOr<T, ()> for T
where T: NotVoid + ?Sized,

type Output = T

impl<T> MaybeOr<T, T> for T
where T: NotVoid + ?Sized,

type Output = T

impl<T> MaybeXnor<T, ()> for T
where T: NotVoid + ?Sized,

type Output = ()

impl<T> MaybeXnor<T, T> for T
where T: NotVoid + ?Sized,

type Output = T

impl<T> MaybeXor<T, ()> for T
where T: NotVoid + ?Sized,

type Output = T

impl<T> MaybeXor<T, T> for T
where T: NotVoid + ?Sized,

type Output = ()

impl<T, E> ResultOrOk<T, E> for T

fn into_result(self) -> Result<T, E>

fn as_result(&self) -> Result<&T, &E>

fn as_result_mut(&mut self) -> Result<&mut T, &mut E>

impl<T> Same for T

type Output = T

Should always be Self

impl<Some> StaticMaybe<Some> for Some
where Some: NotVoid + ?Sized,

const IS_SOME: bool = true

const IS_NONE: bool = false

type None = ()

type Some = Some

type Opposite = ()

type Maybe<M: StaticMaybe<M> + ?Sized> = <M as StaticMaybe<M>>::Some

type MaybeOr<M: ?Sized, O: ?Sized> = M

fn maybe_from_fn<F>(func: F) -> Some
where F: FnOnce() -> Some,

fn maybe_or_from_fn<M, O>( maybe: M, _or: O ) -> <Some as StaticMaybe<Some>>::MaybeOr<<M as FnOnce()>::Output, <O as FnOnce()>::Output>
where M: FnOnce(), O: FnOnce(),

fn maybe_map<F>( self, map: F ) -> <Some as StaticMaybe<Some>>::Maybe<<F as FnOnce(Some)>::Output>
where F: FnOnce(Some), <F as FnOnce(Some)>::Output: StaticMaybe<<F as FnOnce(Some)>::Output>, <Some as StaticMaybe<Some>>::Maybe<<F as FnOnce(Some)>::Output>: Sized,

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V