Struct brassfibre::prelude::Series

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

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

fn sort_index(&self) -> Self

impl<'v, 'i, V, I> Series<'v, 'i, V, I> where 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

///////////////////////////////////////////////////////////////////////////// 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>>

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

impl<'v, 'i, V, I> Series<'v, 'i, V, I> where V: Clone, I: Clone + Eq + Hash

fn iter(&self) -> Iter<V>

Trait Implementations

impl<'v, 'i, V, I> BasicAggregation<'i> for Series<'v, 'i, V, I> where 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

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

type Kept = V

fn min(&'i self) -> Self::Kept

fn max(&'i self) -> Self::Kept

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

type Described = Series<'i, 'i, f64, &'i str>

fn describe(&'i self) -> Self::Described

impl<'v, 'i, V: Clone> From<Vec<V>> for Series<'v, 'i, V, usize>

fn from(values: Vec<V>) -> Self

Performs the conversion.

impl<'v, 'i, V, I> Into<Vec<V>> for Series<'v, 'i, V, I> where V: Clone, I: Clone + Hash

fn into(self) -> Vec<V>

Performs the conversion.

impl<'v, 'i, V, I> Display for Series<'v, 'i, V, I> where V: Clone + Debug, I: Clone + Eq + Hash

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

Formats the value using the given formatter.

impl<'v, 'i, V, I> Debug for Series<'v, 'i, V, I> where V: Clone + ToString, I: Clone + Eq + Hash + ToString

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

Formats the value using the given formatter.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn clone(&self) -> Series<'v, 'i, V, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'v, 'i, V, I> RowIndex<'i> for Series<'v, 'i, V, I> where 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 (slice by Bool LOCationS)

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

///////////////////////////////////////////////////////////////////////////// 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

///////////////////////////////////////////////////////////////////////////// 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

///////////////////////////////////////////////////////////////////////////// Eq /////////////////////////////////////////////////////////////////////////////

fn eq(&self, other: &Self) -> 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 !=.

impl<'v, 'i, V, I> IntoIterator for Series<'v, 'i, V, I> where 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.

impl<'v, 'i, V> FromIterator<V> for Series<'v, 'i, V, usize> where V: Clone

fn from_iter<T>(iter: T) -> Series<'v, 'i, V, usize> where T: IntoIterator<Item=V>

Creates a value from an iterator.