11use  criterion:: { 
2-     black_box,  criterion_group,  criterion_main,  AxisScale ,  BatchSize ,  Criterion , 
3-     PlotConfiguration , 
2+     black_box,  criterion_group,  criterion_main,  AxisScale ,  BatchSize ,  Criterion ,  PlotConfiguration , 
43} ; 
54use  ndarray:: prelude:: * ; 
65use  ndarray_stats:: Sort1dExt ; 
@@ -9,53 +8,45 @@ use rand::prelude::*;
98fn  get_from_sorted_mut ( c :  & mut  Criterion )  { 
109    let  lens = vec ! [ 10 ,  100 ,  1000 ,  10000 ] ; 
1110    let  mut  group = c. benchmark_group ( "get_from_sorted_mut" ) ; 
12-     group. plot_config ( 
13-         PlotConfiguration :: default ( ) . summary_scale ( AxisScale :: Logarithmic ) ) ; 
11+     group. plot_config ( PlotConfiguration :: default ( ) . summary_scale ( AxisScale :: Logarithmic ) ) ; 
1412    for  len in  & lens { 
15-         group. bench_with_input ( 
16-             format ! ( "{}" ,  len) , 
17-             len, 
18-             |b,  & len| { 
19-                 let  mut  rng = StdRng :: seed_from_u64 ( 42 ) ; 
20-                 let  mut  data:  Vec < _ >  = ( 0 ..len) . collect ( ) ; 
21-                 data. shuffle ( & mut  rng) ; 
22-                 let  indices:  Vec < _ >  = ( 0 ..len) . step_by ( len / 10 ) . collect ( ) ; 
23-                 b. iter_batched ( 
24-                     || Array1 :: from ( data. clone ( ) ) , 
25-                     |mut  arr| { 
26-                         for  & i in  & indices { 
27-                             black_box ( arr. get_from_sorted_mut ( i) ) ; 
28-                         } 
29-                     } , 
30-                     BatchSize :: SmallInput , 
31-                 ) 
32-             } ) ; 
13+         group. bench_with_input ( format ! ( "{}" ,  len) ,  len,  |b,  & len| { 
14+             let  mut  rng = StdRng :: seed_from_u64 ( 42 ) ; 
15+             let  mut  data:  Vec < _ >  = ( 0 ..len) . collect ( ) ; 
16+             data. shuffle ( & mut  rng) ; 
17+             let  indices:  Vec < _ >  = ( 0 ..len) . step_by ( len / 10 ) . collect ( ) ; 
18+             b. iter_batched ( 
19+                 || Array1 :: from ( data. clone ( ) ) , 
20+                 |mut  arr| { 
21+                     for  & i in  & indices { 
22+                         black_box ( arr. get_from_sorted_mut ( i) ) ; 
23+                     } 
24+                 } , 
25+                 BatchSize :: SmallInput , 
26+             ) 
27+         } ) ; 
3328    } 
3429    group. finish ( ) ; 
3530} 
3631
3732fn  get_many_from_sorted_mut ( c :  & mut  Criterion )  { 
3833    let  lens = vec ! [ 10 ,  100 ,  1000 ,  10000 ] ; 
3934    let  mut  group = c. benchmark_group ( "get_many_from_sorted_mut" ) ; 
40-     group. plot_config ( 
41-         PlotConfiguration :: default ( ) . summary_scale ( AxisScale :: Logarithmic ) ) ; 
35+     group. plot_config ( PlotConfiguration :: default ( ) . summary_scale ( AxisScale :: Logarithmic ) ) ; 
4236    for  len in  & lens { 
43-         group. bench_with_input ( 
44-             format ! ( "{}" ,  len) , 
45-             len, 
46-             |b,  & len| { 
47-                 let  mut  rng = StdRng :: seed_from_u64 ( 42 ) ; 
48-                 let  mut  data:  Vec < _ >  = ( 0 ..len) . collect ( ) ; 
49-                 data. shuffle ( & mut  rng) ; 
50-                 let  indices:  Array1 < _ >  = ( 0 ..len) . step_by ( len / 10 ) . collect ( ) ; 
51-                 b. iter_batched ( 
52-                     || Array1 :: from ( data. clone ( ) ) , 
53-                     |mut  arr| { 
54-                         black_box ( arr. get_many_from_sorted_mut ( & indices) ) ; 
55-                     } , 
56-                     BatchSize :: SmallInput , 
57-                 ) 
58-             } ) ; 
37+         group. bench_with_input ( format ! ( "{}" ,  len) ,  len,  |b,  & len| { 
38+             let  mut  rng = StdRng :: seed_from_u64 ( 42 ) ; 
39+             let  mut  data:  Vec < _ >  = ( 0 ..len) . collect ( ) ; 
40+             data. shuffle ( & mut  rng) ; 
41+             let  indices:  Array1 < _ >  = ( 0 ..len) . step_by ( len / 10 ) . collect ( ) ; 
42+             b. iter_batched ( 
43+                 || Array1 :: from ( data. clone ( ) ) , 
44+                 |mut  arr| { 
45+                     black_box ( arr. get_many_from_sorted_mut ( & indices) ) ; 
46+                 } , 
47+                 BatchSize :: SmallInput , 
48+             ) 
49+         } ) ; 
5950    } 
6051    group. finish ( ) ; 
6152} 
0 commit comments