Struct Matrix 

pub struct Matrix<'a, T = f32, D: Device = CPU, S: Shape = ()> {
    pub data: Buffer<'a, T, D, S>,
    pub dims: (usize, usize),
}

A matrix using Buffer described with rows and columns

Example

The following example creates a zeroed (or values set to default) Matrix with the given dimensions.

use custos::CPU;
use custos_math::Matrix;

let device = CPU::new();
let m = Matrix::<i32>::new(&device, (5, 8));

assert_eq!(m.rows(), 5);
assert_eq!(m.cols(), 8);
assert_eq!(m.size(), 5*8);
assert_eq!(m.read(), vec![0; 5*8])

Fields

data: Buffer<'a, T, D, S>

dims: (usize, usize)

Implementations

impl<'a, T, D: Device, S: Shape> Matrix<'a, T, D, S>

pub fn new(device: &'a D, dims: (usize, usize)) -> Matrix<'a, T, D, S>

where D: Alloc<'a, T, S>,

Returns an empty matrix with the specified dimensions (rows, cols).

Example

use custos::CPU;
use custos_math::Matrix;

let device = CPU::new();
let m = Matrix::<f64>::new(&device, (20, 10));

assert_eq!(m.size(), 20*10);
assert_eq!(m.read(), vec![0.0; 20*10])

Examples found in repository

examples/cpu_device.rs (line 8)

fn main() {
    let device = CPU::new();
    let a = Matrix::<f32>::new(&device, (5, 5));
    let b = Matrix::from((&device, (5, 5), vec![1.3; 5 * 5]));

    let out = device.add(&a, &b);

    assert_eq!(device.read(&out), vec![1.3; 5 * 5]);
}

examples/cpu_cache.rs (line 9)

fn main() {
    let device = CPU::new();

    let a = Matrix::<i16>::new(&device, (100, 100));
    let b = Matrix::<i16>::new(&device, (100, 100));

    let out = a + b;
    let ptr = {
        let cache = device.cache.borrow();
        let mut node = Ident::new(100 * 100);
        node.idx = 0;
        cache.nodes.get(&node).unwrap().ptr
    };

    assert!(ptr == out.as_buf().ptr.ptr as *mut u8);
}

pub fn device(&self) -> &'a D

pub fn as_buf(&self) -> &Buffer<'a, T, D, S>

Returns a reference to the underlying buffer.

Example

use custos::{CPU, Read};
use custos_math::Matrix;

let device = CPU::new();
let a = Matrix::from((&device, (2, 3), [1., 2., 3., 3., 2., 1.,]));
let read = a.read();
assert_eq!(vec![1., 2., 3., 3., 2., 1.,], read);

Examples found in repository

examples/cpu_cache.rs (line 20)

fn main() {
    let device = CPU::new();

    let a = Matrix::<i16>::new(&device, (100, 100));
    let b = Matrix::<i16>::new(&device, (100, 100));

    let out = a + b;
    let ptr = {
        let cache = device.cache.borrow();
        let mut node = Ident::new(100 * 100);
        node.idx = 0;
        cache.nodes.get(&node).unwrap().ptr
    };

    assert!(ptr == out.as_buf().ptr.ptr as *mut u8);
}

pub fn to_buf(self) -> Buffer<'a, T, D, S>

pub fn as_buf_mut(&mut self) -> &mut Buffer<'a, T, D, S>

Returns a mutable reference to the underlying buffer.

pub fn dims(&self) -> (usize, usize)

pub fn reshape(&mut self, dims: (usize, usize))

pub fn rows(&self) -> usize

Returns the row count of the matrix.

Example

use custos::CPU;
use custos_math::Matrix;

let device = CPU::new();
let matrix = Matrix::<i32>::new(&device, (2, 5));
assert_eq!(matrix.rows(), 2)

pub fn cols(&self) -> usize

Returns the column count of the matrix.

Example

use custos::CPU;
use custos_math::Matrix;

let device = CPU::new();
let matrix = Matrix::<i32>::new(&device, (2, 5));
assert_eq!(matrix.cols(), 5)

pub fn size(&self) -> usize

Returns the number of elements in the matrix: rows * cols

Example

use custos::CPU;
use custos_math::Matrix;

let device = CPU::new();
let matrix = Matrix::<u16>::new(&device, (4, 12));
assert_eq!(matrix.size(), 48)

pub fn as_slice(&self) -> &[T]

where D: MainMemory,

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

where D: MainMemory,

pub fn read(&'a self) -> D::Read<'a>

where T: Default + Copy, D: Read<T, D, S>,

Uses VecRead and current global device to read Matrix

Example

use custos::CPU;
use custos_math::Matrix;

let device = CPU::new();

let a = Matrix::from((&device, (2, 2), [5, 7, 2, 10,]));
assert_eq!(a.read(), vec![5, 7, 2, 10])

Examples found in repository

examples/simple.rs (line 22)

fn with_select(cpu: &CPU) {
    let a: Matrix<i32> = Matrix::from((cpu, (2, 3), [1, 2, 3, 4, 5, 6]));
    let b = Matrix::from((cpu, (2, 3), [6, 5, 4, 3, 2, 1]));

    let c = a + b;
    assert_eq!(c.read(), vec![7, 7, 7, 7, 7, 7]);
}

fn specify_device(cpu: &CPU) {
    //device is specified in every operation
    let a = Matrix::from((cpu, (2, 2), [0.25f32, 0.5, 0.75, 1.]));
    let b = Matrix::from((cpu, (2, 2), [1., 2., 3., 4.]));

    let c_cpu = cpu.mul(&a, &b);
    assert_eq!(cpu.read(&c_cpu), vec![0.25, 1., 2.25, 4.,]);
}

fn using_opencl() -> custos::Result<()> {
    //OpenCL device (GPU)
    let cl = OpenCL::new(0)?;

    let a = Matrix::from((&cl, (2, 2), [0.25f32, 0.5, 0.75, 1.]));
    let b = Matrix::from((&cl, (2, 2), [1., 2., 3., 4.]));

    let c = a * b;
    assert_eq!(c.read(), vec![0.25, 1., 2.25, 4.,]);
    Ok(())
}

examples/gemm.rs (line 12)

fn main() {
    let device = CPU::new();

    let a = Matrix::from((&device, (2, 3), [1., 2., 3., 4., 5., 6.]));
    let b = Matrix::from((&device, (3, 2), [6., 5., 4., 3., 2., 1.]));

    let c = a.gemm(&b);
    println!("c: {c:?}");

    assert_eq!(c.read(), vec![20., 14., 56., 41.,]);
}

pub fn read_to_vec(&self) -> Vec<T>

where T: Default + Copy, D: Read<T, D, S>,

Uses VecRead and current global device to read Matrix

Example

use custos::CPU;
use custos_math::Matrix;

let device = CPU::new();

let a = Matrix::from((&device, (2, 2), [5, 7, 2, 10,]));
assert_eq!(a.read(), vec![5, 7, 2, 10])

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

where D::Ptr<T, S>: ShallowCopy,

Creates a shallow copy of &self.

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

where T: Clone, D::Ptr<T, S>: ShallowCopy, D: CloneBuf<'a, T, S>,

Creates a shallow copy or a deep copy of &self, depening on whether the realloc feature is activated.

impl<'a, T, D: Device, S: Shape> Matrix<'a, T, D, S>

pub fn to_dims<O: Shape>(self) -> Matrix<'a, T, D, O>

where D: ToDim<T, S, O>,

Converts a (non stack allocated) Buffer with no shape to a Buffer with shape O.

impl<T, D: IsShapeIndep, S: Shape> Matrix<'_, T, D, S>

pub fn as_dims<'b, O: Shape>(&self) -> &Matrix<'b, T, D, O>

pub fn as_dims_mut<'b, O: Shape>(&mut self) -> &mut Matrix<'b, T, D, O>

impl<'a, T, D: ActivationOps<T, S>, S: Shape> Matrix<'a, T, D, S>

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

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

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

pub fn relu_mut(&mut self)

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

pub fn relu_grad_mut(&mut self)

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

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

uses pre-computed sigmoid activation

impl<'a, T, S: Shape, D: CCEOp<T, S>> Matrix<'a, T, D, S>

pub fn cce(&self, targets: &Matrix<'a, T, D, S>) -> (T, Matrix<'a, T, D, S>)

pub fn cce_loss(&self, targets: &Matrix<'_, T, D, S>) -> T

pub fn cce_grad(&self, targets: &Matrix<'a, T, D, S>) -> Matrix<'a, T, D, S>

impl<'a, T, D: SoftmaxOps<T>> Matrix<'a, T, D>

pub fn softmax(&self) -> Matrix<'a, T, D>

pub fn softmax_grad(&self, activated: &Matrix<'_, T, D>) -> Matrix<'a, T, D>

impl<'a, T, S: Shape, D: ClipOp<T, S>> Matrix<'a, T, D, S>

pub fn clip(&self, min: T, max: T) -> Matrix<'_, T, D, S>

impl<'a, T, D: DiagflatOp<T>> Matrix<'a, T, D>

pub fn diagflat(&self) -> Matrix<'a, T, D>

impl<'a, T: Float, S: Shape, D: FnsOps<T, S, D>> Matrix<'a, T, D, S>

pub fn exp(&self) -> Self

pub fn ln(&self) -> Self

pub fn neg(&self) -> Self

pub fn powf(&self, rhs: T) -> Self

pub fn powi(&self, rhs: i32) -> Self

impl<'a, T, D: Device, LS: Shape> Matrix<'a, T, D, LS>

pub fn gemm<RS: Shape, OS: Shape>( &self, rhs: &Matrix<'a, T, D, RS>, ) -> Matrix<'a, T, D, OS>

where D: Gemm<T, LS, RS, OS, D>,

Matrix multiplication. Uses current global device.

Example

use custos::CPU;
use custos_math::Matrix;

let device = CPU::new();

let a = Matrix::from((&device, (2, 3), [1., 2., 3., 4., 5., 6.,]));
let b = Matrix::from((&device, (3, 2), [6., 5., 4., 3., 2., 1.,]));

let c = a.gemm(&b);
println!("c: {c:?}");

assert_eq!(c.read(), vec![20., 14., 56., 41.,]);

Examples found in repository

examples/gemm.rs (line 9)

fn main() {
    let device = CPU::new();

    let a = Matrix::from((&device, (2, 3), [1., 2., 3., 4., 5., 6.]));
    let b = Matrix::from((&device, (3, 2), [6., 5., 4., 3., 2., 1.]));

    let c = a.gemm(&b);
    println!("c: {c:?}");

    assert_eq!(c.read(), vec![20., 14., 56., 41.,]);
}

impl<'a, T, D: MaxOps<T>> Matrix<'a, T, D>

pub fn max(&self) -> T

pub fn max_rows(&self) -> Matrix<'a, T, D>

pub fn max_cols(&self) -> Matrix<'a, T, D>

impl<'a, T, LS: Shape, D: Device> Matrix<'a, T, D, LS>

pub fn add_row<RS: Shape>( &self, rhs: &Matrix<'_, T, D, RS>, ) -> Matrix<'a, T, D, LS>

where D: RowOp<T, LS, RS>,

pub fn add_row_mut<RS: Shape>(&mut self, rhs: &Matrix<'a, T, D, RS>)

where D: RowOp<T, LS, RS>,

impl<'a, T, D, S> Matrix<'a, T, D, S>

where D: AdditionalOps<T, S>, S: Shape,

pub fn adds(&self, rhs: T) -> Self

pub fn subs(&self, rhs: T) -> Self

pub fn muls(&self, rhs: T) -> Self

pub fn divs(&self, rhs: T) -> Self

impl<'a, T, IS: Shape, D: SumOps<T, IS>> Matrix<'a, T, D, IS>

pub fn sum(&self) -> T

pub fn mean(&self) -> T

impl<'a, T, D: Device, IS: Shape> Matrix<'a, T, D, IS>

pub fn sum_rows<OS: Shape>(&self) -> Matrix<'a, T, D, OS>

where D: SumOverOps<T, IS, OS>,

pub fn sum_cols<OS: Shape>(&self) -> Matrix<'a, T, D, OS>

where D: SumOverOps<T, IS, OS>,

impl<'a, T, IS: Shape, D: Device> Matrix<'a, T, D, IS>

pub fn T<OS: Shape>(&self) -> Matrix<'a, T, D, OS>

where D: TransposeOp<T, IS, OS>,

Methods from Deref<Target = Buffer<'a, T, D, S>>

pub fn device(&self) -> &'a D

pub fn read(&'a self) -> <D as Read<T, D, S>>::Read<'a>

where T: Clone + Default, D: Read<T, D, S>,

pub fn read_to_vec(&self) -> Vec<T>

where D: Read<T, D, S>, T: Default + Clone,

Reads the contents of the buffer and writes them into a vector. If it is certain whether a CPU, or an unified CPU + OpenCL Buffer, is used, calling .as_slice() (or deref/mut to &/mut [&T]) is probably preferred.

Example

use custos::{CPU, Buffer};

let device = CPU::new();
let buf = Buffer::from((&device, [1, 2, 3, 4]));

assert_eq!(buf.read_to_vec(), vec![1, 2, 3, 4]);

pub fn write(&mut self, data: &[T])

where T: Clone, D: WriteBuf<T, D, S>,

Writes a slice to the Buffer. With a CPU buffer, the slice is just copied to the slice of the buffer.

pub fn len(&self) -> usize

Returns the number of elements contained in Buffer.

Example

use custos::{CPU, Buffer};

let device = CPU::new();
let a = Buffer::<i32, _>::new(&device, 10);
assert_eq!(a.len(), 10)

pub unsafe fn shallow(&self) -> Buffer<'a, T, D, S>

where <D as Device>::Ptr<T, S>: ShallowCopy,

Creates a shallow copy of &self.

Safety

Itself, this function does not need to be unsafe. However, declaring this function as unsafe highlights the violation of creating two or more owners for one resource. Furthermore, the resulting Buffer can outlive self.

pub unsafe fn shallow_or_clone(&self) -> Buffer<'a, T, D, S>

where <D as Device>::Ptr<T, S>: ShallowCopy, T: Clone, D: CloneBuf<'a, T, S>,

Returns a shallow copy of &self, if the realloc feature is deactivated. If the realloc feature is activated, it returns a deep copy / clone.

Safety

Itself, this function does not need to be unsafe. However, declaring this function as unsafe highlights the violation of possibly creating two or more owners for one resource. Furthermore, the resulting Buffer can outlive self.

pub fn id(&self) -> Ident

pub fn as_dims<'b, O>(&self) -> &Buffer<'b, T, D, O>

where O: Shape,

pub fn as_dims_mut<'b, O>(&mut self) -> &mut Buffer<'b, T, D, O>

where O: Shape,

pub fn ptrs(&self) -> (*const T, *mut c_void, u64)

Returns all types of pointers. (host, OpenCL, CUDA)

pub fn ptrs_mut(&mut self) -> (*mut T, *mut c_void, u64)

Returns all types of pointers. (host, OpenCL, CUDA)

pub fn is_empty(&self) -> bool

Returns true if Buffer is created without a slice.

Example

use custos::{CPU, Buffer};

let a = Buffer::<i32, ()>::from(5);
assert!(a.is_empty())

pub fn clear(&mut self)

where D: ClearBuf<T>,

Sets all elements in Buffer to the default value.

pub fn as_slice(&self) -> &[T]

Returns a CPU slice. This does not work with CUDA or raw OpenCL buffers.

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

Returns a mutable CPU slice.

pub fn host_ptr(&self) -> *const T

Returns a non null host pointer

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

Returns a non null host pointer

Trait Implementations

impl<'a, T, D, S: Shape> Add<&Matrix<'a, T, D, S>> for Matrix<'a, T, D, S>

where D: BaseOps<T, S>,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T, D, S: Shape> Add<Matrix<'a, T, D, S>> for &Matrix<'a, T, D, S>

where D: BaseOps<T, S>,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T, D, S: Shape> Add<T> for &Matrix<'a, T, D, S>

where D: AdditionalOps<T, S>,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where D: AdditionalOps<T>,

type Output = Matrix<'a, T, D>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T, D, S: Shape> Add for &Matrix<'a, T, D, S>

where D: BaseOps<T, S>,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T, D, S: Shape> Add for Matrix<'a, T, D, S>

where D: BaseOps<T, S>,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, D, S: Shape> AddAssign<&Matrix<'_, T, D, S>> for Matrix<'_, T, D, S>

where D: AssignOps<T, S, D>,

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<'a, T, S, D> AddAssign<T> for Matrix<'a, T, D, S>

where S: Shape, D: ScalarAssign<T, S>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T, D, S: Shape> AddAssign for Matrix<'_, T, D, S>

where D: AssignOps<T, S, D>,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<'a, T> AsClCvoidPtr for &Matrix<'a, T, OpenCL>

fn as_cvoid_ptr(&self) -> *const c_void

fn is_num(&self) -> bool

fn ptr_size(&self) -> usize

impl<'a, T> AsClCvoidPtr for Matrix<'a, T, OpenCL>

fn as_cvoid_ptr(&self) -> *const c_void

fn is_num(&self) -> bool

fn ptr_size(&self) -> usize

impl<'a, T, S, D> Clone for Matrix<'a, T, D, S>

where T: Clone, S: Shape, D: CloneBuf<'a, T, S>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T: Default + Copy + Debug, D> Debug for Matrix<'a, T, D>

where D: Read<T, D> + 'a,

Available on non-crate feature no-std only.

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

Formats the value using the given formatter.

impl<T, D: Device> Default for Matrix<'_, T, D>

where D::Ptr<T, ()>: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T, D: Device, S: Shape> Deref for Matrix<'a, T, D, S>

type Target = Buffer<'a, T, D, S>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T, D: Device, S: Shape> DerefMut for Matrix<'a, T, D, S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T, S: Shape, D: AdditionalOps<T, S>> Div<T> for &Matrix<'a, T, D, S>

type Output = Matrix<'a, T, D, S>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T, S: Shape, D: AdditionalOps<T, S>> Div<T> for Matrix<'a, T, D, S>

type Output = Matrix<'a, T, D, S>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T, S: Shape, D: BaseOps<T, S>> Div for &Matrix<'a, T, D, S>

type Output = Matrix<'a, T, D, S>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, S, D> DivAssign<T> for Matrix<'_, T, D, S>

where S: Shape, D: ScalarAssign<T, S>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<'a, T> From<(&'a CPU, *mut T, (usize, usize))> for Matrix<'a, T>

Available on crate feature cpu only.

fn from((cpu, ptr, dims): (&'a CPU, *mut T, (usize, usize))) -> Self

Converts to this type from the input type.

impl<'a, T: Copy, D: Alloc<'a, T>> From<(&'a D, (usize, usize))> for Matrix<'a, T, D>

fn from((device, dims): (&'a D, (usize, usize))) -> Self

Converts to this type from the input type.

impl<'a, T: Copy, D: Alloc<'a, T> + IsShapeIndep> From<(&'a D, (usize, usize), &[T])> for Matrix<'a, T, D>

fn from(dims_slice: (&'a D, (usize, usize), &[T])) -> Self

Converts to this type from the input type.

impl<'a, T: Copy, D: Alloc<'a, T> + IsShapeIndep> From<(&'a D, (usize, usize), &Vec<T>)> for Matrix<'a, T, D>

Available on non-crate feature no-std only.

fn from(dims_slice: (&'a D, (usize, usize), &Vec<T>)) -> Self

Converts to this type from the input type.

impl<'a, T: Copy, D: Alloc<'a, T> + IsShapeIndep, const N: usize> From<(&'a D, (usize, usize), [T; N])> for Matrix<'a, T, D>

fn from((device, dims, slice): (&'a D, (usize, usize), [T; N])) -> Self

Converts to this type from the input type.

impl<'a, T: Copy, D: Alloc<'a, T> + IsShapeIndep> From<(&'a D, (usize, usize), Vec<T>)> for Matrix<'a, T, D>

Available on non-crate feature no-std only.

fn from(dims_slice: (&'a D, (usize, usize), Vec<T>)) -> Self

Converts to this type from the input type.

impl<'a, T: Copy, D: Alloc<'a, T>> From<(&'a D, usize, usize)> for Matrix<'a, T, D>

fn from((device, rows, cols): (&'a D, usize, usize)) -> Self

Converts to this type from the input type.

impl<'a, T: Copy, D: Alloc<'a, T> + IsShapeIndep> From<(&'a D, usize, usize, &[T])> for Matrix<'a, T, D>

fn from(dims_slice: (&'a D, usize, usize, &[T])) -> Self

Converts to this type from the input type.

impl<'a, T: Copy, D: Alloc<'a, T> + IsShapeIndep, const N: usize> From<(&'a D, usize, usize, [T; N])> for Matrix<'a, T, D>

fn from(dims_slice: (&'a D, usize, usize, [T; N])) -> Self

Converts to this type from the input type.

impl<'a, T: Copy, D: Alloc<'a, T> + IsShapeIndep> From<(&'a D, usize, usize, Vec<T>)> for Matrix<'a, T, D>

Available on non-crate feature no-std only.

fn from(dims_slice: (&'a D, usize, usize, Vec<T>)) -> Self

Converts to this type from the input type.

impl<'a, 'b, T> From<(&'a OpenCL, Matrix<'b, T>)> for Matrix<'a, T, OpenCL>

Available on crate feature opencl only.

fn from((device, matrix): (&'a OpenCL, Matrix<'b, T>)) -> Self

Converts to this type from the input type.

impl<'a, T> From<(*mut T, (usize, usize))> for Matrix<'a, T>

Available on crate feature cpu only.

fn from((ptr, dims): (*mut T, (usize, usize))) -> Self

Converts to this type from the input type.

impl<'a, T, D: Device, S: Shape> From<(Buffer<'a, T, D, S>, (usize, usize))> for Matrix<'a, T, D, S>

fn from((data, dims): (Buffer<'a, T, D, S>, (usize, usize))) -> Self

Converts to this type from the input type.

impl<'a, T, D: Device, S: Shape> From<(Buffer<'a, T, D, S>, usize, usize)> for Matrix<'a, T, D, S>

fn from((data, rows, cols): (Buffer<'a, T, D, S>, usize, usize)) -> Self

Converts to this type from the input type.

impl<'a, T, D, S: Shape> Mul<&Matrix<'a, T, D, S>> for Matrix<'a, T, D, S>

where D: BaseOps<T, S>,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T: Copy, S: Shape, D: AdditionalOps<T, S>> Mul<&T> for Matrix<'a, T, D, S>

type Output = Matrix<'a, T, D, S>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, S: Shape, D: AdditionalOps<T, S>> Mul<T> for &Matrix<'a, T, D, S>

type Output = Matrix<'a, T, D, S>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, S: Shape, D: AdditionalOps<T, S>> Mul<T> for Matrix<'a, T, D, S>

type Output = Matrix<'a, T, D, S>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, D, S: Shape> Mul for &Matrix<'a, T, D, S>

where D: BaseOps<T, S>,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, D, S: Shape> Mul for Matrix<'a, T, D, S>

where D: BaseOps<T, S>,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, D, S: Shape> MulAssign<&Matrix<'_, T, D, S>> for Matrix<'_, T, D, S>

where D: AssignOps<T, S, D>,

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<T, S, D> MulAssign<T> for Matrix<'_, T, D, S>

where S: Shape, D: ScalarAssign<T, S>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T, D, S: Shape> MulAssign for Matrix<'_, T, D, S>

where D: AssignOps<T, S, D>,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<'a, T, D, S> Sub<&Matrix<'a, T, D, S>> for Matrix<'a, T, D, S>

where D: BaseOps<T, S>, S: Shape,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T, D, S> Sub<Matrix<'a, T, D, S>> for &Matrix<'a, T, D, S>

where D: BaseOps<T, S>, S: Shape,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T, D, S> Sub<T> for &Matrix<'a, T, D, S>

where S: Shape, D: AdditionalOps<T, S>,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Matrix<'a, T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T, D, S> Sub for &Matrix<'a, T, D, S>

where D: BaseOps<T, S>, S: Shape,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T, D, S> Sub for Matrix<'a, T, D, S>

where D: BaseOps<T, S>, S: Shape,

type Output = Matrix<'a, T, D, S>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, D, S: Shape> SubAssign<&Matrix<'_, T, D, S>> for &mut Matrix<'_, T, D, S>

where D: AssignOps<T, S, D>,

fn sub_assign(&mut self, rhs: &Matrix<'_, T, D, S>)

Performs the -= operation.

impl<T, D, S: Shape> SubAssign<&Matrix<'_, T, D, S>> for Matrix<'_, T, D, S>

where D: AssignOps<T, S, D>,

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<T, D, S: Shape> SubAssign<Matrix<'_, T, D, S>> for &mut Matrix<'_, T, D, S>

where D: AssignOps<T, S, D>,

fn sub_assign(&mut self, rhs: Matrix<'_, T, D, S>)

Performs the -= operation.

impl<T, D, S: Shape> SubAssign for Matrix<'_, T, D, S>

where D: AssignOps<T, S, D>,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<'a, T, D, C, const B: usize, const A: usize> WithShape<&'a D, C> for Matrix<'a, T, D, Dim2<B, A>>

where D: Device, Buffer<'a, T, D, Dim2<B, A>>: WithShape<&'a D, C>,

fn with(device: &'a D, array: C) -> Self