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<()>;
    fn abs_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn abs_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn pow_a_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn pow_at_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn pow_a_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn pow_at_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn pow_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn pow_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn rpow_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn rpow_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn exp_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn exp_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn ln_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn ln_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn log2_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn log2_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn log10_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn log10_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sin_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sin_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn cos_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn cos_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn tan_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn tan_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn asin_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn asin_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn acos_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn acos_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn atan_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn atan_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn atan2_a_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn atan2_at_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn atan2_a_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn atan2_at_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn atan2_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn atan2_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn ratan2_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn ratan2_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sinh_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn sinh_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn cosh_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn cosh_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn asinh_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn asinh_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn acosh_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn acosh_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn atanh_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn atanh_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn signum_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn signum_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn ceil_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn ceil_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn floor_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn floor_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn round_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn round_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn trunc_a(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn trunc_at(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn max_a_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn max_at_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn max_a_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn max_at_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn max_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn max_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn min_a_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn min_at_b(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn min_a_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn min_at_bt(
        &self,
        a: &BackendArray,
        b: &BackendArray,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn min_a_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &BackendArray,
        n: usize,
        m: usize,
    ) -> Result<()>;
    fn min_at_b_for_scalar(
        &self,
        a: &BackendArray,
        b: f32,
        c: &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{B}={\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_{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_{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_{ji}·b_{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_{ji}}{b_{ij}}$).

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

Divides thea matrix elements by the transposed b matrix elements and then the result is in the c matrix ($c_{ij}=\frac{a_{ij}}{b_{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_{ji}}{b_{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_{ji}}$).

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

Calculates sigmoid function for the a matrix and then the result is in 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 and then the result is in 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 roots of the a matrix elements and then the result is in the b matrix ($b_{ij}=\sqrt{a_{ij}}$).

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

Calculates square roots of the transposed a matrix elements and then the result is in the b matrix ($b_{ij}=\sqrt{a_{ji}}$).

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$).

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

Calculates absolute values of the a matrix elements and then the result is in the b matrix ($b_{ij}=\left|a_{ij}\right|$).

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

Calculates absolute values of the transposed a matrix elements and then the result is in the b matrix ($b_{ij}=\left|a_{ji}\right|$).

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

Raises the a matrix elements to the power of the b matrix elements and then the result is in the c matrix ($c_{ij}={a_{ij}}^{b_{ij}}$).

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

Raises the transposed a matrix elements to the power of the b matrix elements and then the result is in the c matrix ($c_{ij}={a_{ji}}^{b_{ij}}$).

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

Raises the a matrix elements to the power of the transposed b matrix elements and then the result is in the c matrix ($c_{ij}={a_{ij}}^{b_{ji}}$).

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

Raises the transposed a matrix elements to the power of the transposed b matrix elements and then the result is in the c matrix ($c_{ij}={a_{ji}}^{b_{ji}}$).

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

Raises the a matrix elements to the power of the b scalar and then the result is in the c matrix ($c_{ij}={a_{ij}}^b$).

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

Raises the transposed a matrix elements to the power of the b scalar and then the result is in the c matrix ($c_{ij}={a_{ji}}^b$).

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

Raises the b scalar to the power of the a matrix elements and then the result is in the c matrix ($c_{ij}=b^{a_{ij}}$).

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

Raises the b scalar to the power of the transposed a matrix elements and then the result is in the c matrix ($c_{ij}=b^{a_{ji}}$).

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

Calculates exponential function for the a matrix and then the result is in the b matrix ($b_{ij}=e^{a_{ij}}$).

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

Calculates exponential function for the transposed a matrix elements and then the result is in the b matrix ($b_{ij}=e^{a_{ji}}$).

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

Calculates natural logarithm of the a matrix elements and then the result is in the b matrix ($b_{ij}=\ln a_{ij}$).

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

Calculates natural logarithm of the transposed a matrix elements and then the result is in the b matrix ($b_{ij}=\ln a_{ji}$).

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

Calculates base 2 logarithm of the a matrix elements and then the result is in the b matrix ($b_{ij}={\log }_2{a}_{ij}$).

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

Calculates base 2 logarithm of the transposed a matrix elements and then the result is in the b matrix ($b_{ij}={\log }_2{a}_{ji}$).

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

Calculates base 10 logarithm of the a matrix elements and then the result is in the b matrix ($b_{ij}={\log }_{10}{a}_{ij}$).

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

Calculates base 10 logarithm of the transposed a matrix elements and then the result is in the b matrix ($b_{ij}={\log }_{10}{a}_{ji}$).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Calculates arctangent function for the a matrix elements and the b matrix elements and then the result is in the c matrix ($c_{ij}=\arctan \left(\frac{a_{ij}}{b_{ij}}\right)$).

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

Calculates arctangent function for the transposed a matrix elements and the b matrix elements and then the result is in the c matrix ($c_{ij}=\arctan \left(\frac{a_{ij}}{b_{ij}}\right)$).

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

Calculates arctangent function for the a matrix elements and the transposed b matrix elements and then the result is in the c matrix ($c_{ij}=\arctan \left(\frac{a_{ij}}{b_{ji}}\right)$).

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

Calculates arctangent function for the transposeda matrix elements and the transposed b matrix elements and then the result is in the c matrix ($c_{ij}=\arctan \left(\frac{a_{ji}}{b_{ji}}\right)$).

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

Calculates arctangent function for the a matrix elements and the b scalar and then the result is in the c matrix ($c_{ij}=\arctan \left(\frac{a_{ij}}{b}\right)$).

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

Calculates arctangent function for the transposed a matrix elements and the b scalar and then the result is in the c matrix ($c_{ij}=\arctan \left(\frac{a_{ji}}{b}\right)$).

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

Calculates arctangent function for the b scalar and the a matrix elements and then the result is in the c matrix ($c_{ij}=\arctan \left(\frac{b}{a_{ij}}\right)$).

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

Calculates arctangent function for the b scalar and the transposed a matrix elements and then the result is in the c matrix ($c_{ij}=\arctan \left(\frac{b}{a_{ji}}\right)$).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Finds maximum values between the a matrix elements and the b matrix elements and then the result is in the c matrix ($c_{ij}=\max (a_{ij},b_{ij})$).

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

Finds maximum values between the transposed a matrix elements and the b matrix elements and then the result is in the c matrix ($c_{ij}=\max (a_{ji},b_{ij})$).

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

Finds maximum values between the a matrix elements and the transposed b matrix elements and then the result is in the c matrix ($c_{ij}=\max (a_{ij},b_{ji})$).

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

Finds maximum values between the transposed a matrix elements and the transposed b matrix elements and then the result is in the c matrix ($c_{ij}=\max (a_{ji},b_{ji})$).

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

Finds maximum values between the a matrix elements and the b scalar and then the result is in the c matrix ($c_{ij}=\max (a_{ij},b)$).

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

Finds maximum values between the transposed a matrix elements and the b scalar and then the result is in the c matrix ($c_{ij}=\max (a_{ji},b)$).

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

Finds minimum values between the a matrix elements and the b matrix elements and then the result is in the c matrix ($c_{ij}=\min (a_{ij},b_{ij})$).

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

Finds minimum values between the transposed a matrix elements and the b matrix elements and then the result is in the c matrix ($c_{ij}=\min (a_{ji},b_{ij})$).

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

Finds minimum values between the a matrix elements and the transposed b matrix elements and then the result is in the c matrix ($c_{ij}=\min (a_{ij},b_{ji})$).

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

Finds minimum values between the transposed a matrix elements and the transposed b matrix elements and then the result is in the c matrix ($c_{ij}=\min (a_{ji},b_{ji})$).

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

Finds minimum values between the a matrix elements and the b scalar and then the result is in the c matrix ($c_{ij}=\min (a_{ij},b)$).

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

Finds minimum values between the transposed a matrix elements and the b scalar and then the result is in the c matrix ($c_{ij}=\min (a_{ji},b)$).

Implementors

impl Backend for CudaBackend

impl Backend for ClBackend