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 new(memory: M, shape: S, stride: S) -> Self

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

where M: Memory, S: DimTrait,

Trait Implementations

impl<'a, 'b, D1, D2, T> Add<Matrix<ViewMem<'a, T>, D1>> for Matrix<ViewMem<'b, T>, D2>

where D1: DimTrait, D2: DimTrait, T: Num,

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

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<ViewMem<'_, T>, D1>) -> Self::Output

Performs the + operation.

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

where D: DimTrait, T: Num,

type Output = Matrix<OwnedMem<T>, 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<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: ViewMut<Item = T>, V: View<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<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<'a, 'b, 'c, T, D1, D2, D3> Gemm<Matrix<ViewMem<'a, T>, D1>, Matrix<ViewMem<'b, T>, D2>> for Matrix<ViewMutMem<'c, T>, D3>

where T: Num, D1: DimTrait, D2: DimTrait, D3: DimTrait,

fn gemm(self, rhs: Matrix<ViewMem<'_, T>, D1>, lhs: Matrix<ViewMem<'_, T>, D2>)

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

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

type Output<'a> = Matrix<<M as ToViewMemory>::View<'a>, <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<<M as ToViewMemory>::View<'a>, 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<<M as ToViewMutMemory>::ViewMut<'a>, <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<<M as ToViewMutMemory>::ViewMut<'a>, 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<'a, 'b, T, D> MatrixAdd<Matrix<ViewMem<'a, T>, D>, T> for Matrix<ViewMutMem<'b, T>, D>

where T: Num, D: DimTrait,

fn add(self, lhs: Matrix<ViewMem<'_, T>, D>, rhs: T)

impl<'a, 'b, 'c, T, D1, D2> MatrixAdd<Matrix<ViewMem<'a, T>, D1>, Matrix<ViewMem<'b, T>, D2>> for Matrix<ViewMutMem<'c, T>, D1>

where T: Num, D1: DimTrait, D2: DimTrait,

fn add(self, lhs: Matrix<ViewMem<'_, T>, D1>, rhs: Matrix<ViewMem<'_, T>, D2>)

impl<'a, 'b, T, D1, D2> MatrixAddAssign<Matrix<ViewMem<'a, T>, D1>> for Matrix<ViewMutMem<'b, T>, D2>

where T: Num, D1: DimTrait, D2: DimTrait,

fn add_assign(self, rhs: Matrix<ViewMem<'_, T>, D1>)

impl<'a, T, D> MatrixAddAssign<T> for Matrix<ViewMutMem<'a, T>, D>

where T: Num, D: DimTrait,

fn add_assign(self, rhs: T)

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, RM, SM, D> MatrixMul<Matrix<RM, D>, T> for Matrix<SM, D>

where T: Num, RM: View<Item = T>, SM: ViewMut<Item = T>, D: DimTrait,

fn mul(self, lhs: Matrix<RM, D>, rhs: T)

impl<'a, 'b, 'c, T, DS, DR> MatrixMul<Matrix<ViewMem<'a, T>, DS>, Matrix<ViewMem<'b, T>, DR>> for Matrix<ViewMutMem<'c, T>, DS>

where T: Num, DS: DimTrait, DR: DimTrait,

fn mul(self, lhs: Matrix<ViewMem<'_, T>, DS>, rhs: Matrix<ViewMem<'_, T>, DR>)

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

type Output<'a> = Matrix<<M as ToViewMemory>::View<'a>, 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<<M as ToViewMemory>::View<'a>, 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<<M as ToViewMutMemory>::ViewMut<'a>, D> where Self: 'a

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

impl<'a, 'b, 'c, T, D1, D2, D3> MatrixSub<Matrix<ViewMem<'a, T>, D1>, Matrix<ViewMem<'b, T>, D2>> for Matrix<ViewMutMem<'c, T>, D3>

where D1: DimTrait, D2: DimTrait, D3: DimTrait, T: Num,

fn sub(self, lhs: Matrix<ViewMem<'_, T>, D1>, rhs: Matrix<ViewMem<'_, T>, D2>)

impl<'a, 'b, T, D1, D2> MatrixSub<Matrix<ViewMem<'a, T>, D1>, T> for Matrix<ViewMutMem<'b, T>, D2>

where D1: DimTrait, D2: DimTrait, T: Num,

fn sub(self, lhs: Matrix<ViewMem<'_, T>, D1>, rhs: T)

impl<'a, 'b, T, D1, D2> MatrixSubAssign<Matrix<ViewMem<'a, T>, D1>> for Matrix<ViewMutMem<'b, T>, D2>

where D1: DimTrait, D2: DimTrait, T: Num,

fn sub_assign(self, rhs: Matrix<ViewMem<'_, T>, D1>)

impl<'a, T, D> MatrixSubAssign<T> for Matrix<ViewMutMem<'a, T>, D>

where D: DimTrait, T: Num,

fn sub_assign(self, rhs: T)

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

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

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

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

where T: Num, D: DimTrait,

fn max_idx(self) -> DimDyn

impl<'a, 'b, D1, D2, T> Mul<Matrix<ViewMem<'a, T>, D1>> for Matrix<ViewMem<'b, T>, D2>

where D1: DimTrait, D2: DimTrait, T: Num,

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

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<ViewMem<'_, T>, D1>) -> Self::Output

Performs the * operation.

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

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

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<'a, 'b, D1, D2, T> Sub<Matrix<ViewMem<'a, T>, D1>> for Matrix<ViewMem<'b, T>, D2>

where D1: DimTrait, D2: DimTrait, T: Num,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<ViewMem<'_, T>, D1>) -> Self::Output

Performs the - operation.

impl<'a, D1, T> Sub<T> for Matrix<ViewMem<'a, T>, D1>

where D1: DimTrait, T: Num,

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> ToDefaultStride<T> for Matrix<OwnedMem<T>, DimDyn>

where T: Num,

fn to_default_stride<SD>(source: Matrix<ViewMem<'_, T>, SD>) -> Self

where SD: DimTrait,

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

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

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

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

type View<'a> = Matrix<<M as ToViewMemory>::View<'a>, S> where Self: 'a

fn to_view(&self) -> Self::View<'_>

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

type ViewMut<'a> = Matrix<<M as ToViewMutMemory>::ViewMut<'a>, S> where Self: 'a

fn to_view_mut(&mut self) -> Self::ViewMut<'_>

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<M: View, S: DimTrait> ViewMatrix for Matrix<M, S>

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