4 Matrix

4.1 Declare matrix

You can declare matrix by various ways.
- R’s way - Default
- MATLAB’s way
- Python’s way
- Other macro

4.1.1 R’s way

Description: Same as R - matrix(Vector, Row, Col, Shape)

Type: matrix(Vec<T>, usize, usize, Shape) where T: std::convert::Into<f64> + Copy

Shape: Enum for matrix shape - Row & Col

fn main() {
    let a = matrix(c!(1,2,3,4), 2, 2, Row);
    a.print();
    //       c[0] c[1]
    // r[0]     1    2
    // r[1]     3    4

    let b = matrix(c!(1,2,3,4), 2, 2, Col);
    b.print();
    //       c[0] c[1]
    // r[0]     1    3
    // r[1]     2    4
}

4.1.2 MATLAB’s way

Description: Similar to MATLAB (But should use &str)

Type: ml_matrix(&str)

fn main() {
    let a = ml_matrix("1 2; 3 4");
    a.print();
    //       c[0] c[1]
    // r[0]     1    2
    // r[1]     3    4
}

4.1.3 Python’s way

Description: Declare matrix as vector of vectors.

Type: py_matrix(Vec<Vec<T>>) where T: std::convert::Into<f64> + Copy

fn main() {
    let a = py_matrix(vec![vec![1, 2], vec![3, 4]]);
    a.print();
    //       c[0] c[1]
    // r[0]     1    2
    // r[1]     3    4
}

4.1.4 Other macro

Description: R-like macro to declare matrix

For R,

# R
a = matrix(1:4:1, 2, 2, Row)
print(a)
#      [,1] [,2]
# [1,]    1    2
# [2,]    3    4

For Peroxide,

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    a.print();
    //       c[0] c[1]
    // r[0]     1    2
    // r[1]     3    4
}

4.2 Basic Method for Matrix

There are some useful methods for Matrix

row(&self, index: usize) -> Vec<f64> : Extract specific row as Vec<f64>
col(&self, index: usize) -> Vec<f64> : Extract specific column as Vec<f64>
diag(&self) -> Vec<f64>: Extract diagonal components as Vec<f64>
swap(&self, usize, usize, Shape) -> Matrix: Swap two rows or columns
subs_col(&mut self, usize, Vec<f64>): Substitute column with Vec<f64>

subs_row(&mut self, usize, Vec<f64>): Substitute row with Vec<f64>

fn main() {
    let a = ml_matrix("1 2; 3 4");

    a.row(0).print(); // [1, 2]
    a.col(0).print(); // [1, 3]
    a.diag().print(); // [1, 4]
    a.swap(0, 1, Row).print();
    //      c[0] c[1]
    // r[0]    3    4
    // r[1]    1    2

    let mut b = ml_matrix("1 2;3 4");
    b.subs_col(0, c!(5, 6));
    b.subs_row(1, c!(7, 8));
    b.print();
    //       c[0] c[1]
    // r[0]    5    2
    // r[1]    7    8
}

4.3 Read & Write

In peroxide, we can write matrix to csv or pickle.

4.3.1 CSV (Legacy)

write(&self, file_path: &str): Write matrix to csv

write_with_header(&self, file_path, header: Vec<&str>): Write with header

fn main() {
    let a = ml_matrix("1 2;3 4");
    a.write("matrix.csv").expect("Can't write file");

    let b = ml_matrix("1 2; 3 4; 5 6");
    b.write_with_header("header.csv", vec!["odd", "even"])
        .expect("Can't write header file");
}

Also, you can read matrix from csv.

Type: read(&str, bool, char) -> Result<Matrix, Box<Error>>

Description: read(file_path, is_header, delimiter)

fn main() {
    let a = read("matrix.csv", false, ',')
        .expect("Can't read matrix.csv file");
    a.print();
    //       c[0] c[1]
    // r[0]     1    2
    // r[1]     3    4
}

4.3.2 Pickle (Export as python object)

SimpleWriter : Struct to write pickle

Necessary method
- set_path : Set path
- insert_matrix or insert_vector
- write_pickle : Must be at last
Optional method
- set_round_level : Set round-off level
- insert_header : Insert header

fn main() {
    let a = ml_matrix("1 2;3 4");
    let v = c!(1,2,3,4);

    let mut wrt = SimpleWriter::new();
    wrt.set_path("data/sample.pickle")
        .insert_matrix(a)
        .insert_vector(v)
        .set_round_level(4)
        .write_pickle();
}

4.4 Concatenation

There are two options to concatenate matrices.

cbind: Concatenate two matrices by column direction.

rbind: Concatenate two matrices by row direction.

fn main() {
    let a = ml_matrix("1 2;3 4");
    let b = ml_matrix("5 6;7 8");

    cbind(a.clone(), b.clone()).print();
    //      c[0] c[1] c[2] c[3]
    // r[0]    1    2    5    7
    // r[1]    3    4    6    8

    rbind(a, b).print();
    //      c[0] c[1]
    // r[0]    1    2
    // r[1]    3    4
    // r[2]    5    6
    // r[3]    7    8
}

4.5 Matrix operations

In peroxide, can use basic operations between matrices. I’ll show you by examples.

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    (a.clone() + 1).print(); // -, *, / are also available
    //      c[0] c[1]
    // r[0]    2    3
    // r[1]    4    5

    let b = matrix!(5;8;1, 2, 2, Row);
    (a.clone() + b.clone()).print(); // - is also available
    //      c[0] c[1]
    // r[0]    6    8
    // r[1]   10   12

    (a.clone() * b.clone()).print(); // Matrix multiplication
    //      c[0] c[1]
    // r[0]   19   22
    // r[1]   43   50
}

clone is too annoying - We can use reference operations!

fn main() {
    let a = ml_matrix("1 2;3 4");
    let b = ml_matrix("5 6;7 8");

    (&a + 1).print();
    (&a + &b).print();
    (&a - &b).print();
    (&a * &b).print();
}

4.6 Extract & modify components

In peroxide, matrix data is saved as linear structure.

But you can use two-dimensional index to extract or modify components.

fn main() {
    let mut a = matrix!(1;4;1, 2, 2, Row);
    a[(0,0)].print(); // 1
    a[(0,0)] = 2f64; // Modify component
    a.print();
    //       c[0] c[1]
    //  r[0]    2    2
    //  r[1]    3    4
}

4.7 Conversion to vector

Just use row or col method (I already showed at Basic method section).

fn main() {
    let a = matrix!(1;4;1, 2, 2, Row);
    a.row(0).print(); // [1, 2]
}

4.8 Useful constructor

zeros(usize, usize): Construct matrix which elements are all zero
eye(usize): Identity matrix

rand(usize, usize): Construct random uniform matrix (from 0 to 1)

fn main() {
    let a = zeros(2, 2);
    assert_eq!(a, ml_matrix("0 0;0 0"));

    let b = eye(2);
    assert_eq!(b, ml_matrix("1 0;0 1"));

    let c = rand(2, 2);
    c.print(); // Random 2x2 matrix
}