Struct Frontend 

pub struct Frontend { /* private fields */ }

A frontend structure.

The frontend contains methods which operate on matrices or calculate functions for the matrices. Backend methods are called by the frontend to operate the matrices. The frontend is high-level layer that can be directly used by programmer or a Matrix structure.

Implementations

impl Frontend

pub fn new() -> Result<Frontend>

Creates a frontend with a default backend.

This method also automatically initializes a default backend if the default backend is uninitialized.

Examples found in repository

examples/mul.rs (line 63)

fn main()
{
    let args: Vec<String> = env::args().collect();
    let n: usize = match args.get(1) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_n) => tmp_n,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let m: usize = match args.get(2) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_m) => tmp_m,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let l: usize = match args.get(3) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_l) => tmp_l,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let frontend = match Frontend::new() {
        Ok(tmp_frontend) => tmp_frontend,
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    };
    println!("backend: {}", frontend.backend().name());
    let a = create_matrix(n, l);
    let b = create_matrix(l, m);
    let now = Instant::now();
    let c = a * b;
    let duration = now.elapsed();
    let elems = c.elems();
    let sum = elems.iter().fold(0.0f32, |x, y| x + y);
    println!("sum: {}", sum);
    println!("time: {}.{:06}", duration.as_secs(), duration.as_micros() % 1000000);
    match finalize_default_backend() {
        Ok(()) => (),
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    }
}

examples/mul_bt.rs (line 63)

fn main()
{
    let args: Vec<String> = env::args().collect();
    let n: usize = match args.get(1) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_n) => tmp_n,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let m: usize = match args.get(2) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_m) => tmp_m,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let l: usize = match args.get(3) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_l) => tmp_l,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let frontend = match Frontend::new() {
        Ok(tmp_frontend) => tmp_frontend,
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    };
    println!("backend: {}", frontend.backend().name());
    let a = create_matrix(n, l);
    let b = create_matrix(m, l);
    let now = Instant::now();
    let c = a * b.transpose();
    let duration = now.elapsed();
    let elems = c.elems();
    let sum = elems.iter().fold(0.0f32, |x, y| x + y);
    println!("sum: {}", sum);
    println!("time: {}.{:06}", duration.as_secs(), duration.as_micros() % 1000000);
    match finalize_default_backend() {
        Ok(()) => (),
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    }
}

examples/mad.rs (line 68)

fn main()
{
    let args: Vec<String> = env::args().collect();
    let n: usize = match args.get(1) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_n) => tmp_n,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let m: usize = match args.get(2) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_m) => tmp_m,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let l: usize = match args.get(3) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_l) => tmp_l,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let frontend = match Frontend::new() {
        Ok(tmp_frontend) => tmp_frontend,
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    };
    println!("backend: {}", frontend.backend().name());
    let a = create_matrix(n, l, false);
    let b = create_matrix(l, m, false);
    let c = create_matrix(n, m, true);
    let now = Instant::now();
    let d = a * b + c;
    let duration = now.elapsed();
    let elems = d.elems();
    let sum = elems.iter().fold(0.0f32, |x, y| x + y);
    println!("sum: {}", sum);
    println!("time: {}.{:06}", duration.as_secs(), duration.as_micros() % 1000000);
    match finalize_default_backend() {
        Ok(()) => (),
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    }
}

pub fn new_with_backend(backend: Arc<dyn Backend + Send + Sync>) -> Frontend

Creates a frotend with the backend.

pub fn backend(&self) -> Arc<dyn Backend + Send + Sync>

Returns the backend.

Examples found in repository

examples/mul.rs (line 70)

fn main()
{
    let args: Vec<String> = env::args().collect();
    let n: usize = match args.get(1) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_n) => tmp_n,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let m: usize = match args.get(2) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_m) => tmp_m,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let l: usize = match args.get(3) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_l) => tmp_l,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let frontend = match Frontend::new() {
        Ok(tmp_frontend) => tmp_frontend,
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    };
    println!("backend: {}", frontend.backend().name());
    let a = create_matrix(n, l);
    let b = create_matrix(l, m);
    let now = Instant::now();
    let c = a * b;
    let duration = now.elapsed();
    let elems = c.elems();
    let sum = elems.iter().fold(0.0f32, |x, y| x + y);
    println!("sum: {}", sum);
    println!("time: {}.{:06}", duration.as_secs(), duration.as_micros() % 1000000);
    match finalize_default_backend() {
        Ok(()) => (),
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    }
}

examples/mul_bt.rs (line 70)

fn main()
{
    let args: Vec<String> = env::args().collect();
    let n: usize = match args.get(1) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_n) => tmp_n,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let m: usize = match args.get(2) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_m) => tmp_m,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let l: usize = match args.get(3) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_l) => tmp_l,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let frontend = match Frontend::new() {
        Ok(tmp_frontend) => tmp_frontend,
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    };
    println!("backend: {}", frontend.backend().name());
    let a = create_matrix(n, l);
    let b = create_matrix(m, l);
    let now = Instant::now();
    let c = a * b.transpose();
    let duration = now.elapsed();
    let elems = c.elems();
    let sum = elems.iter().fold(0.0f32, |x, y| x + y);
    println!("sum: {}", sum);
    println!("time: {}.{:06}", duration.as_secs(), duration.as_micros() % 1000000);
    match finalize_default_backend() {
        Ok(()) => (),
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    }
}

examples/mad.rs (line 75)

fn main()
{
    let args: Vec<String> = env::args().collect();
    let n: usize = match args.get(1) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_n) => tmp_n,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let m: usize = match args.get(2) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_m) => tmp_m,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let l: usize = match args.get(3) {
        Some(s) => {
            match s.parse::<usize>() {
                Ok(tmp_l) => tmp_l,
                Err(err) => {
                    eprintln!("{}", err);
                    exit(1);
                },
            }
        },
        None => 100,
    };
    let frontend = match Frontend::new() {
        Ok(tmp_frontend) => tmp_frontend,
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    };
    println!("backend: {}", frontend.backend().name());
    let a = create_matrix(n, l, false);
    let b = create_matrix(l, m, false);
    let c = create_matrix(n, m, true);
    let now = Instant::now();
    let d = a * b + c;
    let duration = now.elapsed();
    let elems = d.elems();
    let sum = elems.iter().fold(0.0f32, |x, y| x + y);
    println!("sum: {}", sum);
    println!("time: {}.{:06}", duration.as_secs(), duration.as_micros() % 1000000);
    match finalize_default_backend() {
        Ok(()) => (),
        Err(err) => {
            eprintln!("{}", err);
            exit(1);
        },
    }
}

pub unsafe fn create_matrix( &self, row_count: usize, col_count: usize, ) -> Result<Matrix>

Creates a matrix with unset elements.

pub fn create_matrix_and_set_zeros( &self, row_count: usize, col_count: usize, ) -> Result<Matrix>

Creates a matrix and sets the matrix elements on zeros.

pub fn create_matrix_and_set_elems( &self, row_count: usize, col_count: usize, elems: &[f32], ) -> Result<Matrix>

Creates a matrix and sets the matrix elements.

pub fn set_elems(&self, a: &Matrix, elems: &[f32]) -> Result<()>

Sets the matrix elements.

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

Copies the a matrix to the b matrix.

This method indeed copies the a matrix array to the b matrix array.

pub fn get_elems_and_transpose_flag( &self, a: &Matrix, elems: &mut [f32], is_transposed: &mut bool, ) -> Result<()>

Copies the matrix elements to the mutable slice and the transpose flag to the object that is referred by the reference.

pub fn elems_and_transpose_flag(&self, a: &Matrix) -> Result<(Vec<f32>, bool)>

Returns the elements and the transpose flag of matrix.

pub fn add(&self, a: &Matrix, b: &Matrix, c: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = matrix![
    [5.0, 6.0],
    [7.0, 8.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.add(&a, &b, &c).unwrap();
assert_eq!(vec![1.0 + 5.0, 2.0 + 6.0, 3.0 + 7.0, 4.0 + 8.0], c.elems());

pub fn sub(&self, a: &Matrix, b: &Matrix, c: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = matrix![
    [5.0, 6.0],
    [7.0, 8.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.sub(&a, &b, &c).unwrap();
assert_eq!(vec![1.0 - 5.0, 2.0 - 6.0, 3.0 - 7.0, 4.0 - 8.0], c.elems());

pub fn mul(&self, a: &Matrix, b: &Matrix, c: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0, 3.0],
    [4.0, 5.0, 6.0]
];
let b = matrix![
    [7.0,  8.0],
    [9.0,  10.0],
    [11.0, 12.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.mul(&a, &b, &c).unwrap();
let c11: f32 = 1.0 * 7.0 + 2.0 * 9.0 + 3.0 * 11.0;
let c12: f32 = 1.0 * 8.0 + 2.0 * 10.0 + 3.0 * 12.0;
let c21: f32 = 4.0 * 7.0 + 5.0 * 9.0 + 6.0 * 11.0;
let c22: f32 = 4.0 * 8.0 + 5.0 * 10.0 + 6.0 * 12.0;
assert_eq!(vec![c11, c12, c21, c22], c.elems());

pub fn mul_elems(&self, a: &Matrix, b: &Matrix, c: &Matrix) -> 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}$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = matrix![
    [5.0, 6.0],
    [7.0, 8.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.mul_elems(&a, &b, &c).unwrap();
assert_eq!(vec![1.0 * 5.0, 2.0 * 6.0, 3.0 * 7.0, 4.0 * 8.0], c.elems());

pub fn div_elems(&self, a: &Matrix, b: &Matrix, c: &Matrix) -> 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}}$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = matrix![
    [5.0, 6.0],
    [7.0, 8.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.div_elems(&a, &b, &c).unwrap();
let elems = c.elems();
assert!((1.0 / 5.0 - elems[0]).abs() < 0.001);
assert!((2.0 / 6.0 - elems[1]).abs() < 0.001);
assert!((3.0 / 7.0 - elems[2]).abs() < 0.001);
assert!((4.0 / 8.0 - elems[3]).abs() < 0.001);

pub fn add_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.add_for_scalar(&a, 10.5, &c).unwrap();
assert_eq!(vec![1.0 + 10.5, 2.0 + 10.5, 3.0 + 10.5, 4.0 + 10.5], c.elems());

pub fn sub_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.sub_for_scalar(&a, 10.5, &c).unwrap();
assert_eq!(vec![1.0 - 10.5, 2.0 - 10.5, 3.0 - 10.5, 4.0 - 10.5], c.elems());

pub fn rsub_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.rsub_for_scalar(&a, 10.5, &c).unwrap();
assert_eq!(vec![10.5 - 1.0, 10.5 - 2.0, 10.5 - 3.0, 10.5 - 4.0], c.elems());

pub fn mul_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.mul_for_scalar(&a, 10.5, &c).unwrap();
assert_eq!(vec![1.0 * 10.5, 2.0 * 10.5, 3.0 * 10.5, 4.0 * 10.5], c.elems());

pub fn div_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.div_for_scalar(&a, 10.5, &c).unwrap();
let elems = c.elems();
assert!((1.0 / 10.5 - elems[0]).abs() < 0.001);
assert!((2.0 / 10.5 - elems[1]).abs() < 0.001);
assert!((3.0 / 10.5 - elems[2]).abs() < 0.001);
assert!((4.0 / 10.5 - elems[3]).abs() < 0.001);

pub fn rdiv_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> 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}}$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.rdiv_for_scalar(&a, 10.5, &c).unwrap();
let elems = c.elems();
assert!((10.5 / 1.0- elems[0]).abs() < 0.001);
assert!((10.5 / 2.0 - elems[1]).abs() < 0.001);
assert!((10.5 / 3.0 - elems[2]).abs() < 0.001);
assert!((10.5 / 4.0 - elems[3]).abs() < 0.001);

pub fn sigmoid(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.sigmoid(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0 / (1.0 + (-1.0f32).exp()) - elems[0]).abs() < 0.001);
assert!((1.0 / (1.0 + (-2.0f32).exp()) - elems[1]).abs() < 0.001);
assert!((1.0 / (1.0 + (-3.0f32).exp()) - elems[2]).abs() < 0.001);
assert!((1.0 / (1.0 + (-4.0f32).exp()) - elems[3]).abs() < 0.001);

pub fn tanh(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.tanh(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.tanh() - elems[0]).abs() < 0.001);
assert!((2.0f32.tanh() - elems[1]).abs() < 0.001);
assert!((3.0f32.tanh() - elems[2]).abs() < 0.001);
assert!((4.0f32.tanh() - elems[3]).abs() < 0.001);

pub fn swish(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.swish(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0 / (1.0 + (-1.0f32).exp()) - elems[0]).abs() < 0.001);
assert!((2.0 / (1.0 + (-2.0f32).exp()) - elems[1]).abs() < 0.001);
assert!((3.0 / (1.0 + (-3.0f32).exp()) - elems[2]).abs() < 0.001);
assert!((4.0 / (1.0 + (-4.0f32).exp()) - elems[3]).abs() < 0.001);

pub fn softmax(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.softmax(&a, &b).unwrap();
let elems = b.elems();
let sum1 = 1.0f32.exp() + 3.0f32.exp();
let sum2 = 2.0f32.exp() + 4.0f32.exp();
assert!((1.0f32.exp() / sum1 - elems[0]).abs() < 0.001);
assert!((2.0f32.exp() / sum2 - elems[1]).abs() < 0.001);
assert!((3.0f32.exp() / sum1 - elems[2]).abs() < 0.001);
assert!((4.0f32.exp() / sum2 - elems[3]).abs() < 0.001);

pub fn sqrt(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.sqrt(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.sqrt() - elems[0]).abs() < 0.001);
assert!((2.0f32.sqrt() - elems[1]).abs() < 0.001);
assert!((3.0f32.sqrt() - elems[2]).abs() < 0.001);
assert!((4.0f32.sqrt() - elems[3]).abs() < 0.001);

pub fn really_transpose(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

This method indeed transposes the a matrix without changing the transpose flag.

Examples

let a = matrix![
    [1.0, 2.0, 3.0],
    [4.0, 5.0, 6.0]
];
let b = Matrix::new(3, 2);
let frontend = Frontend::new().unwrap();
frontend.really_transpose(&a, &b).unwrap();
assert_eq!(vec![1.0, 4.0, 2.0, 5.0, 3.0, 6.0], b.elems());

pub fn repeat(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0],
    [2.0]
];
let b = Matrix::new(2, 3);
let frontend = Frontend::new().unwrap();
frontend.repeat(&a, &b).unwrap();
assert_eq!(vec![1.0, 1.0, 1.0, 2.0, 2.0, 2.0], b.elems());
let c = matrix![[1.0, 2.0, 3.0]];
let d = Matrix::new(2, 3);
let frontend = Frontend::new().unwrap();
frontend.repeat(&c, &d).unwrap();
assert_eq!(vec![1.0, 2.0, 3.0, 1.0, 2.0, 3.0], d.elems());

pub fn abs(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [-2.0, -1.0],
    [1.0, 2.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.abs(&a, &b).unwrap();
assert_eq!(vec![2.0, 1.0, 1.0, 2.0], b.elems());

pub fn pow(&self, a: &Matrix, b: &Matrix, c: &Matrix) -> 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}}$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = matrix![
    [3.0, 4.0],
    [5.0, 6.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.pow(&a, &b, &c).unwrap();
let elems = c.elems();
assert!((1.0f32.powf(3.0) - elems[0]).abs() < 0.001);
assert!((2.0f32.powf(4.0) - elems[1]).abs() < 0.001);
assert!((3.0f32.powf(5.0) - elems[2]).abs() < 0.001);
assert!((4.0f32.powf(6.0) - elems[3]).abs() < 0.001);

pub fn pow_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> 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$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.pow_for_scalar(&a, 2.5, &c).unwrap();
let elems = c.elems();
assert!((1.0f32.powf(2.5) - elems[0]).abs() < 0.001);
assert!((2.0f32.powf(2.5) - elems[1]).abs() < 0.001);
assert!((3.0f32.powf(2.5) - elems[2]).abs() < 0.001);
assert!((4.0f32.powf(2.5) - elems[3]).abs() < 0.001);

pub fn rpow_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> 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}}$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.rpow_for_scalar(&a, 10.5, &c).unwrap();
let elems = c.elems();
assert!((10.5f32.powf(1.0) - elems[0]).abs() < 0.001);
assert!((10.5f32.powf(2.0) - elems[1]).abs() < 0.001);
assert!((10.5f32.powf(3.0) - elems[2]).abs() < 0.001);
assert!((10.5f32.powf(4.0) - elems[3]).abs() < 0.001);

pub fn exp(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.exp(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.exp() - elems[0]).abs() < 0.001);
assert!((2.0f32.exp() - elems[1]).abs() < 0.001);
assert!((3.0f32.exp() - elems[2]).abs() < 0.001);
assert!((4.0f32.exp() - elems[3]).abs() < 0.001);

pub fn ln(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.ln(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.ln() - elems[0]).abs() < 0.001);
assert!((2.0f32.ln() - elems[1]).abs() < 0.001);
assert!((3.0f32.ln() - elems[2]).abs() < 0.001);
assert!((4.0f32.ln() - elems[3]).abs() < 0.001);

pub fn log2(&self, a: &Matrix, b: &Matrix) -> 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}$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.log2(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.log2() - elems[0]).abs() < 0.001);
assert!((2.0f32.log2() - elems[1]).abs() < 0.001);
assert!((3.0f32.log2() - elems[2]).abs() < 0.001);
assert!((4.0f32.log2() - elems[3]).abs() < 0.001);

pub fn log10(&self, a: &Matrix, b: &Matrix) -> 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}$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.log10(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.log10() - elems[0]).abs() < 0.001);
assert!((2.0f32.log10() - elems[1]).abs() < 0.001);
assert!((3.0f32.log10() - elems[2]).abs() < 0.001);
assert!((4.0f32.log10() - elems[3]).abs() < 0.001);

pub fn sin(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.sin(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.sin() - elems[0]).abs() < 0.001);
assert!((2.0f32.sin() - elems[1]).abs() < 0.001);
assert!((3.0f32.sin() - elems[2]).abs() < 0.001);
assert!((4.0f32.sin() - elems[3]).abs() < 0.001);

pub fn cos(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.cos(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.cos() - elems[0]).abs() < 0.001);
assert!((2.0f32.cos() - elems[1]).abs() < 0.001);
assert!((3.0f32.cos() - elems[2]).abs() < 0.001);
assert!((4.0f32.cos() - elems[3]).abs() < 0.001);

pub fn tan(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.tan(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.tan() - elems[0]).abs() < 0.001);
assert!((2.0f32.tan() - elems[1]).abs() < 0.001);
assert!((3.0f32.tan() - elems[2]).abs() < 0.001);
assert!((4.0f32.tan() - elems[3]).abs() < 0.001);

pub fn asin(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [0.25, 0.5],
    [0.75, 1.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.asin(&a, &b).unwrap();
let elems = b.elems();
assert!((0.25f32.asin() - elems[0]).abs() < 0.001);
assert!((0.5f32.asin() - elems[1]).abs() < 0.001);
assert!((0.75f32.asin() - elems[2]).abs() < 0.001);
assert!((1.0f32.asin() - elems[3]).abs() < 0.001);

pub fn acos(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [0.25, 0.5],
    [0.75, 1.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.acos(&a, &b).unwrap();
let elems = b.elems();
assert!((0.25f32.acos() - elems[0]).abs() < 0.001);
assert!((0.5f32.acos() - elems[1]).abs() < 0.001);
assert!((0.75f32.acos() - elems[2]).abs() < 0.001);
assert!((1.0f32.acos() - elems[3]).abs() < 0.001);

pub fn atan(&self, a: &Matrix, b: &Matrix) -> Result<()>

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

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.atan(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.atan() - elems[0]).abs() < 0.001);
assert!((2.0f32.atan() - elems[1]).abs() < 0.001);
assert!((3.0f32.atan() - elems[2]).abs() < 0.001);
assert!((4.0f32.atan() - elems[3]).abs() < 0.001);

pub fn atan2(&self, a: &Matrix, b: &Matrix, c: &Matrix) -> 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)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = matrix![
    [5.0, 6.0],
    [7.0, 8.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.atan2(&a, &b, &c).unwrap();
let elems = c.elems();
assert!((1.0f32.atan2(5.0) - elems[0]).abs() < 0.001);
assert!((2.0f32.atan2(6.0) - elems[1]).abs() < 0.001);
assert!((3.0f32.atan2(7.0) - elems[2]).abs() < 0.001);
assert!((4.0f32.atan2(8.0) - elems[3]).abs() < 0.001);

pub fn atan2_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> 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)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.atan2_for_scalar(&a, 10.5, &c).unwrap();
let elems = c.elems();
assert!((1.0f32.atan2(10.5) - elems[0]).abs() < 0.001);
assert!((2.0f32.atan2(10.5) - elems[1]).abs() < 0.001);
assert!((3.0f32.atan2(10.5) - elems[2]).abs() < 0.001);
assert!((4.0f32.atan2(10.5) - elems[3]).abs() < 0.001);

pub fn ratan2_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> 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)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.ratan2_for_scalar(&a, 10.5, &c).unwrap();
let elems = c.elems();
assert!((10.5f32.atan2(1.0) - elems[0]).abs() < 0.001);
assert!((10.5f32.atan2(2.0) - elems[1]).abs() < 0.001);
assert!((10.5f32.atan2(3.0) - elems[2]).abs() < 0.001);
assert!((10.5f32.atan2(4.0) - elems[3]).abs() < 0.001);

pub fn sinh(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.sinh(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.sinh() - elems[0]).abs() < 0.001);
assert!((2.0f32.sinh() - elems[1]).abs() < 0.001);
assert!((3.0f32.sinh() - elems[2]).abs() < 0.001);
assert!((4.0f32.sinh() - elems[3]).abs() < 0.001);

pub fn cosh(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.cosh(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.cosh() - elems[0]).abs() < 0.001);
assert!((2.0f32.cosh() - elems[1]).abs() < 0.001);
assert!((3.0f32.cosh() - elems[2]).abs() < 0.001);
assert!((4.0f32.cosh() - elems[3]).abs() < 0.001);

pub fn asinh(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.asinh(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.asinh() - elems[0]).abs() < 0.001);
assert!((2.0f32.asinh() - elems[1]).abs() < 0.001);
assert!((3.0f32.asinh() - elems[2]).abs() < 0.001);
assert!((4.0f32.asinh() - elems[3]).abs() < 0.001);

pub fn acosh(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.acosh(&a, &b).unwrap();
let elems = b.elems();
assert!((1.0f32.acosh() - elems[0]).abs() < 0.001);
assert!((2.0f32.acosh() - elems[1]).abs() < 0.001);
assert!((3.0f32.acosh() - elems[2]).abs() < 0.001);
assert!((4.0f32.acosh() - elems[3]).abs() < 0.001);

pub fn atanh(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [0.25, 0.5],
    [0.75, 1.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.atanh(&a, &b).unwrap();
let elems = b.elems();
assert!((0.25f32.atanh() - elems[0]).abs() < 0.001);
assert!((0.5f32.atanh() - elems[1]).abs() < 0.001);
assert!((0.75f32.atanh() - elems[2]).abs() < 0.001);
assert_eq!(f32::INFINITY, elems[3]);

pub fn signum(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [-2.0, -1.0],
    [1.0, 2.0]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.signum(&a, &b).unwrap();
assert_eq!(vec![-1.0, -1.0, 1.0, 1.0], b.elems());

pub fn ceil(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [-2.6, -1.3],
    [1.3, 2.6]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.ceil(&a, &b).unwrap();
assert_eq!(vec![-2.0, -1.0, 2.0, 3.0], b.elems());

pub fn floor(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [-2.6, -1.3],
    [1.3, 2.6]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.floor(&a, &b).unwrap();
assert_eq!(vec![-3.0, -2.0, 1.0, 2.0], b.elems());

pub fn round(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [-2.6, -1.3],
    [1.3, 2.6]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.round(&a, &b).unwrap();
assert_eq!(vec![-3.0, -1.0, 1.0, 3.0], b.elems());

pub fn trunc(&self, a: &Matrix, b: &Matrix) -> 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)$).

Examples

let a = matrix![
    [-2.6, -1.3],
    [1.3, 2.6]
];
let b = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.trunc(&a, &b).unwrap();
assert_eq!(vec![-2.0, -1.0, 1.0, 2.0], b.elems());

pub fn max(&self, a: &Matrix, b: &Matrix, c: &Matrix) -> 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})$).

Examples

let a = matrix![
    [-2.0, -1.0],
    [1.0, 2.0]
];
let b = matrix![
    [4.0, 2.0],
    [-2.0, -4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.max(&a, &b, &c).unwrap();
assert_eq!(vec![4.0, 2.0, 1.0, 2.0], c.elems());

pub fn max_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> 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)$).

Examples

let a = matrix![
    [-2.0, -1.0],
    [1.0, 2.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.max_for_scalar(&a, 0.0, &c).unwrap();
assert_eq!(vec![0.0, 0.0, 1.0, 2.0], c.elems());

pub fn min(&self, a: &Matrix, b: &Matrix, c: &Matrix) -> 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})$).

Examples

let a = matrix![
    [-2.0, -1.0],
    [1.0, 2.0]
];
let b = matrix![
    [4.0, 2.0],
    [-2.0, -4.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.min(&a, &b, &c).unwrap();
assert_eq!(vec![-2.0, -1.0, -2.0, -4.0], c.elems());

pub fn min_for_scalar(&self, a: &Matrix, b: f32, c: &Matrix) -> 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)$).

Examples

let a = matrix![
    [-2.0, -1.0],
    [1.0, 2.0]
];
let c = Matrix::new(2, 2);
let frontend = Frontend::new().unwrap();
frontend.min_for_scalar(&a, 0.0, &c).unwrap();
assert_eq!(vec![-2.0, -1.0, 0.0, 0.0], c.elems());