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>) -> Frontend

Creates a frotend with the backend.

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

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 root of the a matrix and then the result is in the b matrix ($\mathbf{B}=\sqrt{\mathbf{A}}$).

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());