use array_math::{ArrayOps, SliceMath};
use num::{One, Zero};
use crate::quantities::{MaybeLists, Polynomial};
impl<T1, T2, const N: usize> From<Polynomial<T1, ()>> for Polynomial<T2, [T2; N]>
where
T1: One + Into<T2>,
T2: Zero,
[(); N - 1]:
{
fn from(_: Polynomial<T1, ()>) -> Self
{
let mut p = <[T2; N]>::fill(|_| T2::zero());
*p.last_mut().unwrap() = T1::one().into();
Self::new(p)
}
}
impl<T1, T2, const N: usize> From<Polynomial<T1, ()>> for Polynomial<T2, [[T2; N]; 1]>
where
T1: One + Into<T2>,
T2: Zero,
[(); N - 1]:
{
fn from(_: Polynomial<T1, ()>) -> Self
{
let mut p = <[T2; N]>::fill(|_| T2::zero());
*p.last_mut().unwrap() = T1::one().into();
Self::new([p])
}
}
impl<T1, T2, const N: usize> From<Polynomial<T1, ()>> for Polynomial<T2, Vec<[T2; N]>>
where
T1: One + Into<T2>,
T2: Zero,
[(); N - 1]:
{
fn from(_: Polynomial<T1, ()>) -> Self
{
let mut p = <[T2; N]>::fill(|_| T2::zero());
*p.last_mut().unwrap() = T1::one().into();
Self::new(vec![p])
}
}
impl<T1, T2> From<Polynomial<T1, ()>> for Polynomial<T2, Vec<T2>>
where
T1: One + Into<T2>
{
fn from(_: Polynomial<T1, ()>) -> Self
{
Self::new(vec![T1::one().into()])
}
}
impl<T1, T2> From<Polynomial<T1, ()>> for Polynomial<T2, [Vec<T2>; 1]>
where
T1: One + Into<T2>
{
fn from(_: Polynomial<T1, ()>) -> Self
{
Self::new([vec![T1::one().into()]])
}
}
impl<T1, T2> From<Polynomial<T1, ()>> for Polynomial<T2, Vec<Vec<T2>>>
where
T1: One + Into<T2>
{
fn from(_: Polynomial<T1, ()>) -> Self
{
Self::new(vec![vec![T1::one().into()]])
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, [T1; M]>) -> Self
{
Self::new(
[p.c.map(Into::into).rresize(|_| T2::zero())]
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, [T1; M]>) -> Self
{
Self::new(
vec![p.c.map(Into::into).rresize(|_| T2::zero())]
)
}
}
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
{
Self::new(
p.c.into_iter()
.map(Into::into)
.collect()
)
}
}
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
{
Self::new([
p.c.into_iter()
.map(Into::into)
.collect()
])
}
}
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
{
Self::new(vec![
p.c.into_iter()
.map(Into::into)
.collect()
])
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, &[T1; M]>) -> Self
{
Self::new(
p.c.clone()
.map(Into::into)
.resize(|_| T2::zero())
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, &[T1; M]>) -> Self
{
Self::new([
p.c.clone()
.map(Into::into)
.resize(|_| T2::zero())
])
}
}
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
{
Self::new(
core::array::from_ref(p.c)
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, &[T1; M]>) -> Self
{
Self::new(vec![
p.c.clone()
.map(Into::into)
.resize(|_| T2::zero())
])
}
}
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
{
Self::new(
core::slice::from_ref(p.c)
)
}
}
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
{
Self::new(
[p.c]
)
}
}
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
{
Self::new(
vec![p.c]
)
}
}
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
{
Self::new(
p.c.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
)
}
}
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
{
Self::new([
p.c.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
])
}
}
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
{
Self::new(vec![
p.c.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
])
}
}
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
{
Self::new(
p.c.as_slice().trim_zeros_front()
)
}
}
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
{
Self::new(
[p.c.as_slice().trim_zeros_front()]
)
}
}
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
{
Self::new(
vec![p.c.as_slice().trim_zeros_front()]
)
}
}
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
{
Self::new([
p.c.into_iter()
.map(Into::into)
.collect()
])
}
}
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
{
Self::new(vec![
p.c.into_iter()
.map(Into::into)
.collect()
])
}
}
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
{
Self::new(
p.c.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
)
}
}
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
{
Self::new([
p.c.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
])
}
}
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
{
Self::new(vec![
p.c.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
])
}
}
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
{
Self::new(
[p.c.trim_zeros_front()]
)
}
}
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
{
Self::new(
vec![p.c.trim_zeros_front()]
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, [[T1; M]; K]>) -> Self
{
Self::new(
p.c.into_iter()
.map(|p| p.map(Into::into).resize(|_| T2::zero()))
.collect()
)
}
}
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
{
Self::new(
p.c.map(|p| p.into_iter()
.map(Into::into)
.collect()
)
)
}
}
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
{
Self::new(
p.c.into_iter()
.map(|p| p.into_iter()
.map(Into::into)
.collect()
).collect()
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, [&[T1; M]; K]>) -> Self
{
Self::new(
p.c.map(|p| p.clone().map(Into::into).resize(|_| T2::zero()))
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, [&[T1; M]; K]>) -> Self
{
Self::new(
p.c.into_iter()
.map(|p| p.clone().map(Into::into).resize(|_| T2::zero()))
.collect()
)
}
}
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
{
Self::new(
p.c.into_iter()
.collect()
)
}
}
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
{
Self::new(
p.c.map(|p| p.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
)
)
}
}
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
{
Self::new(
p.c.into_iter()
.map(|p| p.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
).collect()
)
}
}
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
{
Self::new(
p.c.map(|p| p.as_slice().trim_zeros_front())
)
}
}
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
{
Self::new(
p.c.into_iter()
.map(|p| p.as_slice().trim_zeros_front())
.collect()
)
}
}
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
{
Self::new(
p.c.into_iter()
.map(|p| p.into_iter()
.map(Into::into)
.collect()
).collect()
)
}
}
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
{
Self::new(
p.c.map(|p| p.trim_zeros_front()
.iter()
.map(|s| s.clone().into())
.collect()
)
)
}
}
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
{
Self::new(
p.c.into_iter()
.map(|p| p.trim_zeros_front()
.iter()
.map(|s| s.clone().into())
.collect()
).collect()
)
}
}
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
{
Self::new(
p.c.into_iter()
.collect()
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, &[[T1; M]; K]>) -> Self
{
Self::new(
p.c.each_ref()
.map(|p| p.clone().map(Into::into).resize(|_| T2::zero()))
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, &[[T1; M]; K]>) -> Self
{
Self::new(
p.c.iter()
.map(|p| p.clone().map(Into::into).resize(|_| T2::zero()))
.collect()
)
}
}
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
{
Self::new(
p.c.as_slice()
)
}
}
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
{
Self::new(
p.c.each_ref()
)
}
}
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
{
Self::new(
p.c.iter()
.collect()
)
}
}
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
{
Self::new(
p.c.each_ref()
.map(|p| p.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
)
)
}
}
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
{
Self::new(
p.c.iter()
.map(|p| p.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
).collect()
)
}
}
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
{
Self::new(
p.c.each_ref()
.map(|p| p.as_slice().trim_zeros_front())
)
}
}
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
{
Self::new(
p.c.iter()
.map(|p| p.as_slice().trim_zeros_front())
.collect()
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, &[&[T1; M]; K]>) -> Self
{
Self::new(
p.c.map(|p| p.clone().map(Into::into).resize(|_| T2::zero()))
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, &[&[T1; M]; K]>) -> Self
{
Self::new(
p.c.iter()
.map(|&p| p.clone().map(Into::into).resize(|_| T2::zero()))
.collect()
)
}
}
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
{
Self::new(
*p.c
)
}
}
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
{
Self::new(
p.c.iter().copied()
.collect()
)
}
}
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
{
Self::new(
p.c.as_slice()
)
}
}
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
{
Self::new(
p.c.map(|p| p.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
)
)
}
}
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
{
Self::new(
p.c.iter()
.map(|&p| p.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
).collect()
)
}
}
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
{
Self::new(
p.c.map(|p| p.as_slice().trim_zeros_front())
)
}
}
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
{
Self::new(
p.c.iter()
.map(|&p| p.as_slice().trim_zeros_front())
.collect()
)
}
}
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
{
Self::new(
p.c.each_ref()
.map(|c| c.iter()
.map(|c| c.clone().into())
.collect()
)
)
}
}
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
{
Self::new(
p.c.iter()
.map(|p| p.iter()
.map(|c| c.clone().into())
.collect()
).collect()
)
}
}
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
{
Self::new(
p.c.as_slice()
)
}
}
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
{
Self::new(
p.c.each_ref()
.map(|p| p.as_slice())
)
}
}
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
{
Self::new(
p.c.iter()
.map(|p| p.as_slice().trim_zeros_front())
.collect()
)
}
}
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
{
Self::new(
p.c.each_ref()
.map(|&p| p.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
)
)
}
}
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
{
Self::new(
p.c.map(|p| p.trim_zeros_front())
)
}
}
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
{
Self::new(
p.c.as_slice()
)
}
}
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
{
Self::new(
p.c.iter()
.map(|&p| p.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
).collect()
)
}
}
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
{
Self::new(
(*p.c).into_iter()
.map(|p| p.trim_zeros_front())
.collect()
)
}
}
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
{
Self::new(
p.c.into_iter()
.map(|p| p.into_iter()
.map(Into::into)
.collect()
).collect()
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, Vec<&[T1; M]>>) -> Self
{
Self::new(
p.c.into_iter()
.map(|p| p.clone().map(Into::into).resize(|_| T2::zero()))
.collect()
)
}
}
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
{
Self::new(
p.c.into_iter()
.map(|p| p.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
).collect()
)
}
}
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
{
Self::new(
p.c.into_iter()
.map(|p| p.as_slice().trim_zeros_front())
.collect()
)
}
}
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
{
Self::new(
p.c.into_iter()
.map(|p| p.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
).collect()
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, &[[T1; M]]>) -> Self
{
Self::new(
p.c.iter()
.map(|p| p.clone().map(Into::into).resize(|_| T2::zero()))
.collect()
)
}
}
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
{
Self::new(
p.c.iter()
.collect()
)
}
}
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
{
Self::new(
p.c.iter()
.map(|p| p.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
).collect()
)
}
}
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
{
Self::new(
p.c.iter()
.map(|p| p.as_slice().trim_zeros_front())
.collect()
)
}
}
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,
[(); N - M]:
{
fn from(p: Polynomial<T1, &[&[T1; M]]>) -> Self
{
Self::new(
p.c.iter()
.map(|&p| p.clone().map(Into::into).resize(|_| T2::zero()))
.collect()
)
}
}
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
{
Self::new(
p.c.to_vec()
)
}
}
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
{
Self::new(
p.c.iter()
.map(|&p| p.as_slice()
.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
).collect()
)
}
}
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
{
Self::new(
p.c.iter()
.map(|&p| p.as_slice().trim_zeros_front())
.collect()
)
}
}
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
{
Self::new(
p.c.iter()
.map(|p| p.iter()
.map(|c| c.clone().into())
.collect()
).collect()
)
}
}
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
{
Self::new(
p.c.iter()
.map(|p| p.as_slice().trim_zeros_front())
.collect()
)
}
}
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
{
Self::new(
p.c.iter()
.map(|&p| p.trim_zeros_front()
.iter()
.map(|c| c.clone().into())
.collect()
).collect()
)
}
}
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
{
Self::new(
p.c.iter()
.map(|&p| p.trim_zeros_front())
.collect()
)
}
}
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
{
Polynomial::new(p.c.as_view()).into()
}
}