Struct VecMutView

pub struct VecMutView<'a, T: Debug + Display + Copy + Sized> { /* private fields */ }

Provide mutable window on array

Trait Implementations

impl<T: Debug + Display + Copy + Sized> Array<T, usize> for VecMutView<'_, T>

fn get(&self, i: usize) -> &T

retrieve a reference to a value at position

fn shape(&self) -> usize

return shape of the array

fn is_empty(&self) -> bool

return true if array is empty

fn iterator<'b>(&'b self, axis: u8) -> Box<dyn Iterator<Item = &'b T> + 'b>

iterate over array’s values

impl<T: Debug + Display + Copy + Sized> ArrayView1<T> for VecMutView<'_, T>

fn dot(&self, other: &dyn ArrayView1<T>) -> T

where T: Number,

return dot product with another array

fn sum(&self) -> T

where T: Number,

return sum of all value of the view

fn max(&self) -> T

where T: Number + PartialOrd,

return max value from the view

fn min(&self) -> T

where T: Number + PartialOrd,

return min value from the view

fn argmax(&self) -> usize

where T: Number + PartialOrd,

return the position of the max value of the view

fn unique(&self) -> Vec<T>

where T: Number + Ord,

sort the elements and remove duplicates

fn unique_with_indices(&self) -> (Vec<T>, Vec<usize>)

where T: Number + Ord,

return sorted unique elements

fn norm2(&self) -> f64

where T: Number,

return norm2

fn norm(&self, p: f64) -> f64

where T: Number,

return norm

fn max_diff(&self, other: &dyn ArrayView1<T>) -> T

where T: Number + Signed + PartialOrd,

return max differences in array

fn variance(&self) -> f64

where T: Number,

return array variance

fn std_dev(&self) -> f64

where T: Number,

return variance

fn mean_by(&self) -> f64

where T: Number,

return mean of the array

impl<'a, T: Debug + Debug + Display + Copy + Sized> Debug for VecMutView<'a, T>

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

Formats the value using the given formatter.

impl<T: Debug + Display + Copy + Sized> MutArray<T, usize> for VecMutView<'_, T>

fn set(&mut self, i: usize, x: T)

assign value to a position

fn iterator_mut<'b>( &'b mut self, axis: u8, ) -> Box<dyn Iterator<Item = &'b mut T> + 'b>

iterate over mutable values

fn swap(&mut self, a: S, b: S)

where S: Copy,

swap values between positions

fn div_element_mut(&mut self, pos: S, x: T)

where T: Number, S: Copy,

divide element by a given value

fn mul_element_mut(&mut self, pos: S, x: T)

where T: Number, S: Copy,

multiply element for a given value

fn add_element_mut(&mut self, pos: S, x: T)

where T: Number, S: Copy,

add a given value to an element

fn sub_element_mut(&mut self, pos: S, x: T)

where T: Number, S: Copy,

subtract a given value to an element

fn sub_scalar_mut(&mut self, x: T)

where T: Number,

subtract a given value to all the elements

fn add_scalar_mut(&mut self, x: T)

where T: Number,

add a given value to all the elements

fn mul_scalar_mut(&mut self, x: T)

where T: Number,

multiply a given value to all the elements

fn div_scalar_mut(&mut self, x: T)

where T: Number,

divide a given value to all the elements

fn add_mut(&mut self, other: &dyn Array<T, S>)

where T: Number, S: Eq,

add values from another array to the values of initial array

fn sub_mut(&mut self, other: &dyn Array<T, S>)

where T: Number, S: Eq,

subtract values from another array to the values of initial array

fn mul_mut(&mut self, other: &dyn Array<T, S>)

where T: Number, S: Eq,

multiply values from another array to the values of initial array

fn div_mut(&mut self, other: &dyn Array<T, S>)

where T: Number, S: Eq,

divide values from another array to the values of initial array

impl<T: Debug + Display + Copy + Sized> MutArrayView1<T> for VecMutView<'_, T>

fn copy_from(&mut self, other: &dyn Array<T, usize>)

copy a mutable view from array

fn abs_mut(&mut self)

where T: Number + Signed,

return a mutable view of absolute values

fn neg_mut(&mut self)

where T: Number + Neg<Output = T>,

return a mutable view of values with opposite sign

fn pow_mut(&mut self, p: T)

where T: RealNumber,

return a mutable view of values at power p

fn argsort_mut(&mut self) -> Vec<usize>

where T: Number + PartialOrd,

return vector of indices for sorted elements

fn softmax_mut(&mut self)

where T: RealNumber,

return softmax values