Struct Matrix

pub struct Matrix { /* private fields */ }

A matrix structure.

Implementations

impl Matrix

pub fn new(row_count: usize, col_count: usize) -> Self

Creates a matrix with the number of rows and the number of columns.

pub fn new_with_elems(row_count: usize, col_count: usize, elems: &[f32]) -> Self

Creates a matrix with the number of rows, the number of columns, and the elements.

Examples found in repository

examples/mul.rs (line 21)

fn create_matrix(n: usize, m: usize) -> Matrix
{
    let mut elems: Vec<f32> = vec![0.0f32; n * m];
    for i in 0..n {
        for j in 0..m {
            elems[m * i + j] = (m * i + j) as f32;
        }
    }
    Matrix::new_with_elems(n, m, elems.as_slice())
}

examples/mul_bt.rs (line 21)

fn create_matrix(n: usize, m: usize) -> Matrix
{
    let mut elems: Vec<f32> = vec![0.0f32; n * m];
    for i in 0..n {
        for j in 0..m {
            elems[m * i + j] = (m * i + j) as f32;
        }
    }
    Matrix::new_with_elems(n, m, elems.as_slice())
}

examples/mad.rs (line 26)

fn create_matrix(n: usize, m: usize, is_scalar: bool) -> Matrix
{
    let mut elems: Vec<f32> = vec![0.0f32; n * m];
    let scalar = if is_scalar {
        (n * m) as f32
    } else {
        1.0f32
    };
    for i in 0..n {
        for j in 0..m {
            elems[m * i + j] = ((m * i + j) as f32) * scalar;
        }
    }
    Matrix::new_with_elems(n, m, elems.as_slice())
}

pub fn new_with_elem_vecs(elem_vecs: &[Vec<f32>]) -> Self

Creates a matrix with the vector of rows.

pub fn row_count(&self) -> usize

Returns the number of matrix rows.

Examples found in repository

examples/simple.rs (line 24)

fn main()
{
    let a = matrix![
        [1.0, 2.0, 3.0],
        [4.0, 5.0, 6.0],
        [7.0, 8.0, 9.0]
    ];
    let b = matrix![
        [1.0, 4.0, 7.0],
        [2.0, 5.0, 8.0],
        [3.0, 6.0, 9.0]
    ];
    let c = a * b;
    let elems = c.elems();
    for i in 0..c.row_count() {
        for j in 0..c.col_count() {
            print!("\t{}", elems[i * c.col_count() + j]);
        }
        println!("");
    }
}

pub fn col_count(&self) -> usize

Returns the number of matrix columns.

Examples found in repository

examples/simple.rs (line 25)

fn main()
{
    let a = matrix![
        [1.0, 2.0, 3.0],
        [4.0, 5.0, 6.0],
        [7.0, 8.0, 9.0]
    ];
    let b = matrix![
        [1.0, 4.0, 7.0],
        [2.0, 5.0, 8.0],
        [3.0, 6.0, 9.0]
    ];
    let c = a * b;
    let elems = c.elems();
    for i in 0..c.row_count() {
        for j in 0..c.col_count() {
            print!("\t{}", elems[i * c.col_count() + j]);
        }
        println!("");
    }
}

pub fn is_transposed(&self) -> bool

Returns true if the matrix is transposed, otherwise false.

This method indeed returns the transpose flag of matrix that is changed by transpose.

pub fn elems(&self) -> Vec<f32>

Returns the matrix elements.

Examples found in repository

examples/simple.rs (line 23)

fn main()
{
    let a = matrix![
        [1.0, 2.0, 3.0],
        [4.0, 5.0, 6.0],
        [7.0, 8.0, 9.0]
    ];
    let b = matrix![
        [1.0, 4.0, 7.0],
        [2.0, 5.0, 8.0],
        [3.0, 6.0, 9.0]
    ];
    let c = a * b;
    let elems = c.elems();
    for i in 0..c.row_count() {
        for j in 0..c.col_count() {
            print!("\t{}", elems[i * c.col_count() + j]);
        }
        println!("");
    }
}

examples/mul.rs (line 76)

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

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

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 copy(&self) -> Self

Creates a matrix copy.

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

pub fn transpose(&self) -> Self

Transposes the matrix (${\mathbf{A}}^{\mathrm{T}}$).

This method doesn’t indeed transpose the matrix but changes the transpose flag and exchanges the number of matrix rows with the number of matrix columns.

Examples

let a = matrix![
    [1.0, 2.0, 3.0],
    [4.0, 5.0, 6.0]
];
let b = a.transpose();
assert_eq!(3, b.row_count());
assert_eq!(2, b.col_count());
assert_eq!(true, b.is_transposed());
assert_eq!(a.elems(), b.elems());
let c = b.transpose();
assert_eq!(2, c.row_count());
assert_eq!(3, c.col_count());
assert_eq!(false, c.is_transposed());
assert_eq!(a.elems(), c.elems());

Examples found in repository

examples/mul_bt.rs (line 74)

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);
        },
    }
}

pub fn t(&self) -> Self

See transpose.

pub fn really_transpose(&self) -> Self

Indeed transposes the matrix (${\mathbf{A}}^{\mathrm{T}}$).

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

Examples

let a = matrix![
    [1.0, 2.0, 3.0],
    [4.0, 5.0, 6.0]
];
let b = a.really_transpose();
assert_eq!(3, b.row_count());
assert_eq!(2, b.col_count());
assert_eq!(false, b.is_transposed());
assert_eq!(vec![1.0, 4.0, 2.0, 5.0, 3.0, 6.0], b.elems());

pub fn rt(&self) -> Self

See really_transpose.

pub fn mul_elems(&self, b: &Self) -> Self

Multiplies the matrix elements by the b matrix elements ($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 = a.mul_elems(&b);
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, b: &Self) -> Self

Divides the matrix elements by the b matrix elements ($\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 = a.div_elems(&b);
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 rsub(&self, b: f32) -> Self

Subtracts the matrix from the scalar ($b-\mathbf{A}$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = a.rsub(10.5);
assert_eq!(vec![10.5 - 1.0, 10.5 - 2.0, 10.5 - 3.0, 10.5 - 4.0], b.elems());

pub fn rdiv(&self, b: f32) -> Self

Divides the scalar by the matrix elements ($\frac{b}{a_{ij}}$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = a.rdiv(10.5);
let elems = b.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) -> Self

Calculates sigmoid function for the matrix ($\mathrm{sigmoid}\left(\mathbf{A}\right)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = a.sigmoid();
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) -> Self

Calculates hiperbolic tangent function for the matrix ($\tanh \left(\mathbf{A}\right)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = a.tanh();
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) -> Self

Calculates swish function for the matrix ($\mathrm{swish}\left(\mathbf{A}\right)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = a.swish();
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) -> Self

Calculates softmax function for the matrix ($\mathrm{softmax}\left(\mathbf{A}\right)$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = a.softmax();
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) -> Self

Calculates square root of the matrix ($\sqrt{\mathbf{A}}$).

Examples

let a = matrix![
    [1.0, 2.0],
    [3.0, 4.0]
];
let b = a.sqrt();
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 repeat(&self, n: usize) -> Self

Repeats the vector as column or a row.

Examples

let a = matrix![
    [1.0],
    [2.0]
];
let b = a.repeat(3);
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 = c.repeat(2);
assert_eq!(vec![1.0, 2.0, 3.0, 1.0, 2.0, 3.0], d.elems());

Trait Implementations

impl Add<&Matrix> for &Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, rhs: &Matrix) -> Self::Output

Performs the + operation.

impl Add<&Matrix> for Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, rhs: &Matrix) -> Self::Output

Performs the + operation.

impl Add<&f32> for &Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, rhs: &f32) -> Self::Output

Performs the + operation.

impl Add<&f32> for Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, rhs: &f32) -> Self::Output

Performs the + operation.

impl Add<Matrix> for &Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, rhs: Matrix) -> Self::Output

Performs the + operation.

impl Add<f32> for &Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl Add<f32> for Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl Add for Matrix

type Output = Matrix

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl AddAssign<&Matrix> for Matrix

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl AddAssign<&f32> for Matrix

fn add_assign(&mut self, rhs: &f32)

Performs the += operation.

impl AddAssign<f32> for Matrix

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl AddAssign for Matrix

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Matrix

fn clone(&self) -> Matrix

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Matrix

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div<&f32> for &Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, rhs: &f32) -> Self::Output

Performs the / operation.

impl Div<&f32> for Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, rhs: &f32) -> Self::Output

Performs the / operation.

impl Div<f32> for &Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl Div<f32> for Matrix

type Output = Matrix

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl DivAssign<&f32> for Matrix

fn div_assign(&mut self, rhs: &f32)

Performs the /= operation.

impl DivAssign<f32> for Matrix

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl Mul<&Matrix> for &Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix) -> Self::Output

Performs the * operation.

impl Mul<&Matrix> for Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix) -> Self::Output

Performs the * operation.

impl Mul<&f32> for &Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, rhs: &f32) -> Self::Output

Performs the * operation.

impl Mul<&f32> for Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, rhs: &f32) -> Self::Output

Performs the * operation.

impl Mul<Matrix> for &Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix) -> Self::Output

Performs the * operation.

impl Mul<f32> for &Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl Mul<f32> for Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl Mul for Matrix

type Output = Matrix

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl MulAssign<&Matrix> for Matrix

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl MulAssign<&f32> for Matrix

fn mul_assign(&mut self, rhs: &f32)

Performs the *= operation.

impl MulAssign<f32> for Matrix

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign for Matrix

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Sub<&Matrix> for &Matrix

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, rhs: &Matrix) -> Self::Output

Performs the - operation.

impl Sub<&Matrix> for Matrix

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, rhs: &Matrix) -> Self::Output

Performs the - operation.

impl Sub<&f32> for &Matrix

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, rhs: &f32) -> Self::Output

Performs the - operation.

impl Sub<&f32> for Matrix

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, rhs: &f32) -> Self::Output

Performs the - operation.

impl Sub<Matrix> for &Matrix

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix) -> Self::Output

Performs the - operation.

impl Sub<f32> for &Matrix

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl Sub<f32> for Matrix

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl Sub for Matrix

type Output = Matrix

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl SubAssign<&Matrix> for Matrix

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl SubAssign<&f32> for Matrix

fn sub_assign(&mut self, rhs: &f32)

Performs the -= operation.

impl SubAssign<f32> for Matrix

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl SubAssign for Matrix

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.