Struct brassfibre::prelude::Series
[−]
[src]
pub struct Series<'v, 'i, V, I> where
V: 'v + Clone,
I: 'i + Clone + Hash, { pub values: Cow<'v, Vec<V>>, pub index: Cow<'i, Indexer<I>>, }
Fields
values: Cow<'v, Vec<V>>
index: Cow<'i, Indexer<I>>
Methods
impl<'v, 'i, V, I> Series<'v, 'i, V, I> where
V: Clone + Eq + Hash + Ord,
I: Clone + Eq + Hash,
[src]
V: Clone + Eq + Hash + Ord,
I: Clone + Eq + Hash,
fn value_counts<'a>(&self) -> Series<'a, 'a, usize, V>
impl<'v, 'i, V, I> Series<'v, 'i, V, I> where
V: Clone,
I: Clone + Eq + Hash + Ord,
[src]
V: Clone,
I: Clone + Eq + Hash + Ord,
fn sort_index(&self) -> Self
impl<'v, 'i, V, I> Series<'v, 'i, V, I> where
V: Clone + Ord,
I: Clone + Eq + Hash,
[src]
V: Clone + Ord,
I: Clone + Eq + Hash,
fn sort_values(&self) -> Self
impl<'v, 'i, V, I> Series<'v, 'i, V, I> where
V: 'v + Clone,
I: 'i + Clone + Eq + Hash,
[src]
V: 'v + Clone,
I: 'i + Clone + Eq + Hash,
///////////////////////////////////////////////////////////////////////////// Misc /////////////////////////////////////////////////////////////////////////////
fn from_vec(values: Vec<V>) -> Series<'v, 'i, V, usize>
fn new<X>(values: Vec<V>, index: X) -> Self where
X: Into<Indexer<I>>,
X: Into<Indexer<I>>,
fn from_cow(values: Cow<'v, Vec<V>>, index: Cow<'i, Indexer<I>>) -> Self
fn groupby<G>(&self, other: Vec<G>) -> GroupBy<Series<V, I>, G> where
G: Clone + Eq + Hash + Ord,
G: Clone + Eq + Hash + Ord,
impl<'v, 'i, V, I> Series<'v, 'i, V, I> where
V: Clone,
I: Clone + Eq + Hash,
[src]
V: Clone,
I: Clone + Eq + Hash,
Trait Implementations
impl<'v, 'i, V, I> BasicAggregation<'i> for Series<'v, 'i, V, I> where
V: Clone + Zero + Add,
I: Clone + Eq + Hash,
[src]
V: Clone + Zero + Add,
I: Clone + Eq + Hash,
type Kept = V
type Counted = usize
fn sum(&'i self) -> Self::Kept
fn count(&'i self) -> Self::Counted
impl<'v, 'i, V, I> NumericAggregation<'i> for Series<'v, 'i, V, I> where
V: Clone + Zero + Add + Sub + Div + ToPrimitive,
I: Clone + Eq + Hash,
[src]
V: Clone + Zero + Add + Sub + Div + ToPrimitive,
I: Clone + Eq + Hash,
type Coerced = f64
fn mean(&'i self) -> Self::Coerced
fn var(&'i self) -> Self::Coerced
fn unbiased_var(&'i self) -> Self::Coerced
fn std(&'i self) -> Self::Coerced
fn unbiased_std(&'i self) -> Self::Coerced
impl<'v, 'i, V, I> ComparisonAggregation<'i> for Series<'v, 'i, V, I> where
V: Clone + NanMinMax<V>,
I: Clone + Eq + Hash,
[src]
V: Clone + NanMinMax<V>,
I: Clone + Eq + Hash,
impl<'v, 'i, V, I> Description<'i> for Series<'v, 'i, V, I> where
V: Clone + Zero + Add + Sub + Div + ToPrimitive + NanMinMax<V>,
I: Clone + Eq + Hash,
[src]
V: Clone + Zero + Add + Sub + Div + ToPrimitive + NanMinMax<V>,
I: Clone + Eq + Hash,
impl<'v, 'i, V: Clone> From<Vec<V>> for Series<'v, 'i, V, usize>
[src]
impl<'v, 'i, V, I> Into<Vec<V>> for Series<'v, 'i, V, I> where
V: Clone,
I: Clone + Hash,
[src]
V: Clone,
I: Clone + Hash,
impl<'v, 'i, V, I> Display for Series<'v, 'i, V, I> where
V: Clone + Debug,
I: Clone + Eq + Hash,
[src]
V: Clone + Debug,
I: Clone + Eq + Hash,
impl<'v, 'i, V, I> Debug for Series<'v, 'i, V, I> where
V: Clone + ToString,
I: Clone + Eq + Hash + ToString,
[src]
V: Clone + ToString,
I: Clone + Eq + Hash + ToString,
impl<'v, 'i, V, I, O> Add<V> for Series<'v, 'i, V, I> where
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the +
operator
fn add(self, _rhs: V) -> Self::Output
The method for the +
operator
impl<'v, 'i, 'r, V, I, O> Add<&'r V> for Series<'v, 'i, V, I> where
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the +
operator
fn add(self, _rhs: &'r V) -> Self::Output
The method for the +
operator
impl<'v, 'i, 'l, V, I, O> Add<V> for &'l Series<'v, 'i, V, I> where
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the +
operator
fn add(self, _rhs: V) -> Self::Output
The method for the +
operator
impl<'v, 'i, 'l, 'r, V, I, O> Add<&'r V> for &'l Series<'v, 'i, V, I> where
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the +
operator
fn add(self, _rhs: &'r V) -> Self::Output
The method for the +
operator
impl<'lv, 'rv, 'li, 'ri, V, I, O> Add<Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the +
operator
fn add(self, _rhs: Series<V, I>) -> Self::Output
The method for the +
operator
impl<'lv, 'rv, 'li, 'ri, 'r, V, I, O> Add<&'r Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the +
operator
fn add(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the +
operator
impl<'lv, 'rv, 'li, 'ri, 'l, V, I, O> Add<Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the +
operator
fn add(self, _rhs: Series<V, I>) -> Self::Output
The method for the +
operator
impl<'lv, 'rv, 'li, 'ri, 'l, 'r, V, I, O> Add<&'r Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Add<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the +
operator
fn add(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the +
operator
impl<'v, 'i, V, I, O> Mul<V> for Series<'v, 'i, V, I> where
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the *
operator
fn mul(self, _rhs: V) -> Self::Output
The method for the *
operator
impl<'v, 'i, 'r, V, I, O> Mul<&'r V> for Series<'v, 'i, V, I> where
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the *
operator
fn mul(self, _rhs: &'r V) -> Self::Output
The method for the *
operator
impl<'v, 'i, 'l, V, I, O> Mul<V> for &'l Series<'v, 'i, V, I> where
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the *
operator
fn mul(self, _rhs: V) -> Self::Output
The method for the *
operator
impl<'v, 'i, 'l, 'r, V, I, O> Mul<&'r V> for &'l Series<'v, 'i, V, I> where
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the *
operator
fn mul(self, _rhs: &'r V) -> Self::Output
The method for the *
operator
impl<'lv, 'rv, 'li, 'ri, V, I, O> Mul<Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the *
operator
fn mul(self, _rhs: Series<V, I>) -> Self::Output
The method for the *
operator
impl<'lv, 'rv, 'li, 'ri, 'r, V, I, O> Mul<&'r Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the *
operator
fn mul(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the *
operator
impl<'lv, 'rv, 'li, 'ri, 'l, V, I, O> Mul<Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the *
operator
fn mul(self, _rhs: Series<V, I>) -> Self::Output
The method for the *
operator
impl<'lv, 'rv, 'li, 'ri, 'l, 'r, V, I, O> Mul<&'r Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Mul<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the *
operator
fn mul(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the *
operator
impl<'v, 'i, V, I, O> Sub<V> for Series<'v, 'i, V, I> where
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the -
operator
fn sub(self, _rhs: V) -> Self::Output
The method for the -
operator
impl<'v, 'i, 'r, V, I, O> Sub<&'r V> for Series<'v, 'i, V, I> where
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the -
operator
fn sub(self, _rhs: &'r V) -> Self::Output
The method for the -
operator
impl<'v, 'i, 'l, V, I, O> Sub<V> for &'l Series<'v, 'i, V, I> where
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the -
operator
fn sub(self, _rhs: V) -> Self::Output
The method for the -
operator
impl<'v, 'i, 'l, 'r, V, I, O> Sub<&'r V> for &'l Series<'v, 'i, V, I> where
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the -
operator
fn sub(self, _rhs: &'r V) -> Self::Output
The method for the -
operator
impl<'lv, 'rv, 'li, 'ri, V, I, O> Sub<Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the -
operator
fn sub(self, _rhs: Series<V, I>) -> Self::Output
The method for the -
operator
impl<'lv, 'rv, 'li, 'ri, 'r, V, I, O> Sub<&'r Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the -
operator
fn sub(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the -
operator
impl<'lv, 'rv, 'li, 'ri, 'l, V, I, O> Sub<Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the -
operator
fn sub(self, _rhs: Series<V, I>) -> Self::Output
The method for the -
operator
impl<'lv, 'rv, 'li, 'ri, 'l, 'r, V, I, O> Sub<&'r Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Sub<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the -
operator
fn sub(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the -
operator
impl<'v, 'i, V, I, O> Div<V> for Series<'v, 'i, V, I> where
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the /
operator
fn div(self, _rhs: V) -> Self::Output
The method for the /
operator
impl<'v, 'i, 'r, V, I, O> Div<&'r V> for Series<'v, 'i, V, I> where
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the /
operator
fn div(self, _rhs: &'r V) -> Self::Output
The method for the /
operator
impl<'v, 'i, 'l, V, I, O> Div<V> for &'l Series<'v, 'i, V, I> where
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the /
operator
fn div(self, _rhs: V) -> Self::Output
The method for the /
operator
impl<'v, 'i, 'l, 'r, V, I, O> Div<&'r V> for &'l Series<'v, 'i, V, I> where
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the /
operator
fn div(self, _rhs: &'r V) -> Self::Output
The method for the /
operator
impl<'lv, 'rv, 'li, 'ri, V, I, O> Div<Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the /
operator
fn div(self, _rhs: Series<V, I>) -> Self::Output
The method for the /
operator
impl<'lv, 'rv, 'li, 'ri, 'r, V, I, O> Div<&'r Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the /
operator
fn div(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the /
operator
impl<'lv, 'rv, 'li, 'ri, 'l, V, I, O> Div<Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the /
operator
fn div(self, _rhs: Series<V, I>) -> Self::Output
The method for the /
operator
impl<'lv, 'rv, 'li, 'ri, 'l, 'r, V, I, O> Div<&'r Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Div<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the /
operator
fn div(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the /
operator
impl<'v, 'i, V, I, O> Rem<V> for Series<'v, 'i, V, I> where
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the %
operator
fn rem(self, _rhs: V) -> Self::Output
The method for the %
operator
impl<'v, 'i, 'r, V, I, O> Rem<&'r V> for Series<'v, 'i, V, I> where
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the %
operator
fn rem(self, _rhs: &'r V) -> Self::Output
The method for the %
operator
impl<'v, 'i, 'l, V, I, O> Rem<V> for &'l Series<'v, 'i, V, I> where
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the %
operator
fn rem(self, _rhs: V) -> Self::Output
The method for the %
operator
impl<'v, 'i, 'l, 'r, V, I, O> Rem<&'r V> for &'l Series<'v, 'i, V, I> where
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the %
operator
fn rem(self, _rhs: &'r V) -> Self::Output
The method for the %
operator
impl<'lv, 'rv, 'li, 'ri, V, I, O> Rem<Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the %
operator
fn rem(self, _rhs: Series<V, I>) -> Self::Output
The method for the %
operator
impl<'lv, 'rv, 'li, 'ri, 'r, V, I, O> Rem<&'r Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the %
operator
fn rem(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the %
operator
impl<'lv, 'rv, 'li, 'ri, 'l, V, I, O> Rem<Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the %
operator
fn rem(self, _rhs: Series<V, I>) -> Self::Output
The method for the %
operator
impl<'lv, 'rv, 'li, 'ri, 'l, 'r, V, I, O> Rem<&'r Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + Rem<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the %
operator
fn rem(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the %
operator
impl<'v, 'i, V, I, O> BitAnd<V> for Series<'v, 'i, V, I> where
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the &
operator
fn bitand(self, _rhs: V) -> Self::Output
The method for the &
operator
impl<'v, 'i, 'r, V, I, O> BitAnd<&'r V> for Series<'v, 'i, V, I> where
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the &
operator
fn bitand(self, _rhs: &'r V) -> Self::Output
The method for the &
operator
impl<'v, 'i, 'l, V, I, O> BitAnd<V> for &'l Series<'v, 'i, V, I> where
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the &
operator
fn bitand(self, _rhs: V) -> Self::Output
The method for the &
operator
impl<'v, 'i, 'l, 'r, V, I, O> BitAnd<&'r V> for &'l Series<'v, 'i, V, I> where
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the &
operator
fn bitand(self, _rhs: &'r V) -> Self::Output
The method for the &
operator
impl<'lv, 'rv, 'li, 'ri, V, I, O> BitAnd<Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the &
operator
fn bitand(self, _rhs: Series<V, I>) -> Self::Output
The method for the &
operator
impl<'lv, 'rv, 'li, 'ri, 'r, V, I, O> BitAnd<&'r Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the &
operator
fn bitand(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the &
operator
impl<'lv, 'rv, 'li, 'ri, 'l, V, I, O> BitAnd<Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the &
operator
fn bitand(self, _rhs: Series<V, I>) -> Self::Output
The method for the &
operator
impl<'lv, 'rv, 'li, 'ri, 'l, 'r, V, I, O> BitAnd<&'r Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitAnd<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the &
operator
fn bitand(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the &
operator
impl<'v, 'i, V, I, O> BitOr<V> for Series<'v, 'i, V, I> where
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the |
operator
fn bitor(self, _rhs: V) -> Self::Output
The method for the |
operator
impl<'v, 'i, 'r, V, I, O> BitOr<&'r V> for Series<'v, 'i, V, I> where
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the |
operator
fn bitor(self, _rhs: &'r V) -> Self::Output
The method for the |
operator
impl<'v, 'i, 'l, V, I, O> BitOr<V> for &'l Series<'v, 'i, V, I> where
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the |
operator
fn bitor(self, _rhs: V) -> Self::Output
The method for the |
operator
impl<'v, 'i, 'l, 'r, V, I, O> BitOr<&'r V> for &'l Series<'v, 'i, V, I> where
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the |
operator
fn bitor(self, _rhs: &'r V) -> Self::Output
The method for the |
operator
impl<'lv, 'rv, 'li, 'ri, V, I, O> BitOr<Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the |
operator
fn bitor(self, _rhs: Series<V, I>) -> Self::Output
The method for the |
operator
impl<'lv, 'rv, 'li, 'ri, 'r, V, I, O> BitOr<&'r Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the |
operator
fn bitor(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the |
operator
impl<'lv, 'rv, 'li, 'ri, 'l, V, I, O> BitOr<Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the |
operator
fn bitor(self, _rhs: Series<V, I>) -> Self::Output
The method for the |
operator
impl<'lv, 'rv, 'li, 'ri, 'l, 'r, V, I, O> BitOr<&'r Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitOr<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the |
operator
fn bitor(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the |
operator
impl<'v, 'i, V, I, O> BitXor<V> for Series<'v, 'i, V, I> where
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the ^
operator
fn bitxor(self, _rhs: V) -> Self::Output
The method for the ^
operator
impl<'v, 'i, 'r, V, I, O> BitXor<&'r V> for Series<'v, 'i, V, I> where
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
[src]
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'v + Clone,
type Output = Series<'v, 'i, O, I>
The resulting type after applying the ^
operator
fn bitxor(self, _rhs: &'r V) -> Self::Output
The method for the ^
operator
impl<'v, 'i, 'l, V, I, O> BitXor<V> for &'l Series<'v, 'i, V, I> where
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the ^
operator
fn bitxor(self, _rhs: V) -> Self::Output
The method for the ^
operator
impl<'v, 'i, 'l, 'r, V, I, O> BitXor<&'r V> for &'l Series<'v, 'i, V, I> where
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the ^
operator
fn bitxor(self, _rhs: &'r V) -> Self::Output
The method for the ^
operator
impl<'lv, 'rv, 'li, 'ri, V, I, O> BitXor<Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the ^
operator
fn bitxor(self, _rhs: Series<V, I>) -> Self::Output
The method for the ^
operator
impl<'lv, 'rv, 'li, 'ri, 'r, V, I, O> BitXor<&'r Series<'rv, 'ri, V, I>> for Series<'lv, 'li, V, I> where
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
[src]
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'lv + Clone,
type Output = Series<'lv, 'li, O, I>
The resulting type after applying the ^
operator
fn bitxor(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the ^
operator
impl<'lv, 'rv, 'li, 'ri, 'l, V, I, O> BitXor<Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the ^
operator
fn bitxor(self, _rhs: Series<V, I>) -> Self::Output
The method for the ^
operator
impl<'lv, 'rv, 'li, 'ri, 'l, 'r, V, I, O> BitXor<&'r Series<'rv, 'ri, V, I>> for &'l Series<'lv, 'li, V, I> where
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
[src]
V: Clone + BitXor<Output = O>,
I: Clone + Eq + Hash,
O: 'l + Clone,
type Output = Series<'l, 'l, O, I>
The resulting type after applying the ^
operator
fn bitxor(self, _rhs: &'r Series<V, I>) -> Self::Output
The method for the ^
operator
impl<'v, 'i, V: Clone, I: Clone> Clone for Series<'v, 'i, V, I> where
V: 'v + Clone,
I: 'i + Clone + Hash,
[src]
V: 'v + Clone,
I: 'i + Clone + Hash,
fn clone(&self) -> Series<'v, 'i, V, I>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl<'v, 'i, V, I> RowIndex<'i> for Series<'v, 'i, V, I> where
V: Clone,
I: Clone + Eq + Hash,
[src]
V: Clone,
I: Clone + Eq + Hash,
///////////////////////////////////////////////////////////////////////////// Indexing /////////////////////////////////////////////////////////////////////////////
type Key = I
type Row = V
fn len(&self) -> usize
fn loc(&self, label: &Self::Key) -> Self::Row
Get a single value corresponding to given label (slice by LOCation)
fn iloc(&self, location: &usize) -> Self::Row
Get a single value corresponding to given index (slice by Index LOCation)
fn reindex(&self, labels: &[Self::Key]) -> Self
fn reindex_by_index(&self, locations: &[usize]) -> Self
fn blocs(&self, flags: &[bool]) -> Self
Slice using given Vec
fn head(&'s self, n: usize) -> Self
fn tail(&'s self, n: usize) -> Self
fn locs<'l>(&'s self, labels: &'l [Self::Key]) -> Self
Slice using given labels (slice by LOCationS)
fn ilocs<'l>(&'s self, locations: &'l [usize]) -> Self
Slice using given indices (slice by Index LOCationS)
impl<'v, 'i, V, I> Append<'i> for Series<'v, 'i, V, I> where
V: Clone,
I: Clone + Eq + Hash,
[src]
V: Clone,
I: Clone + Eq + Hash,
///////////////////////////////////////////////////////////////////////////// Append /////////////////////////////////////////////////////////////////////////////
fn append(&self, other: &Self) -> Self
impl<'v, 'i, V, I, R> Apply<'i, R> for Series<'v, 'i, V, I> where
V: 'i + Clone,
I: Clone + Eq + Hash,
[src]
V: 'i + Clone,
I: Clone + Eq + Hash,
///////////////////////////////////////////////////////////////////////////// Apply /////////////////////////////////////////////////////////////////////////////
type In = Vec<V>
type FOut = R
type Out = R
fn apply<'f>(&'i self, func: &'f Fn(&Self::In) -> Self::FOut) -> Self::Out
impl<'v, 'i, V, I> PartialEq for Series<'v, 'i, V, I> where
V: Clone + PartialEq,
I: Clone + Hash + Eq,
[src]
V: Clone + PartialEq,
I: Clone + Hash + Eq,
///////////////////////////////////////////////////////////////////////////// Eq /////////////////////////////////////////////////////////////////////////////
fn eq(&self, other: &Self) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0
This method tests for !=
.
impl<'v, 'i, V, I> IntoIterator for Series<'v, 'i, V, I> where
V: Clone,
I: Clone + Eq + Hash,
[src]
V: Clone,
I: Clone + Eq + Hash,
///////////////////////////////////////////////////////////////////////////// Iterator /////////////////////////////////////////////////////////////////////////////
type Item = V
The type of the elements being iterated over.
type IntoIter = IntoIter<V>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
Creates an iterator from a value. Read more
impl<'v, 'i, V> FromIterator<V> for Series<'v, 'i, V, usize> where
V: Clone,
[src]
V: Clone,
fn from_iter<T>(iter: T) -> Series<'v, 'i, V, usize> where
T: IntoIterator<Item = V>,
T: IntoIterator<Item = V>,
Creates a value from an iterator. Read more