Struct Matrix 

pub struct Matrix<R, S, D>
where
    R: Repr,
    S: DimTrait,
    D: DeviceBase,
{ /* private fields */ }

Implementations

impl<T, S, D> Matrix<Owned<T>, S, D>

where T: Num, D: DeviceBase, S: DimTrait,

pub fn alloc<I: Into<S>>(shape: I) -> Self

pub fn alloc_like<R: Repr<Item = T>>(mat: &Matrix<R, S, D>) -> Self

impl<T, S, D> Matrix<Owned<T>, S, D>

where T: Num, D: DeviceBase, S: DimTrait,

pub fn from_vec<I: Into<S>>(vec: Vec<T>, shape: I) -> Self

impl<T, S, D> Matrix<Owned<T>, S, D>

where T: Num, S: DimTrait, D: DeviceBase,

pub fn ones<I: Into<S>>(dim: I) -> Self

pub fn ones_like<R: Repr<Item = T>>(m: &Matrix<R, S, D>) -> Self

impl<T, S, D> Matrix<Owned<T>, S, D>

where T: Num, S: DimTrait, D: DeviceBase,

pub fn zeros<I: Into<S>>(dim: I) -> Self

pub fn zeros_like<R: Repr<Item = T>>(m: &Matrix<R, S, D>) -> Self

impl<R, S, D> Matrix<R, S, D>

where R: Repr, S: DimTrait, D: DeviceBase,

pub fn offset(&self) -> usize

pub fn shape_stride(&self) -> ShapeStride<S>

pub fn shape(&self) -> S

pub fn stride(&self) -> S

pub fn is_default_stride(&self) -> bool

pub fn is_transpose_default_stride(&self) -> bool

pub fn as_ptr(&self) -> *const R::Item

pub fn to_vec(&self) -> Vec<R::Item>

where R::Item: Clone,

this code retunrs a slice of the matrix WARNING: even if the matrix has offset, the slice will be created from the original pointer

pub fn into_dyn_dim(self) -> Matrix<R, DimDyn, D>

pub fn update_shape_stride(&mut self, shape_stride: ShapeStride<S>)

pub fn update_shape(&mut self, shape: S)

pub fn update_stride(&mut self, stride: S)

pub fn into_dim<S2>(self) -> Matrix<R, S2, D>

where S2: DimTrait,

pub fn slice<I>(&self, index: I) -> Matrix<Ref<&R::Item>, S, D>

where I: SliceTrait<Dim = S>,

pub fn slice_dyn(&self, index: Slice) -> Matrix<Ref<&R::Item>, DimDyn, D>

pub fn index_axis<I>(&self, index: I) -> Matrix<Ref<&R::Item>, S, D>

where I: IndexAxisTrait, S: LessDimTrait, S::LessDim: DimTrait,

pub fn index_axis_dyn<I>(&self, index: I) -> Matrix<Ref<&R::Item>, DimDyn, D>

where I: IndexAxisTrait,

pub fn index_item<I: Into<S>>(&self, index: I) -> R::Item

pub fn to_ref<'a>(&self) -> Matrix<Ref<&'a R::Item>, S, D>

pub fn convert_dim_type<Dout: DimTrait>(self) -> Matrix<R, Dout, D>

pub fn new_matrix(&self) -> Matrix<Owned<R::Item>, S, D>

where D: Device,

pub fn try_to_scalar(&self) -> Result<R::Item, String>

pub fn to_scalar(&self) -> R::Item

pub fn as_slice(&self) -> &[R::Item]

pub fn as_slice_unchecked(&self) -> &[R::Item]

impl<T, S, D> Matrix<Owned<T>, S, D>

where T: Num, D: DeviceBase, S: DimTrait,

pub fn to_ref_mut<'a>(&mut self) -> Matrix<Ref<&'a mut T>, S, D>

pub fn to<Dout: DeviceBase>(self) -> Matrix<Owned<T>, S, Dout>

impl<'a, T, S, D> Matrix<Ref<&'a mut T>, S, D>

where T: Num, D: DeviceBase, S: DimTrait,

pub fn as_mut_ptr(&self) -> *mut T

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

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

pub fn each_by<F>(&mut self, f: F)

where F: FnMut(&mut T),

pub fn slice_mut<I>(&self, index: I) -> Matrix<Ref<&'a mut T>, S, D>

where I: SliceTrait<Dim = S>,

pub fn slice_mut_dyn(&self, index: Slice) -> Matrix<Ref<&'a mut T>, DimDyn, D>

pub fn index_axis_mut<I>(&self, index: I) -> Matrix<Ref<&'a mut T>, S, D>

where I: IndexAxisTrait, S: LessDimTrait, S::LessDim: DimTrait,

pub fn index_axis_mut_dyn<I>( &self, index: I, ) -> Matrix<Ref<&'a mut T>, DimDyn, D>

where I: IndexAxisTrait,

pub fn index_item_assign<I: Into<S>>(&self, index: I, value: T)

impl<R: Repr, D: Device> Matrix<R, DimDyn, D>

pub fn add_axis(&mut self, axis: usize)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + Asum> Matrix<R, S, D>

pub fn asum(&self) -> T

impl<T, D> Matrix<Ref<&mut T>, DimDyn, D>

where T: Num, D: DeviceBase + AddOps,

pub fn add_scalar<OR: Repr<Item = T>>( &mut self, other: &Matrix<OR, DimDyn, D>, scalar: T, )

pub fn add_scalar_assign(&mut self, scalar: T)

pub fn add_assign(&mut self, other: &Matrix<Ref<&T>, DimDyn, D>)

pub fn add_array<LR: Repr<Item = T>, RR: Repr<Item = T>>( &mut self, lhs: &Matrix<LR, DimDyn, D>, rhs: &Matrix<RR, DimDyn, D>, )

impl<T, D> Matrix<Ref<&mut T>, DimDyn, D>

where T: Num, D: DeviceBase + SubOps,

pub fn sub_scalar<OR: Repr<Item = T>>( &mut self, other: &Matrix<OR, DimDyn, D>, scalar: T, )

pub fn sub_scalar_assign(&mut self, scalar: T)

pub fn sub_assign(&mut self, other: &Matrix<Ref<&T>, DimDyn, D>)

pub fn sub_array<LR: Repr<Item = T>, RR: Repr<Item = T>>( &mut self, lhs: &Matrix<LR, DimDyn, D>, rhs: &Matrix<RR, DimDyn, D>, )

impl<T, D> Matrix<Ref<&mut T>, DimDyn, D>

where T: Num, D: DeviceBase + MulOps,

pub fn mul_scalar<OR: Repr<Item = T>>( &mut self, other: &Matrix<OR, DimDyn, D>, scalar: T, )

pub fn mul_scalar_assign(&mut self, scalar: T)

pub fn mul_assign(&mut self, other: &Matrix<Ref<&T>, DimDyn, D>)

pub fn mul_array<LR: Repr<Item = T>, RR: Repr<Item = T>>( &mut self, lhs: &Matrix<LR, DimDyn, D>, rhs: &Matrix<RR, DimDyn, D>, )

impl<T, D> Matrix<Ref<&mut T>, DimDyn, D>

where T: Num, D: DeviceBase + DivOps,

pub fn div_scalar<OR: Repr<Item = T>>( &mut self, other: &Matrix<OR, DimDyn, D>, scalar: T, )

pub fn div_scalar_assign(&mut self, scalar: T)

pub fn div_assign(&mut self, other: &Matrix<Ref<&T>, DimDyn, D>)

pub fn div_array<LR: Repr<Item = T>, RR: Repr<Item = T>>( &mut self, lhs: &Matrix<LR, DimDyn, D>, rhs: &Matrix<RR, DimDyn, D>, )

impl<T: Num, S: DimTrait, D: DeviceBase + SinOps> Matrix<Ref<&mut T>, S, D>

pub fn sin_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn sin_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + SinOps> Matrix<R, S, D>

pub fn sin(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + CosOps> Matrix<Ref<&mut T>, S, D>

pub fn cos_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn cos_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + CosOps> Matrix<R, S, D>

pub fn cos(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + TanOps> Matrix<Ref<&mut T>, S, D>

pub fn tan_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn tan_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + TanOps> Matrix<R, S, D>

pub fn tan(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + AsinOps> Matrix<Ref<&mut T>, S, D>

pub fn asin_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn asin_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + AsinOps> Matrix<R, S, D>

pub fn asin(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + AcosOps> Matrix<Ref<&mut T>, S, D>

pub fn acos_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn acos_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + AcosOps> Matrix<R, S, D>

pub fn acos(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + AtanOps> Matrix<Ref<&mut T>, S, D>

pub fn atan_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn atan_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + AtanOps> Matrix<R, S, D>

pub fn atan(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + SinhOps> Matrix<Ref<&mut T>, S, D>

pub fn sinh_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn sinh_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + SinhOps> Matrix<R, S, D>

pub fn sinh(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + CoshOps> Matrix<Ref<&mut T>, S, D>

pub fn cosh_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn cosh_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + CoshOps> Matrix<R, S, D>

pub fn cosh(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + TanhOps> Matrix<Ref<&mut T>, S, D>

pub fn tanh_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn tanh_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + TanhOps> Matrix<R, S, D>

pub fn tanh(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + AbsOps> Matrix<Ref<&mut T>, S, D>

pub fn abs_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn abs_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + AbsOps> Matrix<R, S, D>

pub fn abs(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + SqrtOps> Matrix<Ref<&mut T>, S, D>

pub fn sqrt_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn sqrt_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + SqrtOps> Matrix<R, S, D>

pub fn sqrt(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + ExpOps> Matrix<Ref<&mut T>, S, D>

pub fn exp_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn exp_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + ExpOps> Matrix<R, S, D>

pub fn exp(&self) -> Matrix<Owned<T>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + LogOps> Matrix<Ref<&mut T>, S, D>

pub fn log_array<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, )

pub fn log_assign(&mut self)

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: DeviceBase + LogOps> Matrix<R, S, D>

pub fn log(&self) -> Matrix<Owned<T>, S, D>

impl<R: Repr, S: DimTrait, D: DeviceBase + PowOws + CopyBlas> Matrix<R, S, D>

pub fn powf_array(&self, scalar: R::Item) -> Matrix<Owned<R::Item>, S, D>

impl<T: Num, S: DimTrait, D: DeviceBase + PowOws + CopyBlas> Matrix<Ref<&mut T>, S, D>

pub fn powf<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, scalar: T, )

pub fn powf_assign(&self, scalar: T)

impl<T: Num, D: Device> Matrix<Ref<&mut T>, DimDyn, D>

pub fn broadcast<R: Repr<Item = T>>(&self, source: &Matrix<R, DimDyn, D>)

impl<R: Repr, S: DimTrait, D: Device> Matrix<R, S, D>

pub fn clip(&self, min: R::Item, max: R::Item) -> Matrix<Owned<R::Item>, S, D>

pub fn clip_backward_mask( &self, min: R::Item, max: R::Item, ) -> Matrix<Owned<R::Item>, S, D>

impl<T: Num, D: Device> Matrix<Ref<&mut T>, DimDyn, D>

pub fn clip_assign(&self, min: T, max: T)

pub fn clip_backward_assign_mask(&self, min: T, max: T)

impl<T, SA, D> Matrix<Ref<&mut T>, SA, D>

where T: Num, SA: DimTrait, D: DeviceBase + CopyBlas,

pub fn copy_from<R: Repr<Item = T>, SB: DimTrait>( &self, source: &Matrix<R, SB, D>, )

impl<T: Num, R: Repr<Item = T>, D: Device> Matrix<R, DimDyn, D>

pub fn max_idx(&self) -> DimDyn

pub fn max_item(&self) -> T

pub fn max_axis( &self, axis: usize, keep_dim: bool, ) -> Matrix<Owned<T>, DimDyn, D>

selfはdefault stride

pub fn max_axis_idx_ravel(&self, axis: usize) -> Vec<usize>

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: Device> Matrix<R, S, D>

pub fn mean( &self, axis: Option<usize>, keep_dim: bool, ) -> Matrix<Owned<T>, DimDyn, D>

impl<T: Num, S: DimTrait, D: Device> Matrix<Ref<&mut T>, S, D>

pub fn relu<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, alpha: T, )

pub fn relu_backward_mask<R: Repr<Item = T>, SO: DimTrait>( &self, other: &Matrix<R, SO, D>, alpha: T, )

impl<T: Num, R: Repr<Item = T>, S: DimTrait, D: Device> Matrix<R, S, D>

pub fn reshape<I: Into<DimDyn>>( &self, new_shape: I, ) -> Matrix<Ref<&T>, DimDyn, D>

impl<T: Num, R: Repr<Item = T>, D: Device> Matrix<R, DimDyn, D>

pub fn reshape_new_matrix<I: Into<DimDyn>>( &self, new_shape: I, ) -> Matrix<Owned<T>, DimDyn, D>

impl<T: Num, S: DimTrait, D: Device> Matrix<Owned<T>, S, D>

pub fn reshape_mut<I: Into<DimDyn>>( &mut self, new_shape: I, ) -> Matrix<Ref<&mut T>, DimDyn, D>

impl<T: Num, S: DimTrait, D: Device> Matrix<Owned<T>, S, D>

pub fn reshape_no_alloc_owned<I: Into<DimDyn>>( self, new_shape: I, ) -> Matrix<Owned<T>, DimDyn, D>

impl<T: Num, D: Device> Matrix<Ref<&mut T>, DimDyn, D>

pub fn softmax_assign<R: Repr<Item = T>>( &self, source: &Matrix<R, DimDyn, D>, axis: usize, )

impl<T: Num, D: Device> Matrix<Ref<&T>, DimDyn, D>

pub fn sum(&self, axis: usize, keep_dim: bool) -> Matrix<Owned<T>, DimDyn, D>

impl<R: Repr, S: DimTrait, D: Device> Matrix<R, S, D>

pub fn to_default_stride(&self) -> Matrix<Owned<R::Item>, S, D>

impl<R: Repr, D: Device> Matrix<R, DimDyn, D>

pub fn transpose(&mut self)

pub fn transpose_by_index(&mut self, index: &[usize])

pub fn transpose_by_index_new_matrix( &self, index: &[usize], ) -> Matrix<Owned<R::Item>, DimDyn, D>

pub fn transpose_swap_index(&mut self, a: usize, b: usize)

pub fn transpose_swap_index_new_matrix( &self, a: usize, b: usize, ) -> Matrix<Owned<R::Item>, DimDyn, D>

impl<T: Num, R: Repr<Item = T>, D: Device> Matrix<R, DimDyn, D>

pub fn variance( &self, axis: Option<usize>, keep_dim: bool, ) -> Matrix<Owned<T>, DimDyn, D>

Trait Implementations

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Add<&Matrix<RO, SO, D>> for &Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the + operator.

fn add(self, rhs: &Matrix<RO, SO, D>) -> Self::Output

Performs the + operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Add<&Matrix<RO, SO, D>> for Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the + operator.

fn add(self, rhs: &Matrix<RO, SO, D>) -> Self::Output

Performs the + operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Add<Matrix<RO, SO, D>> for &Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<RO, SO, D>) -> Self::Output

Performs the + operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Add<Matrix<RO, SO, D>> for Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<RO, SO, D>) -> Self::Output

Performs the + operation.

impl<T: Num, R: Repr<Item = T>, D: Device> Add<T> for &Matrix<R, DimDyn, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Num, R: Repr<Item = T>, D: Device> Add<T> for Matrix<R, DimDyn, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Num, R: Repr<Item = T>, SO: DimTrait, D: Device> AddAssign<Matrix<R, SO, D>> for Matrix<Ref<&mut T>, DimDyn, D>

fn add_assign(&mut self, rhs: Matrix<R, SO, D>)

Performs the += operation.

impl<T: Num, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> AddAssign<Matrix<RO, SO, D>> for Matrix<Owned<T>, SS, D>

fn add_assign(&mut self, rhs: Matrix<RO, SO, D>)

Performs the += operation.

impl<T: Num, S: DimTrait, D: Device> AddAssign<T> for Matrix<Owned<T>, S, D>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: Num, D: Device> AddAssign<T> for Matrix<Ref<&mut T>, DimDyn, D>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<R, S, D> Clone for Matrix<R, S, D>

where R: Repr, S: DimTrait, D: DeviceBase,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, R, S, D> Debug for Matrix<R, S, D>

where A: Num + Debug, R: Repr<Item = A>, S: DimTrait, D: DeviceBase,

Format the array using Debug and apply the formatting parameters used to each element.

The array is shown in multiline style.

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

Formats the value using the given formatter.

impl<'de, T: Num + Deserialize<'de>, D: Device> Deserialize<'de> for Matrix<Owned<T>, DimDyn, D>

fn deserialize<Ds>(deserializer: Ds) -> Result<Self, Ds::Error>

where Ds: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A, R, S, D> Display for Matrix<R, S, D>

where A: Num + Display, R: Repr<Item = A>, S: DimTrait, D: DeviceBase,

Format the array using Display and apply the formatting parameters used to each element.

The array is shown in multiline style.

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

Formats the value using the given formatter.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Div<&Matrix<RO, SO, D>> for &Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the / operator.

fn div(self, rhs: &Matrix<RO, SO, D>) -> Self::Output

Performs the / operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Div<&Matrix<RO, SO, D>> for Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the / operator.

fn div(self, rhs: &Matrix<RO, SO, D>) -> Self::Output

Performs the / operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Div<Matrix<RO, SO, D>> for &Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the / operator.

fn div(self, rhs: Matrix<RO, SO, D>) -> Self::Output

Performs the / operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Div<Matrix<RO, SO, D>> for Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the / operator.

fn div(self, rhs: Matrix<RO, SO, D>) -> Self::Output

Performs the / operation.

impl<T: Num, R: Repr<Item = T>, D: Device> Div<T> for &Matrix<R, DimDyn, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Num, R: Repr<Item = T>, D: Device> Div<T> for Matrix<R, DimDyn, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Num, R: Repr<Item = T>, SO: DimTrait, D: Device> DivAssign<Matrix<R, SO, D>> for Matrix<Ref<&mut T>, DimDyn, D>

fn div_assign(&mut self, rhs: Matrix<R, SO, D>)

Performs the /= operation.

impl<T: Num, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> DivAssign<Matrix<RO, SO, D>> for Matrix<Owned<T>, SS, D>

fn div_assign(&mut self, rhs: Matrix<RO, SO, D>)

Performs the /= operation.

impl<T: Num, S: DimTrait, D: Device> DivAssign<T> for Matrix<Owned<T>, S, D>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Num, D: Device> DivAssign<T> for Matrix<Ref<&mut T>, DimDyn, D>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Num, D: Device> MatrixIter<T, D> for Matrix<Ref<&mut T>, DimDyn, D>

fn map_axis<F>(&self, axis: usize, fn_map: F) -> Matrix<Owned<T>, DimDyn, D>

where F: FnMut(Matrix<Ref<&mut T>, DimDyn, D>),

fn map_axis_mut<F>(self, axis: usize, fn_map: F)

where F: FnMut(Matrix<Ref<&mut T>, DimDyn, D>),

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Mul<&Matrix<RO, SO, D>> for &Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<RO, SO, D>) -> Self::Output

Performs the * operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Mul<&Matrix<RO, SO, D>> for Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<RO, SO, D>) -> Self::Output

Performs the * operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Mul<Matrix<RO, SO, D>> for &Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<RO, SO, D>) -> Self::Output

Performs the * operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Mul<Matrix<RO, SO, D>> for Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<RO, SO, D>) -> Self::Output

Performs the * operation.

impl<T: Num, R: Repr<Item = T>, D: Device> Mul<T> for &Matrix<R, DimDyn, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Num, R: Repr<Item = T>, D: Device> Mul<T> for Matrix<R, DimDyn, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Num, R: Repr<Item = T>, SO: DimTrait, D: Device> MulAssign<Matrix<R, SO, D>> for Matrix<Ref<&mut T>, DimDyn, D>

fn mul_assign(&mut self, rhs: Matrix<R, SO, D>)

Performs the *= operation.

impl<T: Num, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> MulAssign<Matrix<RO, SO, D>> for Matrix<Owned<T>, SS, D>

fn mul_assign(&mut self, rhs: Matrix<RO, SO, D>)

Performs the *= operation.

impl<T: Num, S: DimTrait, D: Device> MulAssign<T> for Matrix<Owned<T>, S, D>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Num, D: Device> MulAssign<T> for Matrix<Ref<&mut T>, DimDyn, D>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<R: Repr, D: Device> Serialize for Matrix<R, DimDyn, D>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Sub<&Matrix<RO, SO, D>> for &Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the - operator.

fn sub(self, rhs: &Matrix<RO, SO, D>) -> Self::Output

Performs the - operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Sub<&Matrix<RO, SO, D>> for Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the - operator.

fn sub(self, rhs: &Matrix<RO, SO, D>) -> Self::Output

Performs the - operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Sub<Matrix<RO, SO, D>> for &Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<RO, SO, D>) -> Self::Output

Performs the - operation.

impl<T: Num, RS: Repr<Item = T>, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> Sub<Matrix<RO, SO, D>> for Matrix<RS, SS, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<RO, SO, D>) -> Self::Output

Performs the - operation.

impl<T: Num, R: Repr<Item = T>, D: Device> Sub<T> for &Matrix<R, DimDyn, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Num, R: Repr<Item = T>, D: Device> Sub<T> for Matrix<R, DimDyn, D>

type Output = Matrix<Owned<T>, DimDyn, D>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Num, R: Repr<Item = T>, SO: DimTrait, D: Device> SubAssign<Matrix<R, SO, D>> for Matrix<Ref<&mut T>, DimDyn, D>

fn sub_assign(&mut self, rhs: Matrix<R, SO, D>)

Performs the -= operation.

impl<T: Num, SS: DimTrait, RO: Repr<Item = T>, SO: DimTrait, D: Device> SubAssign<Matrix<RO, SO, D>> for Matrix<Owned<T>, SS, D>

fn sub_assign(&mut self, rhs: Matrix<RO, SO, D>)

Performs the -= operation.

impl<T: Num, S: DimTrait, D: Device> SubAssign<T> for Matrix<Owned<T>, S, D>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: Num, D: Device> SubAssign<T> for Matrix<Ref<&mut T>, DimDyn, D>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.