mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove vecs from std::sort

Browse Source
This commit is contained in:
Brian Anderson 2011-08-11 22:48:08 -07:00
parent abf41e15ea
commit 7625ed52ee
11 changed files with 57 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/comp/front/attr.rs
View File

@ -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]; }

2
src/comp/metadata/encoder.rs
View File

@ -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;

4
src/comp/middle/trans_objects.rs
View File

@ -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

2
src/comp/middle/ty.rs
View File

@ -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 {

176
src/lib/sort.rs
View File

@ -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: &lteq[T], v: vec[T]) -> vec[T] {
fn merge[@T](le: &lteq[T], a: vec[T], b: vec[T]) -> vec[T] {
let rs: vec[T] = [];
fn merge_sort[@T](le: &lteq[T], v: &[T]) -> [T] {
fn merge[@T](le: &lteq[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: &lteq[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: &lteq[T], arr: vec[mutable T], left: uint,
fn part[@T](compare_func: &lteq[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: &lteq[T], arr: vec[mutable T], left: uint,
ret storage_index;
}
fn qsort[@T](compare_func: &lteq[T], arr: vec[mutable T], left: uint,
fn qsort[@T](compare_func: &lteq[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: &lteq[T], arr: vec[mutable T], left: uint,
}
}
fn quick_sort[@T](compare_func: &lteq[T], arr: vec[mutable T]) {
fn quick_sort[@T](compare_func: &lteq[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: &lteq[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: &lteq[T], compare_func_eq: &lteq[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: &lteq[T], compare_func_eq: &lteq[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: &lteq[T], compare_func_eq: &lteq[T],
}
fn quick_sort3[@T](compare_func_lt: &lteq[T], compare_func_eq: &lteq[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: &lteq[T], v: &[T]) -> [T] {
fn merge[@T](le: &lteq[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: &lteq[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: &lteq[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: &lteq[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: &lteq[T], compare_func_eq: &lteq[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: &lteq[T], compare_func_eq: &lteq[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:

1
src/lib/test.rs
View File

@ -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;

24
src/test/stdtest/qsort.rs
View File

@ -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 {

22
src/test/stdtest/qsort3.rs
View File

@ -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);
}
}

20
src/test/stdtest/sort.rs
View File

@ -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);
}
}
}

28
src/test/stdtest/sort_ivec.rs
View File

@ -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);
}
}

1
src/test/stdtest/stdtest.rc
View File

@ -21,7 +21,6 @@ mod qsort;
mod rand;
mod run;
mod sha1;
mod sort_ivec;
mod sort;
mod str_buf;
mod str;