Struct MatrixUpper

pub struct MatrixUpper<T> {
    pub size: usize,
    pub data: Vec<T>,
}

Fields

size: usize

data: Vec<T>

Implementations

impl<T> MatrixUpper<T>

pub fn empty() -> MatrixUpper<T>

pub unsafe fn from_vec_unchecked(size: usize, new_vec: Vec<T>) -> MatrixUpper<T>

pub fn from_vec(size: usize, new_vec: Vec<T>) -> Option<MatrixUpper<T>>

pub fn to_slice_mut(&mut self) -> &mut [T]

pub fn to_matrixupperslicemut(&mut self) -> MatrixUpperSliceMut<'_, T>

pub fn size(&self) -> [usize; 2]

pub fn get_diagonal_terms(&self) -> Option<Vec<&T>>

impl<T: Copy + Clone> MatrixUpper<T>

pub fn new(size: usize, new_default: T) -> MatrixUpper<T>

pub fn to_matrixfull(&self) -> Option<MatrixFull<T>>

impl MatrixUpper<f64>

pub fn formated_output(&self, n_len: usize, mat_form: &str)

Trait Implementations

impl<T: Copy + Clone + Display + Send + Sync + Add + AddAssign> Add for MatrixUpper<T>

type Output = MatrixUpper<T>

The resulting type after applying the + operator.

fn add(self, other: MatrixUpper<T>) -> MatrixUpper<T>

Performs the + operation.

impl<T: Clone> Clone for MatrixUpper<T>

fn clone(&self) -> MatrixUpper<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for MatrixUpper<T>

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

Formats the value using the given formatter.

impl<T, I: SliceIndex<[T]>> Index<I> for MatrixUpper<T>

type Output = <I as SliceIndex<[T]>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, I: SliceIndex<[T]>> IndexMut<I> for MatrixUpper<T>

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

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

impl<T: PartialEq> PartialEq for MatrixUpper<T>

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

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

const 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: Clone + Display + Send + Sync + Sub + SubAssign> Sub for MatrixUpper<T>

type Output = MatrixUpper<T>

The resulting type after applying the - operator.

fn sub(self, other: MatrixUpper<T>) -> MatrixUpper<T>

Performs the - operation.

impl<T> TensorOpt<T> for MatrixUpper<T>

fn get1d(&self, position: usize) -> Option<&T>

fn get2d(&self, position: [usize; 2]) -> Option<&T>

fn get(&self, position: &[usize]) -> Option<&T>

fn get3d(&self, position: [usize; 3]) -> Option<&T>

fn get4d(&self, position: [usize; 4]) -> Option<&T>

impl<'a, T> TensorOptMut<'a, T> for MatrixUpper<T>

fn get1d_mut(&mut self, position: usize) -> Option<&mut T>

fn get2d_mut(&mut self, position: [usize; 2]) -> Option<&mut T>

fn get_mut(&mut self, position: &[usize]) -> Option<&mut T>

fn set1d(&mut self, position: usize, new_data: T)

fn set2d(&mut self, position: [usize; 2], new_data: T)

fn set(&mut self, position: &[usize], new_data: T)

fn get3d_mut(&mut self, position: [usize; 3]) -> Option<&mut T>

fn get4d_mut(&mut self, position: [usize; 4]) -> Option<&mut T>

fn set3d(&mut self, position: [usize; 3], new_data: T)

fn set4d(&mut self, position: [usize; 4], new_data: T)

impl<'a, T> TensorOptMutUncheck<'a, T> for MatrixUpper<T>

fn get2d_mut_uncheck(&mut self, position: [usize; 2]) -> Option<&mut T>

fn set2d_uncheck(&mut self, position: [usize; 2], new_data: T)

fn get4d_mut_uncheck(&mut self, position: [usize; 4]) -> Option<&mut T>

fn set4d_uncheck(&mut self, position: [usize; 4], new_data: T)

impl<T> TensorOptUncheck<T> for MatrixUpper<T>

fn get2d_uncheck(&self, position: [usize; 2]) -> Option<&T>

fn get4d_uncheck(&self, position: [usize; 4]) -> Option<&T>

impl<T> TensorSlice<T> for MatrixUpper<T>

fn get1d_slice(&self, position: usize, length: usize) -> Option<&[T]>

fn get2d_slice(&self, position: [usize; 2], length: usize) -> Option<&[T]>

fn get_slice(&self, position: &[usize], length: usize) -> Option<&[T]>

fn get3d_slice(&self, position: [usize; 3], length: usize) -> Option<&[T]>

fn get4d_slice(&self, position: [usize; 4], length: usize) -> Option<&[T]>

impl<'a, T> TensorSliceMut<'a, T> for MatrixUpper<T>

fn get1d_slice_mut( &mut self, position: usize, length: usize, ) -> Option<&mut [T]>

fn get2d_slice_mut( &mut self, position: [usize; 2], length: usize, ) -> Option<&mut [T]>

fn get_slice_mut( &mut self, position: &[usize], length: usize, ) -> Option<&mut [T]>

fn get3d_slice_mut( &mut self, position: [usize; 3], length: usize, ) -> Option<&mut [T]>

fn get4d_slice_mut( &mut self, position: [usize; 4], length: usize, ) -> Option<&mut [T]>

impl<'a, T> TensorSliceMutUncheck<'a, T> for MatrixUpper<T>

fn get2d_slice_mut_uncheck( &mut self, position: [usize; 2], length: usize, ) -> Option<&mut [T]>

fn get4d_slice_mut_uncheck( &mut self, position: [usize; 4], length: usize, ) -> Option<&mut [T]>

impl<T> TensorSliceUncheck<T> for MatrixUpper<T>

fn get2d_slice_uncheck( &self, position: [usize; 2], length: usize, ) -> Option<&[T]>

fn get4d_slice_uncheck( &self, position: [usize; 4], length: usize, ) -> Option<&[T]>

impl<T> StructuralPartialEq for MatrixUpper<T>