Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
int
Rust
提交
dbc2e996
R
Rust
项目概览
int
/
Rust
大约 1 年 前同步成功
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
Rust
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
dbc2e996
编写于
4月 26, 2013
作者:
B
Brendan Zabarauskas
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Use `///` doc-comment form instead of `/** */`
上级
ad0b3370
变更
7
隐藏空白更改
内联
并排
Showing
7 changed file
with
662 addition
and
663 deletion
+662
-663
src/libcore/num/f32.rs
src/libcore/num/f32.rs
+138
-138
src/libcore/num/f64.rs
src/libcore/num/f64.rs
+138
-138
src/libcore/num/float.rs
src/libcore/num/float.rs
+155
-155
src/libcore/num/int-template.rs
src/libcore/num/int-template.rs
+136
-136
src/libcore/num/num.rs
src/libcore/num/num.rs
+28
-28
src/libcore/num/uint-template.rs
src/libcore/num/uint-template.rs
+3
-4
src/libcore/num/uint-template/uint.rs
src/libcore/num/uint-template/uint.rs
+64
-64
未找到文件。
src/libcore/num/f32.rs
浏览文件 @
dbc2e996
...
...
@@ -304,13 +304,13 @@ impl Signed for f32 {
#[inline(always)]
fn
abs
(
&
self
)
->
f32
{
abs
(
*
self
)
}
/
**
*
# Returns
*
*
- `1.0` if the number is positive, `+0.0` or `infinity`
*
- `-1.0` if the number is negative, `-0.0` or `neg_infinity`
* - `NaN` if the number is `NaN`
*
/
/
//
///
# Returns
///
///
- `1.0` if the number is positive, `+0.0` or `infinity`
///
- `-1.0` if the number is negative, `-0.0` or `neg_infinity`
/// - `NaN` if the number is NaN
//
/
#[inline(always)]
fn
signum
(
&
self
)
->
f32
{
if
is_NaN
(
*
self
)
{
NaN
}
else
{
copysign
(
1.0
,
*
self
)
}
...
...
@@ -509,17 +509,17 @@ fn cosh(&self) -> f32 { cosh(*self) }
fn
tanh
(
&
self
)
->
f32
{
tanh
(
*
self
)
}
}
/
**
*
Section: String Conversions
*
/
/
/
//
Section: String Conversions
/
/
/
**
*
Converts a float to a string
*
*
# Arguments
*
*
* num - The float value
*
/
/
//
///
Converts a float to a string
///
///
# Arguments
///
///
* num - The float value
//
/
#[inline(always)]
pub
fn
to_str
(
num
:
f32
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -527,13 +527,13 @@ pub fn to_str(num: f32) -> ~str {
r
}
/
**
*
Converts a float to a string in hexadecimal format
*
*
# Arguments
*
*
* num - The float value
*
/
/
//
///
Converts a float to a string in hexadecimal format
///
///
# Arguments
///
///
* num - The float value
//
/
#[inline(always)]
pub
fn
to_str_hex
(
num
:
f32
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -541,20 +541,20 @@ pub fn to_str_hex(num: f32) -> ~str {
r
}
/
**
*
Converts a float to a string in a given radix
*
*
# Arguments
*
*
* num - The float value
*
* radix - The base to use
*
*
# Failure
*
*
Fails if called on a special value like `inf`, `-inf` or `NaN` due to
*
possible misinterpretation of the result at higher bases. If those values
*
are expected, use `to_str_radix_special()` instead.
*
/
/
//
///
Converts a float to a string in a given radix
///
///
# Arguments
///
///
* num - The float value
///
* radix - The base to use
///
///
# Failure
///
///
Fails if called on a special value like `inf`, `-inf` or `NaN` due to
///
possible misinterpretation of the result at higher bases. If those values
///
are expected, use `to_str_radix_special()` instead.
//
/
#[inline(always)]
pub
fn
to_str_radix
(
num
:
f32
,
rdx
:
uint
)
->
~
str
{
let
(
r
,
special
)
=
strconv
::
to_str_common
(
...
...
@@ -564,30 +564,30 @@ pub fn to_str_radix(num: f32, rdx: uint) -> ~str {
r
}
/
**
*
Converts a float to a string in a given radix, and a flag indicating
*
whether it's a special value
*
*
# Arguments
*
*
* num - The float value
*
* radix - The base to use
*
/
/
//
///
Converts a float to a string in a given radix, and a flag indicating
///
whether it's a special value
///
///
# Arguments
///
///
* num - The float value
///
* radix - The base to use
//
/
#[inline(always)]
pub
fn
to_str_radix_special
(
num
:
f32
,
rdx
:
uint
)
->
(
~
str
,
bool
)
{
strconv
::
to_str_common
(
&
num
,
rdx
,
true
,
strconv
::
SignNeg
,
strconv
::
DigAll
)
}
/
**
*
Converts a float to a string with exactly the number of
*
provided significant digits
*
*
# Arguments
*
*
* num - The float value
*
* digits - The number of significant digits
*
/
/
//
///
Converts a float to a string with exactly the number of
///
provided significant digits
///
///
# Arguments
///
///
* num - The float value
///
* digits - The number of significant digits
//
/
#[inline(always)]
pub
fn
to_str_exact
(
num
:
f32
,
dig
:
uint
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -595,15 +595,15 @@ pub fn to_str_exact(num: f32, dig: uint) -> ~str {
r
}
/
**
*
Converts a float to a string with a maximum number of
*
significant digits
*
*
# Arguments
*
*
* num - The float value
*
* digits - The number of significant digits
*
/
/
//
///
Converts a float to a string with a maximum number of
///
significant digits
///
///
# Arguments
///
///
* num - The float value
///
* digits - The number of significant digits
//
/
#[inline(always)]
pub
fn
to_str_digits
(
num
:
f32
,
dig
:
uint
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -623,91 +623,91 @@ fn to_str_radix(&self, rdx: uint) -> ~str {
}
}
/
**
*
Convert a string in base 10 to a float.
*
Accepts a optional decimal exponent.
*
*
This function accepts strings such as
*
*
* '3.14'
*
* '+3.14', equivalent to '3.14'
*
* '-3.14'
*
* '2.5E10', or equivalently, '2.5e10'
*
* '2.5E-10'
*
* '.' (understood as 0)
*
* '5.'
*
* '.5', or, equivalently, '0.5'
*
* '+inf', 'inf', '-inf', 'NaN'
*
*
Leading and trailing whitespace represent an error.
*
*
# Arguments
*
*
* num - A string
*
*
# Return value
*
*
`none` if the string did not represent a valid number. Otherwise,
*
`Some(n)` where `n` is the floating-point number represented by `num`.
*
/
/
//
///
Convert a string in base 10 to a float.
///
Accepts a optional decimal exponent.
///
///
This function accepts strings such as
///
///
* '3.14'
///
* '+3.14', equivalent to '3.14'
///
* '-3.14'
///
* '2.5E10', or equivalently, '2.5e10'
///
* '2.5E-10'
///
* '.' (understood as 0)
///
* '5.'
///
* '.5', or, equivalently, '0.5'
///
* '+inf', 'inf', '-inf', 'NaN'
///
///
Leading and trailing whitespace represent an error.
///
///
# Arguments
///
///
* num - A string
///
///
# Return value
///
///
`none` if the string did not represent a valid number. Otherwise,
///
`Some(n)` where `n` is the floating-point number represented by `num`.
//
/
#[inline(always)]
pub
fn
from_str
(
num
:
&
str
)
->
Option
<
f32
>
{
strconv
::
from_str_common
(
num
,
10u
,
true
,
true
,
true
,
strconv
::
ExpDec
,
false
,
false
)
}
/
**
*
Convert a string in base 16 to a float.
*
Accepts a optional binary exponent.
*
*
This function accepts strings such as
*
*
* 'a4.fe'
*
* '+a4.fe', equivalent to 'a4.fe'
*
* '-a4.fe'
*
* '2b.aP128', or equivalently, '2b.ap128'
*
* '2b.aP-128'
*
* '.' (understood as 0)
*
* 'c.'
*
* '.c', or, equivalently, '0.c'
*
* '+inf', 'inf', '-inf', 'NaN'
*
*
Leading and trailing whitespace represent an error.
*
*
# Arguments
*
*
* num - A string
*
*
# Return value
*
*
`none` if the string did not represent a valid number. Otherwise,
*
`Some(n)` where `n` is the floating-point number represented by `[num]`.
*
/
/
//
///
Convert a string in base 16 to a float.
///
Accepts a optional binary exponent.
///
///
This function accepts strings such as
///
///
* 'a4.fe'
///
* '+a4.fe', equivalent to 'a4.fe'
///
* '-a4.fe'
///
* '2b.aP128', or equivalently, '2b.ap128'
///
* '2b.aP-128'
///
* '.' (understood as 0)
///
* 'c.'
///
* '.c', or, equivalently, '0.c'
///
* '+inf', 'inf', '-inf', 'NaN'
///
///
Leading and trailing whitespace represent an error.
///
///
# Arguments
///
///
* num - A string
///
///
# Return value
///
///
`none` if the string did not represent a valid number. Otherwise,
///
`Some(n)` where `n` is the floating-point number represented by `[num]`.
//
/
#[inline(always)]
pub
fn
from_str_hex
(
num
:
&
str
)
->
Option
<
f32
>
{
strconv
::
from_str_common
(
num
,
16u
,
true
,
true
,
true
,
strconv
::
ExpBin
,
false
,
false
)
}
/
**
*
Convert a string in an given base to a float.
*
*
Due to possible conflicts, this function does **not** accept
*
the special values `inf`, `-inf`, `+inf` and `NaN`, **nor**
*
does it recognize exponents of any kind.
*
*
Leading and trailing whitespace represent an error.
*
*
# Arguments
*
*
* num - A string
*
* radix - The base to use. Must lie in the range [2 .. 36]
*
*
# Return value
*
*
`none` if the string did not represent a valid number. Otherwise,
*
`Some(n)` where `n` is the floating-point number represented by `num`.
*
/
/
//
///
Convert a string in an given base to a float.
///
///
Due to possible conflicts, this function does **not** accept
///
the special values `inf`, `-inf`, `+inf` and `NaN`, **nor**
///
does it recognize exponents of any kind.
///
///
Leading and trailing whitespace represent an error.
///
///
# Arguments
///
///
* num - A string
///
* radix - The base to use. Must lie in the range [2 .. 36]
///
///
# Return value
///
///
`none` if the string did not represent a valid number. Otherwise,
///
`Some(n)` where `n` is the floating-point number represented by `num`.
//
/
#[inline(always)]
pub
fn
from_str_radix
(
num
:
&
str
,
rdx
:
uint
)
->
Option
<
f32
>
{
strconv
::
from_str_common
(
num
,
rdx
,
true
,
true
,
false
,
...
...
src/libcore/num/f64.rs
浏览文件 @
dbc2e996
...
...
@@ -314,13 +314,13 @@ impl Signed for f64 {
#[inline(always)]
fn
abs
(
&
self
)
->
f64
{
abs
(
*
self
)
}
/
**
*
# Returns
*
*
- `1.0` if the number is positive, `+0.0` or `infinity`
*
- `-1.0` if the number is negative, `-0.0` or `neg_infinity`
* - `NaN` if the number is `NaN`
*
/
/
//
///
# Returns
///
///
- `1.0` if the number is positive, `+0.0` or `infinity`
///
- `-1.0` if the number is negative, `-0.0` or `neg_infinity`
/// - `NaN` if the number is NaN
//
/
#[inline(always)]
fn
signum
(
&
self
)
->
f64
{
if
is_NaN
(
*
self
)
{
NaN
}
else
{
copysign
(
1.0
,
*
self
)
}
...
...
@@ -549,17 +549,17 @@ fn y1(&self) -> f64 { y1(*self) }
fn
yn
(
&
self
,
n
:
int
)
->
f64
{
yn
(
n
as
c_int
,
*
self
)
}
}
/
**
*
Section: String Conversions
*
/
/
/
//
Section: String Conversions
/
/
/
**
*
Converts a float to a string
*
*
# Arguments
*
*
* num - The float value
*
/
/
//
///
Converts a float to a string
///
///
# Arguments
///
///
* num - The float value
//
/
#[inline(always)]
pub
fn
to_str
(
num
:
f64
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -567,13 +567,13 @@ pub fn to_str(num: f64) -> ~str {
r
}
/
**
*
Converts a float to a string in hexadecimal format
*
*
# Arguments
*
*
* num - The float value
*
/
/
//
///
Converts a float to a string in hexadecimal format
///
///
# Arguments
///
///
* num - The float value
//
/
#[inline(always)]
pub
fn
to_str_hex
(
num
:
f64
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -581,20 +581,20 @@ pub fn to_str_hex(num: f64) -> ~str {
r
}
/
**
*
Converts a float to a string in a given radix
*
*
# Arguments
*
*
* num - The float value
*
* radix - The base to use
*
*
# Failure
*
*
Fails if called on a special value like `inf`, `-inf` or `NaN` due to
*
possible misinterpretation of the result at higher bases. If those values
*
are expected, use `to_str_radix_special()` instead.
*
/
/
//
///
Converts a float to a string in a given radix
///
///
# Arguments
///
///
* num - The float value
///
* radix - The base to use
///
///
# Failure
///
///
Fails if called on a special value like `inf`, `-inf` or `NaN` due to
///
possible misinterpretation of the result at higher bases. If those values
///
are expected, use `to_str_radix_special()` instead.
//
/
#[inline(always)]
pub
fn
to_str_radix
(
num
:
f64
,
rdx
:
uint
)
->
~
str
{
let
(
r
,
special
)
=
strconv
::
to_str_common
(
...
...
@@ -604,30 +604,30 @@ pub fn to_str_radix(num: f64, rdx: uint) -> ~str {
r
}
/
**
*
Converts a float to a string in a given radix, and a flag indicating
*
whether it's a special value
*
*
# Arguments
*
*
* num - The float value
*
* radix - The base to use
*
/
/
//
///
Converts a float to a string in a given radix, and a flag indicating
///
whether it's a special value
///
///
# Arguments
///
///
* num - The float value
///
* radix - The base to use
//
/
#[inline(always)]
pub
fn
to_str_radix_special
(
num
:
f64
,
rdx
:
uint
)
->
(
~
str
,
bool
)
{
strconv
::
to_str_common
(
&
num
,
rdx
,
true
,
strconv
::
SignNeg
,
strconv
::
DigAll
)
}
/
**
*
Converts a float to a string with exactly the number of
*
provided significant digits
*
*
# Arguments
*
*
* num - The float value
*
* digits - The number of significant digits
*
/
/
//
///
Converts a float to a string with exactly the number of
///
provided significant digits
///
///
# Arguments
///
///
* num - The float value
///
* digits - The number of significant digits
//
/
#[inline(always)]
pub
fn
to_str_exact
(
num
:
f64
,
dig
:
uint
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -635,15 +635,15 @@ pub fn to_str_exact(num: f64, dig: uint) -> ~str {
r
}
/
**
*
Converts a float to a string with a maximum number of
*
significant digits
*
*
# Arguments
*
*
* num - The float value
*
* digits - The number of significant digits
*
/
/
//
///
Converts a float to a string with a maximum number of
///
significant digits
///
///
# Arguments
///
///
* num - The float value
///
* digits - The number of significant digits
//
/
#[inline(always)]
pub
fn
to_str_digits
(
num
:
f64
,
dig
:
uint
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -663,91 +663,91 @@ fn to_str_radix(&self, rdx: uint) -> ~str {
}
}
/
**
*
Convert a string in base 10 to a float.
*
Accepts a optional decimal exponent.
*
*
This function accepts strings such as
*
*
* '3.14'
*
* '+3.14', equivalent to '3.14'
*
* '-3.14'
*
* '2.5E10', or equivalently, '2.5e10'
*
* '2.5E-10'
*
* '.' (understood as 0)
*
* '5.'
*
* '.5', or, equivalently, '0.5'
*
* '+inf', 'inf', '-inf', 'NaN'
*
*
Leading and trailing whitespace represent an error.
*
*
# Arguments
*
*
* num - A string
*
*
# Return value
*
*
`none` if the string did not represent a valid number. Otherwise,
*
`Some(n)` where `n` is the floating-point number represented by `num`.
*
/
/
//
///
Convert a string in base 10 to a float.
///
Accepts a optional decimal exponent.
///
///
This function accepts strings such as
///
///
* '3.14'
///
* '+3.14', equivalent to '3.14'
///
* '-3.14'
///
* '2.5E10', or equivalently, '2.5e10'
///
* '2.5E-10'
///
* '.' (understood as 0)
///
* '5.'
///
* '.5', or, equivalently, '0.5'
///
* '+inf', 'inf', '-inf', 'NaN'
///
///
Leading and trailing whitespace represent an error.
///
///
# Arguments
///
///
* num - A string
///
///
# Return value
///
///
`none` if the string did not represent a valid number. Otherwise,
///
`Some(n)` where `n` is the floating-point number represented by `num`.
//
/
#[inline(always)]
pub
fn
from_str
(
num
:
&
str
)
->
Option
<
f64
>
{
strconv
::
from_str_common
(
num
,
10u
,
true
,
true
,
true
,
strconv
::
ExpDec
,
false
,
false
)
}
/
**
*
Convert a string in base 16 to a float.
*
Accepts a optional binary exponent.
*
*
This function accepts strings such as
*
*
* 'a4.fe'
*
* '+a4.fe', equivalent to 'a4.fe'
*
* '-a4.fe'
*
* '2b.aP128', or equivalently, '2b.ap128'
*
* '2b.aP-128'
*
* '.' (understood as 0)
*
* 'c.'
*
* '.c', or, equivalently, '0.c'
*
* '+inf', 'inf', '-inf', 'NaN'
*
*
Leading and trailing whitespace represent an error.
*
*
# Arguments
*
*
* num - A string
*
*
# Return value
*
*
`none` if the string did not represent a valid number. Otherwise,
*
`Some(n)` where `n` is the floating-point number represented by `[num]`.
*
/
/
//
///
Convert a string in base 16 to a float.
///
Accepts a optional binary exponent.
///
///
This function accepts strings such as
///
///
* 'a4.fe'
///
* '+a4.fe', equivalent to 'a4.fe'
///
* '-a4.fe'
///
* '2b.aP128', or equivalently, '2b.ap128'
///
* '2b.aP-128'
///
* '.' (understood as 0)
///
* 'c.'
///
* '.c', or, equivalently, '0.c'
///
* '+inf', 'inf', '-inf', 'NaN'
///
///
Leading and trailing whitespace represent an error.
///
///
# Arguments
///
///
* num - A string
///
///
# Return value
///
///
`none` if the string did not represent a valid number. Otherwise,
///
`Some(n)` where `n` is the floating-point number represented by `[num]`.
//
/
#[inline(always)]
pub
fn
from_str_hex
(
num
:
&
str
)
->
Option
<
f64
>
{
strconv
::
from_str_common
(
num
,
16u
,
true
,
true
,
true
,
strconv
::
ExpBin
,
false
,
false
)
}
/
**
*
Convert a string in an given base to a float.
*
*
Due to possible conflicts, this function does **not** accept
*
the special values `inf`, `-inf`, `+inf` and `NaN`, **nor**
*
does it recognize exponents of any kind.
*
*
Leading and trailing whitespace represent an error.
*
*
# Arguments
*
*
* num - A string
*
* radix - The base to use. Must lie in the range [2 .. 36]
*
*
# Return value
*
*
`none` if the string did not represent a valid number. Otherwise,
*
`Some(n)` where `n` is the floating-point number represented by `num`.
*
/
/
//
///
Convert a string in an given base to a float.
///
///
Due to possible conflicts, this function does **not** accept
///
the special values `inf`, `-inf`, `+inf` and `NaN`, **nor**
///
does it recognize exponents of any kind.
///
///
Leading and trailing whitespace represent an error.
///
///
# Arguments
///
///
* num - A string
///
* radix - The base to use. Must lie in the range [2 .. 36]
///
///
# Return value
///
///
`none` if the string did not represent a valid number. Otherwise,
///
`Some(n)` where `n` is the floating-point number represented by `num`.
//
/
#[inline(always)]
pub
fn
from_str_radix
(
num
:
&
str
,
rdx
:
uint
)
->
Option
<
f64
>
{
strconv
::
from_str_common
(
num
,
rdx
,
true
,
true
,
false
,
...
...
src/libcore/num/float.rs
浏览文件 @
dbc2e996
...
...
@@ -84,17 +84,17 @@ pub mod consts {
pub
static
ln_10
:
float
=
2.30258509299404568401799145468436421
;
}
/
*
*
Section: String Conversions
*
/
/
**
*
Converts a float to a string
*
*
# Arguments
*
*
* num - The float value
*
/
/
/
//
Section: String Conversions
/
/
/
//
///
Converts a float to a string
///
///
# Arguments
///
///
* num - The float value
//
/
#[inline(always)]
pub
fn
to_str
(
num
:
float
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -102,13 +102,13 @@ pub fn to_str(num: float) -> ~str {
r
}
/
**
*
Converts a float to a string in hexadecimal format
*
*
# Arguments
*
*
* num - The float value
*
/
/
//
///
Converts a float to a string in hexadecimal format
///
///
# Arguments
///
///
* num - The float value
//
/
#[inline(always)]
pub
fn
to_str_hex
(
num
:
float
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -116,20 +116,20 @@ pub fn to_str_hex(num: float) -> ~str {
r
}
/
**
*
Converts a float to a string in a given radix
*
*
# Arguments
*
*
* num - The float value
*
* radix - The base to use
*
*
# Failure
*
*
Fails if called on a special value like `inf`, `-inf` or `NaN` due to
*
possible misinterpretation of the result at higher bases. If those values
*
are expected, use `to_str_radix_special()` instead.
*
/
/
//
///
Converts a float to a string in a given radix
///
///
# Arguments
///
///
* num - The float value
///
* radix - The base to use
///
///
# Failure
///
///
Fails if called on a special value like `inf`, `-inf` or `NaN` due to
///
possible misinterpretation of the result at higher bases. If those values
///
are expected, use `to_str_radix_special()` instead.
//
/
#[inline(always)]
pub
fn
to_str_radix
(
num
:
float
,
radix
:
uint
)
->
~
str
{
let
(
r
,
special
)
=
strconv
::
to_str_common
(
...
...
@@ -139,30 +139,30 @@ pub fn to_str_radix(num: float, radix: uint) -> ~str {
r
}
/
**
*
Converts a float to a string in a given radix, and a flag indicating
*
whether it's a special value
*
*
# Arguments
*
*
* num - The float value
*
* radix - The base to use
*
/
/
//
///
Converts a float to a string in a given radix, and a flag indicating
///
whether it's a special value
///
///
# Arguments
///
///
* num - The float value
///
* radix - The base to use
//
/
#[inline(always)]
pub
fn
to_str_radix_special
(
num
:
float
,
radix
:
uint
)
->
(
~
str
,
bool
)
{
strconv
::
to_str_common
(
&
num
,
radix
,
true
,
strconv
::
SignNeg
,
strconv
::
DigAll
)
}
/
**
*
Converts a float to a string with exactly the number of
*
provided significant digits
*
*
# Arguments
*
*
* num - The float value
*
* digits - The number of significant digits
*
/
/
//
///
Converts a float to a string with exactly the number of
///
provided significant digits
///
///
# Arguments
///
///
* num - The float value
///
* digits - The number of significant digits
//
/
#[inline(always)]
pub
fn
to_str_exact
(
num
:
float
,
digits
:
uint
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -170,15 +170,15 @@ pub fn to_str_exact(num: float, digits: uint) -> ~str {
r
}
/
**
*
Converts a float to a string with a maximum number of
*
significant digits
*
*
# Arguments
*
*
* num - The float value
*
* digits - The number of significant digits
*
/
/
//
///
Converts a float to a string with a maximum number of
///
significant digits
///
///
# Arguments
///
///
* num - The float value
///
* digits - The number of significant digits
//
/
#[inline(always)]
pub
fn
to_str_digits
(
num
:
float
,
digits
:
uint
)
->
~
str
{
let
(
r
,
_
)
=
strconv
::
to_str_common
(
...
...
@@ -198,91 +198,91 @@ fn to_str_radix(&self, radix: uint) -> ~str {
}
}
/
**
*
Convert a string in base 10 to a float.
*
Accepts a optional decimal exponent.
*
*
This function accepts strings such as
*
*
* '3.14'
*
* '+3.14', equivalent to '3.14'
*
* '-3.14'
*
* '2.5E10', or equivalently, '2.5e10'
*
* '2.5E-10'
*
* '.' (understood as 0)
*
* '5.'
*
* '.5', or, equivalently, '0.5'
*
* '+inf', 'inf', '-inf', 'NaN'
*
*
Leading and trailing whitespace represent an error.
*
*
# Arguments
*
*
* num - A string
*
*
# Return value
*
*
`none` if the string did not represent a valid number. Otherwise,
*
`Some(n)` where `n` is the floating-point number represented by `num`.
*
/
/
//
///
Convert a string in base 10 to a float.
///
Accepts a optional decimal exponent.
///
///
This function accepts strings such as
///
///
* '3.14'
///
* '+3.14', equivalent to '3.14'
///
* '-3.14'
///
* '2.5E10', or equivalently, '2.5e10'
///
* '2.5E-10'
///
* '.' (understood as 0)
///
* '5.'
///
* '.5', or, equivalently, '0.5'
///
* '+inf', 'inf', '-inf', 'NaN'
///
///
Leading and trailing whitespace represent an error.
///
///
# Arguments
///
///
* num - A string
///
///
# Return value
///
///
`none` if the string did not represent a valid number. Otherwise,
///
`Some(n)` where `n` is the floating-point number represented by `num`.
//
/
#[inline(always)]
pub
fn
from_str
(
num
:
&
str
)
->
Option
<
float
>
{
strconv
::
from_str_common
(
num
,
10u
,
true
,
true
,
true
,
strconv
::
ExpDec
,
false
,
false
)
}
/
**
*
Convert a string in base 16 to a float.
*
Accepts a optional binary exponent.
*
*
This function accepts strings such as
*
*
* 'a4.fe'
*
* '+a4.fe', equivalent to 'a4.fe'
*
* '-a4.fe'
*
* '2b.aP128', or equivalently, '2b.ap128'
*
* '2b.aP-128'
*
* '.' (understood as 0)
*
* 'c.'
*
* '.c', or, equivalently, '0.c'
*
* '+inf', 'inf', '-inf', 'NaN'
*
*
Leading and trailing whitespace represent an error.
*
*
# Arguments
*
*
* num - A string
*
*
# Return value
*
*
`none` if the string did not represent a valid number. Otherwise,
*
`Some(n)` where `n` is the floating-point number represented by `[num]`.
*
/
/
//
///
Convert a string in base 16 to a float.
///
Accepts a optional binary exponent.
///
///
This function accepts strings such as
///
///
* 'a4.fe'
///
* '+a4.fe', equivalent to 'a4.fe'
///
* '-a4.fe'
///
* '2b.aP128', or equivalently, '2b.ap128'
///
* '2b.aP-128'
///
* '.' (understood as 0)
///
* 'c.'
///
* '.c', or, equivalently, '0.c'
///
* '+inf', 'inf', '-inf', 'NaN'
///
///
Leading and trailing whitespace represent an error.
///
///
# Arguments
///
///
* num - A string
///
///
# Return value
///
///
`none` if the string did not represent a valid number. Otherwise,
///
`Some(n)` where `n` is the floating-point number represented by `[num]`.
//
/
#[inline(always)]
pub
fn
from_str_hex
(
num
:
&
str
)
->
Option
<
float
>
{
strconv
::
from_str_common
(
num
,
16u
,
true
,
true
,
true
,
strconv
::
ExpBin
,
false
,
false
)
}
/
**
*
Convert a string in an given base to a float.
*
*
Due to possible conflicts, this function does **not** accept
*
the special values `inf`, `-inf`, `+inf` and `NaN`, **nor**
*
does it recognize exponents of any kind.
*
*
Leading and trailing whitespace represent an error.
*
*
# Arguments
*
*
* num - A string
*
* radix - The base to use. Must lie in the range [2 .. 36]
*
*
# Return value
*
*
`none` if the string did not represent a valid number. Otherwise,
*
`Some(n)` where `n` is the floating-point number represented by `num`.
*
/
/
//
///
Convert a string in an given base to a float.
///
///
Due to possible conflicts, this function does **not** accept
///
the special values `inf`, `-inf`, `+inf` and `NaN`, **nor**
///
does it recognize exponents of any kind.
///
///
Leading and trailing whitespace represent an error.
///
///
# Arguments
///
///
* num - A string
///
* radix - The base to use. Must lie in the range [2 .. 36]
///
///
# Return value
///
///
`none` if the string did not represent a valid number. Otherwise,
///
`Some(n)` where `n` is the floating-point number represented by `num`.
//
/
#[inline(always)]
pub
fn
from_str_radix
(
num
:
&
str
,
radix
:
uint
)
->
Option
<
float
>
{
strconv
::
from_str_common
(
num
,
radix
,
true
,
true
,
false
,
...
...
@@ -301,22 +301,22 @@ fn from_str_radix(val: &str, radix: uint) -> Option<float> {
}
}
/
**
*
Section: Arithmetics
*
/
/
**
*
Compute the exponentiation of an integer by another integer as a float
*
*
# Arguments
*
*
* x - The base
*
* pow - The exponent
*
*
# Return value
*
*
`NaN` if both `x` and `pow` are `0u`, otherwise `x^pow`
*
/
/
/
//
Section: Arithmetics
/
/
/
//
///
Compute the exponentiation of an integer by another integer as a float
///
///
# Arguments
///
///
* x - The base
///
* pow - The exponent
///
///
# Return value
///
///
`NaN` if both `x` and `pow` are `0u`, otherwise `x^pow`
//
/
pub
fn
pow_with_uint
(
base
:
uint
,
pow
:
uint
)
->
float
{
if
base
==
0u
{
if
pow
==
0u
{
...
...
@@ -668,13 +668,13 @@ impl Signed for float {
#[inline(always)]
fn
abs
(
&
self
)
->
float
{
abs
(
*
self
)
}
/
**
*
# Returns
*
*
- `1.0` if the number is positive, `+0.0` or `infinity`
*
- `-1.0` if the number is negative, `-0.0` or `neg_infinity`
*
- `NaN` if the number is NaN
*
/
/
//
///
# Returns
///
///
- `1.0` if the number is positive, `+0.0` or `infinity`
///
- `-1.0` if the number is negative, `-0.0` or `neg_infinity`
///
- `NaN` if the number is NaN
//
/
#[inline(always)]
fn
signum
(
&
self
)
->
float
{
if
is_NaN
(
*
self
)
{
NaN
}
else
{
f64
::
copysign
(
1.0
,
*
self
as
f64
)
as
float
}
...
...
src/libcore/num/int-template.rs
浏览文件 @
dbc2e996
...
...
@@ -32,26 +32,26 @@ pub fn mul(x: T, y: T) -> T { x * y }
#[inline(always)]
pub
fn
quot
(
x
:
T
,
y
:
T
)
->
T
{
x
/
y
}
/
**
*
Returns the remainder of y / x.
*
*
# Examples
*
~~~
*
assert!(int::rem(5 / 2) == 1);
*
~~~
*
*
When faced with negative numbers, the result copies the sign of the
*
dividend.
*
*
~~~
*
assert!(int::rem(2 / -3) == 2);
*
~~~
*
*
~~~
*
assert!(int::rem(-2 / 3) == -2);
*
~~~
*
*
/
/
//
///
Returns the remainder of y / x.
///
///
# Examples
///
~~~
///
assert!(int::rem(5 / 2) == 1);
///
~~~
///
///
When faced with negative numbers, the result copies the sign of the
///
dividend.
///
///
~~~
///
assert!(int::rem(2 / -3) == 2);
///
~~~
///
///
~~~
///
assert!(int::rem(-2 / 3) == -2);
///
~~~
///
//
/
#[inline(always)]
pub
fn
rem
(
x
:
T
,
y
:
T
)
->
T
{
x
%
y
}
...
...
@@ -68,23 +68,23 @@ pub fn ge(x: T, y: T) -> bool { x >= y }
#[inline(always)]
pub
fn
gt
(
x
:
T
,
y
:
T
)
->
bool
{
x
>
y
}
/
**
*
Iterate over the range [`lo`..`hi`)
*
*
# Arguments
*
*
* `lo` - lower bound, inclusive
*
* `hi` - higher bound, exclusive
*
*
# Examples
*
~~~
*
let mut sum = 0;
*
for int::range(1, 5) |i| {
*
sum += i;
*
}
*
assert!(sum == 10);
*
~~~
*
/
/
//
///
Iterate over the range [`lo`..`hi`)
///
///
# Arguments
///
///
* `lo` - lower bound, inclusive
///
* `hi` - higher bound, exclusive
///
///
# Examples
///
~~~
///
let mut sum = 0;
///
for int::range(1, 5) |i| {
///
sum += i;
///
}
///
assert!(sum == 10);
///
~~~
//
/
#[inline(always)]
/// Iterate over the range [`start`,`start`+`step`..`stop`)
pub
fn
range_step
(
start
:
T
,
stop
:
T
,
step
:
T
,
it
:
&
fn
(
T
)
->
bool
)
{
...
...
@@ -190,24 +190,24 @@ fn div(&self, other: &T) -> T { *self / *other }
}
#[cfg(not(stage0),notest)]
impl
Quot
<
T
,
T
>
for
T
{
/
**
*
Returns the integer quotient, truncated towards 0. As this behaviour reflects
*
the underlying machine implementation it is more efficient than `Natural::div`.
*
*
# Examples
*
*
~~~
*
assert!( 8 / 3 == 2);
*
assert!( 8 / -3 == -2);
*
assert!(-8 / 3 == -2);
*
assert!(-8 / -3 == 2);
*
assert!( 1 / 2 == 0);
*
assert!( 1 / -2 == 0);
*
assert!(-1 / 2 == 0);
*
assert!(-1 / -2 == 0);
*
~~~
*
/
/
//
///
Returns the integer quotient, truncated towards 0. As this behaviour reflects
///
the underlying machine implementation it is more efficient than `Natural::div`.
///
///
# Examples
///
///
~~~
///
assert!( 8 / 3 == 2);
///
assert!( 8 / -3 == -2);
///
assert!(-8 / 3 == -2);
///
assert!(-8 / -3 == 2);
///
assert!( 1 / 2 == 0);
///
assert!( 1 / -2 == 0);
///
assert!(-1 / 2 == 0);
///
assert!(-1 / -2 == 0);
///
~~~
//
/
#[inline(always)]
fn
quot
(
&
self
,
other
:
&
T
)
->
T
{
*
self
/
*
other
}
}
...
...
@@ -219,27 +219,27 @@ fn modulo(&self, other: &T) -> T { *self % *other }
}
#[cfg(not(stage0),notest)]
impl
Rem
<
T
,
T
>
for
T
{
/
**
*
Returns the integer remainder after division, satisfying:
*
*
~~~
*
assert!((n / d) * d + (n % d) == n)
*
~~~
*
*
# Examples
*
*
~~~
*
assert!( 8 % 3 == 2);
*
assert!( 8 % -3 == 2);
*
assert!(-8 % 3 == -2);
*
assert!(-8 % -3 == -2);
*
assert!( 1 % 2 == 1);
*
assert!( 1 % -2 == 1);
*
assert!(-1 % 2 == -1);
*
assert!(-1 % -2 == -1);
*
~~~
*
/
/
//
///
Returns the integer remainder after division, satisfying:
///
///
~~~
///
assert!((n / d) * d + (n % d) == n)
///
~~~
///
///
# Examples
///
///
~~~
///
assert!( 8 % 3 == 2);
///
assert!( 8 % -3 == 2);
///
assert!(-8 % 3 == -2);
///
assert!(-8 % -3 == -2);
///
assert!( 1 % 2 == 1);
///
assert!( 1 % -2 == 1);
///
assert!(-1 % 2 == -1);
///
assert!(-1 % -2 == -1);
///
~~~
//
/
#[inline(always)]
fn
rem
(
&
self
,
other
:
&
T
)
->
T
{
*
self
%
*
other
}
}
...
...
@@ -257,13 +257,13 @@ fn abs(&self) -> T {
if
self
.is_negative
()
{
-*
self
}
else
{
*
self
}
}
/
**
*
# Returns
*
*
- `0` if the number is zero
*
- `1` if the number is positive
*
- `-1` if the number is negative
*
/
/
//
///
# Returns
///
///
- `0` if the number is zero
///
- `1` if the number is positive
///
- `-1` if the number is negative
//
/
#[inline(always)]
fn
signum
(
&
self
)
->
T
{
match
*
self
{
...
...
@@ -283,23 +283,23 @@ fn is_negative(&self) -> bool { *self < 0 }
}
impl
Integer
for
T
{
/
**
*
Floored integer division
*
*
# Examples
*
*
~~~
*
assert!(( 8).div( 3) == 2);
*
assert!(( 8).div(-3) == -3);
*
assert!((-8).div( 3) == -3);
*
assert!((-8).div(-3) == 2);
*
*
assert!(( 1).div( 2) == 0);
*
assert!(( 1).div(-2) == -1);
*
assert!((-1).div( 2) == -1);
*
assert!((-1).div(-2) == 0);
*
~~~
*
/
/
//
///
Floored integer division
///
///
# Examples
///
///
~~~
///
assert!(( 8).div( 3) == 2);
///
assert!(( 8).div(-3) == -3);
///
assert!((-8).div( 3) == -3);
///
assert!((-8).div(-3) == 2);
///
///
assert!(( 1).div( 2) == 0);
///
assert!(( 1).div(-2) == -1);
///
assert!((-1).div( 2) == -1);
///
assert!((-1).div(-2) == 0);
///
~~~
//
/
#[inline(always)]
fn
div
(
&
self
,
other
:
&
T
)
->
T
{
// Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_,
...
...
@@ -311,27 +311,27 @@ fn div(&self, other: &T) -> T {
}
}
/
**
*
Integer modulo, satisfying:
*
*
~~~
*
assert!(n.div(d) * d + n.modulo(d) == n)
*
~~~
*
*
# Examples
*
*
~~~
*
assert!(( 8).modulo( 3) == 2);
*
assert!(( 8).modulo(-3) == -1);
*
assert!((-8).modulo( 3) == 1);
*
assert!((-8).modulo(-3) == -2);
*
*
assert!(( 1).modulo( 2) == 1);
*
assert!(( 1).modulo(-2) == -1);
*
assert!((-1).modulo( 2) == 1);
*
assert!((-1).modulo(-2) == -1);
*
~~~
*
/
/
//
///
Integer modulo, satisfying:
///
///
~~~
///
assert!(n.div(d) * d + n.modulo(d) == n)
///
~~~
///
///
# Examples
///
///
~~~
///
assert!(( 8).modulo( 3) == 2);
///
assert!(( 8).modulo(-3) == -1);
///
assert!((-8).modulo( 3) == 1);
///
assert!((-8).modulo(-3) == -2);
///
///
assert!(( 1).modulo( 2) == 1);
///
assert!(( 1).modulo(-2) == -1);
///
assert!((-1).modulo( 2) == 1);
///
assert!((-1).modulo(-2) == -1);
///
~~~
//
/
#[inline(always)]
fn
modulo
(
&
self
,
other
:
&
T
)
->
T
{
// Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_,
...
...
@@ -361,11 +361,11 @@ fn quot_rem(&self, other: &T) -> (T,T) {
(
*
self
/
*
other
,
*
self
%
*
other
)
}
/
**
*
Calculates the Greatest Common Divisor (GCD) of the number and `other`
*
*
The result is always positive
*
/
/
//
///
Calculates the Greatest Common Divisor (GCD) of the number and `other`
///
///
The result is always positive
//
/
#[inline(always)]
fn
gcd
(
&
self
,
other
:
&
T
)
->
T
{
// Use Euclid's algorithm
...
...
@@ -378,9 +378,9 @@ fn gcd(&self, other: &T) -> T {
n
.abs
()
}
/
**
*
Calculates the Lowest Common Multiple (LCM) of the number and `other`
*
/
/
//
///
Calculates the Lowest Common Multiple (LCM) of the number and `other`
//
/
#[inline(always)]
fn
lcm
(
&
self
,
other
:
&
T
)
->
T
{
((
*
self
*
*
other
)
/
self
.gcd
(
other
))
.abs
()
// should not have to recaluculate abs
...
...
@@ -545,13 +545,13 @@ pub fn test_signed() {
assert
!
((
-
1
as
T
)
.is_negative
());
}
/
**
*
Checks that the division rule holds for:
*
*
- `n`: numerator (dividend)
*
- `d`: denominator (divisor)
*
- `qr`: quotient and remainder
*
/
/
//
///
Checks that the division rule holds for:
///
///
- `n`: numerator (dividend)
///
- `d`: denominator (divisor)
///
- `qr`: quotient and remainder
//
/
#[cfg(test)]
fn
test_division_rule
(
nd
:
(
T
,
T
),
qr
:
(
T
,
T
))
{
let
(
n
,
d
)
=
nd
,
...
...
src/libcore/num/num.rs
浏览文件 @
dbc2e996
...
...
@@ -153,7 +153,9 @@ pub trait Real: Signed
fn
tanh
(
&
self
)
->
Self
;
}
///
/// Methods that are harder to implement and not commonly used.
///
pub
trait
RealExt
:
Real
{
// FIXME (#5527): usages of `int` should be replaced with an associated
// integer type once these are implemented
...
...
@@ -171,24 +173,24 @@ pub trait RealExt: Real {
fn
yn
(
&
self
,
n
:
int
)
->
Self
;
}
/
**
*
Cast from one machine scalar to another
*
*
# Example
*
*
~~~
*
let twenty: f32 = num::cast(0x14);
*
assert_eq!(twenty, 20f32);
*
~~~
*
/
/
//
///
Cast from one machine scalar to another
///
///
# Example
///
///
~~~
///
let twenty: f32 = num::cast(0x14);
///
assert_eq!(twenty, 20f32);
///
~~~
//
/
#[inline(always)]
pub
fn
cast
<
T
:
NumCast
,
U
:
NumCast
>
(
n
:
T
)
->
U
{
NumCast
::
from
(
n
)
}
/
**
*
An interface for casting between machine scalars
*
/
/
//
///
An interface for casting between machine scalars
//
/
pub
trait
NumCast
{
fn
from
<
T
:
NumCast
>
(
n
:
T
)
->
Self
;
...
...
@@ -260,21 +262,19 @@ pub trait FromStrRadix {
pub
fn
from_str_radix
(
str
:
&
str
,
radix
:
uint
)
->
Option
<
Self
>
;
}
// Generic math functions:
/**
* Calculates a power to a given radix, optimized for uint `pow` and `radix`.
*
* Returns `radix^pow` as `T`.
*
* Note:
* Also returns `1` for `0^0`, despite that technically being an
* undefined number. The reason for this is twofold:
* - If code written to use this function cares about that special case, it's
* probably going to catch it before making the call.
* - If code written to use this function doesn't care about it, it's
* probably assuming that `x^0` always equals `1`.
*/
///
/// Calculates a power to a given radix, optimized for uint `pow` and `radix`.
///
/// Returns `radix^pow` as `T`.
///
/// Note:
/// Also returns `1` for `0^0`, despite that technically being an
/// undefined number. The reason for this is twofold:
/// - If code written to use this function cares about that special case, it's
/// probably going to catch it before making the call.
/// - If code written to use this function doesn't care about it, it's
/// probably assuming that `x^0` always equals `1`.
///
pub
fn
pow_with_uint
<
T
:
NumCast
+
One
+
Zero
+
Copy
+
Quot
<
T
,
T
>+
Mul
<
T
,
T
>>
(
radix
:
uint
,
pow
:
uint
)
->
T
{
let
_0
:
T
=
Zero
::
zero
();
...
...
src/libcore/num/uint-template.rs
浏览文件 @
dbc2e996
...
...
@@ -49,10 +49,9 @@ pub fn ge(x: T, y: T) -> bool { x >= y }
pub
fn
gt
(
x
:
T
,
y
:
T
)
->
bool
{
x
>
y
}
#[inline(always)]
/**
* Iterate over the range [`start`,`start`+`step`..`stop`)
*
*/
///
/// Iterate over the range [`start`,`start`+`step`..`stop`)
///
pub
fn
range_step
(
start
:
T
,
stop
:
T
,
step
:
T_SIGNED
,
...
...
src/libcore/num/uint-template/uint.rs
浏览文件 @
dbc2e996
...
...
@@ -31,74 +31,74 @@ pub mod inst {
#[cfg(target_arch
=
"x86_64"
)]
pub
static
bits
:
uint
=
64
;
/
**
*
Divide two numbers, return the result, rounded up.
*
*
# Arguments
*
*
* x - an integer
*
* y - an integer distinct from 0u
*
*
# Return value
*
*
The smallest integer `q` such that `x/y <= q`.
*
/
/
//
///
Divide two numbers, return the result, rounded up.
///
///
# Arguments
///
///
* x - an integer
///
* y - an integer distinct from 0u
///
///
# Return value
///
///
The smallest integer `q` such that `x/y <= q`.
//
/
pub
fn
div_ceil
(
x
:
uint
,
y
:
uint
)
->
uint
{
let
div
=
x
/
y
;
if
x
%
y
==
0u
{
div
}
else
{
div
+
1u
}
}
/
**
*
Divide two numbers, return the result, rounded to the closest integer.
*
*
# Arguments
*
*
* x - an integer
*
* y - an integer distinct from 0u
*
*
# Return value
*
*
The integer `q` closest to `x/y`.
*
/
/
//
///
Divide two numbers, return the result, rounded to the closest integer.
///
///
# Arguments
///
///
* x - an integer
///
* y - an integer distinct from 0u
///
///
# Return value
///
///
The integer `q` closest to `x/y`.
//
/
pub
fn
div_round
(
x
:
uint
,
y
:
uint
)
->
uint
{
let
div
=
x
/
y
;
if
x
%
y
*
2u
<
y
{
div
}
else
{
div
+
1u
}
}
/
**
*
Divide two numbers, return the result, rounded down.
*
*
Note: This is the same function as `div`.
*
*
# Arguments
*
*
* x - an integer
*
* y - an integer distinct from 0u
*
*
# Return value
*
*
The smallest integer `q` such that `x/y <= q`. This
*
is either `x/y` or `x/y + 1`.
*
/
/
//
///
Divide two numbers, return the result, rounded down.
///
///
Note: This is the same function as `div`.
///
///
# Arguments
///
///
* x - an integer
///
* y - an integer distinct from 0u
///
///
# Return value
///
///
The smallest integer `q` such that `x/y <= q`. This
///
is either `x/y` or `x/y + 1`.
//
/
pub
fn
div_floor
(
x
:
uint
,
y
:
uint
)
->
uint
{
return
x
/
y
;
}
/
**
*
Iterate over the range [`lo`..`hi`), or stop when requested
*
*
# Arguments
*
*
* lo - The integer at which to start the loop (included)
*
* hi - The integer at which to stop the loop (excluded)
*
* it - A block to execute with each consecutive integer of the range.
*
Return `true` to continue, `false` to stop.
*
*
# Return value
*
*
`true` If execution proceeded correctly, `false` if it was interrupted,
*
that is if `it` returned `false` at any point.
*
/
/
//
///
Iterate over the range [`lo`..`hi`), or stop when requested
///
///
# Arguments
///
///
* lo - The integer at which to start the loop (included)
///
* hi - The integer at which to stop the loop (excluded)
///
* it - A block to execute with each consecutive integer of the range.
///
Return `true` to continue, `false` to stop.
///
///
# Return value
///
///
`true` If execution proceeded correctly, `false` if it was interrupted,
///
that is if `it` returned `false` at any point.
//
/
pub
fn
iterate
(
lo
:
uint
,
hi
:
uint
,
it
:
&
fn
(
uint
)
->
bool
)
->
bool
{
let
mut
i
=
lo
;
while
i
<
hi
{
...
...
@@ -110,16 +110,16 @@ pub fn iterate(lo: uint, hi: uint, it: &fn(uint) -> bool) -> bool {
impl
iter
::
Times
for
uint
{
#[inline(always)]
/
**
*
A convenience form for basic iteration. Given a uint `x`,
*
`for x.times { ... }` executes the given block x times.
*
*
Equivalent to `for uint::range(0, x) |_| { ... }`.
*
*
Not defined on all integer types to permit unambiguous
*
use with integer literals of inferred integer-type as
*
the self-value (eg. `for 100.times { ... }`).
*
/
/
//
///
A convenience form for basic iteration. Given a uint `x`,
///
`for x.times { ... }` executes the given block x times.
///
///
Equivalent to `for uint::range(0, x) |_| { ... }`.
///
///
Not defined on all integer types to permit unambiguous
///
use with integer literals of inferred integer-type as
///
the self-value (eg. `for 100.times { ... }`).
//
/
fn
times
(
&
self
,
it
:
&
fn
()
->
bool
)
{
let
mut
i
=
*
self
;
while
i
>
0
{
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录