little-matrix 0.1.0

use rand::random;
use std::ops;

#[derive(Clone)]
pub struct Matrix {
    nrows: i16,
    ncols: i16,
    data:  Vec<Vec<f64>>
}

/// A Matrix is represented here by 3 fields named: nrows: i16, ncols: i16, data: Vec<Vec<f64>>
impl Matrix {
    /// Returns the number of rows as i16.
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrix: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// println!("The matrix has {} rows and {} cols", matrix.nrows(), matrix.ncols());
    /// 
    #[allow(dead_code)]
    pub fn nrows(&self) -> i16 {
        self.nrows
    }
    /// Returns the number of cols as i16.
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrix: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// println!("The matrix has {} rows and {} cols", matrix.nrows(), matrix.ncols());
    /// 
    #[allow(dead_code)]
    pub fn ncols(&self) -> i16 {
        self.ncols
    }
    /// Sets one value in the Vector.
    /// # Arguments
    /// 
    /// * `x` - A i16 Integer that holds the row, in which the variable is set.
    /// * `y` - A i16 Integer that holds the col, in which the variable is set.
    /// * `v` - A f64 Float that holds the new variable value.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrix: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// matrix.print();
    /// 
    /// matrix.set(0, 0, 5.3);
    /// 
    /// matrix.print();
    /// 
    #[allow(dead_code)]
    pub fn set(&mut self, x: i16, y: i16, v: f64) {
        assert!(x >= 0 && x <= (self.data.len() as i16 -1), "{}", format!("Row Index out of bounds! {} but got Index:{}", self.get_shape_string(), x));
        assert!(y >= 0 && y <= (self.data[0].len() as i16 -1), "{}", format!("Column Index out of bounds! {} but got Index:{}", self.get_shape_string(), y));
        self.data[x as usize][y as usize] = v;
    }
    /// Returns one value in the Vector by a given row and col as f64.
    /// # Arguments
    /// 
    /// * `x` - A i16 Integer that holds the row, in which the variable is set.
    /// * `y` - A i16 Integer that holds the col, in which the variable is set.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrix: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// println!("Value at row 0 and col 0 has the value {}", matrix.get(0, 0));
    /// 
    #[allow(dead_code)]
    pub fn get(&self, x: i16, y: i16) -> f64 {
        assert!(x >= 0 && x <= (self.data.len() as i16 -1), "{}", format!("Row Index out of bounds! {} but got Index:{}", self.get_shape_string(), x));
        assert!(y >= 0 && y <= (self.data[0].len() as i16 -1), "{}", format!("Column Index out of bounds! {} but got Index:{}", self.get_shape_string(), y));
        return self.data[x as usize][y as usize];
    }
    /// Returns two matrices added together one by one as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `b` - A &Matrix.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrix_sum: Matrix = Matrix::add(&matrixa, &matrixb);
    /// 
    #[allow(dead_code)]
    pub fn add(a: &Matrix, b: &Matrix) -> Matrix {
        assert!(a.ncols() == b.nrows(), "{}", format!("Dimensional mismatch! A: [{}, {}] | B: [{}, {}]", a.nrows(), a.ncols(), b.nrows(), b.ncols()));
        let mut data = Vec::<Vec<f64>>::new();
        for i in 0..(a.nrows) {
            let mut row = Vec::<f64>::new();
            for j in 0..(a.ncols) {
                row.push(a.data[i as usize][j as usize] +  b.data[i as usize][j as usize])
            }
            data.push(row);
        }
        Matrix {
            nrows: a.nrows,
            ncols: a.ncols,
            data: data
        }
    }
    /// Returns two matrices subtracted one by one as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `b` - A &Matrix.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrix_sub: Matrix = Matrix::sub(&matrixa, &matrixb);
    /// 
    #[allow(dead_code)]
    pub fn sub(a: &Matrix, b: &Matrix) -> Matrix {
        assert!(a.ncols() == b.nrows(), "{}", format!("Dimensional mismatch! A: [{}, {}] | B: [{}, {}]", a.nrows(), a.ncols(), b.nrows(), b.ncols()));
        let mut data = Vec::<Vec<f64>>::new();
        for i in 0..(a.nrows) {
            let mut row = Vec::<f64>::new();
            for j in 0..(a.ncols) {
                row.push(a.data[i as usize][j as usize] -  b.data[i as usize][j as usize])
            }
            data.push(row);
        }
        Matrix {
            nrows: a.nrows,
            ncols: a.ncols,
            data: data
        }
    }
    /// Returns two matrices multiplied one by one as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `b` - A &Matrix.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrix_mul: Matrix = Matrix::mul(&matrixa, &matrixb);
    /// 
    #[allow(dead_code)]
    pub fn mul(a: &Matrix, b: &Matrix) -> Matrix {
        assert!(a.ncols() == b.nrows(), "{}", format!("Dimensional mismatch! A: [{}, {}] | B: [{}, {}]", a.nrows(), a.ncols(), b.nrows(), b.ncols()));
        let mut data = Vec::<Vec<f64>>::new();
        for i in 0..(a.nrows) {
            let mut row = Vec::<f64>::new();
            for j in 0..(a.ncols) {
                row.push(a.data[i as usize][j as usize] *  b.data[i as usize][j as usize])
            }
            data.push(row);
        }
        Matrix {
            nrows: a.nrows,
            ncols: a.ncols,
            data: data
        }
    }
    /// Returns two matrices divided one by one as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `b` - A &Matrix.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrix_div: Matrix = Matrix::div(&matrixa, &matrixb);
    /// 
    #[allow(dead_code)]
    pub fn div(a: &Matrix, b: &Matrix) -> Matrix {
        assert!(a.ncols() == b.nrows(), "{}", format!("Dimensional mismatch! A: [{}, {}] | B: [{}, {}]", a.nrows(), a.ncols(), b.nrows(), b.ncols()));
        let mut data = Vec::<Vec<f64>>::new();
        for i in 0..(a.nrows) {
            let mut row = Vec::<f64>::new();
            for j in 0..(a.ncols) {
                row.push(a.data[i as usize][j as usize] /  b.data[i as usize][j as usize])
            }
            data.push(row);
        }
        Matrix {
            nrows: a.nrows,
            ncols: a.ncols,
            data: data
        }
    }
    /// Returns the dot product of two matrices as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `b` - A &Matrix.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(1, 2);
    /// 
    /// let matrixb: Matrix = Matrix::create_random_matrix(2, 1);
    /// 
    /// let matrix_dot: Matrix = Matrix::dot(&matrixa, &matrixb);
    /// 
    #[allow(dead_code)]
    pub fn dot(a: &Matrix, b: &Matrix) -> Matrix {
        assert!(a.ncols() == b.nrows(), "{}", format!("Dimensional mismatch! A: [{}, {}] | B: [{}, {}]", a.nrows(), a.ncols(), b.nrows(), b.ncols()));
        
        let mut mat = Matrix::create_matrix(a.nrows(), b.ncols());
        for i in 0..(mat.nrows()) {
            for k in 0..(mat.ncols()) {
                for j in 0..(a.ncols()) {
                    mat.set(i, k, mat.get(i, k) + a.get(i, j) * b.get(j, k))
                }
            }
        }
        mat
    }
    /// Returns the transposed Matrix as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrix_t: Matrix = Matrix::transpose(&matrixa);
    /// 
    #[allow(dead_code)]
    pub fn transpose(a: &Matrix) -> Matrix {
        let mut data = Matrix::create_matrix(a.ncols, a.nrows);
        for i in 0..(a.nrows) {
            for j in 0..(a.ncols) {
                data.set(j, i, a.get(i, j));
            }
        }
        data
    }
    /// Applies a given function fn(f64) -> f64 to every value in the Matrix and returns the new Matrix as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `f` - A fn(f64) -> f64.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// let closure = |i: f64| -> f64 { i+10.0 };
    /// let matrixb = matrixa.map(closure);
    #[allow(dead_code)]
    pub fn map(&self, f: fn(f64) -> f64) -> Matrix {
        let mut data = Matrix::create_matrix(self.nrows, self.ncols);
        for i in 0..(self.nrows) {
            for j in 0..(self.ncols) {
                data.set(i, j, f(self.data[i as usize][j as usize]));
            }
        }
        data
    }
    /// Adds a single f64 float to every value in a given Matrix and returns it as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `v` - A f64.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let scalar_add: Matrix = Matrix::scalar_add(&matrixa, 10.0);
    /// 
    #[allow(dead_code)]
    pub fn scalar_add(a: &Matrix, v: f64) -> Matrix {
        let mut data = Matrix::create_matrix(a.nrows, a.ncols);
        for i in 0..(a.nrows) {
            for j in 0..(a.ncols) {
                data.set(i, j, a.get(i, j) + v);
            }
        }
        data
    }
    /// Subtracts a single f64 float from every value in a given Matrix and returns it as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `v` - A f64.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let scalar_sub: Matrix = Matrix::scalar_sub(&matrixa, 10.0);
    /// 
    #[allow(dead_code)]
    pub fn scalar_sub(a: &Matrix, v: f64) -> Matrix {
        let mut data = Matrix::create_matrix(a.nrows, a.ncols);
        for i in 0..(a.nrows) {
            for j in 0..(a.ncols) {
                data.set(i, j, a.get(i, j) - v);
            }
        }
        data
    }
    /// Subtracts every value of the Matrix from a given float f64 and returns it as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `v` - A f64.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let scalar_sub: Matrix = Matrix::scalar_sub_first(&matrixa, 10.0);
    /// 
    #[allow(dead_code)]
    pub fn scalar_sub_first(a: &Matrix, v: f64) -> Matrix {
        let mut data = Matrix::create_matrix(a.nrows, a.ncols);
        for i in 0..(a.nrows) {
            for j in 0..(a.ncols) {
                data.set(i, j, v - a.get(i, j));
            }
        }
        data
    }
    /// Multiplies every value of the Matrix by a given float f64 and returns it as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `v` - A f64.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let scalar_sub: Matrix = Matrix::scalar_mult(&matrixa, 10.0);
    /// 
    #[allow(dead_code)]
    pub fn scalar_mult(a: &Matrix, v: f64) -> Matrix {
        let mut data = Matrix::create_matrix(a.nrows, a.ncols);
        for i in 0..(a.nrows) {
            for j in 0..(a.ncols) {
                data.set(i, j, a.get(i, j) * v);
            }
        }
        data
    }
    /// Divides every value of the Matrix by a given float f64 and returns it as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `v` - A f64.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let scalar_sub: Matrix = Matrix::scalar_div(&matrixa, 10.0);
    /// 
    #[allow(dead_code)]
    pub fn scalar_div(a: &Matrix, v: f64) -> Matrix {
        let mut data = Matrix::create_matrix(a.nrows, a.ncols);
        for i in 0..(a.nrows) {
            for j in 0..(a.ncols) {
                data.set(i, j, a.get(i, j) / v);
            }
        }
        data
    }
    /// Returns a Matrix where every value has the opposite sign as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrixa_inverse: Matrix = Matrix::inverse(&matrixa);
    /// 
    #[allow(dead_code)]
    pub fn inverse(a: &Matrix) -> Matrix {
        let mut data = Matrix::create_matrix(a.nrows, a.ncols);
        for i in 0..(a.nrows) {
            for j in 0..(a.ncols) {
                data.set(i, j, -a.get(i, j));
            }
        }
        data
    }
    /// Sums every row together and returns a Matrix with the same number of rows and 1 column.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// 
    /// # Examples
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrixa_rows_sum: = Matrix::sum_rows(&matrixa);
    /// 
    #[allow(dead_code)]
    pub fn sum_rows(a: &Matrix) -> Matrix {
        let mut data = Matrix::create_matrix(a.nrows(), 1);
        for i in 0..(a.nrows()) {
            let mut sum: f64 = 0.0;
            for j in 0..(a.ncols()) {
                sum += a.get(i, j);
            }
            data.set(i, 0, sum);
        }
        return data;
    }
    /// Every value in the Matrix is raised to a given power and returned as a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `v` - A f64.
    /// 
    /// # Examples
    /// 
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let matrixa_pow_2 = Matrix::pow(&matrixa, 2.0);
    /// 
    #[allow(dead_code)]
    pub fn pow(a: &Matrix, v: f64) -> Matrix {
        let mut data = Matrix::create_matrix(a.nrows, a.ncols);
        for i in 0..(a.nrows) {
            for j in 0..(a.ncols) {
                data.set(i, j, a.get(i, j).powf(v));
            }
        }
        data
    }
    /// Filters every value in the Matrix by a given function fn(f64) -> bool. If the output of the function is true, the value stays the same. If the output of the function is false, the value is replaced by a given float f64. It returns a Matrix.
    /// # Arguments
    /// 
    /// * `a` - A &Matrix.
    /// * `f` - A fn(f64) -> bool.
    /// * `v` - A f64.
    /// 
    /// # Examples
    /// 
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// let closure = |v: f64| -> bool { v < 10.0 };
    /// 
    /// let matrixb = Matrix::filter_by_function(&matrixa, closure, 0.0);
    /// 
    #[allow(dead_code)]
    pub fn filter_by_function(a: &Matrix, f: fn(f64) -> bool, v: f64) -> Matrix {
        let mut data = Matrix::create_matrix(a.nrows, a.ncols);
        for i in 0..(a.nrows) {
            for j in 0..(a.ncols) {
                let temp = a.get(i, j);
                match f(temp) {
                    false => data.set(i, j, v),
                    true => data.set(i, j, temp)
                }
            }
        }
        data
    }
    #[allow(dead_code)]
    fn get_digits(&self, i: &f64) -> i32 {
        i.to_string().chars().count() as i32
    }
    /// Returns the shape of a Matrix as a string formatted with Shape:({}, {}) as a String.
    /// 
    /// # Examples
    /// 
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// println!("Matrix has {}", matrixa.get_shape_string());
    /// 
    #[allow(dead_code)]
    pub fn get_shape_string(&self) -> String {
        format!("Shape:({}, {})", self.nrows(), self.ncols())
    }
    #[allow(dead_code)]
    fn get_most_digits(&self) -> i32 {
        let mut cnt: i32 = 0;
        for i in 0..(self.data.len()) {
            for j in 0..(self.data[i].len()) {
                let digits = self.get_digits(&self.data[i][j]);
                if digits > cnt {
                    cnt = digits;
                }
            }
        }
        cnt
    }
    #[allow(dead_code)]
    fn to_append(&self, i: &f64, cnt: i32) -> String {
        let mut appendix = String::new();
        for _ in 0..(cnt - self.get_digits(i)) {
            appendix = format!("{}{}", appendix, " ");
        }
        appendix
    } 
    #[allow(dead_code)]
    fn before_print(&self, cnt: i32) -> String {
        let mut appendix = String::new();
        for _ in 0..(cnt * (self.ncols() as i32) + 3 + (self.ncols() as i32) ) {
            appendix = format!("{}{}", appendix, "-");
        }
        appendix
    }
    /// Pretty prints the Matrix to the console using print!().
    /// 
    /// # Examples
    /// 
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
    /// 
    /// matrixa.print();
    /// 
    #[allow(dead_code)]
    pub fn print(&self) {
        let most_digits: i32 = self.get_most_digits();
        println!("\t{}", self.before_print(most_digits));
        for i in 0..(self.data.len()) {
            for j in 0..(self.data[i].len()) {
                if j == 0 && j == self.data[i].len() - 1 {
                    let current = self.get(i as i16, j as i16);
                    print!("\t| {}{} |\n", current, self.to_append(&current, most_digits));
                }
                else if j == 0 {
                    let current = self.get(i as i16, j as i16);
                    print!("\t| {}{}", current, self.to_append(&current, most_digits));
                } else if j == self.data[i].len() - 1 {
                    let current = self.get(i as i16, j as i16);
                    print!(" {}{} |\n", current, self.to_append(&current, most_digits));
                } else {
                    let current = self.get(i as i16, j as i16);
                    print!(" {}{}", current, self.to_append(&current, most_digits));
                }
            }
        }
        println!("\t{}", self.before_print(most_digits));
        println!("\t{}", self.get_shape_string());
    }
    /// Creates a Matrix by a given number of rows as i16 and cols as i16 where every value is zero and returns it as a Matrix.
    /// # Arguments
    /// 
    /// * `nrows` - A i16.
    /// * `ncols` - A i16.
    /// 
    /// # Examples
    /// 
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_matrix(6, 6);
    /// 
    #[allow(dead_code)]
    pub fn create_matrix(nrows: i16, ncols: i16) -> Matrix { 
        let mut data = Vec::<Vec<f64>>::new();
        for _ in 0..nrows {
            let mut row = Vec::<f64>::new();
            for _ in 0..ncols {
                row.push(0.0);
            }
            data.push(row);
        }
        Matrix {
            nrows: nrows,
            ncols: ncols,
            data: data
        }
    }
    /// Creates a Matrix by a given number of rows as i16 and cols as i16 where every value is random between 0 and 1 and returns it as a Matrix.
    /// # Arguments
    /// 
    /// * `nrows` - A i16.
    /// * `ncols` - A i16.
    /// 
    /// # Examples
    /// 
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_matrix(6, 6);
    /// 
    #[allow(dead_code)]
    pub fn create_random_matrix(nrows: i16, ncols: i16) -> Matrix { 
        let mut data = Vec::<Vec<f64>>::new();
        for _ in 0..nrows {
            let mut row = Vec::<f64>::new();
            for _ in 0..ncols {
                row.push(random());
            }
            data.push(row);
        }
        Matrix {
            nrows: nrows,
            ncols: ncols,
            data: data
        }
    }
    /// Creates a Matrix by a given number of rows as i16 and cols as i16 where every value is a given float and returns it as a Matrix.
    /// # Arguments
    /// 
    /// * `nrows` - A i16.
    /// * `ncols` - A i16.
    /// * `v` - A f64.
    /// 
    /// # Examples
    /// 
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_matrix_by_float(6, 6, 10.0);
    /// 
    #[allow(dead_code)]
    pub fn create_matrix_by_float(nrows: i16, ncols: i16, v: f64) -> Matrix {
        let mut data = Vec::<Vec<f64>>::new();
        for _ in 0..nrows {
            let mut row = Vec::<f64>::new();
            for _ in 0..ncols {
                row.push(v);
            }
            data.push(row);
        }
        Matrix {
            nrows: nrows,
            ncols: ncols,
            data: data
        }
    }
    /// Creates a Matrix by nested float array &[&[f64]] and returns it as a Matrix.
    /// # Arguments
    /// 
    /// * `v` - A &[&[f64]].
    /// 
    /// # Examples
    /// 
    /// use nn::Matrix;
    /// 
    /// let matrixa: Matrix = Matrix::create_matrix_from_nested_float_array(&[
    ///     &[10.0, 1.0, 1.2, 3.4],
    ///     &[2.3, 4.3, 2.1, 5.4]
    /// ]);
    /// 
    /// matrixa.print();
    /// 
    #[allow(dead_code)]
    pub fn create_matrix_from_nested_float_array(v: &[&[f64]]) -> Matrix {
        
        assert!(v.len() != 0, "Please provide filled Arrays");


        let mut mat: Matrix = Matrix::create_matrix(v.len() as i16, v[0].len() as i16);
        
        for i in 0..(v.len()) {
            for j in 0..(v[i].len()) {
                mat.set(i as i16, j as i16, v[i][j]);
            }
        }

        mat
    }

}

/// Creates a Matrix by nested float array &[&[f64]] and returns it as a Matrix.
/// 
/// # Examples
/// 
/// use nn::Matrix;
/// 
/// let matrixa: Matrix = Matrix::create_random_matrix(2, 2);
/// 
/// println!("The value at Row 0 and Col 0 has the value {}", matrixa[0..0]);
/// 
impl ops::Index<ops::Range<usize>> for Matrix {
    type Output = f64;

    fn index(&self, l: ops::Range<usize>) -> &f64 {
        let i = &l.start;
        let j = &l.end;
        &self.data[ *i as usize][ *j as usize]
    }

}

/// Returns a Matrix where every value has the opposite sign as a Matrix.
/// 
/// # Examples
/// use nn::Matrix;
/// 
/// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrixa_inverse: Matrix = Matrix::inverse(&matrixa);
/// 
impl ops::Not for Matrix {
    type Output = Matrix;

    fn not(self) -> Self::Output {
        Matrix::inverse(&self)
    }

}

/// Returns two matrices added together one by one as a Matrix.
/// 
/// # Examples
/// use nn::Matrix;
/// 
/// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrix_sum: Matrix = matrixa.clone() + matrixb.clone();
/// 
impl ops::Add<Matrix> for Matrix {
    type Output = Matrix;

    fn add(self, _rhs: Matrix) -> Matrix {
        Matrix::add(&self, &_rhs)
    }
}

/// Returns two matrices multiplied one by one as a Matrix.
/// 
/// # Examples
/// use nn::Matrix;
/// 
/// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrix_mul: Matrix = matrixa.clone() * matrixb.clone();
/// 
impl ops::Mul<Matrix> for Matrix {
    type Output = Matrix;

    fn mul(self, _rhs: Matrix) -> Matrix {
        Matrix::mul(&self, &_rhs)
    }
}

/// Returns two matrices subtracted one by one as a Matrix.
/// 
/// # Examples
/// use nn::Matrix;
/// 
/// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrix_sub: Matrix = matrixa.clone() - matrixb.clone();
/// 
impl ops::Sub<Matrix> for Matrix {
    type Output = Matrix;

    fn sub(self, _rhs: Matrix) -> Matrix {
        Matrix::sub(&self, &_rhs)
    }
}

/// Returns two matrices divided one by one as a Matrix.
/// 
/// # Examples
/// use nn::Matrix;
/// 
/// let matrixa: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrix_div: Matrix = matrixa.clone() / matrixb.clone();
/// 
impl ops::Div<Matrix> for Matrix {
    type Output = Matrix;

    fn div(self, _rhs: Matrix) -> Matrix {
        Matrix::div(&self, &_rhs)
    }
}

/// Returns the dot product of two matrices as a Matrix.
/// 
/// # Examples
/// use nn::Matrix;
/// 
/// let matrixa: Matrix = Matrix::create_random_matrix(1, 2);
/// 
/// let matrixb: Matrix = Matrix::create_random_matrix(2, 1);
/// 
/// let matrix_dot: Matrix = matrixa.clone() | matrixb.clone();
/// 
impl ops::BitOr<Matrix> for Matrix {
    type Output = Matrix;

    fn bitor(self, rhs: Matrix) -> Matrix {
        Matrix::dot(&self, &rhs)
    }
}

/// Adds a Matrix to a given Matrix one by one.
/// 
/// # Examples
/// use nn::Matrix;
/// 
/// let mut matrixa: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// matrixa += matrixb;
/// 
impl ops::AddAssign<Matrix> for Matrix {
    fn add_assign(&mut self, _rhs: Matrix) {
        *self = Matrix::add(self, &_rhs);
    }
}

/// Multiplies a Matrix with a given Matrix one by one.
/// 
/// # Examples
/// use nn::Matrix;
/// 
/// let mut matrixa: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// matrixa *= matrixb;
/// 
impl ops::MulAssign<Matrix> for Matrix {
    fn mul_assign(&mut self, _rhs: Matrix) {
        *self = Matrix::mul(self, &_rhs);
    }
}

/// Divides a Matrix by a given Matrix one by one.
/// 
/// # Examples
/// use nn::Matrix;
/// 
/// let mut matrixa: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// matrixa /= matrixb;
/// 
impl ops::DivAssign<Matrix> for Matrix {
    fn div_assign(&mut self, _rhs: Matrix) {
        *self = Matrix::div(self, &_rhs);
    }
}

/// Subtracts a Matrix with a given Matrix one by one.
/// 
/// # Examples
/// use nn::Matrix;
/// 
/// let mut matrixa: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// let matrixb: Matrix = Matrix::create_random_matrix(6, 6);
/// 
/// matrixa -= matrixb;
/// 
impl ops::SubAssign<Matrix> for Matrix {
    fn sub_assign(&mut self, _rhs: Matrix) {
        *self = Matrix::sub(self, &_rhs);
    }
}