Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 0470a82

Browse files
termoshtttermoshtt
committedSep 17, 2022
Use random_*_using API in ndarray_linalg/tests
1 parent b1fe48f commit 0470a82

21 files changed

+277
-156
lines changed
 

‎ndarray-linalg/tests/arnoldi.rs

Lines changed: 12 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -3,8 +3,9 @@ use ndarray_linalg::{krylov::*, *};
33

44
#[test]
55
fn aq_qh_mgs() {
6-
let a: Array2<f64> = random((5, 5));
7-
let v: Array1<f64> = random(5);
6+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
7+
let a: Array2<f64> = random_using((5, 5), &mut rng);
8+
let v: Array1<f64> = random_using(5, &mut rng);
89
let (q, h) = arnoldi_mgs(a.clone(), v, 1e-9);
910
println!("A = \n{:?}", &a);
1011
println!("Q = \n{:?}", &q);
@@ -18,8 +19,9 @@ fn aq_qh_mgs() {
1819

1920
#[test]
2021
fn aq_qh_householder() {
21-
let a: Array2<f64> = random((5, 5));
22-
let v: Array1<f64> = random(5);
22+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
23+
let a: Array2<f64> = random_using((5, 5), &mut rng);
24+
let v: Array1<f64> = random_using(5, &mut rng);
2325
let (q, h) = arnoldi_mgs(a.clone(), v, 1e-9);
2426
println!("A = \n{:?}", &a);
2527
println!("Q = \n{:?}", &q);
@@ -33,8 +35,9 @@ fn aq_qh_householder() {
3335

3436
#[test]
3537
fn aq_qh_mgs_complex() {
36-
let a: Array2<c64> = random((5, 5));
37-
let v: Array1<c64> = random(5);
38+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
39+
let a: Array2<c64> = random_using((5, 5), &mut rng);
40+
let v: Array1<c64> = random_using(5, &mut rng);
3841
let (q, h) = arnoldi_mgs(a.clone(), v, 1e-9);
3942
println!("A = \n{:?}", &a);
4043
println!("Q = \n{:?}", &q);
@@ -48,8 +51,9 @@ fn aq_qh_mgs_complex() {
4851

4952
#[test]
5053
fn aq_qh_householder_complex() {
51-
let a: Array2<c64> = random((5, 5));
52-
let v: Array1<c64> = random(5);
54+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
55+
let a: Array2<c64> = random_using((5, 5), &mut rng);
56+
let v: Array1<c64> = random_using(5, &mut rng);
5357
let (q, h) = arnoldi_mgs(a.clone(), v, 1e-9);
5458
println!("A = \n{:?}", &a);
5559
println!("Q = \n{:?}", &q);

‎ndarray-linalg/tests/cholesky.rs

Lines changed: 11 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,8 @@ macro_rules! cholesky {
66
paste::item! {
77
#[test]
88
fn [<cholesky_ $elem>]() {
9-
let a_orig: Array2<$elem> = random_hpd(3);
9+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
10+
let a_orig: Array2<$elem> = random_hpd_using(3, &mut rng);
1011
println!("a = \n{:?}", a_orig);
1112

1213
let upper = a_orig.cholesky(UPLO::Upper).unwrap();
@@ -79,7 +80,8 @@ macro_rules! cholesky_into_lower_upper {
7980
paste::item! {
8081
#[test]
8182
fn [<cholesky_into_lower_upper_ $elem>]() {
82-
let a: Array2<$elem> = random_hpd(3);
83+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
84+
let a: Array2<$elem> = random_hpd_using(3, &mut rng);
8385
println!("a = \n{:?}", a);
8486
let upper = a.cholesky(UPLO::Upper).unwrap();
8587
let fac_upper = a.factorizec(UPLO::Upper).unwrap();
@@ -106,7 +108,8 @@ macro_rules! cholesky_into_inverse {
106108
paste::item! {
107109
#[test]
108110
fn [<cholesky_inverse_ $elem>]() {
109-
let a: Array2<$elem> = random_hpd(3);
111+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
112+
let a: Array2<$elem> = random_hpd_using(3, &mut rng);
110113
println!("a = \n{:?}", a);
111114
let inv = a.invc().unwrap();
112115
assert_close_l2!(&a.dot(&inv), &Array2::eye(3), $rtol);
@@ -134,7 +137,8 @@ macro_rules! cholesky_det {
134137
paste::item! {
135138
#[test]
136139
fn [<cholesky_det_ $elem>]() {
137-
let a: Array2<$elem> = random_hpd(3);
140+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
141+
let a: Array2<$elem> = random_hpd_using(3, &mut rng);
138142
println!("a = \n{:?}", a);
139143
let ln_det = a
140144
.eigvalsh(UPLO::Upper)
@@ -168,8 +172,9 @@ macro_rules! cholesky_solve {
168172
paste::item! {
169173
#[test]
170174
fn [<cholesky_solve_ $elem>]() {
171-
let a: Array2<$elem> = random_hpd(3);
172-
let x: Array1<$elem> = random(3);
175+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
176+
let a: Array2<$elem> = random_hpd_using(3, &mut rng);
177+
let x: Array1<$elem> = random_using(3, &mut rng);
173178
let b = a.dot(&x);
174179
println!("a = \n{:?}", a);
175180
println!("x = \n{:?}", x);

‎ndarray-linalg/tests/convert.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,8 @@ use ndarray_linalg::*;
33

44
#[test]
55
fn generalize() {
6-
let a: Array3<f64> = random((3, 2, 4).f());
6+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
7+
let a: Array3<f64> = random_using((3, 2, 4).f(), &mut rng);
78
let ans = a.clone();
89
let a: Array3<f64> = convert::generalize(a);
910
assert_eq!(a, ans);

‎ndarray-linalg/tests/det.rs

Lines changed: 31 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -136,23 +136,45 @@ fn det() {
136136
assert_rclose!(result.1, ln_det, rtol);
137137
}
138138
}
139+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
139140
for rows in 1..5 {
140-
det_impl(random_regular::<f64>(rows), 1e-9);
141-
det_impl(random_regular::<f32>(rows), 1e-4);
142-
det_impl(random_regular::<c64>(rows), 1e-9);
143-
det_impl(random_regular::<c32>(rows), 1e-4);
144-
det_impl(random_regular::<f64>(rows).t().to_owned(), 1e-9);
145-
det_impl(random_regular::<f32>(rows).t().to_owned(), 1e-4);
146-
det_impl(random_regular::<c64>(rows).t().to_owned(), 1e-9);
147-
det_impl(random_regular::<c32>(rows).t().to_owned(), 1e-4);
141+
det_impl(random_regular_using::<f64, _>(rows, &mut rng), 1e-9);
142+
det_impl(random_regular_using::<f32, _>(rows, &mut rng), 1e-4);
143+
det_impl(random_regular_using::<c64, _>(rows, &mut rng), 1e-9);
144+
det_impl(random_regular_using::<c32, _>(rows, &mut rng), 1e-4);
145+
det_impl(
146+
random_regular_using::<f64, _>(rows, &mut rng)
147+
.t()
148+
.to_owned(),
149+
1e-9,
150+
);
151+
det_impl(
152+
random_regular_using::<f32, _>(rows, &mut rng)
153+
.t()
154+
.to_owned(),
155+
1e-4,
156+
);
157+
det_impl(
158+
random_regular_using::<c64, _>(rows, &mut rng)
159+
.t()
160+
.to_owned(),
161+
1e-9,
162+
);
163+
det_impl(
164+
random_regular_using::<c32, _>(rows, &mut rng)
165+
.t()
166+
.to_owned(),
167+
1e-4,
168+
);
148169
}
149170
}
150171

151172
#[test]
152173
fn det_nonsquare() {
153174
macro_rules! det_nonsquare {
154175
($elem:ty, $shape:expr) => {
155-
let a: Array2<$elem> = random($shape);
176+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
177+
let a: Array2<$elem> = random_using($shape, &mut rng);
156178
assert!(a.factorize().unwrap().det().is_err());
157179
assert!(a.factorize().unwrap().sln_det().is_err());
158180
assert!(a.factorize().unwrap().det_into().is_err());

‎ndarray-linalg/tests/deth.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,8 @@ fn deth_zero_nonsquare() {
7272
fn deth() {
7373
macro_rules! deth {
7474
($elem:ty, $rows:expr, $atol:expr) => {
75-
let a: Array2<$elem> = random_hermite($rows);
75+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
76+
let a: Array2<$elem> = random_hermite_using($rows, &mut rng);
7677
println!("a = \n{:?}", a);
7778

7879
// Compute determinant from eigenvalues.

‎ndarray-linalg/tests/eigh.rs

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,8 @@ fn fixed_t_lower() {
7979

8080
#[test]
8181
fn ssqrt() {
82-
let a: Array2<f64> = random_hpd(3);
82+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
83+
let a: Array2<f64> = random_hpd_using(3, &mut rng);
8384
let ans = a.clone();
8485
let s = a.ssqrt(UPLO::Upper).unwrap();
8586
println!("a = {:?}", &ans);
@@ -92,7 +93,8 @@ fn ssqrt() {
9293

9394
#[test]
9495
fn ssqrt_t() {
95-
let a: Array2<f64> = random_hpd(3).reversed_axes();
96+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
97+
let a: Array2<f64> = random_hpd_using(3, &mut rng).reversed_axes();
9698
let ans = a.clone();
9799
let s = a.ssqrt(UPLO::Upper).unwrap();
98100
println!("a = {:?}", &ans);
@@ -105,7 +107,8 @@ fn ssqrt_t() {
105107

106108
#[test]
107109
fn ssqrt_lower() {
108-
let a: Array2<f64> = random_hpd(3);
110+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
111+
let a: Array2<f64> = random_hpd_using(3, &mut rng);
109112
let ans = a.clone();
110113
let s = a.ssqrt(UPLO::Lower).unwrap();
111114
println!("a = {:?}", &ans);
@@ -118,7 +121,8 @@ fn ssqrt_lower() {
118121

119122
#[test]
120123
fn ssqrt_t_lower() {
121-
let a: Array2<f64> = random_hpd(3).reversed_axes();
124+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
125+
let a: Array2<f64> = random_hpd_using(3, &mut rng).reversed_axes();
122126
let ans = a.clone();
123127
let s = a.ssqrt(UPLO::Lower).unwrap();
124128
println!("a = {:?}", &ans);

‎ndarray-linalg/tests/householder.rs

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,8 @@ use ndarray_linalg::{krylov::*, *};
33

44
fn over<A: Scalar + Lapack>(rtol: A::Real) {
55
const N: usize = 4;
6-
let a: Array2<A> = random((N, N * 2));
6+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
7+
let a: Array2<A> = random_using((N, N * 2), &mut rng);
78

89
// Terminate
910
let (q, r) = householder(a.axis_iter(Axis(1)), N, rtol, Strategy::Terminate);
@@ -45,7 +46,8 @@ fn over_c64() {
4546

4647
fn full<A: Scalar + Lapack>(rtol: A::Real) {
4748
const N: usize = 5;
48-
let a: Array2<A> = random((N, N));
49+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
50+
let a: Array2<A> = random_using((N, N), &mut rng);
4951
let (q, r) = householder(a.axis_iter(Axis(1)), N, rtol, Strategy::Terminate);
5052
let qc: Array2<A> = conjugate(&q);
5153
assert_close_l2!(&qc.dot(&q), &Array::eye(N), rtol; "Check Q^H Q = I");
@@ -71,7 +73,8 @@ fn full_c64() {
7173

7274
fn half<A: Scalar + Lapack>(rtol: A::Real) {
7375
const N: usize = 4;
74-
let a: Array2<A> = random((N, N / 2));
76+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
77+
let a: Array2<A> = random_using((N, N / 2), &mut rng);
7578
let (q, r) = householder(a.axis_iter(Axis(1)), N, rtol, Strategy::Terminate);
7679
let qc: Array2<A> = conjugate(&q);
7780
assert_close_l2!(&qc.dot(&q), &Array::eye(N / 2), rtol; "Check Q^H Q = I");

‎ndarray-linalg/tests/inner.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,8 @@ fn size_longer() {
1919

2020
#[test]
2121
fn abs() {
22-
let a: Array1<c32> = random(1);
22+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
23+
let a: Array1<c32> = random_using(1, &mut rng);
2324
let aa = a.inner(&a);
2425
assert_aclose!(aa.re(), a.norm().powi(2), 1e-5);
2526
assert_aclose!(aa.im(), 0.0, 1e-5);

‎ndarray-linalg/tests/inv.rs

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,8 @@ fn test_inv_random<A>(n: usize, set_f: bool, rtol: A::Real)
55
where
66
A: Scalar + Lapack,
77
{
8-
let a: Array2<A> = random([n; 2].set_f(set_f));
8+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
9+
let a: Array2<A> = random_using([n; 2].set_f(set_f), &mut rng);
910
let identity = Array2::eye(n);
1011
assert_close_l2!(&a.inv().unwrap().dot(&a), &identity, rtol);
1112
assert_close_l2!(
@@ -24,7 +25,8 @@ fn test_inv_into_random<A>(n: usize, set_f: bool, rtol: A::Real)
2425
where
2526
A: Scalar + Lapack,
2627
{
27-
let a: Array2<A> = random([n; 2].set_f(set_f));
28+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
29+
let a: Array2<A> = random_using([n; 2].set_f(set_f), &mut rng);
2830
let identity = Array2::eye(n);
2931
assert_close_l2!(&a.clone().inv_into().unwrap().dot(&a), &identity, rtol);
3032
assert_close_l2!(

‎ndarray-linalg/tests/least_squares.rs

Lines changed: 18 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,8 @@ use ndarray_linalg::*;
55

66
/// A is square. `x = A^{-1} b`, `|b - Ax| = 0`
77
fn test_exact<T: Scalar + Lapack>(a: Array2<T>) {
8-
let b: Array1<T> = random(3);
8+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
9+
let b: Array1<T> = random_using(3, &mut rng);
910
let result = a.least_squares(&b).unwrap();
1011
// unpack result
1112
let x = result.solution;
@@ -27,13 +28,15 @@ macro_rules! impl_exact {
2728
paste::item! {
2829
#[test]
2930
fn [<least_squares_ $scalar _exact>]() {
30-
let a: Array2<$scalar> = random((3, 3));
31+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
32+
let a: Array2<$scalar> = random_using((3, 3), &mut rng);
3133
test_exact(a)
3234
}
3335

3436
#[test]
3537
fn [<least_squares_ $scalar _exact_t>]() {
36-
let a: Array2<$scalar> = random((3, 3).f());
38+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
39+
let a: Array2<$scalar> = random_using((3, 3).f(), &mut rng);
3740
test_exact(a)
3841
}
3942
}
@@ -51,7 +54,8 @@ fn test_overdetermined<T: Scalar + Lapack>(a: Array2<T>)
5154
where
5255
T::Real: AbsDiffEq<Epsilon = T::Real>,
5356
{
54-
let b: Array1<T> = random(4);
57+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
58+
let b: Array1<T> = random_using(4, &mut rng);
5559
let result = a.least_squares(&b).unwrap();
5660
// unpack result
5761
let x = result.solution;
@@ -73,13 +77,15 @@ macro_rules! impl_overdetermined {
7377
paste::item! {
7478
#[test]
7579
fn [<least_squares_ $scalar _overdetermined>]() {
76-
let a: Array2<$scalar> = random((4, 3));
80+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
81+
let a: Array2<$scalar> = random_using((4, 3), &mut rng);
7782
test_overdetermined(a)
7883
}
7984

8085
#[test]
8186
fn [<least_squares_ $scalar _overdetermined_t>]() {
82-
let a: Array2<$scalar> = random((4, 3).f());
87+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
88+
let a: Array2<$scalar> = random_using((4, 3).f(), &mut rng);
8389
test_overdetermined(a)
8490
}
8591
}
@@ -94,7 +100,8 @@ impl_overdetermined!(c64);
94100
/// #column > #row case.
95101
/// Linear problem is underdetermined, `|b - Ax| = 0` and `x` is not unique
96102
fn test_underdetermined<T: Scalar + Lapack>(a: Array2<T>) {
97-
let b: Array1<T> = random(3);
103+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
104+
let b: Array1<T> = random_using(3, &mut rng);
98105
let result = a.least_squares(&b).unwrap();
99106
assert_eq!(result.rank, 3);
100107
assert!(result.residual_sum_of_squares.is_none());
@@ -110,13 +117,15 @@ macro_rules! impl_underdetermined {
110117
paste::item! {
111118
#[test]
112119
fn [<least_squares_ $scalar _underdetermined>]() {
113-
let a: Array2<$scalar> = random((3, 4));
120+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
121+
let a: Array2<$scalar> = random_using((3, 4), &mut rng);
114122
test_underdetermined(a)
115123
}
116124

117125
#[test]
118126
fn [<least_squares_ $scalar _underdetermined_t>]() {
119-
let a: Array2<$scalar> = random((3, 4).f());
127+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
128+
let a: Array2<$scalar> = random_using((3, 4).f(), &mut rng);
120129
test_underdetermined(a)
121130
}
122131
}

‎ndarray-linalg/tests/least_squares_nrhs.rs

Lines changed: 36 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -32,29 +32,33 @@ macro_rules! impl_exact {
3232
paste::item! {
3333
#[test]
3434
fn [<least_squares_ $scalar _exact_ac_bc>]() {
35-
let a: Array2<$scalar> = random((3, 3));
36-
let b: Array2<$scalar> = random((3, 2));
35+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
36+
let a: Array2<$scalar> = random_using((3, 3), &mut rng);
37+
let b: Array2<$scalar> = random_using((3, 2), &mut rng);
3738
test_exact(a, b)
3839
}
3940

4041
#[test]
4142
fn [<least_squares_ $scalar _exact_ac_bf>]() {
42-
let a: Array2<$scalar> = random((3, 3));
43-
let b: Array2<$scalar> = random((3, 2).f());
43+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
44+
let a: Array2<$scalar> = random_using((3, 3), &mut rng);
45+
let b: Array2<$scalar> = random_using((3, 2).f(), &mut rng);
4446
test_exact(a, b)
4547
}
4648

4749
#[test]
4850
fn [<least_squares_ $scalar _exact_af_bc>]() {
49-
let a: Array2<$scalar> = random((3, 3).f());
50-
let b: Array2<$scalar> = random((3, 2));
51+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
52+
let a: Array2<$scalar> = random_using((3, 3).f(), &mut rng);
53+
let b: Array2<$scalar> = random_using((3, 2), &mut rng);
5154
test_exact(a, b)
5255
}
5356

5457
#[test]
5558
fn [<least_squares_ $scalar _exact_af_bf>]() {
56-
let a: Array2<$scalar> = random((3, 3).f());
57-
let b: Array2<$scalar> = random((3, 2).f());
59+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
60+
let a: Array2<$scalar> = random_using((3, 3).f(), &mut rng);
61+
let b: Array2<$scalar> = random_using((3, 2).f(), &mut rng);
5862
test_exact(a, b)
5963
}
6064
}
@@ -100,29 +104,33 @@ macro_rules! impl_overdetermined {
100104
paste::item! {
101105
#[test]
102106
fn [<least_squares_ $scalar _overdetermined_ac_bc>]() {
103-
let a: Array2<$scalar> = random((4, 3));
104-
let b: Array2<$scalar> = random((4, 2));
107+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
108+
let a: Array2<$scalar> = random_using((4, 3), &mut rng);
109+
let b: Array2<$scalar> = random_using((4, 2), &mut rng);
105110
test_overdetermined(a, b)
106111
}
107112

108113
#[test]
109114
fn [<least_squares_ $scalar _overdetermined_af_bc>]() {
110-
let a: Array2<$scalar> = random((4, 3).f());
111-
let b: Array2<$scalar> = random((4, 2));
115+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
116+
let a: Array2<$scalar> = random_using((4, 3).f(), &mut rng);
117+
let b: Array2<$scalar> = random_using((4, 2), &mut rng);
112118
test_overdetermined(a, b)
113119
}
114120

115121
#[test]
116122
fn [<least_squares_ $scalar _overdetermined_ac_bf>]() {
117-
let a: Array2<$scalar> = random((4, 3));
118-
let b: Array2<$scalar> = random((4, 2).f());
123+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
124+
let a: Array2<$scalar> = random_using((4, 3), &mut rng);
125+
let b: Array2<$scalar> = random_using((4, 2).f(), &mut rng);
119126
test_overdetermined(a, b)
120127
}
121128

122129
#[test]
123130
fn [<least_squares_ $scalar _overdetermined_af_bf>]() {
124-
let a: Array2<$scalar> = random((4, 3).f());
125-
let b: Array2<$scalar> = random((4, 2).f());
131+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
132+
let a: Array2<$scalar> = random_using((4, 3).f(), &mut rng);
133+
let b: Array2<$scalar> = random_using((4, 2).f(), &mut rng);
126134
test_overdetermined(a, b)
127135
}
128136
}
@@ -155,29 +163,33 @@ macro_rules! impl_underdetermined {
155163
paste::item! {
156164
#[test]
157165
fn [<least_squares_ $scalar _underdetermined_ac_bc>]() {
158-
let a: Array2<$scalar> = random((3, 4));
159-
let b: Array2<$scalar> = random((3, 2));
166+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
167+
let a: Array2<$scalar> = random_using((3, 4), &mut rng);
168+
let b: Array2<$scalar> = random_using((3, 2), &mut rng);
160169
test_underdetermined(a, b)
161170
}
162171

163172
#[test]
164173
fn [<least_squares_ $scalar _underdetermined_af_bc>]() {
165-
let a: Array2<$scalar> = random((3, 4).f());
166-
let b: Array2<$scalar> = random((3, 2));
174+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
175+
let a: Array2<$scalar> = random_using((3, 4).f(), &mut rng);
176+
let b: Array2<$scalar> = random_using((3, 2), &mut rng);
167177
test_underdetermined(a, b)
168178
}
169179

170180
#[test]
171181
fn [<least_squares_ $scalar _underdetermined_ac_bf>]() {
172-
let a: Array2<$scalar> = random((3, 4));
173-
let b: Array2<$scalar> = random((3, 2).f());
182+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
183+
let a: Array2<$scalar> = random_using((3, 4), &mut rng);
184+
let b: Array2<$scalar> = random_using((3, 2).f(), &mut rng);
174185
test_underdetermined(a, b)
175186
}
176187

177188
#[test]
178189
fn [<least_squares_ $scalar _underdetermined_af_bf>]() {
179-
let a: Array2<$scalar> = random((3, 4).f());
180-
let b: Array2<$scalar> = random((3, 2).f());
190+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
191+
let a: Array2<$scalar> = random_using((3, 4).f(), &mut rng);
192+
let b: Array2<$scalar> = random_using((3, 2).f(), &mut rng);
181193
test_underdetermined(a, b)
182194
}
183195
}

‎ndarray-linalg/tests/mgs.rs

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,8 @@ fn qr_full<A: Scalar + Lapack>() {
55
const N: usize = 5;
66
let rtol: A::Real = A::real(1e-9);
77

8-
let a: Array2<A> = random((N, N));
8+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
9+
let a: Array2<A> = random_using((N, N), &mut rng);
910
let (q, r) = mgs(a.axis_iter(Axis(1)), N, rtol, Strategy::Terminate);
1011
assert_close_l2!(&q.dot(&r), &a, rtol);
1112

@@ -27,7 +28,8 @@ fn qr<A: Scalar + Lapack>() {
2728
const N: usize = 4;
2829
let rtol: A::Real = A::real(1e-9);
2930

30-
let a: Array2<A> = random((N, N / 2));
31+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
32+
let a: Array2<A> = random_using((N, N / 2), &mut rng);
3133
let (q, r) = mgs(a.axis_iter(Axis(1)), N, rtol, Strategy::Terminate);
3234
assert_close_l2!(&q.dot(&r), &a, rtol);
3335

@@ -49,7 +51,8 @@ fn qr_over<A: Scalar + Lapack>() {
4951
const N: usize = 4;
5052
let rtol: A::Real = A::real(1e-9);
5153

52-
let a: Array2<A> = random((N, N * 2));
54+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
55+
let a: Array2<A> = random_using((N, N * 2), &mut rng);
5356

5457
// Terminate
5558
let (q, r) = mgs(a.axis_iter(Axis(1)), N, rtol, Strategy::Terminate);

‎ndarray-linalg/tests/normalize.rs

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,14 +3,16 @@ use ndarray_linalg::*;
33

44
#[test]
55
fn n_columns() {
6-
let a: Array2<f64> = random((3, 2));
6+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
7+
let a: Array2<f64> = random_using((3, 2), &mut rng);
78
let (n, v) = normalize(a.clone(), NormalizeAxis::Column);
89
assert_close_l2!(&n.dot(&from_diag(&v)), &a, 1e-7);
910
}
1011

1112
#[test]
1213
fn n_rows() {
13-
let a: Array2<f64> = random((3, 2));
14+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
15+
let a: Array2<f64> = random_using((3, 2), &mut rng);
1416
let (n, v) = normalize(a.clone(), NormalizeAxis::Row);
1517
assert_close_l2!(&from_diag(&v).dot(&n), &a, 1e-7);
1618
}

‎ndarray-linalg/tests/qr.rs

Lines changed: 16 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -26,48 +26,56 @@ fn test_square(a: &Array2<f64>, n: usize, m: usize) {
2626

2727
#[test]
2828
fn qr_sq() {
29-
let a = random((3, 3));
29+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
30+
let a = random_using((3, 3), &mut rng);
3031
test_square(&a, 3, 3);
3132
}
3233

3334
#[test]
3435
fn qr_sq_t() {
35-
let a = random((3, 3).f());
36+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
37+
let a = random_using((3, 3).f(), &mut rng);
3638
test_square(&a, 3, 3);
3739
}
3840

3941
#[test]
4042
fn qr_3x3() {
41-
let a = random((3, 3));
43+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
44+
let a = random_using((3, 3), &mut rng);
4245
test(&a, 3, 3);
4346
}
4447

4548
#[test]
4649
fn qr_3x3_t() {
47-
let a = random((3, 3).f());
50+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
51+
let a = random_using((3, 3).f(), &mut rng);
4852
test(&a, 3, 3);
4953
}
5054

5155
#[test]
5256
fn qr_3x4() {
53-
let a = random((3, 4));
57+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
58+
let a = random_using((3, 4), &mut rng);
5459
test(&a, 3, 4);
5560
}
5661

5762
#[test]
5863
fn qr_3x4_t() {
59-
let a = random((3, 4).f());
64+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
65+
let a = random_using((3, 4).f(), &mut rng);
6066
test(&a, 3, 4);
6167
}
6268

6369
#[test]
6470
fn qr_4x3() {
65-
let a = random((4, 3));
71+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
72+
let a = random_using((4, 3), &mut rng);
6673
test(&a, 4, 3);
6774
}
6875

6976
#[test]
7077
fn qr_4x3_t() {
71-
let a = random((4, 3).f());
78+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
79+
let a = random_using((4, 3).f(), &mut rng);
7280
test(&a, 4, 3);
7381
}

‎ndarray-linalg/tests/solve.rs

Lines changed: 34 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
use ndarray::prelude::*;
22
use ndarray_linalg::{
3-
assert_aclose, assert_close_l2, c32, c64, random, random_hpd, solve::*, OperationNorm, Scalar,
3+
assert_aclose, assert_close_l2, c32, c64, random_hpd_using, random_using, solve::*,
4+
OperationNorm, Scalar,
45
};
56

67
macro_rules! test_solve {
@@ -97,12 +98,13 @@ macro_rules! test_solve_all {
9798

9899
#[test]
99100
fn solve_random_float() {
101+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
100102
for n in 0..=8 {
101103
for &set_f in &[false, true] {
102104
test_solve_all!(
103105
[f32 => 1e-3, f64 => 1e-9],
104-
a = random([n; 2].set_f(set_f)),
105-
x = random(n),
106+
a = random_using([n; 2].set_f(set_f), &mut rng),
107+
x = random_using(n, &mut rng),
106108
b = a.dot(&x),
107109
[solve, solve_into, solve_inplace],
108110
);
@@ -112,12 +114,13 @@ fn solve_random_float() {
112114

113115
#[test]
114116
fn solve_random_complex() {
117+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
115118
for n in 0..=8 {
116119
for &set_f in &[false, true] {
117120
test_solve_all!(
118121
[c32 => 1e-3, c64 => 1e-9],
119-
a = random([n; 2].set_f(set_f)),
120-
x = random(n),
122+
a = random_using([n; 2].set_f(set_f), &mut rng),
123+
x = random_using(n, &mut rng),
121124
b = a.dot(&x),
122125
[solve, solve_into, solve_inplace],
123126
);
@@ -128,19 +131,21 @@ fn solve_random_complex() {
128131
#[should_panic]
129132
#[test]
130133
fn solve_shape_mismatch() {
131-
let a: Array2<f64> = random((3, 3));
132-
let b: Array1<f64> = random(2);
134+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
135+
let a: Array2<f64> = random_using((3, 3), &mut rng);
136+
let b: Array1<f64> = random_using(2, &mut rng);
133137
let _ = a.solve_into(b);
134138
}
135139

136140
#[test]
137141
fn solve_t_random_float() {
142+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
138143
for n in 0..=8 {
139144
for &set_f in &[false, true] {
140145
test_solve_all!(
141146
[f32 => 1e-3, f64 => 1e-9],
142-
a = random([n; 2].set_f(set_f)),
143-
x = random(n),
147+
a = random_using([n; 2].set_f(set_f), &mut rng),
148+
x = random_using(n, &mut rng),
144149
b = a.t().dot(&x),
145150
[solve_t, solve_t_into, solve_t_inplace],
146151
);
@@ -151,19 +156,21 @@ fn solve_t_random_float() {
151156
#[should_panic]
152157
#[test]
153158
fn solve_t_shape_mismatch() {
154-
let a: Array2<f64> = random((3, 3).f());
155-
let b: Array1<f64> = random(4);
159+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
160+
let a: Array2<f64> = random_using((3, 3).f(), &mut rng);
161+
let b: Array1<f64> = random_using(4, &mut rng);
156162
let _ = a.solve_into(b);
157163
}
158164

159165
#[test]
160166
fn solve_t_random_complex() {
167+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
161168
for n in 0..=8 {
162169
for &set_f in &[false, true] {
163170
test_solve_all!(
164171
[c32 => 1e-3, c64 => 1e-9],
165-
a = random([n; 2].set_f(set_f)),
166-
x = random(n),
172+
a = random_using([n; 2].set_f(set_f), &mut rng),
173+
x = random_using(n, &mut rng),
167174
b = a.t().dot(&x),
168175
[solve_t, solve_t_into, solve_t_inplace],
169176
);
@@ -174,20 +181,22 @@ fn solve_t_random_complex() {
174181
#[should_panic]
175182
#[test]
176183
fn solve_factorized_shape_mismatch() {
177-
let a: Array2<f64> = random((3, 3));
178-
let b: Array1<f64> = random(4);
184+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
185+
let a: Array2<f64> = random_using((3, 3), &mut rng);
186+
let b: Array1<f64> = random_using(4, &mut rng);
179187
let f = a.factorize_into().unwrap();
180188
let _ = f.solve_into(b);
181189
}
182190

183191
#[test]
184192
fn solve_h_random_float() {
193+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
185194
for n in 0..=8 {
186195
for &set_f in &[false, true] {
187196
test_solve_all!(
188197
[f32 => 1e-3, f64 => 1e-9],
189-
a = random([n; 2].set_f(set_f)),
190-
x = random(n),
198+
a = random_using([n; 2].set_f(set_f), &mut rng),
199+
x = random_using(n, &mut rng),
191200
b = a.t().mapv(|x| x.conj()).dot(&x),
192201
[solve_h, solve_h_into, solve_h_inplace],
193202
);
@@ -198,20 +207,22 @@ fn solve_h_random_float() {
198207
#[should_panic]
199208
#[test]
200209
fn solve_factorized_t_shape_mismatch() {
201-
let a: Array2<f64> = random((3, 3).f());
202-
let b: Array1<f64> = random(4);
210+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
211+
let a: Array2<f64> = random_using((3, 3).f(), &mut rng);
212+
let b: Array1<f64> = random_using(4, &mut rng);
203213
let f = a.factorize_into().unwrap();
204214
let _ = f.solve_into(b);
205215
}
206216

207217
#[test]
208218
fn solve_h_random_complex() {
219+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
209220
for n in 0..=8 {
210221
for &set_f in &[false, true] {
211222
test_solve_all!(
212223
[c32 => 1e-3, c64 => 1e-9],
213-
a = random([n; 2].set_f(set_f)),
214-
x = random(n),
224+
a = random_using([n; 2].set_f(set_f), &mut rng),
225+
x = random_using(n, &mut rng),
215226
b = a.t().mapv(|x| x.conj()).dot(&x),
216227
[solve_h, solve_h_into, solve_h_inplace],
217228
);
@@ -223,7 +234,8 @@ fn solve_h_random_complex() {
223234
fn rcond() {
224235
macro_rules! rcond {
225236
($elem:ty, $rows:expr, $atol:expr) => {
226-
let a: Array2<$elem> = random_hpd($rows);
237+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
238+
let a: Array2<$elem> = random_hpd_using($rows, &mut rng);
227239
let rcond = 1. / (a.opnorm_one().unwrap() * a.inv().unwrap().opnorm_one().unwrap());
228240
assert_aclose!(a.rcond().unwrap(), rcond, $atol);
229241
assert_aclose!(a.rcond_into().unwrap(), rcond, $atol);

‎ndarray-linalg/tests/solveh.rs

Lines changed: 18 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -4,24 +4,27 @@ use ndarray_linalg::*;
44
#[should_panic]
55
#[test]
66
fn solveh_shape_mismatch() {
7-
let a: Array2<f64> = random_hpd(3);
8-
let b: Array1<f64> = random(2);
7+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
8+
let a: Array2<f64> = random_hpd_using(3, &mut rng);
9+
let b: Array1<f64> = random_using(2, &mut rng);
910
let _ = a.solveh_into(b);
1011
}
1112

1213
#[should_panic]
1314
#[test]
1415
fn factorizeh_solveh_shape_mismatch() {
15-
let a: Array2<f64> = random_hpd(3);
16-
let b: Array1<f64> = random(2);
16+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
17+
let a: Array2<f64> = random_hpd_using(3, &mut rng);
18+
let b: Array1<f64> = random_using(2, &mut rng);
1719
let f = a.factorizeh_into().unwrap();
1820
let _ = f.solveh_into(b);
1921
}
2022

2123
#[test]
2224
fn solveh_random() {
23-
let a: Array2<f64> = random_hpd(3);
24-
let x: Array1<f64> = random(3);
25+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
26+
let a: Array2<f64> = random_hpd_using(3, &mut rng);
27+
let x: Array1<f64> = random_using(3, &mut rng);
2528
let b = a.dot(&x);
2629
let y = a.solveh_into(b).unwrap();
2730
assert_close_l2!(&x, &y, 1e-7);
@@ -35,24 +38,27 @@ fn solveh_random() {
3538
#[should_panic]
3639
#[test]
3740
fn solveh_t_shape_mismatch() {
38-
let a: Array2<f64> = random_hpd(3).reversed_axes();
39-
let b: Array1<f64> = random(2);
41+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
42+
let a: Array2<f64> = random_hpd_using(3, &mut rng).reversed_axes();
43+
let b: Array1<f64> = random_using(2, &mut rng);
4044
let _ = a.solveh_into(b);
4145
}
4246

4347
#[should_panic]
4448
#[test]
4549
fn factorizeh_solveh_t_shape_mismatch() {
46-
let a: Array2<f64> = random_hpd(3).reversed_axes();
47-
let b: Array1<f64> = random(2);
50+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
51+
let a: Array2<f64> = random_hpd_using(3, &mut rng).reversed_axes();
52+
let b: Array1<f64> = random_using(2, &mut rng);
4853
let f = a.factorizeh_into().unwrap();
4954
let _ = f.solveh_into(b);
5055
}
5156

5257
#[test]
5358
fn solveh_random_t() {
54-
let a: Array2<f64> = random_hpd(3).reversed_axes();
55-
let x: Array1<f64> = random(3);
59+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
60+
let a: Array2<f64> = random_hpd_using(3, &mut rng).reversed_axes();
61+
let x: Array1<f64> = random_using(3, &mut rng);
5662
let b = a.dot(&x);
5763
let y = a.solveh_into(b).unwrap();
5864
assert_close_l2!(&x, &y, 1e-7);

‎ndarray-linalg/tests/svd.rs

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -53,13 +53,15 @@ macro_rules! test_svd_impl {
5353
paste::item! {
5454
#[test]
5555
fn [<svd_ $type _ $test _ $n x $m>]() {
56-
let a = random(($n, $m));
56+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
57+
let a = random_using(($n, $m), &mut rng);
5758
$test::<$type>(&a);
5859
}
5960

6061
#[test]
6162
fn [<svd_ $type _ $test _ $n x $m _t>]() {
62-
let a = random(($n, $m).f());
63+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
64+
let a = random_using(($n, $m).f(), &mut rng);
6365
$test::<$type>(&a);
6466
}
6567
}

‎ndarray-linalg/tests/svddc.rs

Lines changed: 12 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -32,37 +32,43 @@ macro_rules! test_svd_impl {
3232
paste::item! {
3333
#[test]
3434
fn [<svddc_ $scalar _full_ $n x $m>]() {
35-
let a = random(($n, $m));
35+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
36+
let a = random_using(($n, $m), &mut rng);
3637
test::<$scalar>(&a, JobSvd::All);
3738
}
3839

3940
#[test]
4041
fn [<svddc_ $scalar _some_ $n x $m>]() {
41-
let a = random(($n, $m));
42+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
43+
let a = random_using(($n, $m), &mut rng);
4244
test::<$scalar>(&a, JobSvd::Some);
4345
}
4446

4547
#[test]
4648
fn [<svddc_ $scalar _none_ $n x $m>]() {
47-
let a = random(($n, $m));
49+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
50+
let a = random_using(($n, $m), &mut rng);
4851
test::<$scalar>(&a, JobSvd::None);
4952
}
5053

5154
#[test]
5255
fn [<svddc_ $scalar _full_ $n x $m _t>]() {
53-
let a = random(($n, $m).f());
56+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
57+
let a = random_using(($n, $m).f(), &mut rng);
5458
test::<$scalar>(&a, JobSvd::All);
5559
}
5660

5761
#[test]
5862
fn [<svddc_ $scalar _some_ $n x $m _t>]() {
59-
let a = random(($n, $m).f());
63+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
64+
let a = random_using(($n, $m).f(), &mut rng);
6065
test::<$scalar>(&a, JobSvd::Some);
6166
}
6267

6368
#[test]
6469
fn [<svddc_ $scalar _none_ $n x $m _t>]() {
65-
let a = random(($n, $m).f());
70+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
71+
let a = random_using(($n, $m).f(), &mut rng);
6672
test::<$scalar>(&a, JobSvd::None);
6773
}
6874
}

‎ndarray-linalg/tests/trace.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@ use ndarray_linalg::*;
33

44
#[test]
55
fn trace() {
6-
let a: Array2<f64> = random((3, 3));
6+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
7+
let a: Array2<f64> = random_using((3, 3), &mut rng);
78
assert_rclose!(a.trace().unwrap(), a[(0, 0)] + a[(1, 1)] + a[(2, 2)], 1e-7);
89
}

‎ndarray-linalg/tests/triangular.rs

Lines changed: 36 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -34,87 +34,99 @@ where
3434
#[test]
3535
fn triangular_1d_upper() {
3636
let n = 3;
37-
let b: Array1<f64> = random(n);
38-
let a: Array2<f64> = random((n, n)).into_triangular(UPLO::Upper);
37+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
38+
let b: Array1<f64> = random_using(n, &mut rng);
39+
let a: Array2<f64> = random_using((n, n), &mut rng).into_triangular(UPLO::Upper);
3940
test1d(UPLO::Upper, &a, &b, 1e-7);
4041
}
4142

4243
#[test]
4344
fn triangular_1d_lower() {
4445
let n = 3;
45-
let b: Array1<f64> = random(n);
46-
let a: Array2<f64> = random((n, n)).into_triangular(UPLO::Lower);
46+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
47+
let b: Array1<f64> = random_using(n, &mut rng);
48+
let a: Array2<f64> = random_using((n, n), &mut rng).into_triangular(UPLO::Lower);
4749
test1d(UPLO::Lower, &a, &b, 1e-7);
4850
}
4951

5052
#[test]
5153
fn triangular_1d_upper_t() {
5254
let n = 3;
53-
let b: Array1<f64> = random(n);
54-
let a: Array2<f64> = random((n, n).f()).into_triangular(UPLO::Upper);
55+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
56+
let b: Array1<f64> = random_using(n, &mut rng);
57+
let a: Array2<f64> = random_using((n, n).f(), &mut rng).into_triangular(UPLO::Upper);
5558
test1d(UPLO::Upper, &a, &b, 1e-7);
5659
}
5760

5861
#[test]
5962
fn triangular_1d_lower_t() {
6063
let n = 3;
61-
let b: Array1<f64> = random(n);
62-
let a: Array2<f64> = random((n, n).f()).into_triangular(UPLO::Lower);
64+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
65+
let b: Array1<f64> = random_using(n, &mut rng);
66+
let a: Array2<f64> = random_using((n, n).f(), &mut rng).into_triangular(UPLO::Lower);
6367
test1d(UPLO::Lower, &a, &b, 1e-7);
6468
}
6569

6670
#[test]
6771
fn triangular_2d_upper() {
68-
let b: Array2<f64> = random((3, 4));
69-
let a: Array2<f64> = random((3, 3)).into_triangular(UPLO::Upper);
72+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
73+
let b: Array2<f64> = random_using((3, 4), &mut rng);
74+
let a: Array2<f64> = random_using((3, 3), &mut rng).into_triangular(UPLO::Upper);
7075
test2d(UPLO::Upper, &a, &b, 1e-7);
7176
}
7277

7378
#[test]
7479
fn triangular_2d_lower() {
75-
let b: Array2<f64> = random((3, 4));
76-
let a: Array2<f64> = random((3, 3)).into_triangular(UPLO::Lower);
80+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
81+
let b: Array2<f64> = random_using((3, 4), &mut rng);
82+
let a: Array2<f64> = random_using((3, 3), &mut rng).into_triangular(UPLO::Lower);
7783
test2d(UPLO::Lower, &a, &b, 1e-7);
7884
}
7985

8086
#[test]
8187
fn triangular_2d_lower_t() {
82-
let b: Array2<f64> = random((3, 4));
83-
let a: Array2<f64> = random((3, 3).f()).into_triangular(UPLO::Lower);
88+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
89+
let b: Array2<f64> = random_using((3, 4), &mut rng);
90+
let a: Array2<f64> = random_using((3, 3).f(), &mut rng).into_triangular(UPLO::Lower);
8491
test2d(UPLO::Lower, &a, &b, 1e-7);
8592
}
8693

8794
#[test]
8895
fn triangular_2d_upper_t() {
89-
let b: Array2<f64> = random((3, 4));
90-
let a: Array2<f64> = random((3, 3).f()).into_triangular(UPLO::Upper);
96+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
97+
let b: Array2<f64> = random_using((3, 4), &mut rng);
98+
let a: Array2<f64> = random_using((3, 3).f(), &mut rng).into_triangular(UPLO::Upper);
9199
test2d(UPLO::Upper, &a, &b, 1e-7);
92100
}
93101

94102
#[test]
95103
fn triangular_2d_upper_bt() {
96-
let b: Array2<f64> = random((3, 4).f());
97-
let a: Array2<f64> = random((3, 3)).into_triangular(UPLO::Upper);
104+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
105+
let b: Array2<f64> = random_using((3, 4).f(), &mut rng);
106+
let a: Array2<f64> = random_using((3, 3), &mut rng).into_triangular(UPLO::Upper);
98107
test2d(UPLO::Upper, &a, &b, 1e-7);
99108
}
100109

101110
#[test]
102111
fn triangular_2d_lower_bt() {
103-
let b: Array2<f64> = random((3, 4).f());
104-
let a: Array2<f64> = random((3, 3)).into_triangular(UPLO::Lower);
112+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
113+
let b: Array2<f64> = random_using((3, 4).f(), &mut rng);
114+
let a: Array2<f64> = random_using((3, 3), &mut rng).into_triangular(UPLO::Lower);
105115
test2d(UPLO::Lower, &a, &b, 1e-7);
106116
}
107117

108118
#[test]
109119
fn triangular_2d_lower_t_bt() {
110-
let b: Array2<f64> = random((3, 4).f());
111-
let a: Array2<f64> = random((3, 3).f()).into_triangular(UPLO::Lower);
120+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
121+
let b: Array2<f64> = random_using((3, 4).f(), &mut rng);
122+
let a: Array2<f64> = random_using((3, 3).f(), &mut rng).into_triangular(UPLO::Lower);
112123
test2d(UPLO::Lower, &a, &b, 1e-7);
113124
}
114125

115126
#[test]
116127
fn triangular_2d_upper_t_bt() {
117-
let b: Array2<f64> = random((3, 4).f());
118-
let a: Array2<f64> = random((3, 3).f()).into_triangular(UPLO::Upper);
128+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
129+
let b: Array2<f64> = random_using((3, 4).f(), &mut rng);
130+
let a: Array2<f64> = random_using((3, 3).f(), &mut rng).into_triangular(UPLO::Upper);
119131
test2d(UPLO::Upper, &a, &b, 1e-7);
120132
}

‎ndarray-linalg/tests/tridiagonal.rs

Lines changed: 13 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,8 @@ fn tridiagonal_index() {
2828

2929
#[test]
3030
fn opnorm_tridiagonal() {
31-
let mut a: Array2<f64> = random((4, 4));
31+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
32+
let mut a: Array2<f64> = random_using((4, 4), &mut rng);
3233
a[[0, 2]] = 0.0;
3334
a[[0, 3]] = 0.0;
3435
a[[1, 3]] = 0.0;
@@ -129,10 +130,11 @@ fn solve_tridiagonal_c64() {
129130

130131
#[test]
131132
fn solve_tridiagonal_random() {
132-
let mut a: Array2<f64> = random((3, 3));
133+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
134+
let mut a: Array2<f64> = random_using((3, 3), &mut rng);
133135
a[[0, 2]] = 0.0;
134136
a[[2, 0]] = 0.0;
135-
let x: Array1<f64> = random(3);
137+
let x: Array1<f64> = random_using(3, &mut rng);
136138
let b1 = a.dot(&x);
137139
let b2 = b1.clone();
138140
let y1 = a.solve_tridiagonal_into(b1).unwrap();
@@ -143,10 +145,11 @@ fn solve_tridiagonal_random() {
143145

144146
#[test]
145147
fn solve_tridiagonal_random_t() {
146-
let mut a: Array2<f64> = random((3, 3));
148+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
149+
let mut a: Array2<f64> = random_using((3, 3), &mut rng);
147150
a[[0, 2]] = 0.0;
148151
a[[2, 0]] = 0.0;
149-
let x: Array1<f64> = random(3);
152+
let x: Array1<f64> = random_using(3, &mut rng);
150153
let at = a.t();
151154
let b1 = at.dot(&x);
152155
let b2 = b1.clone();
@@ -158,11 +161,12 @@ fn solve_tridiagonal_random_t() {
158161

159162
#[test]
160163
fn extract_tridiagonal_solve_random() {
161-
let mut a: Array2<f64> = random((3, 3));
164+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
165+
let mut a: Array2<f64> = random_using((3, 3), &mut rng);
162166
a[[0, 2]] = 0.0;
163167
a[[2, 0]] = 0.0;
164168
let tridiag = a.extract_tridiagonal().unwrap();
165-
let x: Array1<f64> = random(3);
169+
let x: Array1<f64> = random_using(3, &mut rng);
166170
let b1 = a.dot(&x);
167171
let b2 = b1.clone();
168172
let y1 = tridiag.solve_tridiagonal_into(b1).unwrap();
@@ -180,7 +184,8 @@ fn det_tridiagonal_f64() {
180184

181185
#[test]
182186
fn det_tridiagonal_random() {
183-
let mut a: Array2<f64> = random((3, 3));
187+
let mut rng = rand_pcg::Mcg128Xsl64::new(0xcafef00dd15ea5e5);
188+
let mut a: Array2<f64> = random_using((3, 3), &mut rng);
184189
a[[0, 2]] = 0.0;
185190
a[[2, 0]] = 0.0;
186191
assert_aclose!(a.det_tridiagonal().unwrap(), a.det().unwrap(), 1e-7);

0 commit comments

Comments
 (0)
Please sign in to comment.