Struct Matrix 

pub struct Matrix<T> { /* private fields */ }

The Matrix struct.

Can be instantiated with any type.

Implementations

impl<T> Matrix<T>

where T: Any + Float,

pub fn qr_decomp(self) -> Result<(Matrix<T>, Matrix<T>), Error>

Compute the QR decomposition of the matrix.

Returns the tuple (Q,R).

Examples

use rulinalg::matrix::Matrix;

let m = Matrix::new(3,3, vec![1.0,0.5,0.5,0.5,1.0,0.5,0.5,0.5,1.0]);

let (q, r) = m.qr_decomp().unwrap();

Failures

• Cannot compute the QR decomposition.

impl<T> Matrix<T>

where T: Any + Float,

pub fn cholesky(&self) -> Result<Matrix<T>, Error>

Cholesky decomposition

Returns the cholesky decomposition of a positive definite matrix.

Examples

use rulinalg::matrix::Matrix;

let m = Matrix::new(3,3, vec![1.0,0.5,0.5,0.5,1.0,0.5,0.5,0.5,1.0]);

let l = m.cholesky();

Panics

• The matrix is not square.

Failures

• Matrix is not positive definite.

impl<T> Matrix<T>

where T: Any + Float,

pub fn bidiagonal_decomp( self, ) -> Result<(Matrix<T>, Matrix<T>, Matrix<T>), Error>

Converts matrix to bidiagonal form

Returns (B, U, V), where B is bidiagonal and self = U B V_T.

Note that if self has self.rows() > self.cols() the matrix will be transposed and then reduced - this will lead to a sub-diagonal instead of super-diagonal.

Failures

• The matrix cannot be reduced to bidiagonal form.

impl<T> Matrix<T>

where T: Any + Float + Signed,

pub fn svd(self) -> Result<(Matrix<T>, Matrix<T>, Matrix<T>), Error>

Singular Value Decomposition

Computes the SVD using the Golub-Reinsch algorithm.

Returns Σ, U, V, such that self = U Σ V^T. Σ is a diagonal matrix whose elements correspond to the non-negative singular values of the matrix. The singular values are ordered in non-increasing order. U and V have orthonormal columns, and each column represents the left and right singular vectors for the corresponding singular value in Σ, respectively.

If self has M rows and N columns, the dimensions of the returned matrices are as follows.

If M >= N:

• Σ: N x N
• U: M x N
• V: N x N

If M < N:

• Σ: M x M
• U: M x M
• V: N x M

Note: This version of the SVD is sometimes referred to as the ‘economy SVD’.

Failures

This function may fail in some cases. The current decomposition whilst being efficient is fairly basic. Hopefully the algorithm can be made not to fail in the near future.

impl<T> Matrix<T>

where T: Any + Float,

pub fn upper_hessenberg(self) -> Result<Matrix<T>, Error>

Returns H, where H is the upper hessenberg form.

If the transformation matrix is also required, you should use upper_hess_decomp.

Examples

use rulinalg::matrix::Matrix;

let a = Matrix::new(4,4,vec![2.,0.,1.,1.,2.,0.,1.,2.,1.,2.,0.,0.,2.,0.,1.,1.]);
let h = a.upper_hessenberg();

println!("{:?}", h.expect("Could not get upper Hessenberg form.").data());

Panics

• The matrix is not square.

Failures

• The matrix cannot be reduced to upper hessenberg form.

pub fn upper_hess_decomp(self) -> Result<(Matrix<T>, Matrix<T>), Error>

Returns (U,H), where H is the upper hessenberg form and U is the unitary transform matrix.

Note: The current transform matrix seems broken…

Examples

use rulinalg::matrix::{Matrix, BaseMatrix};

let a = Matrix::new(3,3,vec![1.,2.,3.,4.,5.,6.,7.,8.,9.]);

// u is the transform, h is the upper hessenberg form.
let (u,h) = a.clone().upper_hess_decomp().expect("This matrix should decompose!");

println!("The hess : {:?}", h.data());
println!("Manual hess : {:?}", (u.transpose() * a * u).data());

Panics

• The matrix is not square.

Failures

• The matrix cannot be reduced to upper hessenberg form.

impl<T> Matrix<T>

where T: Any + Float,

pub fn lup_decomp(&self) -> Result<(Matrix<T>, Matrix<T>, Matrix<T>), Error>

Computes L, U, and P for LUP decomposition.

Returns L,U, and P respectively.

Examples

use rulinalg::matrix::Matrix;

let a = Matrix::new(3,3, vec![1.0,2.0,0.0,
                              0.0,3.0,4.0,
                              5.0, 1.0, 2.0]);

let (l,u,p) = a.lup_decomp().expect("This matrix should decompose!");

Panics

• Matrix is not square.

Failures

• Matrix cannot be LUP decomposed.

impl<T> Matrix<T>

where T: Any + Float + Signed,

pub fn eigenvalues(&self) -> Result<Vec<T>, Error>

Eigenvalues of a square matrix.

Returns a Vec of eigenvalues.

Examples

use rulinalg::matrix::Matrix;

let a = Matrix::new(4,4, (1..17).map(|v| v as f64).collect::<Vec<f64>>());
let e = a.eigenvalues().expect("We should be able to compute these eigenvalues!");
println!("{:?}", e);

Panics

• The matrix is not square.

Failures

• Eigenvalues cannot be computed.

pub fn eigendecomp(&self) -> Result<(Vec<T>, Matrix<T>), Error>

Eigendecomposition of a square matrix.

Returns a Vec of eigenvalues, and a matrix with eigenvectors as the columns.

The eigenvectors are only gauranteed to be correct if the matrix is real-symmetric.

Examples

use rulinalg::matrix::Matrix;

let a = Matrix::new(3,3,vec![3.,2.,4.,2.,0.,2.,4.,2.,3.]);

let (e, m) = a.eigendecomp().expect("We should be able to compute this eigendecomp!");
println!("{:?}", e);
println!("{:?}", m.data());

Panics

• The matrix is not square.

Failures

• The eigen decomposition can not be computed.

impl<T> Matrix<T>

pub fn new<U>(rows: usize, cols: usize, data: U) -> Matrix<T>

where U: Into<Vec<T>>,

Constructor for Matrix struct.

Requires both the row and column dimensions.

Examples

use rulinalg::matrix::{Matrix, BaseMatrix};

let mat = Matrix::new(2,2, vec![1.0,2.0,3.0,4.0]);

assert_eq!(mat.rows(), 2);
assert_eq!(mat.cols(), 2);

Panics

• The input data does not match the given dimensions.

Examples found in repository

examples/k-means_generating_cluster.rs (lines 39-41)

fn generate_data(centroids: &Matrix<f64>,
                 points_per_centroid: usize,
                 noise: f64)
                 -> Matrix<f64> {
    assert!(centroids.cols() > 0, "Centroids cannot be empty.");
    assert!(centroids.rows() > 0, "Centroids cannot be empty.");
    assert!(noise >= 0f64, "Noise must be non-negative.");
    let mut raw_cluster_data = Vec::with_capacity(centroids.rows() * points_per_centroid *
                                                  centroids.cols());

    let mut rng = thread_rng();
    let normal_rv = Normal::new(0f64, noise);

    for _ in 0..points_per_centroid {
        // Generate points from each centroid
        for centroid in centroids.iter_rows() {
            // Generate a point randomly around the centroid
            let mut point = Vec::with_capacity(centroids.cols());
            for feature in centroid {
                point.push(feature + normal_rv.ind_sample(&mut rng));
            }

            // Push point to raw_cluster_data
            raw_cluster_data.extend(point);
        }
    }

    Matrix::new(centroids.rows() * points_per_centroid,
                centroids.cols(),
                raw_cluster_data)
}

fn main() {
    println!("K-Means clustering example:");

    const SAMPLES_PER_CENTROID: usize = 2000;

    println!("Generating {0} samples from each centroids:",
             SAMPLES_PER_CENTROID);
    // Choose two cluster centers, at (-0.5, -0.5) and (0, 0.5).
    let centroids = Matrix::new(2, 2, vec![-0.5, -0.5, 0.0, 0.5]);
    println!("{}", centroids);

    // Generate some data randomly around the centroids
    let samples = generate_data(&centroids, SAMPLES_PER_CENTROID, 0.4);

    // Create a new model with 2 clusters
    let mut model = KMeansClassifier::new(2);

    // Train the model
    println!("Training the model...");
    // Our train function returns a Result<(), E>
    model.train(&samples).unwrap();

    let centroids = model.centroids().as_ref().unwrap();
    println!("Model Centroids:\n{:.3}", centroids);

    // Predict the classes and partition into
    println!("Classifying the samples...");
    let classes = model.predict(&samples).unwrap();
    let (first, second): (Vec<usize>, Vec<usize>) = classes.data().iter().partition(|&x| *x == 0);

    println!("Samples closest to first centroid: {}", first.len());
    println!("Samples closest to second centroid: {}", second.len());
}

examples/svm-sign_learner.rs (lines 22-25)

fn main() {
    println!("Sign learner sample:");

    println!("Training...");
    // Training data
    let inputs = Matrix::new(11, 1, vec![
                             -0.1, -2., -9., -101., -666.7,
                             0., 0.1, 1., 11., 99., 456.7
                             ]);
    let targets = Vector::new(vec![
                              -1., -1., -1., -1., -1.,
                              1., 1., 1., 1., 1., 1.
                              ]);

    // Trainee
    let mut svm_mod = SVM::new(HyperTan::new(100., 0.), 0.3);
    // Our train function returns a Result<(), E>
    svm_mod.train(&inputs, &targets).unwrap();

    println!("Evaluation...");
    let mut hits = 0;
    let mut misses = 0;
    // Evaluation
    //   Note: We could pass all input values at once to the `predict` method!
    //         Here, we use a loop just to count and print logs.
    for n in (-1000..1000).filter(|&x| x % 100 == 0) {
        let nf = n as f64;
        let input = Matrix::new(1, 1, vec![nf]);
        let out = svm_mod.predict(&input).unwrap();
        let res = if out[0] * nf > 0. {
            hits += 1;
            true
        } else if nf == 0. {
            hits += 1;
            true
        } else {
            misses += 1;
            false
        };

        println!("{} -> {}: {}", Matrix::data(&input)[0], out[0], res);
    }

    println!("Performance report:");
    println!("Hits: {}, Misses: {}", hits, misses);
    let hits_f = hits as f64;
    let total = (hits + misses) as f64;
    println!("Accuracy: {}", (hits_f / total) * 100.);
}

examples/nnet-and_gate.rs (line 39)

fn main() {
    println!("AND gate learner sample:");

    const THRESHOLD: f64 = 0.7;

    const SAMPLES: usize = 10000;
    println!("Generating {} training data and labels...", SAMPLES as u32);

    let mut input_data = Vec::with_capacity(SAMPLES * 2);
    let mut label_data = Vec::with_capacity(SAMPLES);

    for _ in 0..SAMPLES {
        // The two inputs are "signals" between 0 and 1
        let Closed01(left) = random::<Closed01<f64>>();
        let Closed01(right) = random::<Closed01<f64>>();
        input_data.push(left);
        input_data.push(right);
        if left > THRESHOLD && right > THRESHOLD {
            label_data.push(1.0);
        } else {
            label_data.push(0.0)
        }
    }

    let inputs = Matrix::new(SAMPLES, 2, input_data);
    let targets = Matrix::new(SAMPLES, 1, label_data);

    let layers = &[2, 1];
    let criterion = BCECriterion::new(Regularization::L2(0.));
    let mut model = NeuralNet::new(layers, criterion, StochasticGD::default());

    println!("Training...");
    // Our train function returns a Result<(), E>
    model.train(&inputs, &targets).unwrap();

    let test_cases = vec![
        0.0, 0.0,
        0.0, 1.0,
        1.0, 1.0,
        1.0, 0.0,
        ];
    let expected = vec![
        0.0,
        0.0,
        1.0,
        0.0,
        ];
    let test_inputs = Matrix::new(test_cases.len() / 2, 2, test_cases);
    let res = model.predict(&test_inputs).unwrap();

    println!("Evaluation...");
    let mut hits = 0;
    let mut misses = 0;
    // Evaluation
    println!("Got\tExpected");
    for (idx, prediction) in res.into_vec().iter().enumerate() {
        println!("{:.2}\t{}", prediction, expected[idx]);
        if (prediction - 0.5) * (expected[idx] - 0.5) > 0. {
            hits += 1;
        } else {
            misses += 1;
        }
    }

    println!("Hits: {}, Misses: {}", hits, misses);
    let hits_f = hits as f64;
    let total = (hits + misses) as f64;
    println!("Accuracy: {}%", (hits_f / total) * 100.);
}

pub fn from_fn<F>(rows: usize, cols: usize, f: F) -> Matrix<T>

where F: FnMut(usize, usize) -> T,

Constructor for Matrix struct that takes a function f and constructs a new matrix such that A_ij = f(i, j), where i is the row index and j the column index.

Requires both the row and column dimensions as well as a generating function.

Examples

use rulinalg::matrix::{Matrix, BaseMatrix};

// Let's assume you have an array of "things" for
// which you want to generate a distance matrix:
let things: [i32; 3] = [1, 2, 3];
let distances: Matrix<f64> = Matrix::from_fn(things.len(), things.len(), |col, row| {
    (things[col] - things[row]).abs().into()
});

assert_eq!(distances.rows(), 3);
assert_eq!(distances.cols(), 3);
assert_eq!(distances.data(), &vec![
    0.0, 1.0, 2.0,
    1.0, 0.0, 1.0,
    2.0, 1.0, 0.0,
]);

pub fn data(&self) -> &Vec<T>

Returns a non-mutable reference to the underlying data.

Examples found in repository

examples/svm-sign_learner.rs (line 57)

fn main() {
    println!("Sign learner sample:");

    println!("Training...");
    // Training data
    let inputs = Matrix::new(11, 1, vec![
                             -0.1, -2., -9., -101., -666.7,
                             0., 0.1, 1., 11., 99., 456.7
                             ]);
    let targets = Vector::new(vec![
                              -1., -1., -1., -1., -1.,
                              1., 1., 1., 1., 1., 1.
                              ]);

    // Trainee
    let mut svm_mod = SVM::new(HyperTan::new(100., 0.), 0.3);
    // Our train function returns a Result<(), E>
    svm_mod.train(&inputs, &targets).unwrap();

    println!("Evaluation...");
    let mut hits = 0;
    let mut misses = 0;
    // Evaluation
    //   Note: We could pass all input values at once to the `predict` method!
    //         Here, we use a loop just to count and print logs.
    for n in (-1000..1000).filter(|&x| x % 100 == 0) {
        let nf = n as f64;
        let input = Matrix::new(1, 1, vec![nf]);
        let out = svm_mod.predict(&input).unwrap();
        let res = if out[0] * nf > 0. {
            hits += 1;
            true
        } else if nf == 0. {
            hits += 1;
            true
        } else {
            misses += 1;
            false
        };

        println!("{} -> {}: {}", Matrix::data(&input)[0], out[0], res);
    }

    println!("Performance report:");
    println!("Hits: {}, Misses: {}", hits, misses);
    let hits_f = hits as f64;
    let total = (hits + misses) as f64;
    println!("Accuracy: {}", (hits_f / total) * 100.);
}

pub fn mut_data(&mut self) -> &mut [T]

Returns a mutable slice of the underlying data.

pub fn into_vec(self) -> Vec<T>

Consumes the Matrix and returns the Vec of data.

Examples found in repository

examples/nnet-and_gate.rs (line 70)

fn main() {
    println!("AND gate learner sample:");

    const THRESHOLD: f64 = 0.7;

    const SAMPLES: usize = 10000;
    println!("Generating {} training data and labels...", SAMPLES as u32);

    let mut input_data = Vec::with_capacity(SAMPLES * 2);
    let mut label_data = Vec::with_capacity(SAMPLES);

    for _ in 0..SAMPLES {
        // The two inputs are "signals" between 0 and 1
        let Closed01(left) = random::<Closed01<f64>>();
        let Closed01(right) = random::<Closed01<f64>>();
        input_data.push(left);
        input_data.push(right);
        if left > THRESHOLD && right > THRESHOLD {
            label_data.push(1.0);
        } else {
            label_data.push(0.0)
        }
    }

    let inputs = Matrix::new(SAMPLES, 2, input_data);
    let targets = Matrix::new(SAMPLES, 1, label_data);

    let layers = &[2, 1];
    let criterion = BCECriterion::new(Regularization::L2(0.));
    let mut model = NeuralNet::new(layers, criterion, StochasticGD::default());

    println!("Training...");
    // Our train function returns a Result<(), E>
    model.train(&inputs, &targets).unwrap();

    let test_cases = vec![
        0.0, 0.0,
        0.0, 1.0,
        1.0, 1.0,
        1.0, 0.0,
        ];
    let expected = vec![
        0.0,
        0.0,
        1.0,
        0.0,
        ];
    let test_inputs = Matrix::new(test_cases.len() / 2, 2, test_cases);
    let res = model.predict(&test_inputs).unwrap();

    println!("Evaluation...");
    let mut hits = 0;
    let mut misses = 0;
    // Evaluation
    println!("Got\tExpected");
    for (idx, prediction) in res.into_vec().iter().enumerate() {
        println!("{:.2}\t{}", prediction, expected[idx]);
        if (prediction - 0.5) * (expected[idx] - 0.5) > 0. {
            hits += 1;
        } else {
            misses += 1;
        }
    }

    println!("Hits: {}, Misses: {}", hits, misses);
    let hits_f = hits as f64;
    let total = (hits + misses) as f64;
    println!("Accuracy: {}%", (hits_f / total) * 100.);
}

impl<T> Matrix<T>

where T: Clone + Zero,

pub fn zeros(rows: usize, cols: usize) -> Matrix<T>

Constructs matrix of all zeros.

Requires both the row and the column dimensions.

Examples

use rulinalg::matrix::Matrix;

let mat = Matrix::<f64>::zeros(2,3);

pub fn from_diag(diag: &[T]) -> Matrix<T>

Constructs matrix with given diagonal.

Requires slice of diagonal elements.

Examples

use rulinalg::matrix::Matrix;

let mat = Matrix::from_diag(&vec![1.0,2.0,3.0,4.0]);

impl<T> Matrix<T>

where T: Clone + One,

pub fn ones(rows: usize, cols: usize) -> Matrix<T>

Constructs matrix of all ones.

Requires both the row and the column dimensions.

Examples

use rulinalg::matrix::Matrix;

let mat = Matrix::<f64>::ones(2,3);

impl<T> Matrix<T>

where T: Clone + Zero + One,

pub fn identity(size: usize) -> Matrix<T>

Constructs the identity matrix.

Requires the size of the matrix.

Examples

use rulinalg::matrix::Matrix;

let I = Matrix::<f64>::identity(4);

impl<T> Matrix<T>

where T: Float + FromPrimitive,

pub fn mean(&self, axis: Axes) -> Vector<T>

The mean of the matrix along the specified axis.

• Axis Row - Arithmetic mean of rows.
• Axis Col - Arithmetic mean of columns.

Calling mean() on an empty matrix will return an empty matrix.

Examples

use rulinalg::matrix::{Matrix, Axes};

let a = Matrix::<f64>::new(2,2, vec![1.0,2.0,3.0,4.0]);

let c = a.mean(Axes::Row);
assert_eq!(*c.data(), vec![2.0, 3.0]);

let d = a.mean(Axes::Col);
assert_eq!(*d.data(), vec![1.5, 3.5]);

pub fn variance(&self, axis: Axes) -> Result<Vector<T>, Error>

The variance of the matrix along the specified axis.

• Axis Row - Sample variance of rows.
• Axis Col - Sample variance of columns.

Examples

use rulinalg::matrix::{Matrix, Axes};

let a = Matrix::<f32>::new(2,2,vec![1.0,2.0,3.0,4.0]);

let c = a.variance(Axes::Row).unwrap();
assert_eq!(*c.data(), vec![2.0, 2.0]);

let d = a.variance(Axes::Col).unwrap();
assert_eq!(*d.data(), vec![0.5, 0.5]);

Failures

• There are one or fewer row/columns in the working axis.

impl<T> Matrix<T>

where T: Any + Float,

pub fn solve(&self, y: Vector<T>) -> Result<Vector<T>, Error>

Solves the equation Ax = y.

Requires a Vector y as input.

Examples

use rulinalg::matrix::Matrix;
use rulinalg::vector::Vector;

let a = Matrix::new(2,2, vec![2.0,3.0,1.0,2.0]);
let y = Vector::new(vec![13.0,8.0]);

let x = a.solve(y).unwrap();

assert_eq!(*x.data(), vec![2.0, 3.0]);

Panics

• The matrix column count and vector size are different.
• The matrix is not square.

Failures

• The matrix cannot be decomposed into an LUP form to solve.
• There is no valid solution as the matrix is singular.

pub fn inverse(&self) -> Result<Matrix<T>, Error>

Computes the inverse of the matrix.

Examples

use rulinalg::matrix::Matrix;

let a = Matrix::new(2,2, vec![2.,3.,1.,2.]);
let inv = a.inverse().expect("This matrix should have an inverse!");

let I = a * inv;

assert_eq!(*I.data(), vec![1.0,0.0,0.0,1.0]);

Panics

• The matrix is not square.

Failures

• The matrix could not be LUP decomposed.
• The matrix has zero determinant.

pub fn det(&self) -> T

Computes the determinant of the matrix.

Examples

use rulinalg::matrix::Matrix;

let a = Matrix::new(3,3, vec![1.0,2.0,0.0,
                              0.0,3.0,4.0,
                              5.0, 1.0, 2.0]);

let det = a.det();

Panics

• The matrix is not square.

Trait Implementations

impl<'a, 'b, T> Add<&'b Matrix<T>> for &'a Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between two matrices.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: &Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, T> Add<&'c Matrix<T>> for &'b MatrixSlice<'a, T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: &Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, T> Add<&'c Matrix<T>> for &'b MatrixSliceMut<'a, T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: &Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, T> Add<&'a Matrix<T>> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between two matrices.

This will reuse allocated memory from self.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: &Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<&'b Matrix<T>> for MatrixSlice<'a, T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: &Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<&'b Matrix<T>> for MatrixSliceMut<'a, T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: &Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, T> Add<&'c MatrixSlice<'a, T>> for &'b Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSlice<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<&'b MatrixSlice<'a, T>> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSlice<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, 'c, T> Add<&'c MatrixSliceMut<'a, T>> for &'b Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<&'b MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<&'b T> for &'a Matrix<T>

where T: Copy + Add<Output = T>,

Scalar addition with matrix.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, f: &T) -> Matrix<T>

Performs the + operation.

impl<'a, T> Add<&'a T> for Matrix<T>

where T: Copy + Add<Output = T>,

Scalar addition with matrix.

Will reuse the memory allocated for the existing matrix.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, f: &T) -> Matrix<T>

Performs the + operation.

impl<'a, T> Add<Matrix<T>> for &'a Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between two matrices.

This will reuse allocated memory from m.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<Matrix<T>> for &'b MatrixSlice<'a, T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<Matrix<T>> for &'b MatrixSliceMut<'a, T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, T> Add<Matrix<T>> for MatrixSlice<'a, T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, T> Add<Matrix<T>> for MatrixSliceMut<'a, T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<MatrixSlice<'a, T>> for &'b Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSlice<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, T> Add<MatrixSlice<'a, T>> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSlice<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, 'b, T> Add<MatrixSliceMut<'a, T>> for &'b Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, T> Add<MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the + operation.

impl<'a, T> Add<T> for &'a Matrix<T>

where T: Copy + Add<Output = T>,

Scalar addition with matrix.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, f: T) -> Matrix<T>

Performs the + operation.

impl<T> Add<T> for Matrix<T>

where T: Copy + Add<Output = T>,

Scalar addition with matrix.

Will reuse the memory allocated for the existing matrix.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, f: T) -> Matrix<T>

Performs the + operation.

impl<T> Add for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition between two matrices.

This will reuse allocated memory from self.

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, m: Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<'a, T> AddAssign<&'a Matrix<T>> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: &Matrix<T>)

Performs the += operation.

impl<'a, 'b, T> AddAssign<&'b Matrix<T>> for MatrixSliceMut<'a, T>

where T: Copy + Add<Output = T>,

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: &Matrix<T>)

Performs the += operation.

impl<'a, 'b, T> AddAssign<&'b MatrixSlice<'a, T>> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: &MatrixSlice<'_, T>)

Performs the += operation.

impl<'a, 'b, T> AddAssign<&'b MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: &MatrixSliceMut<'_, T>)

Performs the += operation.

impl<'a, T> AddAssign<&'a T> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs addition assignment between a matrix and a scalar.

fn add_assign(&mut self, _rhs: &T)

Performs the += operation.

impl<'a, T> AddAssign<Matrix<T>> for MatrixSliceMut<'a, T>

where T: Copy + Add<Output = T>,

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: Matrix<T>)

Performs the += operation.

impl<'a, T> AddAssign<MatrixSlice<'a, T>> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: MatrixSlice<'_, T>)

Performs the += operation.

impl<'a, T> AddAssign<MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: MatrixSliceMut<'_, T>)

Performs the += operation.

impl<T> AddAssign<T> for Matrix<T>

where T: Copy + Add<Output = T>,

Performs addition assignment between a matrix and a scalar.

fn add_assign(&mut self, _rhs: T)

Performs the += operation.

impl<T> AddAssign for Matrix<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition assignment between two matrices.

fn add_assign(&mut self, _rhs: Matrix<T>)

Performs the += operation.

impl<T> BaseMatrix<T> for Matrix<T>

fn rows(&self) -> usize

Rows in the matrix.

fn cols(&self) -> usize

Columns in the matrix.

fn row_stride(&self) -> usize

Row stride in the matrix.

fn is_empty(&self) -> bool

Returns true if the matrix contais no elements

fn as_ptr(&self) -> *const T

Top left index of the matrix.

fn into_matrix(self) -> Matrix<T>

where T: Copy,

Convert the matrix struct into a owned Matrix.

fn sum(&self) -> T

where T: Copy + Zero<Output = T> + Add,

The sum of all elements in the matrix

fn elemul(&self, m: &Matrix<T>) -> Matrix<T>

where T: Copy + Mul<Output = T>,

The elementwise product of two matrices.

fn elediv(&self, m: &Matrix<T>) -> Matrix<T>

where T: Copy + Div<Output = T>,

The elementwise division of two matrices.

fn vcat<S>(&self, m: &S) -> Matrix<T>

where T: Copy, S: BaseMatrix<T>,

Vertically concatenates two matrices. With self on top.

fn as_slice(&self) -> MatrixSlice<'_, T>

Returns a MatrixSlice over the whole matrix.

unsafe fn get_unchecked(&self, index: [usize; 2]) -> &T

Get a reference to a point in the matrix without bounds checking.

fn get_row(&self, index: usize) -> Option<&[T]>

Returns the row of a matrix at the given index. None if the index is out of bounds.

unsafe fn get_row_unchecked(&self, index: usize) -> &[T]

Returns the row of a matrix at the given index without doing unbounds checking

fn iter<'a>(&self) -> SliceIter<'a, T>

where T: 'a,

Returns an iterator over the matrix data.

fn iter_rows(&self) -> Rows<'_, T>

Iterate over the rows of the matrix.

fn iter_diag(&self, k: DiagOffset) -> Diagonal<'_, T, Self>

Iterate over diagonal entries

fn sum_rows(&self) -> Vector<T>

where T: Copy + Zero<Output = T> + Add,

The sum of the rows of the matrix.

fn sum_cols(&self) -> Vector<T>

where T: Copy + Zero<Output = T> + Add,

The sum of the columns of the matrix.

fn select_rows<'a, I>(&self, rows: I) -> Matrix<T>

where T: Copy, I: IntoIterator<Item = &'a usize>, <I as IntoIterator>::IntoIter: ExactSizeIterator + Clone,

Select rows from matrix

fn select_cols<'a, I>(&self, cols: I) -> Matrix<T>

where T: Copy, I: IntoIterator<Item = &'a usize>, <I as IntoIterator>::IntoIter: ExactSizeIterator + Clone,

Select columns from matrix

fn select(&self, rows: &[usize], cols: &[usize]) -> Matrix<T>

where T: Copy,

Select block matrix from matrix

fn hcat<S>(&self, m: &S) -> Matrix<T>

where T: Copy, S: BaseMatrix<T>,

Horizontally concatenates two matrices. With self on the left.

fn diag(&self) -> Vector<T>

where T: Copy,

Extract the diagonal of the matrix

fn transpose(&self) -> Matrix<T>

where T: Copy,

Tranposes the given matrix

fn is_diag(&self) -> bool

where T: Zero + PartialEq,

Checks if matrix is diagonal.

fn solve_u_triangular(&self, y: Vector<T>) -> Result<Vector<T>, Error>

where T: Any + Float,

Solves an upper triangular linear system.

fn solve_l_triangular(&self, y: Vector<T>) -> Result<Vector<T>, Error>

where T: Any + Float,

Solves a lower triangular linear system.

fn split_at( &self, mid: usize, axis: Axes, ) -> (MatrixSlice<'_, T>, MatrixSlice<'_, T>)

Split the matrix at the specified axis returning two MatrixSlices.

fn sub_slice<'a>( &self, start: [usize; 2], rows: usize, cols: usize, ) -> MatrixSlice<'a, T>

where T: 'a,

Produce a MatrixSlice from an existing matrix.

impl<T> BaseMatrixMut<T> for Matrix<T>

fn as_mut_ptr(&mut self) -> *mut T

Top left index of the slice.

fn as_mut_slice(&mut self) -> MatrixSliceMut<'_, T>

Returns a MatrixSliceMut over the whole matrix.

unsafe fn get_unchecked_mut(&mut self, index: [usize; 2]) -> &mut T

Get a mutable reference to a point in the matrix without bounds checks.

fn iter_mut<'a>(&mut self) -> SliceIterMut<'a, T>

where T: 'a,

Returns a mutable iterator over the matrix.

fn get_row_mut(&mut self, index: usize) -> Option<&mut [T]>

Returns a mutable reference to the row of a matrix at the given index. None if the index is out of bounds.

unsafe fn get_row_unchecked_mut(&mut self, index: usize) -> &mut [T]

Returns a mutable reference to the row of a matrix at the given index without doing unbounds checking

fn swap_rows(&mut self, a: usize, b: usize)

Swaps two rows in a matrix.

fn swap_cols(&mut self, a: usize, b: usize)

Swaps two columns in a matrix.

fn iter_rows_mut(&mut self) -> RowsMut<'_, T>

Iterate over the mutable rows of the matrix.

fn iter_diag_mut(&mut self, k: DiagOffset) -> DiagonalMut<'_, T, Self>

Iterate over diagonal entries mutably

fn set_to<M>(self, target: M)

where M: BaseMatrix<T>, T: Copy,

Sets the underlying matrix data to the target data.

fn apply(self, f: &dyn Fn(T) -> T) -> Self

where T: Copy,

Applies a function to each element in the matrix.

fn split_at_mut( &mut self, mid: usize, axis: Axes, ) -> (MatrixSliceMut<'_, T>, MatrixSliceMut<'_, T>)

Split the matrix at the specified axis returning two MatrixSliceMuts.

fn sub_slice_mut<'a>( &mut self, start: [usize; 2], rows: usize, cols: usize, ) -> MatrixSliceMut<'a, T>

where T: 'a,

Produce a MatrixSliceMut from an existing matrix.

impl<T> Clone for Matrix<T>

where T: Clone,

fn clone(&self) -> Matrix<T>

Clones the Matrix.

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

Performs copy-assignment from source.

impl CostFunc<Matrix<f64>> for CrossEntropyError

fn cost(outputs: &Matrix<f64>, targets: &Matrix<f64>) -> f64

The cost function.

fn grad_cost(outputs: &Matrix<f64>, targets: &Matrix<f64>) -> Matrix<f64>

The gradient of the cost function.

impl CostFunc<Matrix<f64>> for MeanSqError

fn cost(outputs: &Matrix<f64>, targets: &Matrix<f64>) -> f64

The cost function.

fn grad_cost(outputs: &Matrix<f64>, targets: &Matrix<f64>) -> Matrix<f64>

The gradient of the cost function.

impl<T> Debug for Matrix<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Display for Matrix<T>

where T: Display,

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

Formats the Matrix for display.

impl<'a, 'b, T> Div<&'b T> for &'a Matrix<T>

where T: Copy + Div<Output = T>,

Scalar division with matrix.

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, f: &T) -> Matrix<T>

Performs the / operation.

impl<'a, T> Div<&'a T> for Matrix<T>

where T: Copy + Div<Output = T>,

Scalar division with matrix.

Will reuse the memory allocated for the existing matrix.

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, f: &T) -> Matrix<T>

Performs the / operation.

impl<'a, T> Div<T> for &'a Matrix<T>

where T: Copy + Div<Output = T>,

Scalar division with matrix.

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, f: T) -> Matrix<T>

Performs the / operation.

impl<T> Div<T> for Matrix<T>

where T: Copy + Div<Output = T>,

Scalar division with matrix.

Will reuse the memory allocated for the existing matrix.

type Output = Matrix<T>

The resulting type after applying the / operator.

fn div(self, f: T) -> Matrix<T>

Performs the / operation.

impl<'a, T> DivAssign<&'a T> for Matrix<T>

where T: Copy + Div<Output = T>,

Performs division assignment between a matrix and a scalar.

fn div_assign(&mut self, _rhs: &T)

Performs the /= operation.

impl<T> DivAssign<T> for Matrix<T>

where T: Copy + Div<Output = T>,

Performs division assignment between a matrix and a scalar.

fn div_assign(&mut self, _rhs: T)

Performs the /= operation.

impl<'a, T> From<MatrixSlice<'a, T>> for Matrix<T>

where T: Copy,

fn from(slice: MatrixSlice<'a, T>) -> Matrix<T>

Converts to this type from the input type.

impl<'a, T> From<MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy,

fn from(slice: MatrixSliceMut<'a, T>) -> Matrix<T>

Converts to this type from the input type.

impl<T> From<Vector<T>> for Matrix<T>

fn from(vector: Vector<T>) -> Matrix<T>

Converts to this type from the input type.

impl<'a, T> FromIterator<&'a [T]> for Matrix<T>

where T: 'a + Copy,

Creates a Matrix from an iterator over slices.

Each of the slices produced by the iterator will become a row in the matrix.

Panics

Will panic if the iterators items do not have constant length.

Examples

We can create a new matrix from some data.

use rulinalg::matrix::{Matrix, BaseMatrix};

let a : Matrix<f64> = vec![4f64; 16].chunks(4).collect();

assert_eq!(a.rows(), 4);
assert_eq!(a.cols(), 4);

We can also do more interesting things.

use rulinalg::matrix::{Matrix, BaseMatrix};

let a = Matrix::new(4,2, (0..8).collect::<Vec<usize>>());

// Here we skip the first row and take only those
// where the first entry is less than 6.
let b = a.iter_rows()
         .skip(1)
         .filter(|x| x[0] < 6)
         .collect::<Matrix<usize>>();

// We take the middle rows
assert_eq!(b.into_vec(), vec![2,3,4,5]);

fn from_iter<I>(iterable: I) -> Matrix<T>

where I: IntoIterator<Item = &'a [T]>,

Creates a value from an iterator.

impl<T> Hash for Matrix<T>

where T: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<[usize; 2]> for Matrix<T>

Indexes matrix.

Takes row index first then column.

type Output = T

The returned type after indexing.

fn index(&self, idx: [usize; 2]) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<[usize; 2]> for Matrix<T>

Indexes mutable matrix.

Takes row index first then column.

fn index_mut(&mut self, idx: [usize; 2]) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T: Float> Invertible<Matrix<T>> for MinMaxScaler<T>

fn inv_transform(&self, inputs: Matrix<T>) -> Result<Matrix<T>, Error>

Maps the inputs using the inverse of the fitted transform.

impl<T: Float + FromPrimitive> Invertible<Matrix<T>> for Standardizer<T>

fn inv_transform(&self, inputs: Matrix<T>) -> Result<Matrix<T>, Error>

Maps the inputs using the inverse of the fitted transform.

impl<T> Metric<T> for Matrix<T>

where T: Float,

fn norm(&self) -> T

Compute euclidean norm for matrix.

Examples

use rulinalg::matrix::Matrix;
use rulinalg::Metric;

let a = Matrix::new(2,1, vec![3.0,4.0]);
let c = a.norm();

assert_eq!(c, 5.0);

impl<'a, 'b, T> Mul<&'b Matrix<T>> for &'a Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: &Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<&'c Matrix<T>> for &'b MatrixSlice<'a, T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: &Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<&'c Matrix<T>> for &'b MatrixSliceMut<'a, T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: &Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, T> Mul<&'a Matrix<T>> for Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: &Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, T> Mul<&'b Matrix<T>> for MatrixSlice<'a, T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: &Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, T> Mul<&'b Matrix<T>> for MatrixSliceMut<'a, T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: &Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<&'c MatrixSlice<'a, T>> for &'b Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: &MatrixSlice<'_, T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, T> Mul<&'b MatrixSlice<'a, T>> for Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: &MatrixSlice<'_, T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, 'c, T> Mul<&'c MatrixSliceMut<'a, T>> for &'b Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, T> Mul<&'b MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, T> Mul<&'b T> for &'a Matrix<T>

where T: Copy + Mul<Output = T>,

Scalar multiplication with matrix.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, f: &T) -> Matrix<T>

Performs the * operation.

impl<'a, T> Mul<&'a T> for Matrix<T>

where T: Copy + Mul<Output = T>,

Scalar multiplication with matrix.

Will reuse the memory allocated for the existing matrix.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, f: &T) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, T> Mul<&'b Vector<T>> for &'a Matrix<T>

where T: Zero<Output = T> + Mul<Output = T> + Add + Copy,

Multiplies matrix by vector.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, v: &Vector<T>) -> Vector<T>

Performs the * operation.

impl<'a, T> Mul<&'a Vector<T>> for Matrix<T>

where T: Zero<Output = T> + Mul<Output = T> + Add + Copy,

Multiplies matrix by vector.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, m: &Vector<T>) -> Vector<T>

Performs the * operation.

impl<'a, T> Mul<Matrix<T>> for &'a Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, T> Mul<Matrix<T>> for &'b MatrixSlice<'a, T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, T> Mul<Matrix<T>> for &'b MatrixSliceMut<'a, T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, T> Mul<Matrix<T>> for MatrixSlice<'a, T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, T> Mul<Matrix<T>> for MatrixSliceMut<'a, T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, T> Mul<MatrixSlice<'a, T>> for &'b Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: MatrixSlice<'_, T>) -> Matrix<T>

Performs the * operation.

impl<'a, T> Mul<MatrixSlice<'a, T>> for Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: MatrixSlice<'_, T>) -> Matrix<T>

Performs the * operation.

impl<'a, 'b, T> Mul<MatrixSliceMut<'a, T>> for &'b Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the * operation.

impl<'a, T> Mul<MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the * operation.

impl<'a, T> Mul<T> for &'a Matrix<T>

where T: Copy + Mul<Output = T>,

Scalar multiplication with matrix.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, f: T) -> Matrix<T>

Performs the * operation.

impl<T> Mul<T> for Matrix<T>

where T: Copy + Mul<Output = T>,

Scalar multiplication with matrix.

Will reuse the memory allocated for the existing matrix.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, f: T) -> Matrix<T>

Performs the * operation.

impl<'a, T> Mul<Vector<T>> for &'a Matrix<T>

where T: Zero<Output = T> + Mul<Output = T> + Add + Copy,

Multiplies matrix by vector.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, m: Vector<T>) -> Vector<T>

Performs the * operation.

impl<T> Mul<Vector<T>> for Matrix<T>

where T: Zero<Output = T> + Mul<Output = T> + Add + Copy,

Multiplies matrix by vector.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, m: Vector<T>) -> Vector<T>

Performs the * operation.

impl<'a, T> Mul for Matrix<T>

where T: Copy + Zero<Output = T> + Add + Mul<Output = T> + Any,

Multiplies two matrices together.

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, m: Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<'a, T> MulAssign<&'a T> for Matrix<T>

where T: Copy + Mul<Output = T>,

Performs multiplication assignment between a matrix and a scalar.

fn mul_assign(&mut self, _rhs: &T)

Performs the *= operation.

impl<T> MulAssign<T> for Matrix<T>

where T: Copy + Mul<Output = T>,

Performs multiplication assignment between a matrix and a scalar.

fn mul_assign(&mut self, _rhs: T)

Performs the *= operation.

impl<'a, T> Neg for &'a Matrix<T>

where T: Neg<Output = T> + Copy,

Gets negative of matrix.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn neg(self) -> Matrix<T>

Performs the unary - operation.

impl<T> Neg for Matrix<T>

where T: Neg<Output = T> + Copy,

Gets negative of matrix.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn neg(self) -> Matrix<T>

Performs the unary - operation.

impl<T> PartialEq for Matrix<T>

where T: PartialEq,

fn eq(&self, other: &Matrix<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, T> Sub<&'b Matrix<T>> for &'a Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between two matrices.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: &Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<&'c Matrix<T>> for &'b MatrixSlice<'a, T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: &Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<&'c Matrix<T>> for &'b MatrixSliceMut<'a, T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: &Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, T> Sub<&'a Matrix<T>> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between two matrices.

This will reuse allocated memory from self.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: &Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<&'b Matrix<T>> for MatrixSlice<'a, T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: &Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<&'b Matrix<T>> for MatrixSliceMut<'a, T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: &Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<&'c MatrixSlice<'a, T>> for &'b Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSlice<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<&'b MatrixSlice<'a, T>> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSlice<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, 'c, T> Sub<&'c MatrixSliceMut<'a, T>> for &'b Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<&'b MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: &MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<&'b T> for &'a Matrix<T>

where T: Copy + Sub<Output = T>,

Scalar subtraction with matrix.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, f: &T) -> Matrix<T>

Performs the - operation.

impl<'a, T> Sub<&'a T> for Matrix<T>

where T: Copy + Sub<Output = T>,

Scalar subtraction with matrix.

Will reuse the memory allocated for the existing matrix.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, f: &T) -> Matrix<T>

Performs the - operation.

impl<'a, T> Sub<Matrix<T>> for &'a Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between two matrices.

This will reuse allocated memory from m.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<Matrix<T>> for &'b MatrixSlice<'a, T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<Matrix<T>> for &'b MatrixSliceMut<'a, T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, T> Sub<Matrix<T>> for MatrixSlice<'a, T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, T> Sub<Matrix<T>> for MatrixSliceMut<'a, T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<MatrixSlice<'a, T>> for &'b Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSlice<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, T> Sub<MatrixSlice<'a, T>> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSlice<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, 'b, T> Sub<MatrixSliceMut<'a, T>> for &'b Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, T> Sub<MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between Matrix and MatrixSlice.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, s: MatrixSliceMut<'_, T>) -> Matrix<T>

Performs the - operation.

impl<'a, T> Sub<T> for &'a Matrix<T>

where T: Copy + Sub<Output = T>,

Scalar subtraction with matrix.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, f: T) -> Matrix<T>

Performs the - operation.

impl<T> Sub<T> for Matrix<T>

where T: Copy + Sub<Output = T>,

Scalar subtraction with matrix.

Will reuse the memory allocated for the existing matrix.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, f: T) -> Matrix<T>

Performs the - operation.

impl<T> Sub for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction between two matrices.

This will reuse allocated memory from self.

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, m: Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<'a, T> SubAssign<&'a Matrix<T>> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: &Matrix<T>)

Performs the -= operation.

impl<'a, 'b, T> SubAssign<&'b Matrix<T>> for MatrixSliceMut<'a, T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: &Matrix<T>)

Performs the -= operation.

impl<'a, 'b, T> SubAssign<&'b MatrixSlice<'a, T>> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: &MatrixSlice<'_, T>)

Performs the -= operation.

impl<'a, 'b, T> SubAssign<&'b MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: &MatrixSliceMut<'_, T>)

Performs the -= operation.

impl<'a, T> SubAssign<&'a T> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs subtraction assignment between a matrix and a scalar.

fn sub_assign(&mut self, _rhs: &T)

Performs the -= operation.

impl<'a, T> SubAssign<Matrix<T>> for MatrixSliceMut<'a, T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: Matrix<T>)

Performs the -= operation.

impl<'a, T> SubAssign<MatrixSlice<'a, T>> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: MatrixSlice<'_, T>)

Performs the -= operation.

impl<'a, T> SubAssign<MatrixSliceMut<'a, T>> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: MatrixSliceMut<'_, T>)

Performs the -= operation.

impl<T> SubAssign<T> for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs subtraction assignment between a matrix and a scalar.

fn sub_assign(&mut self, _rhs: T)

Performs the -= operation.

impl<T> SubAssign for Matrix<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction assignment between two matrices.

fn sub_assign(&mut self, _rhs: Matrix<T>)

Performs the -= operation.

impl<T: Distribution> SupModel<Matrix<f64>, Matrix<f64>> for NaiveBayes<T>

Train and predict from the Naive Bayes model.

The input matrix must be rows made up of features. The target matrix should have indicator vectors in each row specifying the input class. e.g. [[1,0,0],[0,0,1]] shows class 1 first, then class 3.

fn train( &mut self, inputs: &Matrix<f64>, targets: &Matrix<f64>, ) -> LearningResult<()>

Train the model using inputs and targets.

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Matrix<f64>>

Predict output from inputs.

impl<'a, T, A> SupModel<Matrix<f64>, Matrix<f64>> for NeuralNet<'a, T, A>

where T: Criterion, A: OptimAlgorithm<BaseNeuralNet<'a, T>>,

Supervised learning for the Neural Network.

The model is trained using back propagation.

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Matrix<f64>>

Predict neural network output using forward propagation.

fn train( &mut self, inputs: &Matrix<f64>, targets: &Matrix<f64>, ) -> LearningResult<()>

Train the model using gradient optimization and back propagation.

impl<T: Kernel, U: MeanFunc> SupModel<Matrix<f64>, Vector<f64>> for GaussianProcess<T, U>

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<f64>>

Predict output from inputs.

fn train( &mut self, inputs: &Matrix<f64>, targets: &Vector<f64>, ) -> LearningResult<()>

Train the model using data and outputs.

impl<C: Criterion> SupModel<Matrix<f64>, Vector<f64>> for GenLinearModel<C>

Supervised model trait for the GLM.

Predictions are made from the model by computing g^-1(Xb).

The model is trained using Iteratively Re-weighted Least Squares.

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<f64>>

Predict output from inputs.

fn train( &mut self, inputs: &Matrix<f64>, targets: &Vector<f64>, ) -> LearningResult<()>

Train the model using inputs and targets.

impl SupModel<Matrix<f64>, Vector<f64>> for LinRegressor

fn train( &mut self, inputs: &Matrix<f64>, targets: &Vector<f64>, ) -> LearningResult<()>

Train the linear regression model.

Takes training data and output values as input.

Examples

use rusty_machine::learning::lin_reg::LinRegressor;
use rusty_machine::linalg::Matrix;
use rusty_machine::linalg::Vector;
use rusty_machine::learning::SupModel;

let mut lin_mod = LinRegressor::default();
let inputs = Matrix::new(3,1, vec![2.0, 3.0, 4.0]);
let targets = Vector::new(vec![5.0, 6.0, 7.0]);

lin_mod.train(&inputs, &targets).unwrap();

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<f64>>

Predict output value from input data.

Model must be trained before prediction can be made.

impl<A> SupModel<Matrix<f64>, Vector<f64>> for LogisticRegressor<A>

where A: OptimAlgorithm<BaseLogisticRegressor>,

fn train( &mut self, inputs: &Matrix<f64>, targets: &Vector<f64>, ) -> LearningResult<()>

Train the logistic regression model.

Takes training data and output values as input.

Examples

use rusty_machine::learning::logistic_reg::LogisticRegressor;
use rusty_machine::linalg::Matrix;
use rusty_machine::linalg::Vector;
use rusty_machine::learning::SupModel;

let mut logistic_mod = LogisticRegressor::default();
let inputs = Matrix::new(3,2, vec![1.0, 2.0, 1.0, 3.0, 1.0, 4.0]);
let targets = Vector::new(vec![5.0, 6.0, 7.0]);

logistic_mod.train(&inputs, &targets).unwrap();

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<f64>>

Predict output value from input data.

Model must be trained before prediction can be made.

impl<K: Kernel> SupModel<Matrix<f64>, Vector<f64>> for SVM<K>

Train the model using the Pegasos algorithm and predict the model output from new data.

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<f64>>

Predict output from inputs.

fn train( &mut self, inputs: &Matrix<f64>, targets: &Vector<f64>, ) -> LearningResult<()>

Train the model using inputs and targets.

impl<T: Float> Transformer<Matrix<T>> for MinMaxScaler<T>

fn fit(&mut self, inputs: &Matrix<T>) -> Result<(), Error>

Fit Transformer to input data, and stores the transformation in the Transformer

fn transform(&mut self, inputs: Matrix<T>) -> Result<Matrix<T>, Error>

Transforms the inputs and stores the transformation in the Transformer

impl<R: Rng, T> Transformer<Matrix<T>> for Shuffler<R>

The Shuffler will transform the input Matrix by shuffling its rows in place.

Under the hood this uses a Fisher-Yates shuffle.

fn fit(&mut self, inputs: &Matrix<T>) -> Result<(), Error>

Fit Transformer to input data, and stores the transformation in the Transformer

fn transform(&mut self, inputs: Matrix<T>) -> LearningResult<Matrix<T>>

Transforms the inputs and stores the transformation in the Transformer

impl<T: Float + FromPrimitive> Transformer<Matrix<T>> for Standardizer<T>

fn fit(&mut self, inputs: &Matrix<T>) -> Result<(), Error>

Fit Transformer to input data, and stores the transformation in the Transformer

fn transform(&mut self, inputs: Matrix<T>) -> Result<Matrix<T>, Error>

Transforms the inputs and stores the transformation in the Transformer

impl UnSupModel<Matrix<f64>, Matrix<f64>> for GaussianMixtureModel

fn train(&mut self, inputs: &Matrix<f64>) -> LearningResult<()>

Train the model using inputs.

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Matrix<f64>>

Predict output from inputs.

impl UnSupModel<Matrix<f64>, Vector<Option<usize>>> for DBSCAN

fn train(&mut self, inputs: &Matrix<f64>) -> LearningResult<()>

Train the classifier using input data.

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<Option<usize>>>

Predict output from inputs.

impl<InitAlg: Initializer> UnSupModel<Matrix<f64>, Vector<usize>> for KMeansClassifier<InitAlg>

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<usize>>

Predict classes from data.

Model must be trained.

fn train(&mut self, inputs: &Matrix<f64>) -> LearningResult<()>

Train the classifier using input data.

impl<T> Eq for Matrix<T>

where T: Eq,

impl<T> StructuralPartialEq for Matrix<T>