Skip to content

#5270: Change int/uint range_rev to use (hi,lo] instead of [hi,lo). #7524

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions src/libextra/smallintmap.rs
Original file line number Diff line number Diff line change
@@ -157,8 +157,8 @@ impl<V> SmallIntMap<V> {
/// Visit all key-value pairs in reverse order
pub fn each_reverse<'a>(&'a self, it: &fn(uint, &'a V) -> bool) -> bool {
for uint::range_rev(self.v.len(), 0) |i| {
match self.v[i - 1] {
Some(ref elt) => if !it(i - 1, elt) { return false; },
match self.v[i] {
Some(ref elt) => if !it(i, elt) { return false; },
None => ()
}
}
95 changes: 76 additions & 19 deletions src/libstd/num/int_macros.rs
Original file line number Diff line number Diff line change
@@ -83,28 +83,38 @@ pub fn ge(x: $T, y: $T) -> bool { x >= y }
#[inline]
pub fn gt(x: $T, y: $T) -> bool { x > y }

enum Range { Closed, HalfOpen }

#[inline]
///
/// Iterate over the range [`lo`..`hi`)
/// Iterate through a range with a given step value.
///
/// # Arguments
/// Let `term` denote the closed interval `[stop-step,stop]` if `r` is Closed;
/// otherwise `term` denotes the half-open interval `[stop-step,stop)`.
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// `x_j == start + step*j`, and `x_n` lies in the interval `term`.
///
/// * `lo` - lower bound, inclusive
/// * `hi` - higher bound, exclusive
///
/// # Examples
/// ~~~
/// let mut sum = 0;
/// for int::range(1, 5) |i| {
/// sum += i;
/// }
/// assert!(sum == 10);
/// ~~~
/// If no such nonnegative integer `n` exists, then the iteration range
/// is empty.
///
#[inline]
pub fn range_step(start: $T, stop: $T, step: $T, it: &fn($T) -> bool) -> bool {
fn range_step_core(start: $T, stop: $T, step: $T, r: Range, it: &fn($T) -> bool) -> bool {
let mut i = start;
if step == 0 {
fail!(~"range_step called with step == 0");
} else if step == (1 as $T) { // elide bounds check to tighten loop
while i < stop {
if !it(i) { return false; }
// no need for overflow check;
// cannot have i + 1 > max_value because i < stop <= max_value
i += (1 as $T);
}
} else if step == (-1 as $T) { // elide bounds check to tighten loop
while i > stop {
if !it(i) { return false; }
// no need for underflow check;
// cannot have i - 1 < min_value because i > stop >= min_value
i -= (1 as $T);
}
} else if step > 0 { // ascending
while i < stop {
if !it(i) { return false; }
@@ -120,19 +130,66 @@ pub fn range_step(start: $T, stop: $T, step: $T, it: &fn($T) -> bool) -> bool {
i += step;
}
}
return true;
match r {
HalfOpen => return true,
Closed => return (i != stop || it(i))
}
}
#[inline]
///
/// Iterate through the range [`start`..`stop`) with a given step value.
///
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// * `x_i == start + step*i`, and
/// * `n` is the greatest nonnegative integer such that `x_n < stop`
///
/// (If no such `n` exists, then the iteration range is empty.)
///
/// # Arguments
///
/// * `start` - lower bound, inclusive
/// * `stop` - higher bound, exclusive
///
/// # Examples
/// ~~~
/// let mut sum = 0;
/// for int::range(1, 5) |i| {
/// sum += i;
/// }
/// assert!(sum == 10);
/// ~~~
///
pub fn range_step(start: $T, stop: $T, step: $T, it: &fn($T) -> bool) -> bool {
range_step_core(start, stop, step, HalfOpen, it)
}
#[inline]
///
/// Iterate through a range with a given step value.
///
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// `x_i == start + step*i` and `x_n <= last < step + x_n`.
///
/// (If no such nonnegative integer `n` exists, then the iteration
/// range is empty.)
///
pub fn range_step_inclusive(start: $T, last: $T, step: $T, it: &fn($T) -> bool) -> bool {
range_step_core(start, last, step, Closed, it)
}
#[inline]
/// Iterate over the range [`lo`..`hi`)
pub fn range(lo: $T, hi: $T, it: &fn($T) -> bool) -> bool {
range_step(lo, hi, 1 as $T, it)
}
#[inline]
/// Iterate over the range [`hi`..`lo`)
/// Iterate over the range (`hi`..`lo`]
pub fn range_rev(hi: $T, lo: $T, it: &fn($T) -> bool) -> bool {
range_step(hi, lo, -1 as $T, it)
if hi == min_value { return true; }
range_step_inclusive(hi-1, lo, -1 as $T, it)
}
/// Computes the bitwise complement
@@ -905,7 +962,7 @@ mod tests {
for range(0,3) |i| {
l.push(i);
}
for range_rev(13,10) |i| {
for range_rev(14,11) |i| {
l.push(i);
}
for range_step(20,26,2) |i| {
100 changes: 80 additions & 20 deletions src/libstd/num/uint_macros.rs
Original file line number Diff line number Diff line change
@@ -64,40 +64,99 @@ pub fn ge(x: $T, y: $T) -> bool { x >= y }
#[inline]
pub fn gt(x: $T, y: $T) -> bool { x > y }

enum Range { Closed, HalfOpen }

#[inline]
/**
* Iterate through a range with a given step value.
*
* # Examples
* ~~~ {.rust}
* let nums = [1,2,3,4,5,6,7];
*
* for uint::range_step(0, nums.len() - 1, 2) |i| {
* println(fmt!("%d & %d", nums[i], nums[i+1]));
* }
* ~~~
*/
pub fn range_step(start: $T, stop: $T, step: $T_SIGNED, it: &fn($T) -> bool) -> bool {
///
/// Iterate through a range with a given step value.
///
/// Let `term` denote the closed interval `[stop-step,stop]` if `r` is Closed;
/// otherwise `term` denotes the half-open interval `[stop-step,stop)`.
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// `x_j == start + step*j`, and `x_n` lies in the interval `term`.
///
/// If no such nonnegative integer `n` exists, then the iteration range
/// is empty.
///
fn range_step_core(start: $T, stop: $T, step: $T_SIGNED, r: Range, it: &fn($T) -> bool) -> bool {
let mut i = start;
if step == 0 {
fail!("range_step called with step == 0");
}
if step >= 0 {
} else if step == (1 as $T_SIGNED) { // elide bounds check to tighten loop
while i < stop {
if !it(i) { return false; }
// no need for overflow check;
// cannot have i + 1 > max_value because i < stop <= max_value
i += (1 as $T);
}
} else if step == (-1 as $T_SIGNED) { // elide bounds check to tighten loop
while i > stop {
if !it(i) { return false; }
// no need for underflow check;
// cannot have i - 1 < min_value because i > stop >= min_value
i -= (1 as $T);
}
} else if step > 0 { // ascending
while i < stop {
if !it(i) { return false; }
// avoiding overflow. break if i + step > max_value
if i > max_value - (step as $T) { return true; }
i += step as $T;
}
} else {
} else { // descending
while i > stop {
if !it(i) { return false; }
// avoiding underflow. break if i + step < min_value
if i < min_value + ((-step) as $T) { return true; }
i -= -step as $T;
}
}
return true;
match r {
HalfOpen => return true,
Closed => return (i != stop || it(i))
}
}

#[inline]
///
/// Iterate through the range [`start`..`stop`) with a given step value.
///
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// - `x_i == start + step*i`, and
/// - `n` is the greatest nonnegative integer such that `x_n < stop`
///
/// (If no such `n` exists, then the iteration range is empty.)
///
/// # Arguments
///
/// * `start` - lower bound, inclusive
/// * `stop` - higher bound, exclusive
///
/// # Examples
/// ~~~ {.rust}
/// let nums = [1,2,3,4,5,6,7];
///
/// for uint::range_step(0, nums.len() - 1, 2) |i| {
/// println(fmt!("%d & %d", nums[i], nums[i+1]));
/// }
/// ~~~
///
pub fn range_step(start: $T, stop: $T, step: $T_SIGNED, it: &fn($T) -> bool) -> bool {
range_step_core(start, stop, step, HalfOpen, it)
}

#[inline]
///
/// Iterate through a range with a given step value.
///
/// Iterates through the range `[x_0, x_1, ..., x_n]` where
/// `x_i == start + step*i` and `x_n <= last < step + x_n`.
///
/// (If no such nonnegative integer `n` exists, then the iteration
/// range is empty.)
///
pub fn range_step_inclusive(start: $T, last: $T, step: $T_SIGNED, it: &fn($T) -> bool) -> bool {
range_step_core(start, last, step, Closed, it)
}

#[inline]
@@ -107,9 +166,10 @@ pub fn range(lo: $T, hi: $T, it: &fn($T) -> bool) -> bool {
}

#[inline]
/// Iterate over the range [`hi`..`lo`)
/// Iterate over the range (`hi`..`lo`]
pub fn range_rev(hi: $T, lo: $T, it: &fn($T) -> bool) -> bool {
range_step(hi, lo, -1 as $T_SIGNED, it)
if hi == min_value { return true; }
range_step_inclusive(hi-1, lo, -1 as $T_SIGNED, it)
}

/// Computes the bitwise complement
@@ -643,7 +703,7 @@ mod tests {
for range(0,3) |i| {
l.push(i);
}
for range_rev(13,10) |i| {
for range_rev(14,11) |i| {
l.push(i);
}
for range_step(20,26,2) |i| {
2 changes: 1 addition & 1 deletion src/libstd/run.rs
Original file line number Diff line number Diff line change
@@ -669,7 +669,7 @@ fn spawn_process_os(prog: &str, args: &[~str],
fail!("failure in dup3(err_fd, 2): %s", os::last_os_error());
}
// close all other fds
for int::range_rev(getdtablesize() as int - 1, 2) |fd| {
for int::range_rev(getdtablesize() as int, 3) |fd| {
close(fd as c_int);
}

2 changes: 1 addition & 1 deletion src/libstd/trie.rs
Original file line number Diff line number Diff line change
@@ -261,7 +261,7 @@ impl<T> TrieNode<T> {

fn each_reverse<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
for uint::range_rev(self.children.len(), 0) |idx| {
match self.children[idx - 1] {
match self.children[idx] {
Internal(ref x) => if !x.each_reverse(|i,t| f(i,t)) { return false },
External(k, ref v) => if !f(&k, v) { return false },
Nothing => ()
114 changes: 114 additions & 0 deletions src/test/run-pass/num-range-rev.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,114 @@
// 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 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use std::int;
use std::uint;

fn uint_range(lo: uint, hi: uint, it: &fn(uint) -> bool) -> bool {
uint::range(lo, hi, it)
}

fn int_range(lo: int, hi: int, it: &fn(int) -> bool) -> bool {
int::range(lo, hi, it)
}

fn uint_range_rev(hi: uint, lo: uint, it: &fn(uint) -> bool) -> bool {
uint::range_rev(hi, lo, it)
}

fn int_range_rev(hi: int, lo: int, it: &fn(int) -> bool) -> bool {
int::range_rev(hi, lo, it)
}

fn int_range_step(a: int, b: int, step: int, it: &fn(int) -> bool) -> bool {
int::range_step(a, b, step, it)
}

fn uint_range_step(a: uint, b: uint, step: int, it: &fn(uint) -> bool) -> bool {
uint::range_step(a, b, step, it)
}


pub fn main() {
// int and uint have same result for
// Sum{100 > i >= 2} == (Sum{1 <= i <= 99} - 1) == n*(n+1)/2 - 1 for n=99
let mut sum = 0u;
for uint_range_rev(100, 2) |i| {
sum += i;
}
assert_eq!(sum, 4949);

let mut sum = 0i;
for int_range_rev(100, 2) |i| {
sum += i;
}
assert_eq!(sum, 4949);


// elements are visited in correct order
let primes = [2,3,5,7,11];
let mut prod = 1i;
for uint_range_rev(5, 0) |i| {
println(fmt!("uint 4 downto 0: %u", i));
prod *= int::pow(primes[i], i);
}
assert_eq!(prod, 11*11*11*11*7*7*7*5*5*3*1);
let mut prod = 1i;
for int_range_rev(5, 0) |i| {
println(fmt!("int 4 downto 0: %d", i));
prod *= int::pow(primes[i], i as uint);
}
assert_eq!(prod, 11*11*11*11*7*7*7*5*5*3*1);


// range and range_rev are symmetric.
let mut sum_up = 0u;
for uint_range(10, 30) |i| {
sum_up += i;
}
let mut sum_down = 0u;
for uint_range_rev(30, 10) |i| {
sum_down += i;
}
assert_eq!(sum_up, sum_down);

let mut sum_up = 0;
for int_range(-20, 10) |i| {
sum_up += i;
}
let mut sum_down = 0;
for int_range_rev(10, -20) |i| {
sum_down += i;
}
assert_eq!(sum_up, sum_down);


// empty ranges
for int_range_rev(10, 10) |_| {
fail!("range should be empty when start == stop");
}

for uint_range_rev(0, 1) |_| {
fail!("range should be empty when start-1 underflows");
}

// range iterations do not wrap/underflow
let mut uflo_loop_visited = ~[];
for int_range_step(int::min_value+15, int::min_value, -4) |x| {
uflo_loop_visited.push(x - int::min_value);
}
assert_eq!(uflo_loop_visited, ~[15, 11, 7, 3]);

let mut uflo_loop_visited = ~[];
for uint_range_step(uint::min_value+15, uint::min_value, -4) |x| {
uflo_loop_visited.push(x - uint::min_value);
}
assert_eq!(uflo_loop_visited, ~[15, 11, 7, 3]);
}
119 changes: 119 additions & 0 deletions src/test/run-pass/num-range.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,119 @@
// 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 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use std::int;
use std::uint;

fn uint_range(lo: uint, hi: uint, it: &fn(uint) -> bool) -> bool {
uint::range(lo, hi, it)
}

fn int_range(lo: int, hi: int, it: &fn(int) -> bool) -> bool {
int::range(lo, hi, it)
}

fn int_range_step(a: int, b: int, step: int, it: &fn(int) -> bool) -> bool {
int::range_step(a, b, step, it)
}

fn uint_range_step(a: uint, b: uint, s: int, it: &fn(uint) -> bool) -> bool {
uint::range_step(a, b, s, it)
}

pub fn main() {
println(fmt!("num-range start"));
// int and uint have same result for
// Sum{2 <= i < 100} == (Sum{1 <= i <= 99} - 1) == n*(n+1)/2 - 1 for n=99
let mut sum = 0u;
for uint_range(2, 100) |i| {
sum += i;
}
assert_eq!(sum, 4949);

let mut sum = 0i;
for int_range(2, 100) |i| {
sum += i;
}
assert_eq!(sum, 4949);


// elements are visited in correct order
let primes = [2,3,5,7];
let mut prod = 1i;
for uint_range(0, 4) |i| {
prod *= int::pow(primes[i], i);
}
assert_eq!(prod, 1*3*5*5*7*7*7);
let mut prod = 1i;
for int_range(0, 4) |i| {
prod *= int::pow(primes[i], i as uint);
}
assert_eq!(prod, 1*3*5*5*7*7*7);


// empty ranges
for int_range(10, 10) |_| {
fail!("range should be empty when start == stop");
}

for uint_range(10, 10) |_| {
fail!("range should be empty when start == stop");
}


// range iterations do not wrap/overflow
let mut oflo_loop_visited = ~[];
for uint_range_step(uint::max_value-15, uint::max_value, 4) |x| {
oflo_loop_visited.push(uint::max_value - x);
}
assert_eq!(oflo_loop_visited, ~[15, 11, 7, 3]);

let mut oflo_loop_visited = ~[];
for int_range_step(int::max_value-15, int::max_value, 4) |x| {
oflo_loop_visited.push(int::max_value - x);
}
assert_eq!(oflo_loop_visited, ~[15, 11, 7, 3]);


// range_step never passes nor visits the stop element
for int_range_step(0, 21, 3) |x| {
assert!(x < 21);
}

// range_step_inclusive will never pass stop element, and may skip it.
let mut saw21 = false;
for uint::range_step_inclusive(0, 21, 4) |x| {
assert!(x <= 21);
if x == 21 { saw21 = true; }
}
assert!(!saw21);
let mut saw21 = false;
for int::range_step_inclusive(0, 21, 4) |x| {
assert!(x <= 21);
if x == 21 { saw21 = true; }
}
assert!(!saw21);

// range_step_inclusive will never pass stop element, but may visit it.
let mut saw21 = false;
for uint::range_step_inclusive(0, 21, 3) |x| {
assert!(x <= 21);
println(fmt!("saw: %u", x));
if x == 21 { saw21 = true; }
}
assert!(saw21);
let mut saw21 = false;
for int::range_step_inclusive(0, 21, 3) |x| {
assert!(x <= 21);
if x == 21 { saw21 = true; }
}
assert!(saw21);

}