Merge #333 #334

333: Remove remaining debug_assert calls r=samueltardieu a=samueltardieu



334: Remove unused uninit/assume_init on Matrix r=samueltardieu a=samueltardieu

The `Vec<C>` and `Vec<MaybeUninit<C>>` don't have any long-term
guarantee of having the same in-memory representation.


Co-authored-by: Samuel Tardieu <[email protected]>

Author: bors[bot]

src/kuhn_munkres.rs

@@ -128,7 +128,6 @@ where
                         y = yy;
                     }
                 }
-                debug_assert!(s.contains(x));
                 // If some slack has been found, remove it from x nodes in the
                 // alternating path, and add it to y nodes in the alternating path.
                 // The slack of y nodes outside the alternating path will be reduced
@@ -145,7 +144,6 @@ where
                         }
                     }
                 }
-                debug_assert!(lx[x] + ly[y] == weights.at(x, y));
                 // Add (x, y) to the alternating path.
                 alternating[y] = Some(x);
                 if yx[y].is_none() {
@@ -155,7 +153,6 @@ where
                 // This y node had a predecessor, add it to the set of x nodes
                 // in the augmenting path.
                 let x = yx[y].unwrap();
-                debug_assert!(!s.contains(x));
                 s.insert(x);
                 // Update slack because of the added vertex in s might contain a
                 // greater slack than with previously inserted x nodes in the augmenting

src/matrix.rs

@@ -8,7 +8,6 @@ use itertools::Itertools;
 use num_traits::Signed;
 use std::collections::BTreeSet;
 use std::iter::FusedIterator;
-use std::mem::MaybeUninit;
 use std::ops::{Deref, DerefMut, Index, IndexMut, Neg, Range};
 use std::slice::{Iter, IterMut};
 use thiserror::Error;
@@ -232,20 +231,6 @@ impl<C> Matrix<C> {
         })
     }
 
-    /// Construct a new Matrix with uninitialized content.
-    pub fn new_uninit(rows: usize, columns: usize) -> Matrix<MaybeUninit<C>> {
-        let data_len = rows * columns;
-        let mut data = Vec::with_capacity(data_len);
-        unsafe {
-            data.set_len(data_len);
-        }
-        Matrix {
-            rows,
-            columns,
-            data,
-        }
-    }
-
     /// Create new square matrix from vector values. The first value
     /// will be assigned to index (0, 0), the second one to index (0, 1),
     /// and so on. An error is returned if the number of values is not a
@@ -636,23 +621,6 @@ impl<C> Matrix<C> {
     }
 }
 
-impl<C> Matrix<MaybeUninit<C>> {
-    /// Convert to `Matrix<C>`.
-    ///
-    /// # Safety
-    ///
-    /// As with [`MaybeUninit::assume_init()`], it is up to the caller to guarantee
-    /// that the value really is in an initialized state. Calling this when the content
-    /// is not yet fully initialized causes immediate undefined behavior.
-    pub unsafe fn assume_init(self) -> Matrix<C> {
-        Matrix {
-            rows: self.rows,
-            columns: self.columns,
-            data: std::mem::transmute(self.data),
-        }
-    }
-}
-
 impl<C> Index<(usize, usize)> for Matrix<C> {
     type Output = C;
 

tests/matrix.rs

@@ -574,23 +574,6 @@ fn in_direction() {
     );
 }
 
-#[test]
-fn uninit() {
-    struct NonClonable(usize);
-    let mut mat = Matrix::<NonClonable>::new_uninit(3, 3);
-    for row in 0..mat.rows {
-        for column in 0..mat.columns {
-            mat[(row, column)].write(NonClonable(3 * row + column));
-        }
-    }
-    let mat = unsafe { mat.assume_init() };
-    for row in 0..mat.rows {
-        for column in 0..mat.columns {
-            assert_eq!(mat[(row, column)].0, row * 3 + column);
-        }
-    }
-}
-
 #[test]
 fn map() {
     let m = Matrix::new(3, 3, 10);