diff --git a/src/comp/front/attr.rs b/src/comp/front/attr.rs index 061193022cb..3d3a26bc228 100644 --- a/src/comp/front/attr.rs +++ b/src/comp/front/attr.rs @@ -155,7 +155,7 @@ fn sort_meta_items(items: &[@ast::meta_item]) -> [@ast::meta_item] { let v: [mutable @ast::meta_item] = ~[mutable]; for mi: @ast::meta_item in items { v += ~[mutable mi]; } - std::sort::ivector::quick_sort(lteq, v); + std::sort::quick_sort(lteq, v); let v2: [@ast::meta_item] = ~[]; for mi: @ast::meta_item in v { v2 += ~[mi]; } diff --git a/src/comp/metadata/encoder.rs b/src/comp/metadata/encoder.rs index c35da50f965..de06f0114bc 100644 --- a/src/comp/metadata/encoder.rs +++ b/src/comp/metadata/encoder.rs @@ -552,7 +552,7 @@ fn encode_crate_deps(ebml_w: &ebmlivec::writer, cstore: &cstore::cstore) { fn lteq(kv1: &numname, kv2: &numname) -> bool { kv1.crate <= kv2.crate } - std::sort::ivector::quick_sort(lteq, pairs); + std::sort::quick_sort(lteq, pairs); // Sanity-check the crate numbers let expected_cnum = 1; diff --git a/src/comp/middle/trans_objects.rs b/src/comp/middle/trans_objects.rs index d79851813e1..428fb20059e 100644 --- a/src/comp/middle/trans_objects.rs +++ b/src/comp/middle/trans_objects.rs @@ -460,7 +460,7 @@ fn create_vtbl(cx: @local_ctxt, sp: &span, outer_obj_ty: ty::t, // Sort and process all the methods. let meths = - std::sort::ivector::merge_sort[@ast::method] + std::sort::merge_sort[@ast::method] (bind ast_mthd_lteq(_, _), ob.methods); for m: @ast::method in meths { @@ -504,7 +504,7 @@ fn create_vtbl(cx: @local_ctxt, sp: &span, outer_obj_ty: ty::t, // Sort all the methods and process them. meths = - std::sort::ivector::merge_sort[vtbl_mthd] + std::sort::merge_sort[vtbl_mthd] (bind vtbl_mthd_lteq(_, _), meths); // To create forwarding methods, we'll need a "backwarding" vtbl. See diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs index 7ab295fd2e1..c631e9bbd4a 100644 --- a/src/comp/middle/ty.rs +++ b/src/comp/middle/ty.rs @@ -1991,7 +1991,7 @@ fn sort_methods(meths: &[method]) -> [method] { fn method_lteq(a: &method, b: &method) -> bool { ret str::lteq(a.ident, b.ident); } - ret std::sort::ivector::merge_sort[method](bind method_lteq(_, _), meths); + ret std::sort::merge_sort[method](bind method_lteq(_, _), meths); } fn is_lval(expr: &@ast::expr) -> bool { diff --git a/src/lib/sort.rs b/src/lib/sort.rs index 825a16cea6d..19242b74c74 100644 --- a/src/lib/sort.rs +++ b/src/lib/sort.rs @@ -1,28 +1,25 @@ -import vec::len; -import vec::slice; -import ilen = ivec::len; -import islice = ivec::slice; -export ivector; -export lteq; +import ivec::len; +import ivec::slice; + export merge_sort; export quick_sort; export quick_sort3; type lteq[T] = block(&T, &T) -> bool ; -fn merge_sort[@T](le: <eq[T], v: vec[T]) -> vec[T] { - fn merge[@T](le: <eq[T], a: vec[T], b: vec[T]) -> vec[T] { - let rs: vec[T] = []; +fn merge_sort[@T](le: <eq[T], v: &[T]) -> [T] { + fn merge[@T](le: <eq[T], a: &[T], b: &[T]) -> [T] { + let rs: [T] = ~[]; let a_len: uint = len[T](a); let a_ix: uint = 0u; let b_len: uint = len[T](b); let b_ix: uint = 0u; while a_ix < a_len && b_ix < b_len { if le(a.(a_ix), b.(b_ix)) { - rs += [a.(a_ix)]; + rs += ~[a.(a_ix)]; a_ix += 1u; - } else { rs += [b.(b_ix)]; b_ix += 1u; } + } else { rs += ~[b.(b_ix)]; b_ix += 1u; } } rs += slice[T](a, a_ix, a_len); rs += slice[T](b, b_ix, b_len); @@ -31,18 +28,18 @@ fn merge_sort[@T](le: <eq[T], v: vec[T]) -> vec[T] { let v_len: uint = len[T](v); if v_len <= 1u { ret v; } let mid: uint = v_len / 2u; - let a: vec[T] = slice[T](v, 0u, mid); - let b: vec[T] = slice[T](v, mid, v_len); + let a: [T] = slice[T](v, 0u, mid); + let b: [T] = slice[T](v, mid, v_len); ret merge[T](le, merge_sort[T](le, a), merge_sort[T](le, b)); } -fn swap[@T](arr: vec[mutable T], x: uint, y: uint) { +fn swap[@T](arr: &[mutable T], x: uint, y: uint) { let a = arr.(x); arr.(x) = arr.(y); arr.(y) = a; } -fn part[@T](compare_func: <eq[T], arr: vec[mutable T], left: uint, +fn part[@T](compare_func: <eq[T], arr: &[mutable T], left: uint, right: uint, pivot: uint) -> uint { let pivot_value = arr.(pivot); swap[T](arr, pivot, right); @@ -59,7 +56,7 @@ fn part[@T](compare_func: <eq[T], arr: vec[mutable T], left: uint, ret storage_index; } -fn qsort[@T](compare_func: <eq[T], arr: vec[mutable T], left: uint, +fn qsort[@T](compare_func: <eq[T], arr: &[mutable T], left: uint, right: uint) { if right > left { let pivot = (left + right) / 2u; @@ -72,7 +69,7 @@ fn qsort[@T](compare_func: <eq[T], arr: vec[mutable T], left: uint, } } -fn quick_sort[@T](compare_func: <eq[T], arr: vec[mutable T]) { +fn quick_sort[@T](compare_func: <eq[T], arr: &[mutable T]) { if len[T](arr) == 0u { ret; } qsort[T](compare_func, arr, 0u, len[T](arr) - 1u); } @@ -83,7 +80,7 @@ fn quick_sort[@T](compare_func: <eq[T], arr: vec[mutable T]) { // According to these slides this is the algorithm of choice for // 'randomly ordered keys, abstract compare' & 'small number of key values' fn qsort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T], - arr: vec[mutable T], left: int, right: int) { + arr: &[mutable T], left: int, right: int) { if right <= left { ret; } let v: T = arr.(right); let i: int = left - 1; @@ -117,7 +114,7 @@ fn qsort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T], swap[T](arr, k as uint, j as uint); k += 1; j -= 1; - if k == vec::len[T](arr) as int { break; } + if k == len[T](arr) as int { break; } } k = right - 1; while k > q { @@ -131,145 +128,10 @@ fn qsort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T], } fn quick_sort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T], - arr: vec[mutable T]) { - if vec::len[T](arr) == 0u { ret; } + arr: &[mutable T]) { + if len[T](arr) == 0u { ret; } qsort3[T](compare_func_lt, compare_func_eq, arr, 0, - (vec::len[T](arr) as int) - 1); -} - -mod ivector { - export merge_sort; - export quick_sort; - export quick_sort3; - - type lteq[T] = fn(&T, &T) -> bool ; - - fn merge_sort[@T](le: <eq[T], v: &[T]) -> [T] { - fn merge[@T](le: <eq[T], a: &[T], b: &[T]) -> [T] { - let rs: [T] = ~[]; - let a_len: uint = ilen[T](a); - let a_ix: uint = 0u; - let b_len: uint = ilen[T](b); - let b_ix: uint = 0u; - while a_ix < a_len && b_ix < b_len { - if le(a.(a_ix), b.(b_ix)) { - rs += ~[a.(a_ix)]; - a_ix += 1u; - } else { rs += ~[b.(b_ix)]; b_ix += 1u; } - } - rs += islice[T](a, a_ix, a_len); - rs += islice[T](b, b_ix, b_len); - ret rs; - } - let v_len: uint = ilen[T](v); - if v_len <= 1u { ret v; } - let mid: uint = v_len / 2u; - let a: [T] = islice[T](v, 0u, mid); - let b: [T] = islice[T](v, mid, v_len); - ret merge[T](le, merge_sort[T](le, a), merge_sort[T](le, b)); - } - - fn swap[@T](arr: &[mutable T], x: uint, y: uint) { - let a = arr.(x); - arr.(x) = arr.(y); - arr.(y) = a; - } - - fn part[@T](compare_func: <eq[T], arr: &[mutable T], left: uint, - right: uint, pivot: uint) -> uint { - let pivot_value = arr.(pivot); - swap[T](arr, pivot, right); - let storage_index: uint = left; - let i: uint = left; - while i < right { - if compare_func({ arr.(i) }, pivot_value) { - swap[T](arr, i, storage_index); - storage_index += 1u; - } - i += 1u; - } - swap[T](arr, storage_index, right); - ret storage_index; - } - - fn qsort[@T](compare_func: <eq[T], arr: &[mutable T], left: uint, - right: uint) { - if right > left { - let pivot = (left + right) / 2u; - let new_pivot = part[T](compare_func, arr, left, right, pivot); - if new_pivot != 0u { - // Need to do this check before recursing due to overflow - qsort[T](compare_func, arr, left, new_pivot - 1u); - } - qsort[T](compare_func, arr, new_pivot + 1u, right); - } - } - - fn quick_sort[@T](compare_func: <eq[T], arr: &[mutable T]) { - if ilen[T](arr) == 0u { ret; } - qsort[T](compare_func, arr, 0u, ilen[T](arr) - 1u); - } - - - // Based on algorithm presented by Sedgewick and Bentley here: - // 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' - fn qsort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T], - arr: &[mutable T], left: int, right: int) { - if right <= left { ret; } - let v: T = arr.(right); - let i: int = left - 1; - let j: int = right; - let p: int = i; - let q: int = j; - while true { - i += 1; - while compare_func_lt({ arr.(i) }, v) { i += 1; } - j -= 1; - while compare_func_lt(v, { arr.(j) }) { - if j == left { break; } - j -= 1; - } - if i >= j { break; } - swap[T](arr, i as uint, j as uint); - if compare_func_eq({ arr.(i) }, v) { - p += 1; - swap[T](arr, p as uint, i as uint); - } - if compare_func_eq(v, { arr.(j) }) { - q -= 1; - swap[T](arr, j as uint, q as uint); - } - } - swap[T](arr, i as uint, right as uint); - j = i - 1; - i += 1; - let k: int = left; - while k < p { - swap[T](arr, k as uint, j as uint); - k += 1; - j -= 1; - if k == ilen[T](arr) as int { break; } - } - k = right - 1; - while k > q { - swap[T](arr, i as uint, k as uint); - k -= 1; - i += 1; - if k == 0 { break; } - } - qsort3[T](compare_func_lt, compare_func_eq, arr, left, j); - qsort3[T](compare_func_lt, compare_func_eq, arr, i, right); - } - - fn quick_sort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T], - arr: &[mutable T]) { - if ilen[T](arr) == 0u { ret; } - qsort3[T](compare_func_lt, compare_func_eq, arr, 0, - (ilen[T](arr) as int) - 1); - } + (len[T](arr) as int) - 1); } // Local Variables: diff --git a/src/lib/test.rs b/src/lib/test.rs index 70f9580bf73..de6a4555cf1 100644 --- a/src/lib/test.rs +++ b/src/lib/test.rs @@ -3,7 +3,6 @@ // simplest interface possible for representing and running tests // while providing a base that other test frameworks may build off of. -import sort = sort::ivector; import generic_os::getenv; export test_name; diff --git a/src/test/stdtest/qsort.rs b/src/test/stdtest/qsort.rs index c8f19e373b3..0799f505e3c 100644 --- a/src/test/stdtest/qsort.rs +++ b/src/test/stdtest/qsort.rs @@ -5,8 +5,8 @@ import std::sort; import std::ivec; import std::int; -fn check_sort(v1: vec[mutable int], v2: vec[mutable int]) { - let len = std::vec::len[int](v1); +fn check_sort(v1: &[mutable int], v2: &[mutable int]) { + let len = std::ivec::len[int](v1); fn ltequal(a: &int, b: &int) -> bool { ret a <= b; } let f = ltequal; std::sort::quick_sort[int](f, v1); @@ -17,24 +17,24 @@ fn check_sort(v1: vec[mutable int], v2: vec[mutable int]) { #[test] fn test() { { - let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8]; - let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9]; + let v1 = ~[mutable 3, 7, 4, 5, 2, 9, 5, 8]; + let v2 = ~[mutable 2, 3, 4, 5, 5, 7, 8, 9]; check_sort(v1, v2); } { - let v1 = [mutable 1, 1, 1]; - let v2 = [mutable 1, 1, 1]; + let v1 = ~[mutable 1, 1, 1]; + let v2 = ~[mutable 1, 1, 1]; check_sort(v1, v2); } { - let v1: vec[mutable int] = [mutable ]; - let v2: vec[mutable int] = [mutable ]; + let v1: [mutable int] = ~[mutable ]; + let v2: [mutable int] = ~[mutable ]; check_sort(v1, v2); } - { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); } + { let v1 = ~[mutable 9]; let v2 = ~[mutable 9]; check_sort(v1, v2); } { - let v1 = [mutable 9, 3, 3, 3, 9]; - let v2 = [mutable 3, 3, 3, 9, 9]; + let v1 = ~[mutable 9, 3, 3, 3, 9]; + let v2 = ~[mutable 3, 3, 3, 9, 9]; check_sort(v1, v2); } } @@ -47,7 +47,7 @@ fn test_simple() { let expected = ~[1, 2, 3]; fn lteq(a: &int, b: &int) -> bool { int::le(a, b) } - sort::ivector::quick_sort(lteq, names); + sort::quick_sort(lteq, names); let pairs = ivec::zip(expected, ivec::from_mut(names)); for p: {_0: int, _1: int} in pairs { diff --git a/src/test/stdtest/qsort3.rs b/src/test/stdtest/qsort3.rs index 79e4c42c590..fe871ceda21 100644 --- a/src/test/stdtest/qsort3.rs +++ b/src/test/stdtest/qsort3.rs @@ -1,8 +1,8 @@ use std; -fn check_sort(v1: vec[mutable int], v2: vec[mutable int]) { - let len = std::vec::len[int](v1); +fn check_sort(v1: &[mutable int], v2: &[mutable int]) { + let len = std::ivec::len[int](v1); fn lt(a: &int, b: &int) -> bool { ret a < b; } fn equal(a: &int, b: &int) -> bool { ret a == b; } let f1 = lt; @@ -15,24 +15,24 @@ fn check_sort(v1: vec[mutable int], v2: vec[mutable int]) { #[test] fn test() { { - let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8]; - let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9]; + let v1 = ~[mutable 3, 7, 4, 5, 2, 9, 5, 8]; + let v2 = ~[mutable 2, 3, 4, 5, 5, 7, 8, 9]; check_sort(v1, v2); } { - let v1 = [mutable 1, 1, 1]; - let v2 = [mutable 1, 1, 1]; + let v1 = ~[mutable 1, 1, 1]; + let v2 = ~[mutable 1, 1, 1]; check_sort(v1, v2); } { - let v1: vec[mutable int] = [mutable ]; - let v2: vec[mutable int] = [mutable ]; + let v1: [mutable int] = ~[mutable ]; + let v2: [mutable int] = ~[mutable ]; check_sort(v1, v2); } - { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); } + { let v1 = ~[mutable 9]; let v2 = ~[mutable 9]; check_sort(v1, v2); } { - let v1 = [mutable 9, 3, 3, 3, 9]; - let v2 = [mutable 3, 3, 3, 9, 9]; + let v1 = ~[mutable 9, 3, 3, 3, 9]; + let v2 = ~[mutable 3, 3, 3, 9, 9]; check_sort(v1, v2); } } diff --git a/src/test/stdtest/sort.rs b/src/test/stdtest/sort.rs index e2ce3f028fb..eac5204cde3 100644 --- a/src/test/stdtest/sort.rs +++ b/src/test/stdtest/sort.rs @@ -1,8 +1,8 @@ use std; -fn check_sort(v1: vec[int], v2: vec[int]) { - let len = std::vec::len[int](v1); +fn check_sort(v1: &[int], v2: &[int]) { + let len = std::ivec::len[int](v1); fn lteq(a: &int, b: &int) -> bool { ret a <= b; } let f = lteq; let v3 = std::sort::merge_sort[int](f, v1); @@ -13,16 +13,16 @@ fn check_sort(v1: vec[int], v2: vec[int]) { #[test] fn test() { { - let v1 = [3, 7, 4, 5, 2, 9, 5, 8]; - let v2 = [2, 3, 4, 5, 5, 7, 8, 9]; + 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: vec[int] = []; let v2: vec[int] = []; check_sort(v1, v2); } - { let v1 = [9]; let v2 = [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]; + let v1 = ~[9, 3, 3, 3, 9]; + let v2 = ~[3, 3, 3, 9, 9]; check_sort(v1, v2); } -} \ No newline at end of file +} diff --git a/src/test/stdtest/sort_ivec.rs b/src/test/stdtest/sort_ivec.rs deleted file mode 100644 index 3e52de4ad2e..00000000000 --- a/src/test/stdtest/sort_ivec.rs +++ /dev/null @@ -1,28 +0,0 @@ - -use std; - -fn check_sort(v1: &[int], v2: &[int]) { - let len = std::ivec::len[int](v1); - fn lteq(a: &int, b: &int) -> bool { ret a <= b; } - let f = lteq; - let v3 = std::sort::ivector::merge_sort[int](f, v1); - let i = 0u; - while i < len { log v3.(i); assert (v3.(i) == v2.(i)); i += 1u; } -} - -#[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); - } -} diff --git a/src/test/stdtest/stdtest.rc b/src/test/stdtest/stdtest.rc index b8907248cbd..401587ed36e 100644 --- a/src/test/stdtest/stdtest.rc +++ b/src/test/stdtest/stdtest.rc @@ -21,7 +21,6 @@ mod qsort; mod rand; mod run; mod sha1; -mod sort_ivec; mod sort; mod str_buf; mod str;