Struct agnes::select::Selection

pub struct Selection<DTypes, D, T> { /* fields omitted */ }

Type for accessing a specified field (identified by a FieldIdent) for an underlying data structure.

Methods

impl<DTypes, D, T> Selection<DTypes, D, T>

pub fn new(data: D, ident: FieldIdent) -> Selection<DTypes, D, T>

Create a new Selection object from specified data and identifier.

Trait Implementations

impl<'a, 'b, DI> Add<&'b u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b u64) -> DataView<Types>

Performs the + operation.

impl<DI> Add<u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<&'b u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b u64) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'a Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<&'a Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b i64) -> DataView<Types>

Performs the + operation.

impl<DI> Add<i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<&'b i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b i64) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'a Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<&'a Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b f64) -> DataView<Types>

Performs the + operation.

impl<DI> Add<f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<&'b f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b f64) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'a Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<&'a Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Sub<&'b u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b u64) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<&'b u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b u64) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'a Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<&'a Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b i64) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<&'b i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b i64) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'a Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<&'a Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b f64) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<&'b f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b f64) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'a Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<&'a Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Mul<&'b u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b u64) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<&'b u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b u64) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'a Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<&'a Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b i64) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<&'b i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b i64) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'a Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<&'a Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b f64) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<&'b f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b f64) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'a Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<&'a Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Div<&'b u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b u64) -> DataView<Types>

Performs the / operation.

impl<DI> Div<u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<&'b u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b u64) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'a Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<&'a Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b i64) -> DataView<Types>

Performs the / operation.

impl<DI> Div<i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<&'b i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b i64) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'a Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<&'a Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b f64) -> DataView<Types>

Performs the / operation.

impl<DI> Div<f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<&'b f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b f64) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'a Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<&'a Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Add<&'b Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, DI> Add<Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'b, DI> Add<&'b Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, DI> Add<Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'b, DI> Add<&'b Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, DI> Add<Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'b, DI> Add<&'b Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, 'b, DI> Sub<&'b Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, DI> Sub<Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'b, DI> Sub<&'b Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, DI> Sub<Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'b, DI> Sub<&'b Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, DI> Sub<Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'b, DI> Sub<&'b Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, 'b, DI> Mul<&'b Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, DI> Mul<Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'b, DI> Mul<&'b Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, DI> Mul<Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'b, DI> Mul<&'b Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, DI> Mul<Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'b, DI> Mul<&'b Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, 'b, DI> Div<&'b Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, DI> Div<Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'b, DI> Div<&'b Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, DI> Div<Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'b, DI> Div<&'b Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, DI> Div<Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'b, DI> Div<&'b Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, 'b, DI> Add<&'b u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b u64) -> DataView<Types>

Performs the + operation.

impl<DI> Add<u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<&'b u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b u64) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'a Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<&'a Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b i64) -> DataView<Types>

Performs the + operation.

impl<DI> Add<i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<&'b i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b i64) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'a Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<&'a Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b f64) -> DataView<Types>

Performs the + operation.

impl<DI> Add<f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<&'b f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b f64) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'a Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<&'a Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b u32> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b u32) -> DataView<Types>

Performs the + operation.

impl<DI> Add<u32> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<&'b u32> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b u32) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<u32> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'a Selection<Types, DI, u32>> for &'b u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, u32>) -> DataView<Types>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, u32>> for u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u32>) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<Selection<Types, DI, u32>> for &'b u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u32>) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<&'a Selection<Types, DI, u32>> for u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, u32>) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b i32> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b i32) -> DataView<Types>

Performs the + operation.

impl<DI> Add<i32> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<&'b i32> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b i32) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<i32> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'a Selection<Types, DI, i32>> for &'b i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, i32>) -> DataView<Types>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, i32>> for i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i32>) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<Selection<Types, DI, i32>> for &'b i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i32>) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<&'a Selection<Types, DI, i32>> for i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, i32>) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b f32> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b f32) -> DataView<Types>

Performs the + operation.

impl<DI> Add<f32> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<&'b f32> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'b f32) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<f32> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Add<&'a Selection<Types, DI, f32>> for &'b f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, f32>) -> DataView<Types>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, f32>> for f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f32>) -> DataView<Types>

Performs the + operation.

impl<'b, DI> Add<Selection<Types, DI, f32>> for &'b f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f32>) -> DataView<Types>

Performs the + operation.

impl<'a, DI> Add<&'a Selection<Types, DI, f32>> for f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Selection<Types, DI, f32>) -> DataView<Types>

Performs the + operation.

impl<'a, 'b, DI> Sub<&'b u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b u64) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<&'b u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b u64) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'a Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<&'a Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b i64) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<&'b i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b i64) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'a Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<&'a Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b f64) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<&'b f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b f64) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'a Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<&'a Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b u32> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b u32) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<u32> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<&'b u32> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b u32) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<u32> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'a Selection<Types, DI, u32>> for &'b u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, u32>) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, u32>> for u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u32>) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<Selection<Types, DI, u32>> for &'b u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u32>) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<&'a Selection<Types, DI, u32>> for u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, u32>) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b i32> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b i32) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<i32> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<&'b i32> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b i32) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<i32> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'a Selection<Types, DI, i32>> for &'b i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, i32>) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, i32>> for i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i32>) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<Selection<Types, DI, i32>> for &'b i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i32>) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<&'a Selection<Types, DI, i32>> for i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, i32>) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b f32> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b f32) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<f32> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<&'b f32> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b f32) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<f32> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'a Selection<Types, DI, f32>> for &'b f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, f32>) -> DataView<Types>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, f32>> for f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f32>) -> DataView<Types>

Performs the - operation.

impl<'b, DI> Sub<Selection<Types, DI, f32>> for &'b f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f32>) -> DataView<Types>

Performs the - operation.

impl<'a, DI> Sub<&'a Selection<Types, DI, f32>> for f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Selection<Types, DI, f32>) -> DataView<Types>

Performs the - operation.

impl<'a, 'b, DI> Mul<&'b u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b u64) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<&'b u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b u64) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'a Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<&'a Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b i64) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<&'b i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b i64) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'a Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<&'a Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b f64) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<&'b f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b f64) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'a Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<&'a Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b u32> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b u32) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<u32> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<&'b u32> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b u32) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<u32> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'a Selection<Types, DI, u32>> for &'b u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, u32>) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, u32>> for u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u32>) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<Selection<Types, DI, u32>> for &'b u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u32>) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<&'a Selection<Types, DI, u32>> for u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, u32>) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b i32> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b i32) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<i32> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<&'b i32> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b i32) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<i32> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'a Selection<Types, DI, i32>> for &'b i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, i32>) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, i32>> for i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i32>) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<Selection<Types, DI, i32>> for &'b i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i32>) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<&'a Selection<Types, DI, i32>> for i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, i32>) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b f32> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b f32) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<f32> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<&'b f32> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b f32) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<f32> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'a Selection<Types, DI, f32>> for &'b f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, f32>) -> DataView<Types>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, f32>> for f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f32>) -> DataView<Types>

Performs the * operation.

impl<'b, DI> Mul<Selection<Types, DI, f32>> for &'b f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f32>) -> DataView<Types>

Performs the * operation.

impl<'a, DI> Mul<&'a Selection<Types, DI, f32>> for f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Selection<Types, DI, f32>) -> DataView<Types>

Performs the * operation.

impl<'a, 'b, DI> Div<&'b u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b u64) -> DataView<Types>

Performs the / operation.

impl<DI> Div<u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<&'b u64> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b u64) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<u64> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'a Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<Selection<Types, DI, u64>> for &'b u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u64>) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<&'a Selection<Types, DI, u64>> for u64 where     DI: DataIndex<Types, DType = u64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, u64>) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b i64) -> DataView<Types>

Performs the / operation.

impl<DI> Div<i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<&'b i64> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b i64) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<i64> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'a Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<Selection<Types, DI, i64>> for &'b i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i64>) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<&'a Selection<Types, DI, i64>> for i64 where     DI: DataIndex<Types, DType = i64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, i64>) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b f64) -> DataView<Types>

Performs the / operation.

impl<DI> Div<f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<&'b f64> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b f64) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<f64> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'a Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<Selection<Types, DI, f64>> for &'b f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f64>) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<&'a Selection<Types, DI, f64>> for f64 where     DI: DataIndex<Types, DType = f64>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, f64>) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b u32> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b u32) -> DataView<Types>

Performs the / operation.

impl<DI> Div<u32> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<&'b u32> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b u32) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<u32> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'a Selection<Types, DI, u32>> for &'b u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, u32>) -> DataView<Types>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, u32>> for u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u32>) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<Selection<Types, DI, u32>> for &'b u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u32>) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<&'a Selection<Types, DI, u32>> for u32 where     DI: DataIndex<Types, DType = u32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, u32>) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b i32> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b i32) -> DataView<Types>

Performs the / operation.

impl<DI> Div<i32> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<&'b i32> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b i32) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<i32> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'a Selection<Types, DI, i32>> for &'b i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, i32>) -> DataView<Types>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, i32>> for i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i32>) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<Selection<Types, DI, i32>> for &'b i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i32>) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<&'a Selection<Types, DI, i32>> for i32 where     DI: DataIndex<Types, DType = i32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, i32>) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b f32> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b f32) -> DataView<Types>

Performs the / operation.

impl<DI> Div<f32> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<&'b f32> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'b f32) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<f32> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Div<&'a Selection<Types, DI, f32>> for &'b f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, f32>) -> DataView<Types>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, f32>> for f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f32>) -> DataView<Types>

Performs the / operation.

impl<'b, DI> Div<Selection<Types, DI, f32>> for &'b f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f32>) -> DataView<Types>

Performs the / operation.

impl<'a, DI> Div<&'a Selection<Types, DI, f32>> for f32 where     DI: DataIndex<Types, DType = f32>,

type Output = DataView<Types>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Selection<Types, DI, f32>) -> DataView<Types>

Performs the / operation.

impl<'a, 'b, DI> Add<&'b Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, DI> Add<Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'b, DI> Add<&'b Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, DI> Add<Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'b, DI> Add<&'b Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, DI> Add<Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'b, DI> Add<&'b Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b Selection<Types, DI, u32>> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, u32>> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, DI> Add<Selection<Types, DI, u32>> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the + operation.

impl<'b, DI> Add<&'b Selection<Types, DI, u32>> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b Selection<Types, DI, i32>> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, i32>> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, DI> Add<Selection<Types, DI, i32>> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the + operation.

impl<'b, DI> Add<&'b Selection<Types, DI, i32>> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, 'b, DI> Add<&'b Selection<Types, DI, f32>> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the + operation.

impl<DI> Add<Selection<Types, DI, f32>> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, DI> Add<Selection<Types, DI, f32>> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the + operation.

impl<'b, DI> Add<&'b Selection<Types, DI, f32>> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the + operation.

impl<'a, 'b, DI> Sub<&'b Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, DI> Sub<Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'b, DI> Sub<&'b Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, DI> Sub<Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'b, DI> Sub<&'b Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, DI> Sub<Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'b, DI> Sub<&'b Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b Selection<Types, DI, u32>> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, u32>> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, DI> Sub<Selection<Types, DI, u32>> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the - operation.

impl<'b, DI> Sub<&'b Selection<Types, DI, u32>> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b Selection<Types, DI, i32>> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, i32>> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, DI> Sub<Selection<Types, DI, i32>> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the - operation.

impl<'b, DI> Sub<&'b Selection<Types, DI, i32>> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, 'b, DI> Sub<&'b Selection<Types, DI, f32>> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the - operation.

impl<DI> Sub<Selection<Types, DI, f32>> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, DI> Sub<Selection<Types, DI, f32>> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the - operation.

impl<'b, DI> Sub<&'b Selection<Types, DI, f32>> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the - operation.

impl<'a, 'b, DI> Mul<&'b Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, DI> Mul<Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'b, DI> Mul<&'b Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, DI> Mul<Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'b, DI> Mul<&'b Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, DI> Mul<Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'b, DI> Mul<&'b Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b Selection<Types, DI, u32>> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, u32>> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, DI> Mul<Selection<Types, DI, u32>> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the * operation.

impl<'b, DI> Mul<&'b Selection<Types, DI, u32>> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b Selection<Types, DI, i32>> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, i32>> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, DI> Mul<Selection<Types, DI, i32>> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the * operation.

impl<'b, DI> Mul<&'b Selection<Types, DI, i32>> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, 'b, DI> Mul<&'b Selection<Types, DI, f32>> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the * operation.

impl<DI> Mul<Selection<Types, DI, f32>> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, DI> Mul<Selection<Types, DI, f32>> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the * operation.

impl<'b, DI> Mul<&'b Selection<Types, DI, f32>> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the * operation.

impl<'a, 'b, DI> Div<&'b Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, DI> Div<Selection<Types, DI, u64>> for &'a Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'b, DI> Div<&'b Selection<Types, DI, u64>> for Selection<Types, DI, u64> where     DI: DataIndex<Types, DType = u64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, u64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, DI> Div<Selection<Types, DI, i64>> for &'a Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'b, DI> Div<&'b Selection<Types, DI, i64>> for Selection<Types, DI, i64> where     DI: DataIndex<Types, DType = i64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, i64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, DI> Div<Selection<Types, DI, f64>> for &'a Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'b, DI> Div<&'b Selection<Types, DI, f64>> for Selection<Types, DI, f64> where     DI: DataIndex<Types, DType = f64>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, f64>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b Selection<Types, DI, u32>> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, u32>> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, DI> Div<Selection<Types, DI, u32>> for &'a Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the / operation.

impl<'b, DI> Div<&'b Selection<Types, DI, u32>> for Selection<Types, DI, u32> where     DI: DataIndex<Types, DType = u32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, u32>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b Selection<Types, DI, i32>> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, i32>> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, DI> Div<Selection<Types, DI, i32>> for &'a Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the / operation.

impl<'b, DI> Div<&'b Selection<Types, DI, i32>> for Selection<Types, DI, i32> where     DI: DataIndex<Types, DType = i32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, i32>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, 'b, DI> Div<&'b Selection<Types, DI, f32>> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the / operation.

impl<DI> Div<Selection<Types, DI, f32>> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the / operation.

impl<'a, DI> Div<Selection<Types, DI, f32>> for &'a Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the / operation.

impl<'b, DI> Div<&'b Selection<Types, DI, f32>> for Selection<Types, DI, f32> where     DI: DataIndex<Types, DType = f32>,

type Output = Result<DataView<Types>>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Selection<Types, DI, f32>) -> Result<DataView<Types>>

Performs the / operation.

impl<DTypes: Debug, D: Debug, T: Debug> Debug for Selection<DTypes, D, T>

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

Formats the value using the given formatter.

impl<DTypes: Clone, D: Clone, T: Clone> Clone for Selection<DTypes, D, T>

fn clone(&self) -> Selection<DTypes, D, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<DTypes, U, T> DataIndex<DTypes> for Selection<DTypes, U, T> where     DTypes: DTypeList,     T: DataType<DTypes>,     U: DataIndex<DTypes, DType = T>,

type DType = T

The data type contained within this field.

fn get_datum(&self, idx: usize) -> Result<Value<&T>>

Returns the data (possibly NA) at the specified index, if it exists.

fn len(&self) -> usize

Returns the length of this data field.

fn is_empty(&self) -> bool

Returns whether or not this field is empty.

Important traits for DataIterator<'a, DTypes, T>

impl<'a, DTypes, T> Iterator for DataIterator<'a, DTypes, T> where
    DTypes: DTypeList,
    T: 'a + DataType<DTypes>,  type Item = Value<&'a T>;

fn iter(&self) -> DataIterator<DTypes, Self::DType> where     Self: Sized,

Returns an iterator over the values in this field.