Trait tract_nnef::internal::tract_downcast_rs::__std::ops::Sub

#[lang = "sub"]
pub trait Sub<Rhs = Self> {
    type Output;
    #[must_use]
    pub fn sub(self, rhs: Rhs) -> Self::Output;
}

The subtraction operator -.

Note that Rhs is Self by default, but this is not mandatory. For example, std::time::SystemTime implements Sub<Duration>, which permits operations of the form SystemTime = SystemTime - Duration.

Examples

Subtractable points

use std::ops::Sub;

#[derive(Debug, Copy, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

impl Sub for Point {
    type Output = Self;

    fn sub(self, other: Self) -> Self::Output {
        Self {
            x: self.x - other.x,
            y: self.y - other.y,
        }
    }
}

assert_eq!(Point { x: 3, y: 3 } - Point { x: 2, y: 3 },
           Point { x: 1, y: 0 });

Implementing Sub with generics

Here is an example of the same Point struct implementing the Sub trait using generics.

use std::ops::Sub;

#[derive(Debug, PartialEq)]
struct Point<T> {
    x: T,
    y: T,
}

// Notice that the implementation uses the associated type `Output`.
impl<T: Sub<Output = T>> Sub for Point<T> {
    type Output = Self;

    fn sub(self, other: Self) -> Self::Output {
        Point {
            x: self.x - other.x,
            y: self.y - other.y,
        }
    }
}

assert_eq!(Point { x: 2, y: 3 } - Point { x: 1, y: 0 },
           Point { x: 1, y: 3 });

Associated Types

type Output

The resulting type after applying the - operator.

Loading content...

Required methods

#[must_use]

pub fn sub(self, rhs: Rhs) -> Self::Output

Performs the - operation.

Example

assert_eq!(12 - 1, 11);

Loading content...

Implementations on Foreign Types

impl Sub<i8> for i8

type Output = i8

pub fn sub(self, other: i8) -> i8

impl<'_, '_> Sub<&'_ i16> for &'_ i16

type Output = <i16 as Sub<i16>>::Output

pub fn sub(self, other: &i16) -> <i16 as Sub<i16>>::Output

impl<'_, '_> Sub<&'_ u64> for &'_ u64

type Output = <u64 as Sub<u64>>::Output

pub fn sub(self, other: &u64) -> <u64 as Sub<u64>>::Output

impl<'a> Sub<i64> for &'a i64

type Output = <i64 as Sub<i64>>::Output

pub fn sub(self, other: i64) -> <i64 as Sub<i64>>::Output

impl<'a> Sub<u32> for &'a u32

type Output = <u32 as Sub<u32>>::Output

pub fn sub(self, other: u32) -> <u32 as Sub<u32>>::Output

impl Sub<usize> for usize

type Output = usize

pub fn sub(self, other: usize) -> usize

impl<'_, '_> Sub<&'_ i8> for &'_ i8

type Output = <i8 as Sub<i8>>::Output

pub fn sub(self, other: &i8) -> <i8 as Sub<i8>>::Output

impl Sub<i32> for i32

type Output = i32

pub fn sub(self, other: i32) -> i32

impl<'_, '_> Sub<&'_ u16> for &'_ u16

type Output = <u16 as Sub<u16>>::Output

pub fn sub(self, other: &u16) -> <u16 as Sub<u16>>::Output

impl<'_> Sub<&'_ i128> for i128

type Output = <i128 as Sub<i128>>::Output

pub fn sub(self, other: &i128) -> <i128 as Sub<i128>>::Output

impl<'_, '_> Sub<&'_ isize> for &'_ isize

type Output = <isize as Sub<isize>>::Output

pub fn sub(self, other: &isize) -> <isize as Sub<isize>>::Output

impl<'a> Sub<i32> for &'a i32

type Output = <i32 as Sub<i32>>::Output

pub fn sub(self, other: i32) -> <i32 as Sub<i32>>::Output

impl<'a> Sub<i8> for &'a i8

type Output = <i8 as Sub<i8>>::Output

pub fn sub(self, other: i8) -> <i8 as Sub<i8>>::Output

impl<'a> Sub<i128> for &'a i128

type Output = <i128 as Sub<i128>>::Output

pub fn sub(self, other: i128) -> <i128 as Sub<i128>>::Output

impl<'_> Sub<&'_ i64> for i64

type Output = <i64 as Sub<i64>>::Output

pub fn sub(self, other: &i64) -> <i64 as Sub<i64>>::Output

impl<'_, '_> Sub<&'_ u128> for &'_ u128

type Output = <u128 as Sub<u128>>::Output

pub fn sub(self, other: &u128) -> <u128 as Sub<u128>>::Output

impl<'a> Sub<isize> for &'a isize

type Output = <isize as Sub<isize>>::Output

pub fn sub(self, other: isize) -> <isize as Sub<isize>>::Output

impl<'_, '_> Sub<&'_ f64> for &'_ f64

type Output = <f64 as Sub<f64>>::Output

pub fn sub(self, other: &f64) -> <f64 as Sub<f64>>::Output

impl<'a> Sub<u16> for &'a u16

type Output = <u16 as Sub<u16>>::Output

pub fn sub(self, other: u16) -> <u16 as Sub<u16>>::Output

impl Sub<u8> for u8

type Output = u8

pub fn sub(self, other: u8) -> u8

impl<'a> Sub<u64> for &'a u64

type Output = <u64 as Sub<u64>>::Output

pub fn sub(self, other: u64) -> <u64 as Sub<u64>>::Output

impl<'_> Sub<&'_ f64> for f64

type Output = <f64 as Sub<f64>>::Output

pub fn sub(self, other: &f64) -> <f64 as Sub<f64>>::Output

impl Sub<u16> for u16

type Output = u16

pub fn sub(self, other: u16) -> u16

impl Sub<u128> for u128

type Output = u128

pub fn sub(self, other: u128) -> u128

impl<'_> Sub<&'_ isize> for isize

type Output = <isize as Sub<isize>>::Output

pub fn sub(self, other: &isize) -> <isize as Sub<isize>>::Output

impl<'a> Sub<u128> for &'a u128

type Output = <u128 as Sub<u128>>::Output

pub fn sub(self, other: u128) -> <u128 as Sub<u128>>::Output

impl<'_, '_> Sub<&'_ i32> for &'_ i32

type Output = <i32 as Sub<i32>>::Output

pub fn sub(self, other: &i32) -> <i32 as Sub<i32>>::Output

impl<'_> Sub<&'_ u64> for u64

type Output = <u64 as Sub<u64>>::Output

pub fn sub(self, other: &u64) -> <u64 as Sub<u64>>::Output

impl<'_, '_> Sub<&'_ i128> for &'_ i128

type Output = <i128 as Sub<i128>>::Output

pub fn sub(self, other: &i128) -> <i128 as Sub<i128>>::Output

impl<'_, '_> Sub<&'_ u32> for &'_ u32

type Output = <u32 as Sub<u32>>::Output

pub fn sub(self, other: &u32) -> <u32 as Sub<u32>>::Output

impl Sub<u32> for u32

type Output = u32

pub fn sub(self, other: u32) -> u32

impl<'_, '_> Sub<&'_ i64> for &'_ i64

type Output = <i64 as Sub<i64>>::Output

pub fn sub(self, other: &i64) -> <i64 as Sub<i64>>::Output

impl Sub<f64> for f64

type Output = f64

pub fn sub(self, other: f64) -> f64

impl<'_> Sub<&'_ usize> for usize

type Output = <usize as Sub<usize>>::Output

pub fn sub(self, other: &usize) -> <usize as Sub<usize>>::Output

impl Sub<isize> for isize

type Output = isize

pub fn sub(self, other: isize) -> isize

impl<'a> Sub<f32> for &'a f32

type Output = <f32 as Sub<f32>>::Output

pub fn sub(self, other: f32) -> <f32 as Sub<f32>>::Output

impl<'_> Sub<&'_ u8> for u8

type Output = <u8 as Sub<u8>>::Output

pub fn sub(self, other: &u8) -> <u8 as Sub<u8>>::Output

impl<'_> Sub<&'_ i32> for i32

type Output = <i32 as Sub<i32>>::Output

pub fn sub(self, other: &i32) -> <i32 as Sub<i32>>::Output

impl<'_> Sub<&'_ u16> for u16

type Output = <u16 as Sub<u16>>::Output

pub fn sub(self, other: &u16) -> <u16 as Sub<u16>>::Output

impl Sub<i64> for i64

type Output = i64

pub fn sub(self, other: i64) -> i64

impl<'a> Sub<usize> for &'a usize

type Output = <usize as Sub<usize>>::Output

pub fn sub(self, other: usize) -> <usize as Sub<usize>>::Output

impl<'_> Sub<&'_ u128> for u128

type Output = <u128 as Sub<u128>>::Output

pub fn sub(self, other: &u128) -> <u128 as Sub<u128>>::Output

impl<'_, '_> Sub<&'_ usize> for &'_ usize

type Output = <usize as Sub<usize>>::Output

pub fn sub(self, other: &usize) -> <usize as Sub<usize>>::Output

impl Sub<i16> for i16

type Output = i16

pub fn sub(self, other: i16) -> i16

impl Sub<i128> for i128

type Output = i128

pub fn sub(self, other: i128) -> i128

impl Sub<u64> for u64

type Output = u64

pub fn sub(self, other: u64) -> u64

impl<'_, '_> Sub<&'_ f32> for &'_ f32

type Output = <f32 as Sub<f32>>::Output

pub fn sub(self, other: &f32) -> <f32 as Sub<f32>>::Output

impl<'_> Sub<&'_ i8> for i8

type Output = <i8 as Sub<i8>>::Output

pub fn sub(self, other: &i8) -> <i8 as Sub<i8>>::Output

impl Sub<f32> for f32

type Output = f32

pub fn sub(self, other: f32) -> f32

impl<'a> Sub<i16> for &'a i16

type Output = <i16 as Sub<i16>>::Output

pub fn sub(self, other: i16) -> <i16 as Sub<i16>>::Output

impl<'_> Sub<&'_ i16> for i16

type Output = <i16 as Sub<i16>>::Output

pub fn sub(self, other: &i16) -> <i16 as Sub<i16>>::Output

impl<'_> Sub<&'_ f32> for f32

type Output = <f32 as Sub<f32>>::Output

pub fn sub(self, other: &f32) -> <f32 as Sub<f32>>::Output

impl<'a> Sub<u8> for &'a u8

type Output = <u8 as Sub<u8>>::Output

pub fn sub(self, other: u8) -> <u8 as Sub<u8>>::Output

impl<'_> Sub<&'_ u32> for u32

type Output = <u32 as Sub<u32>>::Output

pub fn sub(self, other: &u32) -> <u32 as Sub<u32>>::Output

impl<'_, '_> Sub<&'_ u8> for &'_ u8

type Output = <u8 as Sub<u8>>::Output

pub fn sub(self, other: &u8) -> <u8 as Sub<u8>>::Output

impl<'a> Sub<f64> for &'a f64

type Output = <f64 as Sub<f64>>::Output

pub fn sub(self, other: f64) -> <f64 as Sub<f64>>::Output

impl<S, D> Sub<ArrayBase<S, D>> for u64 where
    D: Dimension,
    S: DataOwned<Elem = u64> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for u64 where
    D: Dimension,
    S: Data<Elem = u64>, 

type Output = ArrayBase<OwnedRepr<u64>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <u64 as Sub<&'a ArrayBase<S, D>>>::Output

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for f32 where
    D: Dimension,
    S: Data<Elem = f32>, 

type Output = ArrayBase<OwnedRepr<f32>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <f32 as Sub<&'a ArrayBase<S, D>>>::Output

impl<S, D> Sub<ArrayBase<S, D>> for u32 where
    D: Dimension,
    S: DataOwned<Elem = u32> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Sub<ArrayBase<S, D>> for i128 where
    D: Dimension,
    S: DataOwned<Elem = i128> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Sub<ArrayBase<S, D>> for i8 where
    D: Dimension,
    S: DataOwned<Elem = i8> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for i8 where
    D: Dimension,
    S: Data<Elem = i8>, 

type Output = ArrayBase<OwnedRepr<i8>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <i8 as Sub<&'a ArrayBase<S, D>>>::Output

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for u8 where
    D: Dimension,
    S: Data<Elem = u8>, 

type Output = ArrayBase<OwnedRepr<u8>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <u8 as Sub<&'a ArrayBase<S, D>>>::Output

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for u128 where
    D: Dimension,
    S: Data<Elem = u128>, 

type Output = ArrayBase<OwnedRepr<u128>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <u128 as Sub<&'a ArrayBase<S, D>>>::Output

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for u16 where
    D: Dimension,
    S: Data<Elem = u16>, 

type Output = ArrayBase<OwnedRepr<u16>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <u16 as Sub<&'a ArrayBase<S, D>>>::Output

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for Complex<f64> where
    D: Dimension,
    S: Data<Elem = Complex<f64>>, 

type Output = ArrayBase<OwnedRepr<Complex<f64>>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <Complex<f64> as Sub<&'a ArrayBase<S, D>>>::Output

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for i32 where
    D: Dimension,
    S: Data<Elem = i32>, 

type Output = ArrayBase<OwnedRepr<i32>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <i32 as Sub<&'a ArrayBase<S, D>>>::Output

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for u32 where
    D: Dimension,
    S: Data<Elem = u32>, 

type Output = ArrayBase<OwnedRepr<u32>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <u32 as Sub<&'a ArrayBase<S, D>>>::Output

impl<S, D> Sub<ArrayBase<S, D>> for u8 where
    D: Dimension,
    S: DataOwned<Elem = u8> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Sub<ArrayBase<S, D>> for i64 where
    D: Dimension,
    S: DataOwned<Elem = i64> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Sub<ArrayBase<S, D>> for f32 where
    D: Dimension,
    S: DataOwned<Elem = f32> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Sub<ArrayBase<S, D>> for f64 where
    D: Dimension,
    S: DataOwned<Elem = f64> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Sub<ArrayBase<S, D>> for Complex<f64> where
    D: Dimension,
    S: DataOwned<Elem = Complex<f64>> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Sub<ArrayBase<S, D>> for i16 where
    D: Dimension,
    S: DataOwned<Elem = i16> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Sub<ArrayBase<S, D>> for Complex<f32> where
    D: Dimension,
    S: DataOwned<Elem = Complex<f32>> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for f64 where
    D: Dimension,
    S: Data<Elem = f64>, 

type Output = ArrayBase<OwnedRepr<f64>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <f64 as Sub<&'a ArrayBase<S, D>>>::Output

impl<S, D> Sub<ArrayBase<S, D>> for u16 where
    D: Dimension,
    S: DataOwned<Elem = u16> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for Complex<f32> where
    D: Dimension,
    S: Data<Elem = Complex<f32>>, 

type Output = ArrayBase<OwnedRepr<Complex<f32>>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <Complex<f32> as Sub<&'a ArrayBase<S, D>>>::Output

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for i128 where
    D: Dimension,
    S: Data<Elem = i128>, 

type Output = ArrayBase<OwnedRepr<i128>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <i128 as Sub<&'a ArrayBase<S, D>>>::Output

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for i16 where
    D: Dimension,
    S: Data<Elem = i16>, 

type Output = ArrayBase<OwnedRepr<i16>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <i16 as Sub<&'a ArrayBase<S, D>>>::Output

impl<S, D> Sub<ArrayBase<S, D>> for i32 where
    D: Dimension,
    S: DataOwned<Elem = i32> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Sub<&'a ArrayBase<S, D>> for i64 where
    D: Dimension,
    S: Data<Elem = i64>, 

type Output = ArrayBase<OwnedRepr<i64>, D>

pub fn sub(
    self,
    rhs: &ArrayBase<S, D>
) -> <i64 as Sub<&'a ArrayBase<S, D>>>::Output

impl<S, D> Sub<ArrayBase<S, D>> for u128 where
    D: Dimension,
    S: DataOwned<Elem = u128> + DataMut, 

type Output = ArrayBase<S, D>

pub fn sub(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a> Sub<&'a Complex<u16>> for u16

type Output = Complex<u16>

pub fn sub(self, other: &Complex<u16>) -> Complex<u16>

impl<'a> Sub<Complex<u16>> for &'a u16

type Output = Complex<u16>

pub fn sub(self, other: Complex<u16>) -> Complex<u16>

impl<'a, 'b> Sub<&'a Complex<i8>> for &'b i8

type Output = Complex<i8>

pub fn sub(self, other: &Complex<i8>) -> Complex<i8>

impl Sub<Complex<u128>> for u128

type Output = Complex<u128>

pub fn sub(self, other: Complex<u128>) -> <u128 as Sub<Complex<u128>>>::Output

impl<'a> Sub<&'a Complex<i16>> for i16

type Output = Complex<i16>

pub fn sub(self, other: &Complex<i16>) -> Complex<i16>

impl<'a> Sub<Complex<i16>> for &'a i16

type Output = Complex<i16>

pub fn sub(self, other: Complex<i16>) -> Complex<i16>

impl<'a> Sub<&'a Complex<u8>> for u8

type Output = Complex<u8>

pub fn sub(self, other: &Complex<u8>) -> Complex<u8>

impl<'a> Sub<Complex<u32>> for &'a u32

type Output = Complex<u32>

pub fn sub(self, other: Complex<u32>) -> Complex<u32>

impl Sub<Complex<i8>> for i8

type Output = Complex<i8>

pub fn sub(self, other: Complex<i8>) -> <i8 as Sub<Complex<i8>>>::Output

impl<'a> Sub<&'a Complex<i64>> for i64

type Output = Complex<i64>

pub fn sub(self, other: &Complex<i64>) -> Complex<i64>

impl<T> Sub<Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

pub fn sub(self, other: Complex<T>) -> <Complex<T> as Sub<Complex<T>>>::Output

impl<'a> Sub<Complex<i8>> for &'a i8

type Output = Complex<i8>

pub fn sub(self, other: Complex<i8>) -> Complex<i8>

impl<'a> Sub<&'a Complex<usize>> for usize

type Output = Complex<usize>

pub fn sub(self, other: &Complex<usize>) -> Complex<usize>

impl<'a, 'b> Sub<&'a Complex<u32>> for &'b u32

type Output = Complex<u32>

pub fn sub(self, other: &Complex<u32>) -> Complex<u32>

impl<'a> Sub<&'a Complex<u32>> for u32

type Output = Complex<u32>

pub fn sub(self, other: &Complex<u32>) -> Complex<u32>

impl<'a, 'b, T> Sub<&'b Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

pub fn sub(
    self,
    other: &Complex<T>
) -> <&'a Complex<T> as Sub<&'b Complex<T>>>::Output

impl<'a> Sub<&'a Complex<u128>> for u128

type Output = Complex<u128>

pub fn sub(self, other: &Complex<u128>) -> Complex<u128>

impl Sub<Complex<isize>> for isize

type Output = Complex<isize>

pub fn sub(
    self,
    other: Complex<isize>
) -> <isize as Sub<Complex<isize>>>::Output

impl Sub<Complex<i64>> for i64

type Output = Complex<i64>

pub fn sub(self, other: Complex<i64>) -> <i64 as Sub<Complex<i64>>>::Output

impl<'a, 'b> Sub<&'a Complex<f64>> for &'b f64

type Output = Complex<f64>

pub fn sub(self, other: &Complex<f64>) -> Complex<f64>

impl Sub<Complex<i16>> for i16

type Output = Complex<i16>

pub fn sub(self, other: Complex<i16>) -> <i16 as Sub<Complex<i16>>>::Output

impl<'a> Sub<Complex<usize>> for &'a usize

type Output = Complex<usize>

pub fn sub(self, other: Complex<usize>) -> Complex<usize>

impl Sub<Complex<i32>> for i32

type Output = Complex<i32>

pub fn sub(self, other: Complex<i32>) -> <i32 as Sub<Complex<i32>>>::Output

impl Sub<Complex<u8>> for u8

type Output = Complex<u8>

pub fn sub(self, other: Complex<u8>) -> <u8 as Sub<Complex<u8>>>::Output

impl<'a, 'b> Sub<&'a Complex<f32>> for &'b f32

type Output = Complex<f32>

pub fn sub(self, other: &Complex<f32>) -> Complex<f32>

impl<'a, 'b> Sub<&'a Complex<i32>> for &'b i32

type Output = Complex<i32>

pub fn sub(self, other: &Complex<i32>) -> Complex<i32>

impl<'a> Sub<Complex<u8>> for &'a u8

type Output = Complex<u8>

pub fn sub(self, other: Complex<u8>) -> Complex<u8>

impl<'a, T> Sub<&'a T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

pub fn sub(self, other: &T) -> <Complex<T> as Sub<&'a T>>::Output

impl<'a> Sub<Complex<i32>> for &'a i32

type Output = Complex<i32>

pub fn sub(self, other: Complex<i32>) -> Complex<i32>

impl<'a> Sub<&'a Complex<isize>> for isize

type Output = Complex<isize>

pub fn sub(self, other: &Complex<isize>) -> Complex<isize>

impl<'a> Sub<Complex<isize>> for &'a isize

type Output = Complex<isize>

pub fn sub(self, other: Complex<isize>) -> Complex<isize>

impl<'a> Sub<&'a Complex<u64>> for u64

type Output = Complex<u64>

pub fn sub(self, other: &Complex<u64>) -> Complex<u64>

impl<'a, 'b> Sub<&'a Complex<i128>> for &'b i128

type Output = Complex<i128>

pub fn sub(self, other: &Complex<i128>) -> Complex<i128>

impl<'a, 'b> Sub<&'a Complex<u8>> for &'b u8

type Output = Complex<u8>

pub fn sub(self, other: &Complex<u8>) -> Complex<u8>

impl<'a, 'b> Sub<&'a Complex<i16>> for &'b i16

type Output = Complex<i16>

pub fn sub(self, other: &Complex<i16>) -> Complex<i16>

impl<'a, T> Sub<Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

pub fn sub(
    self,
    other: Complex<T>
) -> <&'a Complex<T> as Sub<Complex<T>>>::Output

impl<'a> Sub<&'a Complex<f32>> for f32

type Output = Complex<f32>

pub fn sub(self, other: &Complex<f32>) -> Complex<f32>

impl<'a> Sub<Complex<f32>> for &'a f32

type Output = Complex<f32>

pub fn sub(self, other: Complex<f32>) -> Complex<f32>

impl Sub<Complex<u16>> for u16

type Output = Complex<u16>

pub fn sub(self, other: Complex<u16>) -> <u16 as Sub<Complex<u16>>>::Output

impl<'a, 'b> Sub<&'a Complex<u16>> for &'b u16

type Output = Complex<u16>

pub fn sub(self, other: &Complex<u16>) -> Complex<u16>

impl Sub<Complex<i128>> for i128

type Output = Complex<i128>

pub fn sub(self, other: Complex<i128>) -> <i128 as Sub<Complex<i128>>>::Output

impl<'a> Sub<Complex<i128>> for &'a i128

type Output = Complex<i128>

pub fn sub(self, other: Complex<i128>) -> Complex<i128>

impl Sub<Complex<usize>> for usize

type Output = Complex<usize>

pub fn sub(
    self,
    other: Complex<usize>
) -> <usize as Sub<Complex<usize>>>::Output

impl Sub<Complex<u64>> for u64

type Output = Complex<u64>

pub fn sub(self, other: Complex<u64>) -> <u64 as Sub<Complex<u64>>>::Output

impl<'a, 'b> Sub<&'a Complex<u128>> for &'b u128

type Output = Complex<u128>

pub fn sub(self, other: &Complex<u128>) -> Complex<u128>

impl<'a, T> Sub<T> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

pub fn sub(self, other: T) -> <&'a Complex<T> as Sub<T>>::Output

impl Sub<Complex<f32>> for f32

type Output = Complex<f32>

pub fn sub(self, other: Complex<f32>) -> <f32 as Sub<Complex<f32>>>::Output

impl<'a, 'b> Sub<&'a Complex<i64>> for &'b i64

type Output = Complex<i64>

pub fn sub(self, other: &Complex<i64>) -> Complex<i64>

impl<'a> Sub<Complex<i64>> for &'a i64

type Output = Complex<i64>

pub fn sub(self, other: Complex<i64>) -> Complex<i64>

impl<'a> Sub<Complex<u128>> for &'a u128

type Output = Complex<u128>

pub fn sub(self, other: Complex<u128>) -> Complex<u128>

impl<'a> Sub<Complex<f64>> for &'a f64

type Output = Complex<f64>

pub fn sub(self, other: Complex<f64>) -> Complex<f64>

impl Sub<Complex<f64>> for f64

type Output = Complex<f64>

pub fn sub(self, other: Complex<f64>) -> <f64 as Sub<Complex<f64>>>::Output

impl<'a, 'b> Sub<&'a Complex<isize>> for &'b isize

type Output = Complex<isize>

pub fn sub(self, other: &Complex<isize>) -> Complex<isize>

impl<'a, T> Sub<&'a Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

pub fn sub(
    self,
    other: &Complex<T>
) -> <Complex<T> as Sub<&'a Complex<T>>>::Output

impl<'a> Sub<&'a Complex<i8>> for i8

type Output = Complex<i8>

pub fn sub(self, other: &Complex<i8>) -> Complex<i8>

impl<'a, 'b> Sub<&'a Complex<u64>> for &'b u64

type Output = Complex<u64>

pub fn sub(self, other: &Complex<u64>) -> Complex<u64>

impl Sub<Complex<u32>> for u32

type Output = Complex<u32>

pub fn sub(self, other: Complex<u32>) -> <u32 as Sub<Complex<u32>>>::Output

impl<'a> Sub<&'a Complex<i32>> for i32

type Output = Complex<i32>

pub fn sub(self, other: &Complex<i32>) -> Complex<i32>

impl<'a> Sub<Complex<u64>> for &'a u64

type Output = Complex<u64>

pub fn sub(self, other: Complex<u64>) -> Complex<u64>

impl<T> Sub<T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

pub fn sub(self, other: T) -> <Complex<T> as Sub<T>>::Output

impl<'a> Sub<&'a Complex<i128>> for i128

type Output = Complex<i128>

pub fn sub(self, other: &Complex<i128>) -> Complex<i128>

impl<'a> Sub<&'a Complex<f64>> for f64

type Output = Complex<f64>

pub fn sub(self, other: &Complex<f64>) -> Complex<f64>

impl<'a, 'b> Sub<&'a Complex<usize>> for &'b usize

type Output = Complex<usize>

pub fn sub(self, other: &Complex<usize>) -> Complex<usize>

impl<'a, 'b, T> Sub<&'a T> for &'b Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

pub fn sub(self, other: &T) -> <&'b Complex<T> as Sub<&'a T>>::Output

Loading content...

Implementors

impl Sub<usize> for Dim<[usize; 1]>

type Output = Dim<[usize; 1]>

pub fn sub(self, rhs: usize) -> Dim<[usize; 1]>

impl Sub<f16> for f16

type Output = f16

pub fn sub(self, other: f16) -> f16

impl Sub<Wrapping<i8>> for Wrapping<i8>

type Output = Wrapping<i8>

pub fn sub(self, other: Wrapping<i8>) -> Wrapping<i8>

impl Sub<Wrapping<i16>> for Wrapping<i16>

type Output = Wrapping<i16>

pub fn sub(self, other: Wrapping<i16>) -> Wrapping<i16>

impl Sub<Wrapping<i32>> for Wrapping<i32>

type Output = Wrapping<i32>

pub fn sub(self, other: Wrapping<i32>) -> Wrapping<i32>

impl Sub<Wrapping<i64>> for Wrapping<i64>

type Output = Wrapping<i64>

pub fn sub(self, other: Wrapping<i64>) -> Wrapping<i64>

impl Sub<Wrapping<i128>> for Wrapping<i128>

type Output = Wrapping<i128>

pub fn sub(self, other: Wrapping<i128>) -> Wrapping<i128>

impl Sub<Wrapping<isize>> for Wrapping<isize>

type Output = Wrapping<isize>

pub fn sub(self, other: Wrapping<isize>) -> Wrapping<isize>

impl Sub<Wrapping<u8>> for Wrapping<u8>

type Output = Wrapping<u8>

pub fn sub(self, other: Wrapping<u8>) -> Wrapping<u8>

impl Sub<Wrapping<u16>> for Wrapping<u16>

type Output = Wrapping<u16>

pub fn sub(self, other: Wrapping<u16>) -> Wrapping<u16>

impl Sub<Wrapping<u32>> for Wrapping<u32>

type Output = Wrapping<u32>

pub fn sub(self, other: Wrapping<u32>) -> Wrapping<u32>

impl Sub<Wrapping<u64>> for Wrapping<u64>

type Output = Wrapping<u64>

pub fn sub(self, other: Wrapping<u64>) -> Wrapping<u64>

impl Sub<Wrapping<u128>> for Wrapping<u128>

type Output = Wrapping<u128>

pub fn sub(self, other: Wrapping<u128>) -> Wrapping<u128>

impl Sub<Wrapping<usize>> for Wrapping<usize>

type Output = Wrapping<usize>

pub fn sub(self, other: Wrapping<usize>) -> Wrapping<usize>

impl Sub<Duration> for Duration

type Output = Duration

pub fn sub(self, rhs: Duration) -> Duration

impl Sub<Duration> for Instant

type Output = Instant

pub fn sub(self, other: Duration) -> Instant

impl Sub<Duration> for SystemTime

type Output = SystemTime

pub fn sub(self, dur: Duration) -> SystemTime

impl Sub<Instant> for Instant

type Output = Duration

pub fn sub(self, other: Instant) -> Duration

impl<'_> Sub<&'_ f16> for f16

type Output = f16

pub fn sub(self, other: &f16) -> f16

impl<'_> Sub<&'_ Wrapping<i8>> for Wrapping<i8>

type Output = <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

pub fn sub(
    self,
    other: &Wrapping<i8>
) -> <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

impl<'_> Sub<&'_ Wrapping<i16>> for Wrapping<i16>

type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

pub fn sub(
    self,
    other: &Wrapping<i16>
) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

impl<'_> Sub<&'_ Wrapping<i32>> for Wrapping<i32>

type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

pub fn sub(
    self,
    other: &Wrapping<i32>
) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

impl<'_> Sub<&'_ Wrapping<i64>> for Wrapping<i64>

type Output = <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

pub fn sub(
    self,
    other: &Wrapping<i64>
) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

impl<'_> Sub<&'_ Wrapping<i128>> for Wrapping<i128>

type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

pub fn sub(
    self,
    other: &Wrapping<i128>
) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

impl<'_> Sub<&'_ Wrapping<isize>> for Wrapping<isize>

type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

pub fn sub(
    self,
    other: &Wrapping<isize>
) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

impl<'_> Sub<&'_ Wrapping<u8>> for Wrapping<u8>

type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

pub fn sub(
    self,
    other: &Wrapping<u8>
) -> <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

impl<'_> Sub<&'_ Wrapping<u16>> for Wrapping<u16>

type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

pub fn sub(
    self,
    other: &Wrapping<u16>
) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

impl<'_> Sub<&'_ Wrapping<u32>> for Wrapping<u32>

type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

pub fn sub(
    self,
    other: &Wrapping<u32>
) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

impl<'_> Sub<&'_ Wrapping<u64>> for Wrapping<u64>

type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

pub fn sub(
    self,
    other: &Wrapping<u64>
) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

impl<'_> Sub<&'_ Wrapping<u128>> for Wrapping<u128>

type Output = <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

pub fn sub(
    self,
    other: &Wrapping<u128>
) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

impl<'_> Sub<&'_ Wrapping<usize>> for Wrapping<usize>

type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

pub fn sub(
    self,
    other: &Wrapping<usize>
) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<i8>> for &'_ Wrapping<i8>

type Output = <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

pub fn sub(
    self,
    other: &Wrapping<i8>
) -> <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<i16>> for &'_ Wrapping<i16>

type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

pub fn sub(
    self,
    other: &Wrapping<i16>
) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<i32>> for &'_ Wrapping<i32>

type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

pub fn sub(
    self,
    other: &Wrapping<i32>
) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<i64>> for &'_ Wrapping<i64>

type Output = <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

pub fn sub(
    self,
    other: &Wrapping<i64>
) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<i128>> for &'_ Wrapping<i128>

type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

pub fn sub(
    self,
    other: &Wrapping<i128>
) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<isize>> for &'_ Wrapping<isize>

type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

pub fn sub(
    self,
    other: &Wrapping<isize>
) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<u8>> for &'_ Wrapping<u8>

type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

pub fn sub(
    self,
    other: &Wrapping<u8>
) -> <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<u16>> for &'_ Wrapping<u16>

type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

pub fn sub(
    self,
    other: &Wrapping<u16>
) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<u32>> for &'_ Wrapping<u32>

type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

pub fn sub(
    self,
    other: &Wrapping<u32>
) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<u64>> for &'_ Wrapping<u64>

type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

pub fn sub(
    self,
    other: &Wrapping<u64>
) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<u128>> for &'_ Wrapping<u128>

type Output = <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

pub fn sub(
    self,
    other: &Wrapping<u128>
) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

impl<'_, '_> Sub<&'_ Wrapping<usize>> for &'_ Wrapping<usize>

type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

pub fn sub(
    self,
    other: &Wrapping<usize>
) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

impl<'_, '_, T> Sub<&'_ BTreeSet<T>> for &'_ BTreeSet<T> where
    T: Ord + Clone, 

type Output = BTreeSet<T>

pub fn sub(self, rhs: &BTreeSet<T>) -> BTreeSet<T>

Returns the difference of self and rhs as a new BTreeSet<T>.

Examples

use std::collections::BTreeSet;

let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect();

let result = &a - &b;
let result_vec: Vec<_> = result.into_iter().collect();
assert_eq!(result_vec, [1, 2]);

impl<'_, '_, T, S> Sub<&'_ HashSet<T, S>> for &'_ HashSet<T, S> where
    T: Eq + Hash + Clone,
    S: BuildHasher + Default, 

type Output = HashSet<T, S>

pub fn sub(self, rhs: &HashSet<T, S>) -> HashSet<T, S>

Returns the difference of self and rhs as a new HashSet<T, S>.

Examples

use std::collections::HashSet;

let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();

let set = &a - &b;

let mut i = 0;
let expected = [1, 2];
for x in &set {
    assert!(expected.contains(x));
    i += 1;
}
assert_eq!(i, expected.len());

impl<'a> Sub<&'a TDim> for TDim

type Output = TDim

pub fn sub(self, rhs: &'a TDim) -> TDim

impl<'a> Sub<Wrapping<i8>> for &'a Wrapping<i8>

type Output = <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

pub fn sub(
    self,
    other: Wrapping<i8>
) -> <Wrapping<i8> as Sub<Wrapping<i8>>>::Output

impl<'a> Sub<Wrapping<i16>> for &'a Wrapping<i16>

type Output = <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

pub fn sub(
    self,
    other: Wrapping<i16>
) -> <Wrapping<i16> as Sub<Wrapping<i16>>>::Output

impl<'a> Sub<Wrapping<i32>> for &'a Wrapping<i32>

type Output = <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

pub fn sub(
    self,
    other: Wrapping<i32>
) -> <Wrapping<i32> as Sub<Wrapping<i32>>>::Output

impl<'a> Sub<Wrapping<i64>> for &'a Wrapping<i64>

type Output = <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

pub fn sub(
    self,
    other: Wrapping<i64>
) -> <Wrapping<i64> as Sub<Wrapping<i64>>>::Output

impl<'a> Sub<Wrapping<i128>> for &'a Wrapping<i128>

type Output = <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

pub fn sub(
    self,
    other: Wrapping<i128>
) -> <Wrapping<i128> as Sub<Wrapping<i128>>>::Output

impl<'a> Sub<Wrapping<isize>> for &'a Wrapping<isize>

type Output = <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

pub fn sub(
    self,
    other: Wrapping<isize>
) -> <Wrapping<isize> as Sub<Wrapping<isize>>>::Output

impl<'a> Sub<Wrapping<u8>> for &'a Wrapping<u8>

type Output = <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

pub fn sub(
    self,
    other: Wrapping<u8>
) -> <Wrapping<u8> as Sub<Wrapping<u8>>>::Output

impl<'a> Sub<Wrapping<u16>> for &'a Wrapping<u16>

type Output = <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

pub fn sub(
    self,
    other: Wrapping<u16>
) -> <Wrapping<u16> as Sub<Wrapping<u16>>>::Output

impl<'a> Sub<Wrapping<u32>> for &'a Wrapping<u32>

type Output = <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

pub fn sub(
    self,
    other: Wrapping<u32>
) -> <Wrapping<u32> as Sub<Wrapping<u32>>>::Output

impl<'a> Sub<Wrapping<u64>> for &'a Wrapping<u64>

type Output = <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

pub fn sub(
    self,
    other: Wrapping<u64>
) -> <Wrapping<u64> as Sub<Wrapping<u64>>>::Output

impl<'a> Sub<Wrapping<u128>> for &'a Wrapping<u128>

type Output = <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

pub fn sub(
    self,
    other: Wrapping<u128>
) -> <Wrapping<u128> as Sub<Wrapping<u128>>>::Output

impl<'a> Sub<Wrapping<usize>> for &'a Wrapping<usize>

type Output = <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

pub fn sub(
    self,
    other: Wrapping<usize>
) -> <Wrapping<usize> as Sub<Wrapping<usize>>>::Output

impl<'a, A, B, S, S2, D, E> Sub<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where
    E: Dimension,
    D: Dimension + DimMax<E>,
    A: Clone + Sub<B, Output = A>,
    B: Clone,
    S: Data<Elem = A>,
    S2: Data<Elem = B>, 

Perform elementwise subtraction between references self and rhs, and return the result as a new Array.

If their shapes disagree, self and rhs is broadcast to their broadcast shape, cloning the data if needed.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<OwnedRepr<A>, <D as DimMax<E>>::Output>

pub fn sub(
    self,
    rhs: &'a ArrayBase<S2, E>
) -> <&'a ArrayBase<S, D> as Sub<&'a ArrayBase<S2, E>>>::Output

impl<'a, A, B, S, S2, D, E> Sub<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where
    E: Dimension,
    D: Dimension + DimMax<E>,
    A: Clone + Sub<B, Output = A>,
    B: Clone,
    S: DataOwned<Elem = A> + DataMut,
    S2: Data<Elem = B>, 

Perform elementwise subtraction between self and reference rhs, and return the result.

rhs must be an Array or ArcArray.

If their shapes disagree, self is broadcast to their broadcast shape, cloning the data if needed.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, <D as DimMax<E>>::Output>

pub fn sub(
    self,
    rhs: &ArrayBase<S2, E>
) -> <ArrayBase<S, D> as Sub<&'a ArrayBase<S2, E>>>::Output

impl<'a, A, B, S, S2, D, E> Sub<ArrayBase<S2, E>> for &'a ArrayBase<S, D> where
    E: Dimension + DimMax<D>,
    D: Dimension,
    A: Clone + Sub<B, Output = B>,
    B: Clone,
    S: Data<Elem = A>,
    S2: DataOwned<Elem = B> + DataMut, 

Perform elementwise subtraction between reference self and rhs, and return the result.

rhs must be an Array or ArcArray.

If their shapes disagree, self is broadcast to their broadcast shape, cloning the data if needed.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S2, <E as DimMax<D>>::Output>

pub fn sub(
    self,
    rhs: ArrayBase<S2, E>
) -> <&'a ArrayBase<S, D> as Sub<ArrayBase<S2, E>>>::Output

impl<'a, A, S, D, B> Sub<B> for &'a ArrayBase<S, D> where
    D: Dimension,
    A: Clone + Sub<B, Output = A>,
    B: ScalarOperand,
    S: Data<Elem = A>, 

Perform elementwise subtraction between the reference self and the scalar x, and return the result as a new Array.

type Output = ArrayBase<OwnedRepr<A>, D>

pub fn sub(self, x: B) -> <&'a ArrayBase<S, D> as Sub<B>>::Output

impl<A, B, S, S2, D, E> Sub<ArrayBase<S2, E>> for ArrayBase<S, D> where
    E: Dimension,
    D: Dimension + DimMax<E>,
    A: Clone + Sub<B, Output = A>,
    B: Clone,
    S: DataOwned<Elem = A> + DataMut,
    S2: Data<Elem = B>, 

Perform elementwise subtraction between self and rhs, and return the result.

self must be an Array or ArcArray.

If their shapes disagree, self is broadcast to their broadcast shape.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, <D as DimMax<E>>::Output>

pub fn sub(
    self,
    rhs: ArrayBase<S2, E>
) -> <ArrayBase<S, D> as Sub<ArrayBase<S2, E>>>::Output

impl<A, S, D, B> Sub<B> for ArrayBase<S, D> where
    D: Dimension,
    A: Clone + Sub<B, Output = A>,
    B: ScalarOperand,
    S: DataOwned<Elem = A> + DataMut, 

Perform elementwise subtraction between self and the scalar x, and return the result (based on self).

self must be an Array or ArcArray.

type Output = ArrayBase<S, D>

pub fn sub(self, x: B) -> ArrayBase<S, D>

impl<I> Sub<Dim<I>> for Dim<I> where
    Dim<I>: Dimension, 

type Output = Dim<I>

pub fn sub(self, rhs: Dim<I>) -> Dim<I>

impl<I> Sub<I> for TDim where
    I: Into<TDim>, 

type Output = TDim

pub fn sub(self, rhs: I) -> TDim

Loading content...