Struct CpuBackend 

pub struct CpuBackend;

CPU backend for tensor operations.

Implementations

impl CpuBackend

pub const fn new() -> Self

Creates a new CPU backend.

impl CpuBackend

pub fn add<T: Numeric + Sync + Send>(dst: &mut [T], a: &[T], b: &[T])

Adds two slices element-wise with optional parallelization.

pub fn sub<T: Numeric + Sync + Send>(dst: &mut [T], a: &[T], b: &[T])

Subtracts two slices element-wise with optional parallelization.

pub fn mul<T: Numeric + Sync + Send>(dst: &mut [T], a: &[T], b: &[T])

Multiplies two slices element-wise with optional parallelization.

pub fn div<T: Numeric + Sync + Send>(dst: &mut [T], a: &[T], b: &[T])

Divides two slices element-wise with optional parallelization.

pub fn add_scalar<T: Numeric + Sync + Send>(dst: &mut [T], a: &[T], scalar: T)

Adds a scalar to each element with optional parallelization.

pub fn mul_scalar<T: Numeric + Sync + Send>(dst: &mut [T], a: &[T], scalar: T)

Multiplies each element by a scalar with optional parallelization.

pub fn neg<T: Numeric + Sync + Send>(dst: &mut [T], a: &[T])

Negates each element with optional parallelization.

pub fn abs<T: Numeric + Sync + Send>(dst: &mut [T], a: &[T])

Computes absolute value of each element with optional parallelization.

impl CpuBackend

pub fn relu<T: Float + Sync + Send>(dst: &mut [T], a: &[T])

Applies ReLU activation: max(0, x) with optional parallelization.

pub fn sigmoid<T: Float + Sync + Send>(dst: &mut [T], a: &[T])

Applies sigmoid activation: 1 / (1 + exp(-x)) with optional parallelization.

pub fn tanh<T: Float + Sync + Send>(dst: &mut [T], a: &[T])

Applies tanh activation with optional parallelization.

pub fn exp<T: Float + Sync + Send>(dst: &mut [T], a: &[T])

Applies exponential function with optional parallelization.

pub fn ln<T: Float + Sync + Send>(dst: &mut [T], a: &[T])

Applies natural logarithm with optional parallelization.

pub fn sqrt<T: Float + Sync + Send>(dst: &mut [T], a: &[T])

Applies square root with optional parallelization.

pub fn square<T: Numeric + Sync + Send>(dst: &mut [T], a: &[T])

Squares each element with optional parallelization.

impl CpuBackend

pub fn sum<T: Numeric>(a: &[T]) -> T

Computes the sum of all elements.

pub fn prod<T: Numeric>(a: &[T]) -> T

Computes the product of all elements.

pub fn max<T: Numeric>(a: &[T]) -> Option<T>

Finds the maximum element.

pub fn min<T: Numeric>(a: &[T]) -> Option<T>

Finds the minimum element.

pub fn mean<T: Float>(a: &[T]) -> Option<T>

Computes the mean of all elements.

pub fn argmax<T: Numeric>(a: &[T]) -> Option<usize>

Finds the index of the maximum element.

pub fn argmin<T: Numeric>(a: &[T]) -> Option<usize>

Finds the index of the minimum element.

impl CpuBackend

pub fn matmul<T: Numeric>( c: &mut [T], a: &[T], b: &[T], m: usize, n: usize, k: usize, )

Performs matrix multiplication: C = A @ B.

A is (m x k), B is (k x n), C is (m x n). Uses optimized GEMM from matrixmultiply crate for f32/f64, falls back to cache-efficient tiled implementation for other types.

pub fn sgemm( c: &mut [f32], a: &[f32], b: &[f32], m: usize, n: usize, k: usize, alpha: f32, beta: f32, )

Performs optimized f32 matrix multiplication using matrixmultiply crate.

C = alpha * A @ B + beta * C

pub fn dgemm( c: &mut [f64], a: &[f64], b: &[f64], m: usize, n: usize, k: usize, alpha: f64, beta: f64, )

Performs optimized f64 matrix multiplication using matrixmultiply crate.

C = alpha * A @ B + beta * C

pub fn matmul_f32( c: &mut [f32], a: &[f32], b: &[f32], m: usize, n: usize, k: usize, )

Performs f32 matrix multiplication: C = A @ B using optimized GEMM.

pub fn matmul_f64( c: &mut [f64], a: &[f64], b: &[f64], m: usize, n: usize, k: usize, )

Performs f64 matrix multiplication: C = A @ B using optimized GEMM.

pub fn transpose<T: Scalar>(dst: &mut [T], src: &[T], rows: usize, cols: usize)

Transposes a matrix.

A is (rows x cols), B is (cols x rows).

pub fn dot<T: Numeric>(a: &[T], b: &[T]) -> T

Computes dot product of two vectors.

impl CpuBackend

pub fn eq<T: Scalar + PartialEq>(dst: &mut [bool], a: &[T], b: &[T])

Element-wise equality comparison.

pub fn lt<T: Numeric>(dst: &mut [bool], a: &[T], b: &[T])

Element-wise less-than comparison.

pub fn gt<T: Numeric>(dst: &mut [bool], a: &[T], b: &[T])

Element-wise greater-than comparison.

impl CpuBackend

pub fn fill<T: Scalar>(dst: &mut [T], value: T)

Fills a slice with a value.

pub fn fill_zeros<T: Scalar>(dst: &mut [T])

Fills a slice with zeros.

pub fn copy<T: Scalar>(dst: &mut [T], src: &[T])

Copies from source to destination.

Trait Implementations

impl Backend for CpuBackend

fn name(&self) -> &'static str

Returns the name of this backend.

fn is_available(&self) -> bool

Returns whether this backend is available on the current system.

fn capabilities(&self) -> DeviceCapabilities

Returns the device capabilities.

fn allocate(&self, size: usize) -> *mut u8

Allocates memory on this backend.

fn deallocate(&self, ptr: *mut u8, size: usize)

Deallocates memory on this backend.

fn copy_to_device(&self, dst: *mut u8, src: *const u8, size: usize)

Copies data from host to device.

fn copy_to_host(&self, dst: *mut u8, src: *const u8, size: usize)

Copies data from device to host.

fn copy_device_to_device(&self, dst: *mut u8, src: *const u8, size: usize)

Copies data within the device.

fn synchronize(&self)

Synchronizes the device (waits for all operations to complete).

impl Clone for CpuBackend

fn clone(&self) -> CpuBackend

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CpuBackend

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

Formats the value using the given formatter.

impl Default for CpuBackend

fn default() -> CpuBackend

Returns the “default value” for a type.

impl Copy for CpuBackend