addition: gauss-jordan-elimination

Cargo.lock

@@ -11,7 +11,7 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 [[package]]
 name = "fractions"
 version = "0.1.0"
-source = "git+https://laentropia-homelab.tail7368da.ts.net/laentropia/Rusty-Fractions.git?branch=main#e79d93aa9d20a90358789f872994bc8cefa2779e"
+source = "git+https://laentropia-homelab.tail7368da.ts.net/laentropia/Rusty-Fractions.git?branch=main#885bbfeebed047a62ef86eae5bcc44137e2ae127"
 
 [[package]]
 name = "matrix"

f

@@ -1,23 +0,0 @@
-commit 918815f5b1a997018bc83b9ec7d65dd3a7ca7bce (HEAD -> main)
-Author: LaEntropiaa <aadrian887mh@gmail.com>
-Date:   Tue Aug 26 11:38:47 2025 -0600
-
-    Added sum and substract function
-
-commit a0523d9ccb77f77184429638f33cc4adc1376a48
-Author: LaEntropiaa <aadrian887mh@gmail.com>
-Date:   Thu Aug 21 11:45:42 2025 -0600
-
-    added display trait for matrix struct
-
-commit 6b426fa1b0f9ebdbbf5e8c3b2eb2e435a053eca4
-Author: LaEntropiaa <aadrian887mh@gmail.com>
-Date:   Wed Aug 20 10:32:43 2025 -0600
-
-    added get function
-
-commit ef914ed0169305a120c16ad1e0c4927049af4c94
-Author: LaEntropiaa <aadrian887mh@gmail.com>
-Date:   Sat Aug 9 16:19:53 2025 -0600
-
-    Initial comit, bases for matrix struct and creation

src/lib.rs

@@ -1,246 +1,311 @@
-use core::panic;
+use fractions::{Fraction, FractionError};
-use fractions::Fraction;
+use std::fmt::{Debug, Display};
-use num_traits::{Float, Num, NumAssign, Signed};
-use std::fmt::{self, Debug};
 use std::ops::Add;
 use std::ops::Mul;
 use std::ops::Sub;
 
-#[derive(PartialEq, Eq, Debug)]
+#[derive(Debug, Eq, PartialEq)]
-pub struct Matrix<
+pub enum MatrixError {
-    T: Num
+    IndexOutOfRange,
-        + NumAssign
+    RowOutOfRange,
-        + Signed
+    ColumnOutOfRange,
-        + Float
+    NotSquared,
-        + fmt::Display
+    InvalidDataSize,
-        + Copy
+    InvalidSizeForAdd,
-        + PartialEq
+    InvalidSizeForSub,
-        + Debug
+    InvalidSizeForMul,
-        + std::iter::Product<T>,
+    ZeroSize,
-> {
+    FailedGauss,
-    rows: usize,
+    FailedGaussJordan,
-    columns: usize,
+    FractionError(FractionError),
-    data: Vec<T>,
 }
 
-impl<
+impl From<FractionError> for MatrixError {
-        T: Num
+    fn from(err: FractionError) -> Self {
-            + NumAssign
+        MatrixError::FractionError(err)
-            + Signed
+    }
-            + Float
+}
-            + fmt::Display
+
-            + Copy
+#[derive(PartialEq, Eq, Debug)]
-            + PartialEq
+pub struct Matrix {
-            + Debug
+    rows: usize,
-            + std::iter::Product<T>,
+    columns: usize,
-    > Matrix<T>
+    data: Vec<Fraction>,
-{
+}
-    pub fn new(rows: usize, columns: usize, default: T) -> Self {
+
-        Self {
+impl Matrix {
+    pub fn new(rows: usize, columns: usize, default: Fraction) -> Result<Self, MatrixError> {
+        if columns < 1 || rows < 1 {
+            return Err(MatrixError::ZeroSize);
+        }
+
+        Ok(Self {
             rows,
             columns,
             data: vec![default; rows * columns],
-        }
+        })
     }
 
-    pub fn get(&self, row: usize, column: usize) -> &T {
+    pub fn get(&self, row: usize, column: usize) -> Result<&Fraction, MatrixError> {
         if row >= self.rows || column >= self.columns {
-            panic!("Index given is out of range.")
+            return Err(MatrixError::IndexOutOfRange);
         }
         let mut index = 0;
         index += row * self.columns;
         index += column;
-        return &self.data[index];
+        return Ok(&self.data[index]);
     }
 
-    pub fn get_row(&self, row: usize) -> Vec<T> {
+    pub fn get_row(&self, row: usize) -> Result<impl Iterator<Item = &Fraction>, MatrixError> {
         if row >= self.rows {
-            panic!("Row index is out of bounds.");
+            return Err(MatrixError::RowOutOfRange);
         }
 
-        let mut index = 0;
+        let start = row * self.columns;
-        let mut data = Vec::new();
+        let end = start + self.columns;
 
-        index += self.columns * row;
+        return Ok(self.data[start..end].iter());
-        for i in 0..self.columns {
-            data.push(self.data[index + i]);
-        }
-
-        return data;
     }
 
-    pub fn get_column(&self, column: usize) -> Vec<T> {
+    pub fn get_column(
+        &self,
+        column: usize,
+    ) -> Result<impl Iterator<Item = &Fraction>, MatrixError> {
         if column >= self.columns {
-            panic!("Column index is out of bounds.");
+            return Err(MatrixError::ColumnOutOfRange);
         }
 
-        let index = column;
+        Ok((0..self.rows).map(move |i| &self.data[i * self.columns + column]))
-        let mut data = Vec::new();
-
-        for i in 0..self.rows {
-            data.push(self.data[(i * self.columns) + index])
-        }
-
-        return data;
     }
 
-    pub fn get_diagonal(&self) -> Vec<T> {
+    pub fn get_diagonal(&self) -> Result<impl Iterator<Item = &Fraction>, MatrixError> {
         if self.columns != self.rows {
-            panic!("The matrix needs to be squared for getting diagonal.")
+            return Err(MatrixError::NotSquared);
         }
 
-        let mut data = Vec::new();
+        Ok((0..self.rows).map(move |i| &self.data[i * self.columns + i]))
-
-        let mut index = 0;
-        for i in 0..self.columns {
-            index = i + (i * self.columns);
-            data.push(self.data[index]);
-        }
-        return data;
     }
 
-    pub fn set(&mut self, row: usize, column: usize, data: T) -> () {
+    pub fn set(&mut self, row: usize, column: usize, data: Fraction) -> Option<MatrixError> {
         if row >= self.rows || column >= self.columns {
-            panic!("Index given is out of range.")
+            return Some(MatrixError::IndexOutOfRange);
         }
         let mut index = 0;
         index += row * self.columns;
         index += column;
         self.data[index] = data;
-        return;
+        return None;
     }
 
-    pub fn set_row(&mut self, row: usize, data: Vec<T>) -> () {
+    pub fn set_row(&mut self, row: usize, data: Vec<Fraction>) -> Option<MatrixError> {
         if row >= self.rows {
-            panic!("Row index given is out of bounds.")
+            return Some(MatrixError::IndexOutOfRange);
         }
         if data.len() != self.columns {
-            panic!("Data is not the required size")
+            return Some(MatrixError::InvalidDataSize);
         }
 
         for i in 0..data.len() {
             self.set(row, i, data[i]);
         }
+
+        None
     }
 
-    pub fn set_column(&mut self, column: usize, data: Vec<T>) -> () {
+    pub fn set_column(&mut self, column: usize, data: Vec<Fraction>) -> Option<MatrixError> {
         if column >= self.columns {
-            panic!("Column index given is out of bouds.")
+            return Some(MatrixError::ColumnOutOfRange);
         }
         if data.len() != self.rows {
-            panic!("Data is not the required size")
+            return Some(MatrixError::InvalidDataSize);
         }
 
         for i in 0..data.len() {
             self.set(i, column, data[i]);
         }
+
+        None
     }
 
-    pub fn exchange_rows(&mut self, row1: usize, row2: usize) -> () {
+    pub fn exchange_rows(&mut self, row1: usize, row2: usize) -> Option<MatrixError> {
         if row1 >= self.rows || row2 >= self.rows {
-            panic!("Row index is out of bounds.");
+            return Some(MatrixError::RowOutOfRange);
         }
 
-        //Get copy of row2
+        let start1 = row1 * self.columns;
-        let temp = self.get_row(row2);
+        let start2 = row2 * self.columns;
-        let mut index1 = 0;
+
-        let mut index2 = 0;
-        //Move from row1 to row2
-        index1 += self.columns * row1;
-        index2 += self.columns * row2;
         for i in 0..self.columns {
-            self.data[index2 + i] = self.data[index1 + i];
+            self.data.swap(start1 + i, start2 + i);
-            self.data[index1 + i] = temp[i];
         }
+
+        None
     }
 
-    pub fn exchange_columns(&mut self, column1: usize, column2: usize) -> () {
+    pub fn exchange_columns(&mut self, column1: usize, column2: usize) -> Option<MatrixError> {
         if column1 >= self.columns || column2 >= self.columns {
-            panic!("Column index is out of bounds.")
+            return Some(MatrixError::ColumnOutOfRange);
         }
 
-        //Get copy of column2
-        let temp = self.get_column(column2);
         for i in 0..self.rows {
-            self.data[column2 + (i * self.columns)] = self.data[column1 + (i * self.columns)];
+            let idx1 = column1 + i * self.columns;
-            self.data[column1 + (i * self.columns)] = temp[i];
+            let idx2 = column2 + i * self.columns;
+
+            self.data.swap(idx1, idx2);
         }
+
+        None
     }
 
-    pub fn get_determinant(&self) -> T {
+    fn partial_pivoting(&mut self, col: usize, sign: &mut Fraction) -> Result<bool, MatrixError> {
-        if self.rows != self.columns {
+        if col >= self.columns {
-            panic!("Only nxn matrixes can have a determinant.");
+            return Err(MatrixError::ColumnOutOfRange);
         }
 
+        let mut max_row = col;
+        let mut max_value = self.get(col, col).unwrap().abs();
+
+        for r in (col + 1)..self.rows {
+            let val = self.get(r, col).unwrap().abs();
+            if val > max_value {
+                max_value = val;
+                max_row = r;
+            }
+        }
+
+        if max_value.is_zero() {
+            return Ok(false);
+        }
+
+        if max_row != col {
+            match self.exchange_rows(col, max_row) {
+                Some(err) => return Err(err),
+                None => {}
+            };
+            *sign = -*sign;
+        }
+
+        Ok(true)
+    }
+
+    pub fn gaussian_elimination(&self) -> Result<(Matrix, Fraction), MatrixError> {
         let mut trig_matrix = Matrix {
             columns: self.columns,
             rows: self.rows,
             data: self.data.clone(),
         };
-        let mut sign = T::one();
+        let mut sign = Fraction::new(1, 1).unwrap();
 
         for i in 0..self.columns {
-            let mut pivot = *trig_matrix.get(i, i);
+            // We do partial pivoting for better efifiency and security
+            let pivot_exists = trig_matrix.partial_pivoting(i, &mut sign)?;
 
-            // Assign x to next row
+            // If there ain't no other thing but 0 then we're
-            let mut x = i + 1;
+            // fucked, determinant is zero
-            while pivot.is_zero() && x < self.rows {
+            if !pivot_exists {
-                if !trig_matrix.get(x, i).is_zero() {
+                return Err(MatrixError::FailedGauss);
-                    trig_matrix.exchange_rows(x, i);
-                    sign = -sign;
-                    pivot = *trig_matrix.get(i, i);
-                    break;
-                }
-                x += 1;
-            }
-            // If even exchanging in all ways posible pivot is still 0
-            // then determinant is 0
-            if pivot.is_zero() {
-                return T::zero();
             }
 
-            //So, we got the pivot, now we evaluate to 0 to create the
+            let pivot = *trig_matrix.get(i, i).unwrap();
-            //triangular matrix
+
-            x = i + 1;
+            // The main gaussian elimination, not even I remember how
-            while x < trig_matrix.rows {
+            // i did it in such a asimple way
-                let m = *trig_matrix.get(x, i) / pivot;
+            for x in (i + 1)..trig_matrix.rows {
-                let new_row = trig_matrix
+                let m = (*trig_matrix.get(x, i).unwrap() / pivot).unwrap();
-                    .get_row(x)
+
-                    .iter()
+                let row_x = trig_matrix.get_row(x)?;
-                    .zip(trig_matrix.get_row(i).iter())
+                let row_i = trig_matrix.get_row(i)?;
+
+                let new_row = row_x
+                    .zip(row_i)
                     .map(|(a, b)| *a - m * *b)
-                    .collect::<Vec<T>>();
+                    .collect::<Vec<Fraction>>();
+
                 trig_matrix.set_row(x, new_row);
-                x += 1;
             }
         }
 
+        Ok((trig_matrix, sign))
+    }
+
+    pub fn gauss_jordan_elimination(&self) -> Result<Matrix, MatrixError> {
+        let mut new_matrix = Matrix {
+            columns: self.columns,
+            rows: self.rows,
+            data: self.data.clone(),
+        };
+
+        let mut dummy = Fraction::from(1);
+
+        for i in 0..self.columns {
+            let pivot_exists = new_matrix.partial_pivoting(i, &mut dummy)?;
+
+            if !pivot_exists {
+                return Err(MatrixError::FailedGaussJordan);
+            }
+
+            let pivot = *new_matrix.get(i, i).unwrap();
+
+            let new_pivot_row = new_matrix
+                .get_row(i)?
+                .map(|x| *x / pivot)
+                .collect::<Result<Vec<_>, _>>()?;
+
+            new_matrix.set_row(i, new_pivot_row);
+
+            for r in 0..new_matrix.rows {
+                if r == 1 {
+                    continue;
+                }
+
+                let factor = *new_matrix.get(r, i).unwrap();
+
+                if factor.is_zero() {
+                    continue;
+                }
+
+                let new_row_normalized = new_matrix
+                    .get_row(r)?
+                    .zip(new_matrix.get_row(i)?)
+                    .map(|(a, b)| *a - factor * *b)
+                    .collect::<Vec<Fraction>>();
+
+                new_matrix.set_row(r, new_row_normalized);
+            }
+        }
+
+        Ok(new_matrix)
+    }
+
+    pub fn get_determinant(&self) -> Result<Fraction, MatrixError> {
+        if self.rows != self.columns {
+            return Err(MatrixError::NotSquared);
+        }
+
+        let (trig_matrix, sign) = match self.gaussian_elimination() {
+            Err(MatrixError::FailedGauss) => return Ok(Fraction::new(0, 1).unwrap()),
+            Ok((matrix, sign)) => (matrix, sign),
+            Err(err) => return Err(err),
+        };
         // YES, now we got ourselves a triangular matrix, now we just
         // take the product of the diagonal and multiply by sign, that's
         // the determinant :)
-        let determinant = sign * trig_matrix.get_diagonal().iter().copied().product::<T>();
+        let determinant = sign
+            * trig_matrix
+                .get_diagonal()?
+                .copied()
+                .fold(Fraction::from(1i64), |acc, x| acc * x);
 
-        return determinant;
+        return Ok(determinant);
     }
 }
 
-impl<
+impl Add for Matrix {
-        T: Num
+    type Output = Result<Self, MatrixError>;
-            + NumAssign
-            + Signed
-            + Float
-            + fmt::Display
-            + Copy
-            + PartialEq
-            + Debug
-            + std::iter::Product<T>,
-    > Add for Matrix<T>
-{
-    type Output = Self;
 
     fn add(self, other: Self) -> Self::Output {
         if self.data.len() != other.data.len() {
-            panic!("Matrix size is inadecuate.");
+            return Err(MatrixError::InvalidSizeForAdd);
         }
 
         let mut new_data = Vec::new();
@@ -248,31 +313,20 @@ impl<
             new_data.push(self.data[i] + other.data[i]);
         }
 
-        Matrix {
+        Ok(Matrix {
             columns: self.columns,
             rows: self.rows,
             data: new_data,
-        }
+        })
     }
 }
 
-impl<
+impl Sub for Matrix {
-        T: Num
+    type Output = Result<Self, MatrixError>;
-            + NumAssign
-            + Signed
-            + Float
-            + fmt::Display
-            + Copy
-            + PartialEq
-            + Debug
-            + std::iter::Product<T>,
-    > Sub for Matrix<T>
-{
-    type Output = Self;
 
     fn sub(self, other: Self) -> Self::Output {
         if self.data.len() != other.data.len() {
-            panic!("Matrix size is inadecuate.");
+            return Err(MatrixError::InvalidSizeForSub);
         }
 
         let mut new_data = Vec::new();
@@ -280,67 +334,47 @@ impl<
             new_data.push(self.data[i] - other.data[i]);
         }
 
-        Matrix {
+        Ok(Matrix {
             columns: self.columns,
             rows: self.rows,
             data: new_data,
-        }
+        })
     }
 }
 
-impl<
+impl Mul for Matrix {
-        T: Num
+    type Output = Result<Self, MatrixError>;
-            + NumAssign
-            + Signed
-            + Float
-            + fmt::Display
-            + Copy
-            + PartialEq
-            + Debug
-            + std::iter::Product<T>,
-    > Mul for Matrix<T>
-{
-    type Output = Self;
 
     fn mul(self, other: Self) -> Self::Output {
         if self.columns != other.rows {
-            panic!("Matrix dimentions are inadecuate.");
+            return Err(MatrixError::InvalidSizeForMul);
         }
 
-        let mut new_data: Vec<T> = Vec::new();
+        let mut new_data: Vec<Fraction> = Vec::new();
         for i in 0..self.rows {
-            let current_row = self.get_row(i);
-
             for k in 0..other.columns {
-                let current_column = other.get_column(k);
+                let current_column = other.get_column(k)?;
-                let mut new_value = T::zero();
+                let current_row = self.get_row(i)?;
-                for (a, b) in current_row.iter().zip(current_column.iter()) {
+
-                    new_value += *a * *b;
+                let mut new_value = Fraction::new(0, 1).unwrap();
+
+                for (a, b) in current_row.zip(current_column) {
+                    new_value = new_value + (*a * *b);
                 }
+
                 new_data.push(new_value);
             }
         }
 
-        Matrix {
+        Ok(Matrix {
             rows: self.rows,
             columns: other.columns,
             data: new_data,
-        }
+        })
     }
 }
 
-impl<
+impl Display for Matrix {
-        T: Num
-            + NumAssign
-            + Signed
-            + Float
-            + fmt::Display
-            + Copy
-            + PartialEq
-            + Debug
-            + std::iter::Product<T>,
-    > fmt::Display for Matrix<T>
-{
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut display = String::new();
         let mut index = 0;
@@ -359,411 +393,4 @@ impl<
 #[cfg(test)]
 mod tests {
     use super::*;
-
-    #[test]
-    fn sum_two_matrix_1() {
-        let mut matrix1 = Matrix::new(4, 4, 2.0);
-        let matrix2 = Matrix::new(4, 4, 3.0);
-        let result_matrix = Matrix::new(4, 4, 5.0);
-
-        matrix1 = matrix1 + matrix2;
-
-        assert_eq!(matrix1, result_matrix);
-    }
-
-    #[test]
-    fn sum_two_matrix_2() {
-        let mut matrix1 = Matrix::new(4, 4, 2.0);
-        let mut matrix2 = Matrix::new(4, 4, 0.0);
-        let mut result_matrix = Matrix::new(4, 4, 2.0);
-
-        result_matrix.set(0, 0, 9.0);
-        matrix2.set(0, 0, 7.0);
-        matrix1 = matrix1 + matrix2;
-
-        assert_eq!(matrix1, result_matrix);
-    }
-
-    #[test]
-    #[should_panic]
-    fn sum_two_matrix_3() {
-        let mut matrix1 = Matrix::new(4, 4, 2.0);
-        let matrix2 = Matrix::new(4, 5, 0.0);
-
-        matrix1 = matrix1 + matrix2;
-    }
-
-    #[test]
-    fn substract_two_matrix_1() {
-        let mut matrix1 = Matrix::new(4, 4, 2.0);
-        let matrix2 = Matrix::new(4, 4, 3.0);
-        let result_matrix = Matrix::new(4, 4, -1.0);
-
-        matrix1 = matrix1 - matrix2;
-
-        assert_eq!(matrix1, result_matrix);
-    }
-
-    #[test]
-    fn substract_two_matrix_2() {
-        let mut matrix1 = Matrix::new(4, 4, 2.0);
-        let mut matrix2 = Matrix::new(4, 4, 0.0);
-        let mut result_matrix = Matrix::new(4, 4, 2.0);
-
-        result_matrix.set(0, 0, -5.0);
-        matrix2.set(0, 0, 7.0);
-        matrix1 = matrix1 - matrix2;
-
-        assert_eq!(matrix1, result_matrix);
-    }
-
-    #[test]
-    #[should_panic]
-    fn substract_two_matrix_3() {
-        let mut matrix1 = Matrix::new(4, 4, 2.0);
-        let matrix2 = Matrix::new(4, 5, 0.0);
-
-        matrix1 = matrix1 - matrix2;
-    }
-
-    #[test]
-    fn get_row_1() {
-        let mut matrix1 = Matrix::new(3, 4, 0.0);
-        matrix1.set(0, 0, 8.0);
-        matrix1.set(0, 1, 7.0);
-        matrix1.set(0, 2, 9.0);
-        matrix1.set(0, 3, 6.0);
-
-        let data = vec![8.0, 7.0, 9.0, 6.0];
-
-        assert_eq!(matrix1.get_row(0), data);
-    }
-
-    #[test]
-    fn get_row_2() {
-        let mut matrix1 = Matrix::new(3, 4, 0.0);
-
-        matrix1.set(2, 0, 8.0);
-        matrix1.set(2, 1, 7.0);
-        matrix1.set(2, 2, 9.0);
-        matrix1.set(2, 3, 6.0);
-
-        let data = vec![8.0, 7.0, 9.0, 6.0];
-
-        assert_eq!(matrix1.get_row(2), data);
-    }
-
-    #[test]
-    #[should_panic]
-    fn get_row_3() {
-        let matrix1 = Matrix::new(3, 4, 0.0);
-
-        let _data = matrix1.get_row(4);
-    }
-
-    #[test]
-    fn get_column_1() {
-        let mut matrix1 = Matrix::new(4, 3, 0.0);
-        matrix1.set(0, 0, 8.0);
-        matrix1.set(1, 0, 7.0);
-        matrix1.set(2, 0, 9.0);
-        matrix1.set(3, 0, 6.0);
-
-        let data = vec![8.0, 7.0, 9.0, 6.0];
-
-        assert_eq!(matrix1.get_column(0), data);
-    }
-
-    #[test]
-    fn get_column_2() {
-        let mut matrix1 = Matrix::new(4, 3, 0.0);
-
-        matrix1.set(0, 2, 8.0);
-        matrix1.set(1, 2, 7.0);
-        matrix1.set(2, 2, 9.0);
-        matrix1.set(3, 2, 6.0);
-
-        let data = vec![8.0, 7.0, 9.0, 6.0];
-
-        assert_eq!(matrix1.get_column(2), data);
-    }
-
-    #[test]
-    #[should_panic]
-    fn get_column_3() {
-        let matrix1 = Matrix::new(4, 4, 0.0);
-
-        let _data = matrix1.get_column(4);
-    }
-
-    #[test]
-    fn mult_matrix_1() {
-        let mut matrix1 = Matrix::new(4, 4, 2.0);
-        let matrix2 = Matrix::new(4, 4, 2.0);
-        let result_matrix = Matrix::new(4, 4, 16.0);
-
-        matrix1 = matrix1 * matrix2;
-
-        assert_eq!(matrix1, result_matrix);
-    }
-
-    #[test]
-    fn mult_matrix_2() {
-        let mut matrix1 = Matrix::new(4, 4, 2.0);
-        let mut matrix2 = Matrix::new(4, 3, 4.0);
-        let mut result_matrix = Matrix::new(4, 3, 0.0);
-
-        matrix1.set(0, 0, 6.0);
-        matrix1.set(0, 1, 8.0);
-        matrix1.set(0, 2, 9.0);
-        matrix1.set(0, 3, 5.0);
-        matrix1.set(1, 0, 3.0);
-        matrix1.set(1, 1, 8.0);
-        matrix1.set(1, 2, 4.0);
-        matrix1.set(1, 3, 7.0);
-        matrix1.set(2, 0, 4.0);
-        matrix1.set(2, 1, 5.0);
-        matrix1.set(2, 2, 6.0);
-        matrix1.set(2, 3, 4.0);
-        matrix1.set(3, 0, 6.0);
-        matrix1.set(3, 1, 2.0);
-        matrix1.set(3, 2, 2.0);
-        matrix1.set(3, 3, 9.0);
-
-        matrix2.set(0, 0, 7.0);
-        matrix2.set(0, 1, 6.0);
-        matrix2.set(0, 2, 1.0);
-        matrix2.set(1, 0, 6.0);
-        matrix2.set(1, 1, 4.0);
-        matrix2.set(1, 2, 8.0);
-        matrix2.set(2, 0, 3.0);
-        matrix2.set(2, 1, 0.0);
-        matrix2.set(2, 2, 6.0);
-        matrix2.set(3, 0, 1.0);
-        matrix2.set(3, 1, 1.0);
-        matrix2.set(3, 2, 1.0);
-
-        result_matrix.set(0, 0, 122.0);
-        result_matrix.set(0, 1, 73.0);
-        result_matrix.set(0, 2, 129.0);
-        result_matrix.set(1, 0, 88.0);
-        result_matrix.set(1, 1, 57.0);
-        result_matrix.set(1, 2, 98.0);
-        result_matrix.set(2, 0, 80.0);
-        result_matrix.set(2, 1, 48.0);
-        result_matrix.set(2, 2, 84.0);
-        result_matrix.set(3, 0, 69.0);
-        result_matrix.set(3, 1, 53.0);
-        result_matrix.set(3, 2, 43.0);
-
-        matrix1 = matrix1 * matrix2;
-
-        assert_eq!(result_matrix, matrix1);
-    }
-
-    #[test]
-    fn exchange_rows_1() {
-        let mut matrix = Matrix::new(3, 4, 5.0);
-        matrix.set(0, 0, 1.0);
-        matrix.set(0, 1, 2.0);
-        matrix.set(0, 2, 3.0);
-        matrix.set(0, 3, 4.0);
-        matrix.set(1, 0, 5.0);
-        matrix.set(1, 1, 6.0);
-        matrix.set(1, 2, 7.0);
-        matrix.set(1, 3, 8.0);
-
-        matrix.exchange_rows(0, 1);
-
-        let row1 = vec![1.0, 2.0, 3.0, 4.0];
-        let row2 = vec![5.0, 6.0, 7.0, 8.0];
-
-        assert_eq!(row1, matrix.get_row(1));
-        assert_eq!(row2, matrix.get_row(0));
-    }
-
-    #[test]
-    fn exchange_rows_2() {
-        let mut matrix = Matrix::new(3, 4, 5.0);
-        matrix.set(0, 0, 1.0);
-        matrix.set(0, 1, 2.0);
-        matrix.set(0, 2, 3.0);
-        matrix.set(0, 3, 4.0);
-        matrix.set(2, 0, 5.0);
-        matrix.set(2, 1, 6.0);
-        matrix.set(2, 2, 7.0);
-        matrix.set(2, 3, 8.0);
-
-        matrix.exchange_rows(0, 2);
-
-        let row1 = vec![1.0, 2.0, 3.0, 4.0];
-        let row2 = vec![5.0, 6.0, 7.0, 8.0];
-
-        assert_eq!(row1, matrix.get_row(2));
-        assert_eq!(row2, matrix.get_row(0));
-    }
-
-    #[test]
-    fn exchange_columns_1() {
-        let mut matrix = Matrix::new(3, 4, 5.0);
-        matrix.set(0, 0, 1.0);
-        matrix.set(1, 0, 2.0);
-        matrix.set(2, 0, 3.0);
-        matrix.set(0, 1, 4.0);
-        matrix.set(1, 1, 5.0);
-        matrix.set(2, 1, 6.0);
-
-        matrix.exchange_columns(0, 1);
-
-        let column1 = vec![1.0, 2.0, 3.0];
-        let column2 = vec![4.0, 5.0, 6.0];
-
-        assert_eq!(column1, matrix.get_column(1));
-        assert_eq!(column2, matrix.get_column(0));
-    }
-
-    #[test]
-    fn exchange_columns_2() {
-        let mut matrix = Matrix::new(3, 4, 5.0);
-        matrix.set(0, 0, 1.0);
-        matrix.set(1, 0, 2.0);
-        matrix.set(2, 0, 3.0);
-        matrix.set(0, 3, 4.0);
-        matrix.set(1, 3, 5.0);
-        matrix.set(2, 3, 6.0);
-
-        matrix.exchange_columns(0, 3);
-
-        let column1 = vec![1.0, 2.0, 3.0];
-        let column2 = vec![4.0, 5.0, 6.0];
-
-        assert_eq!(column1, matrix.get_column(3));
-        assert_eq!(column2, matrix.get_column(0));
-    }
-
-    #[test]
-    fn set_row_1() {
-        let mut matrix = Matrix::new(3, 4, 5.0);
-        let vec1 = vec![1.0, 2.0, 3.0, 4.0];
-        matrix.set_row(0, vec1);
-
-        let vec2 = vec![1.0, 2.0, 3.0, 4.0];
-        let row = matrix.get_row(0);
-        assert_eq!(row, vec2);
-    }
-
-    #[test]
-    fn set_row_2() {
-        let mut matrix = Matrix::new(3, 4, 5.0);
-        let vec1 = vec![1.0, 2.0, 3.0, 4.0];
-        matrix.set_row(2, vec1);
-
-        let vec2 = vec![1.0, 2.0, 3.0, 4.0];
-        let row = matrix.get_row(2);
-        assert_eq!(row, vec2);
-    }
-
-    #[test]
-    fn set_column_1() {
-        let mut matrix = Matrix::new(3, 4, 5.0);
-        let vec1 = vec![1.0, 2.0, 3.0];
-        matrix.set_column(0, vec1);
-
-        let vec2 = vec![1.0, 2.0, 3.0];
-        let column = matrix.get_column(0);
-        assert_eq!(column, vec2);
-    }
-
-    #[test]
-    fn set_column_2() {
-        let mut matrix = Matrix::new(3, 4, 5.0);
-        let vec1 = vec![1.0, 2.0, 3.0];
-        matrix.set_column(3, vec1);
-
-        let vec2 = vec![1.0, 2.0, 3.0];
-        let column = matrix.get_column(3);
-        assert_eq!(column, vec2);
-    }
-
-    #[test]
-    fn get_diagonal_1() {
-        let mut matrix = Matrix::new(3, 3, 8.0);
-        matrix.set(0, 0, 1.0);
-        matrix.set(1, 1, 2.0);
-        matrix.set(2, 2, 3.0);
-
-        let vec1 = vec![1.0, 2.0, 3.0];
-        assert_eq!(matrix.get_diagonal(), vec1);
-    }
-
-    #[test]
-    fn get_diagonal_2() {
-        let mut matrix = Matrix::new(4, 4, 8.0);
-        matrix.set(0, 0, 1.0);
-        matrix.set(1, 1, 2.0);
-        matrix.set(2, 2, 3.0);
-        matrix.set(3, 3, 4.0);
-
-        let vec1 = vec![1.0, 2.0, 3.0, 4.0];
-        assert_eq!(matrix.get_diagonal(), vec1);
-    }
-
-    #[test]
-    fn get_determinant_1() {
-        let mut matrix = Matrix::new(2, 2, 0.0);
-        matrix.set(0, 0, 2.0);
-        matrix.set(1, 0, 4.0);
-        matrix.set(0, 1, 3.0);
-        matrix.set(1, 1, 5.0);
-
-        assert_eq!(matrix.get_determinant(), -2.0);
-    }
-
-    #[test]
-    fn get_determinant_2() {
-        let mut matrix = Matrix::new(3, 3, 0.0);
-        matrix.set(0, 0, 3.0);
-        matrix.set(1, 0, 4.0);
-        matrix.set(2, 0, 7.0);
-        matrix.set(0, 1, 2.0);
-        matrix.set(1, 1, 5.0);
-        matrix.set(2, 1, 8.0);
-        matrix.set(0, 2, 1.0);
-        matrix.set(1, 2, 6.0);
-        matrix.set(2, 2, 9.0);
-
-        assert_eq!(matrix.get_determinant(), 0.0);
-    }
-
-    #[test]
-    fn get_determinant_3() {
-        let mut matrix = Matrix::new(3, 3, 0.0);
-        matrix.set(0, 0, 0.0);
-        matrix.set(1, 0, 1.0);
-        matrix.set(2, 0, 2.0);
-        matrix.set(0, 1, 2.0);
-        matrix.set(1, 1, 3.0);
-        matrix.set(2, 1, 1.0);
-        matrix.set(0, 2, 1.0);
-        matrix.set(1, 2, 4.0);
-        matrix.set(2, 2, 3.0);
-
-        assert_eq!(matrix.get_determinant(), 5.0);
-    }
-
-    #[test]
-    fn get_determinant_4() {
-        let mut matrix = Matrix::new(3, 3, 0.0);
-        matrix.set(0, 0, 2.0);
-        matrix.set(1, 0, 0.0);
-        matrix.set(2, 0, 1.0);
-        matrix.set(0, 1, 3.0);
-        matrix.set(1, 1, 4.0);
-        matrix.set(2, 1, 0.0);
-        matrix.set(0, 2, 5.0);
-        matrix.set(1, 2, 1.0);
-        matrix.set(2, 2, 6.0);
-
-        assert_eq!(matrix.get_determinant(), 31.0);
-    }
 }

src/main.rs

@@ -1,8 +1,3 @@
-use matrix::Matrix;
-
 fn main() {
     println!("Hola mundo que rollo wey");
-    let mut matriz1 = Matrix::new(10, 15, 0.0);
-    matriz1.set(5, 5, 40.0);
-    println!("{}", matriz1);
 }