2012-04-14 19:21:10 -05:00
|
|
|
import T = inst::T;
|
2012-06-06 16:19:52 -05:00
|
|
|
import cmp::{eq, ord};
|
2012-04-14 19:21:10 -05:00
|
|
|
|
|
|
|
export min_value, max_value;
|
|
|
|
export min, max;
|
|
|
|
export add, sub, mul, div, rem;
|
|
|
|
export lt, le, eq, ne, ge, gt;
|
|
|
|
export is_positive, is_negative;
|
|
|
|
export is_nonpositive, is_nonnegative;
|
|
|
|
export range;
|
|
|
|
export compl;
|
|
|
|
export abs;
|
2012-06-04 20:05:34 -05:00
|
|
|
export parse_buf, from_str, to_str, to_str_bytes, str;
|
A new `times` method on numeric types
This method is intended to elegantly subsume two common iteration functions.
The first is `iter::range`, which is used identically to the method introduced
in this commit, but currently works only on uints. The second is a common case
of `{int, i8, uint, etc.}::range`, in the case where the inductive variable is
ignored. Compare the usage of the three:
```
for iter::range(100u) {
// do whatever
}
for int::range(0, 100) |_i| {
// do whatever
}
for 100.times {
// do whatever
}
```
I feel that the latter reads much more nicely than the first two approaches,
and unlike the first two the new method allows the user to ignore the specific
type of the number (ineed, if we're throwing away the inductive variable, who
cares what type it is?). A minor benefit is that this new method will be
somewhat familiar to users of Ruby, from which we borrow the name "times".
2012-07-05 21:12:26 -05:00
|
|
|
export num, ord, eq, times;
|
2012-04-14 19:21:10 -05:00
|
|
|
|
|
|
|
const min_value: T = -1 as T << (inst::bits - 1 as T);
|
|
|
|
const max_value: T = min_value - 1 as T;
|
|
|
|
|
2012-06-12 18:16:47 -05:00
|
|
|
pure fn min(&&x: T, &&y: T) -> T { if x < y { x } else { y } }
|
|
|
|
pure fn max(&&x: T, &&y: T) -> T { if x > y { x } else { y } }
|
2012-04-14 19:21:10 -05:00
|
|
|
|
2012-06-12 18:16:47 -05:00
|
|
|
pure fn add(&&x: T, &&y: T) -> T { x + y }
|
|
|
|
pure fn sub(&&x: T, &&y: T) -> T { x - y }
|
|
|
|
pure fn mul(&&x: T, &&y: T) -> T { x * y }
|
|
|
|
pure fn div(&&x: T, &&y: T) -> T { x / y }
|
|
|
|
pure fn rem(&&x: T, &&y: T) -> T { x % y }
|
2012-04-14 19:21:10 -05:00
|
|
|
|
2012-06-12 18:16:47 -05:00
|
|
|
pure fn lt(&&x: T, &&y: T) -> bool { x < y }
|
|
|
|
pure fn le(&&x: T, &&y: T) -> bool { x <= y }
|
|
|
|
pure fn eq(&&x: T, &&y: T) -> bool { x == y }
|
|
|
|
pure fn ne(&&x: T, &&y: T) -> bool { x != y }
|
|
|
|
pure fn ge(&&x: T, &&y: T) -> bool { x >= y }
|
|
|
|
pure fn gt(&&x: T, &&y: T) -> bool { x > y }
|
2012-04-14 19:21:10 -05:00
|
|
|
|
|
|
|
pure fn is_positive(x: T) -> bool { x > 0 as T }
|
|
|
|
pure fn is_negative(x: T) -> bool { x < 0 as T }
|
|
|
|
pure fn is_nonpositive(x: T) -> bool { x <= 0 as T }
|
|
|
|
pure fn is_nonnegative(x: T) -> bool { x >= 0 as T }
|
|
|
|
|
2012-06-08 20:18:41 -05:00
|
|
|
#[inline(always)]
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Iterate over the range [`lo`..`hi`)
|
2012-05-26 02:32:08 -05:00
|
|
|
fn range(lo: T, hi: T, it: fn(T) -> bool) {
|
2012-04-14 19:21:10 -05:00
|
|
|
let mut i = lo;
|
2012-05-26 02:32:08 -05:00
|
|
|
while i < hi {
|
|
|
|
if !it(i) { break }
|
|
|
|
i += 1 as T;
|
|
|
|
}
|
2012-04-14 19:21:10 -05:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Computes the bitwise complement
|
2012-04-14 19:21:10 -05:00
|
|
|
pure fn compl(i: T) -> T {
|
|
|
|
-1 as T ^ i
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Computes the absolute value
|
2012-05-04 13:47:37 -05:00
|
|
|
// FIXME: abs should return an unsigned int (#2353)
|
2012-04-14 19:21:10 -05:00
|
|
|
pure fn abs(i: T) -> T {
|
|
|
|
if is_negative(i) { -i } else { i }
|
|
|
|
}
|
2012-05-16 01:18:04 -05:00
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* Parse a buffer of bytes
|
|
|
|
*
|
|
|
|
* # Arguments
|
|
|
|
*
|
|
|
|
* * buf - A byte buffer
|
|
|
|
* * radix - The base of the number
|
|
|
|
*/
|
2012-06-29 18:26:56 -05:00
|
|
|
fn parse_buf(buf: ~[u8], radix: uint) -> option<T> {
|
2012-05-16 01:18:04 -05:00
|
|
|
if vec::len(buf) == 0u { ret none; }
|
|
|
|
let mut i = vec::len(buf) - 1u;
|
|
|
|
let mut start = 0u;
|
|
|
|
let mut power = 1 as T;
|
|
|
|
|
|
|
|
if buf[0] == ('-' as u8) {
|
|
|
|
power = -1 as T;
|
|
|
|
start = 1u;
|
|
|
|
}
|
|
|
|
let mut n = 0 as T;
|
|
|
|
loop {
|
|
|
|
alt char::to_digit(buf[i] as char, radix) {
|
|
|
|
some(d) { n += (d as T) * power; }
|
|
|
|
none { ret none; }
|
|
|
|
}
|
|
|
|
power *= radix as T;
|
|
|
|
if i <= start { ret some(n); }
|
|
|
|
i -= 1u;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Parse a string to an int
|
2012-07-14 00:57:48 -05:00
|
|
|
fn from_str(s: ~str) -> option<T> { parse_buf(str::bytes(s), 10u) }
|
2012-05-16 01:18:04 -05:00
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Convert to a string in a given base
|
2012-07-14 00:57:48 -05:00
|
|
|
fn to_str(n: T, radix: uint) -> ~str {
|
2012-06-30 18:19:07 -05:00
|
|
|
do to_str_bytes(n, radix) |slice| {
|
|
|
|
do vec::unpack_slice(slice) |p, len| {
|
2012-06-24 22:18:18 -05:00
|
|
|
unsafe { str::unsafe::from_buf_len(p, len) }
|
2012-06-04 20:44:41 -05:00
|
|
|
}
|
|
|
|
}
|
2012-05-16 01:18:04 -05:00
|
|
|
}
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
fn to_str_bytes<U>(n: T, radix: uint, f: fn(v: &[u8]) -> U) -> U {
|
2012-06-04 20:05:34 -05:00
|
|
|
if n < 0 as T {
|
|
|
|
uint::to_str_bytes(true, -n as uint, radix, f)
|
|
|
|
} else {
|
|
|
|
uint::to_str_bytes(false, n as uint, radix, f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Convert to a string
|
2012-07-14 00:57:48 -05:00
|
|
|
fn str(i: T) -> ~str { ret to_str(i, 10u); }
|
2012-05-16 01:18:04 -05:00
|
|
|
|
2012-06-06 16:19:52 -05:00
|
|
|
impl ord of ord for T {
|
|
|
|
fn lt(&&other: T) -> bool {
|
|
|
|
ret self < other;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl eq of eq for T {
|
|
|
|
fn eq(&&other: T) -> bool {
|
|
|
|
ret self == other;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-25 15:41:13 -05:00
|
|
|
impl num of num::num for T {
|
|
|
|
fn add(&&other: T) -> T { ret self + other; }
|
|
|
|
fn sub(&&other: T) -> T { ret self - other; }
|
|
|
|
fn mul(&&other: T) -> T { ret self * other; }
|
|
|
|
fn div(&&other: T) -> T { ret self / other; }
|
|
|
|
fn modulo(&&other: T) -> T { ret self % other; }
|
|
|
|
fn neg() -> T { ret -self; }
|
|
|
|
|
|
|
|
fn to_int() -> int { ret self as int; }
|
|
|
|
fn from_int(n: int) -> T { ret n as T; }
|
2012-06-07 18:08:38 -05:00
|
|
|
}
|
|
|
|
|
A new `times` method on numeric types
This method is intended to elegantly subsume two common iteration functions.
The first is `iter::range`, which is used identically to the method introduced
in this commit, but currently works only on uints. The second is a common case
of `{int, i8, uint, etc.}::range`, in the case where the inductive variable is
ignored. Compare the usage of the three:
```
for iter::range(100u) {
// do whatever
}
for int::range(0, 100) |_i| {
// do whatever
}
for 100.times {
// do whatever
}
```
I feel that the latter reads much more nicely than the first two approaches,
and unlike the first two the new method allows the user to ignore the specific
type of the number (ineed, if we're throwing away the inductive variable, who
cares what type it is?). A minor benefit is that this new method will be
somewhat familiar to users of Ruby, from which we borrow the name "times".
2012-07-05 21:12:26 -05:00
|
|
|
impl times of iter::times for T {
|
|
|
|
#[inline(always)]
|
|
|
|
#[doc = "A convenience form for basic iteration. Given a variable `x` \
|
|
|
|
of any numeric type, the expression `for x.times { /* anything */ }` \
|
|
|
|
will execute the given function exactly x times. If we assume that \
|
|
|
|
`x` is an int, this is functionally equivalent to \
|
|
|
|
`for int::range(0, x) |_i| { /* anything */ }`."]
|
|
|
|
fn times(it: fn() -> bool) {
|
|
|
|
if self < 0 {
|
|
|
|
fail #fmt("The .times method expects a nonnegative number, \
|
|
|
|
but found %?", self);
|
|
|
|
}
|
|
|
|
let mut i = self;
|
|
|
|
while i > 0 {
|
|
|
|
if !it() { break }
|
|
|
|
i -= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-05-16 01:18:04 -05:00
|
|
|
|
2012-06-14 18:30:18 -05:00
|
|
|
// FIXME: Has alignment issues on windows and 32-bit linux (#2609)
|
2012-05-16 01:18:04 -05:00
|
|
|
#[test]
|
2012-05-16 18:17:28 -05:00
|
|
|
#[ignore]
|
2012-05-16 01:18:04 -05:00
|
|
|
fn test_from_str() {
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"0") == some(0 as T);
|
|
|
|
assert from_str(~"3") == some(3 as T);
|
|
|
|
assert from_str(~"10") == some(10 as T);
|
|
|
|
assert from_str(~"123456789") == some(123456789 as T);
|
|
|
|
assert from_str(~"00100") == some(100 as T);
|
2012-05-16 01:18:04 -05:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~"-1") == some(-1 as T);
|
|
|
|
assert from_str(~"-3") == some(-3 as T);
|
|
|
|
assert from_str(~"-10") == some(-10 as T);
|
|
|
|
assert from_str(~"-123456789") == some(-123456789 as T);
|
|
|
|
assert from_str(~"-00100") == some(-100 as T);
|
2012-05-16 01:18:04 -05:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
assert from_str(~" ") == none;
|
|
|
|
assert from_str(~"x") == none;
|
2012-05-16 01:18:04 -05:00
|
|
|
}
|
|
|
|
|
2012-06-14 18:30:18 -05:00
|
|
|
// FIXME: Has alignment issues on windows and 32-bit linux (#2609)
|
2012-05-16 01:18:04 -05:00
|
|
|
#[test]
|
2012-05-16 18:17:28 -05:00
|
|
|
#[ignore]
|
2012-05-16 01:18:04 -05:00
|
|
|
fn test_parse_buf() {
|
|
|
|
import str::bytes;
|
2012-07-14 00:57:48 -05:00
|
|
|
assert parse_buf(bytes(~"123"), 10u) == some(123 as T);
|
|
|
|
assert parse_buf(bytes(~"1001"), 2u) == some(9 as T);
|
|
|
|
assert parse_buf(bytes(~"123"), 8u) == some(83 as T);
|
|
|
|
assert parse_buf(bytes(~"123"), 16u) == some(291 as T);
|
|
|
|
assert parse_buf(bytes(~"ffff"), 16u) == some(65535 as T);
|
|
|
|
assert parse_buf(bytes(~"FFFF"), 16u) == some(65535 as T);
|
|
|
|
assert parse_buf(bytes(~"z"), 36u) == some(35 as T);
|
|
|
|
assert parse_buf(bytes(~"Z"), 36u) == some(35 as T);
|
|
|
|
|
|
|
|
assert parse_buf(bytes(~"-123"), 10u) == some(-123 as T);
|
|
|
|
assert parse_buf(bytes(~"-1001"), 2u) == some(-9 as T);
|
|
|
|
assert parse_buf(bytes(~"-123"), 8u) == some(-83 as T);
|
|
|
|
assert parse_buf(bytes(~"-123"), 16u) == some(-291 as T);
|
|
|
|
assert parse_buf(bytes(~"-ffff"), 16u) == some(-65535 as T);
|
|
|
|
assert parse_buf(bytes(~"-FFFF"), 16u) == some(-65535 as T);
|
|
|
|
assert parse_buf(bytes(~"-z"), 36u) == some(-35 as T);
|
|
|
|
assert parse_buf(bytes(~"-Z"), 36u) == some(-35 as T);
|
|
|
|
|
|
|
|
assert parse_buf(str::bytes(~"Z"), 35u) == none;
|
|
|
|
assert parse_buf(str::bytes(~"-9"), 2u) == none;
|
2012-05-16 01:18:04 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_to_str() {
|
|
|
|
import str::eq;
|
2012-07-14 00:57:48 -05:00
|
|
|
assert (eq(to_str(0 as T, 10u), ~"0"));
|
|
|
|
assert (eq(to_str(1 as T, 10u), ~"1"));
|
|
|
|
assert (eq(to_str(-1 as T, 10u), ~"-1"));
|
|
|
|
assert (eq(to_str(127 as T, 16u), ~"7f"));
|
|
|
|
assert (eq(to_str(100 as T, 10u), ~"100"));
|
2012-05-16 01:18:04 -05:00
|
|
|
}
|
2012-06-07 18:08:38 -05:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_ifaces() {
|
2012-06-09 00:36:26 -05:00
|
|
|
fn test<U:num::num>(ten: U) {
|
2012-06-07 18:08:38 -05:00
|
|
|
assert (ten.to_int() == 10);
|
|
|
|
|
|
|
|
let two = ten.from_int(2);
|
|
|
|
assert (two.to_int() == 2);
|
|
|
|
|
|
|
|
assert (ten.add(two) == ten.from_int(12));
|
|
|
|
assert (ten.sub(two) == ten.from_int(8));
|
|
|
|
assert (ten.mul(two) == ten.from_int(20));
|
|
|
|
assert (ten.div(two) == ten.from_int(5));
|
|
|
|
assert (ten.modulo(two) == ten.from_int(0));
|
A new `times` method on numeric types
This method is intended to elegantly subsume two common iteration functions.
The first is `iter::range`, which is used identically to the method introduced
in this commit, but currently works only on uints. The second is a common case
of `{int, i8, uint, etc.}::range`, in the case where the inductive variable is
ignored. Compare the usage of the three:
```
for iter::range(100u) {
// do whatever
}
for int::range(0, 100) |_i| {
// do whatever
}
for 100.times {
// do whatever
}
```
I feel that the latter reads much more nicely than the first two approaches,
and unlike the first two the new method allows the user to ignore the specific
type of the number (ineed, if we're throwing away the inductive variable, who
cares what type it is?). A minor benefit is that this new method will be
somewhat familiar to users of Ruby, from which we borrow the name "times".
2012-07-05 21:12:26 -05:00
|
|
|
assert (ten.neg() == ten.from_int(-10));
|
2012-06-07 18:08:38 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
test(10 as T);
|
|
|
|
}
|
|
|
|
|
A new `times` method on numeric types
This method is intended to elegantly subsume two common iteration functions.
The first is `iter::range`, which is used identically to the method introduced
in this commit, but currently works only on uints. The second is a common case
of `{int, i8, uint, etc.}::range`, in the case where the inductive variable is
ignored. Compare the usage of the three:
```
for iter::range(100u) {
// do whatever
}
for int::range(0, 100) |_i| {
// do whatever
}
for 100.times {
// do whatever
}
```
I feel that the latter reads much more nicely than the first two approaches,
and unlike the first two the new method allows the user to ignore the specific
type of the number (ineed, if we're throwing away the inductive variable, who
cares what type it is?). A minor benefit is that this new method will be
somewhat familiar to users of Ruby, from which we borrow the name "times".
2012-07-05 21:12:26 -05:00
|
|
|
#[test]
|
|
|
|
fn test_times() {
|
|
|
|
let ten = 10 as T;
|
|
|
|
let mut accum = 0;
|
|
|
|
for ten.times { accum += 1; }
|
|
|
|
assert (accum == 10);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[should_fail]
|
2012-07-06 01:26:41 -05:00
|
|
|
#[ignore(cfg(windows))]
|
A new `times` method on numeric types
This method is intended to elegantly subsume two common iteration functions.
The first is `iter::range`, which is used identically to the method introduced
in this commit, but currently works only on uints. The second is a common case
of `{int, i8, uint, etc.}::range`, in the case where the inductive variable is
ignored. Compare the usage of the three:
```
for iter::range(100u) {
// do whatever
}
for int::range(0, 100) |_i| {
// do whatever
}
for 100.times {
// do whatever
}
```
I feel that the latter reads much more nicely than the first two approaches,
and unlike the first two the new method allows the user to ignore the specific
type of the number (ineed, if we're throwing away the inductive variable, who
cares what type it is?). A minor benefit is that this new method will be
somewhat familiar to users of Ruby, from which we borrow the name "times".
2012-07-05 21:12:26 -05:00
|
|
|
fn test_times_negative() {
|
2012-07-14 00:57:48 -05:00
|
|
|
for (-10).times { log(error, ~"nope!"); }
|
A new `times` method on numeric types
This method is intended to elegantly subsume two common iteration functions.
The first is `iter::range`, which is used identically to the method introduced
in this commit, but currently works only on uints. The second is a common case
of `{int, i8, uint, etc.}::range`, in the case where the inductive variable is
ignored. Compare the usage of the three:
```
for iter::range(100u) {
// do whatever
}
for int::range(0, 100) |_i| {
// do whatever
}
for 100.times {
// do whatever
}
```
I feel that the latter reads much more nicely than the first two approaches,
and unlike the first two the new method allows the user to ignore the specific
type of the number (ineed, if we're throwing away the inductive variable, who
cares what type it is?). A minor benefit is that this new method will be
somewhat familiar to users of Ruby, from which we borrow the name "times".
2012-07-05 21:12:26 -05:00
|
|
|
}
|