test: determinant

src/lib.rs

@@ -27,7 +27,7 @@ impl From<FractionError> for MatrixError {
     }
 }
 
-#[derive(PartialEq, Eq, Debug)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 pub struct Matrix {
     rows: usize,
     columns: usize,
@@ -2554,4 +2554,163 @@ mod tests {
             assert_eq!(*res.get(i, i).unwrap(), Fraction::from(1));
         }
     }
+
+    #[test]
+    fn test_det_1x1() {
+        let m = Matrix {
+            rows: 1,
+            columns: 1,
+            data: vec![Fraction::from(5)],
+        };
+
+        let det = m.get_determinant().unwrap();
+
+        assert_eq!(det, Fraction::from(5));
+    }
+
+    #[test]
+    fn test_det_identity() {
+        let m = Matrix {
+            rows: 3,
+            columns: 3,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(0),
+                Fraction::from(0),
+                Fraction::from(0),
+                Fraction::from(1),
+                Fraction::from(0),
+                Fraction::from(0),
+                Fraction::from(0),
+                Fraction::from(1),
+            ],
+        };
+
+        let det = m.get_determinant().unwrap();
+
+        assert_eq!(det, Fraction::from(1));
+    }
+
+    #[test]
+    fn test_det_upper_triangular() {
+        let m = Matrix {
+            rows: 3,
+            columns: 3,
+            data: vec![
+                Fraction::from(2),
+                Fraction::from(1),
+                Fraction::from(3),
+                Fraction::from(0),
+                Fraction::from(4),
+                Fraction::from(5),
+                Fraction::from(0),
+                Fraction::from(0),
+                Fraction::from(6),
+            ],
+        };
+
+        let det = m.get_determinant().unwrap();
+
+        assert_eq!(det, Fraction::from(2 * 4 * 6));
+    }
+
+    #[test]
+    fn test_det_row_swap_sign() {
+        let m = Matrix {
+            rows: 2,
+            columns: 2,
+            data: vec![
+                Fraction::from(0),
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(3),
+            ],
+        };
+
+        let det = m.get_determinant().unwrap();
+
+        // determinante = (0*3 - 1*2) = -2
+        assert_eq!(det, Fraction::from(-2));
+    }
+
+    #[test]
+    fn test_det_singular_matrix() {
+        let m = Matrix {
+            rows: 2,
+            columns: 2,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(2),
+                Fraction::from(4),
+            ],
+        };
+
+        let det = m.get_determinant().unwrap();
+
+        assert!(det.is_zero());
+    }
+
+    #[test]
+    fn test_det_3x3_known() {
+        let m = Matrix {
+            rows: 3,
+            columns: 3,
+            data: vec![
+                Fraction::from(6),
+                Fraction::from(1),
+                Fraction::from(1),
+                Fraction::from(4),
+                Fraction::from(-2),
+                Fraction::from(5),
+                Fraction::from(2),
+                Fraction::from(8),
+                Fraction::from(7),
+            ],
+        };
+
+        let det = m.get_determinant().unwrap();
+
+        // determinante = -306
+        assert_eq!(det, Fraction::from(-306));
+    }
+
+    #[test]
+    fn test_det_not_squared() {
+        let m = Matrix::new(2, 3, Fraction::from(1)).unwrap();
+
+        let res = m.get_determinant();
+
+        assert!(matches!(res, Err(MatrixError::NotSquared)));
+    }
+
+    #[test]
+    fn test_det_scalar_multiple() {
+        let m = Matrix {
+            rows: 2,
+            columns: 2,
+            data: vec![
+                Fraction::from(1),
+                Fraction::from(2),
+                Fraction::from(3),
+                Fraction::from(4),
+            ],
+        };
+
+        let mut scaled = m.clone();
+
+        // multiplicar fila 0 por 2
+        let row0 = scaled
+            .get_row(0)
+            .unwrap()
+            .map(|x| *x * Fraction::from(2))
+            .collect();
+
+        scaled.set_row(0, row0).unwrap();
+
+        let det_original = m.get_determinant().unwrap();
+        let det_scaled = scaled.get_determinant().unwrap();
+
+        assert_eq!(det_scaled, det_original * Fraction::from(2));
+    }
 }