diff --git a/benches/bench1.rs b/benches/bench1.rs index 13bbcb29a..c32cbefec 100644 --- a/benches/bench1.rs +++ b/benches/bench1.rs @@ -20,7 +20,7 @@ use test::black_box; #[bench] fn iter_sum_1d_regular(bench: &mut test::Bencher) { - let a = Array::::zeros(64 * 64); + let a = Array::::zeros([64 * 64]); let a = black_box(a); bench.iter(|| { let mut sum = 0; @@ -35,7 +35,7 @@ fn iter_sum_1d_regular(bench: &mut test::Bencher) fn iter_sum_1d_raw(bench: &mut test::Bencher) { // this is autovectorized to death (= great performance) - let a = Array::::zeros(64 * 64); + let a = Array::::zeros([64 * 64]); let a = black_box(a); bench.iter(|| { let mut sum = 0; @@ -49,7 +49,7 @@ fn iter_sum_1d_raw(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_regular(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); let a = black_box(a); bench.iter(|| { let mut sum = 0; @@ -63,7 +63,7 @@ fn iter_sum_2d_regular(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_by_row(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); let a = black_box(a); bench.iter(|| { let mut sum = 0; @@ -80,7 +80,7 @@ fn iter_sum_2d_by_row(bench: &mut test::Bencher) fn iter_sum_2d_raw(bench: &mut test::Bencher) { // this is autovectorized to death (= great performance) - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); let a = black_box(a); bench.iter(|| { let mut sum = 0; @@ -94,7 +94,7 @@ fn iter_sum_2d_raw(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_cutout(bench: &mut test::Bencher) { - let a = Array::::zeros((66, 66)); + let a = Array::::zeros([66, 66]); let av = a.slice(s![1..-1, 1..-1]); let a = black_box(av); bench.iter(|| { @@ -109,7 +109,7 @@ fn iter_sum_2d_cutout(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_cutout_by_row(bench: &mut test::Bencher) { - let a = Array::::zeros((66, 66)); + let a = Array::::zeros([66, 66]); let av = a.slice(s![1..-1, 1..-1]); let a = black_box(av); bench.iter(|| { @@ -126,7 +126,7 @@ fn iter_sum_2d_cutout_by_row(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_cutout_outer_iter(bench: &mut test::Bencher) { - let a = Array::::zeros((66, 66)); + let a = Array::::zeros([66, 66]); let av = a.slice(s![1..-1, 1..-1]); let a = black_box(av); bench.iter(|| { @@ -143,7 +143,7 @@ fn iter_sum_2d_cutout_outer_iter(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_transpose_regular(bench: &mut test::Bencher) { - let mut a = Array::::zeros((64, 64)); + let mut a = Array::::zeros([64, 64]); a.swap_axes(0, 1); let a = black_box(a); bench.iter(|| { @@ -158,7 +158,7 @@ fn iter_sum_2d_transpose_regular(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_transpose_by_row(bench: &mut test::Bencher) { - let mut a = Array::::zeros((64, 64)); + let mut a = Array::::zeros([64, 64]); a.swap_axes(0, 1); let a = black_box(a); bench.iter(|| { @@ -175,7 +175,7 @@ fn iter_sum_2d_transpose_by_row(bench: &mut test::Bencher) #[bench] fn sum_2d_regular(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); let a = black_box(a); bench.iter(|| { a.sum() @@ -185,7 +185,7 @@ fn sum_2d_regular(bench: &mut test::Bencher) #[bench] fn sum_2d_cutout(bench: &mut test::Bencher) { - let a = Array::::zeros((66, 66)); + let a = Array::::zeros([66, 66]); let av = a.slice(s![1..-1, 1..-1]); let a = black_box(av); bench.iter(|| { @@ -196,7 +196,7 @@ fn sum_2d_cutout(bench: &mut test::Bencher) #[bench] fn sum_2d_float(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); let a = black_box(a.view()); bench.iter(|| { a.sum() @@ -206,7 +206,7 @@ fn sum_2d_float(bench: &mut test::Bencher) #[bench] fn sum_2d_float_cutout(bench: &mut test::Bencher) { - let a = Array::::zeros((66, 66)); + let a = Array::::zeros([66, 66]); let av = a.slice(s![1..-1, 1..-1]); let a = black_box(av); bench.iter(|| { @@ -217,7 +217,7 @@ fn sum_2d_float_cutout(bench: &mut test::Bencher) #[bench] fn sum_2d_float_t_cutout(bench: &mut test::Bencher) { - let a = Array::::zeros((66, 66)); + let a = Array::::zeros([66, 66]); let av = a.slice(s![1..-1, 1..-1]).reversed_axes(); let a = black_box(av); bench.iter(|| { @@ -228,7 +228,7 @@ fn sum_2d_float_t_cutout(bench: &mut test::Bencher) #[bench] fn fold_sum_i32_2d_regular(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); bench.iter(|| { a.fold(0, |acc, &x| acc + x) }); @@ -237,7 +237,7 @@ fn fold_sum_i32_2d_regular(bench: &mut test::Bencher) #[bench] fn fold_sum_i32_2d_cutout(bench: &mut test::Bencher) { - let a = Array::::zeros((66, 66)); + let a = Array::::zeros([66, 66]); let av = a.slice(s![1..-1, 1..-1]); let a = black_box(av); bench.iter(|| { @@ -248,7 +248,7 @@ fn fold_sum_i32_2d_cutout(bench: &mut test::Bencher) #[bench] fn fold_sum_i32_2d_stride(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 128)); + let a = Array::::zeros([64, 128]); let av = a.slice(s![.., ..;2]); let a = black_box(av); bench.iter(|| { @@ -259,7 +259,7 @@ fn fold_sum_i32_2d_stride(bench: &mut test::Bencher) #[bench] fn fold_sum_i32_2d_transpose(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); let a = a.t(); bench.iter(|| { a.fold(0, |acc, &x| acc + x) @@ -269,7 +269,7 @@ fn fold_sum_i32_2d_transpose(bench: &mut test::Bencher) #[bench] fn fold_sum_i32_2d_cutout_transpose(bench: &mut test::Bencher) { - let a = Array::::zeros((66, 66)); + let a = Array::::zeros([66, 66]); let mut av = a.slice(s![1..-1, 1..-1]); av.swap_axes(0, 1); let a = black_box(av); @@ -283,8 +283,8 @@ const ADD2DSZ: usize = 64; #[bench] fn add_2d_regular(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ)); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ]); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); let bv = b.view(); bench.iter(|| { a += &bv; @@ -294,8 +294,8 @@ fn add_2d_regular(bench: &mut test::Bencher) #[bench] fn add_2d_zip(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ)); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ]); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); bench.iter(|| { Zip::from(&mut a).and(&b).apply(|a, &b| *a += b); }); @@ -304,8 +304,8 @@ fn add_2d_zip(bench: &mut test::Bencher) #[bench] fn add_2d_alloc(bench: &mut test::Bencher) { - let a = Array::::zeros((ADD2DSZ, ADD2DSZ)); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let a = Array::::zeros([ADD2DSZ, ADD2DSZ]); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); bench.iter(|| { &a + &b }); @@ -314,22 +314,21 @@ fn add_2d_alloc(bench: &mut test::Bencher) #[bench] fn add_2d_zip_alloc(bench: &mut test::Bencher) { - let a = Array::::zeros((ADD2DSZ, ADD2DSZ)); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); - bench.iter(|| { - unsafe { + let a = Array::::zeros([ADD2DSZ, ADD2DSZ]); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); + bench.iter(|| unsafe { let mut c = Array::uninitialized(a.dim()); azip!(a, b, mut c in { *c = a + b }); c } - }); + ); } #[bench] fn add_2d_assign_ops(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ)); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ]); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); let bv = b.view(); bench.iter(|| { let mut x = a.view_mut(); @@ -341,9 +340,9 @@ fn add_2d_assign_ops(bench: &mut test::Bencher) #[bench] fn add_2d_cutout(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ + 2, ADD2DSZ + 2)); + let mut a = Array::::zeros([ADD2DSZ + 2, ADD2DSZ + 2]); let mut acut = a.slice_mut(s![1..-1, 1..-1]); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); let bv = b.view(); bench.iter(|| { acut += &bv; @@ -353,9 +352,9 @@ fn add_2d_cutout(bench: &mut test::Bencher) #[bench] fn add_2d_zip_cutout(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ + 2, ADD2DSZ + 2)); + let mut a = Array::::zeros([ADD2DSZ + 2, ADD2DSZ + 2]); let mut acut = a.slice_mut(s![1..-1, 1..-1]); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); bench.iter(|| { Zip::from(&mut acut).and(&b).apply(|a, &b| *a += b); }); @@ -364,9 +363,9 @@ fn add_2d_zip_cutout(bench: &mut test::Bencher) #[bench] fn add_2d_cutouts_by_4(bench: &mut test::Bencher) { - let mut a = Array::::zeros((64 * 1, 64 * 1)); - let b = Array::::zeros((64 * 1, 64 * 1)); - let chunksz = (4, 4); + let mut a = Array::::zeros([64 * 1, 64 * 1]); + let b = Array::::zeros([64 * 1, 64 * 1]); + let chunksz = [4, 4]; bench.iter(|| { Zip::from(a.exact_chunks_mut(chunksz)) .and(b.exact_chunks(chunksz)) @@ -377,9 +376,9 @@ fn add_2d_cutouts_by_4(bench: &mut test::Bencher) #[bench] fn add_2d_cutouts_by_16(bench: &mut test::Bencher) { - let mut a = Array::::zeros((64 * 1, 64 * 1)); - let b = Array::::zeros((64 * 1, 64 * 1)); - let chunksz = (16, 16); + let mut a = Array::::zeros([64 * 1, 64 * 1]); + let b = Array::::zeros([64 * 1, 64 * 1]); + let chunksz = [16, 16]; bench.iter(|| { Zip::from(a.exact_chunks_mut(chunksz)) .and(b.exact_chunks(chunksz)) @@ -390,9 +389,9 @@ fn add_2d_cutouts_by_16(bench: &mut test::Bencher) #[bench] fn add_2d_cutouts_by_32(bench: &mut test::Bencher) { - let mut a = Array::::zeros((64 * 1, 64 * 1)); - let b = Array::::zeros((64 * 1, 64 * 1)); - let chunksz = (32, 32); + let mut a = Array::::zeros([64 * 1, 64 * 1]); + let b = Array::::zeros([64 * 1, 64 * 1]); + let chunksz = [32, 32]; bench.iter(|| { Zip::from(a.exact_chunks_mut(chunksz)) .and(b.exact_chunks(chunksz)) @@ -403,8 +402,8 @@ fn add_2d_cutouts_by_32(bench: &mut test::Bencher) #[bench] fn add_2d_broadcast_1_to_2(bench: &mut test::Bencher) { - let mut a = Array2::::zeros((ADD2DSZ, ADD2DSZ)); - let b = Array1::::zeros(ADD2DSZ); + let mut a = Array2::::zeros([ADD2DSZ, ADD2DSZ]); + let b = Array1::::zeros([ADD2DSZ]); let bv = b.view(); bench.iter(|| { a += &bv; @@ -414,8 +413,8 @@ fn add_2d_broadcast_1_to_2(bench: &mut test::Bencher) #[bench] fn add_2d_broadcast_0_to_2(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ)); - let b = Array::::zeros(()); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ]); + let b = Array::::zeros([]); let bv = b.view(); bench.iter(|| { a += &bv; @@ -424,7 +423,7 @@ fn add_2d_broadcast_0_to_2(bench: &mut test::Bencher) #[bench] fn scalar_toowned(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); bench.iter(|| { a.to_owned() }); @@ -432,7 +431,7 @@ fn scalar_toowned(bench: &mut test::Bencher) { #[bench] fn scalar_add_1(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); let n = 1.; bench.iter(|| { &a + n @@ -441,7 +440,7 @@ fn scalar_add_1(bench: &mut test::Bencher) { #[bench] fn scalar_add_2(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); let n = 1.; bench.iter(|| { n + &a @@ -450,7 +449,7 @@ fn scalar_add_2(bench: &mut test::Bencher) { #[bench] fn scalar_sub_1(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); let n = 1.; bench.iter(|| { &a - n @@ -459,19 +458,18 @@ fn scalar_sub_1(bench: &mut test::Bencher) { #[bench] fn scalar_sub_2(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); let n = 1.; bench.iter(|| { n - &a }); } - // This is for comparison with add_2d_broadcast_0_to_2 #[bench] fn add_2d_0_to_2_iadd_scalar(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ]); let n = black_box(0); bench.iter(|| { a += n; @@ -481,9 +479,9 @@ fn add_2d_0_to_2_iadd_scalar(bench: &mut test::Bencher) #[bench] fn add_2d_strided(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ * 2)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ * 2]); let mut a = a.slice_mut(s![.., ..;2]); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); let bv = b.view(); bench.iter(|| { a += &bv; @@ -513,13 +511,12 @@ fn add_2d_strided_dyn(bench: &mut test::Bencher) }); } - #[bench] fn add_2d_zip_strided(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ * 2)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ * 2]); let mut a = a.slice_mut(s![.., ..;2]); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); bench.iter(|| { Zip::from(&mut a).and(&b).apply(|a, &b| *a += b); }); @@ -528,9 +525,9 @@ fn add_2d_zip_strided(bench: &mut test::Bencher) #[bench] fn add_2d_one_transposed(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ]); a.swap_axes(0, 1); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); bench.iter(|| { a += &b; }); @@ -539,9 +536,9 @@ fn add_2d_one_transposed(bench: &mut test::Bencher) #[bench] fn add_2d_zip_one_transposed(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ]); a.swap_axes(0, 1); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); bench.iter(|| { Zip::from(&mut a).and(&b).apply(|a, &b| *a += b); }); @@ -550,9 +547,9 @@ fn add_2d_zip_one_transposed(bench: &mut test::Bencher) #[bench] fn add_2d_both_transposed(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ]); a.swap_axes(0, 1); - let mut b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut b = Array::::zeros([ADD2DSZ, ADD2DSZ]); b.swap_axes(0, 1); bench.iter(|| { a += &b; @@ -562,9 +559,9 @@ fn add_2d_both_transposed(bench: &mut test::Bencher) #[bench] fn add_2d_zip_both_transposed(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ]); a.swap_axes(0, 1); - let mut b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut b = Array::::zeros([ADD2DSZ, ADD2DSZ]); b.swap_axes(0, 1); bench.iter(|| { Zip::from(&mut a).and(&b).apply(|a, &b| *a += b); @@ -574,8 +571,8 @@ fn add_2d_zip_both_transposed(bench: &mut test::Bencher) #[bench] fn add_2d_f32_regular(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ)); - let b = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ]); + let b = Array::::zeros([ADD2DSZ, ADD2DSZ]); let bv = b.view(); bench.iter(|| { a += &bv; @@ -587,7 +584,7 @@ const ADD3DSZ: usize = 16; #[bench] fn add_3d_strided(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD3DSZ, ADD3DSZ, ADD3DSZ * 2)); + let mut a = Array::::zeros([ADD3DSZ, ADD3DSZ, ADD3DSZ * 2]); let mut a = a.slice_mut(s![.., .., ..;2]); let b = Array::::zeros(a.dim()); let bv = b.view(); @@ -608,13 +605,12 @@ fn add_3d_strided_dyn(bench: &mut test::Bencher) }); } - const ADD1D_SIZE: usize = 64 * 64; #[bench] fn add_1d_regular(bench: &mut test::Bencher) { - let mut a = Array::::zeros(ADD1D_SIZE); + let mut a = Array::::zeros([ADD1D_SIZE]); let b = Array::::zeros(a.dim()); bench.iter(|| { a += &b; @@ -624,7 +620,7 @@ fn add_1d_regular(bench: &mut test::Bencher) #[bench] fn add_1d_strided(bench: &mut test::Bencher) { - let mut a = Array::::zeros(ADD1D_SIZE * 2); + let mut a = Array::::zeros([ADD1D_SIZE * 2]); let mut av = a.slice_mut(s![..;2]); let b = Array::::zeros(av.dim()); bench.iter(|| { @@ -635,7 +631,7 @@ fn add_1d_strided(bench: &mut test::Bencher) #[bench] fn iadd_scalar_2d_regular(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ]); bench.iter(|| { a += 1.; }); @@ -644,7 +640,7 @@ fn iadd_scalar_2d_regular(bench: &mut test::Bencher) #[bench] fn iadd_scalar_2d_strided(bench: &mut test::Bencher) { - let mut a = Array::::zeros((ADD2DSZ, ADD2DSZ * 2)); + let mut a = Array::::zeros([ADD2DSZ, ADD2DSZ * 2]); let mut a = a.slice_mut(s![.., ..;2]); bench.iter(|| { a += 1.; @@ -673,8 +669,8 @@ fn iadd_scalar_2d_strided_dyn(bench: &mut test::Bencher) #[bench] fn scaled_add_2d_f32_regular(bench: &mut test::Bencher) { - let mut av = Array::::zeros((ADD2DSZ, ADD2DSZ)); - let bv = Array::::zeros((ADD2DSZ, ADD2DSZ)); + let mut av = Array::::zeros([ADD2DSZ, ADD2DSZ]); + let bv = Array::::zeros([ADD2DSZ, ADD2DSZ]); let scalar = 3.1415926535; bench.iter(|| { av.scaled_add(scalar, &bv); @@ -684,7 +680,7 @@ fn scaled_add_2d_f32_regular(bench: &mut test::Bencher) #[bench] fn assign_scalar_2d_corder(bench: &mut test::Bencher) { - let a = Array::zeros((ADD2DSZ, ADD2DSZ)); + let a = Array::zeros([ADD2DSZ, ADD2DSZ]); let mut a = black_box(a); let s = 3.; bench.iter(move || a.fill(s)) @@ -693,7 +689,7 @@ fn assign_scalar_2d_corder(bench: &mut test::Bencher) #[bench] fn assign_scalar_2d_cutout(bench: &mut test::Bencher) { - let mut a = Array::zeros((66, 66)); + let mut a = Array::zeros([66, 66]); let a = a.slice_mut(s![1..-1, 1..-1]); let mut a = black_box(a); let s = 3.; @@ -703,7 +699,7 @@ fn assign_scalar_2d_cutout(bench: &mut test::Bencher) #[bench] fn assign_scalar_2d_forder(bench: &mut test::Bencher) { - let mut a = Array::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::zeros([ADD2DSZ, ADD2DSZ]); a.swap_axes(0, 1); let mut a = black_box(a); let s = 3.; @@ -713,7 +709,7 @@ fn assign_scalar_2d_forder(bench: &mut test::Bencher) #[bench] fn assign_zero_2d_corder(bench: &mut test::Bencher) { - let a = Array::zeros((ADD2DSZ, ADD2DSZ)); + let a = Array::zeros([ADD2DSZ, ADD2DSZ]); let mut a = black_box(a); bench.iter(|| a.fill(0.)) } @@ -721,7 +717,7 @@ fn assign_zero_2d_corder(bench: &mut test::Bencher) #[bench] fn assign_zero_2d_cutout(bench: &mut test::Bencher) { - let mut a = Array::zeros((66, 66)); + let mut a = Array::zeros([66, 66]); let a = a.slice_mut(s![1..-1, 1..-1]); let mut a = black_box(a); bench.iter(|| a.fill(0.)) @@ -730,7 +726,7 @@ fn assign_zero_2d_cutout(bench: &mut test::Bencher) #[bench] fn assign_zero_2d_forder(bench: &mut test::Bencher) { - let mut a = Array::zeros((ADD2DSZ, ADD2DSZ)); + let mut a = Array::zeros([ADD2DSZ, ADD2DSZ]); a.swap_axes(0, 1); let mut a = black_box(a); bench.iter(|| a.fill(0.)) @@ -739,24 +735,36 @@ fn assign_zero_2d_forder(bench: &mut test::Bencher) #[bench] fn bench_iter_diag(bench: &mut test::Bencher) { - let a = Array::::zeros((1024, 1024)); - bench.iter(|| for elt in a.diag() { black_box(elt); }) + let a = Array::::zeros([1024, 1024]); + bench.iter(|| { + for elt in a.diag() { + black_box(elt); + } + }) } #[bench] fn bench_row_iter(bench: &mut test::Bencher) { - let a = Array::::zeros((1024, 1024)); + let a = Array::::zeros([1024, 1024]); let it = a.row(17); - bench.iter(|| for elt in it.clone() { black_box(elt); }) + bench.iter(|| { + for elt in it.clone() { + black_box(elt); + } + }) } #[bench] fn bench_col_iter(bench: &mut test::Bencher) { - let a = Array::::zeros((1024, 1024)); + let a = Array::::zeros([1024, 1024]); let it = a.column(17); - bench.iter(|| for elt in it.clone() { black_box(elt); }) + bench.iter(|| { + for elt in it.clone() { + black_box(elt); + } + }) } macro_rules! mat_mul { @@ -768,8 +776,8 @@ macro_rules! mat_mul { #[bench] fn $name(bench: &mut Bencher) { - let a = Array::<$ty, _>::zeros(($m, $n)); - let b = Array::<$ty, _>::zeros(($n, $k)); + let a = Array::<$ty, _>::zeros([$m, $n]); + let b = Array::<$ty, _>::zeros([$n, $k]); let a = black_box(a.view()); let b = black_box(b.view()); bench.iter(|| a.dot(&b)); @@ -779,7 +787,7 @@ macro_rules! mat_mul { } } -mat_mul!{mat_mul_f32, f32, +mat_mul! {mat_mul_f32, f32, (m004, 4, 4, 4) (m007, 7, 7, 7) (m008, 8, 8, 8) @@ -793,7 +801,7 @@ mat_mul!{mat_mul_f32, f32, (mix10000, 128, 10000, 128) } -mat_mul!{mat_mul_f64, f64, +mat_mul! {mat_mul_f64, f64, (m004, 4, 4, 4) (m007, 7, 7, 7) (m008, 8, 8, 8) @@ -807,7 +815,7 @@ mat_mul!{mat_mul_f64, f64, (mix10000, 128, 10000, 128) } -mat_mul!{mat_mul_i32, i32, +mat_mul! {mat_mul_i32, i32, (m004, 4, 4, 4) (m007, 7, 7, 7) (m008, 8, 8, 8) @@ -821,27 +829,25 @@ mat_mul!{mat_mul_i32, i32, #[bench] fn create_iter_4d(bench: &mut test::Bencher) { - let mut a = Array::from_elem((4, 5, 3, 2), 1.0); + let mut a = Array::from_elem([4, 5, 3, 2], 1.0); a.swap_axes(0, 1); a.swap_axes(2, 1); let v = black_box(a.view()); - bench.iter(|| { - v.into_iter() - }); + bench.iter(|| v.into_iter()); } #[bench] fn bench_to_owned_n(bench: &mut test::Bencher) { - let a = Array::::zeros((32, 32)); + let a = Array::::zeros([32, 32]); bench.iter(|| a.to_owned()); } #[bench] fn bench_to_owned_t(bench: &mut test::Bencher) { - let mut a = Array::::zeros((32, 32)); + let mut a = Array::::zeros([32, 32]); a.swap_axes(0, 1); bench.iter(|| a.to_owned()); } @@ -849,101 +855,98 @@ fn bench_to_owned_t(bench: &mut test::Bencher) #[bench] fn bench_to_owned_strided(bench: &mut test::Bencher) { - let a = Array::::zeros((32, 64)); + let a = Array::::zeros([32, 64]); let a = a.slice(s![.., ..;2]); bench.iter(|| a.to_owned()); } #[bench] fn equality_i32(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); - let b = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); + let b = Array::::zeros([64, 64]); bench.iter(|| a == b); } #[bench] fn equality_f32(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); - let b = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); + let b = Array::::zeros([64, 64]); bench.iter(|| a == b); } #[bench] fn equality_f32_mixorder(bench: &mut test::Bencher) { - let a = Array::::zeros((64, 64)); - let b = Array::::zeros((64, 64).f()); + let a = Array::::zeros([64, 64]); + let b = Array::::zeros([64, 64].f()); bench.iter(|| a == b); } #[bench] fn dot_f32_16(bench: &mut test::Bencher) { - let a = Array::::zeros(16); - let b = Array::::zeros(16); + let a = Array::::zeros([16]); + let b = Array::::zeros([16]); bench.iter(|| a.dot(&b)); } #[bench] fn dot_f32_20(bench: &mut test::Bencher) { - let a = Array::::zeros(20); - let b = Array::::zeros(20); + let a = Array::::zeros([20]); + let b = Array::::zeros([20]); bench.iter(|| a.dot(&b)); } #[bench] fn dot_f32_32(bench: &mut test::Bencher) { - let a = Array::::zeros(32); - let b = Array::::zeros(32); + let a = Array::::zeros([32]); + let b = Array::::zeros([32]); bench.iter(|| a.dot(&b)); } #[bench] fn dot_f32_256(bench: &mut test::Bencher) { - let a = Array::::zeros(256); - let b = Array::::zeros(256); + let a = Array::::zeros([256]); + let b = Array::::zeros([256]); bench.iter(|| a.dot(&b)); } #[bench] fn dot_f32_1024(bench: &mut test::Bencher) { - let av = Array::::zeros(1024); - let bv = Array::::zeros(1024); - bench.iter(|| { - av.dot(&bv) - }); + let av = Array::::zeros([1024]); + let bv = Array::::zeros([1024]); + bench.iter(|| av.dot(&bv)); } #[bench] fn dot_f32_10e6(bench: &mut test::Bencher) { let n = 1_000_000; - let av = Array::::zeros(n); - let bv = Array::::zeros(n); - bench.iter(|| { - av.dot(&bv) - }); + let av = Array::::zeros([n]); + let bv = Array::::zeros([n]); + bench.iter(|| av.dot(&bv)); } #[bench] -fn dot_extended(bench: &mut test::Bencher) { +fn dot_extended(bench: &mut test::Bencher) +{ let m = 10; let n = 33; let k = 10; - let av = Array::::zeros((m, n)); - let bv = Array::::zeros((n, k)); - let mut res = Array::::zeros((m, k)); + let av = Array::::zeros([m, n]); + let bv = Array::::zeros([n, k]); + let mut res = Array::::zeros([m, k]); // make a manual simple matrix multiply to test bench.iter(|| { for i in 0..m { for j in 0..k { unsafe { - *res.uget_mut((i, j)) = av.row(i).dot(&bv.column(j)); + *res.uget_mut([i, j]) = av.row(i).dot(&bv.column(j)); } } } @@ -952,31 +955,38 @@ fn dot_extended(bench: &mut test::Bencher) { const MEAN_SUM_N: usize = 127; -fn range_mat(m: Ix, n: Ix) -> Array2 { +fn range_mat(m: Ix, n: Ix) -> Array2 +{ assert!(m * n != 0); - Array::linspace(0., (m * n - 1) as f32, m * n).into_shape((m, n)).unwrap() + Array::linspace(0., (m * n - 1) as f32, m * n) + .into_shape([m, n]) + .unwrap() } #[bench] -fn mean_axis0(bench: &mut test::Bencher) { +fn mean_axis0(bench: &mut test::Bencher) +{ let a = range_mat(MEAN_SUM_N, MEAN_SUM_N); bench.iter(|| a.mean_axis(Axis(0))); } #[bench] -fn mean_axis1(bench: &mut test::Bencher) { +fn mean_axis1(bench: &mut test::Bencher) +{ let a = range_mat(MEAN_SUM_N, MEAN_SUM_N); bench.iter(|| a.mean_axis(Axis(1))); } #[bench] -fn sum_axis0(bench: &mut test::Bencher) { +fn sum_axis0(bench: &mut test::Bencher) +{ let a = range_mat(MEAN_SUM_N, MEAN_SUM_N); bench.iter(|| a.sum_axis(Axis(0))); } #[bench] -fn sum_axis1(bench: &mut test::Bencher) { +fn sum_axis1(bench: &mut test::Bencher) +{ let a = range_mat(MEAN_SUM_N, MEAN_SUM_N); bench.iter(|| a.sum_axis(Axis(1))); } diff --git a/benches/chunks.rs b/benches/chunks.rs index 61d68d2bb..9ca6e5109 100644 --- a/benches/chunks.rs +++ b/benches/chunks.rs @@ -10,8 +10,8 @@ use ndarray::NdProducer; #[bench] fn chunk2x2_iter_sum(bench: &mut Bencher) { - let a = Array::::zeros((256, 256)); - let chunksz = (2, 2); + let a = Array::::zeros([256, 256]); + let chunksz = [2, 2]; let mut sum = Array::zeros(a.exact_chunks(chunksz).raw_dim()); bench.iter(|| { azip!(ref a (a.exact_chunks(chunksz)), mut sum in { @@ -23,8 +23,8 @@ fn chunk2x2_iter_sum(bench: &mut Bencher) #[bench] fn chunk2x2_sum(bench: &mut Bencher) { - let a = Array::::zeros((256, 256)); - let chunksz = (2, 2); + let a = Array::::zeros([256, 256]); + let chunksz = [2, 2]; let mut sum = Array::zeros(a.exact_chunks(chunksz).raw_dim()); bench.iter(|| { azip!(ref a (a.exact_chunks(chunksz)), mut sum in { @@ -36,11 +36,11 @@ fn chunk2x2_sum(bench: &mut Bencher) #[bench] fn chunk2x2_sum_get1(bench: &mut Bencher) { - let a = Array::::zeros((256, 256)); - let chunksz = (2, 2); + let a = Array::::zeros([256, 256]); + let chunksz = [2, 2]; let mut sum = Array::::zeros(a.exact_chunks(chunksz).raw_dim()); bench.iter(|| { - let (m, n) = a.dim(); + let [m, n] = a.dim(); for i in 0..m { for j in 0..n { sum[[i/2, j/2]] += a[[i, j]]; @@ -52,11 +52,11 @@ fn chunk2x2_sum_get1(bench: &mut Bencher) #[bench] fn chunk2x2_sum_uget1(bench: &mut Bencher) { - let a = Array::::zeros((256, 256)); - let chunksz = (2, 2); + let a = Array::::zeros([256, 256]); + let chunksz = [2, 2]; let mut sum = Array::::zeros(a.exact_chunks(chunksz).raw_dim()); bench.iter(|| { - let (m, n) = a.dim(); + let [m, n] = a.dim(); for i in 0..m { for j in 0..n { unsafe { @@ -70,11 +70,11 @@ fn chunk2x2_sum_uget1(bench: &mut Bencher) #[bench] fn chunk2x2_sum_get2(bench: &mut Bencher) { - let a = Array::::zeros((256, 256)); - let chunksz = (2, 2); + let a = Array::::zeros([256, 256]); + let chunksz = [2, 2]; let mut sum = Array::::zeros(a.exact_chunks(chunksz).raw_dim()); bench.iter(|| { - let (m, n) = sum.dim(); + let [m, n] = sum.dim(); for i in 0..m { for j in 0..n { sum[[i, j]] += a[[i*2 + 0, j*2 + 0]]; diff --git a/benches/construct.rs b/benches/construct.rs index 6909da5e6..5a3abb66e 100644 --- a/benches/construct.rs +++ b/benches/construct.rs @@ -9,21 +9,21 @@ use ndarray::prelude::*; #[bench] fn default_f64(bench: &mut Bencher) { bench.iter(|| { - Array::::default((128, 128)) + Array::::default([128, 128]) }) } #[bench] fn zeros_f64(bench: &mut Bencher) { bench.iter(|| { - Array::::zeros((128, 128)) + Array::::zeros([128, 128]) }) } #[bench] fn map_regular(bench: &mut test::Bencher) { - let a = Array::linspace(0., 127., 128).into_shape((8, 16)).unwrap(); + let a = Array::linspace(0., 127., 128).into_shape([8, 16]).unwrap(); bench.iter(|| { a.map(|&x| 2. * x) }); @@ -33,7 +33,7 @@ fn map_regular(bench: &mut test::Bencher) #[bench] fn map_stride(bench: &mut test::Bencher) { - let a = Array::linspace(0., 127., 256).into_shape((8, 32)).unwrap(); + let a = Array::linspace(0., 127., 256).into_shape([8, 32]).unwrap(); let av = a.slice(s![.., ..;2]); bench.iter(|| { av.map(|&x| 2. * x) diff --git a/benches/gemv.rs b/benches/gemv.rs index 2cdb7cb2e..e45138306 100644 --- a/benches/gemv.rs +++ b/benches/gemv.rs @@ -10,10 +10,10 @@ use ndarray::linalg::general_mat_vec_mul; #[bench] fn gemv_64_64c(bench: &mut Bencher) { - let a = Array::zeros((64, 64)); - let (m, n) = a.dim(); - let x = Array::zeros(n); - let mut y = Array::zeros(m); + let a = Array::zeros([64, 64]); + let [m, n] = a.dim(); + let x = Array::zeros([n]); + let mut y = Array::zeros([m]); bench.iter(|| { general_mat_vec_mul(1.0, &a, &x, 1.0, &mut y); }); @@ -21,10 +21,10 @@ fn gemv_64_64c(bench: &mut Bencher) { #[bench] fn gemv_64_64f(bench: &mut Bencher) { - let a = Array::zeros((64, 64).f()); - let (m, n) = a.dim(); - let x = Array::zeros(n); - let mut y = Array::zeros(m); + let a = Array::zeros([64, 64].f()); + let [m, n] = a.dim(); + let x = Array::zeros([n]); + let mut y = Array::zeros([m]); bench.iter(|| { general_mat_vec_mul(1.0, &a, &x, 1.0, &mut y); }); @@ -32,10 +32,10 @@ fn gemv_64_64f(bench: &mut Bencher) { #[bench] fn gemv_64_32(bench: &mut Bencher) { - let a = Array::zeros((64, 32)); - let (m, n) = a.dim(); - let x = Array::zeros(n); - let mut y = Array::zeros(m); + let a = Array::zeros([64, 32]); + let [m, n] = a.dim(); + let x = Array::zeros([n]); + let mut y = Array::zeros([m]); bench.iter(|| { general_mat_vec_mul(1.0, &a, &x, 1.0, &mut y); }); diff --git a/benches/higher-order.rs b/benches/higher-order.rs index 22886e4dc..fdd1e791a 100644 --- a/benches/higher-order.rs +++ b/benches/higher-order.rs @@ -15,7 +15,7 @@ const Y: usize = 16; #[bench] fn map_regular(bench: &mut Bencher) { - let a = Array::linspace(0., 127., N).into_shape((X, Y)).unwrap(); + let a = Array::linspace(0., 127., N).into_shape([X, Y]).unwrap(); bench.iter(|| { a.map(|&x| 2. * x) }); diff --git a/benches/iter.rs b/benches/iter.rs index a30c640da..8ef8eabad 100644 --- a/benches/iter.rs +++ b/benches/iter.rs @@ -14,7 +14,7 @@ use ndarray::Slice; #[bench] fn iter_sum_2d_regular(bench: &mut Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); bench.iter(|| { a.iter().fold(0, |acc, &x| acc + x) }); @@ -23,7 +23,7 @@ fn iter_sum_2d_regular(bench: &mut Bencher) #[bench] fn iter_sum_2d_cutout(bench: &mut Bencher) { - let a = Array::::zeros((66, 66)); + let a = Array::::zeros([66, 66]); let av = a.slice(s![1..-1, 1..-1]); let a = av; bench.iter(|| { @@ -34,7 +34,7 @@ fn iter_sum_2d_cutout(bench: &mut Bencher) #[bench] fn iter_all_2d_cutout(bench: &mut Bencher) { - let a = Array::::zeros((66, 66)); + let a = Array::::zeros([66, 66]); let av = a.slice(s![1..-1, 1..-1]); let a = av; bench.iter(|| { @@ -45,7 +45,7 @@ fn iter_all_2d_cutout(bench: &mut Bencher) #[bench] fn iter_sum_2d_transpose(bench: &mut Bencher) { - let a = Array::::zeros((66, 66)); + let a = Array::::zeros([66, 66]); let a = a.t(); bench.iter(|| { a.iter().fold(0, |acc, &x| acc + x) @@ -55,7 +55,7 @@ fn iter_sum_2d_transpose(bench: &mut Bencher) #[bench] fn iter_filter_sum_2d_u32(bench: &mut Bencher) { - let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap(); + let a = Array::linspace(0., 1., 256).into_shape([16, 16]).unwrap(); let b = a.mapv(|x| (x * 100.) as u32); bench.iter(|| { b.iter().filter(|&&x| x < 75).fold(0, |acc, &x| acc + x) @@ -65,7 +65,7 @@ fn iter_filter_sum_2d_u32(bench: &mut Bencher) #[bench] fn iter_filter_sum_2d_f32(bench: &mut Bencher) { - let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap(); + let a = Array::linspace(0., 1., 256).into_shape([16, 16]).unwrap(); let b = a * 100.; bench.iter(|| { b.iter().filter(|&&x| x < 75.).fold(0., |acc, &x| acc + x) @@ -75,7 +75,7 @@ fn iter_filter_sum_2d_f32(bench: &mut Bencher) #[bench] fn iter_filter_sum_2d_stride_u32(bench: &mut Bencher) { - let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap(); + let a = Array::linspace(0., 1., 256).into_shape([16, 16]).unwrap(); let b = a.mapv(|x| (x * 100.) as u32); let b = b.slice(s![.., ..;2]); bench.iter(|| { @@ -86,7 +86,7 @@ fn iter_filter_sum_2d_stride_u32(bench: &mut Bencher) #[bench] fn iter_filter_sum_2d_stride_f32(bench: &mut Bencher) { - let a = Array::linspace(0., 1., 256).into_shape((16, 16)).unwrap(); + let a = Array::linspace(0., 1., 256).into_shape([16, 16]).unwrap(); let b = a * 100.; let b = b.slice(s![.., ..;2]); bench.iter(|| { @@ -235,8 +235,8 @@ const I2DSZ: usize = 64; #[bench] fn indexed_iter_1d_ix1(bench: &mut Bencher) { - let mut a = Array::::zeros(I2DSZ * I2DSZ); - for (i, elt) in a.indexed_iter_mut() { + let mut a = Array::::zeros([I2DSZ * I2DSZ]); + for ([i], elt) in a.indexed_iter_mut() { *elt = i as _; } @@ -250,8 +250,8 @@ fn indexed_iter_1d_ix1(bench: &mut Bencher) { #[bench] fn indexed_zip_1d_ix1(bench: &mut Bencher) { - let mut a = Array::::zeros(I2DSZ * I2DSZ); - for (i, elt) in a.indexed_iter_mut() { + let mut a = Array::::zeros([I2DSZ * I2DSZ]); + for ([i], elt) in a.indexed_iter_mut() { *elt = i as _; } @@ -266,8 +266,8 @@ fn indexed_zip_1d_ix1(bench: &mut Bencher) { #[bench] fn indexed_iter_2d_ix2(bench: &mut Bencher) { - let mut a = Array::::zeros((I2DSZ, I2DSZ)); - for ((i, j), elt) in a.indexed_iter_mut() { + let mut a = Array::::zeros([I2DSZ, I2DSZ]); + for ([i, j], elt) in a.indexed_iter_mut() { *elt = (i + 100 * j) as _; } @@ -280,8 +280,8 @@ fn indexed_iter_2d_ix2(bench: &mut Bencher) { } #[bench] fn indexed_zip_2d_ix2(bench: &mut Bencher) { - let mut a = Array::::zeros((I2DSZ, I2DSZ)); - for ((i, j), elt) in a.indexed_iter_mut() { + let mut a = Array::::zeros([I2DSZ, I2DSZ]); + for ([i, j], elt) in a.indexed_iter_mut() { *elt = (i + 100 * j) as _; } @@ -298,8 +298,8 @@ fn indexed_zip_2d_ix2(bench: &mut Bencher) { #[bench] fn indexed_iter_3d_ix3(bench: &mut Bencher) { - let mut a = Array::::zeros((ISZ, ISZ, ISZ)); - for ((i, j, k), elt) in a.indexed_iter_mut() { + let mut a = Array::::zeros([ISZ, ISZ, ISZ]); + for ([i, j, k], elt) in a.indexed_iter_mut() { *elt = (i + 100 * j + 10000 * k) as _; } @@ -313,8 +313,8 @@ fn indexed_iter_3d_ix3(bench: &mut Bencher) { #[bench] fn indexed_zip_3d_ix3(bench: &mut Bencher) { - let mut a = Array::::zeros((ISZ, ISZ, ISZ)); - for ((i, j, k), elt) in a.indexed_iter_mut() { + let mut a = Array::::zeros([ISZ, ISZ, ISZ]); + for ([i, j, k], elt) in a.indexed_iter_mut() { *elt = (i + 100 * j + 10000 * k) as _; } @@ -329,8 +329,8 @@ fn indexed_zip_3d_ix3(bench: &mut Bencher) { #[bench] fn indexed_iter_3d_dyn(bench: &mut Bencher) { - let mut a = Array::::zeros((ISZ, ISZ, ISZ)); - for ((i, j, k), elt) in a.indexed_iter_mut() { + let mut a = Array::::zeros([ISZ, ISZ, ISZ]); + for ([i, j, k], elt) in a.indexed_iter_mut() { *elt = (i + 100 * j + 10000 * k) as _; } let a = a.into_shape(&[ISZ; 3][..]).unwrap(); @@ -346,7 +346,7 @@ fn indexed_iter_3d_dyn(bench: &mut Bencher) { #[bench] fn iter_sum_1d_strided_fold(bench: &mut Bencher) { - let mut a = Array::::ones(10240); + let mut a = Array::::ones([10240]); a.slice_axis_inplace(Axis(0), Slice::new(0, None, 2)); bench.iter(|| { a.iter().fold(0, |acc, &x| acc + x) @@ -356,7 +356,7 @@ fn iter_sum_1d_strided_fold(bench: &mut Bencher) #[bench] fn iter_sum_1d_strided_rfold(bench: &mut Bencher) { - let mut a = Array::::ones(10240); + let mut a = Array::::ones([10240]); a.slice_axis_inplace(Axis(0), Slice::new(0, None, 2)); bench.iter(|| { a.iter().rfold(0, |acc, &x| acc + x) @@ -367,7 +367,7 @@ fn iter_sum_1d_strided_rfold(bench: &mut Bencher) #[bench] fn iter_axis_iter_sum(bench: &mut Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); bench.iter(|| { a.axis_iter(Axis(0)).map(|plane| plane.sum()).sum::() }); @@ -376,7 +376,7 @@ fn iter_axis_iter_sum(bench: &mut Bencher) #[bench] fn iter_axis_chunks_1_iter_sum(bench: &mut Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); bench.iter(|| { a.axis_chunks_iter(Axis(0), 1).map(|plane| plane.sum()).sum::() }); @@ -385,7 +385,7 @@ fn iter_axis_chunks_1_iter_sum(bench: &mut Bencher) #[bench] fn iter_axis_chunks_5_iter_sum(bench: &mut Bencher) { - let a = Array::::zeros((64, 64)); + let a = Array::::zeros([64, 64]); bench.iter(|| { a.axis_chunks_iter(Axis(0), 5).map(|plane| plane.sum()).sum::() }); diff --git a/benches/par_rayon.rs b/benches/par_rayon.rs index e207a65aa..5e768d838 100644 --- a/benches/par_rayon.rs +++ b/benches/par_rayon.rs @@ -29,7 +29,7 @@ fn set_threads() { #[bench] fn map_exp_regular(bench: &mut Bencher) { - let mut a = Array2::::zeros((EXP_N, EXP_N)); + let mut a = Array2::::zeros([EXP_N, EXP_N]); a.swap_axes(0, 1); bench.iter(|| { a.mapv_inplace(|x| x.exp()); @@ -40,7 +40,7 @@ fn map_exp_regular(bench: &mut Bencher) fn rayon_exp_regular(bench: &mut Bencher) { set_threads(); - let mut a = Array2::::zeros((EXP_N, EXP_N)); + let mut a = Array2::::zeros([EXP_N, EXP_N]); a.swap_axes(0, 1); bench.iter(|| { a.view_mut().into_par_iter().for_each(|x| *x = x.exp()); @@ -58,7 +58,7 @@ fn fastexp(x: f64) -> f64 { #[bench] fn map_fastexp_regular(bench: &mut Bencher) { - let mut a = Array2::::zeros((FASTEXP, FASTEXP)); + let mut a = Array2::::zeros([FASTEXP, FASTEXP]); bench.iter(|| { a.mapv_inplace(|x| fastexp(x)) }); @@ -68,7 +68,7 @@ fn map_fastexp_regular(bench: &mut Bencher) fn rayon_fastexp_regular(bench: &mut Bencher) { set_threads(); - let mut a = Array2::::zeros((FASTEXP, FASTEXP)); + let mut a = Array2::::zeros([FASTEXP, FASTEXP]); bench.iter(|| { a.view_mut().into_par_iter().for_each(|x| *x = fastexp(*x)); }); @@ -77,7 +77,7 @@ fn rayon_fastexp_regular(bench: &mut Bencher) #[bench] fn map_fastexp_cut(bench: &mut Bencher) { - let mut a = Array2::::zeros((FASTEXP, FASTEXP)); + let mut a = Array2::::zeros([FASTEXP, FASTEXP]); let mut a = a.slice_mut(s![.., ..-1]); bench.iter(|| { a.mapv_inplace(|x| fastexp(x)) @@ -88,7 +88,7 @@ fn map_fastexp_cut(bench: &mut Bencher) fn rayon_fastexp_cut(bench: &mut Bencher) { set_threads(); - let mut a = Array2::::zeros((FASTEXP, FASTEXP)); + let mut a = Array2::::zeros([FASTEXP, FASTEXP]); let mut a = a.slice_mut(s![.., ..-1]); bench.iter(|| { a.view_mut().into_par_iter().for_each(|x| *x = fastexp(*x)); @@ -98,7 +98,7 @@ fn rayon_fastexp_cut(bench: &mut Bencher) #[bench] fn map_fastexp_by_axis(bench: &mut Bencher) { - let mut a = Array2::::zeros((FASTEXP, FASTEXP)); + let mut a = Array2::::zeros([FASTEXP, FASTEXP]); bench.iter(|| { for mut sheet in a.axis_iter_mut(Axis(0)) { sheet.mapv_inplace(fastexp) @@ -110,7 +110,7 @@ fn map_fastexp_by_axis(bench: &mut Bencher) fn rayon_fastexp_by_axis(bench: &mut Bencher) { set_threads(); - let mut a = Array2::::zeros((FASTEXP, FASTEXP)); + let mut a = Array2::::zeros([FASTEXP, FASTEXP]); bench.iter(|| { a.axis_iter_mut(Axis(0)).into_par_iter() .for_each(|mut sheet| sheet.mapv_inplace(fastexp)); @@ -121,7 +121,7 @@ fn rayon_fastexp_by_axis(bench: &mut Bencher) fn rayon_fastexp_zip(bench: &mut Bencher) { set_threads(); - let mut a = Array2::::zeros((FASTEXP, FASTEXP)); + let mut a = Array2::::zeros([FASTEXP, FASTEXP]); bench.iter(|| { Zip::from(&mut a).into_par_iter().for_each(|(elt, )| *elt = fastexp(*elt)); }); @@ -130,10 +130,10 @@ fn rayon_fastexp_zip(bench: &mut Bencher) #[bench] fn add(bench: &mut Bencher) { - let mut a = Array2::::zeros((ADDN, ADDN)); - let b = Array2::::zeros((ADDN, ADDN)); - let c = Array2::::zeros((ADDN, ADDN)); - let d = Array2::::zeros((ADDN, ADDN)); + let mut a = Array2::::zeros([ADDN, ADDN]); + let b = Array2::::zeros([ADDN, ADDN]); + let c = Array2::::zeros([ADDN, ADDN]); + let d = Array2::::zeros([ADDN, ADDN]); bench.iter(|| { azip!(mut a, b, c, d in { *a += b.exp() + c.exp() + d.exp(); @@ -145,10 +145,10 @@ fn add(bench: &mut Bencher) fn rayon_add(bench: &mut Bencher) { set_threads(); - let mut a = Array2::::zeros((ADDN, ADDN)); - let b = Array2::::zeros((ADDN, ADDN)); - let c = Array2::::zeros((ADDN, ADDN)); - let d = Array2::::zeros((ADDN, ADDN)); + let mut a = Array2::::zeros([ADDN, ADDN]); + let b = Array2::::zeros([ADDN, ADDN]); + let c = Array2::::zeros([ADDN, ADDN]); + let d = Array2::::zeros([ADDN, ADDN]); bench.iter(|| { par_azip!(mut a, b, c, d in { *a += b.exp() + c.exp() + d.exp(); diff --git a/blas-tests/tests/oper.rs b/blas-tests/tests/oper.rs index 80526e4d8..ea97b25fc 100644 --- a/blas-tests/tests/oper.rs +++ b/blas-tests/tests/oper.rs @@ -128,11 +128,11 @@ fn dot_product_neg_stride() { } fn range_mat(m: Ix, n: Ix) -> Array2 { - Array::linspace(0., (m * n) as f32 - 1., m * n).into_shape((m, n)).unwrap() + Array::linspace(0., (m * n) as f32 - 1., m * n).into_shape([m, n]).unwrap() } fn range_mat64(m: Ix, n: Ix) -> Array2 { - Array::linspace(0., (m * n) as f64 - 1., m * n).into_shape((m, n)).unwrap() + Array::linspace(0., (m * n) as f64 - 1., m * n).into_shape([m, n]).unwrap() } fn range1_mat64(m: Ix) -> Array1 { @@ -140,7 +140,7 @@ fn range1_mat64(m: Ix) -> Array1 { } fn range_i32(m: Ix, n: Ix) -> Array2 { - Array::from_iter(0..(m * n) as i32).into_shape((m, n)).unwrap() + Array::from_iter(0..(m * n) as i32).into_shape([m, n]).unwrap() } // simple, slow, correct (hopefully) mat mul @@ -150,7 +150,7 @@ fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase S: Data, S2: Data, { - let ((m, k), (k2, n)) = (lhs.dim(), rhs.dim()); + let ([m, k], [k2, n]) = (lhs.dim(), rhs.dim()); assert!(m.checked_mul(n).is_some()); assert_eq!(k, k2); let mut res_elems = Vec::::with_capacity(m * n); @@ -163,7 +163,7 @@ fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase for rr in &mut res_elems { unsafe { *rr = (0..k).fold(A::zero(), - move |s, x| s + *lhs.uget((i, x)) * *rhs.uget((x, j))); + move |s, x| s + *lhs.uget([i, x]) * *rhs.uget([x, j])); } j += 1; if j == n { @@ -172,7 +172,7 @@ fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase } } unsafe { - ArrayBase::from_shape_vec_unchecked((m, n), res_elems) + ArrayBase::from_shape_vec_unchecked([m, n], res_elems) } } @@ -183,9 +183,9 @@ fn reference_mat_vec_mul(lhs: &ArrayBase, rhs: &ArrayBase, S2: Data, { - let ((m, _), k) = (lhs.dim(), rhs.dim()); - reference_mat_mul(lhs, &rhs.to_owned().into_shape((k, 1)).unwrap()) - .into_shape(m).unwrap() + let ([m, _], [k]) = (lhs.dim(), rhs.dim()); + reference_mat_mul(lhs, &rhs.to_owned().into_shape([k, 1]).unwrap()) + .into_shape([m]).unwrap() } // simple, slow, correct (hopefully) mat mul @@ -195,14 +195,14 @@ fn reference_vec_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase, S2: Data, { - let (m, (_, n)) = (lhs.dim(), rhs.dim()); - reference_mat_mul(&lhs.to_owned().into_shape((1, m)).unwrap(), rhs) - .into_shape(n).unwrap() + let ([m], [_, n]) = (lhs.dim(), rhs.dim()); + reference_mat_mul(&lhs.to_owned().into_shape([1, m]).unwrap(), rhs) + .into_shape([n]).unwrap() } #[test] fn mat_mul() { - let (m, n, k) = (8, 8, 8); + let [m, n, k] = [8, 8, 8]; let a = range_mat(m, n); let b = range_mat(n, k); let mut b = b / 4.; @@ -221,7 +221,7 @@ fn mat_mul() { assert_eq!(ab, af.dot(&b)); assert_eq!(ab, af.dot(&bf)); - let (m, n, k) = (10, 5, 11); + let [m, n, k] = [10, 5, 11]; let a = range_mat(m, n); let b = range_mat(n, k); let mut b = b / 4.; @@ -240,7 +240,7 @@ fn mat_mul() { assert_eq!(ab, af.dot(&b)); assert_eq!(ab, af.dot(&bf)); - let (m, n, k) = (10, 8, 1); + let [m, n, k] = [10, 8, 1]; let a = range_mat(m, n); let b = range_mat(n, k); let mut b = b / 4.; @@ -264,7 +264,7 @@ fn mat_mul() { // matrix with the same order #[test] fn mat_mul_order() { - let (m, n, k) = (8, 8, 8); + let [m, n, k] = [8, 8, 8]; let a = range_mat(m, n); let b = range_mat(n, k); let mut af = Array::zeros(a.dim().f()); @@ -304,14 +304,14 @@ fn mat_mul_shape_mismatch_2() { // supports broadcast arrays. #[test] fn mat_mul_broadcast() { - let (m, n, k) = (16, 16, 16); + let [m, n, k] = [16, 16, 16]; let a = range_mat(m, n); let x1 = 1.; let x = Array::from_vec(vec![x1]); - let b0 = x.broadcast((n, k)).unwrap(); - let b1 = Array::from_elem(n, x1); - let b1 = b1.broadcast((n, k)).unwrap(); - let b2 = Array::from_elem((n, k), x1); + let b0 = x.broadcast([n, k]).unwrap(); + let b1 = Array::from_elem([n], x1); + let b1 = b1.broadcast([n, k]).unwrap(); + let b2 = Array::from_elem([n, k], x1); let c2 = a.dot(&b2); let c1 = a.dot(&b1); @@ -323,7 +323,7 @@ fn mat_mul_broadcast() { // Check that matrix multiplication supports reversed axes #[test] fn mat_mul_rev() { - let (m, n, k) = (16, 16, 16); + let [m, n, k] = [16, 16, 16]; let a = range_mat(m, n); let b = range_mat(n, k); let mut rev = Array::zeros(b.dim()); @@ -344,12 +344,12 @@ fn mat_mut_zero_len() { for m in 0..4 { let a = range_mat_fn(m, n); let b = range_mat_fn(n, 0); - assert_eq!(a.dot(&b), Array2::zeros((m, 0))); + assert_eq!(a.dot(&b), Array2::zeros([m, 0])); } for k in 0..4 { let a = range_mat_fn(0, n); let b = range_mat_fn(n, k); - assert_eq!(a.dot(&b), Array2::zeros((0, k))); + assert_eq!(a.dot(&b), Array2::zeros([0, k])); } } }); @@ -462,19 +462,19 @@ fn scaled_add_3() { fn gen_mat_mul() { let alpha = -2.3; let beta = 3.14; - let sizes = vec![(4, 4, 4), (8, 8, 8), - (17, 15, 16), - (4, 17, 3), - (17, 3, 22), - (19, 18, 2), - (16, 17, 15), - (15, 16, 17), - (67, 63, 62), + let sizes = vec![[4, 4, 4], [8, 8, 8], + [17, 15, 16], + [4, 17, 3], + [17, 3, 22], + [19, 18, 2], + [16, 17, 15], + [15, 16, 17], + [67, 63, 62], ]; // test different strides for &s1 in &[1, 2, -1, -2] { for &s2 in &[1, 2, -1, -2] { - for &(m, k, n) in &sizes { + for &[m, k, n] in &sizes { let a = range_mat64(m, k); let b = range_mat64(k, n); let mut c = range_mat64(m, n); @@ -501,7 +501,7 @@ fn gen_mat_mul() { #[test] fn gemm_64_1_f() { let a = range_mat64(64, 64).reversed_axes(); - let (m, n) = a.dim(); + let [m, n] = a.dim(); // m x n times n x 1 == m x 1 let x = range_mat64(n, 1); let mut y = range_mat64(m, 1); @@ -514,16 +514,16 @@ fn gemm_64_1_f() { fn gen_mat_mul_i32() { let alpha = -1; let beta = 2; - let sizes = vec![(4, 4, 4), (8, 8, 8), - (17, 15, 16), - (4, 17, 3), - (17, 3, 22), - (19, 18, 2), - (16, 17, 15), - (15, 16, 17), - (67, 63, 62), + let sizes = vec![[4, 4, 4], [8, 8, 8], + [17, 15, 16], + [4, 17, 3], + [17, 3, 22], + [19, 18, 2], + [16, 17, 15], + [15, 16, 17], + [67, 63, 62], ]; - for &(m, k, n) in &sizes { + for &[m, k, n] in &sizes { let a = range_i32(m, k); let b = range_i32(k, n); let mut c = range_i32(m, n); @@ -557,7 +557,7 @@ fn gen_mat_vec_mul() { if rev { a = a.reversed_axes(); } - let (m, k) = a.dim(); + let [m, k] = a.dim(); let b = range1_mat64(k); let mut c = range1_mat64(m); let mut answer = c.clone(); @@ -600,7 +600,7 @@ fn vec_mat_mul() { if rev { b = b.reversed_axes(); } - let (m, n) = b.dim(); + let [m, n] = b.dim(); let a = range1_mat64(m); let mut c = range1_mat64(n); let mut answer = c.clone(); diff --git a/examples/axis_ops.rs b/examples/axis_ops.rs index e1dee54d2..3232cd6e1 100644 --- a/examples/axis_ops.rs +++ b/examples/axis_ops.rs @@ -37,7 +37,7 @@ fn regularize(a: &mut Array) -> Result<(), ()> } fn main() { - let mut a = Array::::zeros((2, 3, 4)); + let mut a = Array::::zeros([2, 3, 4]); for (i, elt) in (0..).zip(&mut a) { *elt = i; } @@ -46,17 +46,17 @@ fn main() { a.slice_collapse(s![.., ..;-1, ..]); regularize(&mut a).ok(); - let mut b = Array::::zeros((2, 3, 4)); + let mut b = Array::::zeros([2, 3, 4]); for (i, elt) in (0..).zip(&mut b) { *elt = i; } regularize(&mut b).ok(); - let mut b = b.into_shape(a.len()).unwrap(); + let mut b = b.into_shape([a.len()]).unwrap(); regularize(&mut b).ok(); b.invert_axis(Axis(0)); regularize(&mut b).ok(); - let mut a = Array::::zeros((2, 3, 4)); + let mut a = Array::::zeros([2, 3, 4]); for (i, elt) in (0..).zip(&mut a) { *elt = i; } diff --git a/examples/convo.rs b/examples/convo.rs index 1e6ee0ba6..96ab2d827 100644 --- a/examples/convo.rs +++ b/examples/convo.rs @@ -16,8 +16,8 @@ type Kernel3x3 = [[A; 3]; 3]; fn conv_3x3(a: &ArrayView2, out: &mut ArrayViewMut2, kernel: &Kernel3x3) where F: Float, { - let (n, m) = a.dim(); - let (np, mp) = out.dim(); + let [n, m] = a.dim(); + let [np, mp] = out.dim(); if n < 3 || m < 3 { return; } @@ -29,11 +29,11 @@ fn conv_3x3(a: &ArrayView2, out: &mut ArrayViewMut2, kernel: &Kernel3x3 let mut conv = F::zero(); for k in 0..3 { for l in 0..3 { - conv = conv + *a.uget((i + k, j + l)) * kernel[k][l]; + conv = conv + *a.uget([i + k, j + l]) * kernel[k][l]; //conv += a[[i + k, j + l]] * x_kernel[k][l]; } } - *out.uget_mut((i + 1, j + 1)) = conv; + *out.uget_mut([i + 1, j + 1]) = conv; } } } @@ -41,10 +41,10 @@ fn conv_3x3(a: &ArrayView2, out: &mut ArrayViewMut2, kernel: &Kernel3x3 fn main() { let n = 16; - let mut a = Array::zeros((n, n)); + let mut a = Array::zeros([n, n]); // make a circle let c = (8., 8.); - for ((i, j), elt) in a.indexed_iter_mut() { + for ([i, j], elt) in a.indexed_iter_mut() { { let s = ((i as f32) - c.0).powi(2) + (j as f32 - c.1).powi(2); if s.sqrt() > 3. && s.sqrt() < 6. { diff --git a/examples/life.rs b/examples/life.rs index 2bb1ccca0..c3a9241e0 100644 --- a/examples/life.rs +++ b/examples/life.rs @@ -12,14 +12,14 @@ type Board = Array2; fn parse(x: &[u8]) -> Board { // make a border of 0 cells - let mut map = Board::from_elem(((N + 2), (N + 2)), 0); + let mut map = Board::from_elem([N + 2, N + 2], 0); let a = Array::from_iter(x.iter().filter_map(|&b| match b { b'#' => Some(1), b'.' => Some(0), _ => None, })); - let a = a.into_shape((N, N)).unwrap(); + let a = a.into_shape([N, N]).unwrap(); map.slice_mut(s![1..-1, 1..-1]).assign(&a); map } @@ -79,7 +79,7 @@ fn render(a: &Board) { fn main() { let mut a = parse(INPUT); - let mut scratch = Board::zeros((N, N)); + let mut scratch = Board::zeros([N, N]); let steps = 100; turn_on_corners(&mut a); for _ in 0..steps { diff --git a/examples/sort-axis.rs b/examples/sort-axis.rs index 1a23146e9..e678cbced 100644 --- a/examples/sort-axis.rs +++ b/examples/sort-axis.rs @@ -127,7 +127,7 @@ impl PermuteArray for Array fn main() { - let a = Array::linspace(0., 63., 64).into_shape((8, 8)).unwrap(); + let a = Array::linspace(0., 63., 64).into_shape([8, 8]).unwrap(); let strings = a.map(|x| x.to_string()); let perm = a.sort_axis_by(Axis(1), |i, j| { diff --git a/examples/zip_many.rs b/examples/zip_many.rs index 5e839d37c..eb982ac4d 100644 --- a/examples/zip_many.rs +++ b/examples/zip_many.rs @@ -5,12 +5,12 @@ use ndarray::Zip; fn main() { let n = 16; - let mut a = Array::::zeros((n, n)); - let mut b = Array::::from_elem((n, n), 1.); - for ((i, j), elt) in b.indexed_iter_mut() { + let mut a = Array::::zeros([n, n]); + let mut b = Array::::from_elem([n, n], 1.); + for ([i, j], elt) in b.indexed_iter_mut() { *elt /= 1. + (i + 2 * j) as f32; } - let c = Array::::from_elem((n, n + 1), 1.7); + let c = Array::::from_elem([n, n + 1], 1.7); let c = c.slice(s![.., ..-1]); { @@ -25,12 +25,12 @@ fn main() { // sum of each row let ax = Axis(0); - let mut sums = Array::zeros(a.len_of(ax)); + let mut sums = Array::zeros([a.len_of(ax)]); azip!(mut sums, ref a (a.axis_iter(ax)) in { *sums = a.sum() }); // sum of each chunk - let chunk_sz = (2, 2); - let nchunks = (n / chunk_sz.0, n / chunk_sz.1); + let chunk_sz = [2, 2]; + let nchunks = [n / chunk_sz[0], n / chunk_sz[1]]; let mut sums = Array::zeros(nchunks); azip!(mut sums, ref a (a.exact_chunks(chunk_sz)) in { *sums = a.sum() }); @@ -38,11 +38,11 @@ fn main() { // Let's imagine we split to parallelize { let (x, y) = Zip::indexed(&mut a).split(); - x.apply(|(_, j), elt| { + x.apply(|[_, j], elt| { *elt = elt.powi(j as i32); }); - y.apply(|(_, j), elt| { + y.apply(|[_, j], elt| { *elt = elt.powi(j as i32); }); } diff --git a/numeric-tests/tests/accuracy.rs b/numeric-tests/tests/accuracy.rs index cf92fde23..4d0785170 100644 --- a/numeric-tests/tests/accuracy.rs +++ b/numeric-tests/tests/accuracy.rs @@ -22,7 +22,7 @@ fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase S: Data, S2: Data, { - let ((m, k), (_, n)) = (lhs.dim(), rhs.dim()); + let ([m, k], [_, n]) = (lhs.dim(), rhs.dim()); let mut res_elems = Vec::::with_capacity(m * n); unsafe { res_elems.set_len(m * n); @@ -33,7 +33,7 @@ fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase for rr in &mut res_elems { unsafe { *rr = (0..k).fold(A::zero(), - move |s, x| s + *lhs.uget((i, x)) * *rhs.uget((x, j))); + move |s, x| s + *lhs.uget([i, x]) * *rhs.uget([x, j])); } j += 1; if j == n { @@ -42,7 +42,7 @@ fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase } } unsafe { - ArrayBase::from_shape_vec_unchecked((m, n), res_elems) + ArrayBase::from_shape_vec_unchecked([m, n], res_elems) } } @@ -285,11 +285,11 @@ fn accurate_mul_with_column_f64() { 0 ... 3 => b_sq = b_owner.view(), 4 ... 7 => { b_row_col = b_owner.column(0); - b_sq = b_row_col.broadcast((k, k)).unwrap(); + b_sq = b_row_col.broadcast([k, k]).unwrap(); } _otherwise => { b_row_col = b_owner.row(0); - b_sq = b_row_col.broadcast((k, k)).unwrap(); + b_sq = b_row_col.broadcast([k, k]).unwrap(); } }; diff --git a/serialization-tests/tests/serialize.rs b/serialization-tests/tests/serialize.rs index d0a2f3b79..76827e9de 100644 --- a/serialization-tests/tests/serialize.rs +++ b/serialization-tests/tests/serialize.rs @@ -47,7 +47,7 @@ fn serial_many_dim_serde() { // Test a sliced array. - let mut a = RcArray::linspace(0., 31., 32).reshape((2, 2, 2, 4)); + let mut a = RcArray::linspace(0., 31., 32).reshape([2, 2, 2, 4]); a.slice_collapse(s![..;-1, .., .., ..2]); let serial = serde_json::to_string(&a).unwrap(); println!("Encode {:?} => {:?}", a, serial); @@ -154,7 +154,7 @@ fn serial_many_dim_serde_msgpack() { // Test a sliced array. - let mut a = RcArray::linspace(0., 31., 32).reshape((2, 2, 2, 4)); + let mut a = RcArray::linspace(0., 31., 32).reshape([2, 2, 2, 4]); a.slice_collapse(s![..;-1, .., .., ..2]); let mut buf = Vec::new(); @@ -206,7 +206,7 @@ fn serial_many_dim_ron() { // Test a sliced array. - let mut a = RcArray::linspace(0., 31., 32).reshape((2, 2, 2, 4)); + let mut a = RcArray::linspace(0., 31., 32).reshape([2, 2, 2, 4]); a.slice_collapse(s![..;-1, .., .., ..2]); let a_s = ron_serialize(&a).unwrap(); diff --git a/src/arrayformat.rs b/src/arrayformat.rs index 894215d8c..0daa1f7dd 100644 --- a/src/arrayformat.rs +++ b/src/arrayformat.rs @@ -221,7 +221,7 @@ mod formatting_with_omit { #[test] fn zero_length_axes() { - let a = Array3::::zeros((3, 0, 4)); + let a = Array3::::zeros([3, 0, 4]); let actual_output = format!("{}", a); let expected_output = String::from("[[[]]]"); print_output_diff(&expected_output, &actual_output); @@ -241,7 +241,7 @@ mod formatting_with_omit { #[test] fn dim_1() { let overflow: usize = 5; - let a = Array1::from_elem((PRINT_ELEMENTS_LIMIT * 2 + overflow, ), 1); + let a = Array1::from_elem([PRINT_ELEMENTS_LIMIT * 2 + overflow, ], 1); let mut expected_output = String::from("["); a.iter() .take(PRINT_ELEMENTS_LIMIT) @@ -260,17 +260,17 @@ mod formatting_with_omit { #[test] fn dim_2_last_axis_overflow() { let overflow: usize = 3; - let a = Array2::from_elem((PRINT_ELEMENTS_LIMIT, PRINT_ELEMENTS_LIMIT * 2 + overflow), 1); + let a = Array2::from_elem([PRINT_ELEMENTS_LIMIT, PRINT_ELEMENTS_LIMIT * 2 + overflow], 1); let mut expected_output = String::from("["); for i in 0..PRINT_ELEMENTS_LIMIT { - expected_output.push_str(format!("[{}", a[(i, 0)]).as_str()); + expected_output.push_str(format!("[{}", a[[i, 0]]).as_str()); for j in 1..PRINT_ELEMENTS_LIMIT { - expected_output.push_str(format!(", {}", a[(i, j)]).as_str()); + expected_output.push_str(format!(", {}", a[[i, j]]).as_str()); } expected_output.push_str(", ..."); for j in PRINT_ELEMENTS_LIMIT + overflow..PRINT_ELEMENTS_LIMIT * 2 + overflow { - expected_output.push_str(format!(", {}", a[(i, j)]).as_str()); + expected_output.push_str(format!(", {}", a[[i, j]]).as_str()); } expected_output.push_str(if i < PRINT_ELEMENTS_LIMIT - 1 { "],\n " } else { "]" }); } @@ -284,21 +284,21 @@ mod formatting_with_omit { #[test] fn dim_2_non_last_axis_overflow() { let overflow: usize = 5; - let a = Array2::from_elem((PRINT_ELEMENTS_LIMIT * 2 + overflow, PRINT_ELEMENTS_LIMIT), 1); + let a = Array2::from_elem([PRINT_ELEMENTS_LIMIT * 2 + overflow, PRINT_ELEMENTS_LIMIT], 1); let mut expected_output = String::from("["); for i in 0..PRINT_ELEMENTS_LIMIT { - expected_output.push_str(format!("[{}", a[(i, 0)]).as_str()); + expected_output.push_str(format!("[{}", a[[i, 0]]).as_str()); for j in 1..PRINT_ELEMENTS_LIMIT { - expected_output.push_str(format!(", {}", a[(i, j)]).as_str()); + expected_output.push_str(format!(", {}", a[[i, j]]).as_str()); } expected_output.push_str("],\n "); } expected_output.push_str("...,\n "); for i in PRINT_ELEMENTS_LIMIT + overflow..PRINT_ELEMENTS_LIMIT * 2 + overflow { - expected_output.push_str(format!("[{}", a[(i, 0)]).as_str()); + expected_output.push_str(format!("[{}", a[[i, 0]]).as_str()); for j in 1..PRINT_ELEMENTS_LIMIT { - expected_output.push_str(format!(", {}", a[(i, j)]).as_str()); + expected_output.push_str(format!(", {}", a[[i, j]]).as_str()); } expected_output.push_str(if i == PRINT_ELEMENTS_LIMIT * 2 + overflow - 1 { "]" @@ -317,30 +317,30 @@ mod formatting_with_omit { fn dim_2_multi_directional_overflow() { let overflow: usize = 5; let a = Array2::from_elem( - (PRINT_ELEMENTS_LIMIT * 2 + overflow, PRINT_ELEMENTS_LIMIT * 2 + overflow), 1 + [PRINT_ELEMENTS_LIMIT * 2 + overflow, PRINT_ELEMENTS_LIMIT * 2 + overflow], 1 ); let mut expected_output = String::from("["); for i in 0..PRINT_ELEMENTS_LIMIT { - expected_output.push_str(format!("[{}", a[(i, 0)]).as_str()); + expected_output.push_str(format!("[{}", a[[i, 0]]).as_str()); for j in 1..PRINT_ELEMENTS_LIMIT { - expected_output.push_str(format!(", {}", a[(i, j)]).as_str()); + expected_output.push_str(format!(", {}", a[[i, j]]).as_str()); } expected_output.push_str(", ..."); for j in PRINT_ELEMENTS_LIMIT + overflow..PRINT_ELEMENTS_LIMIT * 2 + overflow { - expected_output.push_str(format!(", {}", a[(i, j)]).as_str()); + expected_output.push_str(format!(", {}", a[[i, j]]).as_str()); } expected_output.push_str("],\n "); } expected_output.push_str("...,\n "); for i in PRINT_ELEMENTS_LIMIT + overflow..PRINT_ELEMENTS_LIMIT * 2 + overflow { - expected_output.push_str(format!("[{}", a[(i, 0)]).as_str()); + expected_output.push_str(format!("[{}", a[[i, 0]]).as_str()); for j in 1..PRINT_ELEMENTS_LIMIT { - expected_output.push_str(format!(", {}", a[(i, j)]).as_str()); + expected_output.push_str(format!(", {}", a[[i, j]]).as_str()); } expected_output.push_str(", ..."); for j in PRINT_ELEMENTS_LIMIT + overflow..PRINT_ELEMENTS_LIMIT * 2 + overflow { - expected_output.push_str(format!(", {}", a[(i, j)]).as_str()); + expected_output.push_str(format!(", {}", a[[i, j]]).as_str()); } expected_output.push_str(if i == PRINT_ELEMENTS_LIMIT * 2 + overflow - 1 { "]" diff --git a/src/arraytraits.rs b/src/arraytraits.rs index 13b5ce6c8..3c4affa4b 100644 --- a/src/arraytraits.rs +++ b/src/arraytraits.rs @@ -230,7 +230,7 @@ impl<'a, A, Slice: ?Sized> From<&'a Slice> for ArrayView<'a, A, Ix1> ); } unsafe { - Self::from_shape_ptr(xs.len(), xs.as_ptr()) + Self::from_shape_ptr([xs.len()], xs.as_ptr()) } } } @@ -262,7 +262,7 @@ impl<'a, A, Slice: ?Sized> From<&'a mut Slice> for ArrayViewMut<'a, A, Ix1> ); } unsafe { - Self::from_shape_ptr(xs.len(), xs.as_mut_ptr()) + Self::from_shape_ptr([xs.len()], xs.as_mut_ptr()) } } } diff --git a/src/dimension/axes.rs b/src/dimension/axes.rs index f087eb5c5..63cbbc39d 100644 --- a/src/dimension/axes.rs +++ b/src/dimension/axes.rs @@ -25,7 +25,7 @@ pub fn axes_of<'a, D>(d: &'a D, strides: &'a D) -> Axes<'a, D> /// use ndarray::Array3; /// use ndarray::Axis; /// -/// let a = Array3::::zeros((3, 5, 4)); +/// let a = Array3::::zeros([3, 5, 4]); /// /// let largest_axis = a.axes() /// .max_by_key(|ax| ax.len()) diff --git a/src/dimension/conversion.rs b/src/dimension/conversion.rs index c4e49c778..309303e4f 100644 --- a/src/dimension/conversion.rs +++ b/src/dimension/conversion.rs @@ -11,7 +11,7 @@ use std::ops::{Index, IndexMut}; use num_traits::Zero; -use crate::{Ix, Ix1, IxDyn, Dimension, Dim, IxDynImpl}; +use crate::{Ix, IxDyn, Dimension, Dim, IxDynImpl}; /// $m: macro callback /// $m is called with $arg and then the indices corresponding to the size argument @@ -43,12 +43,6 @@ pub trait IntoDimension { fn into_dimension(self) -> Self::Dim; } -impl IntoDimension for Ix { - type Dim = Ix1; - #[inline(always)] - fn into_dimension(self) -> Ix1 { Ix1(self) } -} - impl IntoDimension for D where D: Dimension { type Dim = D; #[inline(always)] @@ -88,12 +82,6 @@ macro_rules! tuple_expr { ) } -macro_rules! array_expr { - ([$self_:expr] $($index:tt)*) => ( - [$($self_ . $index, )*] - ) -} - macro_rules! array_zero { ([] $($index:tt)*) => ( [$(sub!($index 0), )*] @@ -119,14 +107,6 @@ macro_rules! tuple_to_array { } } - impl IntoDimension for index!(tuple_type [Ix] $n) { - type Dim = Dim<[Ix; $n]>; - #[inline(always)] - fn into_dimension(self) -> Self::Dim { - Dim::new(index!(array_expr [self] $n)) - } - } - impl Index for Dim<[Ix; $n]> { type Output = usize; #[inline(always)] diff --git a/src/dimension/dim.rs b/src/dimension/dim.rs index 4adb71658..c6f897814 100644 --- a/src/dimension/dim.rs +++ b/src/dimension/dim.rs @@ -32,7 +32,7 @@ use crate::Ix; /// use ndarray::Array2; /// use ndarray::Dim; /// -/// let mut array = Array2::zeros((3, 2)); +/// let mut array = Array2::zeros([3, 2]); /// array[[0, 0]] = 1.; /// assert_eq!(array.raw_dim(), Dim([3, 2])); /// ``` diff --git a/src/dimension/dimension_trait.rs b/src/dimension/dimension_trait.rs index f8357f069..0491a685e 100644 --- a/src/dimension/dimension_trait.rs +++ b/src/dimension/dimension_trait.rs @@ -22,7 +22,6 @@ use super::{ stride_offset, stride_offset_checked, }; -use super::conversion::Convert; use super::axes_of; /// Array shape and index trait. @@ -62,11 +61,12 @@ pub trait Dimension : Clone + Eq + Debug + Send + Sync + Default + type SliceArg: ?Sized + AsRef<[SliceOrIndex]>; /// Pattern matching friendly form of the dimension value. /// - /// - For `Ix1`: `usize`, - /// - For `Ix2`: `(usize, usize)` + /// - For `Ix0`: `[]`, + /// - For `Ix1`: `[usize]`, + /// - For `Ix2`: `[usize, usize]` /// - and so on.. /// - For `IxDyn`: `IxDyn` - type Pattern: IntoDimension; + type Pattern: IntoDimension + Clone; /// Next smaller dimension (if applicable) type Smaller: Dimension; /// Next larger dimension @@ -75,8 +75,14 @@ pub trait Dimension : Clone + Eq + Debug + Send + Sync + Default + /// Returns the number of dimensions (number of axes). fn ndim(&self) -> usize; - /// Convert the dimension into a pattern matching friendly value. - fn into_pattern(self) -> Self::Pattern; + /// Returns the dimension as a pattern matching friendly value. + fn as_pattern(&self) -> &Self::Pattern; + + /// Convert the dimension to a pattern matching friendly value. + fn to_pattern(&self) -> Self::Pattern + { + self.as_pattern().clone() + } /// Compute the size of the dimension (number of elements) fn size(&self) -> usize { @@ -365,7 +371,7 @@ macro_rules! impl_insert_axis_array( impl Dimension for Dim<[Ix; 0]> { const NDIM: Option = Some(0); type SliceArg = [SliceOrIndex; 0]; - type Pattern = (); + type Pattern = [Ix; 0]; type Smaller = Self; type Larger = Ix1; // empty product is 1 -> size is 1 @@ -378,7 +384,7 @@ impl Dimension for Dim<[Ix; 0]> { #[inline] fn _fastest_varying_stride_order(&self) -> Self { Ix0() } #[inline] - fn into_pattern(self) -> Self::Pattern { } + fn as_pattern(&self) -> &Self::Pattern { &[] } #[inline] fn zeros(ndim: usize) -> Self { assert_eq!(ndim, 0); @@ -402,7 +408,7 @@ impl Dimension for Dim<[Ix; 0]> { impl Dimension for Dim<[Ix; 1]> { const NDIM: Option = Some(1); type SliceArg = [SliceOrIndex; 1]; - type Pattern = Ix; + type Pattern = [Ix; 1]; type Smaller = Ix0; type Larger = Ix2; #[inline] @@ -412,8 +418,8 @@ impl Dimension for Dim<[Ix; 1]> { #[inline] fn slice_mut(&mut self) -> &mut [Ix] { self.ixm() } #[inline] - fn into_pattern(self) -> Self::Pattern { - get!(&self, 0) + fn as_pattern(&self) -> &Self::Pattern { + self.ix() } #[inline] fn zeros(ndim: usize) -> Self { @@ -500,14 +506,14 @@ impl Dimension for Dim<[Ix; 1]> { impl Dimension for Dim<[Ix; 2]> { const NDIM: Option = Some(2); type SliceArg = [SliceOrIndex; 2]; - type Pattern = (Ix, Ix); + type Pattern = [Ix; 2]; type Smaller = Ix1; type Larger = Ix3; #[inline] fn ndim(&self) -> usize { 2 } #[inline] - fn into_pattern(self) -> Self::Pattern { - self.ix().convert() + fn as_pattern(&self) -> &Self::Pattern { + self.ix() } #[inline] fn slice(&self) -> &[Ix] { self.ix() } @@ -646,14 +652,14 @@ impl Dimension for Dim<[Ix; 2]> { impl Dimension for Dim<[Ix; 3]> { const NDIM: Option = Some(3); type SliceArg = [SliceOrIndex; 3]; - type Pattern = (Ix, Ix, Ix); + type Pattern = [Ix; 3]; type Smaller = Ix2; type Larger = Ix4; #[inline] fn ndim(&self) -> usize { 3 } #[inline] - fn into_pattern(self) -> Self::Pattern { - self.ix().convert() + fn as_pattern(&self) -> &Self::Pattern { + self.ix() } #[inline] fn slice(&self) -> &[Ix] { self.ix() } @@ -764,14 +770,14 @@ macro_rules! large_dim { impl Dimension for Dim<[Ix; $n]> { const NDIM: Option = Some($n); type SliceArg = [SliceOrIndex; $n]; - type Pattern = $pattern; + type Pattern = [Ix; $n]; type Smaller = Dim<[Ix; $n - 1]>; type Larger = $larger; #[inline] fn ndim(&self) -> usize { $n } #[inline] - fn into_pattern(self) -> Self::Pattern { - self.ix().convert() + fn as_pattern(&self) -> &Self::Pattern { + self.ix() } #[inline] fn slice(&self) -> &[Ix] { self.ix() } @@ -826,7 +832,7 @@ impl Dimension for IxDyn #[inline] fn slice_mut(&mut self) -> &mut [Ix] { self.ixm() } #[inline] - fn into_pattern(self) -> Self::Pattern { + fn as_pattern(&self) -> &Self::Pattern { self } diff --git a/src/dimension/mod.rs b/src/dimension/mod.rs index aebcfc662..fd9b84f43 100644 --- a/src/dimension/mod.rs +++ b/src/dimension/mod.rs @@ -634,42 +634,42 @@ mod test { #[test] fn slice_indexing_uncommon_strides() { let v: Vec<_> = (0..12).collect(); - let dim = (2, 3, 2).into_dimension(); - let strides = (1, 2, 6).into_dimension(); + let dim = [2, 3, 2].into_dimension(); + let strides = [1, 2, 6].into_dimension(); assert!(super::can_index_slice(&v, &dim, &strides).is_ok()); - let strides = (2, 4, 12).into_dimension(); + let strides = [2, 4, 12].into_dimension(); assert_eq!(super::can_index_slice(&v, &dim, &strides), Err(from_kind(ErrorKind::OutOfBounds))); } #[test] fn overlapping_strides_dim() { - let dim = (2, 3, 2).into_dimension(); - let strides = (5, 2, 1).into_dimension(); + let dim = [2, 3, 2].into_dimension(); + let strides = [5, 2, 1].into_dimension(); assert!(super::dim_stride_overlap(&dim, &strides)); - let strides = (6, 2, 1).into_dimension(); + let strides = [6, 2, 1].into_dimension(); assert!(!super::dim_stride_overlap(&dim, &strides)); - let strides = (6, 0, 1).into_dimension(); + let strides = [6, 0, 1].into_dimension(); assert!(super::dim_stride_overlap(&dim, &strides)); - let dim = (2, 2).into_dimension(); - let strides = (3, 2).into_dimension(); + let dim = [2, 2].into_dimension(); + let strides = [3, 2].into_dimension(); assert!(!super::dim_stride_overlap(&dim, &strides)); } #[test] fn max_abs_offset_check_overflow_examples() { - let dim = (1, ::std::isize::MAX as usize, 1).into_dimension(); - let strides = (1, 1, 1).into_dimension(); + let dim = [1, ::std::isize::MAX as usize, 1].into_dimension(); + let strides = [1, 1, 1].into_dimension(); max_abs_offset_check_overflow::(&dim, &strides).unwrap(); - let dim = (1, ::std::isize::MAX as usize, 2).into_dimension(); - let strides = (1, 1, 1).into_dimension(); + let dim = [1, ::std::isize::MAX as usize, 2].into_dimension(); + let strides = [1, 1, 1].into_dimension(); max_abs_offset_check_overflow::(&dim, &strides).unwrap_err(); - let dim = (0, 2, 2).into_dimension(); - let strides = (1, ::std::isize::MAX as usize, 1).into_dimension(); + let dim = [0, 2, 2].into_dimension(); + let strides = [1, ::std::isize::MAX as usize, 1].into_dimension(); max_abs_offset_check_overflow::(&dim, &strides).unwrap_err(); - let dim = (0, 2, 2).into_dimension(); - let strides = (1, ::std::isize::MAX as usize / 4, 1).into_dimension(); + let dim = [0, 2, 2].into_dimension(); + let strides = [1, ::std::isize::MAX as usize / 4, 1].into_dimension(); max_abs_offset_check_overflow::(&dim, &strides).unwrap_err(); } diff --git a/src/dimension/ndindex.rs b/src/dimension/ndindex.rs index c0a4f4370..0eae41356 100644 --- a/src/dimension/ndindex.rs +++ b/src/dimension/ndindex.rs @@ -16,7 +16,7 @@ use super::{stride_offset, stride_offset_checked}; /// assert_eq!(a[[0, 1]], 1); /// assert_eq!(a[[1, 1]], 3); /// a[[1, 1]] += 1; -/// assert_eq!(a[(1, 1)], 4); +/// assert_eq!(a[[1, 1]], 4); /// ``` pub unsafe trait NdIndex : Debug { #[doc(hidden)] @@ -47,52 +47,6 @@ unsafe impl NdIndex for () { } } -unsafe impl NdIndex for (Ix, Ix) { - #[inline] - fn index_checked(&self, dim: &Ix2, strides: &Ix2) -> Option { - dim.stride_offset_checked(strides, &Ix2(self.0, self.1)) - } - #[inline] - fn index_unchecked(&self, strides: &Ix2) -> isize { - stride_offset(self.0, get!(strides, 0)) + - stride_offset(self.1, get!(strides, 1)) - } -} -unsafe impl NdIndex for (Ix, Ix, Ix) { - #[inline] - fn index_checked(&self, dim: &Ix3, strides: &Ix3) -> Option { - dim.stride_offset_checked(strides, &self.into_dimension()) - } - - #[inline] - fn index_unchecked(&self, strides: &Ix3) -> isize { - stride_offset(self.0, get!(strides, 0)) + - stride_offset(self.1, get!(strides, 1)) + - stride_offset(self.2, get!(strides, 2)) - } -} - -unsafe impl NdIndex for (Ix, Ix, Ix, Ix) { - #[inline] - fn index_checked(&self, dim: &Ix4, strides: &Ix4) -> Option { - dim.stride_offset_checked(strides, &self.into_dimension()) - } - #[inline] - fn index_unchecked(&self, strides: &Ix4) -> isize { - zip(strides.ix(), self.into_dimension().ix()).map(|(&s, &i)| stride_offset(i, s)).sum() - } -} -unsafe impl NdIndex for (Ix, Ix, Ix, Ix, Ix) { - #[inline] - fn index_checked(&self, dim: &Ix5, strides: &Ix5) -> Option { - dim.stride_offset_checked(strides, &self.into_dimension()) - } - #[inline] - fn index_unchecked(&self, strides: &Ix5) -> isize { - zip(strides.ix(), self.into_dimension().ix()).map(|(&s, &i)| stride_offset(i, s)).sum() - } -} - unsafe impl NdIndex for Ix { #[inline] fn index_checked(&self, dim: &Ix1, strides: &Ix1) -> Option { diff --git a/src/doc/ndarray_for_numpy_users/coord_transform.rs b/src/doc/ndarray_for_numpy_users/coord_transform.rs index 1c6468f64..c565612e5 100644 --- a/src/doc/ndarray_for_numpy_users/coord_transform.rs +++ b/src/doc/ndarray_for_numpy_users/coord_transform.rs @@ -55,7 +55,7 @@ //! //! fn main() { //! let nelems = 4; -//! let bunge = Array::ones((3, nelems)); +//! let bunge = Array::ones([3, nelems]); //! //! let s1 = bunge.slice(s![0, ..]).mapv(f64::sin); //! let c1 = bunge.slice(s![0, ..]).mapv(f64::cos); @@ -64,7 +64,7 @@ //! let s3 = bunge.slice(s![2, ..]).mapv(f64::sin); //! let c3 = bunge.slice(s![2, ..]).mapv(f64::cos); //! -//! let mut rmat = Array::zeros((3, 3, nelems).f()); +//! let mut rmat = Array::zeros([3, 3, nelems].f()); //! for i in 0..nelems { //! rmat[[0, 0, i]] = c1[i] * c3[i] - s1[i] * s3[i] * c2[i]; //! rmat[[0, 1, i]] = -c1[i] * s3[i] - s1[i] * c2[i] * c3[i]; @@ -81,7 +81,7 @@ //! //! let eye2d = Array::eye(3); //! -//! let mut rotated = Array::zeros((3, 3, nelems).f()); +//! let mut rotated = Array::zeros([3, 3, nelems].f()); //! for i in 0..nelems { //! rotated //! .slice_mut(s![.., .., i]) @@ -102,9 +102,9 @@ //! //! fn main() { //! let nelems = 4; -//! let bunge = Array2::::ones((3, nelems)); +//! let bunge = Array2::::ones([3, nelems]); //! -//! let mut rmat = Array::zeros((3, 3, nelems).f()); +//! let mut rmat = Array::zeros([3, 3, nelems].f()); //! azip!(mut rmat (rmat.axis_iter_mut(Axis(2))), ref bunge (bunge.axis_iter(Axis(1))) in { //! let s1 = bunge[0].sin(); //! let c1 = bunge[0].cos(); @@ -128,7 +128,7 @@ //! //! let eye2d = Array2::::eye(3); //! -//! let mut rotated = Array3::::zeros((3, 3, nelems).f()); +//! let mut rotated = Array3::::zeros([3, 3, nelems].f()); //! azip!(mut rotated (rotated.axis_iter_mut(Axis(2)), rmat (rmat.axis_iter(Axis(2)))) in { //! rotated.assign({ &rmat.dot(&eye2d) }); //! }); diff --git a/src/doc/ndarray_for_numpy_users/mod.rs b/src/doc/ndarray_for_numpy_users/mod.rs index b268c9b24..c22387293 100644 --- a/src/doc/ndarray_for_numpy_users/mod.rs +++ b/src/doc/ndarray_for_numpy_users/mod.rs @@ -204,18 +204,18 @@ //! # //! // This is an example where the compiler can infer the element type //! // because `f64::sin` can only be called on `f64` elements: -//! let arr1 = Array::zeros((3, 2, 4).f()); +//! let arr1 = Array::zeros([3, 2, 4].f()); //! arr1.mapv(f64::sin); //! //! // Specify just the element type and infer the dimensionality: -//! let arr2 = Array::::zeros((3, 2, 4).f()); -//! let arr3: Array = Array::zeros((3, 2, 4).f()); +//! let arr2 = Array::::zeros([3, 2, 4].f()); +//! let arr3: Array = Array::zeros([3, 2, 4].f()); //! //! // Specify both the element type and dimensionality: -//! let arr4 = Array3::::zeros((3, 2, 4).f()); -//! let arr5: Array3 = Array::zeros((3, 2, 4).f()); -//! let arr6 = Array::::zeros((3, 2, 4).f()); -//! let arr7: Array = Array::zeros((3, 2, 4).f()); +//! let arr4 = Array3::::zeros([3, 2, 4].f()); +//! let arr5: Array3 = Array::zeros([3, 2, 4].f()); +//! let arr6 = Array::::zeros([3, 2, 4].f()); +//! let arr7: Array = Array::zeros([3, 2, 4].f()); //! ``` //! //! ## Indexing and slicing diff --git a/src/doc/ndarray_for_numpy_users/simple_math.rs b/src/doc/ndarray_for_numpy_users/simple_math.rs index b6549d3c2..2e2756e8c 100644 --- a/src/doc/ndarray_for_numpy_users/simple_math.rs +++ b/src/doc/ndarray_for_numpy_users/simple_math.rs @@ -57,7 +57,7 @@ //! //! # fn main() { //! // Create a 5×4 array of threes. -//! let mut a = Array2::::from_elem((5, 4), 3.); +//! let mut a = Array2::::from_elem([5, 4], 3.); //! //! // Fill the even-index rows with twos. //! a.slice_mut(s![..;2, ..]).fill(2.); @@ -72,7 +72,7 @@ //! let odd_sum = a.slice(s![.., 1..;2]).sum(); //! //! // Create a 1-D array of exp(index). -//! let b = Array::from_shape_fn(4, |i| (i as f64).exp()); +//! let b = Array::from_shape_fn([4], |[i]| (i as f64).exp()); //! //! // Add b to a (broadcasting to rows). //! let c = a + &b; diff --git a/src/free_functions.rs b/src/free_functions.rs index f289cdffe..4f48f8589 100644 --- a/src/free_functions.rs +++ b/src/free_functions.rs @@ -55,7 +55,7 @@ macro_rules! array { /// Create a zero-dimensional array with the element `x`. pub fn arr0(x: A) -> Array0 { - unsafe { ArrayBase::from_shape_vec_unchecked((), vec![x]) } + unsafe { ArrayBase::from_shape_vec_unchecked([], vec![x]) } } /// Create a one-dimensional array with elements from `xs`. @@ -81,7 +81,7 @@ pub fn aview0(x: &A) -> ArrayView0 { /// let data = [1.0; 1024]; /// /// // Create a 2D array view from borrowed data -/// let a2d = aview1(&data).into_shape((32, 32)).unwrap(); +/// let a2d = aview1(&data).into_shape([32, 32]).unwrap(); /// /// assert_eq!(a2d.sum(), 1024.0); /// ``` @@ -124,7 +124,7 @@ pub fn aview2>(xs: &[V]) -> ArrayView2 { /// fn main() { /// let mut data = [0; 1024]; /// { -/// let mut a = aview_mut1(&mut data).into_shape((32, 32)).unwrap(); +/// let mut a = aview_mut1(&mut data).into_shape([32, 32]).unwrap(); /// a.slice_mut(s![.., ..;3]).fill(5); /// } /// assert_eq!(&data[..10], [5, 0, 0, 5, 0, 0, 5, 0, 0, 5]); diff --git a/src/impl_constructors.rs b/src/impl_constructors.rs index 1c2b84439..6c2e68753 100644 --- a/src/impl_constructors.rs +++ b/src/impl_constructors.rs @@ -48,7 +48,7 @@ impl ArrayBase "Length must fit in `isize`.", ); } - unsafe { Self::from_shape_vec_unchecked(v.len() as Ix, v) } + unsafe { Self::from_shape_vec_unchecked([v.len() as Ix], v) } } /// Create a one-dimensional array from an iterable. @@ -114,7 +114,7 @@ impl ArrayBase where S: DataMut, A: Clone + Zero + One, { - let mut eye = Self::zeros((n, n)); + let mut eye = Self::zeros([n, n]); for a_ii in eye.diag_mut() { *a_ii = A::one(); } @@ -173,7 +173,7 @@ impl ArrayBase /// ``` /// use ndarray::{Array, arr3, ShapeBuilder}; /// - /// let a = Array::from_elem((2, 2, 2), 1.); + /// let a = Array::from_elem([2, 2, 2], 1.); /// /// assert!( /// a == arr3(&[[[1., 1.], @@ -183,7 +183,7 @@ impl ArrayBase /// ); /// assert!(a.strides() == &[4, 2, 1]); /// - /// let b = Array::from_elem((2, 2, 2).f(), 1.); + /// let b = Array::from_elem([2, 2, 2].f(), 1.); /// assert!(b.strides() == &[1, 2, 4]); /// ``` pub fn from_elem(shape: Sh, elem: A) -> Self @@ -274,10 +274,10 @@ impl ArrayBase /// use ndarray::ShapeBuilder; // Needed for .strides() method /// use ndarray::arr2; /// - /// let a = Array::from_shape_vec((2, 2), vec![1., 2., 3., 4.]); + /// let a = Array::from_shape_vec([2, 2], vec![1., 2., 3., 4.]); /// assert!(a.is_ok()); /// - /// let b = Array::from_shape_vec((2, 2).strides((1, 2)), + /// let b = Array::from_shape_vec([2, 2].strides([1, 2]), /// vec![1., 2., 3., 4.]).unwrap(); /// assert!( /// b == arr2(&[[1., 3.], @@ -389,7 +389,7 @@ impl ArrayBase /// } /// /// # fn main() { - /// # shift_by_two(&Array2::zeros((8, 8))); + /// # shift_by_two(&Array2::zeros([8, 8])); /// # } /// ``` pub unsafe fn uninitialized(shape: Sh) -> Self diff --git a/src/impl_methods.rs b/src/impl_methods.rs index 6192c54ef..27f74c475 100644 --- a/src/impl_methods.rs +++ b/src/impl_methods.rs @@ -79,7 +79,7 @@ where /// an integer in the one-dimensional case, tuple in the n-dimensional cases /// and so on. pub fn dim(&self) -> D::Pattern { - self.dim.clone().into_pattern() + self.dim.to_pattern() } /// Return the shape of the array as it stored in the array. @@ -91,7 +91,7 @@ where /// ``` /// use ndarray::Array; /// - /// let a = Array::from_elem((2, 3), 5.); + /// let a = Array::from_elem([2, 3], 5.); /// /// // Create an array of zeros that's the same shape and dimensionality as `a`. /// let b = Array::::zeros(a.raw_dim()); @@ -112,7 +112,7 @@ where /// ```rust /// use ndarray::{Array, Array2}; /// - /// let a = Array2::::zeros((3, 4)); + /// let a = Array2::::zeros([3, 4]); /// let shape = a.shape(); /// assert_eq!(shape, &[3, 4]); /// @@ -180,7 +180,7 @@ where /// /// ``` /// # use ndarray::prelude::*; - /// # let arr = Array::from_shape_vec((2, 2).f(), vec![1, 2, 3, 4]).unwrap(); + /// # let arr = Array::from_shape_vec([2, 2].f(), vec![1, 2, 3, 4]).unwrap(); /// # let owned = { /// Array::from_shape_vec(arr.raw_dim(), arr.iter().cloned().collect()).unwrap() /// # }; @@ -192,7 +192,7 @@ where /// /// ``` /// # use ndarray::prelude::*; - /// # let arr = Array::from_shape_vec((2, 2), vec![1, 2, 3, 4]).unwrap(); + /// # let arr = Array::from_shape_vec([2, 2], vec![1, 2, 3, 4]).unwrap(); /// # let owned = { /// Array::from_shape_vec(arr.raw_dim().f(), arr.t().iter().cloned().collect()).unwrap() /// # }; @@ -501,9 +501,8 @@ where /// [3., 4.]]); /// /// assert!( - /// a.get((0, 1)) == Some(&2.) && - /// a.get((0, 2)) == None && - /// a[(0, 1)] == 2. && + /// a.get([0, 1]) == Some(&2.) && + /// a.get([0, 2]) == None && /// a[[0, 1]] == 2. /// ); /// ``` @@ -1020,7 +1019,7 @@ where /// use ndarray::Array; /// use ndarray::{arr3, Axis}; /// - /// let a = Array::from_iter(0..28).into_shape((2, 7, 2)).unwrap(); + /// let a = Array::from_iter(0..28).into_shape([2, 7, 2]).unwrap(); /// let mut iter = a.axis_chunks_iter(Axis(1), 2); /// /// // first iteration yields a 2 × 2 × 2 view @@ -1086,10 +1085,10 @@ where /// ```rust /// use ndarray::Array; /// use ndarray::arr2; - /// let mut a = Array::zeros((6, 7)); + /// let mut a = Array::zeros([6, 7]); /// /// // Fill each 2 × 2 chunk with the index of where it appeared in iteration - /// for (i, mut chunk) in a.exact_chunks_mut((2, 2)).into_iter().enumerate() { + /// for (i, mut chunk) in a.exact_chunks_mut([2, 2]).into_iter().enumerate() { /// chunk.fill(i); /// } /// @@ -1342,7 +1341,7 @@ where /// use ndarray::{aview1, aview2}; /// /// assert!( - /// aview1(&[1., 2., 3., 4.]).into_shape((2, 2)).unwrap() + /// aview1(&[1., 2., 3., 4.]).into_shape([2, 2]).unwrap() /// == aview2(&[[1., 2.], /// [3., 4.]]) /// ); @@ -1389,7 +1388,7 @@ where /// use ndarray::{rcarr1, rcarr2}; /// /// assert!( - /// rcarr1(&[1., 2., 3., 4.]).reshape((2, 2)) + /// rcarr1(&[1., 2., 3., 4.]).reshape([2, 2]) /// == rcarr2(&[[1., 2.], /// [3., 4.]]) /// ); @@ -1494,7 +1493,7 @@ where /// use ndarray::{aview1, aview2}; /// /// assert!( - /// aview1(&[1., 0.]).broadcast((10, 2)).unwrap() + /// aview1(&[1., 0.]).broadcast([10, 2]).unwrap() /// == aview2(&[[1., 0.]; 10]) /// ); /// ``` @@ -1600,7 +1599,7 @@ where /// let a = arr2(&[[0, 1], [2, 3]]); /// assert_eq!(a.view().permuted_axes([1, 0]), a.t()); /// - /// let b = Array3::::zeros((1, 2, 3)); + /// let b = Array3::::zeros([1, 2, 3]); /// assert_eq!(b.permuted_axes([1, 0, 2]).shape(), &[2, 1, 3]); /// ``` pub fn permuted_axes(self, axes: T) -> ArrayBase @@ -1717,7 +1716,7 @@ where /// use ndarray::Array3; /// use ndarray::Axis; /// - /// let mut a = Array3::::zeros((2, 3, 4)); + /// let mut a = Array3::::zeros([2, 3, 4]); /// assert!(a.merge_axes(Axis(1), Axis(2))); /// assert_eq!(a.shape(), &[2, 1, 12]); /// ``` @@ -1743,7 +1742,7 @@ where /// assert_eq!(col, arr2(&[[1], [2], [3]])); /// /// // The new axis always has length 1. - /// let b = Array3::::zeros((3, 4, 5)); + /// let b = Array3::::zeros([3, 4, 5]); /// assert_eq!(b.insert_axis(Axis(2)).shape(), &[3, 4, 1, 5]); /// ``` /// diff --git a/src/impl_views.rs b/src/impl_views.rs index e4ac909db..b8002a2f7 100644 --- a/src/impl_views.rs +++ b/src/impl_views.rs @@ -39,7 +39,7 @@ impl<'a, A, D> ArrayView<'a, A, D> /// use ndarray::ShapeBuilder; /// /// let s = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]; - /// let a = ArrayView::from_shape((2, 3, 2).strides((1, 4, 2)), + /// let a = ArrayView::from_shape([2, 3, 2].strides([1, 4, 2]), /// &s).unwrap(); /// /// assert!( @@ -182,7 +182,7 @@ impl<'a, A, D> ArrayView<'a, A, D> /// let data = [0.; 256]; /// let long_life_ref = { /// // make a 16 × 16 array view -/// let view = ArrayView::from(&data[..]).into_shape((16, 16)).unwrap(); +/// let view = ArrayView::from(&data[..]).into_shape([16, 16]).unwrap(); /// /// // index the view and with `IndexLonger`. /// // Note here that we get a reference with a life that is derived from @@ -308,7 +308,7 @@ impl<'a, A, D> ArrayViewMut<'a, A, D> /// use ndarray::ShapeBuilder; /// /// let mut s = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]; - /// let mut a = ArrayViewMut::from_shape((2, 3, 2).strides((1, 4, 2)), + /// let mut a = ArrayViewMut::from_shape([2, 3, 2].strides([1, 4, 2]), /// &mut s).unwrap(); /// /// a[[0, 0, 0]] = 1; diff --git a/src/indexes.rs b/src/indexes.rs index 3c83ad510..c0709be26 100644 --- a/src/indexes.rs +++ b/src/indexes.rs @@ -57,7 +57,7 @@ impl Iterator for IndicesIter Some(ref ix) => ix.clone(), }; self.index = self.dim.next_for(index.clone()); - Some(index.into_pattern()) + Some(index.to_pattern()) } fn size_hint(&self) -> (usize, Option) { @@ -161,7 +161,7 @@ impl NdProducer for Indices { #[doc(hidden)] unsafe fn as_ref(&self, ptr: Self::Ptr) -> Self::Item { - ptr.index.into_pattern() + ptr.index.to_pattern() } #[doc(hidden)] @@ -227,7 +227,7 @@ impl Iterator for IndicesIterF if !self.has_remaining { None } else { - let elt = self.index.clone().into_pattern(); + let elt = self.index.to_pattern(); self.has_remaining = self.dim.next_for_f(&mut self.index); Some(elt) } @@ -264,9 +264,9 @@ mod tests { #[test] fn test_indices_iter_c_size_hint() { - let dim = (3, 4); + let dim = [3, 4]; let mut it = indices(dim).into_iter(); - let mut len = dim.0 * dim.1; + let mut len = dim.iter().product(); assert_eq!(it.len(), len); while let Some(_) = it.next() { len -= 1; @@ -277,9 +277,9 @@ mod tests { #[test] fn test_indices_iter_f_size_hint() { - let dim = (3, 4); + let dim = [3, 4]; let mut it = indices_iter_f(dim); - let mut len = dim.0 * dim.1; + let mut len = dim.iter().product(); assert_eq!(it.len(), len); while let Some(_) = it.next() { len -= 1; diff --git a/src/iterators/mod.rs b/src/iterators/mod.rs index c7e153864..2e05751b3 100644 --- a/src/iterators/mod.rs +++ b/src/iterators/mod.rs @@ -471,7 +471,7 @@ impl<'a, A, D: Dimension> Iterator for IndexedIter<'a, A, D> { }; match self.0.next() { None => None, - Some(elem) => Some((index.into_pattern(), elem)), + Some(elem) => Some((index.to_pattern(), elem)), } } @@ -629,7 +629,7 @@ impl<'a, A, D: Dimension> Iterator for IndexedIterMut<'a, A, D> { }; match self.0.next() { None => None, - Some(elem) => Some((index.into_pattern(), elem)), + Some(elem) => Some((index.to_pattern(), elem)), } } diff --git a/src/lib.rs b/src/lib.rs index 8b44c21d2..b9b31f923 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -271,7 +271,7 @@ pub type Ixs = isize; /// ``` /// // Create a three-dimensional f64 array, initialized with zeros /// use ndarray::Array3; -/// let mut temperature = Array3::::zeros((3, 4, 5)); +/// let mut temperature = Array3::::zeros([3, 4, 5]); /// // Increase the temperature in this location /// temperature[[2, 2, 2]] += 0.5; /// ``` @@ -336,7 +336,7 @@ pub type Ixs = isize; /// /// ``` /// use ndarray::Array2; -/// let mut array = Array2::zeros((4, 3)); +/// let mut array = Array2::zeros([4, 3]); /// array[[1, 1]] = 7; /// ``` /// @@ -409,14 +409,14 @@ pub type Ixs = isize; /// use ndarray::Array; /// /// // 1. Loop over the rows of a 2D array -/// let mut a = Array::zeros((10, 10)); +/// let mut a = Array::zeros([10, 10]); /// for mut row in a.genrows_mut() { /// row.fill(1.); /// } /// /// // 2. Use Zip to pair each row in 2D `a` with elements in 1D `b` /// use ndarray::Zip; -/// let mut b = Array::zeros(a.rows()); +/// let mut b = Array::zeros([a.rows()]); /// /// Zip::from(a.genrows()) /// .and(&mut b) @@ -982,7 +982,7 @@ pub type Ixs = isize; /// ```rust /// use ndarray::{array, Array2, Axis}; /// -/// let mut arr = Array2::zeros((2, 3)); +/// let mut arr = Array2::zeros([2, 3]); /// for (i, mut row) in arr.axis_iter_mut(Axis(0)).enumerate() { /// // Perform calculations and assign to `row`; this is a trivial example: /// row.fill(i); @@ -1010,7 +1010,7 @@ pub type Ixs = isize; /// data.extend_from_slice(&row); /// nrows += 1; /// } -/// let arr = Array2::from_shape_vec((nrows, ncols), data)?; +/// let arr = Array2::from_shape_vec([nrows, ncols], data)?; /// assert_eq!(arr, array![[0, 0, 0], [1, 1, 1]]); /// # Ok(()) /// # } @@ -1031,8 +1031,8 @@ pub type Ixs = isize; /// array![[1, 2, 3], [4, 5, 6]], /// array![[7, 8, 9], [10, 11, 12]], /// ]; -/// let inner_shape = nested[0].dim(); -/// let shape = (nested.len(), inner_shape.0, inner_shape.1); +/// let [rows, cols] = nested[0].dim(); +/// let shape = [nested.len(), rows, cols]; /// let flat: Vec = nested.iter().flatten().cloned().collect(); /// let arr = Array3::from_shape_vec(shape, flat)?; /// assert_eq!(arr, array![ diff --git a/src/linalg/impl_linalg.rs b/src/linalg/impl_linalg.rs index 6e8bbca44..3844a81b2 100644 --- a/src/linalg/impl_linalg.rs +++ b/src/linalg/impl_linalg.rs @@ -79,7 +79,7 @@ impl ArrayBase let mut sum = A::zero(); for i in 0..self.len() { unsafe { - sum = sum.clone() + self.uget(i).clone() * rhs.uget(i).clone(); + sum = sum.clone() + self.uget([i]).clone() * rhs.uget([i]).clone(); } } sum @@ -256,7 +256,7 @@ impl Dot> for ArrayBase { let a = self.view(); let b = b.view(); - let ((m, k), (k2, n)) = (a.dim(), b.dim()); + let ([m, k], [k2, n]) = (a.dim(), b.dim()); if k != k2 || m.checked_mul(n).is_none() { dot_shape_error(m, k, k2, n); } @@ -269,7 +269,7 @@ impl Dot> for ArrayBase let mut c; unsafe { v.set_len(m * n); - c = Array::from_shape_vec_unchecked((m, n).set_f(column_major), v); + c = Array::from_shape_vec_unchecked([m, n].set_f(column_major), v); } mat_mul_impl(A::one(), &a, &b, A::zero(), &mut c.view_mut()); c @@ -312,14 +312,14 @@ impl Dot> for ArrayBase type Output = Array; fn dot(&self, rhs: &ArrayBase) -> Array { - let ((m, a), n) = (self.dim(), rhs.dim()); + let ([m, a], [n]) = (self.dim(), rhs.dim()); if a != n { dot_shape_error(m, a, n, 1); } // Avoid initializing the memory in vec -- set it during iteration unsafe { - let mut c = Array::uninitialized(m); + let mut c = Array::uninitialized([m]); general_mat_vec_mul(A::one(), self, rhs, A::zero(), &mut c); c } @@ -362,7 +362,7 @@ fn mat_mul_impl(alpha: A, { // size cutoff for using BLAS let cut = GEMM_BLAS_CUTOFF; - let ((mut m, a), (_, mut n)) = (lhs.dim(), rhs.dim()); + let ([mut m, a], [_, mut n]) = (lhs.dim(), rhs.dim()); if !(m > cut || n > cut || a > cut) || !(same_type::() || same_type::()) { return mat_mul_general(alpha, lhs, rhs, beta, c); @@ -400,11 +400,11 @@ fn mat_mul_impl(alpha: A, && blas_row_major_2d::<$ty, _>(&rhs_) && blas_row_major_2d::<$ty, _>(&c_) { - let (m, k) = match lhs_trans { + let [m, k] = match lhs_trans { CblasNoTrans => lhs_.dim(), _ => { - let (rows, cols) = lhs_.dim(); - (cols, rows) + let [rows, cols] = lhs_.dim(); + [cols, rows] } }; let n = match rhs_trans { @@ -454,7 +454,7 @@ fn mat_mul_general(alpha: A, c: &mut ArrayViewMut2) where A: LinalgScalar, { - let ((m, k), (_, n)) = (lhs.dim(), rhs.dim()); + let ([m, k], [_, n]) = (lhs.dim(), rhs.dim()); // common parameters for gemm let ap = lhs.as_ptr(); @@ -508,9 +508,9 @@ fn mat_mul_general(alpha: A, let mut j = 0; loop { unsafe { - let elt = c.uget_mut((i, j)); + let elt = c.uget_mut([i, j]); *elt = *elt * beta + alpha * (0..k).fold(A::zero(), - move |s, x| s + *lhs.uget((i, x)) * *rhs.uget((x, j))); + move |s, x| s + *lhs.uget([i, x]) * *rhs.uget([x, j])); } j += 1; if j == n { @@ -545,8 +545,8 @@ pub fn general_mat_mul(alpha: A, S3: DataMut, A: LinalgScalar, { - let ((m, k), (k2, n)) = (a.dim(), b.dim()); - let (m2, n2) = c.dim(); + let ([m, k], [k2, n]) = (a.dim(), b.dim()); + let [m2, n2] = c.dim(); if k != k2 || m != m2 || n != n2 { general_dot_shape_error(m, k, k2, n, m2, n2); } else { @@ -574,8 +574,8 @@ pub fn general_mat_vec_mul(alpha: A, S3: DataMut, A: LinalgScalar, { - let ((m, k), k2) = (a.dim(), x.dim()); - let m2 = y.dim(); + let ([m, k], [k2]) = (a.dim(), x.dim()); + let [m2] = y.dim(); if k != k2 || m != m2 { general_dot_shape_error(m, k, k2, 1, m2, 1); } else { @@ -707,7 +707,7 @@ fn blas_column_major_2d(a: &ArrayBase) -> bool #[cfg(feature="blas")] fn is_blas_2d(dim: &Ix2, stride: &Ix2, order: MemoryOrder) -> bool { - let (m, n) = dim.into_pattern(); + let [m, n] = dim.to_pattern(); let s0 = stride[0] as isize; let s1 = stride[1] as isize; let (inner_stride, outer_dim) = match order { @@ -755,28 +755,28 @@ mod blas_tests { #[test] fn blas_row_major_2d_normal_matrix() { - let m: Array2 = Array2::zeros((3, 5)); + let m: Array2 = Array2::zeros([3, 5]); assert!(blas_row_major_2d::(&m)); assert!(!blas_column_major_2d::(&m)); } #[test] fn blas_row_major_2d_row_matrix() { - let m: Array2 = Array2::zeros((1, 5)); + let m: Array2 = Array2::zeros([1, 5]); assert!(blas_row_major_2d::(&m)); assert!(blas_column_major_2d::(&m)); } #[test] fn blas_row_major_2d_column_matrix() { - let m: Array2 = Array2::zeros((5, 1)); + let m: Array2 = Array2::zeros([5, 1]); assert!(blas_row_major_2d::(&m)); assert!(blas_column_major_2d::(&m)); } #[test] fn blas_row_major_2d_transposed_row_matrix() { - let m: Array2 = Array2::zeros((1, 5)); + let m: Array2 = Array2::zeros([1, 5]); let m_t = m.t(); assert!(blas_row_major_2d::(&m_t)); assert!(blas_column_major_2d::(&m_t)); @@ -784,7 +784,7 @@ mod blas_tests { #[test] fn blas_row_major_2d_transposed_column_matrix() { - let m: Array2 = Array2::zeros((5, 1)); + let m: Array2 = Array2::zeros([5, 1]); let m_t = m.t(); assert!(blas_row_major_2d::(&m_t)); assert!(blas_column_major_2d::(&m_t)); @@ -792,7 +792,7 @@ mod blas_tests { #[test] fn blas_column_major_2d_normal_matrix() { - let m: Array2 = Array2::zeros((3, 5).f()); + let m: Array2 = Array2::zeros([3, 5].f()); assert!(!blas_row_major_2d::(&m)); assert!(blas_column_major_2d::(&m)); } diff --git a/src/parallel/mod.rs b/src/parallel/mod.rs index 6bb93901d..d8483325e 100644 --- a/src/parallel/mod.rs +++ b/src/parallel/mod.rs @@ -42,7 +42,7 @@ //! use ndarray::parallel::prelude::*; //! //! fn main() { -//! let mut a = Array2::::zeros((128, 128)); +//! let mut a = Array2::::zeros([128, 128]); //! //! // Parallel versions of regular array methods //! a.par_map_inplace(|x| *x = x.exp()); @@ -65,7 +65,7 @@ //! use ndarray::parallel::prelude::*; //! //! fn main() { -//! let a = Array::linspace(0., 63., 64).into_shape((4, 16)).unwrap(); +//! let a = Array::linspace(0., 63., 64).into_shape([4, 16]).unwrap(); //! let mut sums = Vec::new(); //! a.axis_iter(Axis(0)) //! .into_par_iter() @@ -90,7 +90,7 @@ //! //! fn main() { //! const N: usize = 128; -//! let a = Array3f64::from_elem((N, N, N), 1.); +//! let a = Array3f64::from_elem([N, N, N], 1.); //! let b = Array3f64::from_elem(a.dim(), 2.); //! let mut c = Array3f64::zeros(a.dim()); //! diff --git a/src/parallel/zipmacro.rs b/src/parallel/zipmacro.rs index a61ae88d4..44d6c1205 100644 --- a/src/parallel/zipmacro.rs +++ b/src/parallel/zipmacro.rs @@ -40,7 +40,7 @@ /// type M = Array2; /// /// fn main() { -/// let mut a = M::zeros((16, 16)); +/// let mut a = M::zeros([16, 16]); /// let b = M::from_elem(a.dim(), 1.); /// let c = M::from_elem(a.dim(), 2.); /// diff --git a/src/zip/mod.rs b/src/zip/mod.rs index fc8b99c7d..437f61280 100644 --- a/src/zip/mod.rs +++ b/src/zip/mod.rs @@ -412,7 +412,7 @@ impl<'a, A, D: Dimension> NdProducer for ArrayViewMut<'a, A, D> { /// type M = Array2; /// /// // Create four 2d arrays of the same size -/// let mut a = M::zeros((64, 32)); +/// let mut a = M::zeros([64, 32]); /// let b = M::from_elem(a.dim(), 1.); /// let c = M::from_elem(a.dim(), 2.); /// let d = M::from_elem(a.dim(), 3.); @@ -437,7 +437,7 @@ impl<'a, A, D: Dimension> NdProducer for ArrayViewMut<'a, A, D> { /// /// use ndarray::{Array1, Axis}; /// -/// let mut totals = Array1::zeros(a.rows()); +/// let mut totals = Array1::zeros([a.rows()]); /// /// Zip::from(&mut totals) /// .and(a.genrows()) diff --git a/src/zip/zipmacro.rs b/src/zip/zipmacro.rs index c836ed52f..f8c6ee19b 100644 --- a/src/zip/zipmacro.rs +++ b/src/zip/zipmacro.rs @@ -57,13 +57,13 @@ /// /// fn main() { /// // Setup example arrays -/// let mut a = M::zeros((16, 16)); +/// let mut a = M::zeros([16, 16]); /// let mut b = M::zeros(a.dim()); /// let mut c = M::zeros(a.dim()); /// /// // assign values /// b.fill(1.); -/// for ((i, j), elt) in c.indexed_iter_mut() { +/// for ([i, j], elt) in c.indexed_iter_mut() { /// *elt = (i + 10 * j) as f32; /// } /// @@ -74,7 +74,7 @@ /// assert_eq!(a, &b + &c); /// /// // Example 2: azip!() with index -/// azip!(index (i, j), b, c in { +/// azip!(index [i, j], b, c in { /// a[[i, j]] = b - c; /// }); /// @@ -103,7 +103,7 @@ /// // /// // The row is an array view; use the 'ref' rule on the row, to avoid the /// // default which is to dereference the produced item. -/// let mut totals = Array1::zeros(a.rows()); +/// let mut totals = Array1::zeros([a.rows()]); /// /// azip!(mut totals, ref row (a.genrows()) in { /// *totals = row.sum(); diff --git a/tests/array-construct.rs b/tests/array-construct.rs index 7e320c314..3f642a708 100644 --- a/tests/array-construct.rs +++ b/tests/array-construct.rs @@ -7,8 +7,8 @@ use ndarray::prelude::*; #[test] fn test_from_shape_fn() { let step = 3.1; - let h = Array::from_shape_fn((5, 5), - |(i, j)| f64::sin(i as f64 / step) * f64::cos(j as f64 / step)); + let h = Array::from_shape_fn([5, 5], + |[i, j]| f64::sin(i as f64 / step) * f64::cos(j as f64 / step)); assert_eq!(h.shape(), &[5, 5]); } @@ -22,7 +22,7 @@ fn test_dimension_zero() { #[test] fn test_arc_into_owned() { - let a = Array2::from_elem((5, 5), 1.).into_shared(); + let a = Array2::from_elem([5, 5], 1.).into_shared(); let mut b = a.clone(); b.fill(0.); let mut c = b.into_owned(); @@ -35,7 +35,7 @@ fn test_arc_into_owned() { fn test_arcarray_thread_safe() { fn is_send(_t: &T) { } fn is_sync(_t: &T) { } - let a = Array2::from_elem((5, 5), 1.).into_shared(); + let a = Array2::from_elem([5, 5], 1.).into_shared(); is_send(&a); is_sync(&a); @@ -44,8 +44,8 @@ fn test_arcarray_thread_safe() { #[test] fn test_uninit() { unsafe { - let mut a = Array::::uninitialized((3, 4).f()); - assert_eq!(a.dim(), (3, 4)); + let mut a = Array::::uninitialized([3, 4].f()); + assert_eq!(a.dim(), [3, 4]); assert_eq!(a.strides(), &[1, 3]); let b = Array::::linspace(0., 25., a.len()).into_shape(a.dim()).unwrap(); a.assign(&b); @@ -56,15 +56,15 @@ fn test_uninit() { #[test] fn test_from_fn_c0() { - let a = Array::from_shape_fn((), |i| i); - assert_eq!(a[()], ()); + let a = Array::from_shape_fn([], |i| i); + assert_eq!(a[()], []); assert_eq!(a.len(), 1); assert_eq!(a.shape(), &[]); } #[test] fn test_from_fn_c1() { - let a = Array::from_shape_fn(28, |i| i); + let a = Array::from_shape_fn([28], |i| i); for (i, elt) in a.indexed_iter() { assert_eq!(i, *elt); } @@ -72,7 +72,7 @@ fn test_from_fn_c1() { #[test] fn test_from_fn_c() { - let a = Array::from_shape_fn((4, 7), |i| i); + let a = Array::from_shape_fn([4, 7], |i| i); for (i, elt) in a.indexed_iter() { assert_eq!(i, *elt); } @@ -80,7 +80,7 @@ fn test_from_fn_c() { #[test] fn test_from_fn_c3() { - let a = Array::from_shape_fn((4, 3, 7), |i| i); + let a = Array::from_shape_fn([4, 3, 7], |i| i); for (i, elt) in a.indexed_iter() { assert_eq!(i, *elt); } @@ -88,15 +88,15 @@ fn test_from_fn_c3() { #[test] fn test_from_fn_f0() { - let a = Array::from_shape_fn(().f(), |i| i); - assert_eq!(a[()], ()); + let a = Array::from_shape_fn([].f(), |i| i); + assert_eq!(a[()], []); assert_eq!(a.len(), 1); assert_eq!(a.shape(), &[]); } #[test] fn test_from_fn_f1() { - let a = Array::from_shape_fn(28.f(), |i| i); + let a = Array::from_shape_fn([28].f(), |i| i); for (i, elt) in a.indexed_iter() { assert_eq!(i, *elt); } @@ -104,7 +104,7 @@ fn test_from_fn_f1() { #[test] fn test_from_fn_f() { - let a = Array::from_shape_fn((4, 7).f(), |i| i); + let a = Array::from_shape_fn([4, 7].f(), |i| i); for (i, elt) in a.indexed_iter() { assert_eq!(i, *elt); } @@ -127,7 +127,7 @@ fn test_from_fn_f_with_zero() { #[test] fn test_from_fn_f3() { - let a = Array::from_shape_fn((4, 2, 7).f(), |i| i); + let a = Array::from_shape_fn([4, 2, 7].f(), |i| i); for (i, elt) in a.indexed_iter() { assert_eq!(i, *elt); } @@ -136,17 +136,17 @@ fn test_from_fn_f3() { #[test] fn deny_wraparound_from_vec() { let five = vec![0; 5]; - let five_large = Array::from_shape_vec((3, 7, 29, 36760123, 823996703), five.clone()); + let five_large = Array::from_shape_vec([3, 7, 29, 36760123, 823996703], five.clone()); assert!(five_large.is_err()); - let six = Array::from_shape_vec(6, five.clone()); + let six = Array::from_shape_vec([6], five.clone()); assert!(six.is_err()); } #[test] fn test_ones() { - let mut a = Array::::zeros((2, 3, 4)); + let mut a = Array::::zeros([2, 3, 4]); a.fill(1.0); - let b = Array::::ones((2, 3, 4)); + let b = Array::::ones([2, 3, 4]); assert_eq!(a, b); } @@ -154,33 +154,33 @@ fn test_ones() { #[test] fn deny_wraparound_zeros() { //2^64 + 5 = 18446744073709551621 = 3×7×29×36760123×823996703 (5 distinct prime factors) - let _five_large = Array::::zeros((3, 7, 29, 36760123, 823996703)); + let _five_large = Array::::zeros([3, 7, 29, 36760123, 823996703]); } #[should_panic] #[test] fn deny_wraparound_reshape() { //2^64 + 5 = 18446744073709551621 = 3×7×29×36760123×823996703 (5 distinct prime factors) - let five = Array::::zeros(5); - let _five_large = five.into_shape((3, 7, 29, 36760123, 823996703)).unwrap(); + let five = Array::::zeros([5]); + let _five_large = five.into_shape([3, 7, 29, 36760123, 823996703]).unwrap(); } #[should_panic] #[test] fn deny_wraparound_default() { - let _five_large = Array::::default((3, 7, 29, 36760123, 823996703)); + let _five_large = Array::::default([3, 7, 29, 36760123, 823996703]); } #[should_panic] #[test] fn deny_wraparound_from_shape_fn() { - let _five_large = Array::::from_shape_fn((3, 7, 29, 36760123, 823996703), |_| 0.); + let _five_large = Array::::from_shape_fn([3, 7, 29, 36760123, 823996703], |_| 0.); } #[should_panic] #[test] fn deny_wraparound_uninit() { unsafe { - let _five_large = Array::::uninitialized((3, 7, 29, 36760123, 823996703)); + let _five_large = Array::::uninitialized([3, 7, 29, 36760123, 823996703]); } } diff --git a/tests/array.rs b/tests/array.rs index ef5b1058d..18b7d382f 100644 --- a/tests/array.rs +++ b/tests/array.rs @@ -32,12 +32,12 @@ macro_rules! assert_panics { #[test] fn test_matmul_arcarray() { - let mut A = ArcArray::::zeros((2, 3)); + let mut A = ArcArray::::zeros([2, 3]); for (i, elt) in A.iter_mut().enumerate() { *elt = i; } - let mut B = ArcArray::::zeros((3, 4)); + let mut B = ArcArray::::zeros([3, 4]); for (i, elt) in B.iter_mut().enumerate() { *elt = i; } @@ -47,7 +47,7 @@ fn test_matmul_arcarray() println!("B = \n{:?}", B); println!("A x B = \n{:?}", c); unsafe { - let result = ArcArray::from_shape_vec_unchecked((2, 4), vec![20, 23, 26, 29, 56, 68, 80, 92]); + let result = ArcArray::from_shape_vec_unchecked([2, 4], vec![20, 23, 26, 29, 56, 68, 80, 92]); assert_eq!(c.shape(), result.shape()); assert!(c.iter().zip(result.iter()).all(|(a,b)| a == b)); assert!(c == result); @@ -71,8 +71,8 @@ fn arrayviewmut_shrink_lifetime<'a, 'b: 'a>(view: ArrayViewMut1<'b, f64>) #[test] fn test_mat_mul() { // smoke test, a big matrix multiplication of uneven size - let (n, m) = (45, 33); - let a = ArcArray::linspace(0., ((n * m) - 1) as f32, n as usize * m as usize ).reshape((n, m)); + let [n, m] = [45, 33]; + let a = ArcArray::linspace(0., ((n * m) - 1) as f32, n as usize * m as usize ).reshape([n, m]); let b = ArcArray::eye(m); assert_eq!(a.dot(&b), a); let c = ArcArray::eye(n); @@ -84,7 +84,7 @@ fn test_mat_mul() { #[test] fn test_slice() { - let mut A = ArcArray::::zeros((3, 4, 5)); + let mut A = ArcArray::::zeros([3, 4, 5]); for (i, elt) in A.iter_mut().enumerate() { *elt = i; } @@ -182,7 +182,7 @@ fn test_slice_args_eval_step_once() { #[test] fn test_slice_array_fixed() { - let mut arr = Array3::::zeros((5, 2, 5)); + let mut arr = Array3::::zeros([5, 2, 5]); let info = s![1.., 1, ..;2]; arr.slice(info); arr.slice_mut(info); @@ -192,7 +192,7 @@ fn test_slice_array_fixed() { #[test] fn test_slice_dyninput_array_fixed() { - let mut arr = Array3::::zeros((5, 2, 5)).into_dyn(); + let mut arr = Array3::::zeros([5, 2, 5]).into_dyn(); let info = s![1.., 1, ..;2]; arr.slice(info); arr.slice_mut(info); @@ -202,7 +202,7 @@ fn test_slice_dyninput_array_fixed() { #[test] fn test_slice_array_dyn() { - let mut arr = Array3::::zeros((5, 2, 5)); + let mut arr = Array3::::zeros([5, 2, 5]); let info = &SliceInfo::<_, IxDyn>::new([ SliceOrIndex::from(1..), SliceOrIndex::from(1), @@ -216,7 +216,7 @@ fn test_slice_array_dyn() { #[test] fn test_slice_dyninput_array_dyn() { - let mut arr = Array3::::zeros((5, 2, 5)).into_dyn(); + let mut arr = Array3::::zeros([5, 2, 5]).into_dyn(); let info = &SliceInfo::<_, IxDyn>::new([ SliceOrIndex::from(1..), SliceOrIndex::from(1), @@ -230,7 +230,7 @@ fn test_slice_dyninput_array_dyn() { #[test] fn test_slice_dyninput_vec_fixed() { - let mut arr = Array3::::zeros((5, 2, 5)).into_dyn(); + let mut arr = Array3::::zeros([5, 2, 5]).into_dyn(); let info = &SliceInfo::<_, Ix2>::new(vec![ SliceOrIndex::from(1..), SliceOrIndex::from(1), @@ -244,7 +244,7 @@ fn test_slice_dyninput_vec_fixed() { #[test] fn test_slice_dyninput_vec_dyn() { - let mut arr = Array3::::zeros((5, 2, 5)).into_dyn(); + let mut arr = Array3::::zeros([5, 2, 5]).into_dyn(); let info = &SliceInfo::<_, IxDyn>::new(vec![ SliceOrIndex::from(1..), SliceOrIndex::from(1), @@ -258,7 +258,7 @@ fn test_slice_dyninput_vec_dyn() { #[test] fn test_slice_with_subview() { - let mut arr = ArcArray::::zeros((3, 5, 4)); + let mut arr = ArcArray::::zeros([3, 5, 4]); for (i, elt) in arr.iter_mut().enumerate() { *elt = i; } @@ -286,12 +286,12 @@ fn test_slice_with_subview() { let vi = arr.slice(s![1, 2, 3]); assert_eq!(vi.shape(), &[]); - assert_eq!(vi, Array0::from_elem((), arr[(1, 2, 3)])); + assert_eq!(vi, Array0::from_elem([], arr[[1, 2, 3]])); } #[test] fn test_slice_collapse_with_indices() { - let mut arr = ArcArray::::zeros((3, 5, 4)); + let mut arr = ArcArray::::zeros([3, 5, 4]); for (i, elt) in arr.iter_mut().enumerate() { *elt = i; } @@ -318,15 +318,15 @@ fn test_slice_collapse_with_indices() { let mut vi = arr.view(); vi.slice_collapse(s![1, 2, 3]); assert_eq!(vi.shape(), &[1, 1, 1]); - assert_eq!(vi, Array3::from_elem((1, 1, 1), arr[(1, 2, 3)])); + assert_eq!(vi, Array3::from_elem([1, 1, 1], arr[[1, 2, 3]])); } // Do it to the ArcArray itself - let elem = arr[(1, 2, 3)]; + let elem = arr[[1, 2, 3]]; let mut vi = arr; vi.slice_collapse(s![1, 2, 3]); assert_eq!(vi.shape(), &[1, 1, 1]); - assert_eq!(vi, Array3::from_elem((1, 1, 1), elem)); + assert_eq!(vi, Array3::from_elem([1, 1, 1], elem)); } #[test] @@ -361,7 +361,7 @@ fn test_multislice() { ); } }); - let mut arr = Array1::from_iter(0..48).into_shape((8, 6)).unwrap(); + let mut arr = Array1::from_iter(0..48).into_shape([8, 6]).unwrap(); assert_eq!((arr.clone().view(),), multislice!(arr, [.., ..])); test_multislice!(&mut arr, s![0, ..], s![1, ..]); @@ -377,34 +377,34 @@ fn test_multislice() { #[test] fn test_multislice_intersecting() { assert_panics!({ - let mut arr = Array2::::zeros((8, 6)); + let mut arr = Array2::::zeros([8, 6]); multislice!(arr, mut [3, ..], [3, ..]); }); assert_panics!({ - let mut arr = Array2::::zeros((8, 6)); + let mut arr = Array2::::zeros([8, 6]); multislice!(arr, mut [3, ..], [3.., ..]); }); assert_panics!({ - let mut arr = Array2::::zeros((8, 6)); + let mut arr = Array2::::zeros([8, 6]); multislice!(arr, mut [3, ..], [..;3, ..]); }); assert_panics!({ - let mut arr = Array2::::zeros((8, 6)); + let mut arr = Array2::::zeros([8, 6]); multislice!(arr, mut [..;6, ..], [3..;3, ..]); }); assert_panics!({ - let mut arr = Array2::::zeros((8, 6)); + let mut arr = Array2::::zeros([8, 6]); multislice!(arr, mut [2, ..], mut [..-1;-2, ..]); }); { - let mut arr = Array2::::zeros((8, 6)); + let mut arr = Array2::::zeros([8, 6]); multislice!(arr, [3, ..], [-1..;-2, ..]); } } #[test] fn test_multislice_eval_args_only_once() { - let mut arr = Array1::::zeros(10); + let mut arr = Array1::::zeros([10]); let mut eval_count = 0; { let mut slice = || { @@ -464,7 +464,7 @@ fn test_multislice_eval_args_only_once() { #[should_panic] #[test] fn index_out_of_bounds() { - let mut a = Array::::zeros((3, 4)); + let mut a = Array::::zeros([3, 4]); a[[3, 2]] = 1; } @@ -472,14 +472,14 @@ fn index_out_of_bounds() { #[test] fn slice_oob() { - let a = ArcArray::::zeros((3, 4)); + let a = ArcArray::::zeros([3, 4]); let _vi = a.slice(s![..10, ..]); } #[should_panic] #[test] fn slice_axis_oob() { - let a = ArcArray::::zeros((3, 4)); + let a = ArcArray::::zeros([3, 4]); let _vi = a.slice_axis(Axis(0), Slice::new(0, Some(10), 1)); } @@ -494,18 +494,18 @@ fn slice_wrong_dim() #[test] fn test_index() { - let mut A = ArcArray::::zeros((2, 3)); + let mut A = ArcArray::::zeros([2, 3]); for (i, elt) in A.iter_mut().enumerate() { *elt = i; } - for ((i, j), a) in zip(indices((2, 3)), &A) { + for ([i, j], a) in zip(indices([2, 3]), &A) { assert_eq!(*a, A[[i, j]]); } let vi = A.slice(s![1.., ..;2]); let mut it = vi.iter(); - for ((i, j), x) in zip(indices((1, 2)), &mut it) { + for ([i, j], x) in zip(indices([1, 2]), &mut it) { assert_eq!(*x, vi[[i, j]]); } assert!(it.next().is_none()); @@ -515,16 +515,16 @@ fn test_index() fn test_index_arrays() { let a = Array1::from_iter(0..12); assert_eq!(a[1], a[[1]]); - let v = a.view().into_shape((3, 4)).unwrap(); + let v = a.view().into_shape([3, 4]).unwrap(); assert_eq!(a[1], v[[0, 1]]); - let w = v.into_shape((2, 2, 3)).unwrap(); + let w = v.into_shape([2, 2, 3]).unwrap(); assert_eq!(a[1], w[[0, 0, 1]]); } #[test] fn test_add() { - let mut A = ArcArray::::zeros((2, 2)); + let mut A = ArcArray::::zeros([2, 2]); for (i, elt) in A.iter_mut().enumerate() { *elt = i; } @@ -540,8 +540,8 @@ fn test_add() #[test] fn test_multidim() { - let mut mat = ArcArray::zeros(2*3*4*5*6).reshape((2,3,4,5,6)); - mat[(0,0,0,0,0)] = 22u8; + let mut mat = ArcArray::zeros([2*3*4*5*6]).reshape([2,3,4,5,6]); + mat[[0,0,0,0,0]] = 22u8; { for (i, elt) in mat.iter_mut().enumerate() { *elt = i as u8; @@ -565,7 +565,7 @@ array([[[ 7, 6], #[test] fn test_negative_stride_arcarray() { - let mut mat = ArcArray::zeros((2, 4, 2)); + let mut mat = ArcArray::zeros([2, 4, 2]); mat[[0, 0, 0]] = 1.0f32; for (i, elt) in mat.iter_mut().enumerate() { *elt = i as f32; @@ -592,7 +592,7 @@ fn test_negative_stride_arcarray() #[test] fn test_cow() { - let mut mat = ArcArray::zeros((2,2)); + let mut mat = ArcArray::zeros([2, 2]); mat[[0, 0]] = 1; let n = mat.clone(); mat[[0, 1]] = 2; @@ -602,8 +602,8 @@ fn test_cow() assert_eq!(mat[[0, 1]], 2); assert_eq!(n[[0, 0]], 1); assert_eq!(n[[0, 1]], 0); - assert_eq!(n.get((0, 1)), Some(&0)); - let mut rev = mat.reshape(4); + assert_eq!(n.get([0, 1]), Some(&0)); + let mut rev = mat.reshape([4]); rev.slice_collapse(s![..;-1]); assert_eq!(rev[0], 4); assert_eq!(rev[1], 3); @@ -628,7 +628,7 @@ fn test_cow_shrink() // A test for clone-on-write in the case that // mutation shrinks the array and gives it different strides // - let mut mat = ArcArray::zeros((2, 3)); + let mut mat = ArcArray::zeros([2, 3]); //mat.slice_collapse(s![.., ..;2]); mat[[0, 0]] = 1; let n = mat.clone(); @@ -641,9 +641,9 @@ fn test_cow_shrink() assert_eq!(mat[[0, 1]], 2); assert_eq!(n[[0, 0]], 1); assert_eq!(n[[0, 1]], 0); - assert_eq!(n.get((0, 1)), Some(&0)); + assert_eq!(n.get([0, 1]), Some(&0)); // small has non-C strides this way - let mut small = mat.reshape(6); + let mut small = mat.reshape([6]); small.slice_collapse(s![4..;-1]); assert_eq!(small[0], 6); assert_eq!(small[1], 5); @@ -660,21 +660,21 @@ fn test_cow_shrink() #[test] fn test_sub() { - let mat = ArcArray::linspace(0., 15., 16).reshape((2, 4, 2)); + let mat = ArcArray::linspace(0., 15., 16).reshape([2, 4, 2]); let s1 = mat.index_axis(Axis(0), 0); let s2 = mat.index_axis(Axis(0), 1); assert_eq!(s1.shape(), &[4, 2]); assert_eq!(s2.shape(), &[4, 2]); - let n = ArcArray::linspace(8., 15., 8).reshape((4,2)); + let n = ArcArray::linspace(8., 15., 8).reshape([4, 2]); assert_eq!(n, s2); - let m = ArcArray::from_vec(vec![2., 3., 10., 11.]).reshape((2, 2)); + let m = ArcArray::from_vec(vec![2., 3., 10., 11.]).reshape([2, 2]); assert_eq!(m, mat.index_axis(Axis(1), 1)); } #[should_panic] #[test] fn test_sub_oob_1() { - let mat = ArcArray::linspace(0., 15., 16).reshape((2, 4, 2)); + let mat = ArcArray::linspace(0., 15., 16).reshape([2, 4, 2]); mat.index_axis(Axis(0), 2); } @@ -709,14 +709,14 @@ fn test_select(){ fn diag() { let d = arr2(&[[1., 2., 3.0f32]]).into_diag(); - assert_eq!(d.dim(), 1); + assert_eq!(d.dim(), [1]); let a = arr2(&[[1., 2., 3.0f32], [0., 0., 0.]]); let d = a.view().into_diag(); - assert_eq!(d.dim(), 2); + assert_eq!(d.dim(), [2]); let d = arr2::(&[[]]).into_diag(); - assert_eq!(d.dim(), 0); - let d = ArcArray::::zeros(()).into_diag(); - assert_eq!(d.dim(), 1); + assert_eq!(d.dim(), [0]); + let d = ArcArray::::zeros([]).into_diag(); + assert_eq!(d.dim(), [1]); } /// Check that the merged shape is correct. @@ -744,7 +744,7 @@ fn merge_axes() { } } - let a = Array4::::zeros((3, 4, 5, 4)); + let a = Array4::::zeros([3, 4, 5, 4]); assert_not_merged!(a, s![.., .., .., ..], 0, 0); assert_merged!(a, s![.., .., .., ..], 0, 1); @@ -786,7 +786,7 @@ fn merge_axes() { assert_merged!(a, s![.., ..;2, .., ..], 2, 3); assert_not_merged!(a, s![.., ..;2, .., ..], 3, 2); - let a = Array4::::zeros((3, 1, 5, 1).f()); + let a = Array4::::zeros([3, 1, 5, 1].f()); assert_merged!(a, s![.., .., ..;2, ..], 0, 1); assert_merged!(a, s![.., .., ..;2, ..], 0, 3); assert_merged!(a, s![.., .., ..;2, ..], 1, 0); @@ -800,7 +800,7 @@ fn merge_axes() { assert_merged!(a, s![.., .., ..;2, ..], 3, 2); assert_merged!(a, s![.., .., ..;2, ..], 3, 3); - let a = Array4::::zeros((3, 0, 5, 1)); + let a = Array4::::zeros([3, 0, 5, 1]); assert_merged!(a, s![.., .., ..;2, ..], 0, 1); assert_merged!(a, s![.., .., ..;2, ..], 1, 1); assert_merged!(a, s![.., .., ..;2, ..], 2, 1); @@ -835,23 +835,23 @@ fn permuted_axes() let permuted = a.view().permuted_axes([0]); assert_eq!(a, permuted); - let a = Array::from_iter(0..24).into_shape((2, 3, 4)).unwrap(); + let a = Array::from_iter(0..24).into_shape([2, 3, 4]).unwrap(); let permuted = a.view().permuted_axes([2, 1, 0]); - for ((i0, i1, i2), elem) in a.indexed_iter() { - assert_eq!(*elem, permuted[(i2, i1, i0)]); + for ([i0, i1, i2], elem) in a.indexed_iter() { + assert_eq!(*elem, permuted[[i2, i1, i0]]); } let permuted = a.view().into_dyn().permuted_axes(&[0, 2, 1][..]); - for ((i0, i1, i2), elem) in a.indexed_iter() { + for ([i0, i1, i2], elem) in a.indexed_iter() { assert_eq!(*elem, permuted[&[i0, i2, i1][..]]); } - let a = Array::from_iter(0..120).into_shape((2, 3, 4, 5)).unwrap(); + let a = Array::from_iter(0..120).into_shape([2, 3, 4, 5]).unwrap(); let permuted = a.view().permuted_axes([1, 0, 3, 2]); - for ((i0, i1, i2, i3), elem) in a.indexed_iter() { - assert_eq!(*elem, permuted[(i1, i0, i3, i2)]); + for ([i0, i1, i2, i3], elem) in a.indexed_iter() { + assert_eq!(*elem, permuted[[i1, i0, i3, i2]]); } let permuted = a.view().into_dyn().permuted_axes(&[1, 2, 3, 0][..]); - for ((i0, i1, i2, i3), elem) in a.indexed_iter() { + for ([i0, i1, i2, i3], elem) in a.indexed_iter() { assert_eq!(*elem, permuted[&[i1, i2, i3, i0][..]]); } } @@ -860,7 +860,7 @@ fn permuted_axes() #[test] fn permuted_axes_repeated_axis() { - let a = Array::from_iter(0..24).into_shape((2, 3, 4)).unwrap(); + let a = Array::from_iter(0..24).into_shape([2, 3, 4]).unwrap(); a.view().permuted_axes([1, 0, 1]); } @@ -868,7 +868,7 @@ fn permuted_axes_repeated_axis() #[test] fn permuted_axes_missing_axis() { - let a = Array::from_iter(0..24).into_shape((2, 3, 4)).unwrap().into_dyn(); + let a = Array::from_iter(0..24).into_shape([2, 3, 4]).unwrap().into_dyn(); a.view().permuted_axes(&[2, 0][..]); } @@ -876,7 +876,7 @@ fn permuted_axes_missing_axis() #[test] fn permuted_axes_oob() { - let a = Array::from_iter(0..24).into_shape((2, 3, 4)).unwrap(); + let a = Array::from_iter(0..24).into_shape([2, 3, 4]).unwrap(); a.view().permuted_axes([1, 0, 3]); } @@ -893,9 +893,9 @@ fn standard_layout() assert!(x1.is_standard_layout()); let x2 = a.index_axis(Axis(1), 0); assert!(!x2.is_standard_layout()); - let x3 = ArrayView1::from_shape(1.strides(2), &[1]).unwrap(); + let x3 = ArrayView1::from_shape(([1]).strides([2]), &[1]).unwrap(); assert!(x3.is_standard_layout()); - let x4 = ArrayView2::from_shape((0, 2).strides((0, 1)), &[1, 2]).unwrap(); + let x4 = ArrayView2::from_shape([0, 2].strides([0, 1]), &[1, 2]).unwrap(); assert!(x4.is_standard_layout()); } @@ -908,12 +908,12 @@ fn assign() assert_eq!(a, b); /* Test broadcasting */ - a.assign(&ArcArray::zeros(1)); - assert_eq!(a, ArcArray::zeros((2, 2))); + a.assign(&ArcArray::zeros([1])); + assert_eq!(a, ArcArray::zeros([2, 2])); /* Test other type */ - a.assign(&Array::from_elem((2, 2), 3.)); - assert_eq!(a, ArcArray::from_elem((2, 2), 3.)); + a.assign(&Array::from_elem([2, 2], 3.)); + assert_eq!(a, ArcArray::from_elem([2, 2], 3.)); /* Test mut view */ let mut a = arr2(&[[1, 2], [3, 4]]); @@ -977,7 +977,7 @@ fn zero_axes() // we can even get a subarray of b let bsub = b.index_axis(Axis(0), 2); - assert_eq!(bsub.dim(), 0); + assert_eq!(bsub.dim(), [0]); } #[test] @@ -986,7 +986,7 @@ fn equality() let a = arr2(&[[1., 2.], [3., 4.]]); let mut b = arr2(&[[1., 2.], [2., 4.]]); assert!(a != b); - b[(1, 0)] = 3.; + b[[1, 0]] = 3.; assert!(a == b); // make sure we can compare different shapes without failure. @@ -1002,7 +1002,7 @@ fn map1() assert_eq!(b, arr2(&[[0, 0], [1, 1]])); // test map to reference with array's lifetime. let c = a.map(|x| x); - assert_eq!(a[(0, 0)], *c[(0, 0)]); + assert_eq!(a[[0, 0]], *c[[0, 0]]); } #[test] @@ -1043,10 +1043,10 @@ fn owned_array1() { } assert_eq!(a.shape(), &[4]); - let mut a = Array::zeros((2, 2)); - let mut b = ArcArray::zeros((2, 2)); - a[(1, 1)] = 3; - b[(1, 1)] = 3; + let mut a = Array::zeros([2, 2]); + let mut b = ArcArray::zeros([2, 2]); + a[[1, 1]] = 3; + b[[1, 1]] = 3; assert_eq!(a, b); let c = a.clone(); @@ -1060,8 +1060,8 @@ fn owned_array1() { #[test] fn owned_array_with_stride() { let v: Vec<_> = (0..12).collect(); - let dim = (2, 3, 2); - let strides = (1, 4, 2); + let dim = [2, 3, 2]; + let strides = [1, 4, 2]; let a = Array::from_shape_vec(dim.strides(strides), v).unwrap(); assert_eq!(a.strides(), &[1, 4, 2]); @@ -1071,8 +1071,8 @@ fn owned_array_with_stride() { fn owned_array_discontiguous() { use ::std::iter::repeat; let v: Vec<_> = (0..12).flat_map(|x| repeat(x).take(2)).collect(); - let dim = (3, 2, 2); - let strides = (8, 4, 2); + let dim = [3, 2, 2]; + let strides = [8, 4, 2]; let a = Array::from_shape_vec(dim.strides(strides), v).unwrap(); assert_eq!(a.strides(), &[8, 4, 2]); @@ -1097,7 +1097,7 @@ fn owned_array_discontiguous_drop() { let set = Rc::new(RefCell::new(BTreeSet::new())); { let v: Vec<_> = (0..12).map(|x| InsertOnDrop(set.clone(), Some(x))).collect(); - let mut a = Array::from_shape_vec((2, 6), v).unwrap(); + let mut a = Array::from_shape_vec([2, 6], v).unwrap(); // discontiguous and non-zero offset a.slice_collapse(s![.., 1..]); } @@ -1118,7 +1118,7 @@ macro_rules! assert_matches { #[test] fn from_vec_dim_stride_empty_1d() { let empty: [f32; 0] = []; - assert_matches!(Array::from_shape_vec(0.strides(1), empty.to_vec()), + assert_matches!(Array::from_shape_vec([0].strides([1]), empty.to_vec()), Ok(_)); } @@ -1128,11 +1128,11 @@ fn from_vec_dim_stride_0d() { let one = [1.]; let two = [1., 2.]; // too few elements - assert_matches!(Array::from_shape_vec(().strides(()), empty.to_vec()), Err(_)); + assert_matches!(Array::from_shape_vec([].strides([]), empty.to_vec()), Err(_)); // exact number of elements - assert_matches!(Array::from_shape_vec(().strides(()), one.to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec([].strides([]), one.to_vec()), Ok(_)); // too many are ok - assert_matches!(Array::from_shape_vec(().strides(()), two.to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec([].strides([]), two.to_vec()), Ok(_)); } #[test] @@ -1182,12 +1182,12 @@ fn from_vec_dim_stride_2d_5() { #[test] fn from_vec_dim_stride_2d_6() { let a = [1., 2., 3., 4., 5., 6.]; - let d = (2, 1, 1); - let s = (2, 2, 1); + let d = [2, 1, 1]; + let s = [2, 2, 1]; assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Ok(_)); - let d = (1, 2, 1); - let s = (2, 2, 1); + let d = [1, 2, 1]; + let s = [2, 2, 1]; assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Ok(_)); } @@ -1196,8 +1196,8 @@ fn from_vec_dim_stride_2d_7() { // empty arrays can have 0 strides let a: [f32; 0] = []; // [[]] shape=[4, 0], strides=[0, 1] - let d = (4, 0); - let s = (0, 1); + let d = [4, 0]; + let s = [0, 1]; assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Ok(_)); } @@ -1205,33 +1205,33 @@ fn from_vec_dim_stride_2d_7() { fn from_vec_dim_stride_2d_8() { // strides of length 1 axes can be zero let a = [1.]; - let d = (1, 1); - let s = (0, 1); + let d = [1, 1]; + let s = [0, 1]; assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Ok(_)); } #[test] fn from_vec_dim_stride_2d_rejects() { let two = [1., 2.]; - let d = (2, 2); - let s = (1, 0); + let d = [2, 2]; + let s = [1, 0]; assert_matches!(Array::from_shape_vec(d.strides(s), two.to_vec()), Err(_)); - let d = (2, 2); - let s = (0, 1); + let d = [2, 2]; + let s = [0, 1]; assert_matches!(Array::from_shape_vec(d.strides(s), two.to_vec()), Err(_)); } #[test] fn views() { - let a = ArcArray::from_vec(vec![1, 2, 3, 4]).reshape((2, 2)); + let a = ArcArray::from_vec(vec![1, 2, 3, 4]).reshape([2, 2]); let b = a.view(); assert_eq!(a, b); assert_eq!(a.shape(), b.shape()); assert_eq!(a.clone() + a.clone(), &b + &b); assert_eq!(a.clone() + b, &b + &b); - a.clone()[(0, 0)] = 99; - assert_eq!(b[(0, 0)], 1); + a.clone()[[0, 0]] = 99; + assert_eq!(b[[0, 0]], 1); assert_eq!(a.view().into_iter().cloned().collect::>(), vec![1, 2, 3, 4]); @@ -1239,26 +1239,26 @@ fn views() { #[test] fn view_mut() { - let mut a = ArcArray::from_vec(vec![1, 2, 3, 4]).reshape((2, 2)); + let mut a = ArcArray::from_vec(vec![1, 2, 3, 4]).reshape([2, 2]); for elt in &mut a.view_mut() { *elt = 0; } - assert_eq!(a, Array::zeros((2, 2))); + assert_eq!(a, Array::zeros([2, 2])); { let mut b = a.view_mut(); - b[(0, 0)] = 7; + b[[0, 0]] = 7; } - assert_eq!(a[(0, 0)], 7); + assert_eq!(a[[0, 0]], 7); for elt in a.view_mut() { *elt = 2; } - assert_eq!(a, ArcArray::from_elem((2, 2), 2)); + assert_eq!(a, ArcArray::from_elem([2, 2], 2)); } #[test] fn slice_mut() { - let mut a = ArcArray::from_vec(vec![1, 2, 3, 4]).reshape((2, 2)); + let mut a = ArcArray::from_vec(vec![1, 2, 3, 4]).reshape([2, 2]); for elt in a.slice_mut(s![.., ..]) { *elt = 0; } @@ -1313,7 +1313,7 @@ fn aview() { fn aview_mut() { let mut data = [0; 16]; { - let mut a = aview_mut1(&mut data).into_shape((4, 4)).unwrap(); + let mut a = aview_mut1(&mut data).into_shape([4, 4]).unwrap(); { let mut slc = a.slice_mut(s![..2, ..;2]); slc += 1; @@ -1354,13 +1354,13 @@ fn transpose_view_mut() { fn reshape() { let data = [1, 2, 3, 4, 5, 6, 7, 8]; let v = aview1(&data); - let u = v.into_shape((3, 3)); + let u = v.into_shape([3, 3]); assert!(u.is_err()); - let u = v.into_shape((2, 2, 2)); + let u = v.into_shape([2, 2, 2]); assert!(u.is_ok()); let u = u.unwrap(); assert_eq!(u.shape(), &[2, 2, 2]); - let s = u.into_shape((4, 2)).unwrap(); + let s = u.into_shape([4, 2]).unwrap(); assert_eq!(s.shape(), &[4, 2]); assert_eq!(s, aview2(&[[1, 2], [3, 4], @@ -1373,7 +1373,7 @@ fn reshape() { fn reshape_error1() { let data = [1, 2, 3, 4, 5, 6, 7, 8]; let v = aview1(&data); - let _u = v.into_shape((2, 5)).unwrap(); + let _u = v.into_shape([2, 5]).unwrap(); } #[test] @@ -1381,14 +1381,14 @@ fn reshape_error1() { fn reshape_error2() { let data = [1, 2, 3, 4, 5, 6, 7, 8]; let v = aview1(&data); - let mut u = v.into_shape((2, 2, 2)).unwrap(); + let mut u = v.into_shape([2, 2, 2]).unwrap(); u.swap_axes(0, 1); - let _s = u.into_shape((2, 4)).unwrap(); + let _s = u.into_shape([2, 4]).unwrap(); } #[test] fn reshape_f() { - let mut u = Array::zeros((3, 4).f()); + let mut u = Array::zeros([3, 4].f()); for (i, elt) in enumerate(u.as_slice_memory_order_mut().unwrap()) { *elt = i as i32; } @@ -1396,16 +1396,16 @@ fn reshape_f() { println!("{:?}", v); // noop ok - let v2 = v.into_shape((3, 4)); + let v2 = v.into_shape([3, 4]); assert!(v2.is_ok()); assert_eq!(v, v2.unwrap()); - let u = v.into_shape((3, 2, 2)); + let u = v.into_shape([3, 2, 2]); assert!(u.is_ok()); let u = u.unwrap(); println!("{:?}", u); assert_eq!(u.shape(), &[3, 2, 2]); - let s = u.into_shape((4, 3)).unwrap(); + let s = u.into_shape([4, 3]).unwrap(); println!("{:?}", s); assert_eq!(s.shape(), &[4, 3]); assert_eq!(s, aview2(&[[0, 4, 8], @@ -1436,20 +1436,20 @@ fn insert_axis() { assert!(::std::panic::catch_unwind( || arr2(&[[1, 2, 3], [4, 5, 6]]).insert_axis(Axis(3))).is_err()); - test_insert!(Array3::::zeros((3, 4, 5)), 0, Array4::::zeros((1, 3, 4, 5))); - test_insert!(Array3::::zeros((3, 4, 5)), 1, Array4::::zeros((3, 1, 4, 5))); - test_insert!(Array3::::zeros((3, 4, 5)), 3, Array4::::zeros((3, 4, 5, 1))); + test_insert!(Array3::::zeros([3, 4, 5]), 0, Array4::::zeros([1, 3, 4, 5])); + test_insert!(Array3::::zeros([3, 4, 5]), 1, Array4::::zeros([3, 1, 4, 5])); + test_insert!(Array3::::zeros([3, 4, 5]), 3, Array4::::zeros([3, 4, 5, 1])); assert!(::std::panic::catch_unwind( - || Array3::::zeros((3, 4, 5)).insert_axis(Axis(4))).is_err()); + || Array3::::zeros([3, 4, 5]).insert_axis(Axis(4))).is_err()); - test_insert!(Array6::::zeros((2, 3, 4, 3, 2, 3)), 0, + test_insert!(Array6::::zeros([2, 3, 4, 3, 2, 3]), 0, ArrayD::::zeros(vec![1, 2, 3, 4, 3, 2, 3])); - test_insert!(Array6::::zeros((2, 3, 4, 3, 2, 3)), 3, + test_insert!(Array6::::zeros([2, 3, 4, 3, 2, 3]), 3, ArrayD::::zeros(vec![2, 3, 4, 1, 3, 2, 3])); - test_insert!(Array6::::zeros((2, 3, 4, 3, 2, 3)), 6, + test_insert!(Array6::::zeros([2, 3, 4, 3, 2, 3]), 6, ArrayD::::zeros(vec![2, 3, 4, 3, 2, 3, 1])); assert!(::std::panic::catch_unwind( - || Array6::::zeros((2, 3, 4, 3, 2, 3)).insert_axis(Axis(7))).is_err()); + || Array6::::zeros([2, 3, 4, 3, 2, 3]).insert_axis(Axis(7))).is_err()); test_insert!(ArrayD::::zeros(vec![3, 4, 5]), 0, ArrayD::::zeros(vec![1, 3, 4, 5])); test_insert!(ArrayD::::zeros(vec![3, 4, 5]), 1, ArrayD::::zeros(vec![3, 1, 4, 5])); @@ -1466,18 +1466,18 @@ fn insert_axis_f() { assert!(res.t().is_standard_layout()); }); - test_insert_f!(Array0::from_shape_vec(().f(), vec![1]).unwrap(), 0, arr1(&[1])); + test_insert_f!(Array0::from_shape_vec([].f(), vec![1]).unwrap(), 0, arr1(&[1])); assert!(::std::panic::catch_unwind( - || Array0::from_shape_vec(().f(), vec![1]).unwrap().insert_axis(Axis(1))).is_err()); + || Array0::from_shape_vec([].f(), vec![1]).unwrap().insert_axis(Axis(1))).is_err()); - test_insert_f!(Array1::::zeros((3).f()), 0, Array2::::zeros((1, 3))); - test_insert_f!(Array1::::zeros((3).f()), 1, Array2::::zeros((3, 1))); + test_insert_f!(Array1::::zeros(([3]).f()), 0, Array2::::zeros([1, 3])); + test_insert_f!(Array1::::zeros(([3]).f()), 1, Array2::::zeros([3, 1])); assert!(::std::panic::catch_unwind( - || Array1::::zeros((3).f()).insert_axis(Axis(2))).is_err()); + || Array1::::zeros(([3]).f()).insert_axis(Axis(2))).is_err()); - test_insert_f!(Array3::::zeros((3, 4, 5).f()), 1, Array4::::zeros((3, 1, 4, 5))); + test_insert_f!(Array3::::zeros([3, 4, 5].f()), 1, Array4::::zeros([3, 1, 4, 5])); assert!(::std::panic::catch_unwind( - || Array3::::zeros((3, 4, 5).f()).insert_axis(Axis(4))).is_err()); + || Array3::::zeros([3, 4, 5].f()).insert_axis(Axis(4))).is_err()); test_insert_f!(ArrayD::::zeros(vec![3, 4, 5].f()), 1, ArrayD::::zeros(vec![3, 1, 4, 5])); @@ -1508,19 +1508,19 @@ fn arithmetic_broadcast() { fn char_array() { // test compilation & basics of non-numerical array - let cc = ArcArray::from_iter("alphabet".chars()).reshape((4, 2)); + let cc = ArcArray::from_iter("alphabet".chars()).reshape([4, 2]); assert!(cc.index_axis(Axis(1), 0) == ArcArray::from_iter("apae".chars())); } #[test] fn scalar_ops() { - let a = Array::::zeros((5, 5)); + let a = Array::::zeros([5, 5]); let b = &a + 1; let c = (&a + &a + 2) - 3; println!("{:?}", b); println!("{:?}", c); - let a = Array::::zeros((2, 2)); + let a = Array::::zeros([2, 2]); let b = (1. + a) * 3.; assert_eq!(b, arr2(&[[3., 3.], [3., 3.]])); @@ -1532,7 +1532,7 @@ fn scalar_ops() { assert_eq!(b, arr1(&[true, false, false])); assert_eq!(true ^ &a, !a); - let zero = Array::::zeros((2, 2)); + let zero = Array::::zeros([2, 2]); let one = &zero + 1.; assert_eq!(0. * &one, zero); assert_eq!(&one * 0., zero); @@ -1540,7 +1540,7 @@ fn scalar_ops() { assert_eq!(&one / 2., 0.5 * &one); assert_eq!(&one % 1., zero); - let zero = Array::::zeros((2, 2)); + let zero = Array::::zeros([2, 2]); let one = &zero + 1; assert_eq!(one.clone() << 3, 8 * &one); assert_eq!(3 << one.clone() , 6 * &one); @@ -1568,7 +1568,7 @@ fn split_at() { assert_eq!(a, arr2(&[[1., 5.], [8., 4.]])); - let b = ArcArray::linspace(0., 59., 60).reshape((3, 4, 5)); + let b = ArcArray::linspace(0., 59., 60).reshape([3, 4, 5]); let (left, right) = b.view().split_at(Axis(2), 2); assert_eq!(left.shape(), [3, 4, 2]); @@ -1718,8 +1718,8 @@ fn test_contiguous() { assert!(!v.is_standard_layout()); assert!(v.as_slice_memory_order().is_some()); - let a = Array::::zeros((20, 1)); - let b = Array::::zeros((20, 1).f()); + let a = Array::::zeros([20, 1]); + let b = Array::::zeros([20, 1].f()); assert!(a.as_slice().is_some()); assert!(b.as_slice().is_some()); assert!(a.as_slice_memory_order().is_some()); @@ -1751,7 +1751,7 @@ fn test_swap() { for i in 0..a.rows() { for j in i + 1..a.cols() { - a.swap((i, j), (j, i)); + a.swap([i, j], [j, i]); } } assert_eq!(a, b.t()); @@ -1766,7 +1766,7 @@ fn test_uswap() { for i in 0..a.rows() { for j in i + 1..a.cols() { - unsafe { a.uswap((i, j), (j, i)) }; + unsafe { a.uswap([i, j], [j, i]) }; } } assert_eq!(a, b.t()); @@ -1775,9 +1775,9 @@ fn test_uswap() { #[test] fn test_shape() { let data = [0, 1, 2, 3, 4, 5]; - let a = Array::from_shape_vec((1, 2, 3), data.to_vec()).unwrap(); - let b = Array::from_shape_vec((1, 2, 3).f(), data.to_vec()).unwrap(); - let c = Array::from_shape_vec((1, 2, 3).strides((1, 3, 1)), data.to_vec()).unwrap(); + let a = Array::from_shape_vec([1, 2, 3], data.to_vec()).unwrap(); + let b = Array::from_shape_vec([1, 2, 3].f(), data.to_vec()).unwrap(); + let c = Array::from_shape_vec([1, 2, 3].strides([1, 3, 1]), data.to_vec()).unwrap(); println!("{:?}", a); println!("{:?}", b); println!("{:?}", c); @@ -1789,11 +1789,11 @@ fn test_shape() { #[test] fn test_view_from_shape_ptr() { let data = [0, 1, 2, 3, 4, 5]; - let view = unsafe { ArrayView::from_shape_ptr((2, 3), data.as_ptr()) }; + let view = unsafe { ArrayView::from_shape_ptr([2, 3], data.as_ptr()) }; assert_eq!(view, aview2(&[[0, 1, 2], [3, 4, 5]])); let mut data = data; - let mut view = unsafe { ArrayViewMut::from_shape_ptr((2, 3), data.as_mut_ptr()) }; + let mut view = unsafe { ArrayViewMut::from_shape_ptr([2, 3], data.as_mut_ptr()) }; view[[1, 2]] = 6; assert_eq!(view, aview2(&[[0, 1, 2], [3, 4, 6]])); view[[0, 1]] = 0; @@ -1835,7 +1835,7 @@ fn test_map_axis() { assert_eq!(c, answer2); // Test zero-length axis case - let arr = Array3::::zeros((3, 0, 4)); + let arr = Array3::::zeros([3, 0, 4]); let mut counter = 0; let result = arr.map_axis(Axis(1), |x| { assert_eq!(x.shape(), &[0]); @@ -1845,7 +1845,7 @@ fn test_map_axis() { assert_eq!(result.shape(), &[3, 4]); itertools::assert_equal(result.iter().cloned().sorted(), 1..=3 * 4); - let mut arr = Array3::::zeros((3, 0, 4)); + let mut arr = Array3::::zeros([3, 0, 4]); let mut counter = 0; let result = arr.map_axis_mut(Axis(1), |x| { assert_eq!(x.shape(), &[0]); @@ -1872,16 +1872,16 @@ fn test_to_vec() { #[test] fn test_array_clone_unalias() { - let a = Array::::zeros((3, 3)); + let a = Array::::zeros([3, 3]); let mut b = a.clone(); b.fill(1); assert!(a != b); - assert_eq!(a, Array::<_, _>::zeros((3, 3))); + assert_eq!(a, Array::<_, _>::zeros([3, 3])); } #[test] fn test_array_clone_same_view() { - let mut a = Array::from_iter(0..9).into_shape((3, 3)).unwrap(); + let mut a = Array::from_iter(0..9).into_shape([3, 3]).unwrap(); a.slice_collapse(s![..;-1, ..;-1]); let b = a.clone(); assert_eq!(a, b); diff --git a/tests/azip.rs b/tests/azip.rs index 39a5d2991..70e5bf29d 100644 --- a/tests/azip.rs +++ b/tests/azip.rs @@ -11,7 +11,7 @@ use std::mem::swap; #[test] fn test_azip1() { - let mut a = Array::zeros(62); + let mut a = Array::zeros([62]); let mut x = 0; azip!(mut a in { *a = x; x += 1; }); assert_equal(cloned(&a), 0..a.len()); @@ -19,16 +19,16 @@ fn test_azip1() { #[test] fn test_azip2() { - let mut a = Array::zeros((5, 7)); - let b = Array::from_shape_fn(a.dim(), |(i, j)| 1. / (i + 2*j) as f32); + let mut a = Array::zeros([5, 7]); + let b = Array::from_shape_fn(a.dim(), |[i, j]| 1. / (i + 2*j) as f32); azip!(mut a, b in { *a = b; }); assert_eq!(a, b); } #[test] fn test_azip2_1() { - let mut a = Array::zeros((5, 7)); - let b = Array::from_shape_fn((5, 10), |(i, j)| 1. / (i + 2*j) as f32); + let mut a = Array::zeros([5, 7]); + let b = Array::from_shape_fn([5, 10], |[i, j]| 1. / (i + 2*j) as f32); let b = b.slice(s![..;-1, 3..]); azip!(mut a, b in { *a = b; }); assert_eq!(a, b); @@ -36,8 +36,8 @@ fn test_azip2_1() { #[test] fn test_azip2_3() { - let mut b = Array::from_shape_fn((5, 10), |(i, j)| 1. / (i + 2*j) as f32); - let mut c = Array::from_shape_fn((5, 10), |(i, j)| f32::exp((i + j) as f32)); + let mut b = Array::from_shape_fn([5, 10], |[i, j]| 1. / (i + 2*j) as f32); + let mut c = Array::from_shape_fn([5, 10], |[i, j]| f32::exp((i + j) as f32)); let a = b.clone(); azip!(mut b, mut c in { swap(b, c) }); assert_eq!(a, c); @@ -46,10 +46,10 @@ fn test_azip2_3() { #[test] fn test_azip2_sum() { - let c = Array::from_shape_fn((5, 10), |(i, j)| f32::exp((i + j) as f32)); + let c = Array::from_shape_fn([5, 10], |[i, j]| f32::exp((i + j) as f32)); for i in 0..2 { let ax = Axis(i); - let mut b = Array::zeros(c.len_of(ax)); + let mut b = Array::zeros([c.len_of(ax)]); azip!(mut b, ref c (c.axis_iter(ax)) in { *b = c.sum() }); assert!(b.all_close(&c.sum_axis(Axis(1 - i)), 1e-6)); } @@ -75,13 +75,13 @@ fn test_azip3_slices() { #[test] fn test_broadcast() { let n = 16; - let mut a = Array::::zeros((n, n)); - let mut b = Array::::from_elem((1, n), 1.); - for ((i, j), elt) in b.indexed_iter_mut() { + let mut a = Array::::zeros([n, n]); + let mut b = Array::::from_elem([1, n], 1.); + for ([i, j], elt) in b.indexed_iter_mut() { *elt /= 1. + (i + 2 * j) as f32; } - let d = Array::from_elem((1, n), 1.); - let e = Array::from_elem((), 2.); + let d = Array::from_elem([1, n], 1.); + let e = Array::from_elem([], 2.); { let z = Zip::from(a.view_mut()) @@ -96,10 +96,10 @@ fn test_broadcast() { #[should_panic] #[test] fn test_zip_dim_mismatch_1() { - let mut a = Array::zeros((5, 7)); + let mut a = Array::zeros([5, 7]); let mut d = a.raw_dim(); d[0] += 1; - let b = Array::from_shape_fn(d, |(i, j)| 1. / (i + 2*j) as f32); + let b = Array::from_shape_fn(d, |[i, j]| 1. / (i + 2*j) as f32); azip!(mut a, b in { *a = b; }); } @@ -108,7 +108,7 @@ fn test_zip_dim_mismatch_1() { // where A is F-contiguous and B contiguous but neither F nor C contiguous. #[test] fn test_contiguous_but_not_c_or_f() { - let a = Array::from_iter(0..27).into_shape((3, 3, 3)).unwrap(); + let a = Array::from_iter(0..27).into_shape([3, 3, 3]).unwrap(); // both F order let a = a.reversed_axes(); @@ -133,9 +133,9 @@ fn test_contiguous_but_not_c_or_f() { #[test] fn test_clone() { - let a = Array::from_iter(0..27).into_shape((3, 3, 3)).unwrap(); + let a = Array::from_iter(0..27).into_shape([3, 3, 3]).unwrap(); - let z = Zip::from(&a).and(a.exact_chunks((1, 1, 1))); + let z = Zip::from(&a).and(a.exact_chunks([1, 1, 1])); let w = z.clone(); let mut result = Vec::new(); z.apply(|x, y| { @@ -150,7 +150,7 @@ fn test_clone() { #[test] fn test_indices_1() { - let mut a1 = Array::default(12); + let mut a1 = Array::default([12]); for (i, elt) in a1.indexed_iter_mut() { *elt = i; } @@ -181,7 +181,7 @@ fn test_indices_1() { #[test] fn test_indices_2() { - let mut a1 = Array::default((10, 12)); + let mut a1 = Array::default([10, 12]); for (i, elt) in a1.indexed_iter_mut() { *elt = i; } @@ -211,7 +211,7 @@ fn test_indices_2() { #[test] fn test_indices_3() { - let mut a1 = Array::default((4, 5, 6)); + let mut a1 = Array::default([4, 5, 6]); for (i, elt) in a1.indexed_iter_mut() { *elt = i; } @@ -244,7 +244,7 @@ fn test_indices_3() { fn test_indices_split_1() { for m in (0..4).chain(10..12) { for n in (0..4).chain(10..12) { - let a1 = Array::::default((m, n)); + let a1 = Array::::default([m, n]); if a1.len() <= 1 { continue; } @@ -274,9 +274,9 @@ fn test_indices_split_1() { #[test] fn test_zip_all() { - let a = Array::::zeros(62); - let b = Array::::ones(62); - let mut c = Array::::ones(62); + let a = Array::::zeros([62]); + let b = Array::::ones([62]); + let mut c = Array::::ones([62]); c[5] = 0.0; assert_eq!(true, Zip::from(&a).and(&b).all(|&x, &y| x + y == 1.0)); assert_eq!(false, Zip::from(&a).and(&b).all(|&x, &y| x == y)); @@ -285,8 +285,8 @@ fn test_zip_all() { #[test] fn test_zip_all_empty_array() { - let a = Array::::zeros(0); - let b = Array::::ones(0); + let a = Array::::zeros([0]); + let b = Array::::ones([0]); assert_eq!(true, Zip::from(&a).and(&b).all(|&_x, &_y| true)); assert_eq!(true, Zip::from(&a).and(&b).all(|&_x, &_y| false)); } diff --git a/tests/broadcast.rs b/tests/broadcast.rs index c194da792..cdd7c63af 100644 --- a/tests/broadcast.rs +++ b/tests/broadcast.rs @@ -14,19 +14,19 @@ fn broadcast_1() let c_dim = Dim([2, 1]); let c = ArcArray::linspace(0., 1., c_dim.size()).reshape(c_dim); - assert!(c.broadcast(1).is_none()); - assert!(c.broadcast(()).is_none()); - assert!(c.broadcast((2, 1)).is_some()); - assert!(c.broadcast((2, 2)).is_some()); - assert!(c.broadcast((32, 2, 1)).is_some()); - assert!(c.broadcast((32, 1, 2)).is_none()); + assert!(c.broadcast([1]).is_none()); + assert!(c.broadcast([]).is_none()); + assert!(c.broadcast([2, 1]).is_some()); + assert!(c.broadcast([2, 2]).is_some()); + assert!(c.broadcast([32, 2, 1]).is_some()); + assert!(c.broadcast([32, 1, 2]).is_none()); /* () can be broadcast to anything */ - let z = ArcArray::::zeros(()); - assert!(z.broadcast(()).is_some()); - assert!(z.broadcast(1).is_some()); - assert!(z.broadcast(3).is_some()); - assert!(z.broadcast((7,2,9)).is_some()); + let z = ArcArray::::zeros([]); + assert!(z.broadcast([]).is_some()); + assert!(z.broadcast([1]).is_some()); + assert!(z.broadcast([3]).is_some()); + assert!(z.broadcast([7,2,9]).is_some()); } #[test] @@ -37,7 +37,7 @@ fn test_add() let mut a = ArcArray::linspace(0.0, 1., a_dim.size()).reshape(a_dim); let b = ArcArray::linspace(0.0, 1., b_dim.size()).reshape(b_dim); a += &b; - let t = ArcArray::from_elem((), 1.0f32); + let t = ArcArray::from_elem([], 1.0f32); a += &t; } @@ -46,22 +46,22 @@ fn test_add_incompat() { let a_dim = Dim([2, 4, 2, 2]); let mut a = ArcArray::linspace(0.0, 1., a_dim.size()).reshape(a_dim); - let incompat = ArcArray::from_elem(3, 1.0f32); + let incompat = ArcArray::from_elem([3], 1.0f32); a += &incompat; } #[test] fn test_broadcast() { - let (_, n, k) = (16, 16, 16); + let [_, n, k] = [16, 16, 16]; let x1 = 1.; // b0 broadcast 1 -> n, k let x = Array::from_vec(vec![x1]); - let b0 = x.broadcast((n, k)).unwrap(); + let b0 = x.broadcast([n, k]).unwrap(); // b1 broadcast n -> n, k - let b1 = Array::from_elem(n, x1); - let b1 = b1.broadcast((n, k)).unwrap(); + let b1 = Array::from_elem([n], x1); + let b1 = b1.broadcast([n, k]).unwrap(); // b2 is n, k - let b2 = Array::from_elem((n, k), x1); + let b2 = Array::from_elem([n, k], x1); println!("b0=\n{:?}", b0); println!("b1=\n{:?}", b1); @@ -76,8 +76,8 @@ fn test_broadcast_1d() { let x1 = 1.; // b0 broadcast 1 -> n let x = Array::from_vec(vec![x1]); - let b0 = x.broadcast(n).unwrap(); - let b2 = Array::from_elem(n, x1); + let b0 = x.broadcast([n]).unwrap(); + let b2 = Array::from_elem([n], x1); println!("b0=\n{:?}", b0); println!("b2=\n{:?}", b2); diff --git a/tests/dimension.rs b/tests/dimension.rs index c76b8d7ad..492d688db 100644 --- a/tests/dimension.rs +++ b/tests/dimension.rs @@ -53,11 +53,11 @@ fn remove_axis() assert_eq!(Dim(vec![1, 2]).remove_axis(Axis(0)), Dim(vec![2])); assert_eq!(Dim(vec![4, 5, 6]).remove_axis(Axis(1)), Dim(vec![4, 6])); - let a = ArcArray::::zeros((4,5)); + let a = ArcArray::::zeros([4, 5]); a.index_axis(Axis(1), 0); let a = ArcArray::::zeros(vec![4,5,6]); - let _b = a.index_axis_move(Axis(1), 0).reshape((4, 6)).reshape(vec![2, 3, 4]); + let _b = a.index_axis_move(Axis(1), 0).reshape([4, 6]).reshape(vec![2, 3, 4]); } #[test] @@ -138,7 +138,7 @@ fn min_stride_axis() { let a = ArrayF32::zeros(10); assert_eq!(a.min_stride_axis(), Axis(0)); - let a = ArrayF32::zeros((3, 3)); + let a = ArrayF32::zeros([3, 3]); assert_eq!(a.min_stride_axis(), Axis(1)); assert_eq!(a.t().min_stride_axis(), Axis(0)); @@ -157,24 +157,24 @@ fn min_stride_axis() { b.swap_axes(3, ax); } - let a = ArrayF32::zeros((3, 3)); - let v = a.broadcast((8, 3, 3)).unwrap(); + let a = ArrayF32::zeros([3, 3]); + let v = a.broadcast([8, 3, 3]).unwrap(); assert_eq!(v.min_stride_axis(), Axis(0)); } */ #[test] fn max_stride_axis() { - let a = ArrayF32::zeros(10); + let a = ArrayF32::zeros([10]); assert_eq!(a.max_stride_axis(), Axis(0)); - let a = ArrayF32::zeros((3, 3)); + let a = ArrayF32::zeros([3, 3]); assert_eq!(a.max_stride_axis(), Axis(0)); assert_eq!(a.t().max_stride_axis(), Axis(1)); let a = ArrayF32::zeros(vec![1, 3]); assert_eq!(a.max_stride_axis(), Axis(1)); - let a = ArrayF32::zeros((1, 3)); + let a = ArrayF32::zeros([1, 3]); assert_eq!(a.max_stride_axis(), Axis(1)); let a = ArrayF32::zeros(vec![3, 3]); @@ -265,7 +265,7 @@ fn test_generic_operations() { test_dim(&Dim([2, 3, 4])); test_dim(&Dim(vec![2, 3, 4, 1])); - test_dim(&Dim(2)); + test_dim(&Dim([2])); } #[test] @@ -277,7 +277,7 @@ fn test_array_view() { test_dim(&Dim([1, 2, 4])); test_dim(&Dim(vec![1, 1, 2, 3])); - test_dim(&Dim(7)); + test_dim(&Dim([7])); } #[test] @@ -308,8 +308,8 @@ macro_rules! ndindex { } } ndindex!(10); - ndindex!(10, 4); - ndindex!(10, 4, 3); + ndindex![10, 4]; + ndindex![10, 4, 3]; ndindex!(10, 4, 3, 2); ndindex!(10, 4, 3, 2, 2); ndindex!(10, 4, 3, 2, 2, 2); diff --git a/tests/format.rs b/tests/format.rs index 4dbc939cc..1ce5cd3e3 100644 --- a/tests/format.rs +++ b/tests/format.rs @@ -12,11 +12,11 @@ fn formatting() "[1, 2, 3, 4]"); assert_eq!(format!("{:4}", a), "[ 1, 2, 3, 4]"); - let a = a.reshape((4, 1, 1)); + let a = a.reshape([4, 1, 1]); assert_eq!(format!("{:4}", a), "[[[ 1]],\n [[ 2]],\n [[ 3]],\n [[ 4]]]"); - let a = a.reshape((2, 2)); + let a = a.reshape([2, 2]); assert_eq!(format!("{}", a), "[[1, 2],\n [3, 4]]"); assert_eq!(format!("{}", a), @@ -38,7 +38,7 @@ fn formatting() #[test] fn debug_format() { - let a = Array2::::zeros((3, 4)); + let a = Array2::::zeros([3, 4]); assert_eq!( format!("{:?}", a), "[[0, 0, 0, 0], diff --git a/tests/indices.rs b/tests/indices.rs index 9e47075a4..2a1e4385f 100644 --- a/tests/indices.rs +++ b/tests/indices.rs @@ -6,9 +6,9 @@ use ndarray::indices_of; #[test] fn test_ixdyn_index_iterate() { for &rev in &[false, true] { - let mut a = Array::zeros((2, 3, 4).set_f(rev)); + let mut a = Array::zeros([2, 3, 4].set_f(rev)); let dim = a.shape().to_vec(); - for ((i, j, k), elt) in a.indexed_iter_mut() { + for ([i, j, k], elt) in a.indexed_iter_mut() { *elt = i + 10 * j + 100 * k; } let a = a.into_shape(dim).unwrap(); diff --git a/tests/into-ixdyn.rs b/tests/into-ixdyn.rs index a24d9abcb..bab0161e1 100644 --- a/tests/into-ixdyn.rs +++ b/tests/into-ixdyn.rs @@ -9,7 +9,7 @@ fn test_arr0_into_dyn() { #[test] fn test_arr2_into_arrd_nonstandard_strides() { - let arr = Array2::from_shape_fn((12, 34).f(), |(i, j)| i * 34 + j).into_dyn(); + let arr = Array2::from_shape_fn([12, 34].f(), |[i, j]| i * 34 + j).into_dyn(); let brr = ArrayD::from_shape_fn(vec![12, 34], |d| d[0] * 34 + d[1]); assert!(arr == brr); diff --git a/tests/iterator_chunks.rs b/tests/iterator_chunks.rs index dbbd44082..73ae10e2d 100644 --- a/tests/iterator_chunks.rs +++ b/tests/iterator_chunks.rs @@ -5,31 +5,31 @@ use ndarray::NdProducer; #[test] fn chunks() { - let a = >::linspace(1., 100., 10 * 10).into_shape((10, 10)).unwrap(); + let a = >::linspace(1., 100., 10 * 10).into_shape([10, 10]).unwrap(); - let (m, n) = a.dim(); + let [m, n] = a.dim(); for i in 1..m + 1 { for j in 1..n + 1 { - let c = a.exact_chunks((i, j)); + let c = a.exact_chunks([i, j]); let ly = n / j; for (index, elt) in c.into_iter().enumerate() { - assert_eq!(elt.dim(), (i, j)); + assert_eq!(elt.dim(), [i, j]); let cindex = (index / ly, index % ly); let cx = (cindex.0 * i) as isize; let cy = (cindex.1 * j) as isize; assert_eq!(elt, a.slice(s![cx.., cy..]).slice(s![..i as isize, ..j as isize])); } - let c = a.exact_chunks((i, j)); + let c = a.exact_chunks([i, j]); assert_eq!(c.into_iter().count(), (m / i) * (n / j)); - let c = a.exact_chunks((i, j)); + let c = a.exact_chunks([i, j]); let (c1, c2) = c.split_at(Axis(0), (m / i) / 2); assert_eq!(c1.into_iter().count(), ((m / i) / 2) * (n / j)); assert_eq!(c2.into_iter().count(), (m / i - (m / i) / 2) * (n / j)); } } - let c = a.exact_chunks((m + 1, n)); + let c = a.exact_chunks([m + 1, n]); assert_eq!(c.raw_dim().size(), 0); assert_eq!(c.into_iter().count(), 0); } @@ -63,8 +63,8 @@ fn chunks_different_size_2() { #[test] fn chunks_mut() { - let mut a = Array::zeros((7, 8)); - for (i, mut chunk) in a.exact_chunks_mut((2, 3)).into_iter().enumerate() { + let mut a = Array::zeros([7, 8]); + for (i, mut chunk) in a.exact_chunks_mut([2, 3]).into_iter().enumerate() { chunk.fill(i); } println!("{:?}", a); diff --git a/tests/iterators.rs b/tests/iterators.rs index 71767562f..bb1a522a7 100644 --- a/tests/iterators.rs +++ b/tests/iterators.rs @@ -23,7 +23,7 @@ fn double_ended() { #[test] fn iter_size_hint() { // Check that the size hint is correctly computed - let a = ArcArray::from_iter(0..24).reshape((2, 3, 4)); + let a = ArcArray::from_iter(0..24).reshape([2, 3, 4]); let mut data = [0; 24]; for (i, elt) in enumerate(&mut data) { *elt = i as i32; @@ -42,13 +42,13 @@ fn iter_size_hint() { fn indexed() { let a = ArcArray::linspace(0., 7., 8); - for (i, elt) in a.indexed_iter() { + for ([i], elt) in a.indexed_iter() { assert_eq!(i, *elt as Ix); } - let a = a.reshape((2, 4, 1)); - let (mut i, mut j, k) = (0, 0, 0); + let a = a.reshape([2, 4, 1]); + let [mut i, mut j, k] = [0, 0, 0]; for (idx, elt) in a.indexed_iter() { - assert_eq!(idx, (i, j, k)); + assert_eq!(idx, [i, j, k]); j += 1; if j == 4 { j = 0; @@ -74,11 +74,11 @@ fn assert_slice_correct(v: &ArrayBase) #[test] fn as_slice() { let a = ArcArray::linspace(0., 7., 8); - let a = a.reshape((2, 4, 1)); + let a = a.reshape([2, 4, 1]); assert_slice_correct(&a); - let a = a.reshape((2, 4)); + let a = a.reshape([2, 4]); assert_slice_correct(&a); assert!(a.view().index_axis(Axis(1), 0).as_slice().is_none()); @@ -101,7 +101,7 @@ fn as_slice() { assert!(u.as_slice().is_some()); assert_slice_correct(&u); - let a = a.reshape((8, 1)); + let a = a.reshape([8, 1]); assert_slice_correct(&a); let u = a.slice(s![..;2, ..]); println!("u={:?}, shape={:?}, strides={:?}", u, u.shape(), u.strides()); @@ -111,7 +111,7 @@ fn as_slice() { #[test] fn inner_iter() { let a = ArcArray::from_iter(0..12); - let a = a.reshape((2, 3, 2)); + let a = a.reshape([2, 3, 2]); // [[[0, 1], // [2, 3], // [4, 5]], @@ -121,7 +121,7 @@ fn inner_iter() { assert_equal(a.genrows(), vec![aview1(&[0, 1]), aview1(&[2, 3]), aview1(&[4, 5]), aview1(&[6, 7]), aview1(&[8, 9]), aview1(&[10, 11])]); - let mut b = ArcArray::zeros((2, 3, 2)); + let mut b = ArcArray::zeros([2, 3, 2]); b.swap_axes(0, 2); b.assign(&a); assert_equal(b.genrows(), @@ -131,14 +131,14 @@ fn inner_iter() { #[test] fn inner_iter_corner_cases() { - let a0 = ArcArray::zeros(()); + let a0 = ArcArray::zeros([]); assert_equal(a0.genrows(), vec![aview1(&[0])]); - let a2 = ArcArray::::zeros((0, 3)); + let a2 = ArcArray::::zeros([0, 3]); assert_equal(a2.genrows(), vec![aview1(&[]); 0]); - let a2 = ArcArray::::zeros((3, 0)); + let a2 = ArcArray::::zeros([3, 0]); assert_equal(a2.genrows(), vec![aview1(&[]); 3]); } @@ -146,7 +146,7 @@ fn inner_iter_corner_cases() { #[test] fn inner_iter_size_hint() { // Check that the size hint is correctly computed - let a = ArcArray::from_iter(0..24).reshape((2, 3, 4)); + let a = ArcArray::from_iter(0..24).reshape([2, 3, 4]); let mut len = 6; let mut it = a.genrows().into_iter(); assert_eq!(it.len(), len); @@ -161,7 +161,7 @@ fn inner_iter_size_hint() { #[test] fn outer_iter() { let a = ArcArray::from_iter(0..12); - let a = a.reshape((2, 3, 2)); + let a = a.reshape([2, 3, 2]); // [[[0, 1], // [2, 3], // [4, 5]], @@ -170,7 +170,7 @@ fn outer_iter() { // ... assert_equal(a.outer_iter(), vec![a.index_axis(Axis(0), 0), a.index_axis(Axis(0), 1)]); - let mut b = ArcArray::zeros((2, 3, 2)); + let mut b = ArcArray::zeros([2, 3, 2]); b.swap_axes(0, 2); b.assign(&a); assert_equal(b.outer_iter(), @@ -194,7 +194,7 @@ fn outer_iter() { assert_eq!(&found_rows, &found_rows_rev); // Test a case where strides are negative instead - let mut c = ArcArray::zeros((2, 3, 2)); + let mut c = ArcArray::zeros([2, 3, 2]); let mut cv = c.slice_mut(s![..;-1, ..;-1, ..;-1]); cv.assign(&a); assert_eq!(&a, &cv); @@ -214,7 +214,7 @@ fn outer_iter() { #[test] fn axis_iter() { let a = ArcArray::from_iter(0..12); - let a = a.reshape((2, 3, 2)); + let a = a.reshape([2, 3, 2]); // [[[0, 1], // [2, 3], // [4, 5]], @@ -229,11 +229,11 @@ fn axis_iter() { #[test] fn outer_iter_corner_cases() { - let a2 = ArcArray::::zeros((0, 3)); + let a2 = ArcArray::::zeros([0, 3]); assert_equal(a2.outer_iter(), vec![aview1(&[]); 0]); - let a2 = ArcArray::::zeros((3, 0)); + let a2 = ArcArray::::zeros([3, 0]); assert_equal(a2.outer_iter(), vec![aview1(&[]); 3]); } @@ -242,14 +242,14 @@ fn outer_iter_corner_cases() { #[test] fn outer_iter_mut() { let a = ArcArray::from_iter(0..12); - let a = a.reshape((2, 3, 2)); + let a = a.reshape([2, 3, 2]); // [[[0, 1], // [2, 3], // [4, 5]], // [[6, 7], // [8, 9], // ... - let mut b = ArcArray::zeros((2, 3, 2)); + let mut b = ArcArray::zeros([2, 3, 2]); b.swap_axes(0, 2); b.assign(&a); assert_equal(b.outer_iter_mut(), @@ -267,7 +267,7 @@ fn outer_iter_mut() { #[test] fn axis_iter_mut() { let a = ArcArray::from_iter(0..12); - let a = a.reshape((2, 3, 2)); + let a = a.reshape([2, 3, 2]); // [[[0, 1], // [2, 3], // [4, 5]], @@ -292,7 +292,7 @@ fn axis_iter_mut() { #[test] fn axis_chunks_iter() { let a = ArcArray::from_iter(0..24); - let a = a.reshape((2, 6, 2)); + let a = a.reshape([2, 6, 2]); let it = a.axis_chunks_iter(Axis(1), 2); assert_equal(it, @@ -301,7 +301,7 @@ fn axis_chunks_iter() { arr3(&[[[8, 9], [10, 11]], [[20, 21], [22, 23]]])]); let a = ArcArray::from_iter(0..28); - let a = a.reshape((2, 7, 2)); + let a = a.reshape([2, 7, 2]); let it = a.axis_chunks_iter(Axis(1), 2); assert_equal(it, @@ -331,7 +331,7 @@ fn axis_chunks_iter_corner_cases() { // and enable checking if no pointer offseting is out of bounds. However // checking the absence of of out of bounds offseting cannot (?) be // done automatically, so one has to launch this test in a debugger. - let a = ArcArray::::linspace(0., 7., 8).reshape((8, 1)); + let a = ArcArray::::linspace(0., 7., 8).reshape([8, 1]); let it = a.axis_chunks_iter(Axis(0), 4); assert_equal(it, vec![a.slice(s![..4, ..]), a.slice(s![4.., ..])]); let a = a.slice(s![..;-1,..]); @@ -343,13 +343,13 @@ fn axis_chunks_iter_corner_cases() { arr2(&[[4.], [3.], [2.]]), arr2(&[[1.], [0.]])]); - let b = ArcArray::::zeros((8, 2)); + let b = ArcArray::::zeros([8, 2]); let a = b.slice(s![1..;2,..]); let it = a.axis_chunks_iter(Axis(0), 8); assert_equal(it, vec![a.view()]); let it = a.axis_chunks_iter(Axis(0), 1); - assert_equal(it, vec![ArcArray::zeros((1, 2)); 4]); + assert_equal(it, vec![ArcArray::zeros([1, 2]); 4]); } #[test] @@ -357,14 +357,14 @@ fn axis_chunks_iter_zero_stride() { { // stride 0 case - let b = Array::from_vec(vec![0f32; 0]).into_shape((5, 0, 3)).unwrap(); + let b = Array::from_vec(vec![0f32; 0]).into_shape([5, 0, 3]).unwrap(); let shapes: Vec<_> = b.axis_chunks_iter(Axis(0), 2).map(|v| v.raw_dim()).collect(); assert_eq!(shapes, vec![Ix3(2, 0, 3), Ix3(2, 0, 3), Ix3(1, 0, 3)]); } { // stride 0 case reverse - let b = Array::from_vec(vec![0f32; 0]).into_shape((5, 0, 3)).unwrap(); + let b = Array::from_vec(vec![0f32; 0]).into_shape([5, 0, 3]).unwrap(); let shapes: Vec<_> = b.axis_chunks_iter(Axis(0), 2).rev().map(|v| v.raw_dim()).collect(); assert_eq!(shapes, vec![Ix3(1, 0, 3), Ix3(2, 0, 3), Ix3(2, 0, 3)]); } @@ -380,7 +380,7 @@ fn axis_chunks_iter_zero_stride() { #[test] fn axis_chunks_iter_mut() { let a = ArcArray::from_iter(0..24); - let mut a = a.reshape((2, 6, 2)); + let mut a = a.reshape([2, 6, 2]); let mut it = a.axis_chunks_iter_mut(Axis(1), 2); let mut col0 = it.next().unwrap(); @@ -391,7 +391,7 @@ fn axis_chunks_iter_mut() { #[test] fn outer_iter_size_hint() { // Check that the size hint is correctly computed - let a = ArcArray::from_iter(0..24).reshape((4, 3, 2)); + let a = ArcArray::from_iter(0..24).reshape([4, 3, 2]); let mut len = 4; let mut it = a.outer_iter(); assert_eq!(it.len(), len); @@ -423,7 +423,7 @@ fn outer_iter_size_hint() { #[test] fn outer_iter_split_at() { - let a = ArcArray::from_iter(0..30).reshape((5, 3, 2)); + let a = ArcArray::from_iter(0..30).reshape([5, 3, 2]); let it = a.outer_iter(); let (mut itl, mut itr) = it.clone().split_at(2); @@ -445,7 +445,7 @@ fn outer_iter_split_at() { #[test] #[should_panic] fn outer_iter_split_at_panics() { - let a = ArcArray::from_iter(0..30).reshape((5, 3, 2)); + let a = ArcArray::from_iter(0..30).reshape([5, 3, 2]); let it = a.outer_iter(); it.split_at(6); @@ -453,7 +453,7 @@ fn outer_iter_split_at_panics() { #[test] fn outer_iter_mut_split_at() { - let mut a = ArcArray::from_iter(0..30).reshape((5, 3, 2)); + let mut a = ArcArray::from_iter(0..30).reshape([5, 3, 2]); { let it = a.outer_iter_mut(); @@ -477,7 +477,7 @@ fn iterators_are_send_sync() { // are too. fn _send_sync(_: &T) { } - let mut a = ArcArray::from_iter(0..30).into_shape((5, 3, 2)).unwrap(); + let mut a = ArcArray::from_iter(0..30).into_shape([5, 3, 2]).unwrap(); _send_sync(&a.view()); _send_sync(&a.view_mut()); @@ -494,21 +494,21 @@ fn iterators_are_send_sync() { _send_sync(&a.axis_chunks_iter(Axis(1), 1)); _send_sync(&a.axis_chunks_iter_mut(Axis(1), 1)); _send_sync(&indices(a.dim())); - _send_sync(&a.exact_chunks((1, 1, 1))); - _send_sync(&a.exact_chunks_mut((1, 1, 1))); - _send_sync(&a.exact_chunks((1, 1, 1)).into_iter()); - _send_sync(&a.exact_chunks_mut((1, 1, 1)).into_iter()); + _send_sync(&a.exact_chunks([1, 1, 1])); + _send_sync(&a.exact_chunks_mut([1, 1, 1])); + _send_sync(&a.exact_chunks([1, 1, 1]).into_iter()); + _send_sync(&a.exact_chunks_mut([1, 1, 1]).into_iter()); } #[test] fn test_fold() { - let mut a = Array2::::default((20, 20)); + let mut a = Array2::::default([20, 20]); a += 1; let mut iter = a.iter(); iter.next(); assert_eq!(iter.fold(0, |acc, &x| acc + x), a.sum() - 1); - let mut a = Array0::::default(()); + let mut a = Array0::::default([]); a += 1; assert_eq!(a.iter().fold(0, |acc, &x| acc + x), 1); } @@ -516,7 +516,7 @@ fn test_fold() { #[test] fn test_rfold() { { - let mut a = Array1::::default(256); + let mut a = Array1::::default([256]); a += 1; let mut iter = a.iter(); iter.next(); @@ -525,7 +525,7 @@ fn test_rfold() { // Test strided arrays { - let mut a = Array1::::default(256); + let mut a = Array1::::default([256]); a.slice_axis_inplace(Axis(0), Slice::new(0, None, 2)); a += 1; let mut iter = a.iter(); @@ -534,7 +534,7 @@ fn test_rfold() { } { - let mut a = Array1::::default(256); + let mut a = Array1::::default([256]); a.slice_axis_inplace(Axis(0), Slice::new(0, None, -2)); a += 1; let mut iter = a.iter(); diff --git a/tests/ixdyn.rs b/tests/ixdyn.rs index 65fce6ecc..ebdcac157 100644 --- a/tests/ixdyn.rs +++ b/tests/ixdyn.rs @@ -35,7 +35,7 @@ fn test_ixdyn_out_of_bounds() { #[test] fn test_ixdyn_iterate() { for &rev in &[false, true] { - let mut a = Array::zeros((2, 3, 4).set_f(rev)); + let mut a = Array::zeros([2, 3, 4].set_f(rev)); let dim = a.shape().to_vec(); for (i, elt) in a.iter_mut().enumerate() { *elt = i; @@ -55,9 +55,9 @@ fn test_ixdyn_iterate() { #[test] fn test_ixdyn_index_iterate() { for &rev in &[false, true] { - let mut a = Array::zeros((2, 3, 4).set_f(rev)); + let mut a = Array::zeros([2, 3, 4].set_f(rev)); let dim = a.shape().to_vec(); - for ((i, j, k), elt) in a.indexed_iter_mut() { + for ([i, j, k], elt) in a.indexed_iter_mut() { *elt = i + 10 * j + 100 * k; } let a = a.into_shape(dim).unwrap(); @@ -151,7 +151,7 @@ fn test_0_add_broad() { #[test] fn test_into_dimension() { - let a = Array::linspace(0., 41., 6 * 7).into_shape((6, 7)).unwrap(); + let a = Array::linspace(0., 41., 6 * 7).into_shape([6, 7]).unwrap(); let a2 = a.clone().into_shape(IxDyn(&[6, 7])).unwrap(); let b = a2.clone().into_dimensionality::().unwrap(); assert_eq!(a, b); diff --git a/tests/numeric.rs b/tests/numeric.rs index e73da4904..a17d6bb31 100644 --- a/tests/numeric.rs +++ b/tests/numeric.rs @@ -49,15 +49,15 @@ fn sum_mean() #[test] fn sum_mean_empty() { - assert_eq!(Array3::::ones((2, 0, 3)).sum(), 0.); - assert_eq!(Array1::::ones(0).sum_axis(Axis(0)), arr0(0.)); + assert_eq!(Array3::::ones([2, 0, 3]).sum(), 0.); + assert_eq!(Array1::::ones([0]).sum_axis(Axis(0)), arr0(0.)); assert_eq!( - Array3::::ones((2, 0, 3)).sum_axis(Axis(1)), - Array::zeros((2, 3)), + Array3::::ones([2, 0, 3]).sum_axis(Axis(1)), + Array::zeros([2, 3]), ); - let a = Array1::::ones(0).mean_axis(Axis(0)); + let a = Array1::::ones([0]).mean_axis(Axis(0)); assert_eq!(a, None); - let a = Array3::::ones((2, 0, 3)).mean_axis(Axis(1)); + let a = Array3::::ones([2, 0, 3]).mean_axis(Axis(1)); assert_eq!(a, None); } @@ -172,7 +172,7 @@ fn var_axis_too_large_ddof() { #[test] fn var_axis_nan_ddof() { - let a = Array2::::zeros((2, 3)); + let a = Array2::::zeros([2, 3]); let v = a.var_axis(Axis(1), ::std::f64::NAN); assert_eq!(v.shape(), &[2]); v.mapv(|x| assert!(x.is_nan())); @@ -180,7 +180,7 @@ fn var_axis_nan_ddof() { #[test] fn var_axis_empty_axis() { - let a = Array2::::zeros((2, 0)); + let a = Array2::::zeros([2, 0]); let v = a.var_axis(Axis(1), 0.); assert_eq!(v.shape(), &[2]); v.mapv(|x| assert!(x.is_nan())); @@ -195,7 +195,7 @@ fn std_axis_bad_dof() { #[test] fn std_axis_empty_axis() { - let a = Array2::::zeros((2, 0)); + let a = Array2::::zeros([2, 0]); let v = a.std_axis(Axis(1), 0.); assert_eq!(v.shape(), &[2]); v.mapv(|x| assert!(x.is_nan())); diff --git a/tests/oper.rs b/tests/oper.rs index 004231c92..e7e4d242e 100644 --- a/tests/oper.rs +++ b/tests/oper.rs @@ -20,12 +20,12 @@ fn test_oper(op: &str, a: &[f32], b: &[f32], c: &[f32]) let bb = rcarr1(b); let cc = rcarr1(c); test_oper_arr::(op, aa.clone(), bb.clone(), cc.clone()); - let dim = (2, 2); + let dim = [2, 2]; let aa = aa.reshape(dim); let bb = bb.reshape(dim); let cc = cc.reshape(dim); test_oper_arr::(op, aa.clone(), bb.clone(), cc.clone()); - let dim = (1, 2, 1, 2); + let dim = [1, 2, 1, 2]; let aa = aa.reshape(dim); let bb = bb.reshape(dim); let cc = cc.reshape(dim); @@ -110,7 +110,7 @@ fn scalar_operations() { let mut x = c.clone(); - let mut y = ArcArray::zeros((2, 2)); + let mut y = ArcArray::zeros([2, 2]); x += 1.; y.fill(2.); assert_eq!(x, c + arr0(1.)); @@ -235,7 +235,7 @@ fn dot_product_neg_stride() { #[test] fn fold_and_sum() { - let a = Array::linspace(0., 127., 128).into_shape((8, 16)).unwrap(); + let a = Array::linspace(0., 127., 128).into_shape([8, 16]).unwrap(); assert_approx_eq(a.fold(0., |acc, &x| acc +x), a.sum(), 1e-5); // test different strides @@ -274,7 +274,7 @@ fn fold_and_sum() { #[test] fn product() { - let a = Array::linspace(0.5, 2., 128).into_shape((8, 16)).unwrap(); + let a = Array::linspace(0.5, 2., 128).into_shape([8, 16]).unwrap(); assert_approx_eq(a.fold(1., |acc, &x| acc * x), a.product(), 1e-5); // test different strides @@ -293,11 +293,11 @@ fn product() { } fn range_mat(m: Ix, n: Ix) -> Array2 { - Array::linspace(0., (m * n) as f32 - 1., m * n).into_shape((m, n)).unwrap() + Array::linspace(0., (m * n) as f32 - 1., m * n).into_shape([m, n]).unwrap() } fn range_mat64(m: Ix, n: Ix) -> Array2 { - Array::linspace(0., (m * n) as f64 - 1., m * n).into_shape((m, n)).unwrap() + Array::linspace(0., (m * n) as f64 - 1., m * n).into_shape([m, n]).unwrap() } fn range1_mat64(m: Ix) -> Array1 { @@ -305,7 +305,7 @@ fn range1_mat64(m: Ix) -> Array1 { } fn range_i32(m: Ix, n: Ix) -> Array2 { - Array::from_iter(0..(m * n) as i32).into_shape((m, n)).unwrap() + Array::from_iter(0..(m * n) as i32).into_shape([m, n]).unwrap() } // simple, slow, correct (hopefully) mat mul @@ -315,7 +315,7 @@ fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase S: Data, S2: Data, { - let ((m, k), (k2, n)) = (lhs.dim(), rhs.dim()); + let ([m, k], [k2, n]) = (lhs.dim(), rhs.dim()); assert!(m.checked_mul(n).is_some()); assert_eq!(k, k2); let mut res_elems = Vec::::with_capacity(m * n); @@ -328,7 +328,7 @@ fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase for rr in &mut res_elems { unsafe { *rr = (0..k).fold(A::zero(), - move |s, x| s + *lhs.uget((i, x)) * *rhs.uget((x, j))); + move |s, x| s + *lhs.uget([i, x]) * *rhs.uget([x, j])); } j += 1; if j == n { @@ -337,7 +337,7 @@ fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase } } unsafe { - ArrayBase::from_shape_vec_unchecked((m, n), res_elems) + ArrayBase::from_shape_vec_unchecked([m, n], res_elems) } } @@ -348,9 +348,9 @@ fn reference_mat_vec_mul(lhs: &ArrayBase, rhs: &ArrayBase, S2: Data, { - let ((m, _), k) = (lhs.dim(), rhs.dim()); - reference_mat_mul(lhs, &rhs.to_owned().into_shape((k, 1)).unwrap()) - .into_shape(m).unwrap() + let ([m, _], [k]) = (lhs.dim(), rhs.dim()); + reference_mat_mul(lhs, &rhs.to_owned().into_shape([k, 1]).unwrap()) + .into_shape([m]).unwrap() } // simple, slow, correct (hopefully) mat mul @@ -360,14 +360,14 @@ fn reference_vec_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase, S2: Data, { - let (m, (_, n)) = (lhs.dim(), rhs.dim()); - reference_mat_mul(&lhs.to_owned().into_shape((1, m)).unwrap(), rhs) - .into_shape(n).unwrap() + let ([m], [_, n]) = (lhs.dim(), rhs.dim()); + reference_mat_mul(&lhs.to_owned().into_shape([1, m]).unwrap(), rhs) + .into_shape([n]).unwrap() } #[test] fn mat_mul() { - let (m, n, k) = (8, 8, 8); + let [m, n, k] = [8, 8, 8]; let a = range_mat(m, n); let b = range_mat(n, k); let mut b = b / 4.; @@ -386,7 +386,7 @@ fn mat_mul() { assert_eq!(ab, af.dot(&b)); assert_eq!(ab, af.dot(&bf)); - let (m, n, k) = (10, 5, 11); + let [m, n, k] = [10, 5, 11]; let a = range_mat(m, n); let b = range_mat(n, k); let mut b = b / 4.; @@ -405,7 +405,7 @@ fn mat_mul() { assert_eq!(ab, af.dot(&b)); assert_eq!(ab, af.dot(&bf)); - let (m, n, k) = (10, 8, 1); + let [m, n, k] = [10, 8, 1]; let a = range_mat(m, n); let b = range_mat(n, k); let mut b = b / 4.; @@ -429,7 +429,7 @@ fn mat_mul() { // matrix with the same order #[test] fn mat_mul_order() { - let (m, n, k) = (8, 8, 8); + let [m, n, k] = [8, 8, 8]; let a = range_mat(m, n); let b = range_mat(n, k); let mut af = Array::zeros(a.dim().f()); @@ -469,14 +469,14 @@ fn mat_mul_shape_mismatch_2() { // supports broadcast arrays. #[test] fn mat_mul_broadcast() { - let (m, n, k) = (16, 16, 16); + let [m, n, k] = [16, 16, 16]; let a = range_mat(m, n); let x1 = 1.; let x = Array::from_vec(vec![x1]); - let b0 = x.broadcast((n, k)).unwrap(); - let b1 = Array::from_elem(n, x1); - let b1 = b1.broadcast((n, k)).unwrap(); - let b2 = Array::from_elem((n, k), x1); + let b0 = x.broadcast([n, k]).unwrap(); + let b1 = Array::from_elem([n], x1); + let b1 = b1.broadcast([n, k]).unwrap(); + let b2 = Array::from_elem([n, k], x1); let c2 = a.dot(&b2); let c1 = a.dot(&b1); @@ -488,7 +488,7 @@ fn mat_mul_broadcast() { // Check that matrix multiplication supports reversed axes #[test] fn mat_mul_rev() { - let (m, n, k) = (16, 16, 16); + let [m, n, k] = [16, 16, 16]; let a = range_mat(m, n); let b = range_mat(n, k); let mut rev = Array::zeros(b.dim()); @@ -509,12 +509,12 @@ fn mat_mut_zero_len() { for m in 0..4 { let a = range_mat_fn(m, n); let b = range_mat_fn(n, 0); - assert_eq!(a.dot(&b), Array2::zeros((m, 0))); + assert_eq!(a.dot(&b), Array2::zeros([m, 0])); } for k in 0..4 { let a = range_mat_fn(0, n); let b = range_mat_fn(n, k); - assert_eq!(a.dot(&b), Array2::zeros((0, k))); + assert_eq!(a.dot(&b), Array2::zeros([0, k])); } } }); @@ -627,19 +627,19 @@ fn scaled_add_3() { fn gen_mat_mul() { let alpha = -2.3; let beta = 3.14; - let sizes = vec![(4, 4, 4), (8, 8, 8), - (17, 15, 16), - (4, 17, 3), - (17, 3, 22), - (19, 18, 2), - (16, 17, 15), - (15, 16, 17), - (67, 63, 62), + let sizes = vec![[4, 4, 4], [8, 8, 8], + [17, 15, 16], + [4, 17, 3], + [17, 3, 22], + [19, 18, 2], + [16, 17, 15], + [15, 16, 17], + [67, 63, 62], ]; // test different strides for &s1 in &[1, 2, -1, -2] { for &s2 in &[1, 2, -1, -2] { - for &(m, k, n) in &sizes { + for &[m, k, n] in &sizes { let a = range_mat64(m, k); let b = range_mat64(k, n); let mut c = range_mat64(m, n); @@ -666,7 +666,7 @@ fn gen_mat_mul() { #[test] fn gemm_64_1_f() { let a = range_mat64(64, 64).reversed_axes(); - let (m, n) = a.dim(); + let [m, n] = a.dim(); // m x n times n x 1 == m x 1 let x = range_mat64(n, 1); let mut y = range_mat64(m, 1); @@ -679,16 +679,16 @@ fn gemm_64_1_f() { fn gen_mat_mul_i32() { let alpha = -1; let beta = 2; - let sizes = vec![(4, 4, 4), (8, 8, 8), - (17, 15, 16), - (4, 17, 3), - (17, 3, 22), - (19, 18, 2), - (16, 17, 15), - (15, 16, 17), - (67, 63, 62), + let sizes = vec![[4, 4, 4], [8, 8, 8], + [17, 15, 16], + [4, 17, 3], + [17, 3, 22], + [19, 18, 2], + [16, 17, 15], + [15, 16, 17], + [67, 63, 62], ]; - for &(m, k, n) in &sizes { + for &[m, k, n] in &sizes { let a = range_i32(m, k); let b = range_i32(k, n); let mut c = range_i32(m, n); @@ -722,7 +722,7 @@ fn gen_mat_vec_mul() { if rev { a = a.reversed_axes(); } - let (m, k) = a.dim(); + let [m, k] = a.dim(); let b = range1_mat64(k); let mut c = range1_mat64(m); let mut answer = c.clone(); @@ -765,7 +765,7 @@ fn vec_mat_mul() { if rev { b = b.reversed_axes(); } - let (m, n) = b.dim(); + let [m, n] = b.dim(); let a = range1_mat64(m); let mut c = range1_mat64(n); let mut answer = c.clone(); diff --git a/tests/par_azip.rs b/tests/par_azip.rs index 4ffe5b347..f8dd6da72 100644 --- a/tests/par_azip.rs +++ b/tests/par_azip.rs @@ -10,16 +10,16 @@ use std::sync::atomic::{AtomicUsize, Ordering}; #[test] fn test_par_azip1() { - let mut a = Array::zeros(62); - let b = Array::from_elem(62, 42); + let mut a = Array::zeros([62]); + let b = Array::from_elem([62], 42); par_azip!(mut a in { *a = 42 }); assert_eq!(a, b); } #[test] fn test_par_azip2() { - let mut a = Array::zeros((5, 7)); - let b = Array::from_shape_fn(a.dim(), |(i, j)| 1. / (i + 2*j) as f32); + let mut a = Array::zeros([5, 7]); + let b = Array::from_shape_fn(a.dim(), |[i, j]| 1. / (i + 2*j) as f32); par_azip!(mut a, b in { *a = b; }); assert_eq!(a, b); } @@ -44,16 +44,16 @@ fn test_par_azip3() { #[should_panic] #[test] fn test_zip_dim_mismatch_1() { - let mut a = Array::zeros((5, 7)); + let mut a = Array::zeros([5, 7]); let mut d = a.raw_dim(); d[0] += 1; - let b = Array::from_shape_fn(d, |(i, j)| 1. / (i + 2*j) as f32); + let b = Array::from_shape_fn(d, |[i, j]| 1. / (i + 2*j) as f32); par_azip!(mut a, b in { *a = b; }); } #[test] fn test_indices_1() { - let mut a1 = Array::default(12); + let mut a1 = Array::default([12]); for (i, elt) in a1.indexed_iter_mut() { *elt = i; } diff --git a/tests/par_rayon.rs b/tests/par_rayon.rs index 70b69e0eb..4b2169d6f 100644 --- a/tests/par_rayon.rs +++ b/tests/par_rayon.rs @@ -13,7 +13,7 @@ const N: usize = 100; #[test] fn test_axis_iter() { - let mut a = Array2::::zeros((M, N)); + let mut a = Array2::::zeros([M, N]); for (i, mut v) in a.axis_iter_mut(Axis(0)).enumerate() { v.fill(i as _); } @@ -25,7 +25,7 @@ fn test_axis_iter() { #[test] fn test_axis_iter_mut() { - let mut a = Array::linspace(0., 1.0f64, M * N).into_shape((M, N)).unwrap(); + let mut a = Array::linspace(0., 1.0f64, M * N).into_shape([M, N]).unwrap(); let b = a.mapv(|x| x.exp()); a.axis_iter_mut(Axis(0)).into_par_iter().for_each(|mut v| v.mapv_inplace(|x| x.exp())); println!("{:?}", a.slice(s![..10, ..5])); @@ -34,7 +34,7 @@ fn test_axis_iter_mut() { #[test] fn test_regular_iter() { - let mut a = Array2::::zeros((M, N)); + let mut a = Array2::::zeros([M, N]); for (i, mut v) in a.axis_iter_mut(Axis(0)).enumerate() { v.fill(i as _); } @@ -45,7 +45,7 @@ fn test_regular_iter() { #[test] fn test_regular_iter_collect() { - let mut a = Array2::::zeros((M, N)); + let mut a = Array2::::zeros([M, N]); for (i, mut v) in a.axis_iter_mut(Axis(0)).enumerate() { v.fill(i as _); } diff --git a/tests/par_zip.rs b/tests/par_zip.rs index 9cba9888c..6b266a3bd 100644 --- a/tests/par_zip.rs +++ b/tests/par_zip.rs @@ -12,7 +12,7 @@ const N: usize = 100; #[test] fn test_zip_1() { - let mut a = Array2::::zeros((M, N)); + let mut a = Array2::::zeros([M, N]); Zip::from(&mut a) .par_apply(|x| { @@ -22,7 +22,7 @@ fn test_zip_1() { #[test] fn test_zip_index_1() { - let mut a = Array2::default((10, 10)); + let mut a = Array2::default([10, 10]); Zip::indexed(&mut a) .par_apply(|i, x| { @@ -36,7 +36,7 @@ fn test_zip_index_1() { #[test] fn test_zip_index_2() { - let mut a = Array2::default((M, N)); + let mut a = Array2::default([M, N]); Zip::indexed(&mut a) .par_apply(|i, x| { @@ -50,7 +50,7 @@ fn test_zip_index_2() { #[test] fn test_zip_index_3() { - let mut a = Array::default((1, 2, 1, 2, 3)); + let mut a = Array::default([1, 2, 1, 2, 3]); Zip::indexed(&mut a) .par_apply(|i, x| { @@ -64,20 +64,20 @@ fn test_zip_index_3() { #[test] fn test_zip_index_4() { - let mut a = Array2::zeros((M, N)); - let mut b = Array2::zeros((M, N)); + let mut a = Array2::zeros([M, N]); + let mut b = Array2::zeros([M, N]); Zip::indexed(&mut a) .and(&mut b) - .par_apply(|(i, j), x, y| { + .par_apply(|[i, j], x, y| { *x = i; *y = j; }); - for ((i, _), elt) in a.indexed_iter() { + for ([i, _], elt) in a.indexed_iter() { assert_eq!(*elt, i); } - for ((_, j), elt) in b.indexed_iter() { + for ([_, j], elt) in b.indexed_iter() { assert_eq!(*elt, j); } } diff --git a/tests/s.rs b/tests/s.rs index 2705b649e..d47110322 100644 --- a/tests/s.rs +++ b/tests/s.rs @@ -5,7 +5,7 @@ use ndarray::{s, Array}; #[test] fn test_s() { - let a = Array::::zeros((3, 4)); + let a = Array::::zeros([3, 4]); let vi = a.slice(s![1.., ..;2]); assert_eq!(vi.shape(), &[2, 2]); diff --git a/tests/windows.rs b/tests/windows.rs index 1155be4a0..d4c43d3f9 100644 --- a/tests/windows.rs +++ b/tests/windows.rs @@ -23,27 +23,27 @@ use ndarray::Zip; #[should_panic] fn windows_iterator_zero_size() { let a = Array::from_iter(10..37) - .into_shape((3, 3, 3)) + .into_shape([3, 3, 3]) .unwrap(); - a.windows(Dim((0, 0, 0))); + a.windows(Dim([0, 0, 0])); } /// Test that verifites that no windows are yielded on oversized window sizes. #[test] fn windows_iterator_oversized() { let a = Array::from_iter(10..37) - .into_shape((3, 3, 3)) + .into_shape([3, 3, 3]) .unwrap(); - let mut iter = a.windows((4, 3, 2)).into_iter(); // (4,3,2) doesn't fit into (3,3,3) => oversized! + let mut iter = a.windows([4, 3, 2]).into_iter(); // (4,3,2) doesn't fit into (3,3,3) => oversized! assert_eq!(iter.next(), None); } /// Simple test for iterating 1d-arrays via `Windows`. #[test] fn windows_iterator_1d() { - let a = Array::from_iter(10..20).into_shape(10).unwrap(); + let a = Array::from_iter(10..20).into_shape([10]).unwrap(); itertools::assert_equal( - a.windows(Dim(4)), + a.windows(Dim([4])), vec![ arr1(&[10, 11, 12, 13]), arr1(&[11, 12, 13, 14]), @@ -58,9 +58,9 @@ fn windows_iterator_1d() { /// Simple test for iterating 2d-arrays via `Windows`. #[test] fn windows_iterator_2d() { - let a = Array::from_iter(10..30).into_shape((5, 4)).unwrap(); + let a = Array::from_iter(10..30).into_shape([5, 4]).unwrap(); itertools::assert_equal( - a.windows(Dim((3, 2))), + a.windows(Dim([3, 2])), vec![ arr2(&[ [10, 11], [14, 15], [18, 19] ]), arr2(&[ [11, 12], [15, 16], [19, 20] ]), @@ -80,9 +80,9 @@ fn windows_iterator_2d() { #[test] fn windows_iterator_3d() { use ndarray::arr3; - let a = Array::from_iter(10..37).into_shape((3, 3, 3)).unwrap(); + let a = Array::from_iter(10..37).into_shape([3, 3, 3]).unwrap(); itertools::assert_equal( - a.windows(Dim((2, 2, 2))), + a.windows(Dim([2, 2, 2])), vec![ arr3(&[ [[10, 11], [13, 14]], [[19, 20], [22, 23]] ]), arr3(&[ [[11, 12], [14, 15]], [[20, 21], [23, 24]] ]), @@ -100,13 +100,13 @@ fn windows_iterator_3d() { #[test] fn test_window_zip() { - let a = Array::from_iter(0..64).into_shape((4, 4, 4)).unwrap(); + let a = Array::from_iter(0..64).into_shape([4, 4, 4]).unwrap(); for x in 1..4 { for y in 1..4 { for z in 1..4 { - Zip::indexed(a.windows((x, y, z))) - .apply(|(i, j, k), window| { + Zip::indexed(a.windows([x, y, z])) + .apply(|[i, j, k], window| { let x = x as isize; let y = y as isize; let z = z as isize; diff --git a/tests/zst.rs b/tests/zst.rs index e8fababb3..a6acedd4e 100644 --- a/tests/zst.rs +++ b/tests/zst.rs @@ -12,7 +12,7 @@ fn test_swap() { for i in 0..a.rows() { for j in i + 1..a.cols() { - a.swap((i, j), (j, i)); + a.swap([i, j], [j, i]); } } assert_eq!(a, b.t()); @@ -20,7 +20,7 @@ fn test_swap() { #[test] fn test() { - let c = ArcArray::<(), _>::default((3, 4)); + let c = ArcArray::<(), _>::default([3, 4]); let mut d = c.clone(); for _ in d.iter_mut() {} }