To make this clearer here are the implementations of **disjoint_columns_mut** and **disjoint_rows_mut**.

```
/// Create two mutable column slices to a Matrix.
///
/// This is safe when the columns are disjoint and the Matix has StorageMut, in this case the Matrix elements
/// refered to by the two columns must be disjoint.
pub fn disjoint_columns_mut<N: RealField, R: Dim, C: Dim, S: StorageMut<N, R, C>>(m: &mut Matrix<N, R, C, S>, col1: usize, col2: usize) ->
(Matrix<N, R, U1, SliceStorageMut<N, R, U1, U1, U1>>, MatrixSliceMut<N, R, U1, S::RStride, S::CStride>)
{
assert!(col1 != col2, "columns not disjoint");
let col_shape = (m.data.shape().0, U1);
unsafe {
let col_start_ptr = m.as_mut_ptr().offset((col1 * m.nrows()) as isize);
let data1 = SliceStorageMut::from_raw_parts(col_start_ptr, col_shape, (U1, U1));
let col_slice1 = Matrix::from_data_statically_unchecked(data1);
(col_slice1, m.column_mut(col2))
}
}
/// Create two mutable row slices to a Matrix.
///
/// This is safe when the rows are disjoint and the Matix has StorageMut, in this case the Matrix elements
/// refered to by the two rows must be disjoint.
pub fn disjoint_rows_mut<N: RealField, R: Dim, C: Dim, S: StorageMut<N, R, C>>(m: &mut Matrix<N, R, C, S>, row1: usize, row2: usize) ->
(Matrix<N, U1, C, SliceStorageMut<N, U1, C, U1, R>>, MatrixSliceMut<N, U1, C, S::RStride, S::CStride>)
{
assert!(row1 != row2, "rows not disjoint");
let row_shape = (U1, m.data.shape().1);
unsafe {
let col_start_ptr = m.as_mut_ptr();
let data1 = SliceStorageMut::from_raw_parts(col_start_ptr, row_shape, (U1, m.data.shape().0));
let row_slice1 = Matrix::from_data_statically_unchecked(data1);
(row_slice1, m.row_mut(row2))
}
}
```