addtion/fix: added insert column and row

src/lib.rs

@@ -86,50 +86,50 @@ impl Matrix {
         Ok((0..self.rows).map(move |i| &self.data[i * self.columns + i]))
     }
 
-    pub fn set(&mut self, row: usize, column: usize, data: Fraction) -> Option<MatrixError> {
+    pub fn set(&mut self, row: usize, column: usize, data: Fraction) -> Result<(), MatrixError> {
         if row >= self.rows || column >= self.columns {
-            return Some(MatrixError::IndexOutOfRange);
+            return Err(MatrixError::IndexOutOfRange);
         }
         let mut index = 0;
         index += row * self.columns;
         index += column;
         self.data[index] = data;
-        return None;
+        Ok(())
     }
 
-    pub fn set_row(&mut self, row: usize, data: Vec<Fraction>) -> Option<MatrixError> {
+    pub fn set_row(&mut self, row: usize, data: Vec<Fraction>) -> Result<(), MatrixError> {
         if row >= self.rows {
-            return Some(MatrixError::IndexOutOfRange);
+            return Err(MatrixError::IndexOutOfRange);
         }
         if data.len() != self.columns {
-            return Some(MatrixError::InvalidDataSize);
+            return Err(MatrixError::InvalidDataSize);
         }
 
         for i in 0..data.len() {
-            self.set(row, i, data[i]);
+            self.set(row, i, data[i])?;
         }
 
-        None
+        Ok(())
     }
 
-    pub fn set_column(&mut self, column: usize, data: Vec<Fraction>) -> Option<MatrixError> {
+    pub fn set_column(&mut self, column: usize, data: Vec<Fraction>) -> Result<(), MatrixError> {
         if column >= self.columns {
-            return Some(MatrixError::ColumnOutOfRange);
+            return Err(MatrixError::ColumnOutOfRange);
         }
         if data.len() != self.rows {
-            return Some(MatrixError::InvalidDataSize);
+            return Err(MatrixError::InvalidDataSize);
         }
 
         for i in 0..data.len() {
-            self.set(i, column, data[i]);
+            self.set(i, column, data[i])?;
         }
 
-        None
+        Ok(())
     }
 
-    pub fn exchange_rows(&mut self, row1: usize, row2: usize) -> Option<MatrixError> {
+    pub fn exchange_rows(&mut self, row1: usize, row2: usize) -> Result<(), MatrixError> {
         if row1 >= self.rows || row2 >= self.rows {
-            return Some(MatrixError::RowOutOfRange);
+            return Err(MatrixError::RowOutOfRange);
         }
 
         let start1 = row1 * self.columns;
@@ -139,12 +139,12 @@ impl Matrix {
             self.data.swap(start1 + i, start2 + i);
         }
 
-        None
+        Ok(())
     }
 
-    pub fn exchange_columns(&mut self, column1: usize, column2: usize) -> Option<MatrixError> {
+    pub fn exchange_columns(&mut self, column1: usize, column2: usize) -> Result<(), MatrixError> {
         if column1 >= self.columns || column2 >= self.columns {
-            return Some(MatrixError::ColumnOutOfRange);
+            return Err(MatrixError::ColumnOutOfRange);
         }
 
         for i in 0..self.rows {
@@ -154,62 +154,43 @@ impl Matrix {
             self.data.swap(idx1, idx2);
         }
 
-        None
+        Ok(())
     }
 
-    pub fn append_column(&mut self, data: Vec<Fraction>) -> Option<MatrixError> {
+    pub fn insert_column(&mut self, index: usize, data: Vec<Fraction>) -> Result<(), MatrixError> {
-        if data.len() != self.columns {
+        if index >= self.columns {
-            return Some(MatrixError::InvalidDataSize);
+            return Err(MatrixError::ColumnOutOfRange);
         }
 
-        for i in 0..data.len() {
+        if data.len() != self.rows {
-            self.data
+            return Err(MatrixError::InvalidDataSize);
-                .insert((i * self.rows) + self.rows + i - 1, data[i]);
+        }
+
+        for i in 0..self.rows {
+            self.data.insert((i * self.columns) + index + i, data[i]);
         }
 
         self.columns += 1;
 
-        None
+        Ok(())
     }
 
-    pub fn append_row(&mut self, data: Vec<Fraction>) -> Option<MatrixError> {
+    pub fn insert_rows(&mut self, index: usize, data: Vec<Fraction>) -> Result<(), MatrixError> {
-        if data.len() != self.rows {
+        if index >= self.rows {
-            return Some(MatrixError::InvalidDataSize);
+            return Err(MatrixError::RowOutOfRange);
         }
 
-        for i in 0..data.len() {
+        if data.len() != self.columns {
-            self.data.push(data[i]);
+            return Err(MatrixError::InvalidDataSize);
+        }
+
+        for i in 0..self.columns {
+            self.data.insert((i * self.columns) + i, data[i]);
         }
 
         self.rows += 1;
 
-        None
+        Ok(())
-    }
-
-    pub fn pop_column(&mut self) -> Option<MatrixError> {
-        if self.columns <= 1 {
-            return Some(MatrixError::InvalidDataSize);
-        }
-
-        for i in 0..self.columns {
-            self.data.remove((i * self.rows) + self.rows - i - 1);
-        }
-
-        self.columns -= 1;
-
-        None
-    }
-
-    pub fn pop_row(&mut self) -> Option<MatrixError> {
-        if self.rows <= 1 {
-            return Some(MatrixError::InvalidDataSize);
-        }
-
-        for _i in 0..self.rows {
-            self.data.pop();
-        }
-
-        None
     }
 
     fn partial_pivoting(&mut self, col: usize, sign: &mut Fraction) -> Result<bool, MatrixError> {
@@ -233,10 +214,7 @@ impl Matrix {
         }
 
         if max_row != col {
-            match self.exchange_rows(col, max_row) {
+            self.exchange_rows(col, max_row)?;
-                Some(err) => return Err(err),
-                None => {}
-            };
             *sign = -*sign;
         }
 
@@ -276,7 +254,7 @@ impl Matrix {
                     .map(|(a, b)| *a - m * *b)
                     .collect::<Vec<Fraction>>();
 
-                trig_matrix.set_row(x, new_row);
+                trig_matrix.set_row(x, new_row)?;
             }
         }
 
@@ -306,7 +284,7 @@ impl Matrix {
                 .map(|x| *x / pivot)
                 .collect::<Result<Vec<_>, _>>()?;
 
-            new_matrix.set_row(i, new_pivot_row);
+            new_matrix.set_row(i, new_pivot_row)?;
 
             for r in 0..new_matrix.rows {
                 if r == i {
@@ -325,7 +303,7 @@ impl Matrix {
                     .map(|(a, b)| *a - factor * *b)
                     .collect::<Vec<Fraction>>();
 
-                new_matrix.set_row(r, new_row_normalized);
+                new_matrix.set_row(r, new_row_normalized)?;
             }
         }