M-Labs/nalgebra
3
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Change zero_or_uninitialized_generic to unimplemented_or_uninitialized_generic, and use it instead of manually dispatching on feature=no_unsound_assume_init in functions without N: Zero.

Browse Source
This commit is contained in:
Avi Weinstock 2020-11-27 15:58:48 -05:00 committed by Crozet Sébastien
parent 36a3ac814f
commit cd12422d6f
16 changed files with 62 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/base/blas.rs
View File

@ -1328,10 +1328,7 @@ where
ShapeConstraint: DimEq<D1, D1> + DimEq<D1, R3> + DimEq<C3, D4>, ShapeConstraint: DimEq<D1, D1> + DimEq<D1, R3> + DimEq<C3, D4>,
DefaultAllocator: Allocator<N, D1>, DefaultAllocator: Allocator<N, D1>,
{ {
#[cfg(feature="no_unsound_assume_init")] let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, U1) };
let mut work = Vector::zeros_generic(self.data.shape().0, U1);
#[cfg(not(feature="no_unsound_assume_init"))]
let mut work = unsafe { Vector::new_uninitialized_generic(self.data.shape().0, U1).assume_init() };
self.quadform_tr_with_workspace(&mut work, alpha, lhs, mid, beta) self.quadform_tr_with_workspace(&mut work, alpha, lhs, mid, beta)
} }
@ -1424,10 +1421,7 @@ where
ShapeConstraint: DimEq<D2, R3> + DimEq<D1, C3> + AreMultipliable<C3, R3, D2, U1>, ShapeConstraint: DimEq<D2, R3> + DimEq<D1, C3> + AreMultipliable<C3, R3, D2, U1>,
DefaultAllocator: Allocator<N, D2>, DefaultAllocator: Allocator<N, D2>,
{ {
#[cfg(feature="no_unsound_assume_init")] let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(mid.data.shape().0, U1) };
let mut work = Vector::zeros_generic(mid.data.shape().0, U1);
#[cfg(not(feature="no_unsound_assume_init"))]
let mut work = unsafe { Vector::new_uninitialized_generic(mid.data.shape().0, U1).assume_init() };
self.quadform_with_workspace(&mut work, alpha, mid, rhs, beta) self.quadform_with_workspace(&mut work, alpha, mid, rhs, beta)
} }
} }

25
src/base/construction.rs
View File

@ -26,12 +26,19 @@ use crate::base::dimension::{Dim, DimName, Dynamic, U1, U2, U3, U4, U5, U6};
use crate::base::storage::Storage; use crate::base::storage::Storage;
use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar, Unit, Vector, VectorN}; use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar, Unit, Vector, VectorN};
/// When "no_unsound_assume_init" is enabled, expands to `zeros_generic()` instead of `new_uninitialized_generic().assume_init()`. /// When "no_unsound_assume_init" is enabled, expands to `unimplemented!()` instead of `new_uninitialized_generic().assume_init()`.
/// Intended for use in contexts where the `Scalar` type implements `num_traits::Zero`, to check whether uninitialized memory is actually performance-critical. /// Intended as a placeholder, each callsite should be refactored to use uninitialized memory soundly
#[macro_export] #[macro_export]
macro_rules! zero_or_uninitialized_generic { macro_rules! unimplemented_or_uninitialized_generic {
($nrows:expr, $ncols:expr) => {{ ($nrows:expr, $ncols:expr) => {{
#[cfg(feature="no_unsound_assume_init")] { crate::base::Matrix::zeros_generic($nrows, $ncols) } #[cfg(feature="no_unsound_assume_init")] {
// Some of the call sites need the number of rows and columns from this to infer a type, so
// uninitialized memory is used to infer the type, as `N: Zero` isn't available at all callsites.
// This may technically still be UB even though the assume_init is dead code, but all callsites should be fixed before #556 is closed.
let typeinference_helper = crate::base::Matrix::new_uninitialized_generic($nrows, $ncols);
unimplemented!();
typeinference_helper.assume_init()
}
#[cfg(not(feature="no_unsound_assume_init"))] { crate::base::Matrix::new_uninitialized_generic($nrows, $ncols).assume_init() } #[cfg(not(feature="no_unsound_assume_init"))] { crate::base::Matrix::new_uninitialized_generic($nrows, $ncols).assume_init() }
}} }}
} }
@ -99,10 +106,7 @@ where
"Matrix init. error: the slice did not contain the right number of elements." "Matrix init. error: the slice did not contain the right number of elements."
); );
#[cfg(feature="no_unsound_assume_init")] let mut res = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
let mut res: Self = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { Self::new_uninitialized_generic(nrows, ncols).assume_init() };
let mut iter = slice.iter(); let mut iter = slice.iter();
for i in 0..nrows.value() { for i in 0..nrows.value() {
@ -128,10 +132,7 @@ where
where where
F: FnMut(usize, usize) -> N, F: FnMut(usize, usize) -> N,
{ {
#[cfg(feature="no_unsound_assume_init")] let mut res: Self = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
let mut res: Self = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { Self::new_uninitialized_generic(nrows, ncols).assume_init() };
for j in 0..ncols.value() { for j in 0..ncols.value() {
for i in 0..nrows.value() { for i in 0..nrows.value() {

10
src/base/conversion.rs
View File

@ -50,10 +50,7 @@ where
let nrows2 = R2::from_usize(nrows); let nrows2 = R2::from_usize(nrows);
let ncols2 = C2::from_usize(ncols); let ncols2 = C2::from_usize(ncols);
#[cfg(feature="no_unsound_assume_init")] let mut res: MatrixMN<N2, R2, C2> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows2, ncols2) };
let mut res: MatrixMN<N2, R2, C2> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { MatrixMN::<N2, R2, C2>::new_uninitialized_generic(nrows2, ncols2).assume_init() };
for i in 0..nrows { for i in 0..nrows {
for j in 0..ncols { for j in 0..ncols {
unsafe { unsafe {
@ -76,10 +73,7 @@ where
let nrows = R1::from_usize(nrows2); let nrows = R1::from_usize(nrows2);
let ncols = C1::from_usize(ncols2); let ncols = C1::from_usize(ncols2);
#[cfg(feature="no_unsound_assume_init")] let mut res: Self = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
let mut res: Self = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { Self::new_uninitialized_generic(nrows, ncols).assume_init() };
for i in 0..nrows2 { for i in 0..nrows2 {
for j in 0..ncols2 { for j in 0..ncols2 {
unsafe { unsafe {

19
src/base/edition.rs
View File

@ -54,7 +54,7 @@ impl<N: Scalar + Zero, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
{ {
let irows = irows.into_iter(); let irows = irows.into_iter();
let ncols = self.data.shape().1; let ncols = self.data.shape().1;
let mut res = unsafe { crate::zero_or_uninitialized_generic!(Dynamic::new(irows.len()), ncols) }; let mut res = unsafe { crate::unimplemented_or_uninitialized_generic!(Dynamic::new(irows.len()), ncols) };
// First, check that all the indices from irows are valid. // First, check that all the indices from irows are valid.
// This will allow us to use unchecked access in the inner loop. // This will allow us to use unchecked access in the inner loop.
@ -89,7 +89,7 @@ impl<N: Scalar + Zero, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
let icols = icols.into_iter(); let icols = icols.into_iter();
let nrows = self.data.shape().0; let nrows = self.data.shape().0;
let mut res = let mut res =
unsafe { crate::zero_or_uninitialized_generic!(nrows, Dynamic::new(icols.len())) }; unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, Dynamic::new(icols.len())) };
for (destination, source) in icols.enumerate() { for (destination, source) in icols.enumerate() {
res.column_mut(destination).copy_from(&self.column(*source)) res.column_mut(destination).copy_from(&self.column(*source))
@ -895,10 +895,7 @@ impl<N: Scalar> DMatrix<N> {
where where
DefaultAllocator: Reallocator<N, Dynamic, Dynamic, Dynamic, Dynamic>, DefaultAllocator: Reallocator<N, Dynamic, Dynamic, Dynamic, Dynamic>,
{ {
#[cfg(feature="no_unsound_assume_init")] let placeholder = unsafe { crate::unimplemented_or_uninitialized_generic!(Dynamic::new(0), Dynamic::new(0)) };
let placeholder = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let placeholder = unsafe { Self::new_uninitialized(0, 0).assume_init() };
let old = mem::replace(self, placeholder); let old = mem::replace(self, placeholder);
let new = old.resize(new_nrows, new_ncols, val); let new = old.resize(new_nrows, new_ncols, val);
let _ = mem::replace(self, new); let _ = mem::replace(self, new);
@ -921,10 +918,7 @@ where
where where
DefaultAllocator: Reallocator<N, Dynamic, C, Dynamic, C>, DefaultAllocator: Reallocator<N, Dynamic, C, Dynamic, C>,
{ {
#[cfg(feature="no_unsound_assume_init")] let placeholder = unsafe { crate::unimplemented_or_uninitialized_generic!(Dynamic::new(0), self.data.shape().1) };
let placeholder = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let placeholder = unsafe { Self::new_uninitialized_generic(Dynamic::new(0), self.data.shape().1).assume_init() };
let old = mem::replace(self, placeholder); let old = mem::replace(self, placeholder);
let new = old.resize_vertically(new_nrows, val); let new = old.resize_vertically(new_nrows, val);
let _ = mem::replace(self, new); let _ = mem::replace(self, new);
@ -947,10 +941,7 @@ where
where where
DefaultAllocator: Reallocator<N, R, Dynamic, R, Dynamic>, DefaultAllocator: Reallocator<N, R, Dynamic, R, Dynamic>,
{ {
#[cfg(feature="no_unsound_assume_init")] let placeholder = unsafe { crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, Dynamic::new(0)) };
let placeholder = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let placeholder = unsafe { Self::new_uninitialized_generic(self.data.shape().0, Dynamic::new(0)).assume_init() };
let old = mem::replace(self, placeholder); let old = mem::replace(self, placeholder);
let new = old.resize_horizontally(new_ncols, val); let new = old.resize_horizontally(new_ncols, val);
let _ = mem::replace(self, new); let _ = mem::replace(self, new);

52
src/base/matrix.rs
View File

@ -507,10 +507,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
let nrows: SameShapeR<R, R2> = Dim::from_usize(nrows); let nrows: SameShapeR<R, R2> = Dim::from_usize(nrows);
let ncols: SameShapeC<C, C2> = Dim::from_usize(ncols); let ncols: SameShapeC<C, C2> = Dim::from_usize(ncols);
#[cfg(feature="no_unsound_assume_init")] let mut res: MatrixSum<N, R, C, R2, C2> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
let mut res: MatrixSum<N, R, C, R2, C2> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res: MatrixSum<N, R, C, R2, C2> = unsafe { Matrix::new_uninitialized_generic(nrows, ncols).assume_init() };
// TODO: use copy_from // TODO: use copy_from
for j in 0..res.ncols() { for j in 0..res.ncols() {
@ -559,10 +556,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
let (nrows, ncols) = self.data.shape(); let (nrows, ncols) = self.data.shape();
unsafe { unsafe {
#[cfg(feature="no_unsound_assume_init")] let mut res = crate::unimplemented_or_uninitialized_generic!(ncols, nrows);
let mut res = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = Matrix::new_uninitialized_generic(ncols, nrows).assume_init();
self.transpose_to(&mut res); self.transpose_to(&mut res);
res res
@ -580,10 +574,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
{ {
let (nrows, ncols) = self.data.shape(); let (nrows, ncols) = self.data.shape();
#[cfg(feature="no_unsound_assume_init")] let mut res: MatrixMN<N2, R, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
let mut res: MatrixMN<N2, R, C> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { MatrixMN::new_uninitialized_generic(nrows, ncols).assume_init() };
for j in 0..ncols.value() { for j in 0..ncols.value() {
for i in 0..nrows.value() { for i in 0..nrows.value() {
@ -627,10 +618,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
{ {
let (nrows, ncols) = self.data.shape(); let (nrows, ncols) = self.data.shape();
#[cfg(feature="no_unsound_assume_init")] let mut res: MatrixMN<N2, R, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
let mut res: MatrixMN<N2, R, C> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { MatrixMN::new_uninitialized_generic(nrows, ncols).assume_init() };
for j in 0..ncols.value() { for j in 0..ncols.value() {
for i in 0..nrows.value() { for i in 0..nrows.value() {
@ -657,10 +645,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
{ {
let (nrows, ncols) = self.data.shape(); let (nrows, ncols) = self.data.shape();
#[cfg(feature="no_unsound_assume_init")] let mut res: MatrixMN<N3, R, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
let mut res: MatrixMN<N3, R, C> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { MatrixMN::new_uninitialized_generic(nrows, ncols).assume_init() };
assert_eq!( assert_eq!(
(nrows.value(), ncols.value()), (nrows.value(), ncols.value()),
@ -701,10 +686,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
{ {
let (nrows, ncols) = self.data.shape(); let (nrows, ncols) = self.data.shape();
#[cfg(feature="no_unsound_assume_init")] let mut res: MatrixMN<N4, R, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
let mut res: MatrixMN<N4, R, C> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { MatrixMN::new_uninitialized_generic(nrows, ncols).assume_init() };
assert_eq!( assert_eq!(
(nrows.value(), ncols.value()), (nrows.value(), ncols.value()),
@ -1198,10 +1180,7 @@ impl<N: SimdComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S
let (nrows, ncols) = self.data.shape(); let (nrows, ncols) = self.data.shape();
unsafe { unsafe {
#[cfg(feature="no_unsound_assume_init")] let mut res: MatrixMN<_, C, R> = crate::unimplemented_or_uninitialized_generic!(ncols, nrows);
let mut res = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res: MatrixMN<_, C, R> = Matrix::new_uninitialized_generic(ncols, nrows).assume_init();
self.adjoint_to(&mut res); self.adjoint_to(&mut res);
res res
@ -1342,10 +1321,7 @@ impl<N: Scalar, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
); );
let dim = self.data.shape().0; let dim = self.data.shape().0;
#[cfg(feature="no_unsound_assume_init")] let mut res: VectorN<N2, D> = unsafe { crate::unimplemented_or_uninitialized_generic!(dim, U1) };
let mut res: VectorN<N2, D> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { VectorN::new_uninitialized_generic(dim, U1).assume_init() };
for i in 0..dim.value() { for i in 0..dim.value() {
unsafe { unsafe {
@ -1472,7 +1448,7 @@ impl<N: Scalar + Zero, D: DimAdd<U1>, S: Storage<N, D>> Vector<N, D, S> {
{ {
let len = self.len(); let len = self.len();
let hnrows = DimSum::<D, U1>::from_usize(len + 1); let hnrows = DimSum::<D, U1>::from_usize(len + 1);
let mut res: VectorN::<N, _> = unsafe { crate::zero_or_uninitialized_generic!(hnrows, U1) }; let mut res: VectorN::<N, _> = unsafe { crate::unimplemented_or_uninitialized_generic!(hnrows, U1) };
res.generic_slice_mut((0, 0), self.data.shape()) res.generic_slice_mut((0, 0), self.data.shape())
.copy_from(self); .copy_from(self);
res[(len, 0)] = element; res[(len, 0)] = element;
@ -1817,10 +1793,7 @@ impl<N: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<N
// TODO: soooo ugly! // TODO: soooo ugly!
let nrows = SameShapeR::<R, R2>::from_usize(3); let nrows = SameShapeR::<R, R2>::from_usize(3);
let ncols = SameShapeC::<C, C2>::from_usize(1); let ncols = SameShapeC::<C, C2>::from_usize(1);
#[cfg(feature="no_unsound_assume_init")] let mut res: MatrixCross<N, R, C, R2, C2> = crate::unimplemented_or_uninitialized_generic!(nrows, ncols);
let mut res: MatrixCross<N, R, C, R2, C2> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = Matrix::new_uninitialized_generic(nrows, ncols).assume_init();
let ax = self.get_unchecked((0, 0)); let ax = self.get_unchecked((0, 0));
let ay = self.get_unchecked((1, 0)); let ay = self.get_unchecked((1, 0));
@ -1844,10 +1817,7 @@ impl<N: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<N
// TODO: ugly! // TODO: ugly!
let nrows = SameShapeR::<R, R2>::from_usize(1); let nrows = SameShapeR::<R, R2>::from_usize(1);
let ncols = SameShapeC::<C, C2>::from_usize(3); let ncols = SameShapeC::<C, C2>::from_usize(3);
#[cfg(feature="no_unsound_assume_init")] let mut res: MatrixCross<N, R, C, R2, C2> = crate::unimplemented_or_uninitialized_generic!(nrows, ncols);
let mut res: MatrixCross<N, R, C, R2, C2> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = Matrix::new_uninitialized_generic(nrows, ncols).assume_init();
let ax = self.get_unchecked((0, 0)); let ax = self.get_unchecked((0, 0));
let ay = self.get_unchecked((0, 1)); let ay = self.get_unchecked((0, 1));

13
src/base/ops.rs
View File

@ -331,10 +331,7 @@ macro_rules! componentwise_binop_impl(
let (nrows, ncols) = self.shape(); let (nrows, ncols) = self.shape();
let nrows: SameShapeR<R1, R2> = Dim::from_usize(nrows); let nrows: SameShapeR<R1, R2> = Dim::from_usize(nrows);
let ncols: SameShapeC<C1, C2> = Dim::from_usize(ncols); let ncols: SameShapeC<C1, C2> = Dim::from_usize(ncols);
#[cfg(feature="no_unsound_assume_init")] crate::unimplemented_or_uninitialized_generic!(nrows, ncols)
{ unimplemented!() }
#[cfg(not(feature="no_unsound_assume_init"))]
{ Matrix::new_uninitialized_generic(nrows, ncols).assume_init() }
}; };
self.$method_to_statically_unchecked(rhs, &mut res); self.$method_to_statically_unchecked(rhs, &mut res);
@ -576,7 +573,7 @@ where
#[inline] #[inline]
fn mul(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output { fn mul(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output {
let mut res = unsafe { crate::zero_or_uninitialized_generic!(self.data.shape().0, rhs.data.shape().1) }; let mut res = unsafe { crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, rhs.data.shape().1) };
self.mul_to(rhs, &mut res); self.mul_to(rhs, &mut res);
res res
} }
@ -685,7 +682,7 @@ where
DefaultAllocator: Allocator<N, C1, C2>, DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfRows<R1, R2>,
{ {
let mut res = unsafe { crate::zero_or_uninitialized_generic!(self.data.shape().1, rhs.data.shape().1) }; let mut res = unsafe { crate::unimplemented_or_uninitialized_generic!(self.data.shape().1, rhs.data.shape().1) };
self.tr_mul_to(rhs, &mut res); self.tr_mul_to(rhs, &mut res);
res res
@ -700,7 +697,7 @@ where
DefaultAllocator: Allocator<N, C1, C2>, DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfRows<R1, R2>,
{ {
let mut res = unsafe { crate::zero_or_uninitialized_generic!(self.data.shape().1, rhs.data.shape().1) }; let mut res = unsafe { crate::unimplemented_or_uninitialized_generic!(self.data.shape().1, rhs.data.shape().1) };
self.ad_mul_to(rhs, &mut res); self.ad_mul_to(rhs, &mut res);
res res
@ -814,7 +811,7 @@ where
let (nrows1, ncols1) = self.data.shape(); let (nrows1, ncols1) = self.data.shape();
let (nrows2, ncols2) = rhs.data.shape(); let (nrows2, ncols2) = rhs.data.shape();
let mut res = unsafe { crate::zero_or_uninitialized_generic!(nrows1.mul(nrows2), ncols1.mul(ncols2)) }; let mut res = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows1.mul(nrows2), ncols1.mul(ncols2)) };
{ {
let mut data_res = res.data.ptr_mut(); let mut data_res = res.data.ptr_mut();

10
src/base/statistics.rs
View File

@ -17,10 +17,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
DefaultAllocator: Allocator<N, U1, C>, DefaultAllocator: Allocator<N, U1, C>,
{ {
let ncols = self.data.shape().1; let ncols = self.data.shape().1;
#[cfg(feature="no_unsound_assume_init")] let mut res: RowVectorN<N, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(U1, ncols) };
let mut res: RowVectorN<N, C> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { RowVectorN::new_uninitialized_generic(U1, ncols).assume_init() };
for i in 0..ncols.value() { for i in 0..ncols.value() {
// TODO: avoid bound checking of column. // TODO: avoid bound checking of column.
@ -45,10 +42,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
DefaultAllocator: Allocator<N, C>, DefaultAllocator: Allocator<N, C>,
{ {
let ncols = self.data.shape().1; let ncols = self.data.shape().1;
#[cfg(feature="no_unsound_assume_init")] let mut res: VectorN<N, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, U1) };
let mut res: VectorN<N, C> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { VectorN::new_uninitialized_generic(ncols, U1).assume_init() };
for i in 0..ncols.value() { for i in 0..ncols.value() {
// TODO: avoid bound checking of column. // TODO: avoid bound checking of column.

5
src/geometry/point.rs
View File

@ -181,10 +181,7 @@ where
D: DimNameAdd<U1>, D: DimNameAdd<U1>,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>>, DefaultAllocator: Allocator<N, DimNameSum<D, U1>>,
{ {
#[cfg(feature="no_unsound_assume_init")] let mut res = unsafe { crate::unimplemented_or_uninitialized_generic!(<DimNameSum<D, U1> as DimName>::name(), U1) };
let mut res: VectorN<N, DimNameSum<D, U1>> = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = unsafe { VectorN::<_, DimNameSum<D, U1>>::new_uninitialized().assume_init() };
res.fixed_slice_mut::<D, U1>(0, 0).copy_from(&self.coords); res.fixed_slice_mut::<D, U1>(0, 0).copy_from(&self.coords);
res[(D::dim(), 0)] = N::one(); res[(D::dim(), 0)] = N::one();

5
src/geometry/point_construction.rs
View File

@ -24,10 +24,7 @@ where
/// Creates a new point with uninitialized coordinates. /// Creates a new point with uninitialized coordinates.
#[inline] #[inline]
pub unsafe fn new_uninitialized() -> Self { pub unsafe fn new_uninitialized() -> Self {
#[cfg(feature="no_unsound_assume_init")] Self::from(crate::unimplemented_or_uninitialized_generic!(D::name(), U1))
{ unimplemented!() }
#[cfg(not(feature="no_unsound_assume_init"))]
{ Self::from(VectorN::new_uninitialized().assume_init()) }
} }
/// Creates a new point with all coordinates equal to zero. /// Creates a new point with all coordinates equal to zero.

12
src/linalg/bidiagonal.rs
View File

@ -81,11 +81,11 @@ where
"Cannot compute the bidiagonalization of an empty matrix." "Cannot compute the bidiagonalization of an empty matrix."
); );
let mut diagonal = unsafe { crate::zero_or_uninitialized_generic!(min_nrows_ncols, U1) }; let mut diagonal = unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, U1) };
let mut off_diagonal = let mut off_diagonal =
unsafe { crate::zero_or_uninitialized_generic!(min_nrows_ncols.sub(U1), U1) }; unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols.sub(U1), U1) };
let mut axis_packed = unsafe { crate::zero_or_uninitialized_generic!(ncols, U1) }; let mut axis_packed = unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, U1) };
let mut work = unsafe { crate::zero_or_uninitialized_generic!(nrows, U1) }; let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, U1) };
let upper_diagonal = nrows.value() >= ncols.value(); let upper_diagonal = nrows.value() >= ncols.value();
if upper_diagonal { if upper_diagonal {
@ -239,8 +239,8 @@ where
let min_nrows_ncols = nrows.min(ncols); let min_nrows_ncols = nrows.min(ncols);
let mut res = Matrix::identity_generic(min_nrows_ncols, ncols); let mut res = Matrix::identity_generic(min_nrows_ncols, ncols);
let mut work = unsafe { crate::zero_or_uninitialized_generic!(min_nrows_ncols, U1) }; let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, U1) };
let mut axis_packed = unsafe { crate::zero_or_uninitialized_generic!(ncols, U1) }; let mut axis_packed = unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, U1) };
let shift = self.axis_shift().1; let shift = self.axis_shift().1;

4
src/linalg/cholesky.rs
View File

@ -223,7 +223,7 @@ where
// loads the data into a new matrix with an additional jth row/column // loads the data into a new matrix with an additional jth row/column
let mut chol = unsafe { let mut chol = unsafe {
crate::zero_or_uninitialized_generic!( crate::unimplemented_or_uninitialized_generic!(
self.chol.data.shape().0.add(U1), self.chol.data.shape().0.add(U1),
self.chol.data.shape().1.add(U1) self.chol.data.shape().1.add(U1)
) )
@ -288,7 +288,7 @@ where
// loads the data into a new matrix except for the jth row/column // loads the data into a new matrix except for the jth row/column
let mut chol = unsafe { let mut chol = unsafe {
crate::zero_or_uninitialized_generic!( crate::unimplemented_or_uninitialized_generic!(
self.chol.data.shape().0.sub(U1), self.chol.data.shape().0.sub(U1),
self.chol.data.shape().1.sub(U1) self.chol.data.shape().1.sub(U1)
) )

4
src/linalg/hessenberg.rs
View File

@ -48,7 +48,7 @@ where
{ {
/// Computes the Hessenberg decomposition using householder reflections. /// Computes the Hessenberg decomposition using householder reflections.
pub fn new(hess: MatrixN<N, D>) -> Self { pub fn new(hess: MatrixN<N, D>) -> Self {
let mut work = unsafe { crate::zero_or_uninitialized_generic!(hess.data.shape().0, U1) }; let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(hess.data.shape().0, U1) };
Self::new_with_workspace(hess, &mut work) Self::new_with_workspace(hess, &mut work)
} }
@ -74,7 +74,7 @@ where
"Hessenberg: invalid workspace size." "Hessenberg: invalid workspace size."
); );
let mut subdiag = unsafe { crate::zero_or_uninitialized_generic!(dim.sub(U1), U1) }; let mut subdiag = unsafe { crate::unimplemented_or_uninitialized_generic!(dim.sub(U1), U1) };
if dim.value() == 0 { if dim.value() == 0 {
return Hessenberg { hess, subdiag }; return Hessenberg { hess, subdiag };

5
src/linalg/permutation_sequence.rs
View File

@ -70,12 +70,9 @@ where
#[inline] #[inline]
pub fn identity_generic(dim: D) -> Self { pub fn identity_generic(dim: D) -> Self {
unsafe { unsafe {
#[cfg(feature="no_unsound_assume_init")]
unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
Self { Self {
len: 0, len: 0,
ipiv: VectorN::new_uninitialized_generic(dim, U1).assume_init(), ipiv: crate::unimplemented_or_uninitialized_generic!(dim, U1),
} }
} }
} }

2
src/linalg/qr.rs
View File

@ -54,7 +54,7 @@ where
let (nrows, ncols) = matrix.data.shape(); let (nrows, ncols) = matrix.data.shape();
let min_nrows_ncols = nrows.min(ncols); let min_nrows_ncols = nrows.min(ncols);
let mut diag = unsafe { crate::zero_or_uninitialized_generic!(min_nrows_ncols, U1) }; let mut diag = unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, U1) };
if min_nrows_ncols.value() == 0 { if min_nrows_ncols.value() == 0 {
return QR { qr: matrix, diag }; return QR { qr: matrix, diag };

12
src/linalg/schur.rs
View File

@ -71,7 +71,7 @@ where
/// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
/// continues indefinitely until convergence. /// continues indefinitely until convergence.
pub fn try_new(m: MatrixN<N, D>, eps: N::RealField, max_niter: usize) -> Option<Self> { pub fn try_new(m: MatrixN<N, D>, eps: N::RealField, max_niter: usize) -> Option<Self> {
let mut work = unsafe { crate::zero_or_uninitialized_generic!(m.data.shape().0, U1) }; let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(m.data.shape().0, U1) };
Self::do_decompose(m, &mut work, eps, max_niter, true) Self::do_decompose(m, &mut work, eps, max_niter, true)
.map(|(q, t)| Schur { q: q.unwrap(), t }) .map(|(q, t)| Schur { q: q.unwrap(), t })
@ -378,7 +378,7 @@ where
/// ///
/// Return `None` if some eigenvalues are complex. /// Return `None` if some eigenvalues are complex.
pub fn eigenvalues(&self) -> Option<VectorN<N, D>> { pub fn eigenvalues(&self) -> Option<VectorN<N, D>> {
let mut out = unsafe { crate::zero_or_uninitialized_generic!(self.t.data.shape().0, U1) }; let mut out = unsafe { crate::unimplemented_or_uninitialized_generic!(self.t.data.shape().0, U1) };
if Self::do_eigenvalues(&self.t, &mut out) { if Self::do_eigenvalues(&self.t, &mut out) {
Some(out) Some(out)
} else { } else {
@ -392,7 +392,7 @@ where
N: RealField, N: RealField,
DefaultAllocator: Allocator<NumComplex<N>, D>, DefaultAllocator: Allocator<NumComplex<N>, D>,
{ {
let mut out = unsafe { crate::zero_or_uninitialized_generic!(self.t.data.shape().0, U1) }; let mut out = unsafe { crate::unimplemented_or_uninitialized_generic!(self.t.data.shape().0, U1) };
Self::do_complex_eigenvalues(&self.t, &mut out); Self::do_complex_eigenvalues(&self.t, &mut out);
out out
} }
@ -503,7 +503,7 @@ where
"Unable to compute eigenvalues of a non-square matrix." "Unable to compute eigenvalues of a non-square matrix."
); );
let mut work = unsafe { crate::zero_or_uninitialized_generic!(self.data.shape().0, U1) }; let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, U1) };
// Special case for 2x2 matrices. // Special case for 2x2 matrices.
if self.nrows() == 2 { if self.nrows() == 2 {
@ -544,7 +544,7 @@ where
DefaultAllocator: Allocator<NumComplex<N>, D>, DefaultAllocator: Allocator<NumComplex<N>, D>,
{ {
let dim = self.data.shape().0; let dim = self.data.shape().0;
let mut work = unsafe { crate::zero_or_uninitialized_generic!(dim, U1) }; let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(dim, U1) };
let schur = Schur::do_decompose( let schur = Schur::do_decompose(
self.clone_owned(), self.clone_owned(),
@ -554,7 +554,7 @@ where
false, false,
) )
.unwrap(); .unwrap();
let mut eig = unsafe { crate::zero_or_uninitialized_generic!(dim, U1) }; let mut eig = unsafe { crate::unimplemented_or_uninitialized_generic!(dim, U1) };
Schur::do_complex_eigenvalues(&schur.1, &mut eig); Schur::do_complex_eigenvalues(&schur.1, &mut eig);
eig eig
} }

4
src/linalg/symmetric_tridiagonal.rs
View File

@ -61,8 +61,8 @@ where
"Unable to compute the symmetric tridiagonal decomposition of an empty matrix." "Unable to compute the symmetric tridiagonal decomposition of an empty matrix."
); );
let mut off_diagonal = unsafe { crate::zero_or_uninitialized_generic!(dim.sub(U1), U1) }; let mut off_diagonal = unsafe { crate::unimplemented_or_uninitialized_generic!(dim.sub(U1), U1) };
let mut p = unsafe { crate::zero_or_uninitialized_generic!(dim.sub(U1), U1) }; let mut p = unsafe { crate::unimplemented_or_uninitialized_generic!(dim.sub(U1), U1) };
for i in 0..dim.value() - 1 { for i in 0..dim.value() - 1 {
let mut m = m.rows_range_mut(i + 1..); let mut m = m.rows_range_mut(i + 1..);