Struct zenu_matrix::matrix_impl::Matrix

pub struct Matrix<M, S> { /* private fields */ }

Implementations

impl<T, M> Matrix<M, Dim0>

where T: Num, M: Memory<Item = T>,

pub fn scalar(scalar: T) -> Self

where M: Owned<Item = T>,

pub fn get_value(&self) -> T

pub fn set_value(&mut self, value: T)

where M: ViewMut<Item = T>,

impl<M, S> Matrix<M, S>

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

where M: Memory, S: DimTrait,

Trait Implementations

impl<T: Num, M1: ToViewMemory<Item = T>, M2: ToViewMemory<Item = T>, D1: DimTrait, D2: DimTrait> Add<Matrix<M1, D1>> for Matrix<M2, D2>

type Output = Matrix<OwnedMem<T>, D2>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<M1, D1>) -> Self::Output

Performs the + operation.

impl<T: Num, M: ToViewMemory<Item = T> + ToOwnedMemory, D: DimTrait> Add<T> for Matrix<M, D>

type Output = Matrix<<M as ToOwnedMemory>::Owned, D>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<M: ViewMut, S: DimTrait> AsMutPtr for Matrix<M, S>

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<M: Memory, S: DimTrait> AsPtr for Matrix<M, S>

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

impl<T, M, D> Asum<T> for Matrix<M, D>

where T: Num, M: ToViewMemory<Item = T>, D: DimTrait,

fn asum(self) -> M::Item

impl<T: Num, M: Memory<Item = T>, D: DimTrait> BlasMatrix for Matrix<M, D>

type Blas = <M as Memory>::Blas

impl<'a, T: Num> Broadcast<T> for Matrix<ViewMutMem<'a, T>, DimDyn>

fn broadcast(&mut self, source: &Matrix<ViewMem<'_, T>, DimDyn>)

impl<T: Num, SM: ToViewMemory<Item = T>, D: DimTrait> Clip<T> for Matrix<SM, D>

fn clip(&self, min: T, max: T) -> Matrix<OwnedMem<T>, Self::Dim>

Creates a new matrix with the values clipped to be within the range [min, max].

impl<T: Num, SM: ToViewMemory + ToViewMutMemory<Item = T>, D: DimTrait> ClipAssign<T> for Matrix<SM, D>

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

Clips the values of the matrix to be within the range [min, max].

impl<M: Clone, S: Clone> Clone for Matrix<M, S>

fn clone(&self) -> Matrix<M, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, V, VM> CopyFrom<Matrix<V, DimDyn>> for Matrix<VM, DimDyn>

where T: Num, VM: ToViewMutMemory<Item = T>, V: ToViewMemory<Item = T>,

fn copy_from(&mut self, rhs: &Matrix<V, DimDyn>)

impl<A, S, D: DimTrait> Debug for Matrix<S, D>

where A: Num + Debug, S: Memory<Item = A> + ToViewMemory,

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, M, S> Deserialize<'de> for Matrix<M, S>

where M: Deserialize<'de>, S: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A, S, D: DimTrait> Display for Matrix<S, D>

where A: Num + Display, S: Memory<Item = A> + ToViewMemory,

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, M1: ToViewMemory<Item = T>, M2: ToViewMemory<Item = T>, D1: DimTrait, D2: DimTrait> Div<Matrix<M1, D1>> for Matrix<M2, D2>

type Output = Matrix<OwnedMem<T>, D2>

The resulting type after applying the / operator.

fn div(self, rhs: Matrix<M1, D1>) -> Self::Output

Performs the / operation.

impl<T: Num, M: ToViewMemory<Item = T> + ToOwnedMemory, D: DimTrait> Div<T> for Matrix<M, D>

type Output = Matrix<<M as ToOwnedMemory>::Owned, D>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, SM, RM, LM, DS, DR, DL> Dot<Matrix<RM, DR>, Matrix<LM, DL>> for Matrix<SM, DS>

where T: Num, SM: ViewMut<Item = T>, RM: ToViewMemory<Item = T>, LM: ToViewMemory<Item = T>, DS: DimTrait, DR: DimTrait, DL: DimTrait,

fn dot(self, rhs: Matrix<RM, DR>, lhs: Matrix<LM, DL>)

impl<T: Num, M: ToViewMemory<Item = T>> Exp<T> for Matrix<M, DimDyn>

fn exp(&self) -> Matrix<OwnedMem<T>, DimDyn>

impl<T: Num, M: ToViewMutMemory<Item = T>> ExpAssign<T> for Matrix<M, DimDyn>

fn exp_assign<V: ToViewMemory<Item = T>>(&mut self, y: &Matrix<V, DimDyn>)

impl<T, M1, M2, M3, D1, D2, D3> Gemm<Matrix<M1, D1>, Matrix<M2, D2>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D2: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMemory<Item = T>, M3: ViewMut<Item = T>,

fn gemm(self, rhs: Matrix<M1, D1>, lhs: Matrix<M2, D2>)

Performs the General Matrix Multiply (GEMM) operation.

impl<M: Hash, S: Hash> Hash for Matrix<M, S>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I: IndexAxisTrait, M: ToViewMemory, D: DimTrait + LessDimTrait> IndexAxis<I> for Matrix<M, D>

where <D as LessDimTrait>::LessDim: DimTrait,

type Output<'a> = Matrix<ViewMem<'a, <M as Memory>::Item>, <D as LessDimTrait>::LessDim> where Self: 'a

fn index_axis(&self, index: I) -> Self::Output<'_>

impl<I: IndexAxisTrait, M: ToViewMemory, D: DimTrait> IndexAxisDyn<I> for Matrix<M, D>

type Output<'a> = Matrix<ViewMem<'a, <Matrix<M, D> as MatrixBase>::Item>, DimDyn> where Self: 'a

fn index_axis_dyn(&self, index: I) -> Self::Output<'_>

impl<I: IndexAxisTrait, M: ToViewMutMemory, D: DimTrait + LessDimTrait> IndexAxisMut<I> for Matrix<M, D>

where <D as LessDimTrait>::LessDim: DimTrait,

type Output<'a> = Matrix<ViewMutMem<'a, <M as Memory>::Item>, <D as LessDimTrait>::LessDim> where Self: 'a

fn index_axis_mut(&mut self, index: I) -> Self::Output<'_>

impl<I: IndexAxisTrait, M: ToViewMutMemory, D: DimTrait> IndexAxisMutDyn<I> for Matrix<M, D>

type Output<'a> = Matrix<ViewMutMem<'a, <M as Memory>::Item>, DimDyn> where Self: 'a

fn index_axis_mut_dyn(&mut self, index: I) -> Self::Output<'_>

impl<D: DimTrait, M: Memory> IndexItem for Matrix<M, D>

fn index_item<I: Into<D>>(&self, index: I) -> Self::Item

impl<T: Num, D: DimTrait, VM: ViewMut + Memory<Item = T>> IndexItemAsign for Matrix<VM, D>

fn index_item_asign<I: Into<Self::Dim>>(&mut self, index: I, value: Self::Item)

impl<T, D, SM> Log for Matrix<SM, D>

where T: Num, D: DimTrait, SM: ToViewMutMemory<Item = T>,

fn log(&mut self, source: Matrix<ViewMem<'_, T>, D>)

Computes the element-wise logarithm of source and stores the result in self.

fn log_assign(&mut self)

Computes the element-wise logarithm of self in-place.

impl<T, D1, D3, M1, M3> MatrixAcos<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn acos(&mut self, lhs: Matrix<M1, D1>)

impl<T, D1, D3, M1, M3> MatrixAcosh<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn acosh(&mut self, lhs: Matrix<M1, D1>)

impl<T, D1, D2, D3, M1, M2, M3> MatrixAdd<Matrix<M1, D1>, Matrix<M2, D2>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D2: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn add(&mut self, lhs: Matrix<M1, D1>, rhs: Matrix<M2, D2>)

impl<T, D1, D2, M1, M2> MatrixAdd<Matrix<M1, D1>, T> for Matrix<M2, D2>

where T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>,

fn add(&mut self, lhs: Matrix<M1, D1>, rhs: T)

impl<T, D1, D2, M1, M2> MatrixAdd<T, Matrix<M1, D1>> for Matrix<M2, D2>

where T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>,

fn add(&mut self, lhs: T, rhs: Matrix<M1, D1>)

impl<T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>> MatrixAddAssign<Matrix<M1, D1>> for Matrix<M2, D2>

fn add_assign(&mut self, rhs: Matrix<M1, D1>)

impl<T: Num, D: DimTrait, M: ToViewMutMemory<Item = T>> MatrixAddAssign<T> for Matrix<M, D>

fn add_assign(&mut self, rhs: T)

impl<M: Memory> MatrixAddAxis for Matrix<M, DimDyn>

fn add_axis(&mut self, axis: usize)

impl<T, D1, D3, M1, M3> MatrixAsin<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn asin(&mut self, lhs: Matrix<M1, D1>)

impl<T, D1, D3, M1, M3> MatrixAsinh<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn asinh(&mut self, lhs: Matrix<M1, D1>)

impl<T, D1, D3, M1, M3> MatrixAtan<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn atan(&mut self, lhs: Matrix<M1, D1>)

impl<T, D1, D3, M1, M3> MatrixAtanh<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn atanh(&mut self, lhs: Matrix<M1, D1>)

impl<T: Num, M: Memory<Item = T>, S: DimTrait> MatrixBase for Matrix<M, S>

type Dim = S

type Item = T

fn shape_stride(&self) -> ShapeStride<Self::Dim>

fn is_default_stride(&self) -> bool

fn shape(&self) -> Self::Dim

fn stride(&self) -> Self::Dim

fn is_transposed_default_stride(&self) -> bool

impl<T, D1, D3, M1, M3> MatrixCos<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn cos(&mut self, lhs: Matrix<M1, D1>)

impl<T, D1, D3, M1, M3> MatrixCosh<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn cosh(&mut self, lhs: Matrix<M1, D1>)

impl<T, D1, D2, D3, M1, M2, M3> MatrixDiv<Matrix<M1, D1>, Matrix<M2, D2>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D2: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn div(&mut self, lhs: Matrix<M1, D1>, rhs: Matrix<M2, D2>)

impl<T, D1, D2, M1, M2> MatrixDiv<Matrix<M1, D1>, T> for Matrix<M2, D2>

where T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>,

fn div(&mut self, lhs: Matrix<M1, D1>, rhs: T)

impl<T, D1, D2, M1, M2> MatrixDiv<T, Matrix<M1, D1>> for Matrix<M2, D2>

where T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>,

fn div(&mut self, lhs: T, rhs: Matrix<M1, D1>)

impl<T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>> MatrixDivAssign<Matrix<M1, D1>> for Matrix<M2, D2>

fn div_assign(&mut self, rhs: Matrix<M1, D1>)

impl<T: Num, D: DimTrait, M: ToViewMutMemory<Item = T>> MatrixDivAssign<T> for Matrix<M, D>

fn div_assign(&mut self, rhs: T)

impl<T: Num, M: ToViewMutMemory<Item = T> + ToViewMemory> MatrixIter<T> for Matrix<M, DimDyn>

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

where F: FnMut(Matrix<ViewMutMem<'_, T>, DimDyn>),

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

where F: FnMut(Matrix<ViewMutMem<'_, T>, DimDyn>),

impl<T, D1, D2, D3, M1, M2, M3> MatrixMul<Matrix<M1, D1>, Matrix<M2, D2>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D2: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn mul(&mut self, lhs: Matrix<M1, D1>, rhs: Matrix<M2, D2>)

impl<T, D1, D2, M1, M2> MatrixMul<Matrix<M1, D1>, T> for Matrix<M2, D2>

where T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>,

fn mul(&mut self, lhs: Matrix<M1, D1>, rhs: T)

impl<T, D1, D2, M1, M2> MatrixMul<T, Matrix<M1, D1>> for Matrix<M2, D2>

where T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>,

fn mul(&mut self, lhs: T, rhs: Matrix<M1, D1>)

impl<T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>> MatrixMulAssign<Matrix<M1, D1>> for Matrix<M2, D2>

fn mul_assign(&mut self, rhs: Matrix<M1, D1>)

impl<T: Num, D: DimTrait, M: ToViewMutMemory<Item = T>> MatrixMulAssign<T> for Matrix<M, D>

fn mul_assign(&mut self, rhs: T)

impl<T, D1, D3, M1, M3> MatrixSin<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn sin(&mut self, lhs: Matrix<M1, D1>)

impl<T, D1, D3, M1, M3> MatrixSinh<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn sinh(&mut self, lhs: Matrix<M1, D1>)

impl<M: ToViewMemory, D: DimTrait, S: SliceTrait<Dim = D>> MatrixSlice<S> for Matrix<M, D>

type Output<'a> = Matrix<ViewMem<'a, <M as Memory>::Item>, D> where Self: 'a

fn slice(&self, index: S) -> Self::Output<'_>

impl<T, M, D> MatrixSliceDyn for Matrix<M, D>

where T: Num, M: Memory<Item = T> + ToViewMemory, D: DimTrait,

type Output<'a> = Matrix<ViewMem<'a, <Matrix<M, D> as MatrixBase>::Item>, DimDyn> where Self: 'a

fn slice_dyn(&self, index: Slice) -> Self::Output<'_>

impl<M: ToViewMutMemory, D: DimTrait, S: SliceTrait<Dim = D>> MatrixSliceMut<S> for Matrix<M, D>

type Output<'a> = Matrix<ViewMutMem<'a, <M as Memory>::Item>, D> where Self: 'a

fn slice_mut(&mut self, index: S) -> Self::Output<'_>

impl<T, M, D> MatrixSliceMutDyn for Matrix<M, D>

where T: Num, M: Memory<Item = T> + ToViewMutMemory, D: DimTrait,

type Output<'a> = Matrix<ViewMutMem<'a, <Matrix<M, D> as MatrixBase>::Item>, DimDyn> where Self: 'a

fn slice_mut_dyn(&mut self, index: Slice) -> Self::Output<'_>

impl<T, D1, D2, D3, M1, M2, M3> MatrixSub<Matrix<M1, D1>, Matrix<M2, D2>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D2: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn sub(&mut self, lhs: Matrix<M1, D1>, rhs: Matrix<M2, D2>)

impl<T, D1, D2, M1, M2> MatrixSub<Matrix<M1, D1>, T> for Matrix<M2, D2>

where T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>,

fn sub(&mut self, lhs: Matrix<M1, D1>, rhs: T)

impl<T, D1, D2, M1, M2> MatrixSub<T, Matrix<M1, D1>> for Matrix<M2, D2>

where T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>,

fn sub(&mut self, lhs: T, rhs: Matrix<M1, D1>)

impl<T: Num, D1: DimTrait, D2: DimTrait, M1: ToViewMemory<Item = T>, M2: ToViewMutMemory<Item = T>> MatrixSubAssign<Matrix<M1, D1>> for Matrix<M2, D2>

fn sub_assign(&mut self, rhs: Matrix<M1, D1>)

impl<T: Num, D: DimTrait, M: ToViewMutMemory<Item = T>> MatrixSubAssign<T> for Matrix<M, D>

fn sub_assign(&mut self, rhs: T)

impl<'a, T: Num> MatrixSum for Matrix<ViewMem<'a, T>, DimDyn>

type Output = Matrix<OwnedMem<T>, DimDyn>

fn sum(self, axis: usize, keep_dim: bool) -> Self::Output

impl<T, D1, D3, M1, M3> MatrixTan<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn tan(&mut self, lhs: Matrix<M1, D1>)

impl<T, D1, D3, M1, M3> MatrixTanh<Matrix<M1, D1>> for Matrix<M3, D3>

where T: Num, D1: DimTrait, D3: DimTrait, M1: ToViewMemory<Item = T>, M3: ToViewMutMemory<Item = T>,

fn tanh(&mut self, lhs: Matrix<M1, D1>)

impl<'a, T, D> MaxIdx<T, D> for Matrix<ViewMem<'a, T>, D>

where T: Num, D: DimTrait,

fn max_idx(self) -> DimDyn

fn max(self) -> T

impl<T: Num, M1: ToViewMemory<Item = T>, M2: ToViewMemory<Item = T>, D1: DimTrait, D2: DimTrait> Mul<Matrix<M1, D1>> for Matrix<M2, D2>

type Output = Matrix<OwnedMem<T>, D2>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<M1, D1>) -> Self::Output

Performs the * operation.

impl<T: Num, M: ToViewMemory<Item = T> + ToOwnedMemory, D: DimTrait> Mul<T> for Matrix<M, D>

type Output = Matrix<<M as ToOwnedMemory>::Owned, D>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<M: Owned, S: DimTrait> OwnedMatrix for Matrix<M, S>

fn from_vec<I: Into<Self::Dim>>(vec: Vec<Self::Item>, dim: I) -> Self

impl<'a, T: Num> Relu<T> for Matrix<ViewMutMem<'a, T>, DimDyn>

fn relu(&mut self, source: Matrix<ViewMem<'_, T>, DimDyn>)

fn relu_backward_mask(&mut self, source: Matrix<ViewMem<'_, T>, DimDyn>)

impl<T: Num, D: DimTrait, V: ToViewMemory<Item = T>> Reshape<T> for Matrix<V, D>

fn reshape<I: Into<DimDyn>>( &self, new_shape: I ) -> Matrix<ViewMem<'_, T>, DimDyn>

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

impl<T: Num, D: DimTrait, V: ToViewMutMemory<Item = T>> ReshapeMut<T> for Matrix<V, D>

fn reshape_mut<I: Into<DimDyn>>( &mut self, new_shape: I ) -> Matrix<ViewMutMem<'_, T>, DimDyn>

impl<T: Num, D: DimTrait> ReshapeNoAlloc<T> for Matrix<OwnedMem<T>, D>

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

impl<M, S> Serialize for Matrix<M, S>

where M: Serialize, S: Serialize,

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, M: ToViewMutMemory<Item = T>> SoftMax<T> for Matrix<M, DimDyn>

fn softmax_assign( &mut self, source: Matrix<ViewMem<'_, T>, DimDyn>, axis: usize )

impl<T: Num, M1: ToViewMemory<Item = T>, M2: ToViewMemory<Item = T>, D1: DimTrait, D2: DimTrait> Sub<Matrix<M1, D1>> for Matrix<M2, D2>

type Output = Matrix<OwnedMem<T>, D2>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<M1, D1>) -> Self::Output

Performs the - operation.

impl<T: Num, M: ToViewMemory<Item = T> + ToOwnedMemory, D: DimTrait> Sub<T> for Matrix<M, D>

type Output = Matrix<<M as ToOwnedMemory>::Owned, D>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, M, D: DimTrait> ToDefaultStride<T> for Matrix<M, D>

where T: Num, M: ToViewMemory<Item = T>,

fn to_default_stride(&self) -> Matrix<OwnedMem<T>, DimDyn>

impl<M: ToOwnedMemory, S: DimTrait> ToOwnedMatrix for Matrix<M, S>

type Owned = Matrix<<M as ToOwnedMemory>::Owned, S>

fn to_owned_matrix(&self) -> Self::Owned

impl<M: ToViewMemory, S: DimTrait> ToViewMatrix for Matrix<M, S>

fn to_view(&self) -> Matrix<ViewMem<'_, M::Item>, S>

impl<M: ToViewMutMemory, S: DimTrait> ToViewMutMatrix for Matrix<M, S>

fn to_view_mut(&mut self) -> Matrix<ViewMutMem<'_, M::Item>, S>

impl<T: Num, M: Memory<Item = T>> Transpose for Matrix<M, Dim2>

fn transpose(&mut self)

impl<T: Num, M: Memory<Item = T>> Transpose for Matrix<M, Dim3>

fn transpose(&mut self)

impl<T: Num, M: Memory<Item = T>> Transpose for Matrix<M, Dim4>

fn transpose(&mut self)

impl<T: Num, M: Memory<Item = T>> Transpose for Matrix<M, DimDyn>

fn transpose(&mut self)

impl<T: Num, M: ToViewMemory<Item = T>> TransposeInplace<T> for Matrix<M, DimDyn>

fn transepose_by_index(&self, index: &[usize]) -> Matrix<ViewMem<'_, T>, DimDyn>

fn transpose_by_index_inplace( &self, index: &[usize] ) -> Matrix<OwnedMem<T>, DimDyn>

fn transpose_swap_index_inplace( &self, a: usize, b: usize ) -> Matrix<OwnedMem<T>, DimDyn>

impl<M: View, S: DimTrait> ViewMatrix for Matrix<M, S>

impl<M: ViewMut, S: DimTrait> ViewMutMatix for Matrix<M, S>