Struct CudaBackend 

pub struct CudaBackend { /* private fields */ }

A structure of CUDA backend.

Implementations

impl CudaBackend

pub fn new() -> Result<CudaBackend>

Creates a CUDA backend for a first device.

pub fn new_with_ordinal_and_flags( ordinal: usize, is_cublas: bool, is_mma: bool, ) -> Result<CudaBackend>

Creates a CUDA backend with the ordinal number and the flags.

This method takes the following flags:

• is_cublas - use the cuBLAS library to multiplication of matrices
• is_mma - use the mma instruction to multiplication of matrices

pub fn has_cublas(&self) -> bool

Trait Implementations

impl Backend for CudaBackend

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