Struct Ndarr 

pub struct Ndarr<T: Clone, R: Unsigned> {
    pub data: Vec<T>,
    pub dim: Dim<R>,
}

Main struct of N Dimensional generic array. The shape is denoted by the shape array where the length is the Rank of the Ndarray the actual values are stored in a flattened state in a rank 1 array.

Fields

data: Vec<T>

dim: Dim<R>

Implementations

impl<T: Clone + Debug, R: Unsigned> Ndarr<T, R>

pub fn assign_at<D: Into<Dim<R>>>(&mut self, index: D, value: T)

Modifies an element at an specific position by assign a new value.

pub fn index_slice_notyped(&self, axis: usize, index: usize) -> Ndarr<T, UTerm>

impl<T1: Clone + Debug, R1: Unsigned> Ndarr<T1, R1>

pub fn poly_dyadic<F, T2, T3, R2: Unsigned>( &self, other: &Ndarr<T2, R2>, f: F, ) -> Result<Ndarr<T3, Maximum<R1, R2>>, DimError>

where R1: Max<R2>, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug, T2: Clone + Debug, T3: Clone + Debug, F: Fn(T1, T2) -> T3,

pub fn mat_mul<R2: Unsigned>( &self, other: &Ndarr<T1, R2>, ) -> Ndarr<T1, Sub1<Sub1<Sum<R1, R2>>>>

where R1: Max<R2> + Add<R2>, <R1 as Max<R2>>::Output: Unsigned, <R1 as Add<R2>>::Output: Sub<B1>, <<R1 as Add<R2>>::Output as Sub<B1>>::Output: Sub<B1>, <<<R1 as Add<R2>>::Output as Sub<B1>>::Output as Sub<B1>>::Output: Unsigned, T1: Clone + Debug + Default + Add<Output = T1> + Mul<Output = T1>,

pub fn inner_product<F, G, T2, T3, R2: Unsigned>( &self, other: &Ndarr<T2, R2>, f: F, g: G, ) -> Ndarr<T3, Sub1<Sub1<Sum<R1, R2>>>>

where R1: Max<R2> + Add<R2>, <R1 as Max<R2>>::Output: Unsigned, <R1 as Add<R2>>::Output: Sub<B1>, <<R1 as Add<R2>>::Output as Sub<B1>>::Output: Sub<B1>, <<<R1 as Add<R2>>::Output as Sub<B1>>::Output as Sub<B1>>::Output: Unsigned, T1: Clone + Debug, T2: Clone + Debug, T3: Clone + Debug, F: Fn(T1, T2) -> T3, G: Fn(T3, T3) -> T3,

pub fn outer_product<F, T2, T3, R2: Unsigned>( &self, other: &Ndarr<T2, R2>, f: F, ) -> Ndarr<T3, Sum<R1, R2>>

where R1: Max<R2> + Add<R2>, <R1 as Max<R2>>::Output: Unsigned, <R1 as Add<R2>>::Output: Unsigned, T1: Clone + Debug, T2: Clone + Debug, T3: Clone + Debug, F: Fn(T1, T2) -> T3,

Examples found in repository

examples/conway_gol.rs (line 15)

fn update(mat: &mut Ndarr<i8, U2>) {
    let rolls = Ndarr::from([1, 0, -1]);
    let out = rolls
        .map(|r| mat.roll(*r, 0))
        .outer_product(&rolls, |a, r| a.roll(r, 1))
        .sum();
    mat.bimap_in_place(&out, |prev, new| {
        if new == 3 || (prev == 1 && (new == 4)) {
            1
        } else {
            0
        }
    })
}

impl<T, R: Unsigned> Ndarr<T, R>

where T: Clone + Debug + Signed + PartialOrd,

pub fn abs(&self) -> Self

pub fn is_positive(&self) -> Ndarr<bool, R>

pub fn is_negative(&self) -> Ndarr<bool, R>

impl<T, R: Unsigned> Ndarr<T, R>

where T: Clone + Debug,

pub fn sum(&self) -> T

where T: Add<Output = T>,

Examples found in repository

examples/conway_gol.rs (line 16)

fn update(mat: &mut Ndarr<i8, U2>) {
    let rolls = Ndarr::from([1, 0, -1]);
    let out = rolls
        .map(|r| mat.roll(*r, 0))
        .outer_product(&rolls, |a, r| a.roll(r, 1))
        .sum();
    mat.bimap_in_place(&out, |prev, new| {
        if new == 3 || (prev == 1 && (new == 4)) {
            1
        } else {
            0
        }
    })
}

pub fn max(&self) -> Option<&T>

where T: Ord,

impl<T, R: Unsigned> Ndarr<T, R>

where T: Clone + Copy + Debug + Default + Float,

pub fn sin(&self) -> Self

pub fn cos(&self) -> Self

pub fn tan(&self) -> Self

pub fn sinh(&self) -> Self

pub fn cosh(&self) -> Self

pub fn tanh(&self) -> Self

pub fn exp(&self) -> Self

Examples found in repository

examples/ising_model.rs (line 18)

fn metropolis(spin_arr: &mut Ndarr<f32, U2>) {
    let energy: Ndarr<f32, U2> = 2.
        * spin_arr.clone()
        * (spin_arr.roll(1, 0) + spin_arr.roll(-1, 0) + spin_arr.roll(1, 1) + spin_arr.roll(-1, 1));
    let temp_exp = (-&energy / T).exp();
    let indexes: Vec<usize> = (0..N).collect();
    let i_s = NdarrRand::choose(&indexes, [M], None); //random i indexes
    let j_s = NdarrRand::choose(&indexes, [M], None); //random j indexes
    let p_swich: f32 = NdarrRand::uniform(0.0, 1.0, [1], None)[0]; // selection probability of random spin switch
    for (i, j) in i_s.data.iter().zip(j_s.data.iter()) {
        if energy[[*i, *j]] < 0.0 || p_swich < temp_exp[[*i, *j]] {
            spin_arr[[*i, *j]] *= &-1.0;
        }
    }
}

pub fn log(&self, base: T) -> Self

pub fn ln(&self) -> Self

pub fn log2(&self) -> Self

pub fn is_infinite(&self) -> Ndarr<bool, R>

pub fn is_finite(&self) -> Ndarr<bool, R>

pub fn is_normal(&self) -> Ndarr<bool, R>

pub fn is_nan(&self) -> Ndarr<bool, R>

pub fn maxf(&self) -> T

Max Float, floating types do not implement Ord, but this gives a way to get the maximum value in an Ndarr if all comparisons are allowed.

pub fn minf(&self) -> T

Min Float, floating types do not implement Ord, but this gives a way to get the minimum value in an Ndarr if all comparisons are allowed.

impl<T1: Clone, R: Unsigned> Ndarr<T1, R>

pub fn map_in_place<F1: Fn(&T1) -> T1>(&mut self, f: F1)

pub fn map<T2: Clone + Debug, F2: Fn(&T1) -> T2>(&self, f: F2) -> Ndarr<T2, R>

Examples found in repository

examples/conway_gol.rs (line 14)

fn update(mat: &mut Ndarr<i8, U2>) {
    let rolls = Ndarr::from([1, 0, -1]);
    let out = rolls
        .map(|r| mat.roll(*r, 0))
        .outer_product(&rolls, |a, r| a.roll(r, 1))
        .sum();
    mat.bimap_in_place(&out, |prev, new| {
        if new == 3 || (prev == 1 && (new == 4)) {
            1
        } else {
            0
        }
    })
}

fn main() {
    //initialize game matrix with random 0 or 1
    let mut x = NdarrRand::choose(&[0, 1], [N, N], None);
    let mut stdout = stdout();
    stdout.flush().unwrap();
    stdout.write_all(b"\x1B[2J\x1B[1;1H").unwrap();

    for i in 0..STEPS {
        update(&mut x); //call update function
        let vis = x.map(|x| {
            if *x == 0 {
                "░".to_string()
            } else {
                "█".to_string()
            }
        }); //make it pretty
        println!("{}", vis);
        println!(
            "\n Conway's Game of Life using rapl: [Step {} out of {}] \n",
            i + 1,
            STEPS
        );
        sleep(Duration::from_millis(50));
        stdout.write_all(b"\x1B[1;1H").unwrap();
        stdout.flush().unwrap();
    }
    stdout.write_all(b"\x1B[2J\x1B[1;1H").unwrap();
}

examples/ising_model.rs (lines 37-43)

fn main() {
    let mut stdout = stdout();
    let mut spin_arr = NdarrRand::choose(&[-1.0, 1.0], [N, N], None);
    stdout.flush().unwrap();
    stdout.write_all(b"\x1B[2J\x1B[1;1H").unwrap();
    for i in 0..STEPS {
        metropolis(&mut spin_arr); //updates array with metropolis algorithm
        let vis = spin_arr.map(|x| {
            if *x < 0.0 {
                "░".to_string()
            } else {
                "█".to_string()
            }
        }); //make it pretty

        println!("{}", vis);

        println!(
            "\n The Ising Model using rapl: [Step {} out of {}] \n \n for more info: https://en.wikipedia.org/wiki/Ising_model"
        , i + 1, STEPS);
        sleep(Duration::from_millis(5));
        stdout.write_all(b"\x1B[1;1H").unwrap();
        stdout.flush().unwrap();
    }
    stdout.write_all(b"\x1B[2J\x1B[1;1H").unwrap();
    stdout.flush().unwrap();
}

pub fn bimap<F: Fn(T1, T1) -> T1>(&self, other: &Self, f: F) -> Self

where T1: Default,

pub fn bimap_in_place<F: Fn(T1, T1) -> T1>(&mut self, other: &Self, f: F)

Examples found in repository

examples/conway_gol.rs (lines 17-23)

fn update(mat: &mut Ndarr<i8, U2>) {
    let rolls = Ndarr::from([1, 0, -1]);
    let out = rolls
        .map(|r| mat.roll(*r, 0))
        .outer_product(&rolls, |a, r| a.roll(r, 1))
        .sum();
    mat.bimap_in_place(&out, |prev, new| {
        if new == 3 || (prev == 1 && (new == 4)) {
            1
        } else {
            0
        }
    })
}

pub fn scanr<F: Fn(T1, T1) -> T1>(&self, axis: usize, f: F) -> Self

where T1: Default, R: Sub<B1>, <R as Sub<B1>>::Output: Unsigned + Add<B1>, <<R as Sub<B1>>::Output as Add<B1>>::Output: Unsigned,

pub fn scanl<F: Fn(T1, T1) -> T1>(&self, axis: usize, f: F) -> Self

where T1: Default, R: Sub<B1>, <R as Sub<B1>>::Output: Unsigned + Add<B1>, <<R as Sub<B1>>::Output as Add<B1>>::Output: Unsigned,

impl<T: Float + Default + Clone + Debug, R: Unsigned> Ndarr<T, R>

pub fn threshold(&self, threshold: &T, value: &T) -> Self

pub fn hard_tanh(&self, min_val: &T, max_val: &T) -> Self

pub fn elu(&self, alpha: &T) -> Self

pub fn hard_shrink(&self, lambda: &T) -> Self

pub fn hard_sigmoid(&self) -> Self

pub fn hard_swish(&self) -> Self

pub fn log_sigmoid(&self) -> Self

pub fn relu_6(&self) -> Self

pub fn selu(&self) -> Self

pub fn celu(&self, alpha: &T) -> Self

pub fn silu(&self) -> Self

pub fn softplus(&self, beta: &T) -> Self

pub fn mish(&self) -> Self

pub fn softshrink(&self, lambda: &T) -> Self

pub fn softsign(&self) -> Self

pub fn tanhshrink(&self) -> Self

pub fn sigmoid(&self) -> Self

pub fn relu(&self) -> Self

pub fn leaky_relu(&self, a: T) -> Self

pub fn softmax(&self) -> Self

impl<T, R: Unsigned> Ndarr<T, R>

where T: Clone + Debug + Default,

pub fn zeros<D: Into<Dim<R>>>(shape: D) -> Self

where T: Zero,

Examples found in repository

examples/image_fft.rs (line 12)

fn main() {
    //open image as lumaf32 (gray scale) where 0.0 is white 1.0 is black.
    let img = open_lumaf32("graphics/peppers.png").unwrap();
    //transform to complex and take the 2D FFT
    let fft = img.to_complex().fft2d();

    //initialize kernel for convolution
    let mut kernel: Ndarr<f32, _> = Ndarr::zeros(&fft.dim);
    let (m, n) = (img.shape()[0], img.shape()[1]);
    let mid_x = m / 2;
    let mid_y = n / 2;
    kernel[[mid_x, mid_y]] = 4.;
    kernel[[mid_x + 1, mid_y]] = -1.;
    kernel[[mid_x - 1, mid_y]] = -1.;
    kernel[[mid_x, mid_y + 1]] = -1.;
    kernel[[mid_x, mid_y - 1]] = -1.;
    //FFT the kernell
    let kernell = kernel.to_complex().fft2d();
    //multiply the image FFT to the kernel fft to then do the inverse transform to ger the convolution of the
    //image and the kernel
    let out = (fft * kernell).ifft2().fftshif().re();
    //save output image
    out.save_as_luma("graphics/pepper_edges.png", ImageFormat::Png)
}

pub fn ones<D: Into<Dim<R>>>(shape: D) -> Self

where T: One,

pub fn fill<D: Into<Dim<R>>>(with: T, shape: D) -> Self

impl<T: Debug + Clone + Add<Output = T> + Div<Output = T> + Sub<Output = T>> Ndarr<T, U1>

pub fn linspace(start: T, end: T, n: u16) -> Self

where u16: TryInto<T>, <u16 as TryInto<T>>::Error: Debug,

Return evenly spaced numbers over a specified interval.

pub fn logspace(start: T, end: T, base: T, n: u16) -> Self

where u16: TryInto<T>, <u16 as TryInto<T>>::Error: Debug, T: Pow<T, Output = T> + Mul<Output = T> + Copy,

Return an Ndarr numbers spaced evenly on a log scale.

pub fn geomspace(start: T, end: T, n: u16) -> Self

where u16: TryInto<T>, <u16 as TryInto<T>>::Error: Debug, T: Pow<T, Output = T> + Mul<Output = T> + Copy,

Generates a sequence of values that form a geometric progression.

impl Ndarr<u8, U3>

pub fn save_as_rgb<P: AsRef<Path>>(&self, path: P, fmt: ImageFormat)

Saves a Ndarr<u8,3> with shape (with, heighth, 3) as RGB Image. Takes path and format, where format is enum: ImageFormat.

impl Ndarr<f32, U3>

pub fn save_as_rgb<P: AsRef<Path>>(&self, path: P, fmt: ImageFormat)

Saves a Ndarr<f32,3> with shape (with, heighth, 3) as RGB Image. Takes path and format, where format is enum: ImageFormat.

impl Ndarr<u8, U2>

pub fn save_as_luma<P: AsRef<Path>>(&self, path: P, fmt: ImageFormat)

Saves a Ndarr<u8,2> with shape (with, heighth) as Luma (Black and white) Image. Takes path and format, where format is enum: ImageFormat.

impl Ndarr<f32, U2>

pub fn save_as_luma<P: AsRef<Path>>(&self, path: P, fmt: ImageFormat)

Normalize a Ndarr<f32,2> to values form 0.0 to 1.0 and saves it as Luma (Black and white) Image. Takes path and format, where format is enum: ImageFormat.

Examples found in repository

examples/image_fft.rs (line 27)

fn main() {
    //open image as lumaf32 (gray scale) where 0.0 is white 1.0 is black.
    let img = open_lumaf32("graphics/peppers.png").unwrap();
    //transform to complex and take the 2D FFT
    let fft = img.to_complex().fft2d();

    //initialize kernel for convolution
    let mut kernel: Ndarr<f32, _> = Ndarr::zeros(&fft.dim);
    let (m, n) = (img.shape()[0], img.shape()[1]);
    let mid_x = m / 2;
    let mid_y = n / 2;
    kernel[[mid_x, mid_y]] = 4.;
    kernel[[mid_x + 1, mid_y]] = -1.;
    kernel[[mid_x - 1, mid_y]] = -1.;
    kernel[[mid_x, mid_y + 1]] = -1.;
    kernel[[mid_x, mid_y - 1]] = -1.;
    //FFT the kernell
    let kernell = kernel.to_complex().fft2d();
    //multiply the image FFT to the kernel fft to then do the inverse transform to ger the convolution of the
    //image and the kernel
    let out = (fft * kernell).ifft2().fftshif().re();
    //save output image
    out.save_as_luma("graphics/pepper_edges.png", ImageFormat::Png)
}

impl<T: Clone + Debug + Copy + PartialEq> Ndarr<C<T>, U1>

pub fn fft(&self) -> Ndarr<C<T>, U1>

where T: Signed + FromPrimitive + Num + Copy + PartialEq + Send + Sync + 'static,

Performs the one dimensional Fourier Transform to a rank one rapl array: Ndarr<C<T>,U1>.

pub fn ifft(&self) -> Ndarr<C<T>, U1>

where T: Signed + FromPrimitive + Num + Copy + PartialEq + Send + Sync + 'static,

Performs the one dimensional Inverse Fourier Transform to a rank one rapl array: a = Ndarr<C<T>,U1>. then a.fft().ifft() is approximately equal to a

impl<T: Clone + Debug + Copy + PartialEq> Ndarr<C<T>, U2>

pub fn fft2d(&self) -> Ndarr<C<T>, U2>

where T: Signed + FromPrimitive + Num + Copy + PartialEq + Send + Sync + 'static,

Performs the two dimensional Fourier Transform to a rank two rapl array: Ndarr<C<T>,U2>.

Examples found in repository

examples/image_fft.rs (line 9)

fn main() {
    //open image as lumaf32 (gray scale) where 0.0 is white 1.0 is black.
    let img = open_lumaf32("graphics/peppers.png").unwrap();
    //transform to complex and take the 2D FFT
    let fft = img.to_complex().fft2d();

    //initialize kernel for convolution
    let mut kernel: Ndarr<f32, _> = Ndarr::zeros(&fft.dim);
    let (m, n) = (img.shape()[0], img.shape()[1]);
    let mid_x = m / 2;
    let mid_y = n / 2;
    kernel[[mid_x, mid_y]] = 4.;
    kernel[[mid_x + 1, mid_y]] = -1.;
    kernel[[mid_x - 1, mid_y]] = -1.;
    kernel[[mid_x, mid_y + 1]] = -1.;
    kernel[[mid_x, mid_y - 1]] = -1.;
    //FFT the kernell
    let kernell = kernel.to_complex().fft2d();
    //multiply the image FFT to the kernel fft to then do the inverse transform to ger the convolution of the
    //image and the kernel
    let out = (fft * kernell).ifft2().fftshif().re();
    //save output image
    out.save_as_luma("graphics/pepper_edges.png", ImageFormat::Png)
}

pub fn ifft2(&self) -> Ndarr<C<T>, U2>

where T: Signed + FromPrimitive + Num + Copy + PartialEq + Send + Sync + 'static,

Examples found in repository

examples/image_fft.rs (line 25)

fn main() {
    //open image as lumaf32 (gray scale) where 0.0 is white 1.0 is black.
    let img = open_lumaf32("graphics/peppers.png").unwrap();
    //transform to complex and take the 2D FFT
    let fft = img.to_complex().fft2d();

    //initialize kernel for convolution
    let mut kernel: Ndarr<f32, _> = Ndarr::zeros(&fft.dim);
    let (m, n) = (img.shape()[0], img.shape()[1]);
    let mid_x = m / 2;
    let mid_y = n / 2;
    kernel[[mid_x, mid_y]] = 4.;
    kernel[[mid_x + 1, mid_y]] = -1.;
    kernel[[mid_x - 1, mid_y]] = -1.;
    kernel[[mid_x, mid_y + 1]] = -1.;
    kernel[[mid_x, mid_y - 1]] = -1.;
    //FFT the kernell
    let kernell = kernel.to_complex().fft2d();
    //multiply the image FFT to the kernel fft to then do the inverse transform to ger the convolution of the
    //image and the kernel
    let out = (fft * kernell).ifft2().fftshif().re();
    //save output image
    out.save_as_luma("graphics/pepper_edges.png", ImageFormat::Png)
}

impl<T: Clone + Debug> Ndarr<T, U1>

pub fn fftshif(&self) -> Self

impl<T: Clone + Debug> Ndarr<T, U2>

pub fn fftshif(&self) -> Self

Examples found in repository

examples/image_fft.rs (line 25)

fn main() {
    //open image as lumaf32 (gray scale) where 0.0 is white 1.0 is black.
    let img = open_lumaf32("graphics/peppers.png").unwrap();
    //transform to complex and take the 2D FFT
    let fft = img.to_complex().fft2d();

    //initialize kernel for convolution
    let mut kernel: Ndarr<f32, _> = Ndarr::zeros(&fft.dim);
    let (m, n) = (img.shape()[0], img.shape()[1]);
    let mid_x = m / 2;
    let mid_y = n / 2;
    kernel[[mid_x, mid_y]] = 4.;
    kernel[[mid_x + 1, mid_y]] = -1.;
    kernel[[mid_x - 1, mid_y]] = -1.;
    kernel[[mid_x, mid_y + 1]] = -1.;
    kernel[[mid_x, mid_y - 1]] = -1.;
    //FFT the kernell
    let kernell = kernel.to_complex().fft2d();
    //multiply the image FFT to the kernel fft to then do the inverse transform to ger the convolution of the
    //image and the kernel
    let out = (fft * kernell).ifft2().fftshif().re();
    //save output image
    out.save_as_luma("graphics/pepper_edges.png", ImageFormat::Png)
}

impl<T: Copy + PartialEq + Clone + Debug + Default, R: Unsigned> Ndarr<C<T>, R>

pub fn re(&self) -> Ndarr<T, R>

Examples found in repository

examples/image_fft.rs (line 25)

fn main() {
    //open image as lumaf32 (gray scale) where 0.0 is white 1.0 is black.
    let img = open_lumaf32("graphics/peppers.png").unwrap();
    //transform to complex and take the 2D FFT
    let fft = img.to_complex().fft2d();

    //initialize kernel for convolution
    let mut kernel: Ndarr<f32, _> = Ndarr::zeros(&fft.dim);
    let (m, n) = (img.shape()[0], img.shape()[1]);
    let mid_x = m / 2;
    let mid_y = n / 2;
    kernel[[mid_x, mid_y]] = 4.;
    kernel[[mid_x + 1, mid_y]] = -1.;
    kernel[[mid_x - 1, mid_y]] = -1.;
    kernel[[mid_x, mid_y + 1]] = -1.;
    kernel[[mid_x, mid_y - 1]] = -1.;
    //FFT the kernell
    let kernell = kernel.to_complex().fft2d();
    //multiply the image FFT to the kernel fft to then do the inverse transform to ger the convolution of the
    //image and the kernel
    let out = (fft * kernell).ifft2().fftshif().re();
    //save output image
    out.save_as_luma("graphics/pepper_edges.png", ImageFormat::Png)
}

pub fn im(&self) -> Ndarr<T, R>

impl<T: Copy + PartialEq + Num + Debug, R: Unsigned> Ndarr<T, R>

pub fn to_complex(&self) -> Ndarr<C<T>, R>

Examples found in repository

examples/image_fft.rs (line 9)

fn main() {
    //open image as lumaf32 (gray scale) where 0.0 is white 1.0 is black.
    let img = open_lumaf32("graphics/peppers.png").unwrap();
    //transform to complex and take the 2D FFT
    let fft = img.to_complex().fft2d();

    //initialize kernel for convolution
    let mut kernel: Ndarr<f32, _> = Ndarr::zeros(&fft.dim);
    let (m, n) = (img.shape()[0], img.shape()[1]);
    let mid_x = m / 2;
    let mid_y = n / 2;
    kernel[[mid_x, mid_y]] = 4.;
    kernel[[mid_x + 1, mid_y]] = -1.;
    kernel[[mid_x - 1, mid_y]] = -1.;
    kernel[[mid_x, mid_y + 1]] = -1.;
    kernel[[mid_x, mid_y - 1]] = -1.;
    //FFT the kernell
    let kernell = kernel.to_complex().fft2d();
    //multiply the image FFT to the kernel fft to then do the inverse transform to ger the convolution of the
    //image and the kernel
    let out = (fft * kernell).ifft2().fftshif().re();
    //save output image
    out.save_as_luma("graphics/pepper_edges.png", ImageFormat::Png)
}

impl<T: Copy + PartialEq + Neg<Output = T> + Clone + Debug + Default, R: Unsigned> Ndarr<C<T>, R>

pub fn conj(&self) -> Self

Element wise complex conjugate.

pub fn h(&self) -> Self

Conjugate or Hermitian transpose.

impl<T, R: Unsigned> Ndarr<C<T>, R>

where T: Copy + PartialEq + Neg<Output = T> + Clone + Debug + Default + Div<Output = T> + Mul<Output = T> + Add<Output = T>,

pub fn inv(&self) -> Self

Applies inv element wise.

impl<T: Copy + PartialEq + Add<Output = T> + Mul<Output = T> + Clone + Debug + Default, R: Unsigned> Ndarr<C<T>, R>

pub fn r_square(&self) -> Ndarr<T, R>

impl<T, R: Unsigned> Ndarr<C<T>, R>

where C<T>: MulAssign + Debug, T: Clone + Default + Debug + Copy + PartialEq + Num,

pub fn powi(&self, n: i32) -> Self

impl<T, R: Unsigned> Ndarr<C<T>, R>

where T: Clone + Debug + Default + Float,

pub fn abs(&self) -> Ndarr<T, R>

pub fn exp(&self) -> Self

pub fn arg(&self) -> Ndarr<T, R>

pub fn ln(&self) -> Self

pub fn sqrt(&self) -> Self

pub fn powf(&self, n: T) -> Self

pub fn powc(&self, _z: C<T>) -> Self

pub fn sin(&self) -> Self

pub fn cos(&self) -> Self

pub fn tan(&self) -> Self

pub fn csc(&self) -> Self

pub fn sec(&self) -> Self

pub fn cot(&self) -> Self

pub fn to_polar(&self) -> Ndarr<(T, T), R>

pub fn is_infinite(&self) -> Ndarr<bool, R>

pub fn is_finite(&self) -> Ndarr<bool, R>

pub fn is_normal(&self) -> Ndarr<bool, R>

pub fn is_nan(&self) -> Ndarr<bool, R>

impl<T: Clone, R: Unsigned> Ndarr<T, R>

pub fn new<D: Into<Dim<R>>>(data: &[T], shape: D) -> Result<Self, DimError>

pub fn rank(&self) -> usize

pub fn shape(&self) -> &[usize]

Examples found in repository

examples/image_fft.rs (line 13)

fn main() {
    //open image as lumaf32 (gray scale) where 0.0 is white 1.0 is black.
    let img = open_lumaf32("graphics/peppers.png").unwrap();
    //transform to complex and take the 2D FFT
    let fft = img.to_complex().fft2d();

    //initialize kernel for convolution
    let mut kernel: Ndarr<f32, _> = Ndarr::zeros(&fft.dim);
    let (m, n) = (img.shape()[0], img.shape()[1]);
    let mid_x = m / 2;
    let mid_y = n / 2;
    kernel[[mid_x, mid_y]] = 4.;
    kernel[[mid_x + 1, mid_y]] = -1.;
    kernel[[mid_x - 1, mid_y]] = -1.;
    kernel[[mid_x, mid_y + 1]] = -1.;
    kernel[[mid_x, mid_y - 1]] = -1.;
    //FFT the kernell
    let kernell = kernel.to_complex().fft2d();
    //multiply the image FFT to the kernel fft to then do the inverse transform to ger the convolution of the
    //image and the kernel
    let out = (fft * kernell).ifft2().fftshif().re();
    //save output image
    out.save_as_luma("graphics/pepper_edges.png", ImageFormat::Png)
}

pub fn flatten(self) -> Vec<T>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn from<P: Into<Self>>(p: P) -> Self

Examples found in repository

examples/conway_gol.rs (line 12)

fn update(mat: &mut Ndarr<i8, U2>) {
    let rolls = Ndarr::from([1, 0, -1]);
    let out = rolls
        .map(|r| mat.roll(*r, 0))
        .outer_product(&rolls, |a, r| a.roll(r, 1))
        .sum();
    mat.bimap_in_place(&out, |prev, new| {
        if new == 3 || (prev == 1 && (new == 4)) {
            1
        } else {
            0
        }
    })
}

pub fn reshape<R2: Unsigned, D: Into<Dim<R2>>>( &self, shape: D, ) -> Result<Ndarr<T, R2>, DimError>

Reshapes an Ndarr into an specified Shape. Returns Error if the shape is not compatible.

pub fn slice_at(&self, axis: usize) -> Vec<Ndarr<T, Sub1<R>>>

where R: Sub<B1>, <R as Sub<B1>>::Output: Unsigned,

pub fn slice_at_notyped(&self, axis: usize) -> Vec<Ndarr<T, UTerm>>

pub fn reduce<F: Fn(T, T) -> T + Clone>( &self, axis: usize, f: F, ) -> Result<Ndarr<T, Sub1<R>>, DimError>

where R: Sub<B1>, <R as Sub<B1>>::Output: Unsigned,

Takes a function `F(T,T)-T and an axis, evaluates the function by inserting it between the elements along the specified axis in right-to-left.

pub fn reduce_notyped<F: Fn(T, T) -> T + Clone>( &self, axis: usize, f: F, ) -> Result<Ndarr<T, UTerm>, DimError>

pub fn broadcast_to<R2: Unsigned, D: Into<Dim<R2>>>( &self, shape: D, ) -> Result<Ndarr<T, Maximum<R, R2>>, DimError>

where T: Default, R: Max<R2>, <R as Max<R2>>::Output: Unsigned,

pub fn broadcast<R2: Unsigned, D: Into<Dim<R2>>>( &self, shape: D, ) -> Result<Ndarr<T, Maximum<R, R2>>, DimError>

where T: Default, R: Max<R2>, <R as Max<R2>>::Output: Unsigned,

pub fn broadcast_data<R2: Unsigned, D: Into<Dim<R2>>>( &self, shape: D, ) -> Result<Vec<T>, DimError>

pub fn roll(&self, shift: isize, axis: usize) -> Self

Roll array elements along a given axis, by shift isize. Elements that roll beyond the last position are re-introduced at the first.

Examples found in repository

examples/conway_gol.rs (line 14)

fn update(mat: &mut Ndarr<i8, U2>) {
    let rolls = Ndarr::from([1, 0, -1]);
    let out = rolls
        .map(|r| mat.roll(*r, 0))
        .outer_product(&rolls, |a, r| a.roll(r, 1))
        .sum();
    mat.bimap_in_place(&out, |prev, new| {
        if new == 3 || (prev == 1 && (new == 4)) {
            1
        } else {
            0
        }
    })
}

examples/ising_model.rs (line 17)

fn metropolis(spin_arr: &mut Ndarr<f32, U2>) {
    let energy: Ndarr<f32, U2> = 2.
        * spin_arr.clone()
        * (spin_arr.roll(1, 0) + spin_arr.roll(-1, 0) + spin_arr.roll(1, 1) + spin_arr.roll(-1, 1));
    let temp_exp = (-&energy / T).exp();
    let indexes: Vec<usize> = (0..N).collect();
    let i_s = NdarrRand::choose(&indexes, [M], None); //random i indexes
    let j_s = NdarrRand::choose(&indexes, [M], None); //random j indexes
    let p_swich: f32 = NdarrRand::uniform(0.0, 1.0, [1], None)[0]; // selection probability of random spin switch
    for (i, j) in i_s.data.iter().zip(j_s.data.iter()) {
        if energy[[*i, *j]] < 0.0 || p_swich < temp_exp[[*i, *j]] {
            spin_arr[[*i, *j]] *= &-1.0;
        }
    }
}

impl<T: Clone + Debug> Ndarr<T, U0>

pub fn scalar(self) -> T

where T: Scalar,

pub fn extract(self) -> T

Trait Implementations

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for char

where T: Clone + Debug + Default + Add<char, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for f32

where T: Clone + Debug + Default + Add<f32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for f64

where T: Clone + Debug + Default + Add<f64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for i128

where T: Clone + Debug + Default + Add<i128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for i16

where T: Clone + Debug + Default + Add<i16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for i32

where T: Clone + Debug + Default + Add<i32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for i64

where T: Clone + Debug + Default + Add<i64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for i8

where T: Clone + Debug + Default + Add<i8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for u128

where T: Clone + Debug + Default + Add<u128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for u16

where T: Clone + Debug + Default + Add<u16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for u32

where T: Clone + Debug + Default + Add<u32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for u64

where T: Clone + Debug + Default + Add<u64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<&Ndarr<T, R>> for u8

where T: Clone + Debug + Default + Add<u8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T1, T2, T3, R1, R2: Unsigned> Add<&Ndarr<T2, R2>> for &Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Add<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T2, R2>) -> Self::Output

Performs the + operation.

impl<T1, T2, T3, R1, R2: Unsigned> Add<&Ndarr<T2, R2>> for Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Add<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: &Ndarr<T2, R2>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for char

where T: Clone + Debug + Default + Add<char, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for f32

where T: Clone + Debug + Default + Add<f32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for f64

where T: Clone + Debug + Default + Add<f64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for i128

where T: Clone + Debug + Default + Add<i128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for i16

where T: Clone + Debug + Default + Add<i16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for i32

where T: Clone + Debug + Default + Add<i32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for i64

where T: Clone + Debug + Default + Add<i64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for i8

where T: Clone + Debug + Default + Add<i8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for u128

where T: Clone + Debug + Default + Add<u128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for u16

where T: Clone + Debug + Default + Add<u16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for u32

where T: Clone + Debug + Default + Add<u32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for u64

where T: Clone + Debug + Default + Add<u64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T, R: Unsigned> Add<Ndarr<T, R>> for u8

where T: Clone + Debug + Default + Add<u8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the + operation.

impl<T1, T2, T3, R1, R2: Unsigned> Add<Ndarr<T2, R2>> for &Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Add<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T2, R2>) -> Self::Output

Performs the + operation.

impl<T1, T2, T3, R1, R2: Unsigned> Add<Ndarr<T2, R2>> for Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Add<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Ndarr<T2, R2>) -> Self::Output

Performs the + operation.

impl<L, P, T, R: Unsigned> Add<P> for &Ndarr<T, R>

where L: Clone + Debug + Default, T: Clone + Debug + Default + Add<P, Output = L>, P: Scalar + Copy,

type Output = Ndarr<L, R>

The resulting type after applying the + operator.

fn add(self, other: P) -> Self::Output

Performs the + operation.

impl<L, P, T, R: Unsigned> Add<P> for Ndarr<T, R>

where L: Clone + Debug + Default, T: Clone + Debug + Default + Add<P, Output = L>, P: Scalar + Copy,

type Output = Ndarr<L, R>

The resulting type after applying the + operator.

fn add(self, other: P) -> Self::Output

Performs the + operation.

impl<P, T, R: Unsigned> AddAssign<&P> for Ndarr<T, R>

where T: Add<Output = T> + Clone + Debug + Default, P: IntoNdarr<T, R> + Clone,

fn add_assign(&mut self, other: &P)

Performs the += operation.

impl<T: Clone + Clone, R: Clone + Unsigned> Clone for Ndarr<T, R>

fn clone(&self) -> Ndarr<T, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Clone, R: Debug + Unsigned> Debug for Ndarr<T, R>

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

Formats the value using the given formatter.

impl<T: Clone + Debug + Display, R: Unsigned> Display for Ndarr<T, R>

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

Formats the value using the given formatter.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for char

where T: Clone + Debug + Default + Div<char, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for f32

where T: Clone + Debug + Default + Div<f32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for f64

where T: Clone + Debug + Default + Div<f64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for i128

where T: Clone + Debug + Default + Div<i128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for i16

where T: Clone + Debug + Default + Div<i16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for i32

where T: Clone + Debug + Default + Div<i32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for i64

where T: Clone + Debug + Default + Div<i64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for i8

where T: Clone + Debug + Default + Div<i8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for u128

where T: Clone + Debug + Default + Div<u128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for u16

where T: Clone + Debug + Default + Div<u16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for u32

where T: Clone + Debug + Default + Div<u32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for u64

where T: Clone + Debug + Default + Div<u64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<&Ndarr<T, R>> for u8

where T: Clone + Debug + Default + Div<u8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T1, T2, T3, R1, R2: Unsigned> Div<&Ndarr<T2, R2>> for &Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Div<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T2, R2>) -> Self::Output

Performs the / operation.

impl<T1, T2, T3, R1, R2: Unsigned> Div<&Ndarr<T2, R2>> for Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Div<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: &Ndarr<T2, R2>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for char

where T: Clone + Debug + Default + Div<char, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for f32

where T: Clone + Debug + Default + Div<f32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for f64

where T: Clone + Debug + Default + Div<f64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for i128

where T: Clone + Debug + Default + Div<i128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for i16

where T: Clone + Debug + Default + Div<i16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for i32

where T: Clone + Debug + Default + Div<i32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for i64

where T: Clone + Debug + Default + Div<i64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for i8

where T: Clone + Debug + Default + Div<i8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for u128

where T: Clone + Debug + Default + Div<u128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for u16

where T: Clone + Debug + Default + Div<u16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for u32

where T: Clone + Debug + Default + Div<u32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for u64

where T: Clone + Debug + Default + Div<u64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T, R: Unsigned> Div<Ndarr<T, R>> for u8

where T: Clone + Debug + Default + Div<u8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the / operation.

impl<T1, T2, T3, R1, R2: Unsigned> Div<Ndarr<T2, R2>> for &Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Div<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T2, R2>) -> Self::Output

Performs the / operation.

impl<T1, T2, T3, R1, R2: Unsigned> Div<Ndarr<T2, R2>> for Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Div<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Ndarr<T2, R2>) -> Self::Output

Performs the / operation.

impl<L, P, T, R: Unsigned> Div<P> for &Ndarr<T, R>

where L: Clone + Debug + Default, T: Clone + Debug + Default + Div<P, Output = L>, P: Scalar + Copy,

type Output = Ndarr<L, R>

The resulting type after applying the / operator.

fn div(self, other: P) -> Self::Output

Performs the / operation.

impl<L, P, T, R: Unsigned> Div<P> for Ndarr<T, R>

where L: Clone + Debug + Default, T: Clone + Debug + Default + Div<P, Output = L>, P: Scalar + Copy,

type Output = Ndarr<L, R>

The resulting type after applying the / operator.

fn div(self, other: P) -> Self::Output

Performs the / operation.

impl<P, T, R: Unsigned> DivAssign<&P> for Ndarr<T, R>

where T: Div<Output = T> + Clone + Debug + Default, P: IntoNdarr<T, R> + Clone,

fn div_assign(&mut self, other: &P)

Performs the /= operation.

impl From<&str> for Ndarr<char, U1>

fn from(value: &str) -> Self

Converts to this type from the input type.

impl<T, const N1: usize, const N2: usize, const N3: usize, const N4: usize> From<[[[[T; N1]; N2]; N3]; N4]> for Ndarr<T, U4>

where T: Clone + Debug + Scalar,

fn from(value: [[[[T; N1]; N2]; N3]; N4]) -> Self

Converts to this type from the input type.

impl<T, const N1: usize, const N2: usize, const N3: usize> From<[[[T; N1]; N2]; N3]> for Ndarr<T, U3>

where T: Clone + Debug + Scalar,

fn from(value: [[[T; N1]; N2]; N3]) -> Self

Converts to this type from the input type.

impl<T, const N1: usize, const N2: usize> From<[[T; N1]; N2]> for Ndarr<T, U2>

where T: Clone + Debug + Scalar,

fn from(value: [[T; N1]; N2]) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<[T; N]> for Ndarr<T, U1>

where T: Clone + Debug + Scalar,

fn from(value: [T; N]) -> Self

Converts to this type from the input type.

impl<T> From<Range<T>> for Ndarr<T, U1>

where T: Clone + Debug + Scalar, Range<T>: Iterator, Vec<T>: FromIterator<<Range<T> as Iterator>::Item>,

fn from(value: Range<T>) -> Self

Converts to this type from the input type.

impl<T> From<Vec<T>> for Ndarr<T, U1>

where T: Clone + Debug + Scalar,

fn from(value: Vec<T>) -> Self

Converts to this type from the input type.

impl<T: Clone + Default + Debug, R: Unsigned, I: Into<Dim<R>>> Index<I> for Ndarr<T, R>

type Output = T

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Clone + Default + Debug, R: Unsigned, I: Into<Dim<R>>> IndexMut<I> for Ndarr<T, R>

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T, R: Unsigned> IntoNdarr<T, R> for Ndarr<T, R>

where T: Debug + Clone + Default,

fn into_ndarr(&self, shape: &Dim<R>) -> Ndarr<T, R>

fn get_rank(&self) -> usize

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for char

where T: Clone + Debug + Default + Mul<char, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for f32

where T: Clone + Debug + Default + Mul<f32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for f64

where T: Clone + Debug + Default + Mul<f64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for i128

where T: Clone + Debug + Default + Mul<i128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for i16

where T: Clone + Debug + Default + Mul<i16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for i32

where T: Clone + Debug + Default + Mul<i32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for i64

where T: Clone + Debug + Default + Mul<i64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for i8

where T: Clone + Debug + Default + Mul<i8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for u128

where T: Clone + Debug + Default + Mul<u128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for u16

where T: Clone + Debug + Default + Mul<u16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for u32

where T: Clone + Debug + Default + Mul<u32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for u64

where T: Clone + Debug + Default + Mul<u64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<&Ndarr<T, R>> for u8

where T: Clone + Debug + Default + Mul<u8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T1, T2, T3, R1, R2: Unsigned> Mul<&Ndarr<T2, R2>> for &Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Mul<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T2, R2>) -> Self::Output

Performs the * operation.

impl<T1, T2, T3, R1, R2: Unsigned> Mul<&Ndarr<T2, R2>> for Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Mul<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ndarr<T2, R2>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for char

where T: Clone + Debug + Default + Mul<char, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for f32

where T: Clone + Debug + Default + Mul<f32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for f64

where T: Clone + Debug + Default + Mul<f64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for i128

where T: Clone + Debug + Default + Mul<i128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for i16

where T: Clone + Debug + Default + Mul<i16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for i32

where T: Clone + Debug + Default + Mul<i32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for i64

where T: Clone + Debug + Default + Mul<i64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for i8

where T: Clone + Debug + Default + Mul<i8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for u128

where T: Clone + Debug + Default + Mul<u128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for u16

where T: Clone + Debug + Default + Mul<u16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for u32

where T: Clone + Debug + Default + Mul<u32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for u64

where T: Clone + Debug + Default + Mul<u64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T, R: Unsigned> Mul<Ndarr<T, R>> for u8

where T: Clone + Debug + Default + Mul<u8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the * operation.

impl<T1, T2, T3, R1, R2: Unsigned> Mul<Ndarr<T2, R2>> for &Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Mul<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T2, R2>) -> Self::Output

Performs the * operation.

impl<T1, T2, T3, R1, R2: Unsigned> Mul<Ndarr<T2, R2>> for Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Mul<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Ndarr<T2, R2>) -> Self::Output

Performs the * operation.

impl<L, P, T, R: Unsigned> Mul<P> for &Ndarr<T, R>

where L: Clone + Debug + Default, T: Clone + Debug + Default + Mul<P, Output = L>, P: Scalar + Copy,

type Output = Ndarr<L, R>

The resulting type after applying the * operator.

fn mul(self, other: P) -> Self::Output

Performs the * operation.

impl<L, P, T, R: Unsigned> Mul<P> for Ndarr<T, R>

where L: Clone + Debug + Default, T: Clone + Debug + Default + Mul<P, Output = L>, P: Scalar + Copy,

type Output = Ndarr<L, R>

The resulting type after applying the * operator.

fn mul(self, other: P) -> Self::Output

Performs the * operation.

impl<P, T, R: Unsigned> MulAssign<&P> for Ndarr<T, R>

where T: Mul<Output = T> + Clone + Debug + Default, P: IntoNdarr<T, R> + Clone,

fn mul_assign(&mut self, other: &P)

Performs the *= operation.

impl<T, R: Unsigned> Neg for &Ndarr<T, R>

where T: Neg<Output = T> + Clone + Debug + Default + Copy,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, R: Unsigned> Neg for Ndarr<T, R>

where T: Neg<Output = T> + Clone + Debug + Default + Copy,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq + Clone, R: PartialEq + Unsigned> PartialEq for Ndarr<T, R>

fn eq(&self, other: &Ndarr<T, R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for char

where T: Clone + Debug + Default + Rem<char, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for f32

where T: Clone + Debug + Default + Rem<f32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for f64

where T: Clone + Debug + Default + Rem<f64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for i128

where T: Clone + Debug + Default + Rem<i128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for i16

where T: Clone + Debug + Default + Rem<i16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for i32

where T: Clone + Debug + Default + Rem<i32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for i64

where T: Clone + Debug + Default + Rem<i64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for i8

where T: Clone + Debug + Default + Rem<i8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for u128

where T: Clone + Debug + Default + Rem<u128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for u16

where T: Clone + Debug + Default + Rem<u16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for u32

where T: Clone + Debug + Default + Rem<u32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for u64

where T: Clone + Debug + Default + Rem<u64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<&Ndarr<T, R>> for u8

where T: Clone + Debug + Default + Rem<u8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T1, T2, T3, R1, R2: Unsigned> Rem<&Ndarr<T2, R2>> for &Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Rem<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T2, R2>) -> Self::Output

Performs the % operation.

impl<T1, T2, T3, R1, R2: Unsigned> Rem<&Ndarr<T2, R2>> for Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Rem<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ndarr<T2, R2>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for char

where T: Clone + Debug + Default + Rem<char, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for f32

where T: Clone + Debug + Default + Rem<f32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for f64

where T: Clone + Debug + Default + Rem<f64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for i128

where T: Clone + Debug + Default + Rem<i128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for i16

where T: Clone + Debug + Default + Rem<i16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for i32

where T: Clone + Debug + Default + Rem<i32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for i64

where T: Clone + Debug + Default + Rem<i64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for i8

where T: Clone + Debug + Default + Rem<i8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for u128

where T: Clone + Debug + Default + Rem<u128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for u16

where T: Clone + Debug + Default + Rem<u16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for u32

where T: Clone + Debug + Default + Rem<u32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for u64

where T: Clone + Debug + Default + Rem<u64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T, R: Unsigned> Rem<Ndarr<T, R>> for u8

where T: Clone + Debug + Default + Rem<u8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the % operation.

impl<T1, T2, T3, R1, R2: Unsigned> Rem<Ndarr<T2, R2>> for &Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Rem<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T2, R2>) -> Self::Output

Performs the % operation.

impl<T1, T2, T3, R1, R2: Unsigned> Rem<Ndarr<T2, R2>> for Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Rem<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: Ndarr<T2, R2>) -> Self::Output

Performs the % operation.

impl<L, P, T, R: Unsigned> Rem<P> for &Ndarr<T, R>

where L: Clone + Debug + Default, T: Clone + Debug + Default + Rem<P, Output = L>, P: Scalar + Copy,

type Output = Ndarr<L, R>

The resulting type after applying the % operator.

fn rem(self, other: P) -> Self::Output

Performs the % operation.

impl<L, P, T, R: Unsigned> Rem<P> for Ndarr<T, R>

where L: Clone + Debug + Default, T: Clone + Debug + Default + Rem<P, Output = L>, P: Scalar + Copy,

type Output = Ndarr<L, R>

The resulting type after applying the % operator.

fn rem(self, other: P) -> Self::Output

Performs the % operation.

impl<P, T, R: Unsigned> RemAssign<&P> for Ndarr<T, R>

where T: Rem<Output = T> + Clone + Debug + Default, P: IntoNdarr<T, R> + Clone,

fn rem_assign(&mut self, other: &P)

Performs the %= operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for char

where T: Clone + Debug + Default + Sub<char, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for f32

where T: Clone + Debug + Default + Sub<f32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for f64

where T: Clone + Debug + Default + Sub<f64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for i128

where T: Clone + Debug + Default + Sub<i128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for i16

where T: Clone + Debug + Default + Sub<i16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for i32

where T: Clone + Debug + Default + Sub<i32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for i64

where T: Clone + Debug + Default + Sub<i64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for i8

where T: Clone + Debug + Default + Sub<i8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for u128

where T: Clone + Debug + Default + Sub<u128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for u16

where T: Clone + Debug + Default + Sub<u16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for u32

where T: Clone + Debug + Default + Sub<u32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for u64

where T: Clone + Debug + Default + Sub<u64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<&Ndarr<T, R>> for u8

where T: Clone + Debug + Default + Sub<u8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T1, T2, T3, R1, R2: Unsigned> Sub<&Ndarr<T2, R2>> for &Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Sub<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T2, R2>) -> Self::Output

Performs the - operation.

impl<T1, T2, T3, R1, R2: Unsigned> Sub<&Ndarr<T2, R2>> for Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Sub<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ndarr<T2, R2>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for char

where T: Clone + Debug + Default + Sub<char, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for f32

where T: Clone + Debug + Default + Sub<f32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for f64

where T: Clone + Debug + Default + Sub<f64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for i128

where T: Clone + Debug + Default + Sub<i128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for i16

where T: Clone + Debug + Default + Sub<i16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for i32

where T: Clone + Debug + Default + Sub<i32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for i64

where T: Clone + Debug + Default + Sub<i64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for i8

where T: Clone + Debug + Default + Sub<i8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for u128

where T: Clone + Debug + Default + Sub<u128, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for u16

where T: Clone + Debug + Default + Sub<u16, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for u32

where T: Clone + Debug + Default + Sub<u32, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for u64

where T: Clone + Debug + Default + Sub<u64, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T, R: Unsigned> Sub<Ndarr<T, R>> for u8

where T: Clone + Debug + Default + Sub<u8, Output = T>,

type Output = Ndarr<T, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T, R>) -> Self::Output

Performs the - operation.

impl<T1, T2, T3, R1, R2: Unsigned> Sub<Ndarr<T2, R2>> for &Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Sub<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T2, R2>) -> Self::Output

Performs the - operation.

impl<T1, T2, T3, R1, R2: Unsigned> Sub<Ndarr<T2, R2>> for Ndarr<T1, R1>

where R1: Max<R2> + Unsigned, <R1 as Max<R2>>::Output: Unsigned, T1: Clone + Debug + Default + Sub<T2, Output = T3>, T2: Clone + Debug + Default, T3: Clone + Debug + Default,

type Output = Ndarr<T3, <R1 as Max<R2>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Ndarr<T2, R2>) -> Self::Output

Performs the - operation.

impl<L, P, T, R: Unsigned> Sub<P> for &Ndarr<T, R>

where L: Clone + Debug + Default, T: Clone + Debug + Default + Sub<P, Output = L>, P: Scalar + Copy,

type Output = Ndarr<L, R>

The resulting type after applying the - operator.

fn sub(self, other: P) -> Self::Output

Performs the - operation.

impl<L, P, T, R: Unsigned> Sub<P> for Ndarr<T, R>

where L: Clone + Debug + Default, T: Clone + Debug + Default + Sub<P, Output = L>, P: Scalar + Copy,

type Output = Ndarr<L, R>

The resulting type after applying the - operator.

fn sub(self, other: P) -> Self::Output

Performs the - operation.

impl<P, T, R: Unsigned> SubAssign<&P> for Ndarr<T, R>

where T: Sub<Output = T> + Clone + Debug + Default, P: IntoNdarr<T, R> + Clone,

fn sub_assign(&mut self, other: &P)

Performs the -= operation.

impl<T: Eq + Clone, R: Eq + Unsigned> Eq for Ndarr<T, R>

impl<T: Clone, R: Unsigned> StructuralPartialEq for Ndarr<T, R>