[INFO] crate sorting_networks 0.1.0 is already in cache [INFO] extracting crate sorting_networks 0.1.0 into work/ex/clippy-test-run/sources/stable/reg/sorting_networks/0.1.0 [INFO] extracting crate sorting_networks 0.1.0 into work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/reg/sorting_networks/0.1.0 [INFO] validating manifest of sorting_networks-0.1.0 on toolchain stable [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "read-manifest" "--manifest-path" "Cargo.toml"` [INFO] validating manifest of sorting_networks-0.1.0 on toolchain stable+rustflags=-Dclippy::into_iter_on_array [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "read-manifest" "--manifest-path" "Cargo.toml"` [INFO] started frobbing sorting_networks-0.1.0 [INFO] finished frobbing sorting_networks-0.1.0 [INFO] frobbed toml for sorting_networks-0.1.0 written to work/ex/clippy-test-run/sources/stable/reg/sorting_networks/0.1.0/Cargo.toml [INFO] started frobbing sorting_networks-0.1.0 [INFO] finished frobbing sorting_networks-0.1.0 [INFO] frobbed toml for sorting_networks-0.1.0 written to work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/reg/sorting_networks/0.1.0/Cargo.toml [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update"` [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update"` [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "fetch" "--locked" "--manifest-path" "Cargo.toml"` [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "fetch" "--locked" "--manifest-path" "Cargo.toml"` [INFO] linting sorting_networks-0.1.0 against stable for clippy-test-run [INFO] running `"docker" "create" "-v" "/mnt/big/crater/work/local/target-dirs/clippy-test-run/worker-4/stable:/opt/crater/target:rw,Z" "-v" "/mnt/big/crater/work/ex/clippy-test-run/sources/stable/reg/sorting_networks/0.1.0:/opt/crater/workdir:ro,Z" "-v" "/mnt/big/crater/work/local/cargo-home:/opt/crater/cargo-home:ro,Z" "-v" "/mnt/big/crater/work/local/rustup-home:/opt/crater/rustup-home:ro,Z" "-e" "USER_ID=1000" "-e" "SOURCE_DIR=/opt/crater/workdir" "-e" "MAP_USER_ID=1000" "-e" "CARGO_TARGET_DIR=/opt/crater/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/crater/cargo-home" "-e" "RUSTUP_HOME=/opt/crater/rustup-home" "-w" "/opt/crater/workdir" "-m" "1536M" "--network" "none" "rustops/crates-build-env" "/opt/crater/cargo-home/bin/cargo" "+stable" "clippy" "--frozen" "--all" "--all-targets"` [INFO] [stdout] ad03814beca27ebe01de89630cf33d0db18413a33718598f4160e8a1337c0683 [INFO] running `"docker" "start" "-a" "ad03814beca27ebe01de89630cf33d0db18413a33718598f4160e8a1337c0683"` [INFO] [stderr] Compiling sorting_networks v0.1.0 (/opt/crater/workdir) [INFO] [stderr] warning: returning the result of a let binding from a block. Consider returning the expression directly. [INFO] [stderr] --> src/debug.rs:16:13 [INFO] [stderr] | [INFO] [stderr] 16 | group_width [INFO] [stderr] | ^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::let_and_return)] on by default [INFO] [stderr] note: this expression can be directly returned [INFO] [stderr] --> src/debug.rs:12:31 [INFO] [stderr] | [INFO] [stderr] 12 | let group_width = (0..stage_count).fold(0, |width, stage| { [INFO] [stderr] | _______________________________^ [INFO] [stderr] 13 | | let stage_width = 1 << stage; [INFO] [stderr] 14 | | width + stage_width [INFO] [stderr] 15 | | }); [INFO] [stderr] | |______________^ [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return [INFO] [stderr] [INFO] [stderr] warning: long literal lacking separators [INFO] [stderr] --> /opt/crater/target/debug/build/sorting_networks-48e4135488fdd1a6/out/generated.rs:1:12807 [INFO] [stderr] | [INFO] [stderr] 1 | use std :: cmp :: Ordering ; # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork2 ; impl SortingNetwork2 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork2 } } impl SortingNetworkTrait for SortingNetwork2 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 2usize , "Expected slice of length {}" , 2usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork1 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 1usize ] = [ ( 0u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork2 { # [ inline ] fn order ( ) -> usize { 1usize } } impl :: std :: fmt :: Debug for SortingNetwork2 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 1usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork4 ; impl SortingNetwork4 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork4 } } impl SortingNetworkTrait for SortingNetwork4 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 4usize , "Expected slice of length {}" , 4usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork2 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 2usize ] = [ ( 0u8 , 1u8 , 2u8 ) , ( 1u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork4 { # [ inline ] fn order ( ) -> usize { 2usize } } impl :: std :: fmt :: Debug for SortingNetwork4 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 2usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork8 ; impl SortingNetwork8 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork8 } } impl SortingNetworkTrait for SortingNetwork8 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 8usize , "Expected slice of length {}" , 8usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork4 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 3usize ] = [ ( 0u8 , 1u8 , 4u8 ) , ( 2u8 , 1u8 , 2u8 ) , ( 1u8 , 3u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork8 { # [ inline ] fn order ( ) -> usize { 3usize } } impl :: std :: fmt :: Debug for SortingNetwork8 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 3usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork16 ; impl SortingNetwork16 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork16 } } impl SortingNetworkTrait for SortingNetwork16 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 16usize , "Expected slice of length {}" , 16usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork8 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 4usize ] = [ ( 0u8 , 1u8 , 8u8 ) , ( 4u8 , 1u8 , 4u8 ) , ( 2u8 , 3u8 , 2u8 ) , ( 1u8 , 7u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork16 { # [ inline ] fn order ( ) -> usize { 4usize } } impl :: std :: fmt :: Debug for SortingNetwork16 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 4usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork32 ; impl SortingNetwork32 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork32 } } impl SortingNetworkTrait for SortingNetwork32 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 32usize , "Expected slice of length {}" , 32usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork16 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 5usize ] = [ ( 0u8 , 1u8 , 16u8 ) , ( 8u8 , 1u8 , 8u8 ) , ( 4u8 , 3u8 , 4u8 ) , ( 2u8 , 7u8 , 2u8 ) , ( 1u8 , 15u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork32 { # [ inline ] fn order ( ) -> usize { 5usize } } impl :: std :: fmt :: Debug for SortingNetwork32 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 5usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork64 ; impl SortingNetwork64 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork64 } } impl SortingNetworkTrait for SortingNetwork64 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 64usize , "Expected slice of length {}" , 64usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork32 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 6usize ] = [ ( 0u8 , 1u8 , 32u8 ) , ( 16u8 , 1u8 , 16u8 ) , ( 8u8 , 3u8 , 8u8 ) , ( 4u8 , 7u8 , 4u8 ) , ( 2u8 , 15u8 , 2u8 ) , ( 1u8 , 31u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork64 { # [ inline ] fn order ( ) -> usize { 6usize } } impl :: std :: fmt :: Debug for SortingNetwork64 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 6usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork128 ; impl SortingNetwork128 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork128 } } impl SortingNetworkTrait for SortingNetwork128 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 128usize , "Expected slice of length {}" , 128usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork64 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 7usize ] = [ ( 0u8 , 1u8 , 64u8 ) , ( 32u8 , 1u8 , 32u8 ) , ( 16u8 , 3u8 , 16u8 ) , ( 8u8 , 7u8 , 8u8 ) , ( 4u8 , 15u8 , 4u8 ) , ( 2u8 , 31u8 , 2u8 ) , ( 1u8 , 63u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork128 { # [ inline ] fn order ( ) -> usize { 7usize } } impl :: std :: fmt :: Debug for SortingNetwork128 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 7usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork256 ; impl SortingNetwork256 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork256 } } impl SortingNetworkTrait for SortingNetwork256 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 256usize , "Expected slice of length {}" , 256usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork128 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 8usize ] = [ ( 0u8 , 1u8 , 128u8 ) , ( 64u8 , 1u8 , 64u8 ) , ( 32u8 , 3u8 , 32u8 ) , ( 16u8 , 7u8 , 16u8 ) , ( 8u8 , 15u8 , 8u8 ) , ( 4u8 , 31u8 , 4u8 ) , ( 2u8 , 63u8 , 2u8 ) , ( 1u8 , 127u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork256 { # [ inline ] fn order ( ) -> usize { 8usize } } impl :: std :: fmt :: Debug for SortingNetwork256 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 8usize , f ) } } # [ cfg ( test ) ] mod sorting_network { use std :: prelude :: v1 :: * ; use super :: * ; fn shuffled ( length : usize ) -> Vec < usize > { let prime = 313373 ; let sorted : Vec < _ > = ( 0 .. length ) . collect ( ) ; ( 0 .. length ) . map ( | i | sorted [ ( i * prime ) % length ] ) . collect ( ) } mod length_2 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 2usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork2 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 2usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_4 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 4usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork4 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 4usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_8 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 8usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork8 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 8usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_16 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 16usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork16 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 16usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_32 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 32usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork32 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 32usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_64 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 64usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork64 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 64usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_128 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 128usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork128 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 128usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_256 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 256usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork256 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 256usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } } [INFO] [stderr] | ^^^^^^ help: consider: `313_373` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::unreadable_literal)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal [INFO] [stderr] [INFO] [stderr] error[E0554]: #![feature] may not be used on the stable release channel [INFO] [stderr] --> src/lib.rs:2:24 [INFO] [stderr] | [INFO] [stderr] 2 | #![cfg_attr(not(test), feature(lang_items))] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] error: aborting due to previous error [INFO] [stderr] [INFO] [stderr] For more information about this error, try `rustc --explain E0554`. [INFO] [stderr] error: Could not compile `sorting_networks`. [INFO] [stderr] warning: build failed, waiting for other jobs to finish... [INFO] [stderr] warning: the loop variable `y` is used to index `wires` [INFO] [stderr] --> src/debug.rs:33:34 [INFO] [stderr] | [INFO] [stderr] 33 | for y in (pair.min)..(pair.max + 1) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::needless_range_loop)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop [INFO] [stderr] help: consider using an iterator [INFO] [stderr] | [INFO] [stderr] 33 | for (y, ) in wires.iter_mut().enumerate().take((pair.max + 1)).skip((pair.min)) { [INFO] [stderr] | ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: an inclusive range would be more readable [INFO] [stderr] --> src/debug.rs:33:34 [INFO] [stderr] | [INFO] [stderr] 33 | for y in (pair.min)..(pair.max + 1) { [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `((pair.min)..=pair.max)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::range_plus_one)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one [INFO] [stderr] [INFO] [stderr] warning: use of `offset` with a `usize` casted to an `isize` [INFO] [stderr] --> src/lib.rs:39:19 [INFO] [stderr] | [INFO] [stderr] 39 | let lhs_ptr = ptr.offset(lhs as isize); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr.add(lhs)` [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::ptr_offset_with_cast)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#ptr_offset_with_cast [INFO] [stderr] [INFO] [stderr] warning: use of `offset` with a `usize` casted to an `isize` [INFO] [stderr] --> src/lib.rs:40:19 [INFO] [stderr] | [INFO] [stderr] 40 | let rhs_ptr = ptr.offset(rhs as isize); [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr.add(rhs)` [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#ptr_offset_with_cast [INFO] [stderr] [INFO] [stderr] warning: you should consider deriving a `Default` implementation for `SortingNetwork` [INFO] [stderr] --> src/lib.rs:84:5 [INFO] [stderr] | [INFO] [stderr] 84 | / pub fn new() -> Self { [INFO] [stderr] 85 | | SortingNetwork [INFO] [stderr] 86 | | } [INFO] [stderr] | |_____^ [INFO] [stderr] | [INFO] [stderr] = note: #[warn(clippy::new_without_default_derive)] on by default [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default_derive [INFO] [stderr] help: try this [INFO] [stderr] | [INFO] [stderr] 81 | #[derive(Default)] [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] warning: you should consider deriving a `Default` implementation for `SortingNetwork2` [INFO] [stderr] --> /opt/crater/target/debug/build/sorting_networks-48e4135488fdd1a6/out/generated.rs:1:271 [INFO] [stderr] | [INFO] [stderr] 1 | use std :: cmp :: Ordering ; # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork2 ; impl SortingNetwork2 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork2 } } impl SortingNetworkTrait for SortingNetwork2 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 2usize , "Expected slice of length {}" , 2usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork1 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 1usize ] = [ ( 0u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork2 { # [ inline ] fn order ( ) -> usize { 1usize } } impl :: std :: fmt :: Debug for SortingNetwork2 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 1usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork4 ; impl SortingNetwork4 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork4 } } impl SortingNetworkTrait for SortingNetwork4 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 4usize , "Expected slice of length {}" , 4usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork2 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 2usize ] = [ ( 0u8 , 1u8 , 2u8 ) , ( 1u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork4 { # [ inline ] fn order ( ) -> usize { 2usize } } impl :: std :: fmt :: Debug for SortingNetwork4 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 2usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork8 ; impl SortingNetwork8 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork8 } } impl SortingNetworkTrait for SortingNetwork8 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 8usize , "Expected slice of length {}" , 8usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork4 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 3usize ] = [ ( 0u8 , 1u8 , 4u8 ) , ( 2u8 , 1u8 , 2u8 ) , ( 1u8 , 3u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork8 { # [ inline ] fn order ( ) -> usize { 3usize } } impl :: std :: fmt :: Debug for SortingNetwork8 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 3usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork16 ; impl SortingNetwork16 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork16 } } impl SortingNetworkTrait for SortingNetwork16 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 16usize , "Expected slice of length {}" , 16usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork8 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 4usize ] = [ ( 0u8 , 1u8 , 8u8 ) , ( 4u8 , 1u8 , 4u8 ) , ( 2u8 , 3u8 , 2u8 ) , ( 1u8 , 7u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork16 { # [ inline ] fn order ( ) -> usize { 4usize } } impl :: std :: fmt :: Debug for SortingNetwork16 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 4usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork32 ; impl SortingNetwork32 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork32 } } impl SortingNetworkTrait for SortingNetwork32 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 32usize , "Expected slice of length {}" , 32usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork16 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 5usize ] = [ ( 0u8 , 1u8 , 16u8 ) , ( 8u8 , 1u8 , 8u8 ) , ( 4u8 , 3u8 , 4u8 ) , ( 2u8 , 7u8 , 2u8 ) , ( 1u8 , 15u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork32 { # [ inline ] fn order ( ) -> usize { 5usize } } impl :: std :: fmt :: Debug for SortingNetwork32 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 5usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork64 ; impl SortingNetwork64 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork64 } } impl SortingNetworkTrait for SortingNetwork64 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 64usize , "Expected slice of length {}" , 64usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork32 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 6usize ] = [ ( 0u8 , 1u8 , 32u8 ) , ( 16u8 , 1u8 , 16u8 ) , ( 8u8 , 3u8 , 8u8 ) , ( 4u8 , 7u8 , 4u8 ) , ( 2u8 , 15u8 , 2u8 ) , ( 1u8 , 31u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork64 { # [ inline ] fn order ( ) -> usize { 6usize } } impl :: std :: fmt :: Debug for SortingNetwork64 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 6usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork128 ; impl SortingNetwork128 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork128 } } impl SortingNetworkTrait for SortingNetwork128 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 128usize , "Expected slice of length {}" , 128usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork64 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 7usize ] = [ ( 0u8 , 1u8 , 64u8 ) , ( 32u8 , 1u8 , 32u8 ) , ( 16u8 , 3u8 , 16u8 ) , ( 8u8 , 7u8 , 8u8 ) , ( 4u8 , 15u8 , 4u8 ) , ( 2u8 , 31u8 , 2u8 ) , ( 1u8 , 63u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork128 { # [ inline ] fn order ( ) -> usize { 7usize } } impl :: std :: fmt :: Debug for SortingNetwork128 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 7usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork256 ; impl SortingNetwork256 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork256 } } impl SortingNetworkTrait for SortingNetwork256 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 256usize , "Expected slice of length {}" , 256usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork128 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 8usize ] = [ ( 0u8 , 1u8 , 128u8 ) , ( 64u8 , 1u8 , 64u8 ) , ( 32u8 , 3u8 , 32u8 ) , ( 16u8 , 7u8 , 16u8 ) , ( 8u8 , 15u8 , 8u8 ) , ( 4u8 , 31u8 , 4u8 ) , ( 2u8 , 63u8 , 2u8 ) , ( 1u8 , 127u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork256 { # [ inline ] fn order ( ) -> usize { 8usize } } impl :: std :: fmt :: Debug for SortingNetwork256 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 8usize , f ) } } # [ cfg ( test ) ] mod sorting_network { use std :: prelude :: v1 :: * ; use super :: * ; fn shuffled ( length : usize ) -> Vec < usize > { let prime = 313373 ; let sorted : Vec < _ > = ( 0 .. length ) . collect ( ) ; ( 0 .. length ) . map ( | i | sorted [ ( i * prime ) % length ] ) . collect ( ) } mod length_2 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 2usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork2 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 2usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_4 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 4usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork4 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 4usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_8 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 8usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork8 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 8usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_16 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 16usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork16 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 16usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_32 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 32usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork32 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 32usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_64 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 64usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork64 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 64usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_128 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 128usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork128 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 128usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_256 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 256usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork256 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 256usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default_derive [INFO] [stderr] [INFO] [stderr] warning: you should consider deriving a `Default` implementation for `SortingNetwork4` [INFO] [stderr] --> /opt/crater/target/debug/build/sorting_networks-48e4135488fdd1a6/out/generated.rs:1:1761 [INFO] [stderr] | [INFO] [stderr] 1 | use std :: cmp :: Ordering ; # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork2 ; impl SortingNetwork2 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork2 } } impl SortingNetworkTrait for SortingNetwork2 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 2usize , "Expected slice of length {}" , 2usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork1 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 1usize ] = [ ( 0u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork2 { # [ inline ] fn order ( ) -> usize { 1usize } } impl :: std :: fmt :: Debug for SortingNetwork2 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 1usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork4 ; impl SortingNetwork4 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork4 } } impl SortingNetworkTrait for SortingNetwork4 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 4usize , "Expected slice of length {}" , 4usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork2 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 2usize ] = [ ( 0u8 , 1u8 , 2u8 ) , ( 1u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork4 { # [ inline ] fn order ( ) -> usize { 2usize } } impl :: std :: fmt :: Debug for SortingNetwork4 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 2usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork8 ; impl SortingNetwork8 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork8 } } impl SortingNetworkTrait for SortingNetwork8 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 8usize , "Expected slice of length {}" , 8usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork4 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 3usize ] = [ ( 0u8 , 1u8 , 4u8 ) , ( 2u8 , 1u8 , 2u8 ) , ( 1u8 , 3u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork8 { # [ inline ] fn order ( ) -> usize { 3usize } } impl :: std :: fmt :: Debug for SortingNetwork8 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 3usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork16 ; impl SortingNetwork16 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork16 } } impl SortingNetworkTrait for SortingNetwork16 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 16usize , "Expected slice of length {}" , 16usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork8 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 4usize ] = [ ( 0u8 , 1u8 , 8u8 ) , ( 4u8 , 1u8 , 4u8 ) , ( 2u8 , 3u8 , 2u8 ) , ( 1u8 , 7u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork16 { # [ inline ] fn order ( ) -> usize { 4usize } } impl :: std :: fmt :: Debug for SortingNetwork16 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 4usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork32 ; impl SortingNetwork32 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork32 } } impl SortingNetworkTrait for SortingNetwork32 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 32usize , "Expected slice of length {}" , 32usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork16 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 5usize ] = [ ( 0u8 , 1u8 , 16u8 ) , ( 8u8 , 1u8 , 8u8 ) , ( 4u8 , 3u8 , 4u8 ) , ( 2u8 , 7u8 , 2u8 ) , ( 1u8 , 15u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork32 { # [ inline ] fn order ( ) -> usize { 5usize } } impl :: std :: fmt :: Debug for SortingNetwork32 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 5usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork64 ; impl SortingNetwork64 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork64 } } impl SortingNetworkTrait for SortingNetwork64 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 64usize , "Expected slice of length {}" , 64usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork32 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 6usize ] = [ ( 0u8 , 1u8 , 32u8 ) , ( 16u8 , 1u8 , 16u8 ) , ( 8u8 , 3u8 , 8u8 ) , ( 4u8 , 7u8 , 4u8 ) , ( 2u8 , 15u8 , 2u8 ) , ( 1u8 , 31u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork64 { # [ inline ] fn order ( ) -> usize { 6usize } } impl :: std :: fmt :: Debug for SortingNetwork64 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 6usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork128 ; impl SortingNetwork128 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork128 } } impl SortingNetworkTrait for SortingNetwork128 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 128usize , "Expected slice of length {}" , 128usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork64 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 7usize ] = [ ( 0u8 , 1u8 , 64u8 ) , ( 32u8 , 1u8 , 32u8 ) , ( 16u8 , 3u8 , 16u8 ) , ( 8u8 , 7u8 , 8u8 ) , ( 4u8 , 15u8 , 4u8 ) , ( 2u8 , 31u8 , 2u8 ) , ( 1u8 , 63u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork128 { # [ inline ] fn order ( ) -> usize { 7usize } } impl :: std :: fmt :: Debug for SortingNetwork128 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 7usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork256 ; impl SortingNetwork256 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork256 } } impl SortingNetworkTrait for SortingNetwork256 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 256usize , "Expected slice of length {}" , 256usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork128 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 8usize ] = [ ( 0u8 , 1u8 , 128u8 ) , ( 64u8 , 1u8 , 64u8 ) , ( 32u8 , 3u8 , 32u8 ) , ( 16u8 , 7u8 , 16u8 ) , ( 8u8 , 15u8 , 8u8 ) , ( 4u8 , 31u8 , 4u8 ) , ( 2u8 , 63u8 , 2u8 ) , ( 1u8 , 127u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork256 { # [ inline ] fn order ( ) -> usize { 8usize } } impl :: std :: fmt :: Debug for SortingNetwork256 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 8usize , f ) } } # [ cfg ( test ) ] mod sorting_network { use std :: prelude :: v1 :: * ; use super :: * ; fn shuffled ( length : usize ) -> Vec < usize > { let prime = 313373 ; let sorted : Vec < _ > = ( 0 .. length ) . collect ( ) ; ( 0 .. length ) . map ( | i | sorted [ ( i * prime ) % length ] ) . collect ( ) } mod length_2 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 2usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork2 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 2usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_4 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 4usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork4 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 4usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_8 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 8usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork8 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 8usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_16 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 16usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork16 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 16usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_32 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 32usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork32 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 32usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_64 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 64usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork64 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 64usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_128 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 128usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork128 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 128usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_256 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 256usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork256 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 256usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default_derive [INFO] [stderr] [INFO] [stderr] warning: you should consider deriving a `Default` implementation for `SortingNetwork8` [INFO] [stderr] --> /opt/crater/target/debug/build/sorting_networks-48e4135488fdd1a6/out/generated.rs:1:3273 [INFO] [stderr] | [INFO] [stderr] 1 | use std :: cmp :: Ordering ; # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork2 ; impl SortingNetwork2 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork2 } } impl SortingNetworkTrait for SortingNetwork2 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 2usize , "Expected slice of length {}" , 2usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork1 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 1usize ] = [ ( 0u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork2 { # [ inline ] fn order ( ) -> usize { 1usize } } impl :: std :: fmt :: Debug for SortingNetwork2 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 1usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork4 ; impl SortingNetwork4 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork4 } } impl SortingNetworkTrait for SortingNetwork4 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 4usize , "Expected slice of length {}" , 4usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork2 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 2usize ] = [ ( 0u8 , 1u8 , 2u8 ) , ( 1u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork4 { # [ inline ] fn order ( ) -> usize { 2usize } } impl :: std :: fmt :: Debug for SortingNetwork4 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 2usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork8 ; impl SortingNetwork8 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork8 } } impl SortingNetworkTrait for SortingNetwork8 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 8usize , "Expected slice of length {}" , 8usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork4 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 3usize ] = [ ( 0u8 , 1u8 , 4u8 ) , ( 2u8 , 1u8 , 2u8 ) , ( 1u8 , 3u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork8 { # [ inline ] fn order ( ) -> usize { 3usize } } impl :: std :: fmt :: Debug for SortingNetwork8 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 3usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork16 ; impl SortingNetwork16 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork16 } } impl SortingNetworkTrait for SortingNetwork16 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 16usize , "Expected slice of length {}" , 16usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork8 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 4usize ] = [ ( 0u8 , 1u8 , 8u8 ) , ( 4u8 , 1u8 , 4u8 ) , ( 2u8 , 3u8 , 2u8 ) , ( 1u8 , 7u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork16 { # [ inline ] fn order ( ) -> usize { 4usize } } impl :: std :: fmt :: Debug for SortingNetwork16 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 4usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork32 ; impl SortingNetwork32 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork32 } } impl SortingNetworkTrait for SortingNetwork32 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 32usize , "Expected slice of length {}" , 32usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork16 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 5usize ] = [ ( 0u8 , 1u8 , 16u8 ) , ( 8u8 , 1u8 , 8u8 ) , ( 4u8 , 3u8 , 4u8 ) , ( 2u8 , 7u8 , 2u8 ) , ( 1u8 , 15u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork32 { # [ inline ] fn order ( ) -> usize { 5usize } } impl :: std :: fmt :: Debug for SortingNetwork32 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 5usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork64 ; impl SortingNetwork64 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork64 } } impl SortingNetworkTrait for SortingNetwork64 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 64usize , "Expected slice of length {}" , 64usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork32 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 6usize ] = [ ( 0u8 , 1u8 , 32u8 ) , ( 16u8 , 1u8 , 16u8 ) , ( 8u8 , 3u8 , 8u8 ) , ( 4u8 , 7u8 , 4u8 ) , ( 2u8 , 15u8 , 2u8 ) , ( 1u8 , 31u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork64 { # [ inline ] fn order ( ) -> usize { 6usize } } impl :: std :: fmt :: Debug for SortingNetwork64 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 6usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork128 ; impl SortingNetwork128 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork128 } } impl SortingNetworkTrait for SortingNetwork128 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 128usize , "Expected slice of length {}" , 128usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork64 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 7usize ] = [ ( 0u8 , 1u8 , 64u8 ) , ( 32u8 , 1u8 , 32u8 ) , ( 16u8 , 3u8 , 16u8 ) , ( 8u8 , 7u8 , 8u8 ) , ( 4u8 , 15u8 , 4u8 ) , ( 2u8 , 31u8 , 2u8 ) , ( 1u8 , 63u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork128 { # [ inline ] fn order ( ) -> usize { 7usize } } impl :: std :: fmt :: Debug for SortingNetwork128 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 7usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork256 ; impl SortingNetwork256 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork256 } } impl SortingNetworkTrait for SortingNetwork256 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 256usize , "Expected slice of length {}" , 256usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork128 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 8usize ] = [ ( 0u8 , 1u8 , 128u8 ) , ( 64u8 , 1u8 , 64u8 ) , ( 32u8 , 3u8 , 32u8 ) , ( 16u8 , 7u8 , 16u8 ) , ( 8u8 , 15u8 , 8u8 ) , ( 4u8 , 31u8 , 4u8 ) , ( 2u8 , 63u8 , 2u8 ) , ( 1u8 , 127u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork256 { # [ inline ] fn order ( ) -> usize { 8usize } } impl :: std :: fmt :: Debug for SortingNetwork256 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 8usize , f ) } } # [ cfg ( test ) ] mod sorting_network { use std :: prelude :: v1 :: * ; use super :: * ; fn shuffled ( length : usize ) -> Vec < usize > { let prime = 313373 ; let sorted : Vec < _ > = ( 0 .. length ) . collect ( ) ; ( 0 .. length ) . map ( | i | sorted [ ( i * prime ) % length ] ) . collect ( ) } mod length_2 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 2usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork2 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 2usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_4 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 4usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork4 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 4usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_8 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 8usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork8 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 8usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_16 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 16usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork16 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 16usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_32 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 32usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork32 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 32usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_64 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 64usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork64 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 64usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_128 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 128usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork128 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 128usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_256 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 256usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork256 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 256usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default_derive [INFO] [stderr] [INFO] [stderr] warning: you should consider deriving a `Default` implementation for `SortingNetwork16` [INFO] [stderr] --> /opt/crater/target/debug/build/sorting_networks-48e4135488fdd1a6/out/generated.rs:1:4809 [INFO] [stderr] | [INFO] [stderr] 1 | use std :: cmp :: Ordering ; # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork2 ; impl SortingNetwork2 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork2 } } impl SortingNetworkTrait for SortingNetwork2 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 2usize , "Expected slice of length {}" , 2usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork1 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 1usize ] = [ ( 0u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork2 { # [ inline ] fn order ( ) -> usize { 1usize } } impl :: std :: fmt :: Debug for SortingNetwork2 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 1usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork4 ; impl SortingNetwork4 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork4 } } impl SortingNetworkTrait for SortingNetwork4 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 4usize , "Expected slice of length {}" , 4usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork2 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 2usize ] = [ ( 0u8 , 1u8 , 2u8 ) , ( 1u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork4 { # [ inline ] fn order ( ) -> usize { 2usize } } impl :: std :: fmt :: Debug for SortingNetwork4 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 2usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork8 ; impl SortingNetwork8 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork8 } } impl SortingNetworkTrait for SortingNetwork8 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 8usize , "Expected slice of length {}" , 8usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork4 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 3usize ] = [ ( 0u8 , 1u8 , 4u8 ) , ( 2u8 , 1u8 , 2u8 ) , ( 1u8 , 3u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork8 { # [ inline ] fn order ( ) -> usize { 3usize } } impl :: std :: fmt :: Debug for SortingNetwork8 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 3usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork16 ; impl SortingNetwork16 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork16 } } impl SortingNetworkTrait for SortingNetwork16 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 16usize , "Expected slice of length {}" , 16usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork8 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 4usize ] = [ ( 0u8 , 1u8 , 8u8 ) , ( 4u8 , 1u8 , 4u8 ) , ( 2u8 , 3u8 , 2u8 ) , ( 1u8 , 7u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork16 { # [ inline ] fn order ( ) -> usize { 4usize } } impl :: std :: fmt :: Debug for SortingNetwork16 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 4usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork32 ; impl SortingNetwork32 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork32 } } impl SortingNetworkTrait for SortingNetwork32 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 32usize , "Expected slice of length {}" , 32usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork16 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 5usize ] = [ ( 0u8 , 1u8 , 16u8 ) , ( 8u8 , 1u8 , 8u8 ) , ( 4u8 , 3u8 , 4u8 ) , ( 2u8 , 7u8 , 2u8 ) , ( 1u8 , 15u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork32 { # [ inline ] fn order ( ) -> usize { 5usize } } impl :: std :: fmt :: Debug for SortingNetwork32 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 5usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork64 ; impl SortingNetwork64 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork64 } } impl SortingNetworkTrait for SortingNetwork64 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 64usize , "Expected slice of length {}" , 64usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork32 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 6usize ] = [ ( 0u8 , 1u8 , 32u8 ) , ( 16u8 , 1u8 , 16u8 ) , ( 8u8 , 3u8 , 8u8 ) , ( 4u8 , 7u8 , 4u8 ) , ( 2u8 , 15u8 , 2u8 ) , ( 1u8 , 31u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork64 { # [ inline ] fn order ( ) -> usize { 6usize } } impl :: std :: fmt :: Debug for SortingNetwork64 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 6usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork128 ; impl SortingNetwork128 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork128 } } impl SortingNetworkTrait for SortingNetwork128 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 128usize , "Expected slice of length {}" , 128usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork64 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 7usize ] = [ ( 0u8 , 1u8 , 64u8 ) , ( 32u8 , 1u8 , 32u8 ) , ( 16u8 , 3u8 , 16u8 ) , ( 8u8 , 7u8 , 8u8 ) , ( 4u8 , 15u8 , 4u8 ) , ( 2u8 , 31u8 , 2u8 ) , ( 1u8 , 63u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork128 { # [ inline ] fn order ( ) -> usize { 7usize } } impl :: std :: fmt :: Debug for SortingNetwork128 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 7usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork256 ; impl SortingNetwork256 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork256 } } impl SortingNetworkTrait for SortingNetwork256 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 256usize , "Expected slice of length {}" , 256usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork128 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 8usize ] = [ ( 0u8 , 1u8 , 128u8 ) , ( 64u8 , 1u8 , 64u8 ) , ( 32u8 , 3u8 , 32u8 ) , ( 16u8 , 7u8 , 16u8 ) , ( 8u8 , 15u8 , 8u8 ) , ( 4u8 , 31u8 , 4u8 ) , ( 2u8 , 63u8 , 2u8 ) , ( 1u8 , 127u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork256 { # [ inline ] fn order ( ) -> usize { 8usize } } impl :: std :: fmt :: Debug for SortingNetwork256 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 8usize , f ) } } # [ cfg ( test ) ] mod sorting_network { use std :: prelude :: v1 :: * ; use super :: * ; fn shuffled ( length : usize ) -> Vec < usize > { let prime = 313373 ; let sorted : Vec < _ > = ( 0 .. length ) . collect ( ) ; ( 0 .. length ) . map ( | i | sorted [ ( i * prime ) % length ] ) . collect ( ) } mod length_2 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 2usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork2 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 2usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_4 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 4usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork4 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 4usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_8 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 8usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork8 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 8usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_16 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 16usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork16 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 16usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_32 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 32usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork32 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 32usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_64 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 64usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork64 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 64usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_128 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 128usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork128 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 128usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_256 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 256usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork256 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 256usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default_derive [INFO] [stderr] [INFO] [stderr] warning: you should consider deriving a `Default` implementation for `SortingNetwork32` [INFO] [stderr] --> /opt/crater/target/debug/build/sorting_networks-48e4135488fdd1a6/out/generated.rs:1:6373 [INFO] [stderr] | [INFO] [stderr] 1 | use std :: cmp :: Ordering ; # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork2 ; impl SortingNetwork2 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork2 } } impl SortingNetworkTrait for SortingNetwork2 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 2usize , "Expected slice of length {}" , 2usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork1 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 1usize ] = [ ( 0u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork2 { # [ inline ] fn order ( ) -> usize { 1usize } } impl :: std :: fmt :: Debug for SortingNetwork2 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 1usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork4 ; impl SortingNetwork4 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork4 } } impl SortingNetworkTrait for SortingNetwork4 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 4usize , "Expected slice of length {}" , 4usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork2 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 2usize ] = [ ( 0u8 , 1u8 , 2u8 ) , ( 1u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork4 { # [ inline ] fn order ( ) -> usize { 2usize } } impl :: std :: fmt :: Debug for SortingNetwork4 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 2usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork8 ; impl SortingNetwork8 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork8 } } impl SortingNetworkTrait for SortingNetwork8 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 8usize , "Expected slice of length {}" , 8usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork4 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 3usize ] = [ ( 0u8 , 1u8 , 4u8 ) , ( 2u8 , 1u8 , 2u8 ) , ( 1u8 , 3u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork8 { # [ inline ] fn order ( ) -> usize { 3usize } } impl :: std :: fmt :: Debug for SortingNetwork8 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 3usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork16 ; impl SortingNetwork16 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork16 } } impl SortingNetworkTrait for SortingNetwork16 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 16usize , "Expected slice of length {}" , 16usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork8 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 4usize ] = [ ( 0u8 , 1u8 , 8u8 ) , ( 4u8 , 1u8 , 4u8 ) , ( 2u8 , 3u8 , 2u8 ) , ( 1u8 , 7u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork16 { # [ inline ] fn order ( ) -> usize { 4usize } } impl :: std :: fmt :: Debug for SortingNetwork16 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 4usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork32 ; impl SortingNetwork32 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork32 } } impl SortingNetworkTrait for SortingNetwork32 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 32usize , "Expected slice of length {}" , 32usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork16 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 5usize ] = [ ( 0u8 , 1u8 , 16u8 ) , ( 8u8 , 1u8 , 8u8 ) , ( 4u8 , 3u8 , 4u8 ) , ( 2u8 , 7u8 , 2u8 ) , ( 1u8 , 15u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork32 { # [ inline ] fn order ( ) -> usize { 5usize } } impl :: std :: fmt :: Debug for SortingNetwork32 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 5usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork64 ; impl SortingNetwork64 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork64 } } impl SortingNetworkTrait for SortingNetwork64 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 64usize , "Expected slice of length {}" , 64usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork32 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 6usize ] = [ ( 0u8 , 1u8 , 32u8 ) , ( 16u8 , 1u8 , 16u8 ) , ( 8u8 , 3u8 , 8u8 ) , ( 4u8 , 7u8 , 4u8 ) , ( 2u8 , 15u8 , 2u8 ) , ( 1u8 , 31u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork64 { # [ inline ] fn order ( ) -> usize { 6usize } } impl :: std :: fmt :: Debug for SortingNetwork64 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 6usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork128 ; impl SortingNetwork128 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork128 } } impl SortingNetworkTrait for SortingNetwork128 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 128usize , "Expected slice of length {}" , 128usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork64 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 7usize ] = [ ( 0u8 , 1u8 , 64u8 ) , ( 32u8 , 1u8 , 32u8 ) , ( 16u8 , 3u8 , 16u8 ) , ( 8u8 , 7u8 , 8u8 ) , ( 4u8 , 15u8 , 4u8 ) , ( 2u8 , 31u8 , 2u8 ) , ( 1u8 , 63u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork128 { # [ inline ] fn order ( ) -> usize { 7usize } } impl :: std :: fmt :: Debug for SortingNetwork128 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 7usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork256 ; impl SortingNetwork256 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork256 } } impl SortingNetworkTrait for SortingNetwork256 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 256usize , "Expected slice of length {}" , 256usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork128 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 8usize ] = [ ( 0u8 , 1u8 , 128u8 ) , ( 64u8 , 1u8 , 64u8 ) , ( 32u8 , 3u8 , 32u8 ) , ( 16u8 , 7u8 , 16u8 ) , ( 8u8 , 15u8 , 8u8 ) , ( 4u8 , 31u8 , 4u8 ) , ( 2u8 , 63u8 , 2u8 ) , ( 1u8 , 127u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork256 { # [ inline ] fn order ( ) -> usize { 8usize } } impl :: std :: fmt :: Debug for SortingNetwork256 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 8usize , f ) } } # [ cfg ( test ) ] mod sorting_network { use std :: prelude :: v1 :: * ; use super :: * ; fn shuffled ( length : usize ) -> Vec < usize > { let prime = 313373 ; let sorted : Vec < _ > = ( 0 .. length ) . collect ( ) ; ( 0 .. length ) . map ( | i | sorted [ ( i * prime ) % length ] ) . collect ( ) } mod length_2 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 2usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork2 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 2usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_4 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 4usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork4 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 4usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_8 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 8usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork8 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 8usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_16 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 16usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork16 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 16usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_32 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 32usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork32 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 32usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_64 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 64usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork64 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 64usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_128 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 128usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork128 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 128usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_256 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 256usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork256 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 256usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default_derive [INFO] [stderr] [INFO] [stderr] warning: you should consider deriving a `Default` implementation for `SortingNetwork64` [INFO] [stderr] --> /opt/crater/target/debug/build/sorting_networks-48e4135488fdd1a6/out/generated.rs:1:7962 [INFO] [stderr] | [INFO] [stderr] 1 | use std :: cmp :: Ordering ; # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork2 ; impl SortingNetwork2 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork2 } } impl SortingNetworkTrait for SortingNetwork2 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 2usize , "Expected slice of length {}" , 2usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork1 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 1usize ] = [ ( 0u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork2 { # [ inline ] fn order ( ) -> usize { 1usize } } impl :: std :: fmt :: Debug for SortingNetwork2 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 1usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork4 ; impl SortingNetwork4 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork4 } } impl SortingNetworkTrait for SortingNetwork4 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 4usize , "Expected slice of length {}" , 4usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork2 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 2usize ] = [ ( 0u8 , 1u8 , 2u8 ) , ( 1u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork4 { # [ inline ] fn order ( ) -> usize { 2usize } } impl :: std :: fmt :: Debug for SortingNetwork4 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 2usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork8 ; impl SortingNetwork8 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork8 } } impl SortingNetworkTrait for SortingNetwork8 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 8usize , "Expected slice of length {}" , 8usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork4 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 3usize ] = [ ( 0u8 , 1u8 , 4u8 ) , ( 2u8 , 1u8 , 2u8 ) , ( 1u8 , 3u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork8 { # [ inline ] fn order ( ) -> usize { 3usize } } impl :: std :: fmt :: Debug for SortingNetwork8 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 3usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork16 ; impl SortingNetwork16 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork16 } } impl SortingNetworkTrait for SortingNetwork16 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 16usize , "Expected slice of length {}" , 16usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork8 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 4usize ] = [ ( 0u8 , 1u8 , 8u8 ) , ( 4u8 , 1u8 , 4u8 ) , ( 2u8 , 3u8 , 2u8 ) , ( 1u8 , 7u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork16 { # [ inline ] fn order ( ) -> usize { 4usize } } impl :: std :: fmt :: Debug for SortingNetwork16 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 4usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork32 ; impl SortingNetwork32 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork32 } } impl SortingNetworkTrait for SortingNetwork32 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 32usize , "Expected slice of length {}" , 32usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork16 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 5usize ] = [ ( 0u8 , 1u8 , 16u8 ) , ( 8u8 , 1u8 , 8u8 ) , ( 4u8 , 3u8 , 4u8 ) , ( 2u8 , 7u8 , 2u8 ) , ( 1u8 , 15u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork32 { # [ inline ] fn order ( ) -> usize { 5usize } } impl :: std :: fmt :: Debug for SortingNetwork32 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 5usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork64 ; impl SortingNetwork64 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork64 } } impl SortingNetworkTrait for SortingNetwork64 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 64usize , "Expected slice of length {}" , 64usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork32 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 6usize ] = [ ( 0u8 , 1u8 , 32u8 ) , ( 16u8 , 1u8 , 16u8 ) , ( 8u8 , 3u8 , 8u8 ) , ( 4u8 , 7u8 , 4u8 ) , ( 2u8 , 15u8 , 2u8 ) , ( 1u8 , 31u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork64 { # [ inline ] fn order ( ) -> usize { 6usize } } impl :: std :: fmt :: Debug for SortingNetwork64 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 6usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork128 ; impl SortingNetwork128 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork128 } } impl SortingNetworkTrait for SortingNetwork128 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 128usize , "Expected slice of length {}" , 128usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork64 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 7usize ] = [ ( 0u8 , 1u8 , 64u8 ) , ( 32u8 , 1u8 , 32u8 ) , ( 16u8 , 3u8 , 16u8 ) , ( 8u8 , 7u8 , 8u8 ) , ( 4u8 , 15u8 , 4u8 ) , ( 2u8 , 31u8 , 2u8 ) , ( 1u8 , 63u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork128 { # [ inline ] fn order ( ) -> usize { 7usize } } impl :: std :: fmt :: Debug for SortingNetwork128 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 7usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork256 ; impl SortingNetwork256 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork256 } } impl SortingNetworkTrait for SortingNetwork256 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 256usize , "Expected slice of length {}" , 256usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork128 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 8usize ] = [ ( 0u8 , 1u8 , 128u8 ) , ( 64u8 , 1u8 , 64u8 ) , ( 32u8 , 3u8 , 32u8 ) , ( 16u8 , 7u8 , 16u8 ) , ( 8u8 , 15u8 , 8u8 ) , ( 4u8 , 31u8 , 4u8 ) , ( 2u8 , 63u8 , 2u8 ) , ( 1u8 , 127u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork256 { # [ inline ] fn order ( ) -> usize { 8usize } } impl :: std :: fmt :: Debug for SortingNetwork256 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 8usize , f ) } } # [ cfg ( test ) ] mod sorting_network { use std :: prelude :: v1 :: * ; use super :: * ; fn shuffled ( length : usize ) -> Vec < usize > { let prime = 313373 ; let sorted : Vec < _ > = ( 0 .. length ) . collect ( ) ; ( 0 .. length ) . map ( | i | sorted [ ( i * prime ) % length ] ) . collect ( ) } mod length_2 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 2usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork2 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 2usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_4 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 4usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork4 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 4usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_8 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 8usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork8 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 8usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_16 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 16usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork16 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 16usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_32 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 32usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork32 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 32usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_64 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 64usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork64 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 64usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_128 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 128usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork128 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 128usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_256 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 256usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork256 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 256usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default_derive [INFO] [stderr] [INFO] [stderr] warning: you should consider deriving a `Default` implementation for `SortingNetwork128` [INFO] [stderr] --> /opt/crater/target/debug/build/sorting_networks-48e4135488fdd1a6/out/generated.rs:1:9578 [INFO] [stderr] | [INFO] [stderr] 1 | use std :: cmp :: Ordering ; # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork2 ; impl SortingNetwork2 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork2 } } impl SortingNetworkTrait for SortingNetwork2 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 2usize , "Expected slice of length {}" , 2usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork1 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 1usize ] = [ ( 0u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork2 { # [ inline ] fn order ( ) -> usize { 1usize } } impl :: std :: fmt :: Debug for SortingNetwork2 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 1usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork4 ; impl SortingNetwork4 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork4 } } impl SortingNetworkTrait for SortingNetwork4 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 4usize , "Expected slice of length {}" , 4usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork2 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 2usize ] = [ ( 0u8 , 1u8 , 2u8 ) , ( 1u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork4 { # [ inline ] fn order ( ) -> usize { 2usize } } impl :: std :: fmt :: Debug for SortingNetwork4 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 2usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork8 ; impl SortingNetwork8 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork8 } } impl SortingNetworkTrait for SortingNetwork8 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 8usize , "Expected slice of length {}" , 8usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork4 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 3usize ] = [ ( 0u8 , 1u8 , 4u8 ) , ( 2u8 , 1u8 , 2u8 ) , ( 1u8 , 3u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork8 { # [ inline ] fn order ( ) -> usize { 3usize } } impl :: std :: fmt :: Debug for SortingNetwork8 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 3usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork16 ; impl SortingNetwork16 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork16 } } impl SortingNetworkTrait for SortingNetwork16 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 16usize , "Expected slice of length {}" , 16usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork8 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 4usize ] = [ ( 0u8 , 1u8 , 8u8 ) , ( 4u8 , 1u8 , 4u8 ) , ( 2u8 , 3u8 , 2u8 ) , ( 1u8 , 7u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork16 { # [ inline ] fn order ( ) -> usize { 4usize } } impl :: std :: fmt :: Debug for SortingNetwork16 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 4usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork32 ; impl SortingNetwork32 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork32 } } impl SortingNetworkTrait for SortingNetwork32 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 32usize , "Expected slice of length {}" , 32usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork16 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 5usize ] = [ ( 0u8 , 1u8 , 16u8 ) , ( 8u8 , 1u8 , 8u8 ) , ( 4u8 , 3u8 , 4u8 ) , ( 2u8 , 7u8 , 2u8 ) , ( 1u8 , 15u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork32 { # [ inline ] fn order ( ) -> usize { 5usize } } impl :: std :: fmt :: Debug for SortingNetwork32 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 5usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork64 ; impl SortingNetwork64 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork64 } } impl SortingNetworkTrait for SortingNetwork64 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 64usize , "Expected slice of length {}" , 64usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork32 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 6usize ] = [ ( 0u8 , 1u8 , 32u8 ) , ( 16u8 , 1u8 , 16u8 ) , ( 8u8 , 3u8 , 8u8 ) , ( 4u8 , 7u8 , 4u8 ) , ( 2u8 , 15u8 , 2u8 ) , ( 1u8 , 31u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork64 { # [ inline ] fn order ( ) -> usize { 6usize } } impl :: std :: fmt :: Debug for SortingNetwork64 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 6usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork128 ; impl SortingNetwork128 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork128 } } impl SortingNetworkTrait for SortingNetwork128 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 128usize , "Expected slice of length {}" , 128usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork64 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 7usize ] = [ ( 0u8 , 1u8 , 64u8 ) , ( 32u8 , 1u8 , 32u8 ) , ( 16u8 , 3u8 , 16u8 ) , ( 8u8 , 7u8 , 8u8 ) , ( 4u8 , 15u8 , 4u8 ) , ( 2u8 , 31u8 , 2u8 ) , ( 1u8 , 63u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork128 { # [ inline ] fn order ( ) -> usize { 7usize } } impl :: std :: fmt :: Debug for SortingNetwork128 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 7usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork256 ; impl SortingNetwork256 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork256 } } impl SortingNetworkTrait for SortingNetwork256 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 256usize , "Expected slice of length {}" , 256usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork128 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 8usize ] = [ ( 0u8 , 1u8 , 128u8 ) , ( 64u8 , 1u8 , 64u8 ) , ( 32u8 , 3u8 , 32u8 ) , ( 16u8 , 7u8 , 16u8 ) , ( 8u8 , 15u8 , 8u8 ) , ( 4u8 , 31u8 , 4u8 ) , ( 2u8 , 63u8 , 2u8 ) , ( 1u8 , 127u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork256 { # [ inline ] fn order ( ) -> usize { 8usize } } impl :: std :: fmt :: Debug for SortingNetwork256 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 8usize , f ) } } # [ cfg ( test ) ] mod sorting_network { use std :: prelude :: v1 :: * ; use super :: * ; fn shuffled ( length : usize ) -> Vec < usize > { let prime = 313373 ; let sorted : Vec < _ > = ( 0 .. length ) . collect ( ) ; ( 0 .. length ) . map ( | i | sorted [ ( i * prime ) % length ] ) . collect ( ) } mod length_2 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 2usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork2 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 2usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_4 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 4usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork4 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 4usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_8 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 8usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork8 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 8usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_16 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 16usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork16 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 16usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_32 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 32usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork32 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 32usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_64 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 64usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork64 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 64usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_128 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 128usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork128 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 128usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_256 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 256usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork256 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 256usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default_derive [INFO] [stderr] [INFO] [stderr] warning: you should consider deriving a `Default` implementation for `SortingNetwork256` [INFO] [stderr] --> /opt/crater/target/debug/build/sorting_networks-48e4135488fdd1a6/out/generated.rs:1:11225 [INFO] [stderr] | [INFO] [stderr] 1 | use std :: cmp :: Ordering ; # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork2 ; impl SortingNetwork2 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork2 } } impl SortingNetworkTrait for SortingNetwork2 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 2usize , "Expected slice of length {}" , 2usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork1 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 1usize ] = [ ( 0u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork2 { # [ inline ] fn order ( ) -> usize { 1usize } } impl :: std :: fmt :: Debug for SortingNetwork2 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 1usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork4 ; impl SortingNetwork4 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork4 } } impl SortingNetworkTrait for SortingNetwork4 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 4usize , "Expected slice of length {}" , 4usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork2 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 2usize ] = [ ( 0u8 , 1u8 , 2u8 ) , ( 1u8 , 1u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork4 { # [ inline ] fn order ( ) -> usize { 2usize } } impl :: std :: fmt :: Debug for SortingNetwork4 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 2usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork8 ; impl SortingNetwork8 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork8 } } impl SortingNetworkTrait for SortingNetwork8 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 8usize , "Expected slice of length {}" , 8usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork4 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 3usize ] = [ ( 0u8 , 1u8 , 4u8 ) , ( 2u8 , 1u8 , 2u8 ) , ( 1u8 , 3u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork8 { # [ inline ] fn order ( ) -> usize { 3usize } } impl :: std :: fmt :: Debug for SortingNetwork8 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 3usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork16 ; impl SortingNetwork16 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork16 } } impl SortingNetworkTrait for SortingNetwork16 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 16usize , "Expected slice of length {}" , 16usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork8 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 4usize ] = [ ( 0u8 , 1u8 , 8u8 ) , ( 4u8 , 1u8 , 4u8 ) , ( 2u8 , 3u8 , 2u8 ) , ( 1u8 , 7u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork16 { # [ inline ] fn order ( ) -> usize { 4usize } } impl :: std :: fmt :: Debug for SortingNetwork16 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 4usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork32 ; impl SortingNetwork32 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork32 } } impl SortingNetworkTrait for SortingNetwork32 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 32usize , "Expected slice of length {}" , 32usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork16 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 5usize ] = [ ( 0u8 , 1u8 , 16u8 ) , ( 8u8 , 1u8 , 8u8 ) , ( 4u8 , 3u8 , 4u8 ) , ( 2u8 , 7u8 , 2u8 ) , ( 1u8 , 15u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork32 { # [ inline ] fn order ( ) -> usize { 5usize } } impl :: std :: fmt :: Debug for SortingNetwork32 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 5usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork64 ; impl SortingNetwork64 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork64 } } impl SortingNetworkTrait for SortingNetwork64 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 64usize , "Expected slice of length {}" , 64usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork32 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 6usize ] = [ ( 0u8 , 1u8 , 32u8 ) , ( 16u8 , 1u8 , 16u8 ) , ( 8u8 , 3u8 , 8u8 ) , ( 4u8 , 7u8 , 4u8 ) , ( 2u8 , 15u8 , 2u8 ) , ( 1u8 , 31u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork64 { # [ inline ] fn order ( ) -> usize { 6usize } } impl :: std :: fmt :: Debug for SortingNetwork64 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 6usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork128 ; impl SortingNetwork128 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork128 } } impl SortingNetworkTrait for SortingNetwork128 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 128usize , "Expected slice of length {}" , 128usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork64 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 7usize ] = [ ( 0u8 , 1u8 , 64u8 ) , ( 32u8 , 1u8 , 32u8 ) , ( 16u8 , 3u8 , 16u8 ) , ( 8u8 , 7u8 , 8u8 ) , ( 4u8 , 15u8 , 4u8 ) , ( 2u8 , 31u8 , 2u8 ) , ( 1u8 , 63u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork128 { # [ inline ] fn order ( ) -> usize { 7usize } } impl :: std :: fmt :: Debug for SortingNetwork128 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 7usize , f ) } } # [ doc = r" Optimized sorting network for slices of specific length." ] # [ derive ( Clone , Copy ) ] pub struct SortingNetwork256 ; impl SortingNetwork256 { # [ doc = r" Creates a sorting network for slices of specific length." ] # [ inline ] pub fn new ( ) -> Self { SortingNetwork256 } } impl SortingNetworkTrait for SortingNetwork256 { fn sort_by < T , F > ( & self , slice : & mut [ T ] , compare : F ) where F : Fn ( & T , & T ) -> Ordering { let len = slice . len ( ) ; assert ! ( len == 256usize , "Expected slice of length {}" , 256usize ) ; { let ( lhs , rhs ) = slice . split_at_mut ( len / 2 ) ; let sub_sort = SortingNetwork128 :: new ( ) ; sub_sort . sort_by ( lhs , & compare ) ; sub_sort . sort_by ( rhs , & compare ) ; } let patterns : [ ( u8 , u8 , u8 ) ; 8usize ] = [ ( 0u8 , 1u8 , 128u8 ) , ( 64u8 , 1u8 , 64u8 ) , ( 32u8 , 3u8 , 32u8 ) , ( 16u8 , 7u8 , 16u8 ) , ( 8u8 , 15u8 , 8u8 ) , ( 4u8 , 31u8 , 4u8 ) , ( 2u8 , 63u8 , 2u8 ) , ( 1u8 , 127u8 , 1u8 ) ] ; for ( start , count , length ) in patterns . iter ( ) . cloned ( ) { let ( start , count , length ) = ( start as usize , count as usize , length as usize ) ; let gap = 2 * length ; for i in 0 .. ( count as usize ) { let offset = i * gap ; for j in 0 .. ( length as usize ) { let min = start + offset + j ; let max = min + length ; unsafe { swap_unchecked ( slice , min , max , & compare ) ; } } } println ! ( ) ; } } } impl FixedSizeSortingNetwork for SortingNetwork256 { # [ inline ] fn order ( ) -> usize { 8usize } } impl :: std :: fmt :: Debug for SortingNetwork256 { fn fmt ( & self , f : & mut :: std :: fmt :: Formatter ) -> :: std :: fmt :: Result { debug :: debug_fmt ( 8usize , f ) } } # [ cfg ( test ) ] mod sorting_network { use std :: prelude :: v1 :: * ; use super :: * ; fn shuffled ( length : usize ) -> Vec < usize > { let prime = 313373 ; let sorted : Vec < _ > = ( 0 .. length ) . collect ( ) ; ( 0 .. length ) . map ( | i | sorted [ ( i * prime ) % length ] ) . collect ( ) } mod length_2 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 2usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork2 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 2usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_4 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 4usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork4 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 4usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_8 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 8usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork8 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 8usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_16 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 16usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork16 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 16usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_32 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 32usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork32 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 32usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_64 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 64usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork64 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 64usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_128 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 128usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork128 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 128usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } mod length_256 { use super :: * ; # [ test ] fn fixed_size ( ) { let mut items = shuffled ( 256usize ) ; println ! ( "\ninput: {:?}\n" , items ) ; let sorter = SortingNetwork256 :: new ( ) ; sorter . sort ( & mut items [ .. ] ) ; let expected : Vec < _ > = ( 0 .. 256usize ) . collect ( ) ; assert_eq ! ( items , expected ) ; } } } [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default_derive [INFO] [stderr] [INFO] [stderr] error: build failed [INFO] running `"docker" "inspect" "ad03814beca27ebe01de89630cf33d0db18413a33718598f4160e8a1337c0683"` [INFO] running `"docker" "rm" "-f" "ad03814beca27ebe01de89630cf33d0db18413a33718598f4160e8a1337c0683"` [INFO] [stdout] ad03814beca27ebe01de89630cf33d0db18413a33718598f4160e8a1337c0683