Struct signal_processing::Polynomial

pub struct Polynomial<T, C>
where
    C: MaybeLists<T>,
{ /* private fields */ }

Implementations

impl<T, C> Polynomial<T, C>

where C: MaybeLists<T>,

pub fn new(c: C) -> Self

pub type View<'a> = Polynomial<T, <C as MaybeContainer<T>>::View<'a>> where C::View<'a>: MaybeLists<T>, Self: 'a

pub type Owned = Polynomial<T, <C as MaybeContainer<T>>::Owned> where C::Owned: MaybeLists<T>

pub fn as_view<'a>(&'a self) -> Polynomial<T, C::View<'a>>

where C::View<'a>: MaybeLists<T>,

pub fn to_owned(&self) -> Polynomial<T, C::Owned>

where C::Owned: MaybeLists<T>, T: Clone,

pub fn into_owned(self) -> Polynomial<T, C::Owned>

where C::Owned: MaybeLists<T>, T: Clone,

pub fn into_inner(self) -> C

pub fn map_to_owned<'a, F>( &'a self, map: F ) -> Polynomial<F::Output, C::Mapped<F::Output>>

where C: Lists<T>, T: 'a, F: FnMut<(&'a T,)>, C::Mapped<F::Output>: MaybeLists<F::Output>,

pub fn map_into_owned<F>( self, map: F ) -> Polynomial<F::Output, C::Mapped<F::Output>>

where T: Clone, C: Lists<T>, F: FnMut<(T,)>, C::Mapped<F::Output>: MaybeLists<F::Output>,

pub fn maybe_map_to_owned<'a, F>( &'a self, map: F ) -> Polynomial<F::Output, C::MaybeMapped<F::Output>>

where T: 'a, F: FnMut<(&'a T,)>, C::MaybeMapped<F::Output>: MaybeLists<F::Output>,

pub fn maybe_map_into_owned<F>( self, map: F ) -> Polynomial<F::Output, C::MaybeMapped<F::Output>>

where T: Clone, F: FnMut<(T,)>, C::MaybeMapped<F::Output>: MaybeLists<F::Output>,

pub fn re(self) -> Polynomial<T::Real, C::MaybeMapped<T::Real>>

where T: ComplexFloat, C::MaybeMapped<T::Real>: MaybeLists<T::Real>,

pub fn truncate_im<U>(self) -> Polynomial<U, C::MaybeMapped<U>>

where T: TruncateIm, T::Real: Into<U>, U: ComplexFloat<Real = T::Real> + 'static, C::MaybeMapped<U>: MaybeLists<U>,

pub fn truncate<const N: usize>(self) -> Polynomial<T, [T; N]>

where T: Zero, Self: Into<Polynomial<T, Vec<T>>>,

pub fn one() -> Self

where Polynomial<T, ()>: Into<Self>,

pub fn zero() -> Self

where Polynomial<T, [T; 0]>: Into<Self>,

pub fn is_zero(&self) -> bool

where T: Zero, C: MaybeLists<T>,

pub fn is_one(&self) -> bool

where T: One + Zero + PartialEq, C: MaybeList<T>,

pub fn gcd<C2>( self, rhs: Polynomial<T, C2> ) -> C::RowsMapped<Polynomial<T, Vec<T>>>

where T: ComplexFloat + DivAssign, C::RowOwned: MaybeList<T>, C2: MaybeList<T> + Clone, Polynomial<T, C2>: Into<Polynomial<T, Vec<T>>>, Polynomial<T, C::RowOwned>: Into<Polynomial<T, Vec<T>>>, Polynomial<T, Vec<T>>: Euclid,

Trait Implementations

impl<'a, 'b, T1, T2> Add<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &'a [T1]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1]>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2]>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the + operation.

impl<'a, 'b, const N: usize, T1, T2> Add<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &'a [T1; N]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1; N]>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2]>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the + operation.

impl<'a, const N: usize, T1, T2> Add<Polynomial<T2, &'a [T2]>> for Polynomial<T1, [T1; N]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, [T1; N]>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'a [T2]>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, &'a [T2]>) -> Self::Output

Performs the + operation.

impl<'b, T1, T2> Add<Polynomial<T2, &'b [T2]>> for Polynomial<T1, ()>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, ()>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2]>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the + operation.

impl<'b, T1, T2> Add<Polynomial<T2, &'b [T2]>> for Polynomial<T1, Vec<T1>>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, Vec<T1>>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2]>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the + operation.

impl<'a, 'b, const M: usize, T1, T2> Add<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &'a [T1]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1]>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2; M]>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the + operation.

impl<'a, 'b, const N: usize, const M: usize, T1, T2> Add<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &'a [T1; N]>

where Polynomial<T1, [T1; N]>: From<Polynomial<T1, &'a [T1; N]>> + Add<Polynomial<T2, [T2; M]>>, Polynomial<T2, [T2; M]>: From<Polynomial<T2, &'b [T2; M]>>,

type Output = <Polynomial<T1, [T1; N]> as Add<Polynomial<T2, [T2; M]>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the + operation.

impl<'a, const N: usize, const M: usize, T1, T2> Add<Polynomial<T2, &'a [T2; M]>> for Polynomial<T1, [T1; N]>

where Polynomial<T1, [T1; N]>: From<Polynomial<T1, [T1; N]>> + Add<Polynomial<T2, [T2; M]>>, Polynomial<T2, [T2; M]>: From<Polynomial<T2, &'a [T2; M]>>,

type Output = <Polynomial<T1, [T1; N]> as Add<Polynomial<T2, [T2; M]>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, &'a [T2; M]>) -> Self::Output

Performs the + operation.

impl<'b, const M: usize, T1, T2> Add<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, ()>

where Polynomial<T1, [T1; 1]>: From<Polynomial<T1, ()>> + Add<Polynomial<T2, [T2; M]>>, Polynomial<T2, [T2; M]>: From<Polynomial<T2, &'b [T2; M]>>,

type Output = <Polynomial<T1, [T1; 1]> as Add<Polynomial<T2, [T2; M]>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the + operation.

impl<'b, const M: usize, T1, T2> Add<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, Vec<T1>>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, Vec<T1>>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2; M]>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the + operation.

impl<'a, const M: usize, T1, T2> Add<Polynomial<T2, [T2; M]>> for Polynomial<T1, &'a [T1]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1]>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, [T2; M]>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the + operation.

impl<'a, const N: usize, const M: usize, T1, T2> Add<Polynomial<T2, [T2; M]>> for Polynomial<T1, &'a [T1; N]>

where Polynomial<T1, [T1; N]>: From<Polynomial<T1, &'a [T1; N]>> + Add<Polynomial<T2, [T2; M]>>, Polynomial<T2, [T2; M]>: From<Polynomial<T2, [T2; M]>>,

type Output = <Polynomial<T1, [T1; N]> as Add<Polynomial<T2, [T2; M]>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the + operation.

impl<T1, T2, const N: usize, const M: usize> Add<Polynomial<T2, [T2; M]>> for Polynomial<T1, [T1; N]>

where T1: Add<T2> + Zero, T2: Zero, [(); { _ }]:,

type Output = Polynomial<<T1 as Add<T2>>::Output, [<T1 as Add<T2>>::Output; { _ }]>

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the + operation.

impl<const M: usize, T1, T2> Add<Polynomial<T2, [T2; M]>> for Polynomial<T1, ()>

where Polynomial<T1, [T1; 1]>: From<Polynomial<T1, ()>> + Add<Polynomial<T2, [T2; M]>>, Polynomial<T2, [T2; M]>: From<Polynomial<T2, [T2; M]>>,

type Output = <Polynomial<T1, [T1; 1]> as Add<Polynomial<T2, [T2; M]>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the + operation.

impl<const M: usize, T1, T2> Add<Polynomial<T2, [T2; M]>> for Polynomial<T1, Vec<T1>>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, Vec<T1>>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, [T2; M]>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the + operation.

impl<'a, T1, T2> Add<Polynomial<T2, ()>> for Polynomial<T1, &'a [T1]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1]>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, ()>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, ()>) -> Self::Output

Performs the + operation.

impl<'a, const N: usize, T1, T2> Add<Polynomial<T2, ()>> for Polynomial<T1, &'a [T1; N]>

where Polynomial<T1, [T1; N]>: From<Polynomial<T1, &'a [T1; N]>> + Add<Polynomial<T2, [T2; 1]>>, Polynomial<T2, [T2; 1]>: From<Polynomial<T2, ()>>,

type Output = <Polynomial<T1, [T1; N]> as Add<Polynomial<T2, [T2; 1]>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, ()>) -> Self::Output

Performs the + operation.

impl<const N: usize, T1, T2> Add<Polynomial<T2, ()>> for Polynomial<T1, [T1; N]>

where Polynomial<T1, [T1; N]>: From<Polynomial<T1, [T1; N]>> + Add<Polynomial<T2, [T2; 1]>>, Polynomial<T2, [T2; 1]>: From<Polynomial<T2, ()>>,

type Output = <Polynomial<T1, [T1; N]> as Add<Polynomial<T2, [T2; 1]>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, ()>) -> Self::Output

Performs the + operation.

impl<T1, T2> Add<Polynomial<T2, ()>> for Polynomial<T1, ()>

where Polynomial<T1, [T1; 1]>: From<Polynomial<T1, ()>> + Add<Polynomial<T2, [T2; 1]>>, Polynomial<T2, [T2; 1]>: From<Polynomial<T2, ()>>,

type Output = <Polynomial<T1, [T1; 1]> as Add<Polynomial<T2, [T2; 1]>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, ()>) -> Self::Output

Performs the + operation.

impl<T1, T2> Add<Polynomial<T2, ()>> for Polynomial<T1, Vec<T1>>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, Vec<T1>>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, ()>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, ()>) -> Self::Output

Performs the + operation.

impl<'a, T1, T2> Add<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &'a [T1]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1]>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, Vec<T2>>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the + operation.

impl<'a, const N: usize, T1, T2> Add<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &'a [T1; N]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1; N]>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, Vec<T2>>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the + operation.

impl<'a, const N: usize, T1, T2> Add<Polynomial<T2, Vec<T2>>> for Polynomial<T1, [T1; N]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, [T1; N]>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, Vec<T2>>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the + operation.

impl<T1, T2> Add<Polynomial<T2, Vec<T2>>> for Polynomial<T1, ()>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, ()>> + Add<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, Vec<T2>>>,

type Output = <Polynomial<T1, Vec<T1>> as Add<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the + operation.

impl<T1, T2> Add<Polynomial<T2, Vec<T2>>> for Polynomial<T1, Vec<T1>>

where T1: Zero + Clone + Add<T2>, T2: Zero + Clone,

type Output = Polynomial<<T1 as Add<T2>>::Output, Vec<<T1 as Add<T2>>::Output>>

The resulting type after applying the + operator.

fn add(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the + operation.

impl<T, C, Rhs> AddAssign<Rhs> for Polynomial<T, C>

where C: MaybeLists<T>, for<'a> C::View<'a>: MaybeLists<T>, for<'a> Polynomial<T, C::View<'a>>: Add<Rhs, Output = Self>,

fn add_assign(&mut self, rhs: Rhs)

Performs the += operation.

impl<T, C> Borrow<C> for Polynomial<T, C>

where C: MaybeLists<T>,

fn borrow(&self) -> &C

Immutably borrows from an owned value.

impl<T, C> BorrowMut<C> for Polynomial<T, C>

where C: MaybeLists<T>,

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

Mutably borrows from an owned value.

impl<T: Clone, C> Clone for Polynomial<T, C>

where C: MaybeLists<T> + Clone,

fn clone(&self) -> Polynomial<T, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, C> Debug for Polynomial<T, C>

where C: MaybeLists<T> + Debug,

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

Formats the value using the given formatter.

impl<T, C> Deref for Polynomial<T, C>

where C: MaybeLists<T>,

type Target = C

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, C> DerefMut for Polynomial<T, C>

where C: MaybeLists<T>,

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

Mutably dereferences the value.

impl<T, C1, C2> Div<Polynomial<T, C2>> for Polynomial<T, C1>

where T: Zero + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + AddAssign + MulAssign + Copy, C1: MaybeList<T>, C2: MaybeList<T>, Self: Into<Polynomial<T, Vec<T>>>, Polynomial<T, C2>: Into<Polynomial<T, Vec<T>>>,

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

The resulting type after applying the / operator.

fn div(self, rhs: Polynomial<T, C2>) -> Self::Output

Performs the / operation.

impl<T1, T2, T3, C> Div<T2> for Polynomial<T1, C>

where C: Lists<T1>, T2: NotPolynomial + Clone, T1: Div<T2, Output = T3> + Clone, C::Mapped<T3>: Lists<T3>,

type Output = Polynomial<T3, <C as Container<T1>>::Mapped<T3>>

The resulting type after applying the / operator.

fn div(self, rhs: T2) -> Self::Output

Performs the / operation.

impl<T> Euclid for Polynomial<T, Vec<T>>

where T: Zero + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + AddAssign + MulAssign + Copy,

fn div_euclid(&self, v: &Self) -> Self

Calculates Euclidean division, the matching method for rem_euclid.

fn rem_euclid(&self, v: &Self) -> Self

Calculates the least nonnegative remainder of self (mod v).

fn div_rem_euclid(&self, v: &Self) -> (Self, Self)

Returns both the quotient and remainder from Euclidean division.

impl<T, C, X> Fn(X) for Polynomial<T, C>

where C: MaybeLists<T>, T: One + Zero + AddAssign + MulAssign<X> + Copy, X: Copy,

extern "rust-call" fn call(&self, (x): (X,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T, C, X> FnMut(X) for Polynomial<T, C>

where C: MaybeLists<T>, T: One + Zero + AddAssign + MulAssign<X> + Copy, X: Copy,

extern "rust-call" fn call_mut(&mut self, args: (X,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T, C, X> FnOnce(X) for Polynomial<T, C>

where C: MaybeLists<T>, T: One + Zero + AddAssign + MulAssign<X> + Copy, X: Copy,

type Output = <C as MaybeLists<T>>::RowsMapped<T>

The returned type after the call operator is used.

extern "rust-call" fn call_once(self, args: (X,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<'a, T, C1, C2> From<&'a Polynomial<T, C1>> for Polynomial<T, C2>

where C1: MaybeLists<T>, C2: MaybeLists<T>, C1::View<'a>: MaybeLists<T>, Polynomial<T, C1::View<'a>>: Into<Polynomial<T, C2>>,

fn from(p: &'a Polynomial<T, C1>) -> Self

Converts to this type from the input type.

impl<'a, T> From<Polynomial<T, &[&'a [T]]>> for Polynomial<T, Vec<&'a [T]>>

where T: Zero,

fn from(p: Polynomial<T, &[&'a [T]]>) -> Self

Converts to this type from the input type.

impl<'a, 'b, T, const K: usize> From<Polynomial<T, &'a [&'b [T]; K]>> for Polynomial<T, &'a [&'b [T]]>

where T: Zero,

fn from(p: Polynomial<T, &'a [&'b [T]; K]>) -> Self

Converts to this type from the input type.

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

where T: Zero,

fn from(p: Polynomial<T, &[&'a [T]; K]>) -> Self

Converts to this type from the input type.

impl<'a, T, const K: usize> From<Polynomial<T, &[&'a [T]; K]>> for Polynomial<T, Vec<&'a [T]>>

where T: Zero,

fn from(p: Polynomial<T, &[&'a [T]; K]>) -> Self

Converts to this type from the input type.

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

where T: Zero,

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(p: Polynomial<T, &'a [&'b [T; M]; K]>) -> Self

Converts to this type from the input type.

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

where T: Zero,

fn from(p: Polynomial<T, &[&'a [T; M]; K]>) -> Self

Converts to this type from the input type.

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

fn from(p: Polynomial<T, &[&'a [T; M]; K]>) -> Self

Converts to this type from the input type.

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

where T: Zero,

fn from(p: Polynomial<T, &[&'a [T; M]; K]>) -> Self

Converts to this type from the input type.

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

fn from(p: Polynomial<T, &[&'a [T; M]; K]>) -> Self

Converts to this type from the input type.

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

where T: Zero + Clone,

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(p: Polynomial<T, &'a [[T; M]; K]>) -> Self

Converts to this type from the input type.

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

where T: Zero + Clone,

fn from(p: Polynomial<T, &'a [[T; M]; K]>) -> Self

Converts to this type from the input type.

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

fn from(p: Polynomial<T, &'a [[T; M]; K]>) -> Self

Converts to this type from the input type.

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

where T: Zero + Clone,

fn from(p: Polynomial<T, &'a [[T; M]; K]>) -> Self

Converts to this type from the input type.

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

fn from(p: Polynomial<T, &'a [[T; M]; K]>) -> Self

Converts to this type from the input type.

impl<'a, T> From<Polynomial<T, &'a [T]>> for Polynomial<T, [&'a [T]; 1]>

where T: Zero,

fn from(p: Polynomial<T, &'a [T]>) -> Self

Converts to this type from the input type.

impl<'a, T> From<Polynomial<T, &'a [T]>> for Polynomial<T, Vec<&'a [T]>>

where T: Zero,

fn from(p: Polynomial<T, &'a [T]>) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

where T: Zero,

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

Converts to this type from the input type.

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

where T: Zero,

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

where T: Zero,

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<'a, T> From<Polynomial<T, &'a [Vec<T>]>> for Polynomial<T, Vec<&'a [T]>>

where T: Zero,

fn from(p: Polynomial<T, &'a [Vec<T>]>) -> Self

Converts to this type from the input type.

impl<'a, T, const K: usize> From<Polynomial<T, &'a [Vec<T>; K]>> for Polynomial<T, &'a [Vec<T>]>

fn from(p: Polynomial<T, &'a [Vec<T>; K]>) -> Self

Converts to this type from the input type.

impl<'a, T, const K: usize> From<Polynomial<T, &'a [Vec<T>; K]>> for Polynomial<T, [&'a [T]; K]>

fn from(p: Polynomial<T, &'a [Vec<T>; K]>) -> Self

Converts to this type from the input type.

impl<'a, T, const K: usize> From<Polynomial<T, &'a [Vec<T>; K]>> for Polynomial<T, Vec<&'a [T]>>

where T: Zero,

fn from(p: Polynomial<T, &'a [Vec<T>; K]>) -> Self

Converts to this type from the input type.

impl<'a, T, const K: usize> From<Polynomial<T, [&'a [T]; K]>> for Polynomial<T, Vec<&'a [T]>>

fn from(p: Polynomial<T, [&'a [T]; K]>) -> Self

Converts to this type from the input type.

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

where T: Zero,

fn from(p: Polynomial<T, [&'a [T; M]; K]>) -> Self

Converts to this type from the input type.

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

where T: Zero,

fn from(p: Polynomial<T, [&'a [T; M]; K]>) -> Self

Converts to this type from the input type.

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

fn from(p: Polynomial<T, [&'a [T; M]; K]>) -> Self

Converts to this type from the input type.

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

where T: Zero,

fn from(p: Polynomial<T, Vec<&'a [T; M]>>) -> Self

Converts to this type from the input type.

impl<T1, T2> From<Polynomial<T1, &[&[T1]]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, &[&[T1]]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const K: usize> From<Polynomial<T1, &[&[T1]; K]>> for Polynomial<T2, [Vec<T2>; K]>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, &[&[T1]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const K: usize> From<Polynomial<T1, &[&[T1]; K]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, &[&[T1]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize> From<Polynomial<T1, &[&[T1; M]]>> for Polynomial<T2, Vec<[T2; N]>>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

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

Converts to this type from the input type.

impl<T1, T2, const M: usize> From<Polynomial<T1, &[&[T1; M]]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Zero + Clone + Into<T2>,

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

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize, const K: usize> From<Polynomial<T1, &[&[T1; M]; K]>> for Polynomial<T2, [[T2; N]; K]>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

fn from(p: Polynomial<T1, &[&[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize, const K: usize> From<Polynomial<T1, &[&[T1; M]; K]>> for Polynomial<T2, [Vec<T2>; K]>

where T1: Zero + Clone + Into<T2>,

fn from(p: Polynomial<T1, &[&[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize, const K: usize> From<Polynomial<T1, &[&[T1; M]; K]>> for Polynomial<T2, Vec<[T2; N]>>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

fn from(p: Polynomial<T1, &[&[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize, const K: usize> From<Polynomial<T1, &[&[T1; M]; K]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Zero + Clone + Into<T2>,

fn from(p: Polynomial<T1, &[&[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize> From<Polynomial<T1, &[[T1; M]]>> for Polynomial<T2, Vec<[T2; N]>>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

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

Converts to this type from the input type.

impl<T1, T2, const M: usize> From<Polynomial<T1, &[[T1; M]]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Zero + Clone + Into<T2>,

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

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize, const K: usize> From<Polynomial<T1, &[[T1; M]; K]>> for Polynomial<T2, [[T2; N]; K]>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

fn from(p: Polynomial<T1, &[[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize, const K: usize> From<Polynomial<T1, &[[T1; M]; K]>> for Polynomial<T2, [Vec<T2>; K]>

where T1: Zero + Clone + Into<T2>,

fn from(p: Polynomial<T1, &[[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize, const K: usize> From<Polynomial<T1, &[[T1; M]; K]>> for Polynomial<T2, Vec<[T2; N]>>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

fn from(p: Polynomial<T1, &[[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize, const K: usize> From<Polynomial<T1, &[[T1; M]; K]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Zero + Clone + Into<T2>,

fn from(p: Polynomial<T1, &[[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2> From<Polynomial<T1, &[T1]>> for Polynomial<T2, [Vec<T2>; 1]>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, &[T1]>) -> Self

Converts to this type from the input type.

impl<T1, T2> From<Polynomial<T1, &[T1]>> for Polynomial<T2, Vec<T2>>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, &[T1]>) -> Self

Converts to this type from the input type.

impl<T1, T2> From<Polynomial<T1, &[T1]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, &[T1]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize> From<Polynomial<T1, &[T1; M]>> for Polynomial<T2, [[T2; N]; 1]>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

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

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize> From<Polynomial<T1, &[T1; M]>> for Polynomial<T2, [T2; N]>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

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

Converts to this type from the input type.

impl<T1, T2, const M: usize> From<Polynomial<T1, &[T1; M]>> for Polynomial<T2, [Vec<T2>; 1]>

where T1: Clone + Zero + Into<T2>,

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

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize> From<Polynomial<T1, &[T1; M]>> for Polynomial<T2, Vec<[T2; N]>>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

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

Converts to this type from the input type.

impl<T1, T2, const M: usize> From<Polynomial<T1, &[T1; M]>> for Polynomial<T2, Vec<T2>>

where T1: Zero + Clone + Into<T2>,

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

Converts to this type from the input type.

impl<T1, T2, const M: usize> From<Polynomial<T1, &[T1; M]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Clone + Zero + Into<T2>,

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

Converts to this type from the input type.

impl<T1, T2> From<Polynomial<T1, &[Vec<T1>]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Clone + Into<T2>,

fn from(p: Polynomial<T1, &[Vec<T1>]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const K: usize> From<Polynomial<T1, &[Vec<T1>; K]>> for Polynomial<T2, [Vec<T2>; K]>

where T1: Clone + Into<T2>,

fn from(p: Polynomial<T1, &[Vec<T1>; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const K: usize> From<Polynomial<T1, &[Vec<T1>; K]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Clone + Into<T2>,

fn from(p: Polynomial<T1, &[Vec<T1>; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const K: usize> From<Polynomial<T1, [&[T1]; K]>> for Polynomial<T2, [Vec<T2>; K]>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, [&[T1]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const K: usize> From<Polynomial<T1, [&[T1]; K]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, [&[T1]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize, const K: usize> From<Polynomial<T1, [&[T1; M]; K]>> for Polynomial<T2, [[T2; N]; K]>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

fn from(p: Polynomial<T1, [&[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize, const K: usize> From<Polynomial<T1, [&[T1; M]; K]>> for Polynomial<T2, [Vec<T2>; K]>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, [&[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize, const K: usize> From<Polynomial<T1, [&[T1; M]; K]>> for Polynomial<T2, Vec<[T2; N]>>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

fn from(p: Polynomial<T1, [&[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize, const K: usize> From<Polynomial<T1, [&[T1; M]; K]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, [&[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize, const K: usize> From<Polynomial<T1, [[T1; M]; K]>> for Polynomial<T2, [Vec<T2>; K]>

where T1: Into<T2>,

fn from(p: Polynomial<T1, [[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize, const K: usize> From<Polynomial<T1, [[T1; M]; K]>> for Polynomial<T2, Vec<[T2; N]>>

where T1: Into<T2>, T2: Zero, [(); { _ }]:,

fn from(p: Polynomial<T1, [[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize, const K: usize> From<Polynomial<T1, [[T1; M]; K]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Into<T2>,

fn from(p: Polynomial<T1, [[T1; M]; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize> From<Polynomial<T1, [T1; M]>> for Polynomial<T2, [[T2; N]; 1]>

where T1: Into<T2>, T2: Zero, [(); { _ }]:,

fn from(p: Polynomial<T1, [T1; M]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize> From<Polynomial<T1, [T1; M]>> for Polynomial<T2, [Vec<T2>; 1]>

where T1: Into<T2>,

fn from(p: Polynomial<T1, [T1; M]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize> From<Polynomial<T1, [T1; M]>> for Polynomial<T2, Vec<[T2; N]>>

where T1: Into<T2>, T2: Zero, [(); { _ }]:,

fn from(p: Polynomial<T1, [T1; M]>) -> Self

Converts to this type from the input type.

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

where T1: Into<T2>,

fn from(p: Polynomial<T1, [T1; M]>) -> Self

Converts to this type from the input type.

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

where T1: Into<T2>,

fn from(p: Polynomial<T1, [T1; M]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const K: usize> From<Polynomial<T1, [Vec<T1>; K]>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Into<T2>,

fn from(p: Polynomial<T1, [Vec<T1>; K]>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize> From<Polynomial<T1, ()>> for Polynomial<T2, [[T2; N]; 1]>

where T1: One + Into<T2>, T2: Zero, [(); { _ }]:,

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

Converts to this type from the input type.

impl<T1, T2, const N: usize> From<Polynomial<T1, ()>> for Polynomial<T2, [T2; N]>

where T1: One + Into<T2>, T2: Zero, [(); { _ }]:,

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

Converts to this type from the input type.

impl<T1, T2> From<Polynomial<T1, ()>> for Polynomial<T2, [Vec<T2>; 1]>

where T1: One + Into<T2>,

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

Converts to this type from the input type.

impl<T1, T2, const N: usize> From<Polynomial<T1, ()>> for Polynomial<T2, Vec<[T2; N]>>

where T1: One + Into<T2>, T2: Zero, [(); { _ }]:,

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

Converts to this type from the input type.

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

where T1: One + Into<T2>,

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

Converts to this type from the input type.

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

where T1: One + Into<T2>,

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

Converts to this type from the input type.

impl<T1, T2> From<Polynomial<T1, Vec<&[T1]>>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, Vec<&[T1]>>) -> Self

Converts to this type from the input type.

impl<T1, T2, const N: usize, const M: usize> From<Polynomial<T1, Vec<&[T1; M]>>> for Polynomial<T2, Vec<[T2; N]>>

where T1: Clone + Into<T2>, T2: Zero, [(); { _ }]:,

fn from(p: Polynomial<T1, Vec<&[T1; M]>>) -> Self

Converts to this type from the input type.

impl<T1, T2, const M: usize> From<Polynomial<T1, Vec<&[T1; M]>>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Clone + Zero + Into<T2>,

fn from(p: Polynomial<T1, Vec<&[T1; M]>>) -> Self

Converts to this type from the input type.

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

where T1: Into<T2>,

fn from(p: Polynomial<T1, Vec<[T1; M]>>) -> Self

Converts to this type from the input type.

impl<T1, T2> From<Polynomial<T1, Vec<T1>>> for Polynomial<T2, [Vec<T2>; 1]>

where T1: Into<T2>,

fn from(p: Polynomial<T1, Vec<T1>>) -> Self

Converts to this type from the input type.

impl<T1, T2> From<Polynomial<T1, Vec<T1>>> for Polynomial<T2, Vec<Vec<T2>>>

where T1: Into<T2>,

fn from(p: Polynomial<T1, Vec<T1>>) -> Self

Converts to this type from the input type.

impl<'c, 'b, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2]]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2]]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const N: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2]]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2]]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const N: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2]]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2]]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2]]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, &'c [&'b [T2]]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2]]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2]]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2]]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const K: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2]; K]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2]; K]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2]; K]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2]; K]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2]; K]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2]; K]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const K: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2]; K]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, &'c [&'b [T2]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2]; K]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const K: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2]; K]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2]; K]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2; M]]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2; M]]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2; M]]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2; M]]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2; M]]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2; M]]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2; M]]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, &'c [&'b [T2; M]]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2; M]]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2; M]]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2; M]]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2; M]; K]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2; M]; K]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2; M]; K]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2; M]; K]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, &'c [&'b [T2; M]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'c, 'b, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [&'b [T2; M]; K]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [&'b [T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'c, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [[T2; M]]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [[T2; M]]>) -> Self::Output

Performs the * operation.

impl<'c, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [[T2; M]]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [[T2; M]]>) -> Self::Output

Performs the * operation.

impl<'c, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [[T2; M]]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [[T2; M]]>) -> Self::Output

Performs the * operation.

impl<'c, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [[T2; M]]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, &'c [[T2; M]]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [[T2; M]]>) -> Self::Output

Performs the * operation.

impl<'c, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [[T2; M]]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [[T2; M]]>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [[T2; M]; K]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [[T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [[T2; M]; K]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [[T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [[T2; M]; K]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [[T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [[T2; M]; K]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, &'c [[T2; M]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [[T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'c [[T2; M]; K]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [[T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'b, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &[&[T1]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &[&[T1]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &[&[T1; N]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &[&[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &[[T1; N]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &[[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'a, 'b, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &'a [T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'a, 'b, const N: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &'a [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &[Vec<T1>]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &[Vec<T1>; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, [&[T1]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, [&[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, [[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, [Vec<T1>; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, &'b [T2]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, Vec<&[T1]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, Vec<&[T1; N]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, Vec<[T1; N]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, T1, T2> Mul<Polynomial<T2, &'b [T2]>> for Polynomial<T1, Vec<Vec<T1>>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the * operation.

impl<'b, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &[&[T1]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &[&[T1]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &[&[T1; N]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &[&[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &[[T1; N]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &[[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'a, 'b, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &'a [T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'a, 'b, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &'a [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [<T1 as Mul<T2>>::Output; { _ }]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &[Vec<T1>]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &[Vec<T1>; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, [&[T1]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, [&[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, [[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [<T1 as Mul<T2>>::Output; { _ }]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, [Vec<T1>; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, &'b [T2; M]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, Vec<&[T1]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, Vec<&[T1; N]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, Vec<[T1; N]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'b, const M: usize, T1, T2> Mul<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, Vec<Vec<T1>>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the * operation.

impl<'c, T1, T2> Mul<Polynomial<T2, &'c [Vec<T2>]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [Vec<T2>]>) -> Self::Output

Performs the * operation.

impl<'c, const N: usize, T1, T2> Mul<Polynomial<T2, &'c [Vec<T2>]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [Vec<T2>]>) -> Self::Output

Performs the * operation.

impl<'c, const N: usize, T1, T2> Mul<Polynomial<T2, &'c [Vec<T2>]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [Vec<T2>]>) -> Self::Output

Performs the * operation.

impl<'c, T1, T2> Mul<Polynomial<T2, &'c [Vec<T2>]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, &'c [Vec<T2>]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [Vec<T2>]>) -> Self::Output

Performs the * operation.

impl<'c, T1, T2> Mul<Polynomial<T2, &'c [Vec<T2>]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [Vec<T2>]>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, T1, T2> Mul<Polynomial<T2, &'c [Vec<T2>; K]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [Vec<T2>; K]>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, &'c [Vec<T2>; K]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [Vec<T2>; K]>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, &'c [Vec<T2>; K]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [Vec<T2>; K]>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, T1, T2> Mul<Polynomial<T2, &'c [Vec<T2>; K]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, &'c [Vec<T2>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [Vec<T2>; K]>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, T1, T2> Mul<Polynomial<T2, &'c [Vec<T2>; K]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, &'c [Vec<T2>; K]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, T1, T2> Mul<Polynomial<T2, [&'b [T2]; K]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [&'b [T2]; K]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, [&'b [T2]; K]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [&'b [T2]; K]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, [&'b [T2]; K]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [&'b [T2]; K]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, T1, T2> Mul<Polynomial<T2, [&'b [T2]; K]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, [&'b [T2]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [&'b [T2]; K]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, T1, T2> Mul<Polynomial<T2, [&'b [T2]; K]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [&'b [T2]; K]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [&'b [T2; M]; K]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [&'b [T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [&'b [T2; M]; K]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [&'b [T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [&'b [T2; M]; K]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [&'b [T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [&'b [T2; M]; K]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, [&'b [T2; M]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [&'b [T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<'b, const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [&'b [T2; M]; K]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [&'b [T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [[T2; M]; K]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [[T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [[T2; M]; K]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [[T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [[T2; M]; K]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [[T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [[T2; M]; K]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, [[T2; M]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [[T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [[T2; M]; K]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [[T2; M]; K]>) -> Self::Output

Performs the * operation.

impl<const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, &[&[T1]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, &[&[T1]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, &[&[T1; N]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, &[&[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, &[[T1; N]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, &[[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<'a, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, &'a [T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<'a, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, &'a [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [<T1 as Mul<T2>>::Output; { _ }]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, &[Vec<T1>]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, &[Vec<T1>; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, [&[T1]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, [&[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, [[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [[<T1 as Mul<T2>>::Output; { _ }]; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [<T1 as Mul<T2>>::Output; { _ }]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, [Vec<T1>; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, [T2; M]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, Vec<&[T1]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, Vec<&[T1; N]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, Vec<[T1; N]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const M: usize, T1, T2> Mul<Polynomial<T2, [T2; M]>> for Polynomial<T1, Vec<Vec<T1>>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the * operation.

impl<const K: usize, T1, T2> Mul<Polynomial<T2, [Vec<T2>; K]>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [Vec<T2>; K]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, [Vec<T2>; K]>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [Vec<T2>; K]>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, [Vec<T2>; K]>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [Vec<T2>; K]>) -> Self::Output

Performs the * operation.

impl<const K: usize, T1, T2> Mul<Polynomial<T2, [Vec<T2>; K]>> for Polynomial<T1, ()>

type Output = Polynomial<T2, [Vec<T2>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [Vec<T2>; K]>) -> Self::Output

Performs the * operation.

impl<const K: usize, T1, T2> Mul<Polynomial<T2, [Vec<T2>; K]>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, [Vec<T2>; K]>) -> Self::Output

Performs the * operation.

impl<'a, 'c, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, &'c [&'a [T1]]>

type Output = Polynomial<T1, &'c [&'a [T1]]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'a, 'c, const K: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, &'c [&'a [T1]; K]>

type Output = Polynomial<T1, &'c [&'a [T1]; K]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'a, 'c, const N: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, &'c [&'a [T1; N]]>

type Output = Polynomial<T1, &'c [&'a [T1; N]]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'a, 'c, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, &'c [&'a [T1; N]; K]>

type Output = Polynomial<T1, &'c [&'a [T1; N]; K]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'c, const N: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, &'c [[T1; N]]>

type Output = Polynomial<T1, &'c [[T1; N]]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, &'c [[T1; N]; K]>

type Output = Polynomial<T1, &'c [[T1; N]; K]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'a, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, &'a [T1]>

type Output = Polynomial<T1, &'a [T1]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'a, const N: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, &'a [T1; N]>

type Output = Polynomial<T1, &'a [T1; N]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'c, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, &'c [Vec<T1>]>

type Output = Polynomial<T1, &'c [Vec<T1>]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'c, const K: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, &'c [Vec<T1>; K]>

type Output = Polynomial<T1, &'c [Vec<T1>; K]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'a, const K: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, [&'a [T1]; K]>

type Output = Polynomial<T1, [&'a [T1]; K]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'a, const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, [&'a [T1; N]; K]>

type Output = Polynomial<T1, [&'a [T1; N]; K]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, [[T1; N]; K]>

type Output = Polynomial<T1, [[T1; N]; K]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<const N: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, [T1; N]>

type Output = Polynomial<T1, [T1; N]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<const K: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, [Vec<T1>; K]>

type Output = Polynomial<T1, [Vec<T1>; K]>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, ()>

type Output = Polynomial<T2, ()>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'a, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, Vec<&'a [T1]>>

type Output = Polynomial<T1, Vec<&'a [T1]>>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'a, const N: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, Vec<&'a [T1; N]>>

type Output = Polynomial<T1, Vec<&'a [T1; N]>>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<const N: usize, T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, Vec<[T1; N]>>

type Output = Polynomial<T1, Vec<[T1; N]>>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, Vec<T1>>

type Output = Polynomial<T1, Vec<T1>>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, ()>> for Polynomial<T1, Vec<Vec<T1>>>

type Output = Polynomial<T1, Vec<Vec<T1>>>

The resulting type after applying the * operator.

fn mul(self, _: Polynomial<T2, ()>) -> Self::Output

Performs the * operation.

impl<'b, T1, T2> Mul<Polynomial<T2, Vec<&'b [T2]>>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<&'b [T2]>>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, T1, T2> Mul<Polynomial<T2, Vec<&'b [T2]>>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<&'b [T2]>>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, T1, T2> Mul<Polynomial<T2, Vec<&'b [T2]>>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<&'b [T2]>>) -> Self::Output

Performs the * operation.

impl<'b, T1, T2> Mul<Polynomial<T2, Vec<&'b [T2]>>> for Polynomial<T1, ()>

type Output = Polynomial<T2, Vec<&'b [T2]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<&'b [T2]>>) -> Self::Output

Performs the * operation.

impl<'b, T1, T2> Mul<Polynomial<T2, Vec<&'b [T2]>>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<&'b [T2]>>) -> Self::Output

Performs the * operation.

impl<'b, const M: usize, T1, T2> Mul<Polynomial<T2, Vec<&'b [T2; M]>>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<&'b [T2; M]>>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, Vec<&'b [T2; M]>>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<&'b [T2; M]>>) -> Self::Output

Performs the * operation.

impl<'b, const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, Vec<&'b [T2; M]>>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<&'b [T2; M]>>) -> Self::Output

Performs the * operation.

impl<'b, const M: usize, T1, T2> Mul<Polynomial<T2, Vec<&'b [T2; M]>>> for Polynomial<T1, ()>

type Output = Polynomial<T2, Vec<&'b [T2; M]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<&'b [T2; M]>>) -> Self::Output

Performs the * operation.

impl<'b, const M: usize, T1, T2> Mul<Polynomial<T2, Vec<&'b [T2; M]>>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<&'b [T2; M]>>) -> Self::Output

Performs the * operation.

impl<const M: usize, T1, T2> Mul<Polynomial<T2, Vec<[T2; M]>>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<[T2; M]>>) -> Self::Output

Performs the * operation.

impl<const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, Vec<[T2; M]>>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<[T2; M]>>) -> Self::Output

Performs the * operation.

impl<const N: usize, const M: usize, T1, T2> Mul<Polynomial<T2, Vec<[T2; M]>>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy, [(); { _ }]:,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<[<T1 as Mul<T2>>::Output; { _ }]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<[T2; M]>>) -> Self::Output

Performs the * operation.

impl<const M: usize, T1, T2> Mul<Polynomial<T2, Vec<[T2; M]>>> for Polynomial<T1, ()>

type Output = Polynomial<T2, Vec<[T2; M]>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<[T2; M]>>) -> Self::Output

Performs the * operation.

impl<const M: usize, T1, T2> Mul<Polynomial<T2, Vec<[T2; M]>>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<[T2; M]>>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &[&[T1]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const K: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &[&[T1]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const N: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &[&[T1; N]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &[&[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const N: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &[[T1; N]]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &[[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<'a, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &'a [T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<'a, const N: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &'a [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &[Vec<T1>]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const K: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &[Vec<T1>; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const K: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, [&[T1]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, [&[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const K: usize, const N: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, [[T1; N]; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const N: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const K: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, [Vec<T1>; K]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, [Vec<<T1 as Mul<T2>>::Output>; K]>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, ()>

type Output = Polynomial<T2, Vec<T2>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, Vec<&[T1]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const N: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, Vec<&[T1; N]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<const N: usize, T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, Vec<[T1; N]>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<<T1 as Mul<T2>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, Vec<T2>>> for Polynomial<T1, Vec<Vec<T1>>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, Vec<Vec<T2>>>> for Polynomial<T1, &[T1]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<Vec<T2>>>) -> Self::Output

Performs the * operation.

impl<const N: usize, T1, T2> Mul<Polynomial<T2, Vec<Vec<T2>>>> for Polynomial<T1, &[T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<Vec<T2>>>) -> Self::Output

Performs the * operation.

impl<const N: usize, T1, T2> Mul<Polynomial<T2, Vec<Vec<T2>>>> for Polynomial<T1, [T1; N]>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<Vec<T2>>>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, Vec<Vec<T2>>>> for Polynomial<T1, ()>

type Output = Polynomial<T2, Vec<Vec<T2>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<Vec<T2>>>) -> Self::Output

Performs the * operation.

impl<T1, T2> Mul<Polynomial<T2, Vec<Vec<T2>>>> for Polynomial<T1, Vec<T1>>

where T1: Mul<T2, Output: AddAssign + Zero> + Copy, T2: Copy,

type Output = Polynomial<<T1 as Mul<T2>>::Output, Vec<Vec<<T1 as Mul<T2>>::Output>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Polynomial<T2, Vec<Vec<T2>>>) -> Self::Output

Performs the * operation.

impl<T1, T2, T3, C> Mul<T2> for Polynomial<T1, C>

where C: Lists<T1> + NotVoid, T2: NotPolynomial + Clone, T1: Mul<T2, Output = T3> + Clone, C::Mapped<T3>: Lists<T3>,

type Output = Polynomial<T3, <C as Container<T1>>::Mapped<T3>>

The resulting type after applying the * operator.

fn mul(self, rhs: T2) -> Self::Output

Performs the * operation.

impl<T, C, Rhs> MulAssign<Rhs> for Polynomial<T, C>

where C: MaybeLists<T>, for<'a> C::View<'a>: MaybeLists<T>, for<'a> Polynomial<T, C::View<'a>>: Mul<Rhs, Output = Self>,

fn mul_assign(&mut self, rhs: Rhs)

Performs the *= operation.

impl<'a, T> Neg for Polynomial<T, &'a [T]>

where Polynomial<T, Vec<T>>: From<Polynomial<T, &'a [T]>> + Neg,

type Output = <Polynomial<T, Vec<T>> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, const N: usize, T> Neg for Polynomial<T, &'a [T; N]>

where Polynomial<T, [T; N]>: From<Polynomial<T, &'a [T; N]>> + Neg,

type Output = <Polynomial<T, [T; N]> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const N: usize, T> Neg for Polynomial<T, [T; N]>

where T: Neg,

type Output = Polynomial<<T as Neg>::Output, [<T as Neg>::Output; N]>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> Neg for Polynomial<T, ()>

where Polynomial<T, [T; 1]>: From<Polynomial<T, ()>> + Neg,

type Output = <Polynomial<T, [T; 1]> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> Neg for Polynomial<T, Vec<T>>

where T: Neg,

type Output = Polynomial<<T as Neg>::Output, Vec<<T as Neg>::Output>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> One for Polynomial<T, ()>

where Self: Mul<Output = Self>, Polynomial<T, ()>: Into<Self>,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

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

impl<T> One for Polynomial<T, Vec<T>>

where Self: Mul<Output = Self>, Polynomial<T, ()>: Into<Self>,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

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

impl<T, C1, C2> PartialEq<Polynomial<T, C2>> for Polynomial<T, C1>

where T: Zero + PartialEq, C1: MaybeLists<T>, C2: MaybeLists<T>,

fn eq(&self, other: &Polynomial<T, C2>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, S, I> Pow<I> for Polynomial<T, S>

where T: Clone + One, S: MaybeList<T>, I: Unsigned + Integer + BitAnd<I, Output = I> + Shr<usize, Output = I> + Copy, Self: Into<Polynomial<T, Vec<T>>>, Polynomial<T, Vec<T>>: Mul<Polynomial<T, Vec<T>>, Output = Polynomial<T, Vec<T>>>,

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

The result after applying the operator.

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

Returns self to the power rhs.

impl<T, C1, C2> Product<Polynomial<T, C1>> for Polynomial<T, C2>

where C1: MaybeLists<T>, C2: MaybeLists<T>, Polynomial<T, C1>: Into<Self>, Self: One,

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

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

impl<T, C1, C2> Rem<Polynomial<T, C2>> for Polynomial<T, C1>

where T: Zero + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + AddAssign + MulAssign + Copy, C1: MaybeList<T>, C2: MaybeList<T>, Self: Into<Polynomial<T, Vec<T>>>, Polynomial<T, C2>: Into<Polynomial<T, Vec<T>>>,

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

The resulting type after applying the % operator.

fn rem(self, rhs: Polynomial<T, C2>) -> Self::Output

Performs the % operation.

impl<'a, 'b, T1, T2> Sub<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &'a [T1]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1]>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2]>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the - operation.

impl<'a, 'b, const N: usize, T1, T2> Sub<Polynomial<T2, &'b [T2]>> for Polynomial<T1, &'a [T1; N]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1; N]>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2]>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the - operation.

impl<'a, const N: usize, T1, T2> Sub<Polynomial<T2, &'a [T2]>> for Polynomial<T1, [T1; N]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, [T1; N]>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'a [T2]>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, &'a [T2]>) -> Self::Output

Performs the - operation.

impl<'b, T1, T2> Sub<Polynomial<T2, &'b [T2]>> for Polynomial<T1, ()>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, ()>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2]>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the - operation.

impl<'b, T1, T2> Sub<Polynomial<T2, &'b [T2]>> for Polynomial<T1, Vec<T1>>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, Vec<T1>>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2]>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, &'b [T2]>) -> Self::Output

Performs the - operation.

impl<'a, 'b, const M: usize, T1, T2> Sub<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &'a [T1]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1]>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2; M]>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the - operation.

impl<'a, 'b, const N: usize, const M: usize, T1, T2> Sub<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, &'a [T1; N]>

where Polynomial<T1, [T1; N]>: From<Polynomial<T1, &'a [T1; N]>> + Sub<Polynomial<T2, [T2; M]>>, Polynomial<T2, [T2; M]>: From<Polynomial<T2, &'b [T2; M]>>,

type Output = <Polynomial<T1, [T1; N]> as Sub<Polynomial<T2, [T2; M]>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the - operation.

impl<'a, const N: usize, const M: usize, T1, T2> Sub<Polynomial<T2, &'a [T2; M]>> for Polynomial<T1, [T1; N]>

where Polynomial<T1, [T1; N]>: From<Polynomial<T1, [T1; N]>> + Sub<Polynomial<T2, [T2; M]>>, Polynomial<T2, [T2; M]>: From<Polynomial<T2, &'a [T2; M]>>,

type Output = <Polynomial<T1, [T1; N]> as Sub<Polynomial<T2, [T2; M]>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, &'a [T2; M]>) -> Self::Output

Performs the - operation.

impl<'b, const M: usize, T1, T2> Sub<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, ()>

where Polynomial<T1, [T1; 1]>: From<Polynomial<T1, ()>> + Sub<Polynomial<T2, [T2; M]>>, Polynomial<T2, [T2; M]>: From<Polynomial<T2, &'b [T2; M]>>,

type Output = <Polynomial<T1, [T1; 1]> as Sub<Polynomial<T2, [T2; M]>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the - operation.

impl<'b, const M: usize, T1, T2> Sub<Polynomial<T2, &'b [T2; M]>> for Polynomial<T1, Vec<T1>>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, Vec<T1>>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, &'b [T2; M]>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, &'b [T2; M]>) -> Self::Output

Performs the - operation.

impl<'a, const M: usize, T1, T2> Sub<Polynomial<T2, [T2; M]>> for Polynomial<T1, &'a [T1]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1]>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, [T2; M]>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the - operation.

impl<'a, const N: usize, const M: usize, T1, T2> Sub<Polynomial<T2, [T2; M]>> for Polynomial<T1, &'a [T1; N]>

where Polynomial<T1, [T1; N]>: From<Polynomial<T1, &'a [T1; N]>> + Sub<Polynomial<T2, [T2; M]>>, Polynomial<T2, [T2; M]>: From<Polynomial<T2, [T2; M]>>,

type Output = <Polynomial<T1, [T1; N]> as Sub<Polynomial<T2, [T2; M]>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the - operation.

impl<T1, T2, const N: usize, const M: usize> Sub<Polynomial<T2, [T2; M]>> for Polynomial<T1, [T1; N]>

where T1: Sub<T2> + Zero, T2: Zero, [(); { _ }]:,

type Output = Polynomial<<T1 as Sub<T2>>::Output, [<T1 as Sub<T2>>::Output; { _ }]>

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the - operation.

impl<const M: usize, T1, T2> Sub<Polynomial<T2, [T2; M]>> for Polynomial<T1, ()>

where Polynomial<T1, [T1; 1]>: From<Polynomial<T1, ()>> + Sub<Polynomial<T2, [T2; M]>>, Polynomial<T2, [T2; M]>: From<Polynomial<T2, [T2; M]>>,

type Output = <Polynomial<T1, [T1; 1]> as Sub<Polynomial<T2, [T2; M]>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the - operation.

impl<const M: usize, T1, T2> Sub<Polynomial<T2, [T2; M]>> for Polynomial<T1, Vec<T1>>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, Vec<T1>>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, [T2; M]>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, [T2; M]>) -> Self::Output

Performs the - operation.

impl<'a, T1, T2> Sub<Polynomial<T2, ()>> for Polynomial<T1, &'a [T1]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1]>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, ()>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, ()>) -> Self::Output

Performs the - operation.

impl<'a, const N: usize, T1, T2> Sub<Polynomial<T2, ()>> for Polynomial<T1, &'a [T1; N]>

where Polynomial<T1, [T1; N]>: From<Polynomial<T1, &'a [T1; N]>> + Sub<Polynomial<T2, [T2; 1]>>, Polynomial<T2, [T2; 1]>: From<Polynomial<T2, ()>>,

type Output = <Polynomial<T1, [T1; N]> as Sub<Polynomial<T2, [T2; 1]>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, ()>) -> Self::Output

Performs the - operation.

impl<const N: usize, T1, T2> Sub<Polynomial<T2, ()>> for Polynomial<T1, [T1; N]>

where Polynomial<T1, [T1; N]>: From<Polynomial<T1, [T1; N]>> + Sub<Polynomial<T2, [T2; 1]>>, Polynomial<T2, [T2; 1]>: From<Polynomial<T2, ()>>,

type Output = <Polynomial<T1, [T1; N]> as Sub<Polynomial<T2, [T2; 1]>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, ()>) -> Self::Output

Performs the - operation.

impl<T1, T2> Sub<Polynomial<T2, ()>> for Polynomial<T1, ()>

where Polynomial<T1, [T1; 1]>: From<Polynomial<T1, ()>> + Sub<Polynomial<T2, [T2; 1]>>, Polynomial<T2, [T2; 1]>: From<Polynomial<T2, ()>>,

type Output = <Polynomial<T1, [T1; 1]> as Sub<Polynomial<T2, [T2; 1]>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, ()>) -> Self::Output

Performs the - operation.

impl<T1, T2> Sub<Polynomial<T2, ()>> for Polynomial<T1, Vec<T1>>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, Vec<T1>>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, ()>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, ()>) -> Self::Output

Performs the - operation.

impl<'a, T1, T2> Sub<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &'a [T1]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1]>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, Vec<T2>>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the - operation.

impl<'a, const N: usize, T1, T2> Sub<Polynomial<T2, Vec<T2>>> for Polynomial<T1, &'a [T1; N]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, &'a [T1; N]>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, Vec<T2>>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the - operation.

impl<'a, const N: usize, T1, T2> Sub<Polynomial<T2, Vec<T2>>> for Polynomial<T1, [T1; N]>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, [T1; N]>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, Vec<T2>>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the - operation.

impl<T1, T2> Sub<Polynomial<T2, Vec<T2>>> for Polynomial<T1, ()>

where Polynomial<T1, Vec<T1>>: From<Polynomial<T1, ()>> + Sub<Polynomial<T2, Vec<T2>>>, Polynomial<T2, Vec<T2>>: From<Polynomial<T2, Vec<T2>>>,

type Output = <Polynomial<T1, Vec<T1>> as Sub<Polynomial<T2, Vec<T2>>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the - operation.

impl<T1, T2> Sub<Polynomial<T2, Vec<T2>>> for Polynomial<T1, Vec<T1>>

where T1: Zero + Clone + Sub<T2>, T2: Zero + Clone,

type Output = Polynomial<<T1 as Sub<T2>>::Output, Vec<<T1 as Sub<T2>>::Output>>

The resulting type after applying the - operator.

fn sub(self, rhs: Polynomial<T2, Vec<T2>>) -> Self::Output

Performs the - operation.

impl<T, C, Rhs> SubAssign<Rhs> for Polynomial<T, C>

where C: MaybeLists<T>, for<'a> C::View<'a>: MaybeLists<T>, for<'a> Polynomial<T, C::View<'a>>: Sub<Rhs, Output = Self>,

fn sub_assign(&mut self, rhs: Rhs)

Performs the -= operation.

impl<T: Copy, C> Copy for Polynomial<T, C>

where C: MaybeLists<T> + Copy,

impl<T, C> Eq for Polynomial<T, C>

where C: MaybeLists<T>, T: Eq, Self: PartialEq,

impl<T, C> !NotPolynomial for Polynomial<T, C>

where C: MaybeLists<T>,

impl<T, C> NotVoid for Polynomial<T, C>

where C: MaybeLists<T>,