diff --git a/src/libextra/glob.rs b/src/libextra/glob.rs index e398a10ecf138..1182d526fa453 100644 --- a/src/libextra/glob.rs +++ b/src/libextra/glob.rs @@ -28,8 +28,6 @@ use std::io; use std::io::fs; use std::path::is_sep; -use sort; - /** * An iterator that yields Paths from the filesystem that match a particular * pattern - see the `glob` function for more details. @@ -149,9 +147,8 @@ impl Iterator for GlobIterator { fn list_dir_sorted(path: &Path) -> ~[Path] { match io::result(|| fs::readdir(path)) { - Ok(children) => { - let mut children = children; - sort::quick_sort(children, |p1, p2| p2.filename() <= p1.filename()); + Ok(mut children) => { + children.sort_by(|p1, p2| p2.filename().cmp(&p1.filename())); children } Err(..) => ~[] @@ -771,4 +768,3 @@ mod test { assert!(Pattern::new("a/b").matches_path(&Path::new("a/b"))); } } - diff --git a/src/libextra/lib.rs b/src/libextra/lib.rs index 82ca4d65b233e..51e105d23f782 100644 --- a/src/libextra/lib.rs +++ b/src/libextra/lib.rs @@ -61,8 +61,6 @@ pub mod ringbuf; pub mod priority_queue; pub mod smallintmap; -pub mod sort; - pub mod dlist; pub mod treemap; pub mod btree; diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs index 77d1c5cdcf49e..bba7d76773293 100644 --- a/src/libextra/priority_queue.rs +++ b/src/libextra/priority_queue.rs @@ -213,7 +213,6 @@ impl Extendable for PriorityQueue { #[cfg(test)] mod tests { - use sort::merge_sort; use priority_queue::PriorityQueue; #[test] @@ -231,7 +230,8 @@ mod tests { #[test] fn test_top_and_pop() { let data = ~[2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]; - let mut sorted = merge_sort(data, |x, y| x.le(y)); + let mut sorted = data.clone(); + sorted.sort(); let mut heap = PriorityQueue::from_vec(data); while !heap.is_empty() { assert_eq!(heap.top(), sorted.last()); @@ -311,11 +311,14 @@ mod tests { assert_eq!(heap.len(), 5); } - fn check_to_vec(data: ~[int]) { + fn check_to_vec(mut data: ~[int]) { let heap = PriorityQueue::from_vec(data.clone()); - assert_eq!(merge_sort(heap.clone().to_vec(), |x, y| x.le(y)), - merge_sort(data, |x, y| x.le(y))); - assert_eq!(heap.to_sorted_vec(), merge_sort(data, |x, y| x.le(y))); + let mut v = heap.clone().to_vec(); + v.sort(); + data.sort(); + + assert_eq!(v, data); + assert_eq!(heap.to_sorted_vec(), data); } #[test] diff --git a/src/libextra/sort.rs b/src/libextra/sort.rs deleted file mode 100644 index bba26a16d4dad..0000000000000 --- a/src/libextra/sort.rs +++ /dev/null @@ -1,1181 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Sorting methods - - -use std::cmp::{Eq, Ord}; -use std::util::swap; -use std::vec; - -type Le<'a, T> = 'a |v1: &T, v2: &T| -> bool; - -/** - * Merge sort. Returns a new vector containing the sorted list. - * - * Has worst case O(n log n) performance, best case O(n), but - * is not space efficient. This is a stable sort. - */ -pub fn merge_sort(v: &[T], le: Le) -> ~[T] { - type Slice = (uint, uint); - - return merge_sort_(v, (0u, v.len()), le); - - fn merge_sort_(v: &[T], slice: Slice, le: Le) -> ~[T] { - let begin = slice.first(); - let end = slice.second(); - - let v_len = end - begin; - if v_len == 0 { return ~[]; } - if v_len == 1 { return ~[v[begin].clone()]; } - - let mid = v_len / 2 + begin; - let a = (begin, mid); - let b = (mid, end); - return merge(|x,y| le(x,y), merge_sort_(v, a, |x,y| le(x,y)), - merge_sort_(v, b, |x,y| le(x,y))); - } - - fn merge(le: Le, a: &[T], b: &[T]) -> ~[T] { - let mut rs = vec::with_capacity(a.len() + b.len()); - let a_len = a.len(); - let mut a_ix = 0; - let b_len = b.len(); - let mut b_ix = 0; - while a_ix < a_len && b_ix < b_len { - if le(&a[a_ix], &b[b_ix]) { - rs.push(a[a_ix].clone()); - a_ix += 1; - } else { - rs.push(b[b_ix].clone()); - b_ix += 1; - } - } - rs.push_all(a.slice(a_ix, a_len)); - rs.push_all(b.slice(b_ix, b_len)); - rs - } -} - -fn part(arr: &mut [T], left: uint, - right: uint, pivot: uint, compare_func: Le) -> uint { - arr.swap(pivot, right); - let mut storage_index: uint = left; - let mut i: uint = left; - while i < right { - if compare_func(&arr[i], &arr[right]) { - arr.swap(i, storage_index); - storage_index += 1; - } - i += 1; - } - arr.swap(storage_index, right); - return storage_index; -} - -fn qsort(arr: &mut [T], left: uint, - right: uint, compare_func: Le) { - if right > left { - let pivot = (left + right) / 2u; - let new_pivot = part::(arr, left, right, pivot, |x,y| compare_func(x,y)); - if new_pivot != 0u { - // Need to do this check before recursing due to overflow - qsort::(arr, left, new_pivot - 1u, |x,y| compare_func(x,y)); - } - qsort::(arr, new_pivot + 1u, right, compare_func); - } -} - -/** - * Quicksort. Sorts a mut vector in place. - * - * Has worst case O(n^2) performance, average case O(n log n). - * This is an unstable sort. - */ -pub fn quick_sort(arr: &mut [T], compare_func: Le) { - let len = arr.len(); - if len == 0u { return; } - qsort::(arr, 0u, len - 1u, compare_func); -} - -fn qsort3(arr: &mut [T], left: int, right: int) { - if right <= left { return; } - let v: T = arr[right].clone(); - let mut i: int = left - 1; - let mut j: int = right; - let mut p: int = i; - let mut q: int = j; - loop { - i += 1; - while arr[i] < v { i += 1; } - j -= 1; - while v < arr[j] { - if j == left { break; } - j -= 1; - } - if i >= j { break; } - arr.swap(i as uint, j as uint); - if arr[i] == v { - p += 1; - arr.swap(p as uint, i as uint); - } - if v == arr[j] { - q -= 1; - arr.swap(j as uint, q as uint); - } - } - arr.swap(i as uint, right as uint); - j = i - 1; - i += 1; - let mut k: int = left; - while k < p { - arr.swap(k as uint, j as uint); - k += 1; - j -= 1; - if k == arr.len() as int { break; } - } - k = right - 1; - while k > q { - arr.swap(i as uint, k as uint); - k -= 1; - i += 1; - if k == 0 { break; } - } - qsort3::(arr, left, j); - qsort3::(arr, i, right); -} - -/** - * Fancy quicksort. Sorts a mut vector in place. - * - * Based on algorithm presented by ~[Sedgewick and Bentley] - * (http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf). - * According to these slides this is the algorithm of choice for - * 'randomly ordered keys, abstract compare' & 'small number of key values'. - * - * This is an unstable sort. - */ -pub fn quick_sort3(arr: &mut [T]) { - if arr.len() <= 1 { return; } - let len = arr.len(); // FIXME(#5074) nested calls - qsort3(arr, 0, (len - 1) as int); -} - -#[allow(missing_doc)] -pub trait Sort { - fn qsort(self); -} - -impl<'a, T:Clone + Ord + Eq> Sort for &'a mut [T] { - fn qsort(self) { quick_sort3(self); } -} - -static MIN_MERGE: uint = 64; -static MIN_GALLOP: uint = 7; - -#[allow(missing_doc)] -pub fn tim_sort(array: &mut [T]) { - let size = array.len(); - if size < 2 { - return; - } - - if size < MIN_MERGE { - let init_run_len = count_run_ascending(array); - binarysort(array, init_run_len); - return; - } - - let mut ms = MergeState(); - let min_run = min_run_length(size); - - let mut idx = 0; - let mut remaining = size; - loop { - let run_len: uint = { - // This scope contains the slice `arr` here: - let arr = array.mut_slice(idx, size); - let mut run_len: uint = count_run_ascending(arr); - - if run_len < min_run { - let force = if remaining <= min_run {remaining} else {min_run}; - let slice = arr.mut_slice(0, force); - binarysort(slice, run_len); - run_len = force; - } - - run_len - }; - - ms.push_run(idx, run_len); - ms.merge_collapse(array); - - idx += run_len; - remaining -= run_len; - if remaining == 0 { break; } - } - - ms.merge_force_collapse(array); -} - -fn binarysort(array: &mut [T], start: uint) { - let size = array.len(); - let mut start = start; - assert!(start <= size); - - if start == 0 { start += 1; } - - while start < size { - let pivot = array[start].clone(); - let mut left = 0; - let mut right = start; - assert!(left <= right); - - while left < right { - let mid = (left + right) >> 1; - if pivot < array[mid] { - right = mid; - } else { - left = mid+1; - } - } - assert_eq!(left, right); - let n = start-left; - - shift_vec(array, left+1, left, n); - array[left] = pivot; - start += 1; - } -} - -// Reverse the order of elements in a slice, in place -fn reverse_slice(v: &mut [T], start: uint, end:uint) { - let mut i = start; - while i < end / 2 { - v.swap(i, end - i - 1); - i += 1; - } -} - -fn min_run_length(n: uint) -> uint { - let mut n = n; - let mut r = 0; // becomes 1 if any 1 bits are shifted off - - while n >= MIN_MERGE { - r |= n & 1; - n >>= 1; - } - return n + r; -} - -fn count_run_ascending(array: &mut [T]) -> uint { - let size = array.len(); - assert!(size > 0); - if size == 1 { return 1; } - - let mut run = 2; - if array[1] < array[0] { - while run < size && array[run] < array[run-1] { - run += 1; - } - reverse_slice(array, 0, run); - } else { - while run < size && array[run] >= array[run-1] { - run += 1; - } - } - - return run; -} - -fn gallop_left(key: &T, - array: &[T], - hint: uint) - -> uint { - let size = array.len(); - assert!(size != 0 && hint < size); - - let mut last_ofs = 0; - let mut ofs = 1; - - if *key > array[hint] { - // Gallop right until array[hint+last_ofs] < key <= array[hint+ofs] - let max_ofs = size - hint; - while ofs < max_ofs && *key > array[hint+ofs] { - last_ofs = ofs; - ofs = (ofs << 1) + 1; - if ofs < last_ofs { ofs = max_ofs; } // uint overflow guard - } - if ofs > max_ofs { ofs = max_ofs; } - - last_ofs += hint; - ofs += hint; - } else { - let max_ofs = hint + 1; - while ofs < max_ofs && *key <= array[hint-ofs] { - last_ofs = ofs; - ofs = (ofs << 1) + 1; - if ofs < last_ofs { ofs = max_ofs; } // uint overflow guard - } - - if ofs > max_ofs { ofs = max_ofs; } - - let tmp = last_ofs; - last_ofs = hint - ofs; - ofs = hint - tmp; - } - assert!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size); - - last_ofs += 1; - while last_ofs < ofs { - let m = last_ofs + ((ofs - last_ofs) >> 1); - if *key > array[m] { - last_ofs = m+1; - } else { - ofs = m; - } - } - assert_eq!(last_ofs, ofs); - return ofs; -} - -fn gallop_right(key: &T, - array: &[T], - hint: uint) - -> uint { - let size = array.len(); - assert!(size != 0 && hint < size); - - let mut last_ofs = 0; - let mut ofs = 1; - - if *key >= array[hint] { - // Gallop right until array[hint+last_ofs] <= key < array[hint+ofs] - let max_ofs = size - hint; - while ofs < max_ofs && *key >= array[hint+ofs] { - last_ofs = ofs; - ofs = (ofs << 1) + 1; - if ofs < last_ofs { ofs = max_ofs; } - } - if ofs > max_ofs { ofs = max_ofs; } - - last_ofs += hint; - ofs += hint; - } else { - // Gallop left until array[hint-ofs] <= key < array[hint-last_ofs] - let max_ofs = hint + 1; - while ofs < max_ofs && *key < array[hint-ofs] { - last_ofs = ofs; - ofs = (ofs << 1) + 1; - if ofs < last_ofs { ofs = max_ofs; } - } - if ofs > max_ofs { ofs = max_ofs; } - - let tmp = last_ofs; - last_ofs = hint - ofs; - ofs = hint - tmp; - } - - assert!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size); - - last_ofs += 1; - while last_ofs < ofs { - let m = last_ofs + ((ofs - last_ofs) >> 1); - - if *key >= array[m] { - last_ofs = m + 1; - } else { - ofs = m; - } - } - assert_eq!(last_ofs, ofs); - return ofs; -} - -struct RunState { - base: uint, - len: uint, -} - -struct MergeState { - min_gallop: uint, - runs: ~[RunState], -} - -// Fixme (#3853) Move into MergeState -fn MergeState() -> MergeState { - MergeState { - min_gallop: MIN_GALLOP, - runs: ~[], - } -} - -impl MergeState { - fn push_run(&mut self, run_base: uint, run_len: uint) { - let tmp = RunState{base: run_base, len: run_len}; - self.runs.push(tmp); - } - - fn merge_at(&mut self, n: uint, array: &mut [T]) { - let size = self.runs.len(); - assert!(size >= 2); - assert!(n == size-2 || n == size-3); - - let mut b1 = self.runs[n].base; - let mut l1 = self.runs[n].len; - let b2 = self.runs[n+1].base; - let l2 = self.runs[n+1].len; - - assert!(l1 > 0 && l2 > 0); - assert_eq!(b1 + l1, b2); - - self.runs[n].len = l1 + l2; - if n == size-3 { - self.runs[n+1].base = self.runs[n+2].base; - self.runs[n+1].len = self.runs[n+2].len; - } - - let k = { // constrain lifetime of slice below - let slice = array.slice(b1, b1+l1); - gallop_right(&array[b2], slice, 0) - }; - b1 += k; - l1 -= k; - if l1 != 0 { - let l2 = { // constrain lifetime of slice below - let slice = array.slice(b2, b2+l2); - gallop_left(&array[b1+l1-1],slice,l2-1) - }; - if l2 > 0 { - if l1 <= l2 { - self.merge_lo(array, b1, l1, b2, l2); - } else { - self.merge_hi(array, b1, l1, b2, l2); - } - } - } - self.runs.pop(); - } - - fn merge_lo(&mut self, array: &mut [T], base1: uint, len1: uint, - base2: uint, len2: uint) { - assert!(len1 != 0 && len2 != 0 && base1+len1 == base2); - - let mut tmp = array.slice(base1, base1 + len1).to_owned(); - - let mut c1 = 0; - let mut c2 = base2; - let mut dest = base1; - let mut len1 = len1; - let mut len2 = len2; - - array.swap(dest, c2); - dest += 1; c2 += 1; len2 -= 1; - - if len2 == 0 { - copy_vec(array, dest, tmp.slice(0, len1)); - return; - } - if len1 == 1 { - shift_vec(array, dest, c2, len2); - swap(&mut tmp[c1], &mut array[dest+len2]); - return; - } - - let mut min_gallop = self.min_gallop; - loop { - let mut count1 = 0; - let mut count2 = 0; - let mut break_outer = false; - - loop { - assert!(len1 > 1 && len2 != 0); - if array[c2] < tmp[c1] { - array.swap(dest, c2); - dest += 1; c2 += 1; len2 -= 1; - count2 += 1; count1 = 0; - if len2 == 0 { - break_outer = true; - } - } else { - swap(&mut array[dest], &mut tmp[c1]); - dest += 1; c1 += 1; len1 -= 1; - count1 += 1; count2 = 0; - if len1 == 1 { - break_outer = true; - } - } - if break_outer || ((count1 | count2) >= min_gallop) { - break; - } - } - if break_outer { break; } - - // Start to gallop - loop { - assert!(len1 > 1 && len2 != 0); - - count1 = { - let tmp_view = tmp.slice(c1, c1+len1); - gallop_right(&array[c2], tmp_view, 0) - }; - if count1 != 0 { - copy_vec(array, dest, tmp.slice(c1, c1+count1)); - dest += count1; c1 += count1; len1 -= count1; - if len1 <= 1 { break_outer = true; break; } - } - array.swap(dest, c2); - dest += 1; c2 += 1; len2 -= 1; - if len2 == 0 { break_outer = true; break; } - - count2 = { - let tmp_view = array.slice(c2, c2+len2); - gallop_left(&tmp[c1], tmp_view, 0) - }; - if count2 != 0 { - shift_vec(array, dest, c2, count2); - dest += count2; c2 += count2; len2 -= count2; - if len2 == 0 { break_outer = true; break; } - } - swap(&mut array[dest], &mut tmp[c1]); - dest += 1; c1 += 1; len1 -= 1; - if len1 == 1 { break_outer = true; break; } - min_gallop -= 1; - if !(count1 >= MIN_GALLOP || count2 >= MIN_GALLOP) { - break; - } - } - if break_outer { break; } - if min_gallop < 0 { min_gallop = 0; } - min_gallop += 2; // Penalize for leaving gallop - } - self.min_gallop = if min_gallop < 1 { 1 } else { min_gallop }; - - if len1 == 1 { - assert!(len2 > 0); - shift_vec(array, dest, c2, len2); - swap(&mut array[dest+len2], &mut tmp[c1]); - } else if len1 == 0 { - fail!("Comparison violates its contract!"); - } else { - assert_eq!(len2, 0); - assert!(len1 > 1); - copy_vec(array, dest, tmp.slice(c1, c1+len1)); - } - } - - fn merge_hi(&mut self, array: &mut [T], base1: uint, len1: uint, - base2: uint, len2: uint) { - assert!(len1 != 1 && len2 != 0 && base1 + len1 == base2); - - let mut tmp = array.slice(base2, base2 + len2).to_owned(); - - let mut c1 = base1 + len1 - 1; - let mut c2 = len2 - 1; - let mut dest = base2 + len2 - 1; - let mut len1 = len1; - let mut len2 = len2; - - array.swap(dest, c1); - dest -= 1; c1 -= 1; len1 -= 1; - - if len1 == 0 { - copy_vec(array, dest-(len2-1), tmp.slice(0, len2)); - return; - } - if len2 == 1 { - dest -= len1; - c1 -= len1; - shift_vec(array, dest+1, c1+1, len1); - swap(&mut array[dest], &mut tmp[c2]); - return; - } - - let mut min_gallop = self.min_gallop; - loop { - let mut count1 = 0; - let mut count2 = 0; - let mut break_outer = false; - - loop { - assert!(len1 != 0 && len2 > 1); - if tmp[c2] < array[c1] { - array.swap(dest, c1); - dest -= 1; c1 -= 1; len1 -= 1; - count1 += 1; count2 = 0; - if len1 == 0 { - break_outer = true; - } - } else { - swap(&mut array[dest], &mut tmp[c2]); - dest -= 1; c2 -= 1; len2 -= 1; - count2 += 1; count1 = 0; - if len2 == 1 { - break_outer = true; - } - } - if break_outer || ((count1 | count2) >= min_gallop) { - break; - } - } - if break_outer { break; } - - // Start to gallop - loop { - assert!(len2 > 1 && len1 != 0); - - { // constrain scope of tmp_view: - let tmp_view = array.mut_slice(base1, base1+len1); - count1 = len1 - gallop_right( - &tmp[c2], tmp_view, len1-1); - } - - if count1 != 0 { - dest -= count1; c1 -= count1; len1 -= count1; - shift_vec(array, dest+1, c1+1, count1); - if len1 == 0 { break_outer = true; break; } - } - - swap(&mut array[dest], &mut tmp[c2]); - dest -= 1; c2 -= 1; len2 -= 1; - if len2 == 1 { break_outer = true; break; } - - let count2; - { // constrain scope of tmp_view - let tmp_view = tmp.mut_slice(0, len2); - count2 = len2 - gallop_left(&array[c1], - tmp_view, - len2-1); - } - - if count2 != 0 { - dest -= count2; c2 -= count2; len2 -= count2; - copy_vec(array, dest+1, tmp.slice(c2+1, c2+1+count2)); - if len2 <= 1 { break_outer = true; break; } - } - array.swap(dest, c1); - dest -= 1; c1 -= 1; len1 -= 1; - if len1 == 0 { break_outer = true; break; } - min_gallop -= 1; - if !(count1 >= MIN_GALLOP || count2 >= MIN_GALLOP) { - break; - } - } - - if break_outer { break; } - if min_gallop < 0 { min_gallop = 0; } - min_gallop += 2; // Penalize for leaving gallop - } - self.min_gallop = if min_gallop < 1 { 1 } else { min_gallop }; - - if len2 == 1 { - assert!(len1 > 0); - dest -= len1; - c1 -= len1; - shift_vec(array, dest+1, c1+1, len1); - swap(&mut array[dest], &mut tmp[c2]); - } else if len2 == 0 { - fail!("Comparison violates its contract!"); - } else { - assert_eq!(len1, 0); - assert!(len2 != 0); - copy_vec(array, dest-(len2-1), tmp.slice(0, len2)); - } - } - - fn merge_collapse(&mut self, array: &mut [T]) { - while self.runs.len() > 1 { - let mut n = self.runs.len()-2; - if n > 0 && - self.runs[n-1].len <= self.runs[n].len + self.runs[n+1].len - { - if self.runs[n-1].len < self.runs[n+1].len { n -= 1; } - } else if self.runs[n].len <= self.runs[n+1].len { - /* keep going */ - } else { - break; - } - self.merge_at(n, array); - } - } - - fn merge_force_collapse(&mut self, array: &mut [T]) { - while self.runs.len() > 1 { - let mut n = self.runs.len()-2; - if n > 0 { - if self.runs[n-1].len < self.runs[n+1].len { - n -= 1; - } - } - self.merge_at(n, array); - } - } -} - -#[inline] -fn copy_vec(dest: &mut [T], - s1: uint, - from: &[T]) { - assert!(s1+from.len() <= dest.len()); - - for (i, v) in from.iter().enumerate() { - dest[s1+i] = (*v).clone(); - } -} - -#[inline] -fn shift_vec(dest: &mut [T], s1: uint, s2: uint, len: uint) { - assert!(s1+len <= dest.len()); - - let tmp = dest.slice(s2, s2+len).to_owned(); - copy_vec(dest, s1, tmp); -} - -#[cfg(test)] -mod test_qsort3 { - use sort::*; - - - fn check_sort(v1: &mut [int], v2: &mut [int]) { - let len = v1.len(); - quick_sort3::(v1); - let mut i = 0; - while i < len { - assert_eq!(v2[i], v1[i]); - i += 1; - } - } - - #[test] - fn test() { - { - let mut v1 = ~[3, 7, 4, 5, 2, 9, 5, 8]; - let mut v2 = ~[2, 3, 4, 5, 5, 7, 8, 9]; - check_sort(v1, v2); - } - { - let mut v1 = ~[1, 1, 1]; - let mut v2 = ~[1, 1, 1]; - check_sort(v1, v2); - } - { - let mut v1: ~[int] = ~[]; - let mut v2: ~[int] = ~[]; - check_sort(v1, v2); - } - { let mut v1 = ~[9]; let mut v2 = ~[9]; check_sort(v1, v2); } - { - let mut v1 = ~[9, 3, 3, 3, 9]; - let mut v2 = ~[3, 3, 3, 9, 9]; - check_sort(v1, v2); - } - } -} - -#[cfg(test)] -mod test_qsort { - use sort::*; - - fn check_sort(v1: &mut [int], v2: &mut [int]) { - let len = v1.len(); - fn leual(a: &int, b: &int) -> bool { *a <= *b } - quick_sort::(v1, leual); - let mut i = 0u; - while i < len { - // debug!(v2[i]); - assert_eq!(v2[i], v1[i]); - i += 1; - } - } - - #[test] - fn test() { - { - let mut v1 = ~[3, 7, 4, 5, 2, 9, 5, 8]; - let mut v2 = ~[2, 3, 4, 5, 5, 7, 8, 9]; - check_sort(v1, v2); - } - { - let mut v1 = ~[1, 1, 1]; - let mut v2 = ~[1, 1, 1]; - check_sort(v1, v2); - } - { - let mut v1: ~[int] = ~[]; - let mut v2: ~[int] = ~[]; - check_sort(v1, v2); - } - { let mut v1 = ~[9]; let mut v2 = ~[9]; check_sort(v1, v2); } - { - let mut v1 = ~[9, 3, 3, 3, 9]; - let mut v2 = ~[3, 3, 3, 9, 9]; - check_sort(v1, v2); - } - } - - // Regression test for #750 - #[test] - fn test_simple() { - let mut names = ~[2, 1, 3]; - - let expected = ~[1, 2, 3]; - - quick_sort(names, |x, y| *x < *y); - - let immut_names = names; - - for (&a, &b) in expected.iter().zip(immut_names.iter()) { - debug!("{} {}", a, b); - assert_eq!(a, b); - } - } -} - -#[cfg(test)] -mod tests { - - use sort::*; - - fn check_sort(v1: &[int], v2: &[int]) { - let len = v1.len(); - fn le(a: &int, b: &int) -> bool { *a <= *b } - let f = le; - let v3 = merge_sort::(v1, f); - let mut i = 0u; - while i < len { - debug!("{:?}", v3[i]); - assert_eq!(v3[i], v2[i]); - i += 1; - } - } - - #[test] - fn test() { - { - let v1 = ~[3, 7, 4, 5, 2, 9, 5, 8]; - let v2 = ~[2, 3, 4, 5, 5, 7, 8, 9]; - check_sort(v1, v2); - } - { let v1 = ~[1, 1, 1]; let v2 = ~[1, 1, 1]; check_sort(v1, v2); } - { let v1:~[int] = ~[]; let v2:~[int] = ~[]; check_sort(v1, v2); } - { let v1 = ~[9]; let v2 = ~[9]; check_sort(v1, v2); } - { - let v1 = ~[9, 3, 3, 3, 9]; - let v2 = ~[3, 3, 3, 9, 9]; - check_sort(v1, v2); - } - } - - #[test] - fn test_merge_sort_mutable() { - fn le(a: &int, b: &int) -> bool { *a <= *b } - let v1 = ~[3, 2, 1]; - let v2 = merge_sort(v1, le); - assert_eq!(v2, ~[1, 2, 3]); - } - - #[test] - fn test_merge_sort_stability() { - // tjc: funny that we have to use parens - fn ile(x: &(&'static str), y: &(&'static str)) -> bool - { - let x = x.to_ascii().to_lower().into_str(); - let y = y.to_ascii().to_lower().into_str(); - x <= y - } - - let names1 = ~["joe bob", "Joe Bob", "Jack Brown", "JOE Bob", - "Sally Mae", "JOE BOB", "Alex Andy"]; - let names2 = ~["Alex Andy", "Jack Brown", "joe bob", "Joe Bob", - "JOE Bob", "JOE BOB", "Sally Mae"]; - let names3 = merge_sort(names1, ile); - assert_eq!(names3, names2); - } -} - -#[cfg(test)] -mod test_tim_sort { - - use sort::tim_sort; - use std::rand::Rng; - use std::rand; - use std::vec; - - #[deriving(Clone)] - struct CVal { - val: f64, - } - - impl Ord for CVal { - fn lt(&self, other: &CVal) -> bool { - let mut rng = rand::rng(); - if rng.gen::() > 0.995 { - fail!("It's happening!!!"); - } - (*self).val < other.val - } - fn le(&self, other: &CVal) -> bool { (*self).val <= other.val } - fn gt(&self, other: &CVal) -> bool { (*self).val > other.val } - fn ge(&self, other: &CVal) -> bool { (*self).val >= other.val } - } - - fn check_sort(v1: &mut [int], v2: &mut [int]) { - let len = v1.len(); - tim_sort::(v1); - let mut i = 0u; - while i < len { - // debug!(v2[i]); - assert_eq!(v2[i], v1[i]); - i += 1u; - } - } - - #[test] - fn test() { - { - let mut v1 = ~[3, 7, 4, 5, 2, 9, 5, 8]; - let mut v2 = ~[2, 3, 4, 5, 5, 7, 8, 9]; - check_sort(v1, v2); - } - { - let mut v1 = ~[1, 1, 1]; - let mut v2 = ~[1, 1, 1]; - check_sort(v1, v2); - } - { - let mut v1: ~[int] = ~[]; - let mut v2: ~[int] = ~[]; - check_sort(v1, v2); - } - { let mut v1 = ~[9]; let mut v2 = ~[9]; check_sort(v1, v2); } - { - let mut v1 = ~[9, 3, 3, 3, 9]; - let mut v2 = ~[3, 3, 3, 9, 9]; - check_sort(v1, v2); - } - } - - #[test] - #[should_fail] - #[cfg(unix)] - fn crash_test() { - let mut rng = rand::rng(); - let mut arr = vec::from_fn(1000, |_i| { - CVal { val: rng.gen() } - }); - - tim_sort(arr); - fail!("Guarantee the fail"); - } - - #[deriving(Clone)] - struct DVal { - val: uint, - } - - impl Ord for DVal { - fn lt(&self, _x: &DVal) -> bool { true } - fn le(&self, _x: &DVal) -> bool { true } - fn gt(&self, _x: &DVal) -> bool { true } - fn ge(&self, _x: &DVal) -> bool { true } - } - - #[test] - fn test_bad_Ord_impl() { - let mut rng = rand::rng(); - let mut arr = vec::from_fn(500, |_i| { - DVal { val: rng.gen() } - }); - - tim_sort(arr); - } -} - -#[cfg(test)] -mod big_tests { - - use sort::*; - - use std::rand::Rng; - use std::rand; - use std::vec; - - #[test] - fn test_unique() { - let low = 5; - let high = 10; - tabulate_unique(low, high); - } - - #[test] - fn test_managed() { - let low = 5; - let high = 10; - tabulate_managed(low, high); - } - - fn multiplyVec(arr: &[T], num: uint) -> ~[T] { - let size = arr.len(); - let res = vec::from_fn(num, |i| { - arr[i % size].clone() - }); - res - } - - fn makeRange(n: uint) -> ~[uint] { - let one = vec::from_fn(n, |i| i); - let mut two = one.clone(); - two.reverse(); - vec::append(two, one) - } - - fn tabulate_unique(lo: uint, hi: uint) { - fn isSorted(arr: &[T]) { - for i in range(0u, arr.len() - 1) { - if arr[i] > arr[i+1] { - fail!("Array not sorted"); - } - } - } - - let mut rng = rand::rng(); - - for i in range(lo, hi) { - let n = 1 << i; - let mut arr: ~[f64] = vec::from_fn(n, |_i| { - rng.gen() - }); - - tim_sort(arr); // *sort - isSorted(arr); - - arr.reverse(); - tim_sort(arr); // \sort - isSorted(arr); - - tim_sort(arr); // /sort - isSorted(arr); - - 3.times(|| { - let i1 = rng.gen_range(0u, n); - let i2 = rng.gen_range(0u, n); - arr.swap(i1, i2); - }); - tim_sort(arr); // 3sort - isSorted(arr); - - if n >= 10 { - let size = arr.len(); - let mut idx = 1; - while idx <= 10 { - arr[size-idx] = rng.gen(); - idx += 1; - } - } - tim_sort(arr); // +sort - isSorted(arr); - - (n/100).times(|| { - let idx = rng.gen_range(0u, n); - arr[idx] = rng.gen(); - }); - tim_sort(arr); - isSorted(arr); - - let mut arr = if n > 4 { - let part = arr.slice(0, 4); - multiplyVec(part, n) - } else { arr }; - tim_sort(arr); // ~sort - isSorted(arr); - - let mut arr = vec::from_elem(n, -0.5); - tim_sort(arr); // =sort - isSorted(arr); - - let half = n / 2; - let mut arr = makeRange(half).map(|i| *i as f64); - tim_sort(arr); // !sort - isSorted(arr); - } - } - - fn tabulate_managed(lo: uint, hi: uint) { - fn isSorted(arr: &[@T]) { - for i in range(0u, arr.len() - 1) { - if arr[i] > arr[i+1] { - fail!("Array not sorted"); - } - } - } - - let mut rng = rand::rng(); - - for i in range(lo, hi) { - let n = 1 << i; - let arr: ~[@f64] = vec::from_fn(n, |_i| { - @rng.gen() - }); - let mut arr = arr; - - tim_sort(arr); // *sort - isSorted(arr); - - arr.reverse(); - tim_sort(arr); // \sort - isSorted(arr); - - tim_sort(arr); // /sort - isSorted(arr); - - 3.times(|| { - let i1 = rng.gen_range(0u, n); - let i2 = rng.gen_range(0u, n); - arr.swap(i1, i2); - }); - tim_sort(arr); // 3sort - isSorted(arr); - - if n >= 10 { - let size = arr.len(); - let mut idx = 1; - while idx <= 10 { - arr[size-idx] = @rng.gen(); - idx += 1; - } - } - tim_sort(arr); // +sort - isSorted(arr); - - (n/100).times(|| { - let idx = rng.gen_range(0u, n); - arr[idx] = @rng.gen(); - }); - tim_sort(arr); - isSorted(arr); - - let mut arr = if n > 4 { - let part = arr.slice(0, 4); - multiplyVec(part, n) - } else { arr }; - tim_sort(arr); // ~sort - isSorted(arr); - - let mut arr = vec::from_elem(n, @(-0.5)); - tim_sort(arr); // =sort - isSorted(arr); - - let half = n / 2; - let mut arr = makeRange(half).map(|i| @(*i as f64)); - tim_sort(arr); // !sort - isSorted(arr); - } - } -} diff --git a/src/libextra/stats.rs b/src/libextra/stats.rs index 07fb7ae96c746..5f3700fec0790 100644 --- a/src/libextra/stats.rs +++ b/src/libextra/stats.rs @@ -10,7 +10,6 @@ #[allow(missing_doc)]; -use sort; use std::cmp; use std::hashmap; use std::io; @@ -20,6 +19,25 @@ use std::util; // NB: this can probably be rewritten in terms of num::Num // to be less f64-specific. +fn f64_cmp(x: f64, y: f64) -> Ordering { + // arbitrarily decide that NaNs are larger than everything. + if y.is_nan() { + Less + } else if x.is_nan() { + Greater + } else if x < y { + Less + } else if x == y { + Equal + } else { + Greater + } +} + +fn f64_sort(v: &mut [f64]) { + v.sort_by(|x: &f64, y: &f64| f64_cmp(*x, *y)); +} + /// Trait that provides simple descriptive statistics on a univariate set of numeric samples. pub trait Stats { @@ -240,13 +258,13 @@ impl<'a> Stats for &'a [f64] { fn percentile(self, pct: f64) -> f64 { let mut tmp = self.to_owned(); - sort::tim_sort(tmp); + f64_sort(tmp); percentile_of_sorted(tmp, pct) } fn quartiles(self) -> (f64,f64,f64) { let mut tmp = self.to_owned(); - sort::tim_sort(tmp); + f64_sort(tmp); let a = percentile_of_sorted(tmp, 25.0); let b = percentile_of_sorted(tmp, 50.0); let c = percentile_of_sorted(tmp, 75.0); @@ -291,7 +309,7 @@ fn percentile_of_sorted(sorted_samples: &[f64], /// See: http://en.wikipedia.org/wiki/Winsorising pub fn winsorize(samples: &mut [f64], pct: f64) { let mut tmp = samples.to_owned(); - sort::tim_sort(tmp); + f64_sort(tmp); let lo = percentile_of_sorted(tmp, pct); let hi = percentile_of_sorted(tmp, 100.0-pct); for samp in samples.mut_iter() { diff --git a/src/libextra/test.rs b/src/libextra/test.rs index 8f0c4fe6d2347..3d6dfd612f254 100644 --- a/src/libextra/test.rs +++ b/src/libextra/test.rs @@ -21,7 +21,6 @@ use getopts::groups; use json::ToJson; use json; use serialize::Decodable; -use sort; use stats::Stats; use stats; use term; @@ -38,7 +37,6 @@ use std::to_str::ToStr; use std::f64; use std::os; - // The name of a test. By convention this follows the rules for rust // paths; i.e. it should be a series of identifiers separated by double // colons. This way if some test runner wants to arrange the tests @@ -488,7 +486,7 @@ impl ConsoleTestState { for f in self.failures.iter() { failures.push(f.name.to_str()); } - sort::tim_sort(failures); + failures.sort(); for name in failures.iter() { self.write_plain(format!(" {}\n", name.to_str())); } @@ -839,10 +837,7 @@ pub fn filter_tests( }; // Sort the tests alphabetically - fn lteq(t1: &TestDescAndFn, t2: &TestDescAndFn) -> bool { - t1.desc.name.to_str() < t2.desc.name.to_str() - } - sort::quick_sort(filtered, lteq); + filtered.sort_by(|t1, t2| t1.desc.name.to_str().cmp(&t2.desc.name.to_str())); // Shard the remaining tests, if sharding requested. match opts.test_shard { diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index f0bff76685fe6..a74497208c013 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -150,7 +150,6 @@ Additional help: } pub fn describe_warnings() { - use extra::sort::Sort; println(" Available lint options: -W Warn about @@ -163,7 +162,7 @@ Available lint options: let mut lint_dict = lint_dict.move_iter() .map(|(k, v)| (v, k)) .collect::<~[(lint::LintSpec, &'static str)]>(); - lint_dict.qsort(); + lint_dict.sort(); let mut max_key = 0; for &(_, name) in lint_dict.iter() { diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index c2f6443ed5401..d6c79e7861c73 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -17,7 +17,6 @@ use metadata::cstore; use metadata::decoder; use std::hashmap::HashMap; -use extra; use syntax::ast; use syntax::parse::token::ident_interner; @@ -168,7 +167,7 @@ pub fn find_extern_mod_stmt_cnum(cstore: &CStore, cstore.extern_mod_crate_map.find(&emod_id).map(|x| *x) } -#[deriving(Clone)] +#[deriving(Clone, TotalEq, TotalOrd)] struct crate_hash { name: @str, vers: @str, @@ -192,14 +191,12 @@ pub fn get_dep_hashes(cstore: &CStore) -> ~[@str] { }); } - let sorted = extra::sort::merge_sort(result, |a, b| { - (a.name, a.vers, a.hash) <= (b.name, b.vers, b.hash) - }); + result.sort(); debug!("sorted:"); - for x in sorted.iter() { + for x in result.iter() { debug!(" hash[{}]: {}", x.name, x.hash); } - sorted.map(|ch| ch.hash) + result.map(|ch| ch.hash) } diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 8d8c246f2cad0..5b2a51e419f85 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -30,7 +30,6 @@ use std::util; use std::vec; use extra::serialize::Encodable; -use extra; use syntax::abi::AbiSet; use syntax::ast::*; @@ -1532,7 +1531,7 @@ fn encode_crate_deps(ecx: &EncodeContext, }); // Sort by cnum - extra::sort::quick_sort(deps, |kv1, kv2| kv1.cnum <= kv2.cnum); + deps.sort_by(|kv1, kv2| kv1.cnum.cmp(&kv2.cnum)); // Sanity-check the crate numbers let mut expected_cnum = 1; diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 7e236a8751434..948c7932ca0dc 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -21,7 +21,6 @@ use util::ppaux::ty_to_str; use std::iter; use std::num; use std::vec; -use extra::sort; use syntax::ast::*; use syntax::ast_util::{unguarded_pat, walk_pat}; use syntax::codemap::{Span, dummy_sp, Spanned}; @@ -454,7 +453,7 @@ fn missing_ctor(cx: &MatchCheckCtxt, ty::ty_unboxed_vec(..) | ty::ty_evec(..) => { // Find the lengths and slices of all vector patterns. - let vec_pat_lens = m.iter().filter_map(|r| { + let mut vec_pat_lens = m.iter().filter_map(|r| { match r[0].node { PatVec(ref before, ref slice, ref after) => { Some((before.len() + after.len(), slice.is_some())) @@ -465,21 +464,19 @@ fn missing_ctor(cx: &MatchCheckCtxt, // Sort them by length such that for patterns of the same length, // those with a destructured slice come first. - let mut sorted_vec_lens = sort::merge_sort(vec_pat_lens, - |&(len1, slice1), &(len2, slice2)| { - if len1 == len2 { - slice1 > slice2 - } else { - len1 <= len2 - } - } - ); - sorted_vec_lens.dedup(); + vec_pat_lens.sort_by(|&(len1, slice1), &(len2, slice2)| { + if len1 == len2 { + slice2.cmp(&slice1) + } else { + len1.cmp(&len2) + } + }); + vec_pat_lens.dedup(); let mut found_slice = false; let mut next = 0; let mut missing = None; - for &(length, slice) in sorted_vec_lens.iter() { + for &(length, slice) in vec_pat_lens.iter() { if length != next { missing = Some(next); break; diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index bdf4c550378fe..9ec0fa337168c 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -63,7 +63,7 @@ use syntax::{ast, ast_util, visit}; use syntax::ast_util::IdVisitingOperation; use syntax::visit::Visitor; -#[deriving(Clone, Eq)] +#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)] pub enum lint { ctypes, unused_imports, @@ -110,20 +110,16 @@ pub fn level_to_str(lv: level) -> &'static str { } } -#[deriving(Clone, Eq, Ord)] +#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)] pub enum level { allow, warn, deny, forbid } -#[deriving(Clone, Eq)] +#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)] pub struct LintSpec { + default: level, lint: lint, desc: &'static str, - default: level -} - -impl Ord for LintSpec { - fn lt(&self, other: &LintSpec) -> bool { self.default < other.default } } pub type LintDict = HashMap<&'static str, LintSpec>; diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 7ab3b4fd69eab..c562a78b961cc 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -73,7 +73,6 @@ use std::libc::c_uint; use std::vec; use std::local_data; use extra::time; -use extra::sort; use syntax::ast::Name; use syntax::ast_map::{path, path_elt_to_str, path_name, path_pretty_name}; use syntax::ast_util::{local_def, is_local}; @@ -3163,10 +3162,9 @@ pub fn trans_crate(sess: session::Session, println!("n_inlines: {}", ccx.stats.n_inlines); println!("n_closures: {}", ccx.stats.n_closures); println("fn stats:"); - sort::quick_sort(ccx.stats.fn_stats, - |&(_, _, insns_a), &(_, _, insns_b)| { - insns_a > insns_b - }); + + ccx.stats.fn_stats.sort_by(|&(_, _, insns_a), &(_, _, insns_b)| insns_b.cmp(&insns_a)); + for tuple in ccx.stats.fn_stats.iter() { match *tuple { (ref name, ms, insns) => { diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index c84caf8acdd3a..8a14e37c81689 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -45,8 +45,6 @@ use std::vec; use extra::arc::Arc; use extra::json::ToJson; -use extra::sort; - use syntax::ast; use syntax::attr; @@ -900,44 +898,44 @@ fn item_module(w: &mut Writer, cx: &Context, debug!("{:?}", items); let mut indices = vec::from_fn(items.len(), |i| i); - fn lt(i1: &clean::Item, i2: &clean::Item, idx1: uint, idx2: uint) -> bool { + fn cmp(i1: &clean::Item, i2: &clean::Item, idx1: uint, idx2: uint) -> Ordering { if shortty(i1) == shortty(i2) { - return i1.name < i2.name; + return i1.name.cmp(&i2.name); } match (&i1.inner, &i2.inner) { (&clean::ViewItemItem(ref a), &clean::ViewItemItem(ref b)) => { match (&a.inner, &b.inner) { - (&clean::ExternMod(..), _) => true, - (_, &clean::ExternMod(..)) => false, - _ => idx1 < idx2, + (&clean::ExternMod(..), _) => Less, + (_, &clean::ExternMod(..)) => Greater, + _ => idx1.cmp(&idx2), } } - (&clean::ViewItemItem(..), _) => true, - (_, &clean::ViewItemItem(..)) => false, - (&clean::ModuleItem(..), _) => true, - (_, &clean::ModuleItem(..)) => false, - (&clean::StructItem(..), _) => true, - (_, &clean::StructItem(..)) => false, - (&clean::EnumItem(..), _) => true, - (_, &clean::EnumItem(..)) => false, - (&clean::StaticItem(..), _) => true, - (_, &clean::StaticItem(..)) => false, - (&clean::ForeignFunctionItem(..), _) => true, - (_, &clean::ForeignFunctionItem(..)) => false, - (&clean::ForeignStaticItem(..), _) => true, - (_, &clean::ForeignStaticItem(..)) => false, - (&clean::TraitItem(..), _) => true, - (_, &clean::TraitItem(..)) => false, - (&clean::FunctionItem(..), _) => true, - (_, &clean::FunctionItem(..)) => false, - (&clean::TypedefItem(..), _) => true, - (_, &clean::TypedefItem(..)) => false, - _ => idx1 < idx2, + (&clean::ViewItemItem(..), _) => Less, + (_, &clean::ViewItemItem(..)) => Greater, + (&clean::ModuleItem(..), _) => Less, + (_, &clean::ModuleItem(..)) => Greater, + (&clean::StructItem(..), _) => Less, + (_, &clean::StructItem(..)) => Greater, + (&clean::EnumItem(..), _) => Less, + (_, &clean::EnumItem(..)) => Greater, + (&clean::StaticItem(..), _) => Less, + (_, &clean::StaticItem(..)) => Greater, + (&clean::ForeignFunctionItem(..), _) => Less, + (_, &clean::ForeignFunctionItem(..)) => Greater, + (&clean::ForeignStaticItem(..), _) => Less, + (_, &clean::ForeignStaticItem(..)) => Greater, + (&clean::TraitItem(..), _) => Less, + (_, &clean::TraitItem(..)) => Greater, + (&clean::FunctionItem(..), _) => Less, + (_, &clean::FunctionItem(..)) => Greater, + (&clean::TypedefItem(..), _) => Less, + (_, &clean::TypedefItem(..)) => Greater, + _ => idx1.cmp(&idx2), } } debug!("{:?}", indices); - sort::quick_sort(indices, |&i1, &i2| lt(&items[i1], &items[i2], i1, i2)); + indices.sort_by(|&i1, &i2| cmp(&items[i1], &items[i2], i1, i2)); debug!("{:?}", indices); let mut curty = ""; @@ -1532,7 +1530,7 @@ fn build_sidebar(m: &clean::Module) -> HashMap<~str, ~[~str]> { } for (_, items) in map.mut_iter() { - sort::quick_sort(*items, |i1, i2| i1 < i2); + items.sort(); } return map; } diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs index 47004ea173f32..583e87370bc72 100644 --- a/src/libstd/prelude.rs +++ b/src/libstd/prelude.rs @@ -79,7 +79,8 @@ pub use tuple::{Tuple1, Tuple2, Tuple3, Tuple4}; pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8}; pub use tuple::{Tuple9, Tuple10, Tuple11, Tuple12}; pub use vec::{ImmutableEqVector, ImmutableTotalOrdVector, ImmutableCopyableVector}; -pub use vec::{OwnedVector, OwnedCopyableVector,OwnedEqVector, MutableVector}; +pub use vec::{OwnedVector, OwnedCopyableVector,OwnedEqVector}; +pub use vec::{MutableVector, MutableTotalOrdVector}; pub use vec::{Vector, VectorVector, CopyableVector, ImmutableVector}; // Reexported runtime types diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 86297cd468f73..d31fe0ee43401 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -1921,6 +1921,151 @@ impl OwnedEqVector for ~[T] { } } +fn merge_sort(v: &mut [T], compare: |&T, &T| -> Ordering) { + // warning: this wildly uses unsafe. + static INSERTION: uint = 8; + + let len = v.len(); + + // allocate some memory to use as scratch memory, we keep the + // length 0 so we can keep shallow copies of the contents of `v` + // without risking the dtors running on an object twice if + // `compare` fails. + let mut working_space = with_capacity(2 * len); + // these both are buffers of length `len`. + let mut buf_dat = working_space.as_mut_ptr(); + let mut buf_tmp = unsafe {buf_dat.offset(len as int)}; + + // length `len`. + let buf_v = v.as_ptr(); + + // step 1. sort short runs with insertion sort. This takes the + // values from `v` and sorts them into `buf_dat`, leaving that + // with sorted runs of length INSERTION. + + // We could hardcode the sorting comparisons here, and we could + // manipulate/step the pointers themselves, rather than repeatedly + // .offset-ing. + for start in range_step(0, len, INSERTION) { + // start <= i <= len; + for i in range(start, cmp::min(start + INSERTION, len)) { + // j satisfies: start <= j <= i; + let mut j = i as int; + unsafe { + // `i` is in bounds. + let read_ptr = buf_v.offset(i as int); + + // find where to insert, we need to do strict <, + // rather than <=, to maintain stability. + + // start <= j - 1 < len, so .offset(j - 1) is in + // bounds. + while j > start as int && + compare(&*read_ptr, &*buf_dat.offset(j - 1)) == Less { + j -= 1; + } + + // shift everything to the right, to make space to + // insert this value. + + // j + 1 could be `len` (for the last `i`), but in + // that case, `i == j` so we don't copy. The + // `.offset(j)` is always in bounds. + ptr::copy_memory(buf_dat.offset(j + 1), + buf_dat.offset(j), + i - j as uint); + ptr::copy_nonoverlapping_memory(buf_dat.offset(j), read_ptr, 1); + } + } + } + + // step 2. merge the sorted runs. + let mut width = INSERTION; + while width < len { + // merge the sorted runs of length `width` in `buf_dat` two at + // a time, placing the result in `buf_tmp`. + + // 0 <= start <= len. + for start in range_step(0, len, 2 * width) { + // manipulate pointers directly for speed (rather than + // using a `for` loop with `range` and `.offset` inside + // that loop). + unsafe { + // the end of the first run & start of the + // second. Offset of `len` is defined, since this is + // precisely one byte past the end of the object. + let right_start = buf_dat.offset(cmp::min(start + width, len) as int); + // end of the second. Similar reasoning to the above re safety. + let right_end_idx = cmp::min(start + 2 * width, len); + let right_end = buf_dat.offset(right_end_idx as int); + + // the pointers to the elements under consideration + // from the two runs. + + // both of these are in bounds. + let mut left = buf_dat.offset(start as int); + let mut right = right_start; + + // where we're putting the results, it is a run of + // length `2*width`, so we step it once for each step + // of either `left` or `right`. `buf_tmp` has length + // `len`, so these are in bounds. + let mut out = buf_tmp.offset(start as int); + let out_end = buf_tmp.offset(right_end_idx as int); + + while out < out_end { + // Either the left or the right run are exhausted, + // so just copy the remainder from the other run + // and move on; this gives a huge speed-up (order + // of 25%) for mostly sorted vectors (the best + // case). + if left == right_start { + // the number remaining in this run. + let elems = (right_end as uint - right as uint) / mem::size_of::(); + ptr::copy_nonoverlapping_memory(out, right, elems); + break; + } else if right == right_end { + let elems = (right_start as uint - left as uint) / mem::size_of::(); + ptr::copy_nonoverlapping_memory(out, left, elems); + break; + } + + // check which side is smaller, and that's the + // next element for the new run. + + // `left < right_start` and `right < right_end`, + // so these are valid. + let to_copy = if compare(&*left, &*right) == Greater { + step(&mut right) + } else { + step(&mut left) + }; + ptr::copy_nonoverlapping_memory(out, to_copy, 1); + step(&mut out); + } + } + } + + util::swap(&mut buf_dat, &mut buf_tmp); + + width *= 2; + } + + // write the result to `v` in one go, so that there are never two copies + // of the same object in `v`. + unsafe { + ptr::copy_nonoverlapping_memory(v.as_mut_ptr(), buf_dat, len); + } + + // increment the pointer, returning the old pointer. + #[inline(always)] + unsafe fn step(ptr: &mut *mut T) -> *mut T { + let old = *ptr; + *ptr = ptr.offset(1); + old + } +} + /// Extension methods for vectors such that their elements are /// mutable. pub trait MutableVector<'a, T> { @@ -2020,6 +2165,25 @@ pub trait MutableVector<'a, T> { /// Reverse the order of elements in a vector, in place fn reverse(self); + /// Sort the vector, in place, using `compare` to compare + /// elements. + /// + /// This sort is `O(n log n)` worst-case and stable, but allocates + /// approximately `2 * n`, where `n` is the length of `self`. + /// + /// # Example + /// + /// ```rust + /// let mut v = [5, 4, 1, 3, 2]; + /// v.sort(|a, b| a.cmp(b)); + /// assert_eq!(v, [1, 2, 3, 4, 5]); + /// + /// // reverse sorting + /// v.sort(|a, b| b.cmp(a)); + /// assert_eq!(v, [5, 4, 3, 2, 1]); + /// ``` + fn sort_by(self, compare: |&T, &T| -> Ordering); + /** * Consumes `src` and moves as many elements as it can into `self` * from the range [start,end). @@ -2164,6 +2328,11 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] { } } + #[inline] + fn sort_by(self, compare: |&T, &T| -> Ordering) { + merge_sort(self, compare) + } + #[inline] fn move_from(self, mut src: ~[T], start: uint, end: uint) -> uint { for (a, b) in self.mut_iter().zip(src.mut_slice(start, end).mut_iter()) { @@ -2217,6 +2386,32 @@ impl<'a, T:Clone> MutableCloneableVector for &'a mut [T] { } } +/// Methods for mutable vectors with orderable elements, such as +/// in-place sorting. +pub trait MutableTotalOrdVector { + /// Sort the vector, in place. + /// + /// This is equivalent to `self.sort_by(std::vec::SortForward)`. + /// + /// # Example + /// + /// ```rust + /// use std::vec; + /// + /// let mut v = [-5, 4, 1, -3, 2]; + /// + /// v.sort(); + /// assert_eq!(v, [-5, -3, 1, 2, 4]); + /// ``` + fn sort(self); +} +impl<'a, T: TotalOrd> MutableTotalOrdVector for &'a mut [T] { + #[inline] + fn sort(self) { + self.sort_by(|a,b| a.cmp(b)) + } +} + /** * Constructs a vector from an unsafe pointer to a buffer * @@ -2692,6 +2887,7 @@ mod tests { use vec::*; use cmp::*; use prelude::*; + use rand::{Rng, task_rng}; fn square(n: uint) -> uint { n * n } @@ -3298,6 +3494,64 @@ mod tests { assert!(v3.is_empty()); } + #[test] + fn test_sort() { + for len in range(4u, 25) { + for _ in range(0, 100) { + let mut v = task_rng().gen_vec::(len); + let mut v1 = v.clone(); + + v.sort(); + assert!(v.windows(2).all(|w| w[0] <= w[1])); + + v1.sort_by(|a, b| a.cmp(b)); + assert!(v1.windows(2).all(|w| w[0] <= w[1])); + + v1.sort_by(|a, b| b.cmp(a)); + assert!(v1.windows(2).all(|w| w[0] >= w[1])); + } + } + + // shouldn't fail/crash + let mut v: [uint, .. 0] = []; + v.sort(); + + let mut v = [0xDEADBEEF]; + v.sort(); + assert_eq!(v, [0xDEADBEEF]); + } + + #[test] + fn test_sort_stability() { + for len in range(4, 25) { + for _ in range(0 , 10) { + let mut counts = [0, .. 10]; + + // create a vector like [(6, 1), (5, 1), (6, 2), ...], + // where the first item of each tuple is random, but + // the second item represents which occurrence of that + // number this element is, i.e. the second elements + // will occur in sorted order. + let mut v = range(0, len).map(|_| { + let n = task_rng().gen::() % 10; + counts[n] += 1; + (n, counts[n]) + }).to_owned_vec(); + + // only sort on the first element, so an unstable sort + // may mix up the counts. + v.sort_by(|&(a,_), &(b,_)| a.cmp(&b)); + + // this comparison includes the count (the second item + // of the tuple), so elements with equal first items + // will need to be ordered with increasing + // counts... i.e. exactly asserting that this sort is + // stable. + assert!(v.windows(2).all(|w| w[0] <= w[1])); + } + } + } + #[test] fn test_partition() { assert_eq!((~[]).partition(|x: &int| *x < 3), (~[], ~[])); @@ -4121,10 +4375,11 @@ mod bench { use extra::test::BenchHarness; use iter::range; use vec; - use vec::VectorVector; + use vec::{VectorVector, MutableTotalOrdVector}; use option::*; use ptr; use rand::{weak_rng, Rng}; + use mem; #[bench] fn iterator(bh: &mut BenchHarness) { @@ -4325,4 +4580,43 @@ mod bench { } }) } + + #[bench] + fn sort_random_small(bh: &mut BenchHarness) { + let mut rng = weak_rng(); + bh.iter(|| { + let mut v: ~[u64] = rng.gen_vec(5); + v.sort(); + }); + bh.bytes = 5 * mem::size_of::() as u64; + } + + #[bench] + fn sort_random_medium(bh: &mut BenchHarness) { + let mut rng = weak_rng(); + bh.iter(|| { + let mut v: ~[u64] = rng.gen_vec(100); + v.sort(); + }); + bh.bytes = 100 * mem::size_of::() as u64; + } + + #[bench] + fn sort_random_large(bh: &mut BenchHarness) { + let mut rng = weak_rng(); + bh.iter(|| { + let mut v: ~[u64] = rng.gen_vec(10000); + v.sort(); + }); + bh.bytes = 10000 * mem::size_of::() as u64; + } + + #[bench] + fn sort_sorted(bh: &mut BenchHarness) { + let mut v = vec::from_fn(10000, |i| i); + bh.iter(|| { + v.sort(); + }); + bh.bytes = (v.len() * mem::size_of_val(&v[0])) as u64; + } } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 5e16213190cad..8dff321ca0e6a 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -10,8 +10,6 @@ // Functions dealing with attributes and meta items -use extra; - use ast; use ast::{Attribute, Attribute_, MetaItem, MetaWord, MetaNameValue, MetaList}; use codemap::{Span, Spanned, spanned, dummy_spanned}; @@ -205,7 +203,7 @@ pub fn sort_meta_items(items: &[@MetaItem]) -> ~[@MetaItem] { .map(|&mi| (mi.name(), mi)) .collect::<~[(@str, @MetaItem)]>(); - extra::sort::quick_sort(v, |&(a, _), &(b, _)| a <= b); + v.sort_by(|&(a, _), &(b, _)| a.cmp(&b)); // There doesn't seem to be a more optimal way to do this v.move_iter().map(|(_, m)| { diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index 96de609787345..2f63c6046f80f 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -15,7 +15,6 @@ extern mod extra; -use extra::sort; use std::cmp::Ord; use std::comm; use std::hashmap::HashMap; @@ -27,35 +26,32 @@ use std::task; use std::util; use std::vec; +fn f64_cmp(x: f64, y: f64) -> Ordering { + // arbitrarily decide that NaNs are larger than everything. + if y.is_nan() { + Less + } else if x.is_nan() { + Greater + } else if x < y { + Less + } else if x == y { + Equal + } else { + Greater + } +} + // given a map, print a sorted version of it fn sort_and_fmt(mm: &HashMap<~[u8], uint>, total: uint) -> ~str { fn pct(xx: uint, yy: uint) -> f64 { return (xx as f64) * 100.0 / (yy as f64); } - fn le_by_val( - kv0: &(TT,UU), - kv1: &(TT,UU)) - -> bool { - let (_, v0) = (*kv0).clone(); - let (_, v1) = (*kv1).clone(); - return v0 >= v1; - } - - fn le_by_key( - kv0: &(TT,UU), - kv1: &(TT,UU)) - -> bool { - let (k0, _) = (*kv0).clone(); - let (k1, _) = (*kv1).clone(); - return k0 <= k1; - } - // sort by key, then by value - fn sortKV(orig: ~[(TT,UU)]) -> ~[(TT,UU)] { - return sort::merge_sort(sort::merge_sort(orig, le_by_key), le_by_val); + fn sortKV(mut orig: ~[(~[u8],f64)]) -> ~[(~[u8],f64)] { + orig.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b)); + orig.sort_by(|&(_, a), &(_, b)| f64_cmp(b, a)); + orig } let mut pairs = ~[]; diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs index 84b2d33c501dc..067ef873fd3d2 100644 --- a/src/test/bench/shootout-k-nucleotide.rs +++ b/src/test/bench/shootout-k-nucleotide.rs @@ -9,7 +9,6 @@ use std::libc::{stat, strlen}; use std::ptr::null; use std::unstable::intrinsics::init; use std::vec::{reverse}; -use extra::sort::quick_sort3; static LINE_LEN: uint = 80; static TABLE: [u8, ..4] = [ 'A' as u8, 'C' as u8, 'G' as u8, 'T' as u8 ]; @@ -267,7 +266,7 @@ fn print_frequencies(frequencies: &Table, frame: i32) { for frequencies.each |entry| { vector.push((entry.code, entry.count)); } - quick_sort3(vector); + vector.sort(); let mut total_count = 0; for vector.each |&(_, count)| { diff --git a/src/test/run-pass/vector-sort-failure-safe.rs b/src/test/run-pass/vector-sort-failure-safe.rs new file mode 100644 index 0000000000000..74f27e480909c --- /dev/null +++ b/src/test/run-pass/vector-sort-failure-safe.rs @@ -0,0 +1,89 @@ +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::task; +use std::rand::{task_rng, Rng}; + +static MAX_LEN: uint = 20; +static mut drop_counts: [uint, .. MAX_LEN] = [0, .. MAX_LEN]; +static mut clone_count: uint = 0; + +#[deriving(Rand, Ord, TotalEq, TotalOrd)] +struct DropCounter { x: uint, clone_num: uint } + +impl Clone for DropCounter { + fn clone(&self) -> DropCounter { + let num = unsafe { clone_count }; + unsafe { clone_count += 1; } + DropCounter { + x: self.x, + clone_num: num + } + } +} + +impl Drop for DropCounter { + fn drop(&mut self) { + unsafe { + // Rand creates some with arbitrary clone_nums + if self.clone_num < MAX_LEN { + drop_counts[self.clone_num] += 1; + } + } + } +} + +pub fn main() { + // len can't go above 64. + for len in range(2u, MAX_LEN) { + for _ in range(0, 10) { + let main = task_rng().gen_vec::(len); + + // work out the total number of comparisons required to sort + // this array... + let mut count = 0; + main.clone().sort_by(|a, b| { count += 1; a.cmp(b) }); + + // ... and then fail on each and every single one. + for fail_countdown in range(0, count) { + // refresh the counters. + unsafe { + drop_counts = [0, .. MAX_LEN]; + clone_count = 0; + } + + let v = main.clone(); + + task::try(proc() { + let mut v = v; + let mut fail_countdown = fail_countdown; + v.sort_by(|a, b| { + if fail_countdown == 0 { + fail!() + } + fail_countdown -= 1; + a.cmp(b) + }) + }); + + // check that the number of things dropped is exactly + // what we expect (i.e. the contents of `v`). + unsafe { + for (i, &c) in drop_counts.iter().enumerate() { + let expected = if i < len {1} else {0}; + assert!(c == expected, + "found drop count == {} for i == {}, len == {}", + c, i, len); + } + } + } + } + } +}