Replace vec_uninit by vec_uninit2

termoshtt · termoshtt · commit b5b92e3b5975 · 2022-09-01T16:00:11.000+09:00
diff --git a/lax/src/eig.rs b/lax/src/eig.rs
@@ -41,14 +41,13 @@ macro_rules! impl_eig_complex {
                 } else {
                     (EigenVectorFlag::Not, EigenVectorFlag::Not)
                 };
-                let mut eigs: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(n as usize) };
-                let mut rwork: Vec<MaybeUninit<Self::Real>> =
-                    unsafe { vec_uninit2(2 * n as usize) };
+                let mut eigs: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(n as usize) };
+                let mut rwork: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(2 * n as usize) };
 
                 let mut vl: Option<Vec<MaybeUninit<Self>>> =
-                    jobvl.then(|| unsafe { vec_uninit2((n * n) as usize) });
+                    jobvl.then(|| unsafe { vec_uninit((n * n) as usize) });
                 let mut vr: Option<Vec<MaybeUninit<Self>>> =
-                    jobvr.then(|| unsafe { vec_uninit2((n * n) as usize) });
+                    jobvr.then(|| unsafe { vec_uninit((n * n) as usize) });
 
                 // calc work size
                 let mut info = 0;
@@ -75,7 +74,7 @@ macro_rules! impl_eig_complex {
 
                 // actal ev
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(lwork) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
                 let lwork = lwork as i32;
                 unsafe {
                     $ev(
@@ -150,13 +149,13 @@ macro_rules! impl_eig_real {
                 } else {
                     (EigenVectorFlag::Not, EigenVectorFlag::Not)
                 };
-                let mut eig_re: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(n as usize) };
-                let mut eig_im: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(n as usize) };
+                let mut eig_re: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(n as usize) };
+                let mut eig_im: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(n as usize) };
 
                 let mut vl: Option<Vec<MaybeUninit<Self>>> =
-                    jobvl.then(|| unsafe { vec_uninit2((n * n) as usize) });
+                    jobvl.then(|| unsafe { vec_uninit((n * n) as usize) });
                 let mut vr: Option<Vec<MaybeUninit<Self>>> =
-                    jobvr.then(|| unsafe { vec_uninit2((n * n) as usize) });
+                    jobvr.then(|| unsafe { vec_uninit((n * n) as usize) });
 
                 // calc work size
                 let mut info = 0;
@@ -183,7 +182,7 @@ macro_rules! impl_eig_real {
 
                 // actual ev
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(lwork) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
                 let lwork = lwork as i32;
                 unsafe {
                     $ev(
@@ -238,7 +237,7 @@ macro_rules! impl_eig_real {
 
                 let n = n as usize;
                 let v = vr.or(vl).unwrap();
-                let mut eigvecs: Vec<MaybeUninit<Self::Complex>> = unsafe { vec_uninit2(n * n) };
+                let mut eigvecs: Vec<MaybeUninit<Self::Complex>> = unsafe { vec_uninit(n * n) };
                 let mut col = 0;
                 while col < n {
                     if eig_im[col] == 0. {
diff --git a/lax/src/eigh.rs b/lax/src/eigh.rs
@@ -42,10 +42,10 @@ macro_rules! impl_eigh {
                 assert_eq!(layout.len(), layout.lda());
                 let n = layout.len();
                 let jobz = if calc_v { EigenVectorFlag::Calc } else { EigenVectorFlag::Not };
-                let mut eigs: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit2(n as usize) };
+                let mut eigs: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(n as usize) };
 
                 $(
-                let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit2(3 * n as usize - 2 as usize) };
+                let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(3 * n as usize - 2 as usize) };
                 )*
 
                 // calc work size
@@ -69,7 +69,7 @@ macro_rules! impl_eigh {
 
                 // actual ev
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(lwork) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
                 let lwork = lwork as i32;
                 unsafe {
                     $ev(
@@ -101,10 +101,10 @@ macro_rules! impl_eigh {
                 assert_eq!(layout.len(), layout.lda());
                 let n = layout.len();
                 let jobz = if calc_v { EigenVectorFlag::Calc } else { EigenVectorFlag::Not };
-                let mut eigs: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit2(n as usize) };
+                let mut eigs: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(n as usize) };
 
                 $(
-                let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit2(3 * n as usize - 2) };
+                let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(3 * n as usize - 2) };
                 )*
 
                 // calc work size
@@ -131,7 +131,7 @@ macro_rules! impl_eigh {
 
                 // actual evg
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(lwork) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
                 let lwork = lwork as i32;
                 unsafe {
                     $evg(
diff --git a/lax/src/layout.rs b/lax/src/layout.rs
@@ -202,7 +202,7 @@ pub fn transpose<T: Copy>(layout: MatrixLayout, input: &[T]) -> (MatrixLayout, V
     let n = n as usize;
     assert_eq!(input.len(), m * n);
 
-    let mut out: Vec<MaybeUninit<T>> = unsafe { vec_uninit2(m * n) };
+    let mut out: Vec<MaybeUninit<T>> = unsafe { vec_uninit(m * n) };
 
     match layout {
         MatrixLayout::C { .. } => {
diff --git a/lax/src/least_squares.rs b/lax/src/least_squares.rs
@@ -87,7 +87,7 @@ macro_rules! impl_least_squares {
                 };
 
                 let rcond: Self::Real = -1.;
-                let mut singular_values: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit2( k as usize) };
+                let mut singular_values: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit( k as usize) };
                 let mut rank: i32 = 0;
 
                 // eval work size
@@ -120,12 +120,12 @@ macro_rules! impl_least_squares {
 
                 // calc
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(lwork) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
                 let liwork = iwork_size[0].to_usize().unwrap();
-                let mut iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit2(liwork) };
+                let mut iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit(liwork) };
                 $(
                 let lrwork = $rwork[0].to_usize().unwrap();
-                let mut $rwork: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit2(lrwork) };
+                let mut $rwork: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(lrwork) };
                 )*
                 unsafe {
                     $gelsd(
diff --git a/lax/src/lib.rs b/lax/src/lib.rs
@@ -269,19 +269,7 @@ impl EigenVectorFlag {
 /// ------
 /// - Memory is not initialized. Do not read the memory before write.
 ///
-unsafe fn vec_uninit<T: Sized>(n: usize) -> Vec<T> {
-    let mut v = Vec::with_capacity(n);
-    v.set_len(n);
-    v
-}
-
-/// Create a vector without initialization
-///
-/// Safety
-/// ------
-/// - Memory is not initialized. Do not read the memory before write.
-///
-unsafe fn vec_uninit2<T: Sized>(n: usize) -> Vec<MaybeUninit<T>> {
+unsafe fn vec_uninit<T: Sized>(n: usize) -> Vec<MaybeUninit<T>> {
     let mut v = Vec::with_capacity(n);
     v.set_len(n);
     v
diff --git a/lax/src/opnorm.rs b/lax/src/opnorm.rs
@@ -19,7 +19,7 @@ macro_rules! impl_opnorm {
                     MatrixLayout::C { .. } => t.transpose(),
                 };
                 let mut work: Vec<MaybeUninit<Self::Real>> = if matches!(t, NormType::Infinity) {
-                    unsafe { vec_uninit2(m as usize) }
+                    unsafe { vec_uninit(m as usize) }
                 } else {
                     Vec::new()
                 };
diff --git a/lax/src/qr.rs b/lax/src/qr.rs
@@ -25,7 +25,7 @@ macro_rules! impl_qr {
                 let m = l.lda();
                 let n = l.len();
                 let k = m.min(n);
-                let mut tau = unsafe { vec_uninit2(k as usize) };
+                let mut tau = unsafe { vec_uninit(k as usize) };
 
                 // eval work size
                 let mut info = 0;
@@ -62,7 +62,7 @@ macro_rules! impl_qr {
 
                 // calc
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(lwork) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
                 unsafe {
                     match l {
                         MatrixLayout::F { .. } => {
@@ -136,7 +136,7 @@ macro_rules! impl_qr {
 
                 // calc
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(lwork) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
                 unsafe {
                     match l {
                         MatrixLayout::F { .. } => $gqr(
diff --git a/lax/src/rcond.rs b/lax/src/rcond.rs
@@ -17,8 +17,8 @@ macro_rules! impl_rcond_real {
                 let mut rcond = Self::Real::zero();
                 let mut info = 0;
 
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(4 * n as usize) };
-                let mut iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit2(n as usize) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(4 * n as usize) };
+                let mut iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit(n as usize) };
                 let norm_type = match l {
                     MatrixLayout::C { .. } => NormType::Infinity,
                     MatrixLayout::F { .. } => NormType::One,
@@ -54,9 +54,8 @@ macro_rules! impl_rcond_complex {
                 let (n, _) = l.size();
                 let mut rcond = Self::Real::zero();
                 let mut info = 0;
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(2 * n as usize) };
-                let mut rwork: Vec<MaybeUninit<Self::Real>> =
-                    unsafe { vec_uninit2(2 * n as usize) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(2 * n as usize) };
+                let mut rwork: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(2 * n as usize) };
                 let norm_type = match l {
                     MatrixLayout::C { .. } => NormType::Infinity,
                     MatrixLayout::F { .. } => NormType::One,
diff --git a/lax/src/solve.rs b/lax/src/solve.rs
@@ -33,7 +33,7 @@ macro_rules! impl_solve {
                     return Ok(Vec::new());
                 }
                 let k = ::std::cmp::min(row, col);
-                let mut ipiv = unsafe { vec_uninit2(k as usize) };
+                let mut ipiv = unsafe { vec_uninit(k as usize) };
                 let mut info = 0;
                 unsafe {
                     $getrf(
@@ -75,7 +75,7 @@ macro_rules! impl_solve {
 
                 // actual
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(lwork) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
                 unsafe {
                     $getri(
                         &l.len(),
diff --git a/lax/src/solveh.rs b/lax/src/solveh.rs
@@ -20,7 +20,7 @@ macro_rules! impl_solveh {
         impl Solveh_ for $scalar {
             fn bk(l: MatrixLayout, uplo: UPLO, a: &mut [Self]) -> Result<Pivot> {
                 let (n, _) = l.size();
-                let mut ipiv = unsafe { vec_uninit2(n as usize) };
+                let mut ipiv = unsafe { vec_uninit(n as usize) };
                 if n == 0 {
                     return Ok(Vec::new());
                 }
@@ -44,7 +44,7 @@ macro_rules! impl_solveh {
 
                 // actual
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(lwork) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
                 unsafe {
                     $trf(
                         uplo.as_ptr(),
@@ -65,7 +65,7 @@ macro_rules! impl_solveh {
             fn invh(l: MatrixLayout, uplo: UPLO, a: &mut [Self], ipiv: &Pivot) -> Result<()> {
                 let (n, _) = l.size();
                 let mut info = 0;
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2(n as usize) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(n as usize) };
                 unsafe {
                     $tri(
                         uplo.as_ptr(),
diff --git a/lax/src/svd.rs b/lax/src/svd.rs
@@ -65,21 +65,21 @@ macro_rules! impl_svd {
 
                 let m = l.lda();
                 let mut u = match ju {
-                    FlagSVD::All => Some(unsafe { vec_uninit2( (m * m) as usize) }),
+                    FlagSVD::All => Some(unsafe { vec_uninit( (m * m) as usize) }),
                     FlagSVD::No => None,
                 };
 
                 let n = l.len();
                 let mut vt = match jvt {
-                    FlagSVD::All => Some(unsafe { vec_uninit2( (n * n) as usize) }),
+                    FlagSVD::All => Some(unsafe { vec_uninit( (n * n) as usize) }),
                     FlagSVD::No => None,
                 };
 
                 let k = std::cmp::min(m, n);
-                let mut s = unsafe { vec_uninit2( k as usize) };
+                let mut s = unsafe { vec_uninit( k as usize) };
 
                 $(
-                let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit2( 5 * k as usize) };
+                let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit( 5 * k as usize) };
                 )*
 
                 // eval work size
@@ -108,7 +108,7 @@ macro_rules! impl_svd {
 
                 // calc
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2( lwork) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit( lwork) };
                 unsafe {
                     $gesvd(
                         ju.as_ptr(),
diff --git a/lax/src/svddc.rs b/lax/src/svddc.rs
@@ -39,20 +39,20 @@ macro_rules! impl_svddc {
                 let m = l.lda();
                 let n = l.len();
                 let k = m.min(n);
-                let mut s = unsafe { vec_uninit2( k as usize) };
+                let mut s = unsafe { vec_uninit( k as usize) };
 
                 let (u_col, vt_row) = match jobz {
                     UVTFlag::Full | UVTFlag::None => (m, n),
                     UVTFlag::Some => (k, k),
                 };
                 let (mut u, mut vt) = match jobz {
                     UVTFlag::Full => (
-                        Some(unsafe { vec_uninit2( (m * m) as usize) }),
-                        Some(unsafe { vec_uninit2( (n * n) as usize) }),
+                        Some(unsafe { vec_uninit( (m * m) as usize) }),
+                        Some(unsafe { vec_uninit( (n * n) as usize) }),
                     ),
                     UVTFlag::Some => (
-                        Some(unsafe { vec_uninit2( (m * u_col) as usize) }),
-                        Some(unsafe { vec_uninit2( (n * vt_row) as usize) }),
+                        Some(unsafe { vec_uninit( (m * u_col) as usize) }),
+                        Some(unsafe { vec_uninit( (n * vt_row) as usize) }),
                     ),
                     UVTFlag::None => (None, None),
                 };
@@ -64,12 +64,12 @@ macro_rules! impl_svddc {
                     UVTFlag::None => 7 * mn,
                     _ => std::cmp::max(5*mn*mn + 5*mn, 2*mx*mn + 2*mn*mn + mn),
                 };
-                let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit2( lrwork) };
+                let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit( lrwork) };
                 )*
 
                 // eval work size
                 let mut info = 0;
-                let mut iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit2( 8 * k as usize) };
+                let mut iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit( 8 * k as usize) };
                 let mut work_size = [Self::zero()];
                 unsafe {
                     $gesdd(
@@ -94,7 +94,7 @@ macro_rules! impl_svddc {
 
                 // do svd
                 let lwork = work_size[0].to_usize().unwrap();
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2( lwork) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit( lwork) };
                 unsafe {
                     $gesdd(
                         jobz.as_ptr(),
diff --git a/lax/src/tridiagonal.rs b/lax/src/tridiagonal.rs
@@ -152,8 +152,8 @@ macro_rules! impl_tridiagonal {
         impl Tridiagonal_ for $scalar {
             fn lu_tridiagonal(mut a: Tridiagonal<Self>) -> Result<LUFactorizedTridiagonal<Self>> {
                 let (n, _) = a.l.size();
-                let mut du2 = unsafe { vec_uninit2( (n - 2) as usize) };
-                let mut ipiv = unsafe { vec_uninit2( n as usize) };
+                let mut du2 = unsafe { vec_uninit( (n - 2) as usize) };
+                let mut ipiv = unsafe { vec_uninit( n as usize) };
                 // We have to calc one-norm before LU factorization
                 let a_opnorm_one = a.opnorm_one();
                 let mut info = 0;
@@ -182,9 +182,9 @@ macro_rules! impl_tridiagonal {
             fn rcond_tridiagonal(lu: &LUFactorizedTridiagonal<Self>) -> Result<Self::Real> {
                 let (n, _) = lu.a.l.size();
                 let ipiv = &lu.ipiv;
-                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit2( 2 * n as usize) };
+                let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit( 2 * n as usize) };
                 $(
-                let mut $iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit2( n as usize) };
+                let mut $iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit( n as usize) };
                 )*
                 let mut rcond = Self::Real::zero();
                 let mut info = 0;
