Trait Backend

pub trait Backend {
    // Required methods
    fn name(&self) -> &'static str;
    fn has_cublas(&self) -> bool;
    unsafe fn alloc(&self, n: usize) -> Result<BackendArray>;
    fn alloc_and_store_zeros(&self, n: usize) -> Result<BackendArray>;
    fn alloc_and_store(&self, elems: &[f32]) -> Result<BackendArray>;
    fn load(&self, a: &BackendArray, elems: &mut [f32]) -> Result<()>;
    fn store(&self, a: &BackendArray, elems: &[f32]) -> Result<()>;
    fn copy(&self, a: &BackendArray, b: &BackendArray) -> Result<()>;
    fn transpose_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn add_a_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn add_at_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn add_a_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn add_at_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sub_a_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sub_at_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sub_a_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sub_at_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn mul_a_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
        l: usize,
    ) -> Result<()>;
    fn mul_at_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
        l: usize,
    ) -> Result<()>;
    fn mul_a_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
        l: usize,
    ) -> Result<()>;
    fn mul_at_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
        l: usize,
    ) -> Result<()>;
    fn mul_a_b_for_elems(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn mul_at_b_for_elems(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn mul_a_bt_for_elems(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn mul_at_bt_for_elems(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn div_a_b_for_elems(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn div_at_b_for_elems(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn div_a_bt_for_elems(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn div_at_bt_for_elems(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn add_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn add_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sub_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sub_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn rsub_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn rsub_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn mul_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn mul_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn div_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn div_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn rdiv_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn rdiv_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sigmoid_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sigmoid_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn tanh_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn tanh_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn swish_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn swish_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn softmax_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn softmax_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sqrt_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sqrt_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn repeat_col_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn repeat_row_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
}

A backend trait.

The backend provides a low-level interface to computing platform (OpenCL or CUDA) for basic operations and functions on matrices. The backend methods operate on backend arrays which refers to areas of the device memory. The backend is low-level layer between a frontend and computing platform.

Required Methods

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

Returns the backend name.

fn has_cublas(&self) -> bool

Returns true if the backend uses cuBLAS, otherwise false.

unsafe fn alloc(&self, n: usize) -> Result<BackendArray>

Allocates a backend array.

fn alloc_and_store_zeros(&self, n: usize) -> Result<BackendArray>

Allocates a backend array and stores zeros in the backend array.

fn alloc_and_store(&self, elems: &[f32]) -> Result<BackendArray>

Allocates a backend array and stores the elements in the backend array.

fn load(&self, a: &BackendArray, elems: &mut [f32]) -> Result<()>

Loads elements from the backenc array.

fn store(&self, a: &BackendArray, elems: &[f32]) -> Result<()>

Stores elements in the backend array.

fn copy(&self, a: &BackendArray, b: &BackendArray) -> Result<()>

Copies the a backend array to the b backend array.

fn transpose_a( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Transposes the a matrix and then the result is in the b matrix ($\mathbf{C}={\mathbf{A}}^{\mathrm{T}}$).

fn add_a_b( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Adds the b matrix to the a matrix and then the result is in the c matrix ($\mathbf{C}=\mathbf{A}+\mathbf{B}$).

fn add_at_b( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Adds the b matrix to the transposed a matrix and then the result is in the c matrix ($\mathbf{C}={\mathbf{A}}^{\mathrm{T}}+\mathbf{B}$).

fn add_a_bt( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Adds the transposed b matrix to the a matrix and then the result is in the c matrix ($\mathbf{C}=\mathbf{A}+{\mathbf{B}}^{\mathrm{T}}$).

fn add_at_bt( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Adds the transposed b matrix to the transposed a matrix and then the result is in the c matrix ($\mathbf{C}={\mathbf{A}}^{\mathrm{T}}+{\mathbf{B}}^{\mathrm{T}}$).

fn sub_a_b( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Subtracts the b matrix from the a matrix and then the result is in the c matrix ($\mathbf{C}=\mathbf{A}-\mathbf{B}$).

fn sub_at_b( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Subtracts the b matrix from the transposed a matrix and then the result is in the c matrix ($\mathbf{C}={\mathbf{A}}^{\mathrm{T}}-\mathbf{B}$).

fn sub_a_bt( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Subtracts the transposed b matrix from the a matrix and then the result is in the c matrix ($\mathbf{C}=\mathbf{A}-{\mathbf{B}}^{\mathrm{T}}$).

fn sub_at_bt( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Subtracts the transposed b matrix from the transposed a matrix and then the result is in the c matrix ($\mathbf{C}={\mathbf{A}}^{\mathrm{T}}-{\mathbf{B}}^{\mathrm{T}}$).

fn mul_a_b( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, l: usize, ) -> Result<()>

Multiplies the a matrix by the b matrix and then the result is in the c matrix ($\mathbf{C}=\mathbf{A}·\mathbf{B}$).

fn mul_at_b( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, l: usize, ) -> Result<()>

Multiplies the transposed a matrix by the b matrix and then the result is in the c matrix ($\mathbf{C}={\mathbf{A}}^{\mathrm{T}}·\mathbf{B}$).

fn mul_a_bt( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, l: usize, ) -> Result<()>

Multiplies the a matrix by the transposed b matrix and then the result is in the c matrix ($\mathbf{C}=\mathbf{A}·{\mathbf{B}}^{\mathrm{T}}$).

fn mul_at_bt( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, l: usize, ) -> Result<()>

Multiplies the transposed a matrix by the transposed b matrix and then the result is in the c matrix ($\mathbf{C}={\mathbf{A}}^{\mathrm{T}}·{\mathbf{B}}^{\mathrm{T}}$).

fn mul_a_b_for_elems( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Multiplies the a matrix elements by the b matrix elements and then the result is in the c matrix ($c_{ij}=a_{ij}·b_{ij}$).

fn mul_at_b_for_elems( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Multiplies the transposed a matrix elements by the b matrix elements and saves the result to the c matrix ($c_{ij}=a_{\mathit{ji}}·b_{ij}$).

fn mul_a_bt_for_elems( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Multiplies the a matrix elements by the transposed b matrix elements and then the result is in the c matrix ($c_{ij}=a_{ij}·b_{\mathit{ji}}$).

fn mul_at_bt_for_elems( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Multiplies the transposed a matrix elements by the transposed b matrix elements and then the result is in the c matrix. ($c_{ij}=a_{\mathit{ji}}·b_{\mathit{ji}}$).

fn div_a_b_for_elems( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Divides the a matrix elements by the b matrix elements and then the result is in the c matrix ($c_{ij}=\frac{a_{ij}}{b_{ij}}$).

fn div_at_b_for_elems( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Divides the transposed a matrix elements by the b matrix elements and then the result is in the c matrix ($c_{ij}=\frac{a_{\mathit{ji}}}{b_{ij}}$).

fn div_a_bt_for_elems( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Divides the transposed a matrix elements by the b matrix elements and then the result is in the c matrix ($c_{ij}=\frac{a_{ij}}{b_{\mathit{ji}}}$).

fn div_at_bt_for_elems( &self, a: &BackendArray, b: &BackendArray, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Divides the transposed a matrix elements by the transposed b matrix elements and then the result is in the c matrix ($c_{ij}=\frac{a_{\mathit{ji}}}{b_{\mathit{ji}}}$).

fn add_a_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Adds the b scalar to the a matrix and then the result is in the c matrix ($\mathbf{C}=\mathbf{A}+b$).

fn add_at_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Adds the b scalar to the transposed a matrix and then the result is in the c matrix ($\mathbf{C}={\mathbf{A}}^{\mathrm{T}}+b$).

fn sub_a_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Subtracts the b scalar from the a matrix and then the result is in the c matrix. ($\mathbf{C}=\mathbf{A}-b$).

fn sub_at_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Subtracts the b scalar from the transposed a matrix and then the result is in the c matrix ($\mathbf{C}={\mathbf{A}}^{\mathrm{T}}-b$).

fn rsub_a_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Subtracts the a matrix from the b scalar and then the result is in the c matrix ($\mathbf{C}=b-\mathbf{A}$).

fn rsub_at_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Subtracts the transposed a matrix from the b scalar and then the result is in the c matrix ($\mathbf{C}=b-{\mathbf{A}}^{\mathrm{T}}$).

fn mul_a_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Multiplies the a matrix by the b scalar and then the result is in the c matrix ($\mathbf{C}=\mathbf{A}·b$).

fn mul_at_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Multiplies the transposed a matrix by the b scalar and then the result is in the c matrix ($\mathbf{C}={\mathbf{A}}^{\mathrm{T}}·b$).

fn div_a_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Divides the a matrix by the b scalar and then the result is in the c matrix ($\mathbf{C}=\frac{\mathbf{A}}{b}$).

fn div_at_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Divides the transposed a matrix by the b scalar and then the result is in the c matrix ($\mathbf{C}=\frac{{\mathbf{A}}^{\mathrm{T}}}{b}$).

fn rdiv_a_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Divides the b scalar by the a matrix elements and then the result is in the c matrix ($c_{ij}=\frac{b}{a_{ij}}$).

fn rdiv_at_b_for_scalar( &self, a: &BackendArray, b: f32, c: &BackendArray, n: usize, m: usize, ) -> Result<()>

Divides the b scalar by the transposed a matrix elements and then the result is in the c matrix ($c_{ij}=\frac{b}{a_{\mathit{ji}}}$).

fn sigmoid_a( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Calculates sigmoid function for the a matrix adn the result is the b matrix ($\mathbf{B}=\mathrm{sigmoid}\left(\mathbf{A}\right)$).

fn sigmoid_at( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Calculates sigmoid function for the transposed a matrix and then the result is in the b matrix ($\mathbf{B}=\mathrm{sigmoid}\left({\mathbf{A}}^{\mathrm{T}}\right)$).

fn tanh_a( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Calculates hyperbolic tangent function for the a matrix and then the result is in b matrix ($\mathbf{B}=\tanh \left(\mathbf{A}\right)$).

fn tanh_at( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Calculates hyperbolic tangent function for the transposed a matrix and then the result is in the b matrix ($\mathbf{B}=\tanh \left({\mathbf{A}}^{\mathrm{T}}\right)$).

fn swish_a( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Calculates swish function for the a matrix adn the result is the b matrix ($\mathbf{B}=\mathrm{swish}\left(\mathbf{A}\right)$).

fn swish_at( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Calculates swish function for the transposed a matrix and then the result is in the b matrix ($\mathbf{B}=\mathrm{swish}\left({\mathbf{A}}^{\mathrm{T}}\right)$).

fn softmax_a( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Calculates softmax function for the a matrix and then the result is in the b matrix ($\mathbf{B}=\mathrm{softmax}\left(\mathbf{A}\right)$).

fn softmax_at( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Calculates softmax function for the transposed a matrix and then the result is in the b matrix ($\mathbf{B}=\mathrm{softmax}\left({\mathbf{A}}^{\mathrm{T}}\right)$).

fn sqrt_a( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Calculates square root of the a matrix adn the result is the b matrix ($\mathbf{B}=\sqrt{\mathbf{A}}$).

fn sqrt_at( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Calculates square root of the transposed a matrix and then the result is in the b matrix ($\mathbf{B}=\sqrt{{\mathbf{A}}^{\mathrm{T}}}$).

fn repeat_col_a( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Repeats the a vector as column ($b_{ij}=a_i$).

fn repeat_row_a( &self, a: &BackendArray, b: &BackendArray, n: usize, m: usize, ) -> Result<()>

Repeats the a vector as row ($b_{ij}=a_j$).

Implementors

impl Backend for CudaBackend

impl Backend for ClBackend