Struct custos_math::custos::devices::cpu::CPU

pub struct CPU {
    pub cache: RefCell<Cache<CPU>>,
    pub graph: RefCell<Graph>,
}

A CPU is used to perform calculations on the host CPU. To make new operations invocable, a trait providing new functions should be implemented for CPU.

Example

use custos::{CPU, Read, Buffer};

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

let out = device.read(&a);

assert_eq!(out, vec![1, 2, 3]);

Fields

cache: RefCell<Cache<CPU>>

graph: RefCell<Graph>

Implementations

impl CPU

pub fn new() -> CPU

Creates an CPU with an InternCPU that holds an empty vector of pointers.

Trait Implementations

impl<T: Float, D: MainMemory, S: Shape> ActivationOps<T, S, D> for CPU

fn sigmoid(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn sigmoid_grad(&self, activated: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn tanh(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn tanh_grad(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn relu(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

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

inplace

fn relu_grad(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

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

inplace

impl<T: Number, D: MainMemory, S: Shape> AdditionalOps<T, S, D> for CPU

fn adds(&self, lhs: &Matrix<'_, T, D, S>, rhs: T) -> Matrix<'_, T, Self, S>

fn subs(&self, lhs: &Matrix<'_, T, D, S>, rhs: T) -> Matrix<'_, T, Self, S>

fn muls(&self, lhs: &Matrix<'_, T, D, S>, rhs: T) -> Matrix<'_, T, Self, S>

fn divs(&self, lhs: &Matrix<'_, T, D, S>, rhs: T) -> Matrix<'_, T, Self, S>

impl<T, S> Alloc<'_, T, S> for CPUwhere S: Shape,

fn alloc(&self, len: usize, flag: AllocFlag) -> CPUPtr<T>

Allocate memory on the implemented device.

fn with_slice(&self, data: &[T]) -> CPUPtr<T>where T: Clone,

Allocate new memory with data

fn alloc_with_vec(&self, vec: Vec<T, Global>) -> CPUPtr<T>

If the vector vec was allocated previously, this function can be used in order to reduce the amount of allocations, which may be faster than using a slice of vec.

impl<T: Number, D: MainMemory, S: Shape> AssignOps<T, S, D> for CPU

fn add_assign(&self, lhs: &mut Buffer<'_, T, Self, S>, rhs: &Buffer<'_, T, D, S>)

Add assign

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

fn mul_assign(&self, lhs: &mut Buffer<'_, T, Self, S>, rhs: &Buffer<'_, T, D, S>)

impl<T, S, D> BaseOps<T, S, D> for CPUwhere T: Number, S: Shape, D: MainMemory,

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

Element-wise addition

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

Element-wise subtraction

fn mul( &self, lhs: &Matrix<'_, T, D, S>, rhs: &Matrix<'_, T, D, S> ) -> Matrix<'_, T, Self, S>

Element-wise multiplication

fn div( &self, lhs: &Matrix<'_, T, D, S>, rhs: &Matrix<'_, T, D, S> ) -> Matrix<'_, T, Self, S>

Element-wise division

impl<'a, T> CacheBuf<'a, T, ()> for CPU

fn cached(&'a self, len: usize) -> Buffer<'a, T, CPU, ()>

Adds a buffer to the cache. Following calls will return this buffer, if the corresponding internal count matches with the id used in the cache.

impl CacheReturn for CPU

type CT = RawCpuBuf

fn cache(&self) -> RefMut<'_, Cache<CPU>>

Returns a device specific Cache.

impl<T, D> ClearBuf<T, D, ()> for CPUwhere T: Default, D: MainMemory,

fn clear(&self, buf: &mut Buffer<'_, T, D, ()>)

Sets all elements of the matrix to zero.

impl<T: Number, D: MainMemory, S: Shape> ClipOp<T, S, D> for CPU

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

impl<'a, T, S> CloneBuf<'a, T, S> for CPUwhere T: Clone, S: Shape,

fn clone_buf(&'a self, buf: &Buffer<'a, T, CPU, S>) -> Buffer<'a, T, CPU, S>

Creates a deep copy of the specified buffer.

impl<T: Number, D: MainMemory> ColOp<T, D> for CPU

fn add_col(&self, lhs: &Matrix<'_, T, D>, rhs: &Matrix<'_, T, D>) -> Matrix<'_, T>

fn sub_col(&self, lhs: &Matrix<'_, T, D>, rhs: &Matrix<'_, T, D>) -> Matrix<'_, T>

fn div_col(&self, lhs: &Matrix<'_, T, D>, rhs: &Matrix<'_, T, D>) -> Matrix<'_, T>

impl<T, R, D> CopySlice<T, R, D> for CPUwhere T: Copy, R: RangeBounds<usize>, D: MainMemory, [T]: Index<R, Output = [T]>,

fn copy_slice( &self, buf: &Buffer<'_, T, D, ()>, range: R ) -> Buffer<'_, T, CPU, ()>

Copy a slice of the given buffer into a new buffer.

impl Debug for CPU

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

Formats the value using the given formatter.

impl Default for CPU

fn default() -> CPU

Returns the “default value” for a type.

impl Device for CPU

type Ptr = CPUPtr<U>

type Cache = Cache<CPU>

fn new() -> Result<CPU, Box<dyn Error + Sync + Send + 'static, Global>>

fn retrieve<T, S>( &self, len: usize, add_node: impl AddGraph ) -> Buffer<'_, T, Self, S>where S: Shape, Self: for<'a> Alloc<'a, T, S>,

impl<T: Default + Copy, D: MainMemory> DiagflatOp<T, D> for CPU

fn diagflat(&self, x: &Matrix<'_, T, D>) -> Matrix<'_, T>

impl<T, D, S> FnsOps<T, S, D> for CPUwhere T: Float, D: MainMemory, S: Shape,

fn exp(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn ln(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn neg(&self, x: &Matrix<'_, T, D, S>) -> Matrix<'_, T, Self, S>

fn powf(&self, x: &Matrix<'_, T, D, S>, rhs: T) -> Matrix<'_, T, Self, S>

fn powi(&self, x: &Matrix<'_, T, D, S>, rhs: i32) -> Matrix<'_, T, Self, S>

impl<T, D, LS, RS, OS> Gemm<T, LS, RS, OS, D> for CPUwhere T: GenericBlas + Default + Copy, D: MainMemory, LS: Shape, RS: Shape, OS: Shape,

fn gemm( &self, lhs: &Matrix<'_, T, D, LS>, rhs: &Matrix<'_, T, D, RS> ) -> Matrix<'_, T, Self, OS>

impl GraphReturn for CPU

fn graph(&self) -> RefMut<'_, Graph>

impl MainMemory for CPU

fn as_ptr<T, S>(ptr: &<CPU as Device>::Ptr<T, S>) -> *const Twhere S: Shape,

fn as_ptr_mut<T, S>(ptr: &mut <CPU as Device>::Ptr<T, S>) -> *mut Twhere S: Shape,

impl<T: Copy + PartialOrd, D: MainMemory> MaxOps<T, D> for CPU

fn max(&self, x: &Matrix<'_, T, D>) -> T

fn max_rows(&self, x: &Matrix<'_, T, D>) -> Matrix<'_, T>

fn max_cols(&self, x: &Matrix<'_, T, D>) -> Matrix<'_, T>

impl<T: Float, D: MainMemory, S: Shape> RandOp<T, S, D> for CPU

fn rand(&self, x: &mut Buffer<'_, T, D, S>, lo: T, hi: T)

impl RawConv for CPU

fn construct<T, S>( ptr: &<CPU as Device>::Ptr<T, S>, len: usize, node: Node ) -> <CPU as CacheReturn>::CTwhere S: Shape,

fn destruct<T, S>( ct: &<CPU as CacheReturn>::CT, flag: AllocFlag ) -> (<CPU as Device>::Ptr<T, S>, Node)where S: Shape,

impl<T, D, S> Read<T, D, S> for CPUwhere D: MainMemory, S: Shape,

type Read = &'a [T]

fn read<'a>( &self, buf: &'a Buffer<'_, T, D, S> ) -> <CPU as Read<T, D, S>>::Read<'a>

Read the data of the Buffer as type Read.

fn read_to_vec<'a>(&self, buf: &Buffer<'_, T, D, S>) -> Vec<T, Global>where T: Default + Clone,

Read the data of a buffer into a vector

impl<T: Number, D: MainMemory, LS: Shape, RS: Shape> RowOp<T, LS, RS, D> for CPU

fn add_row( &self, lhs: &Matrix<'_, T, D, LS>, rhs: &Matrix<'_, T, D, RS> ) -> Matrix<'_, T, Self, LS>

fn add_row_mut(&self, lhs: &mut Matrix<'_, T, D, LS>, rhs: &Matrix<'_, T, D, RS>)

impl<T, D: MainMemory, S: Shape> ScalarAssign<T, S, D> for CPUwhere T: Copy + AddAssign + MulAssign + DivAssign + SubAssign,

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

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

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

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

impl<T: Float + GenericBlas + MatrixMultiply> SoftmaxOps<T, CPU> for CPUwhere CPU: ColOp<T>,

fn softmax(&self, inputs: &Matrix<'_, T>) -> Matrix<'_, T>

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

impl<T: Number, D: MainMemory, IS: Shape> SumOps<T, IS, D> for CPU

fn sum(&self, x: &Matrix<'_, T, D, IS>) -> T

fn mean(&self, x: &Matrix<'_, T, D, IS>) -> T

impl<T: Copy + Default + AddAssign, D: MainMemory, IS: Shape, OS: Shape> SumOverOps<T, IS, OS, D> for CPU

fn sum_rows(&self, x: &Matrix<'_, T, D, IS>) -> Matrix<'_, T, Self, OS>

fn sum_cols(&self, x: &Matrix<'_, T, D, IS>) -> Matrix<'_, T, Self, OS>

impl<T: Default + Copy, D: MainMemory, IS: Shape, OS: Shape> TransposeOp<T, IS, OS, D> for CPU

fn transpose(&self, x: &Matrix<'_, T, D, IS>) -> Matrix<'_, T, Self, OS>

impl<T, D> WriteBuf<T, D, ()> for CPUwhere T: Copy, D: MainMemory,

fn write(&self, buf: &mut Buffer<'_, T, D, ()>, data: &[T])

Write data to the buffer.

fn write_buf( &self, _dst: &mut Buffer<'_, T, Self, S>, _src: &Buffer<'_, T, Self, S> )

Writes data from Buffer to other Buffer.

impl<'a, T> DevicelessAble<'a, T, ()> for CPU