1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*
Module: u64
*/
/*
Const: min_value
Return the minimal value for a u64
*/
const min_value: u64 = 0u64;
/*
Const: max_value
Return the maximal value for a u64
*/
const max_value: u64 = 18446744073709551615u64;
/* Function: add */
pure fn add(x: u64, y: u64) -> u64 { ret x + y; }
/* Function: sub */
pure fn sub(x: u64, y: u64) -> u64 { ret x - y; }
/* Function: mul */
pure fn mul(x: u64, y: u64) -> u64 { ret x * y; }
/* Function: div */
pure fn div(x: u64, y: u64) -> u64 { ret x / y; }
/* Function: rem */
pure fn rem(x: u64, y: u64) -> u64 { ret x % y; }
/* Predicate: lt */
pure fn lt(x: u64, y: u64) -> bool { ret x < y; }
/* Predicate: le */
pure fn le(x: u64, y: u64) -> bool { ret x <= y; }
/* Predicate: eq */
pure fn eq(x: u64, y: u64) -> bool { ret x == y; }
/* Predicate: ne */
pure fn ne(x: u64, y: u64) -> bool { ret x != y; }
/* Predicate: ge */
pure fn ge(x: u64, y: u64) -> bool { ret x >= y; }
/* Predicate: gt */
pure fn gt(x: u64, y: u64) -> bool { ret x > y; }
/*
Function: range
Iterate over the range [`lo`..`hi`)
*/
fn range(lo: u64, hi: u64, it: block(u64)) {
let i = lo;
while i < hi { it(i); i += 1u64; }
}
/*
Function: to_str
Convert to a string in a given base
*/
fn to_str(n: u64, radix: uint) -> str {
assert (0u < radix && radix <= 16u);
let r64 = radix as u64;
fn digit(n: u64) -> str {
ret alt n {
0u64 { "0" }
1u64 { "1" }
2u64 { "2" }
3u64 { "3" }
4u64 { "4" }
5u64 { "5" }
6u64 { "6" }
7u64 { "7" }
8u64 { "8" }
9u64 { "9" }
10u64 { "a" }
11u64 { "b" }
12u64 { "c" }
13u64 { "d" }
14u64 { "e" }
15u64 { "f" }
_ { fail }
};
}
if n == 0u64 { ret "0"; }
let s = "";
let n = n;
while n > 0u64 { s = digit(n % r64) + s; n /= r64; }
ret s;
}
/*
Function: str
Convert to a string
*/
fn str(n: u64) -> str { ret to_str(n, 10u); }
/*
Function: from_str
Parse a string as an unsigned integer.
*/
fn from_str(buf: str, radix: u64) -> u64 {
if str::byte_len(buf) == 0u {
#error("parse_buf(): buf is empty");
fail;
}
let i = str::byte_len(buf) - 1u;
let power = 1u64, n = 0u64;
while true {
let digit = char::to_digit(buf[i] as char) as u64;
if digit >= radix { fail; }
n += digit * power;
power *= radix;
if i == 0u { ret n; }
i -= 1u;
}
fail;
}
|
