Skip to content

Commit 4737b9c

Browse files
termoshtttermoshtt
committed
Drop unsafe from vec_uninit definition
1 parent ecd09eb commit 4737b9c

13 files changed

+56
-54
lines changed

‎lax/src/alloc.rs

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -53,8 +53,10 @@ impl<T> VecAssumeInit for Vec<MaybeUninit<T>> {
5353
/// ------
5454
/// - Memory is not initialized. Do not read the memory before write.
5555
///
56-
pub(crate) unsafe fn vec_uninit<T: Sized>(n: usize) -> Vec<MaybeUninit<T>> {
56+
pub(crate) fn vec_uninit<T: Sized>(n: usize) -> Vec<MaybeUninit<T>> {
5757
let mut v = Vec::with_capacity(n);
58-
v.set_len(n);
58+
unsafe {
59+
v.set_len(n);
60+
}
5961
v
6062
}

‎lax/src/eig.rs

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -48,13 +48,13 @@ macro_rules! impl_eig_complex {
4848
} else {
4949
(JobEv::None, JobEv::None)
5050
};
51-
let mut eigs: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(n as usize) };
52-
let mut rwork: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(2 * n as usize) };
51+
let mut eigs: Vec<MaybeUninit<Self>> = vec_uninit(n as usize);
52+
let mut rwork: Vec<MaybeUninit<Self::Real>> = vec_uninit(2 * n as usize);
5353

5454
let mut vl: Option<Vec<MaybeUninit<Self>>> =
55-
jobvl.then(|| unsafe { vec_uninit((n * n) as usize) });
55+
jobvl.then(|| vec_uninit((n * n) as usize));
5656
let mut vr: Option<Vec<MaybeUninit<Self>>> =
57-
jobvr.then(|| unsafe { vec_uninit((n * n) as usize) });
57+
jobvr.then(|| vec_uninit((n * n) as usize));
5858

5959
// calc work size
6060
let mut info = 0;
@@ -81,7 +81,7 @@ macro_rules! impl_eig_complex {
8181

8282
// actal ev
8383
let lwork = work_size[0].to_usize().unwrap();
84-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
84+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(lwork);
8585
let lwork = lwork as i32;
8686
unsafe {
8787
$ev(
@@ -156,13 +156,13 @@ macro_rules! impl_eig_real {
156156
} else {
157157
(JobEv::None, JobEv::None)
158158
};
159-
let mut eig_re: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(n as usize) };
160-
let mut eig_im: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(n as usize) };
159+
let mut eig_re: Vec<MaybeUninit<Self>> = vec_uninit(n as usize);
160+
let mut eig_im: Vec<MaybeUninit<Self>> = vec_uninit(n as usize);
161161

162162
let mut vl: Option<Vec<MaybeUninit<Self>>> =
163-
jobvl.then(|| unsafe { vec_uninit((n * n) as usize) });
163+
jobvl.then(|| vec_uninit((n * n) as usize));
164164
let mut vr: Option<Vec<MaybeUninit<Self>>> =
165-
jobvr.then(|| unsafe { vec_uninit((n * n) as usize) });
165+
jobvr.then(|| vec_uninit((n * n) as usize));
166166

167167
// calc work size
168168
let mut info = 0;
@@ -189,7 +189,7 @@ macro_rules! impl_eig_real {
189189

190190
// actual ev
191191
let lwork = work_size[0].to_usize().unwrap();
192-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
192+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(lwork);
193193
let lwork = lwork as i32;
194194
unsafe {
195195
$ev(
@@ -244,7 +244,7 @@ macro_rules! impl_eig_real {
244244

245245
let n = n as usize;
246246
let v = vr.or(vl).unwrap();
247-
let mut eigvecs: Vec<MaybeUninit<Self::Complex>> = unsafe { vec_uninit(n * n) };
247+
let mut eigvecs: Vec<MaybeUninit<Self::Complex>> = vec_uninit(n * n);
248248
let mut col = 0;
249249
while col < n {
250250
if eig_im[col] == 0. {

‎lax/src/eigh.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -58,10 +58,10 @@ macro_rules! impl_eigh {
5858
assert_eq!(layout.len(), layout.lda());
5959
let n = layout.len();
6060
let jobz = if calc_v { JobEv::All } else { JobEv::None };
61-
let mut eigs: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(n as usize) };
61+
let mut eigs: Vec<MaybeUninit<Self::Real>> = vec_uninit(n as usize);
6262

6363
$(
64-
let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(3 * n as usize - 2 as usize) };
64+
let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = vec_uninit(3 * n as usize - 2 as usize);
6565
)*
6666

6767
// calc work size
@@ -85,7 +85,7 @@ macro_rules! impl_eigh {
8585

8686
// actual ev
8787
let lwork = work_size[0].to_usize().unwrap();
88-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
88+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(lwork);
8989
let lwork = lwork as i32;
9090
unsafe {
9191
$ev(
@@ -117,10 +117,10 @@ macro_rules! impl_eigh {
117117
assert_eq!(layout.len(), layout.lda());
118118
let n = layout.len();
119119
let jobz = if calc_v { JobEv::All } else { JobEv::None };
120-
let mut eigs: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(n as usize) };
120+
let mut eigs: Vec<MaybeUninit<Self::Real>> = vec_uninit(n as usize);
121121

122122
$(
123-
let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(3 * n as usize - 2) };
123+
let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = vec_uninit(3 * n as usize - 2);
124124
)*
125125

126126
// calc work size
@@ -147,7 +147,7 @@ macro_rules! impl_eigh {
147147

148148
// actual evg
149149
let lwork = work_size[0].to_usize().unwrap();
150-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
150+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(lwork);
151151
let lwork = lwork as i32;
152152
unsafe {
153153
$evg(

‎lax/src/layout.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -202,7 +202,7 @@ pub fn transpose<T: Copy>(layout: MatrixLayout, input: &[T]) -> (MatrixLayout, V
202202
let n = n as usize;
203203
assert_eq!(input.len(), m * n);
204204

205-
let mut out: Vec<MaybeUninit<T>> = unsafe { vec_uninit(m * n) };
205+
let mut out: Vec<MaybeUninit<T>> = vec_uninit(m * n);
206206

207207
match layout {
208208
MatrixLayout::C { .. } => {

‎lax/src/least_squares.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ macro_rules! impl_least_squares {
9191
};
9292

9393
let rcond: Self::Real = -1.;
94-
let mut singular_values: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit( k as usize) };
94+
let mut singular_values: Vec<MaybeUninit<Self::Real>> = vec_uninit( k as usize);
9595
let mut rank: i32 = 0;
9696

9797
// eval work size
@@ -124,12 +124,12 @@ macro_rules! impl_least_squares {
124124

125125
// calc
126126
let lwork = work_size[0].to_usize().unwrap();
127-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
127+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(lwork);
128128
let liwork = iwork_size[0].to_usize().unwrap();
129-
let mut iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit(liwork) };
129+
let mut iwork: Vec<MaybeUninit<i32>> = vec_uninit(liwork);
130130
$(
131131
let lrwork = $rwork[0].to_usize().unwrap();
132-
let mut $rwork: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(lrwork) };
132+
let mut $rwork: Vec<MaybeUninit<Self::Real>> = vec_uninit(lrwork);
133133
)*
134134
unsafe {
135135
$gelsd(

‎lax/src/opnorm.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ macro_rules! impl_opnorm {
1919
MatrixLayout::C { .. } => t.transpose(),
2020
};
2121
let mut work: Vec<MaybeUninit<Self::Real>> = if matches!(t, NormType::Infinity) {
22-
unsafe { vec_uninit(m as usize) }
22+
vec_uninit(m as usize)
2323
} else {
2424
Vec::new()
2525
};

‎lax/src/qr.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ macro_rules! impl_qr {
2525
let m = l.lda();
2626
let n = l.len();
2727
let k = m.min(n);
28-
let mut tau = unsafe { vec_uninit(k as usize) };
28+
let mut tau = vec_uninit(k as usize);
2929

3030
// eval work size
3131
let mut info = 0;
@@ -62,7 +62,7 @@ macro_rules! impl_qr {
6262

6363
// calc
6464
let lwork = work_size[0].to_usize().unwrap();
65-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
65+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(lwork);
6666
unsafe {
6767
match l {
6868
MatrixLayout::F { .. } => {
@@ -136,7 +136,7 @@ macro_rules! impl_qr {
136136

137137
// calc
138138
let lwork = work_size[0].to_usize().unwrap();
139-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
139+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(lwork);
140140
unsafe {
141141
match l {
142142
MatrixLayout::F { .. } => $gqr(

‎lax/src/rcond.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -17,8 +17,8 @@ macro_rules! impl_rcond_real {
1717
let mut rcond = Self::Real::zero();
1818
let mut info = 0;
1919

20-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(4 * n as usize) };
21-
let mut iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit(n as usize) };
20+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(4 * n as usize);
21+
let mut iwork: Vec<MaybeUninit<i32>> = vec_uninit(n as usize);
2222
let norm_type = match l {
2323
MatrixLayout::C { .. } => NormType::Infinity,
2424
MatrixLayout::F { .. } => NormType::One,
@@ -54,8 +54,8 @@ macro_rules! impl_rcond_complex {
5454
let (n, _) = l.size();
5555
let mut rcond = Self::Real::zero();
5656
let mut info = 0;
57-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(2 * n as usize) };
58-
let mut rwork: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit(2 * n as usize) };
57+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(2 * n as usize);
58+
let mut rwork: Vec<MaybeUninit<Self::Real>> = vec_uninit(2 * n as usize);
5959
let norm_type = match l {
6060
MatrixLayout::C { .. } => NormType::Infinity,
6161
MatrixLayout::F { .. } => NormType::One,

‎lax/src/solve.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -75,7 +75,7 @@ macro_rules! impl_solve {
7575
return Ok(Vec::new());
7676
}
7777
let k = ::std::cmp::min(row, col);
78-
let mut ipiv = unsafe { vec_uninit(k as usize) };
78+
let mut ipiv = vec_uninit(k as usize);
7979
let mut info = 0;
8080
unsafe {
8181
$getrf(
@@ -117,7 +117,7 @@ macro_rules! impl_solve {
117117

118118
// actual
119119
let lwork = work_size[0].to_usize().unwrap();
120-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
120+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(lwork);
121121
unsafe {
122122
$getri(
123123
&l.len(),

‎lax/src/solveh.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,7 @@ macro_rules! impl_solveh {
5858
impl Solveh_ for $scalar {
5959
fn bk(l: MatrixLayout, uplo: UPLO, a: &mut [Self]) -> Result<Pivot> {
6060
let (n, _) = l.size();
61-
let mut ipiv = unsafe { vec_uninit(n as usize) };
61+
let mut ipiv = vec_uninit(n as usize);
6262
if n == 0 {
6363
return Ok(Vec::new());
6464
}
@@ -82,7 +82,7 @@ macro_rules! impl_solveh {
8282

8383
// actual
8484
let lwork = work_size[0].to_usize().unwrap();
85-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(lwork) };
85+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(lwork);
8686
unsafe {
8787
$trf(
8888
uplo.as_ptr(),
@@ -103,7 +103,7 @@ macro_rules! impl_solveh {
103103
fn invh(l: MatrixLayout, uplo: UPLO, a: &mut [Self], ipiv: &Pivot) -> Result<()> {
104104
let (n, _) = l.size();
105105
let mut info = 0;
106-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit(n as usize) };
106+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(n as usize);
107107
unsafe {
108108
$tri(
109109
uplo.as_ptr(),

‎lax/src/svd.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -51,23 +51,23 @@ macro_rules! impl_svd {
5151

5252
let m = l.lda();
5353
let mut u = match ju {
54-
JobSvd::All => Some(unsafe { vec_uninit( (m * m) as usize) }),
54+
JobSvd::All => Some(vec_uninit( (m * m) as usize)),
5555
JobSvd::None => None,
5656
_ => unimplemented!("SVD with partial vector output is not supported yet")
5757
};
5858

5959
let n = l.len();
6060
let mut vt = match jvt {
61-
JobSvd::All => Some(unsafe { vec_uninit( (n * n) as usize) }),
61+
JobSvd::All => Some(vec_uninit( (n * n) as usize)),
6262
JobSvd::None => None,
6363
_ => unimplemented!("SVD with partial vector output is not supported yet")
6464
};
6565

6666
let k = std::cmp::min(m, n);
67-
let mut s = unsafe { vec_uninit( k as usize) };
67+
let mut s = vec_uninit( k as usize);
6868

6969
$(
70-
let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit( 5 * k as usize) };
70+
let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = vec_uninit(5 * k as usize);
7171
)*
7272

7373
// eval work size
@@ -96,7 +96,7 @@ macro_rules! impl_svd {
9696

9797
// calc
9898
let lwork = work_size[0].to_usize().unwrap();
99-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit( lwork) };
99+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(lwork);
100100
unsafe {
101101
$gesvd(
102102
ju.as_ptr(),

‎lax/src/svddc.rs

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -30,20 +30,20 @@ macro_rules! impl_svddc {
3030
let m = l.lda();
3131
let n = l.len();
3232
let k = m.min(n);
33-
let mut s = unsafe { vec_uninit( k as usize) };
33+
let mut s = vec_uninit(k as usize);
3434

3535
let (u_col, vt_row) = match jobz {
3636
JobSvd::All | JobSvd::None => (m, n),
3737
JobSvd::Some => (k, k),
3838
};
3939
let (mut u, mut vt) = match jobz {
4040
JobSvd::All => (
41-
Some(unsafe { vec_uninit( (m * m) as usize) }),
42-
Some(unsafe { vec_uninit( (n * n) as usize) }),
41+
Some(vec_uninit((m * m) as usize)),
42+
Some(vec_uninit((n * n) as usize)),
4343
),
4444
JobSvd::Some => (
45-
Some(unsafe { vec_uninit( (m * u_col) as usize) }),
46-
Some(unsafe { vec_uninit( (n * vt_row) as usize) }),
45+
Some(vec_uninit((m * u_col) as usize)),
46+
Some(vec_uninit((n * vt_row) as usize)),
4747
),
4848
JobSvd::None => (None, None),
4949
};
@@ -55,12 +55,12 @@ macro_rules! impl_svddc {
5555
JobSvd::None => 7 * mn,
5656
_ => std::cmp::max(5*mn*mn + 5*mn, 2*mx*mn + 2*mn*mn + mn),
5757
};
58-
let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = unsafe { vec_uninit( lrwork) };
58+
let mut $rwork_ident: Vec<MaybeUninit<Self::Real>> = vec_uninit(lrwork);
5959
)*
6060

6161
// eval work size
6262
let mut info = 0;
63-
let mut iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit( 8 * k as usize) };
63+
let mut iwork: Vec<MaybeUninit<i32>> = vec_uninit(8 * k as usize);
6464
let mut work_size = [Self::zero()];
6565
unsafe {
6666
$gesdd(
@@ -85,7 +85,7 @@ macro_rules! impl_svddc {
8585

8686
// do svd
8787
let lwork = work_size[0].to_usize().unwrap();
88-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit( lwork) };
88+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(lwork);
8989
unsafe {
9090
$gesdd(
9191
jobz.as_ptr(),

‎lax/src/tridiagonal.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -152,8 +152,8 @@ macro_rules! impl_tridiagonal {
152152
impl Tridiagonal_ for $scalar {
153153
fn lu_tridiagonal(mut a: Tridiagonal<Self>) -> Result<LUFactorizedTridiagonal<Self>> {
154154
let (n, _) = a.l.size();
155-
let mut du2 = unsafe { vec_uninit( (n - 2) as usize) };
156-
let mut ipiv = unsafe { vec_uninit( n as usize) };
155+
let mut du2 = vec_uninit( (n - 2) as usize);
156+
let mut ipiv = vec_uninit( n as usize);
157157
// We have to calc one-norm before LU factorization
158158
let a_opnorm_one = a.opnorm_one();
159159
let mut info = 0;
@@ -182,9 +182,9 @@ macro_rules! impl_tridiagonal {
182182
fn rcond_tridiagonal(lu: &LUFactorizedTridiagonal<Self>) -> Result<Self::Real> {
183183
let (n, _) = lu.a.l.size();
184184
let ipiv = &lu.ipiv;
185-
let mut work: Vec<MaybeUninit<Self>> = unsafe { vec_uninit( 2 * n as usize) };
185+
let mut work: Vec<MaybeUninit<Self>> = vec_uninit(2 * n as usize);
186186
$(
187-
let mut $iwork: Vec<MaybeUninit<i32>> = unsafe { vec_uninit( n as usize) };
187+
let mut $iwork: Vec<MaybeUninit<i32>> = vec_uninit(n as usize);
188188
)*
189189
let mut rcond = Self::Real::zero();
190190
let mut info = 0;

0 commit comments

Comments
 (0)