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

#[lang = "sub"]pub trait Sub<Rhs = Self> {
    type Output;
#[must_use]    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 = Point;

    fn sub(self, other: Point) -> Point {
        Point {
            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]fn sub(self, rhs: Rhs) -> Self::Output

Performs the - operation.

Loading content...

Implementations on Foreign Types

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

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

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

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

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

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

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

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

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

impl Sub<u8> for u8

type Output = u8

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

impl Sub<i8> for i8

type Output = i8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Sub<i128> for i128

type Output = i128

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

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

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

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

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

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

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

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

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

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

impl Sub<usize> for usize

type Output = usize

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

impl Sub<i32> for i32

type Output = i32

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

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

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

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

impl Sub<u128> for u128

type Output = u128

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Sub<isize> for isize

type Output = isize

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

impl Sub<f64> for f64

type Output = f64

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

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

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

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

impl Sub<i64> for i64

type Output = i64

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Sub<f32> for f32

type Output = f32

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

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

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

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

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

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

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

impl Sub<u64> for u64

type Output = u64

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

impl Sub<u16> for u16

type Output = u16

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

impl Sub<u32> for u32

type Output = u32

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

impl Sub<i16> for i16

type Output = i16

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

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

type Output = HashSet<T, S>

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 hashbrown::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, S, D> Sub<&'a ArrayBase<S, D>> for u8 where
    D: Dimension,
    S: Data<Elem = u8>, 

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

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u8>, 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>

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i64>, D>

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

type Output = ArrayBase<S, D>

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>

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

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

type Output = ArrayBase<S, D>

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>

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<Complex<f32>>, D>

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

type Output = ArrayBase<S, D>

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>

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

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

type Output = ArrayBase<S, D>

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>

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<f64>, D>

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

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

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<f32>, D>

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

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

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u16>, D>

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

type Output = ArrayBase<S, D>

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

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

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

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i128>, D>

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

type Output = ArrayBase<S, D>

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

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

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

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i16>, D>

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

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

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i32>, D>

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

type Output = ArrayBase<S, D>

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

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

type Output = ArrayBase<S, D>

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

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

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

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u32>, 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>

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i8>, 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>

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u64>, D>

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

type Output = ArrayBase<S, D>

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

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

type Output = ArrayBase<S, D>

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

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>

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<Complex<f64>>, D>

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

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

fn sub(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u128>, D>

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

type Output = ArrayBase<S, D>

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>

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

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

type Output = Complex<i8>

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

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

type Output = Complex<f64>

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

impl Sub<Complex<i8>> for i8

type Output = Complex<i8>

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

impl Sub<Complex<usize>> for usize

type Output = Complex<usize>

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

impl Sub<Complex<u64>> for u64

type Output = Complex<u64>

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

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

type Output = Complex<T>

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

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

type Output = Complex<i32>

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

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

type Output = Complex<f32>

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

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

type Output = Complex<T>

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

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

type Output = Complex<T>

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

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

type Output = Complex<T>

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

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

type Output = Complex<isize>

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

impl Sub<Complex<i32>> for i32

type Output = Complex<i32>

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

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

type Output = Complex<isize>

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

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

type Output = Complex<i64>

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

impl Sub<Complex<u16>> for u16

type Output = Complex<u16>

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

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

type Output = Complex<f64>

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

impl Sub<Complex<f64>> for f64

type Output = Complex<f64>

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

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

type Output = Complex<u32>

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

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

type Output = Complex<i128>

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

impl Sub<Complex<u32>> for u32

type Output = Complex<u32>

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

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

type Output = Complex<i64>

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

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

type Output = Complex<u32>

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

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

type Output = Complex<i128>

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

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

type Output = Complex<i16>

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

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

type Output = Complex<T>

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

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

type Output = Complex<f64>

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

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

type Output = Complex<isize>

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

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

type Output = Complex<u16>

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

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

type Output = Complex<i64>

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

impl Sub<Complex<u128>> for u128

type Output = Complex<u128>

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

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

type Output = Complex<u8>

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

impl Sub<Complex<u8>> for u8

type Output = Complex<u8>

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

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

type Output = Complex<u16>

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

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

type Output = Complex<u64>

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

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

type Output = Complex<u64>

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

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

type Output = Complex<u128>

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

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

type Output = Complex<i8>

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

impl Sub<Complex<f32>> for f32

type Output = Complex<f32>

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

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

type Output = Complex<usize>

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

impl Sub<Complex<i128>> for i128

type Output = Complex<i128>

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

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

type Output = Complex<i128>

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

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

type Output = Complex<usize>

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

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

type Output = Complex<u128>

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

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

type Output = Complex<u128>

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

impl Sub<Complex<i64>> for i64

type Output = Complex<i64>

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

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

type Output = Complex<i8>

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

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

type Output = Complex<T>

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

impl Sub<Complex<i16>> for i16

type Output = Complex<i16>

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

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

type Output = Complex<T>

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

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

type Output = Complex<usize>

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

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

type Output = Complex<u32>

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

impl Sub<Complex<isize>> for isize

type Output = Complex<isize>

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

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

type Output = Complex<f32>

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

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

type Output = Complex<u64>

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

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

type Output = Complex<u8>

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

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

type Output = Complex<i16>

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

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

type Output = Complex<i16>

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

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

type Output = Complex<i32>

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

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

type Output = Complex<i32>

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

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

type Output = Complex<u8>

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

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

type Output = Complex<f32>

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

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

type Output = Complex<u16>

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

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

type Output = Complex<T>

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

Loading content...

Implementors

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

type Output = Dim<[usize; 1]>

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

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

type Output = Wrapping<i8>

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

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

type Output = Wrapping<i16>

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

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

type Output = Wrapping<i32>

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

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

type Output = Wrapping<i64>

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

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

type Output = Wrapping<i128>

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

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

type Output = Wrapping<isize>

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

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

type Output = Wrapping<u8>

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

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

type Output = Wrapping<u16>

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

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

type Output = Wrapping<u32>

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

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

type Output = Wrapping<u64>

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

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

type Output = Wrapping<u128>

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

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

type Output = Wrapping<usize>

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

impl Sub<Duration> for Duration

type Output = Duration

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

impl Sub<Duration> for Instant

type Output = Instant

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

impl Sub<Duration> for SystemTime

type Output = SystemTime

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

impl Sub<Instant> for Instant

type Output = Duration

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

impl Sub<f16> for f16

type Output = f16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Output = f16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Output = BTreeSet<T>

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 &'_ tract_nnef::internal::tract_downcast_rs::__std::collections::HashSet<T, S> where
    S: BuildHasher + Default,
    T: Eq + Hash + Clone, 

type Output = HashSet<T, S>

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

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

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

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

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

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

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

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

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

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

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

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

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

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
    A: Clone + Sub<B, Output = A>,
    B: Clone,
    D: Dimension,
    E: Dimension,
    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, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

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

fn sub(self, rhs: &'a ArrayBase<S2, E>) -> ArrayBase<OwnedRepr<A>, D>

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

Perform elementwise subtraction between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

fn sub(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

impl<'a, A, S, D, B> Sub<B> for &'a ArrayBase<S, D> where
    A: Clone + Sub<B, Output = A>,
    B: ScalarOperand,
    D: Dimension,
    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>

fn sub(self, x: B) -> ArrayBase<OwnedRepr<A>, D>

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

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

self must be an Array or ArcArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

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

impl<A, S, D, B> Sub<B> for ArrayBase<S, D> where
    A: Clone + Sub<B, Output = A>,
    B: ScalarOperand,
    D: Dimension,
    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>

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

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

type Output = Dim<I>

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

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

type Output = TDim

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

Loading content...