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>,
DefaultAllocator: Allocator<N, D1>,
{
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, U1) };
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>,
DefaultAllocator: Allocator<N, D2>,
{
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(mid.data.shape().0, U1) };
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::{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()`.
/// Intended for use in contexts where the `Scalar` type implements `num_traits::Zero`, to check whether uninitialized memory is actually performance-critical.
/// When "no_unsound_assume_init" is enabled, expands to `unimplemented!()` instead of `new_uninitialized_generic().assume_init()`.
/// Intended as a placeholder, each callsite should be refactored to use uninitialized memory soundly
#[macro_export]
macro_rules! zero_or_uninitialized_generic {
macro_rules! unimplemented_or_uninitialized_generic {
($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() }
}}
}
@ -99,10 +106,7 @@ where
"Matrix init. error: the slice did not contain the right number of elements."
);
#[cfg(feature="no_unsound_assume_init")]
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 res = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
let mut iter = slice.iter();
for i in 0..nrows.value() {
@ -128,10 +132,7 @@ where
where
F: FnMut(usize, usize) -> N,
{
#[cfg(feature="no_unsound_assume_init")]
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 res: Self = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
for j in 0..ncols.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 ncols2 = C2::from_usize(ncols);
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut res: MatrixMN<N2, R2, C2> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows2, ncols2) };
for i in 0..nrows {
for j in 0..ncols {
unsafe {
@ -76,10 +73,7 @@ where
let nrows = R1::from_usize(nrows2);
let ncols = C1::from_usize(ncols2);
#[cfg(feature="no_unsound_assume_init")]
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 res: Self = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
for i in 0..nrows2 {
for j in 0..ncols2 {
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 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.
// 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 nrows = self.data.shape().0;
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() {
res.column_mut(destination).copy_from(&self.column(*source))
@ -895,10 +895,7 @@ impl<N: Scalar> DMatrix<N> {
where
DefaultAllocator: Reallocator<N, Dynamic, Dynamic, Dynamic, Dynamic>,
{
#[cfg(feature="no_unsound_assume_init")]
let placeholder = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let placeholder = unsafe { Self::new_uninitialized(0, 0).assume_init() };
let placeholder = unsafe { crate::unimplemented_or_uninitialized_generic!(Dynamic::new(0), Dynamic::new(0)) };
let old = mem::replace(self, placeholder);
let new = old.resize(new_nrows, new_ncols, val);
let _ = mem::replace(self, new);
@ -921,10 +918,7 @@ where
where
DefaultAllocator: Reallocator<N, Dynamic, C, Dynamic, C>,
{
#[cfg(feature="no_unsound_assume_init")]
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 placeholder = unsafe { crate::unimplemented_or_uninitialized_generic!(Dynamic::new(0), self.data.shape().1) };
let old = mem::replace(self, placeholder);
let new = old.resize_vertically(new_nrows, val);
let _ = mem::replace(self, new);
@ -947,10 +941,7 @@ where
where
DefaultAllocator: Reallocator<N, R, Dynamic, R, Dynamic>,
{
#[cfg(feature="no_unsound_assume_init")]
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 placeholder = unsafe { crate::unimplemented_or_uninitialized_generic!(self.data.shape().0, Dynamic::new(0)) };
let old = mem::replace(self, placeholder);
let new = old.resize_horizontally(new_ncols, val);
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 ncols: SameShapeC<C, C2> = Dim::from_usize(ncols);
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut res: MatrixSum<N, R, C, R2, C2> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
// TODO: use copy_from
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();
unsafe {
#[cfg(feature="no_unsound_assume_init")]
let mut res = unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
let mut res = Matrix::new_uninitialized_generic(ncols, nrows).assume_init();
let mut res = crate::unimplemented_or_uninitialized_generic!(ncols, nrows);
self.transpose_to(&mut 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();
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut res: MatrixMN<N2, R, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
for j in 0..ncols.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();
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut res: MatrixMN<N2, R, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
for j in 0..ncols.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();
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut res: MatrixMN<N3, R, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
assert_eq!(
(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();
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut res: MatrixMN<N4, R, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, ncols) };
assert_eq!(
(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();
unsafe {
#[cfg(feature="no_unsound_assume_init")]
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();
let mut res: MatrixMN<_, C, R> = crate::unimplemented_or_uninitialized_generic!(ncols, nrows);
self.adjoint_to(&mut 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;
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut res: VectorN<N2, D> = unsafe { crate::unimplemented_or_uninitialized_generic!(dim, U1) };
for i in 0..dim.value() {
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 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())
.copy_from(self);
res[(len, 0)] = element;
@ -1817,10 +1793,7 @@ impl<N: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<N
// TODO: soooo ugly!
let nrows = SameShapeR::<R, R2>::from_usize(3);
let ncols = SameShapeC::<C, C2>::from_usize(1);
#[cfg(feature="no_unsound_assume_init")]
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 mut res: MatrixCross<N, R, C, R2, C2> = crate::unimplemented_or_uninitialized_generic!(nrows, ncols);
let ax = self.get_unchecked((0, 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!
let nrows = SameShapeR::<R, R2>::from_usize(1);
let ncols = SameShapeC::<C, C2>::from_usize(3);
#[cfg(feature="no_unsound_assume_init")]
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 mut res: MatrixCross<N, R, C, R2, C2> = crate::unimplemented_or_uninitialized_generic!(nrows, ncols);
let ax = self.get_unchecked((0, 0));
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: SameShapeR<R1, R2> = Dim::from_usize(nrows);
let ncols: SameShapeC<C1, C2> = Dim::from_usize(ncols);
#[cfg(feature="no_unsound_assume_init")]
{ unimplemented!() }
#[cfg(not(feature="no_unsound_assume_init"))]
{ Matrix::new_uninitialized_generic(nrows, ncols).assume_init() }
crate::unimplemented_or_uninitialized_generic!(nrows, ncols)
};
self.$method_to_statically_unchecked(rhs, &mut res);
@ -576,7 +573,7 @@ where
#[inline]
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);
res
}
@ -685,7 +682,7 @@ where
DefaultAllocator: Allocator<N, C1, C2>,
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);
res
@ -700,7 +697,7 @@ where
DefaultAllocator: Allocator<N, C1, C2>,
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);
res
@ -814,7 +811,7 @@ where
let (nrows1, ncols1) = self.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();

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>,
{
let ncols = self.data.shape().1;
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut res: RowVectorN<N, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(U1, ncols) };
for i in 0..ncols.value() {
// 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>,
{
let ncols = self.data.shape().1;
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut res: VectorN<N, C> = unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, U1) };
for i in 0..ncols.value() {
// TODO: avoid bound checking of column.

5
src/geometry/point.rs
View File

@ -181,10 +181,7 @@ where
D: DimNameAdd<U1>,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>>,
{
#[cfg(feature="no_unsound_assume_init")]
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() };
let mut res = unsafe { crate::unimplemented_or_uninitialized_generic!(<DimNameSum<D, U1> as DimName>::name(), U1) };
res.fixed_slice_mut::<D, U1>(0, 0).copy_from(&self.coords);
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.
#[inline]
pub unsafe fn new_uninitialized() -> Self {
#[cfg(feature="no_unsound_assume_init")]
{ unimplemented!() }
#[cfg(not(feature="no_unsound_assume_init"))]
{ Self::from(VectorN::new_uninitialized().assume_init()) }
Self::from(crate::unimplemented_or_uninitialized_generic!(D::name(), U1))
}
/// 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."
);
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 =
unsafe { crate::zero_or_uninitialized_generic!(min_nrows_ncols.sub(U1), U1) };
let mut axis_packed = unsafe { crate::zero_or_uninitialized_generic!(ncols, U1) };
let mut work = unsafe { crate::zero_or_uninitialized_generic!(nrows, U1) };
unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols.sub(U1), U1) };
let mut axis_packed = unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, U1) };
let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(nrows, U1) };
let upper_diagonal = nrows.value() >= ncols.value();
if upper_diagonal {
@ -239,8 +239,8 @@ where
let min_nrows_ncols = nrows.min(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 axis_packed = unsafe { crate::zero_or_uninitialized_generic!(ncols, U1) };
let mut work = unsafe { crate::unimplemented_or_uninitialized_generic!(min_nrows_ncols, U1) };
let mut axis_packed = unsafe { crate::unimplemented_or_uninitialized_generic!(ncols, U1) };
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
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().1.add(U1)
)
@ -288,7 +288,7 @@ where
// loads the data into a new matrix except for the jth row/column
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().1.sub(U1)
)

4
src/linalg/hessenberg.rs
View File

@ -48,7 +48,7 @@ where
{
/// Computes the Hessenberg decomposition using householder reflections.
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)
}
@ -74,7 +74,7 @@ where
"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 {
return Hessenberg { hess, subdiag };

5
src/linalg/permutation_sequence.rs
View File

@ -70,12 +70,9 @@ where
#[inline]
pub fn identity_generic(dim: D) -> Self {
unsafe {
#[cfg(feature="no_unsound_assume_init")]
unimplemented!();
#[cfg(not(feature="no_unsound_assume_init"))]
Self {
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 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 {
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
/// continues indefinitely until convergence.
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)
.map(|(q, t)| Schur { q: q.unwrap(), t })
@ -378,7 +378,7 @@ where
///
/// Return `None` if some eigenvalues are complex.
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) {
Some(out)
} else {
@ -392,7 +392,7 @@ where
N: RealField,
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);
out
}
@ -503,7 +503,7 @@ where
"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.
if self.nrows() == 2 {
@ -544,7 +544,7 @@ where
DefaultAllocator: Allocator<NumComplex<N>, D>,
{
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(
self.clone_owned(),
@ -554,7 +554,7 @@ where
false,
)
.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);
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."
);
let mut off_diagonal = unsafe { crate::zero_or_uninitialized_generic!(dim.sub(U1), U1) };
let mut p = 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::unimplemented_or_uninitialized_generic!(dim.sub(U1), U1) };
for i in 0..dim.value() - 1 {
let mut m = m.rows_range_mut(i + 1..);