OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

remove the `float` type 

It is simply defined as `f64` across every platform right now.

A use case hasn't been presented for a `float` type defined as the
highest precision floating point type implemented in hardware on the
platform. Performance-wise, using the smallest precision correct for the
use case greatly saves on cache space and allows for fitting more
numbers into SSE/AVX registers.

If there was a use case, this could be implemented as simply a type
alias or a struct thanks to `#[cfg(...)]`.

Closes #6592

The mailing list thread, for reference:

https://mail.mozilla.org/pipermail/rust-dev/2013-July/004632.html
This commit is contained in:
Daniel Micay 2013-09-26 02:26:09 -04:00
parent 24a253778a
commit c9d4ad07c4
136 changed files with 606 additions and 2209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
doc/rust.md
View File

@ -363,19 +363,17 @@ A _floating-point literal_ has one of two forms:
second decimal literal.
* A single _decimal literal_ followed by an _exponent_.
By default, a floating-point literal is of type `float`. A
floating-point literal may be followed (immediately, without any
spaces) by a _floating-point suffix_, which changes the type of the
literal. There are three floating-point suffixes: `f` (for the base
`float` type), `f32`, and `f64` (the 32-bit and 64-bit floating point
types).
By default, a floating-point literal has a generic type, but will fall back to
`f64`. A floating-point literal may be followed (immediately, without any
spaces) by a _floating-point suffix_, which changes the type of the literal.
There are two floating-point suffixes: `f32`, and `f64` (the 32-bit and 64-bit
floating point types).
Examples of floating-point literals of various forms:
~~~~
123.0; // type float
0.1; // type float
3f; // type float
123.0; // type f64
0.1; // type f64
0.1f32; // type f32
12E+99_f64; // type f64
~~~~
@ -1179,8 +1177,8 @@ a = Cat;
Enumeration constructors can have either named or unnamed fields:
~~~~
enum Animal {
Dog (~str, float),
Cat { name: ~str, weight: float }
Dog (~str, f64),
Cat { name: ~str, weight: f64 }
}
let mut a: Animal = Dog(~"Cocoa", 37.2);
@ -1344,17 +1342,17 @@ For example:
trait Num {
fn from_int(n: int) -> Self;
}
impl Num for float {
fn from_int(n: int) -> float { n as float }
impl Num for f64 {
fn from_int(n: int) -> f64 { n as f64 }
}
let x: float = Num::from_int(42);
let x: f64 = Num::from_int(42);
~~~~
Traits may inherit from other traits. For example, in
~~~~
trait Shape { fn area() -> float; }
trait Circle : Shape { fn radius() -> float; }
trait Shape { fn area() -> f64; }
trait Circle : Shape { fn radius() -> f64; }
~~~~
the syntax `Circle : Shape` means that types that implement `Circle` must also have an implementation for `Shape`.
@ -1367,9 +1365,9 @@ methods of the supertrait may be called on values of subtrait-bound type paramet
Referring to the previous example of `trait Circle : Shape`:
~~~
# trait Shape { fn area(&self) -> float; }
# trait Circle : Shape { fn radius(&self) -> float; }
fn radius_times_area<T: Circle>(c: T) -> float {
# trait Shape { fn area(&self) -> f64; }
# trait Circle : Shape { fn radius(&self) -> f64; }
fn radius_times_area<T: Circle>(c: T) -> f64 {
// `c` is both a Circle and a Shape
c.radius() * c.area()
}
@ -1378,10 +1376,10 @@ fn radius_times_area<T: Circle>(c: T) -> float {
Likewise, supertrait methods may also be called on trait objects.
~~~ {.xfail-test}
# trait Shape { fn area(&self) -> float; }
# trait Circle : Shape { fn radius(&self) -> float; }
# impl Shape for int { fn area(&self) -> float { 0.0 } }
# impl Circle for int { fn radius(&self) -> float { 0.0 } }
# trait Shape { fn area(&self) -> f64; }
# trait Circle : Shape { fn radius(&self) -> f64; }
# impl Shape for int { fn area(&self) -> f64 { 0.0 } }
# impl Circle for int { fn radius(&self) -> f64 { 0.0 } }
# let mycircle = 0;
let mycircle: Circle = @mycircle as @Circle;
@ -1395,14 +1393,14 @@ An _implementation_ is an item that implements a [trait](#traits) for a specific
Implementations are defined with the keyword `impl`.
~~~~
# struct Point {x: float, y: float};
# struct Point {x: f64, y: f64};
# type Surface = int;
# struct BoundingBox {x: float, y: float, width: float, height: float};
# struct BoundingBox {x: f64, y: f64, width: f64, height: f64};
# trait Shape { fn draw(&self, Surface); fn bounding_box(&self) -> BoundingBox; }
# fn do_draw_circle(s: Surface, c: Circle) { }
struct Circle {
radius: float,
radius: f64,
center: Point,
}
@ -1970,7 +1968,7 @@ values.
~~~~~~~~ {.tuple}
(0,);
(0f, 4.5f);
(0.0, 4.5);
("a", 4u, true);
~~~~~~~~
@ -2002,12 +2000,12 @@ A _unit-like structure expression_ consists only of the [path](#paths) of a [str
The following are examples of structure expressions:
~~~~
# struct Point { x: float, y: float }
# struct TuplePoint(float, float);
# struct Point { x: f64, y: f64 }
# struct TuplePoint(f64, f64);
# mod game { pub struct User<'self> { name: &'self str, age: uint, score: uint } }
# struct Cookie; fn some_fn<T>(t: T) {}
Point {x: 10f, y: 20f};
TuplePoint(10f, 20f);
Point {x: 10.0, y: 20.0};
TuplePoint(10.0, 20.0);
let u = game::User {name: "Joe", age: 35, score: 100_000};
some_fn::<Cookie>(Cookie);
~~~~
@ -2248,12 +2246,12 @@ Any other cast is unsupported and will fail to compile.
An example of an `as` expression:
~~~~
# fn sum(v: &[float]) -> float { 0.0 }
# fn len(v: &[float]) -> int { 0 }
# fn sum(v: &[f64]) -> f64 { 0.0 }
# fn len(v: &[f64]) -> int { 0 }
fn avg(v: &[float]) -> float {
let sum: float = sum(v);
let sz: float = len(v) as float;
fn avg(v: &[f64]) -> f64 {
let sum: f64 = sum(v);
let sz: f64 = len(v) as f64;
return sum / sz;
}
~~~~
@ -2767,19 +2765,6 @@ size, in bits, is equal to the size of the rust type `uint` on the same target
machine.
#### Machine-dependent floating point type
The Rust type `float` is a machine-specific type equal to one of the supported
Rust floating-point machine types (`f32` or `f64`). It is the largest
floating-point type that is directly supported by hardware on the target
machine, or if the target machine has no floating-point hardware support, the
largest floating-point type supported by the software floating-point library
used to support the other floating-point machine types.
Note that due to the preference for hardware-supported floating-point, the
type `float` may not be equal to the largest *supported* floating-point type.
### Textual types
The types `char` and `str` hold textual data.

138
doc/tutorial-borrowed-ptr.md
View File

@ -32,7 +32,7 @@ where you would like to use data for a short time.
As an example, consider a simple struct type `Point`:
~~~
struct Point {x: float, y: float}
struct Point {x: f64, y: f64}
~~~
We can use this simple definition to allocate points in many different ways. For
@ -40,7 +40,7 @@ example, in this code, each of these three local variables contains a
point, but allocated in a different place:
~~~
# struct Point {x: float, y: float}
# struct Point {x: f64, y: f64}
let on_the_stack : Point = Point {x: 3.0, y: 4.0};
let managed_box : @Point = @Point {x: 5.0, y: 1.0};
let owned_box : ~Point = ~Point {x: 7.0, y: 9.0};
@ -59,9 +59,9 @@ function that takes the points by pointer. We can use borrowed pointers to do
this:
~~~
# struct Point {x: float, y: float}
# fn sqrt(f: float) -> float { 0f }
fn compute_distance(p1: &Point, p2: &Point) -> float {
# struct Point {x: f64, y: f64}
# fn sqrt(f: f64) -> f64 { 0.0 }
fn compute_distance(p1: &Point, p2: &Point) -> f64 {
let x_d = p1.x - p2.x;
let y_d = p1.y - p2.y;
sqrt(x_d * x_d + y_d * y_d)
@ -71,11 +71,11 @@ fn compute_distance(p1: &Point, p2: &Point) -> float {
Now we can call `compute_distance()` in various ways:
~~~
# struct Point {x: float, y: float}
# struct Point {x: f64, y: f64}
# let on_the_stack : Point = Point{x: 3.0, y: 4.0};
# let managed_box : @Point = @Point{x: 5.0, y: 1.0};
# let owned_box : ~Point = ~Point{x: 7.0, y: 9.0};
# fn compute_distance(p1: &Point, p2: &Point) -> float { 0f }
# fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 }
compute_distance(&on_the_stack, managed_box);
compute_distance(managed_box, owned_box);
~~~
@ -108,7 +108,7 @@ before you can make full use of it again.
In the previous example, the value `on_the_stack` was defined like so:
~~~
# struct Point {x: float, y: float}
# struct Point {x: f64, y: f64}
let on_the_stack: Point = Point {x: 3.0, y: 4.0};
~~~
@ -118,7 +118,7 @@ functions. As a consequence, we had to explicitly take the address of
convenient to move the & operator into the definition of `on_the_stack`:
~~~
# struct Point {x: float, y: float}
# struct Point {x: f64, y: f64}
let on_the_stack2: &Point = &Point {x: 3.0, y: 4.0};
~~~
@ -127,7 +127,7 @@ shorthand for creating a temporary and taking its address. A more verbose
way to write the same code is:
~~~
# struct Point {x: float, y: float}
# struct Point {x: f64, y: f64}
let tmp = Point {x: 3.0, y: 4.0};
let on_the_stack2 : &Point = &tmp;
~~~
@ -140,36 +140,36 @@ individual array elements. For example, consider this type definition
for `rectangle`:
~~~
struct Point {x: float, y: float} // as before
struct Size {w: float, h: float} // as before
struct Point {x: f64, y: f64} // as before
struct Size {w: f64, h: f64} // as before
struct Rectangle {origin: Point, size: Size}
~~~
Now, as before, we can define rectangles in a few different ways:
~~~
# struct Point {x: float, y: float}
# struct Size {w: float, h: float} // as before
# struct Point {x: f64, y: f64}
# struct Size {w: f64, h: f64} // as before
# struct Rectangle {origin: Point, size: Size}
let rect_stack = &Rectangle {origin: Point {x: 1f, y: 2f},
size: Size {w: 3f, h: 4f}};
let rect_managed = @Rectangle {origin: Point {x: 3f, y: 4f},
size: Size {w: 3f, h: 4f}};
let rect_owned = ~Rectangle {origin: Point {x: 5f, y: 6f},
size: Size {w: 3f, h: 4f}};
let rect_stack = &Rectangle {origin: Point {x: 1.0, y: 2.0},
size: Size {w: 3.0, h: 4.0}};
let rect_managed = @Rectangle {origin: Point {x: 3.0, y: 4.0},
size: Size {w: 3.0, h: 4.0}};
let rect_owned = ~Rectangle {origin: Point {x: 5.0, y: 6.0},
size: Size {w: 3.0, h: 4.0}};
~~~
In each case, we can extract out individual subcomponents with the `&`
operator. For example, I could write:
~~~
# struct Point {x: float, y: float} // as before
# struct Size {w: float, h: float} // as before
# struct Point {x: f64, y: f64} // as before
# struct Size {w: f64, h: f64} // as before
# struct Rectangle {origin: Point, size: Size}
# let rect_stack = &Rectangle {origin: Point {x: 1f, y: 2f}, size: Size {w: 3f, h: 4f}};
# let rect_managed = @Rectangle {origin: Point {x: 3f, y: 4f}, size: Size {w: 3f, h: 4f}};
# let rect_owned = ~Rectangle {origin: Point {x: 5f, y: 6f}, size: Size {w: 3f, h: 4f}};
# fn compute_distance(p1: &Point, p2: &Point) -> float { 0f }
# let rect_stack = &Rectangle {origin: Point {x: 1.0, y: 2.0}, size: Size {w: 3.0, h: 4.0}};
# let rect_managed = @Rectangle {origin: Point {x: 3.0, y: 4.0}, size: Size {w: 3.0, h: 4.0}};
# let rect_owned = ~Rectangle {origin: Point {x: 5.0, y: 6.0}, size: Size {w: 3.0, h: 4.0}};
# fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 }
compute_distance(&rect_stack.origin, &rect_managed.origin);
~~~
@ -375,10 +375,10 @@ As an example, let’s look at the following `shape` type that can
represent both rectangles and circles:
~~~
struct Point {x: float, y: float}; // as before
struct Size {w: float, h: float}; // as before
struct Point {x: f64, y: f64}; // as before
struct Size {w: f64, h: f64}; // as before
enum Shape {
Circle(Point, float), // origin, radius
Circle(Point, f64), // origin, radius
Rectangle(Point, Size) // upper-left, dimensions
}
~~~
@ -388,14 +388,14 @@ function takes a borrowed pointer to a shape, to avoid the need for
copying.
~~~
# struct Point {x: float, y: float}; // as before
# struct Size {w: float, h: float}; // as before
# struct Point {x: f64, y: f64}; // as before
# struct Size {w: f64, h: f64}; // as before
# enum Shape {
# Circle(Point, float), // origin, radius
# Circle(Point, f64), // origin, radius
# Rectangle(Point, Size) // upper-left, dimensions
# }
# static tau: float = 6.28f;
fn compute_area(shape: &Shape) -> float {
# static tau: f64 = 6.28;
fn compute_area(shape: &Shape) -> f64 {
match *shape {
Circle(_, radius) => 0.5 * tau * radius * radius,
Rectangle(_, ref size) => size.w * size.h
@ -424,10 +424,10 @@ Stack Memory
+-------+ +---------------+
| shape | ------> | rectangle( |
+-------+ | {x: float, |
| size | -+ | y: float}, |
+-------+ +----> | {w: float, |
| h: float}) |
+-------+ | {x: f64, |
| size | -+ | y: f64}, |
+-------+ +----> | {w: f64, |
| h: f64}) |
+---------------+
~~~
@ -449,16 +449,16 @@ Stack Memory
+-------+ +---------------+
| shape | ------> | circle( |
+-------+ | {x: float, |
| size | -+ | y: float}, |
+-------+ +----> | float) |
+-------+ | {x: f64, |
| size | -+ | y: f64}, |
+-------+ +----> | f64) |
| |
+---------------+
~~~
As you can see, the `size` pointer would be pointing at a `float`
As you can see, the `size` pointer would be pointing at a `f64`
instead of a struct. This is not good: dereferencing the second field
of a `float` as if it were a struct with two fields would be a memory
of a `f64` as if it were a struct with two fields would be a memory
safety violation.
So, in fact, for every `ref` binding, the compiler will impose the
@ -484,13 +484,13 @@ as we'll see, doing so requires some explicit annotation.
For example, we could write a subroutine like this:
~~~
struct Point {x: float, y: float}
fn get_x<'r>(p: &'r Point) -> &'r float { &p.x }
struct Point {x: f64, y: f64}
fn get_x<'r>(p: &'r Point) -> &'r f64 { &p.x }
~~~
Here, the function `get_x()` returns a pointer into the structure it
was given. The type of the parameter (`&'r Point`) and return type
(`&'r float`) both use a new syntactic form that we have not seen so
(`&'r f64`) both use a new syntactic form that we have not seen so
far. Here the identifier `r` names the lifetime of the pointer
explicitly. So in effect, this function declares that it takes a
pointer with lifetime `r` and returns a pointer with that same
@ -525,8 +525,8 @@ To emphasize this point, let’s look at a variation on the example, this
time one that does not compile:
~~~ {.xfail-test}
struct Point {x: float, y: float}
fn get_x_sh(p: @Point) -> &float {
struct Point {x: f64, y: f64}
fn get_x_sh(p: @Point) -> &f64 {
&p.x // Error reported here
}
~~~
@ -564,14 +564,14 @@ for grouping of parameters by lifetime. For example, consider this
function:
~~~
# struct Point {x: float, y: float}; // as before
# struct Size {w: float, h: float}; // as before
# struct Point {x: f64, y: f64}; // as before
# struct Size {w: f64, h: f64}; // as before
# enum Shape {
# Circle(Point, float), // origin, radius
# Circle(Point, f64), // origin, radius
# Rectangle(Point, Size) // upper-left, dimensions
# }
# fn compute_area(shape: &Shape) -> float { 0f }
fn select<'r, T>(shape: &'r Shape, threshold: float,
# fn compute_area(shape: &Shape) -> f64 { 0.0 }
fn select<'r, T>(shape: &'r Shape, threshold: f64,
a: &'r T, b: &'r T) -> &'r T {
if compute_area(shape) > threshold {a} else {b}
}
@ -584,20 +584,20 @@ region parameters*. This may be overly conservative, as in this
example:
~~~
# struct Point {x: float, y: float}; // as before
# struct Size {w: float, h: float}; // as before
# struct Point {x: f64, y: f64}; // as before
# struct Size {w: f64, h: f64}; // as before
# enum Shape {
# Circle(Point, float), // origin, radius
# Circle(Point, f64), // origin, radius
# Rectangle(Point, Size) // upper-left, dimensions
# }
# fn compute_area(shape: &Shape) -> float { 0f }
# fn select<'r, T>(shape: &Shape, threshold: float,
# fn compute_area(shape: &Shape) -> f64 { 0.0 }
# fn select<'r, T>(shape: &Shape, threshold: f64,
# a: &'r T, b: &'r T) -> &'r T {
# if compute_area(shape) > threshold {a} else {b}
# }
// -+ r
fn select_based_on_unit_circle<'r, T>( // |-+ B
threshold: float, a: &'r T, b: &'r T) -> &'r T { // | |
threshold: f64, a: &'r T, b: &'r T) -> &'r T { // | |
// | |
let shape = Circle(Point {x: 0., y: 0.}, 1.); // | |
select(&shape, threshold, a, b) // | |
@ -621,14 +621,14 @@ the latter two. After all, the first parameter is not being
returned. Here is how the new `select()` might look:
~~~
# struct Point {x: float, y: float}; // as before
# struct Size {w: float, h: float}; // as before
# struct Point {x: f64, y: f64}; // as before
# struct Size {w: f64, h: f64}; // as before
# enum Shape {
# Circle(Point, float), // origin, radius
# Circle(Point, f64), // origin, radius
# Rectangle(Point, Size) // upper-left, dimensions
# }
# fn compute_area(shape: &Shape) -> float { 0f }
fn select<'r, 'tmp, T>(shape: &'tmp Shape, threshold: float,
# fn compute_area(shape: &Shape) -> f64 { 0.0 }
fn select<'r, 'tmp, T>(shape: &'tmp Shape, threshold: f64,
a: &'r T, b: &'r T) -> &'r T {
if compute_area(shape) > threshold {a} else {b}
}
@ -640,14 +640,14 @@ However, since the lifetime `tmp` is not returned, it would be more
concise to just omit the named lifetime for `shape` altogether:
~~~
# struct Point {x: float, y: float}; // as before
# struct Size {w: float, h: float}; // as before
# struct Point {x: f64, y: f64}; // as before
# struct Size {w: f64, h: f64}; // as before
# enum Shape {
# Circle(Point, float), // origin, radius
# Circle(Point, f64), // origin, radius
# Rectangle(Point, Size) // upper-left, dimensions
# }
# fn compute_area(shape: &Shape) -> float { 0f }
fn select<'r, T>(shape: &Shape, threshold: float,
# fn compute_area(shape: &Shape) -> f64 { 0.0 }
fn select<'r, T>(shape: &Shape, threshold: f64,
a: &'r T, b: &'r T) -> &'r T {
if compute_area(shape) > threshold {a} else {b}
}

16
doc/tutorial-tasks.md
View File

@ -331,12 +331,12 @@ a single large vector of floats. Each task needs the full vector to perform its
# use std::rand;
use extra::arc::Arc;
fn pnorm(nums: &~[float], p: uint) -> float {
nums.iter().fold(0.0, |a,b| a+(*b).pow(&(p as float)) ).pow(&(1f / (p as float)))
fn pnorm(nums: &~[f64], p: uint) -> f64 {
nums.iter().fold(0.0, |a,b| a+(*b).pow(&(p as f64)) ).pow(&(1.0 / (p as f64)))
}
fn main() {
let numbers = vec::from_fn(1000000, |_| rand::random::<float>());
let numbers = vec::from_fn(1000000, |_| rand::random::<f64>());
println!("Inf-norm = {}", *numbers.iter().max().unwrap());
let numbers_arc = Arc::new(numbers);
@ -346,7 +346,7 @@ fn main() {
chan.send(numbers_arc.clone());
do spawn {
let local_arc : Arc<~[float]> = port.recv();
let local_arc : Arc<~[f64]> = port.recv();
let task_numbers = local_arc.get();
println!("{}-norm = {}", num, pnorm(task_numbers, num));
}
@ -361,7 +361,7 @@ created by the line
# use extra::arc::Arc;
# use std::vec;
# use std::rand;
# let numbers = vec::from_fn(1000000, |_| rand::random::<float>());
# let numbers = vec::from_fn(1000000, |_| rand::random::<f64>());
let numbers_arc=Arc::new(numbers);
~~~
and a clone of it is sent to each task
@ -369,7 +369,7 @@ and a clone of it is sent to each task
# use extra::arc::Arc;
# use std::vec;
# use std::rand;
# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
# let numbers=vec::from_fn(1000000, |_| rand::random::<f64>());
# let numbers_arc = Arc::new(numbers);
# let (port, chan) = stream();
chan.send(numbers_arc.clone());
@ -381,11 +381,11 @@ Each task recovers the underlying data by
# use extra::arc::Arc;
# use std::vec;
# use std::rand;
# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
# let numbers=vec::from_fn(1000000, |_| rand::random::<f64>());
# let numbers_arc=Arc::new(numbers);
# let (port, chan) = stream();
# chan.send(numbers_arc.clone());
# let local_arc : Arc<~[float]> = port.recv();
# let local_arc : Arc<~[f64]> = port.recv();
let task_numbers = local_arc.get();
~~~
and can use it as if it were local.

208
doc/tutorial.md
View File

@ -235,13 +235,13 @@ can specify a variable's type by following it with a colon, then the type
name. Static items, on the other hand, always require a type annotation.
~~~~
static MONSTER_FACTOR: float = 57.8;
static MONSTER_FACTOR: f64 = 57.8;
let monster_size = MONSTER_FACTOR * 10.0;
let monster_size: int = 50;
~~~~
Local variables may shadow earlier declarations, as in the previous example:
`monster_size` was first declared as a `float`, and then a second
`monster_size` was first declared as a `f64`, and then a second
`monster_size` was declared as an `int`. If you were to actually compile this
example, though, the compiler would determine that the first `monster_size` is
unused and issue a warning (because this situation is likely to indicate a
@ -341,10 +341,10 @@ let c = 100u; // c is a uint
let d = 1000i32; // d is an i32
~~~~
There are three floating-point types: `float`, `f32`, and `f64`.
There are two floating-point types: `f32`, and `f64`.
Floating-point numbers are written `0.0`, `1e6`, or `2.1e-4`.
Like integers, floating-point literals are inferred to the correct type.
Suffixes `f`, `f32`, and `f64` can be used to create literals of a specific type.
Suffixes ``f32`, and `f64` can be used to create literals of a specific type.
The keywords `true` and `false` produce literals of type `bool`.
@ -377,7 +377,7 @@ if a meaningful conversion exists, convert the result of the
expression to the given type.
~~~~
let x: float = 4.0;
let x: f64 = 4.0;
let y: uint = x as uint;
assert!(y == 4u);
~~~~
@ -496,25 +496,25 @@ A powerful application of pattern matching is *destructuring*:
matching in order to bind names to the contents of data
types.
> ***Note:*** The following code makes use of tuples (`(float, float)`) which
> ***Note:*** The following code makes use of tuples (`(f64, f64)`) which
> are explained in section 5.3. For now you can think of tuples as a list of
> items.
~~~~
use std::float;
use std::f64;
use std::num::atan;
fn angle(vector: (float, float)) -> float {
let pi = float::consts::pi;
fn angle(vector: (f64, f64)) -> f64 {
let pi = f64::consts::pi;
match vector {
(0f, y) if y < 0f => 1.5 * pi,
(0f, y) => 0.5 * pi,
(0.0, y) if y < 0.0 => 1.5 * pi,
(0.0, y) => 0.5 * pi,
(x, y) => atan(y / x)
}
}
~~~~
A variable name in a pattern matches any value, *and* binds that name
to the value of the matched value inside of the arm's action. Thus, `(0f,
to the value of the matched value inside of the arm's action. Thus, `(0.0,
y)` matches any tuple whose first element is zero, and binds `y` to
the second element. `(x, y)` matches any two-element tuple, and binds both
elements to variables.
@ -583,8 +583,8 @@ operator to access struct fields, as in `mypoint.x`.
~~~~
struct Point {
x: float,
y: float
x: f64,
y: f64
}
~~~~
@ -597,7 +597,7 @@ With a value (say, `mypoint`) of such a type in a mutable location, you can do
struct without inherited mutability would result in a type error.
~~~~ {.xfail-test}
# struct Point { x: float, y: float }
# struct Point { x: f64, y: f64 }
let mut mypoint = Point { x: 1.0, y: 1.0 };
let origin = Point { x: 0.0, y: 0.0 };
@ -609,7 +609,7 @@ origin.y += 1.0; // ERROR: assigning to immutable field
`Name { fieldname: pattern, ... }`:
~~~~
# struct Point { x: float, y: float }
# struct Point { x: f64, y: f64 }
# let mypoint = Point { x: 0.0, y: 0.0 };
match mypoint {
Point { x: 0.0, y: yy } => { println(yy.to_str()); }
@ -625,7 +625,7 @@ Additionally, struct fields have a shorthand matching form that simply
reuses the field name as the binding name.
~~~
# struct Point { x: float, y: float }
# struct Point { x: f64, y: f64 }
# let mypoint = Point { x: 0.0, y: 0.0 };
match mypoint {
Point { x, _ } => { println(x.to_str()) }
@ -638,15 +638,15 @@ Enums are datatypes that have several alternate representations. For
example, consider the type shown earlier:
~~~~
# struct Point { x: float, y: float }
# struct Point { x: f64, y: f64 }
enum Shape {
Circle(Point, float),
Circle(Point, f64),
Rectangle(Point, Point)
}
~~~~
A value of this type is either a `Circle`, in which case it contains a
`Point` struct and a float, or a `Rectangle`, in which case it contains
`Point` struct and a f64, or a `Rectangle`, in which case it contains
two `Point` structs. The run-time representation of such a value
includes an identifier of the actual form that it holds, much like the
"tagged union" pattern in C, but with better static guarantees.
@ -654,7 +654,7 @@ includes an identifier of the actual form that it holds, much like the
The above declaration will define a type `Shape` that can refer to
such shapes, and two functions, `Circle` and `Rectangle`, which can be
used to construct values of the type (taking arguments of the
specified types). So `Circle(Point { x: 0f, y: 0f }, 10f)` is the way to
specified types). So `Circle(Point { x: 0.0, y: 0.0 }, 10.0)` is the way to
create a new circle.
Enum variants need not have parameters. This `enum` declaration,
@ -697,12 +697,12 @@ get at their contents. All variant constructors can be used as
patterns, as in this definition of `area`:
~~~~
use std::float;
# struct Point {x: float, y: float}
# enum Shape { Circle(Point, float), Rectangle(Point, Point) }
fn area(sh: Shape) -> float {
use std::f64;
# struct Point {x: f64, y: f64}
# enum Shape { Circle(Point, f64), Rectangle(Point, Point) }
fn area(sh: Shape) -> f64 {
match sh {
Circle(_, size) => float::consts::pi * size * size,
Circle(_, size) => f64::consts::pi * size * size,
Rectangle(Point { x, y }, Point { x: x2, y: y2 }) => (x2 - x) * (y2 - y)
}
}
@ -714,14 +714,14 @@ introduction form, nullary enum patterns are written without
parentheses.
~~~~
# struct Point { x: float, y: float }
# struct Point { x: f64, y: f64 }
# enum Direction { North, East, South, West }
fn point_from_direction(dir: Direction) -> Point {
match dir {
North => Point { x: 0f, y: 1f },
East => Point { x: 1f, y: 0f },
South => Point { x: 0f, y: -1f },
West => Point { x: -1f, y: 0f }
North => Point { x: 0.0, y: 1.0 },
East => Point { x: 1.0, y: 0.0 },
South => Point { x: 0.0, y: -1.0 },
West => Point { x: -1.0, y: 0.0 }
}
}
~~~~
@ -729,16 +729,16 @@ fn point_from_direction(dir: Direction) -> Point {
Enum variants may also be structs. For example:
~~~~
use std::float;
# struct Point { x: float, y: float }
# fn square(x: float) -> float { x * x }
use std::f64;
# struct Point { x: f64, y: f64 }
# fn square(x: f64) -> f64 { x * x }
enum Shape {
Circle { center: Point, radius: float },
Circle { center: Point, radius: f64 },
Rectangle { top_left: Point, bottom_right: Point }
}
fn area(sh: Shape) -> float {
fn area(sh: Shape) -> f64 {
match sh {
Circle { radius: radius, _ } => float::consts::pi * square(radius),
Circle { radius: radius, _ } => f64::consts::pi * square(radius),
Rectangle { top_left: top_left, bottom_right: bottom_right } => {
(bottom_right.x - top_left.x) * (top_left.y - bottom_right.y)
}
@ -754,7 +754,7 @@ Tuples can have any arity except for 0 (though you may consider
unit, `()`, as the empty tuple if you like).
~~~~
let mytup: (int, int, float) = (10, 20, 30.0);
let mytup: (int, int, f64) = (10, 20, 30.0);
match mytup {
(a, b, c) => info2!("{}", a + b + (c as int))
}
@ -769,7 +769,7 @@ names.
For example:
~~~~
struct MyTup(int, int, float);
struct MyTup(int, int, f64);
let mytup: MyTup = MyTup(10, 20, 30.0);
match mytup {
MyTup(a, b, c) => info2!("{}", a + b + (c as int))
@ -862,7 +862,7 @@ pattern destructuring. Like `let`, argument patterns must be irrefutable,
as in this example that unpacks the first value from a tuple and returns it.
~~~
fn first((value, _): (int, float)) -> int { value }
fn first((value, _): (int, f64)) -> int { value }
~~~
# Destructors
@ -1074,8 +1074,8 @@ As an example, consider a simple struct type, `Point`:
~~~
struct Point {
x: float,
y: float
x: f64,
y: f64
}
~~~~
@ -1084,7 +1084,7 @@ ways. For example, in this code, each of these three local variables
contains a point, but allocated in a different location:
~~~
# struct Point { x: float, y: float }
# struct Point { x: f64, y: f64 }
let on_the_stack : Point = Point { x: 3.0, y: 4.0 };
let managed_box : @Point = @Point { x: 5.0, y: 1.0 };
let owned_box : ~Point = ~Point { x: 7.0, y: 9.0 };
@ -1101,9 +1101,9 @@ bad, but often copies are expensive. So we’d like to define a function
that takes the points by pointer. We can use borrowed pointers to do this:
~~~
# struct Point { x: float, y: float }
# fn sqrt(f: float) -> float { 0f }
fn compute_distance(p1: &Point, p2: &Point) -> float {
# struct Point { x: f64, y: f64 }
# fn sqrt(f: f64) -> f64 { 0.0 }
fn compute_distance(p1: &Point, p2: &Point) -> f64 {
let x_d = p1.x - p2.x;
let y_d = p1.y - p2.y;
sqrt(x_d * x_d + y_d * y_d)
@ -1113,11 +1113,11 @@ fn compute_distance(p1: &Point, p2: &Point) -> float {
Now we can call `compute_distance()` in various ways:
~~~
# struct Point{ x: float, y: float };
# struct Point{ x: f64, y: f64 };
# let on_the_stack : Point = Point { x: 3.0, y: 4.0 };
# let managed_box : @Point = @Point { x: 5.0, y: 1.0 };
# let owned_box : ~Point = ~Point { x: 7.0, y: 9.0 };
# fn compute_distance(p1: &Point, p2: &Point) -> float { 0f }
# fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 }
compute_distance(&on_the_stack, managed_box);
compute_distance(managed_box, owned_box);
~~~
@ -1211,11 +1211,11 @@ dot operator used for field and method access. This precedence order
can sometimes make code awkward and parenthesis-filled.
~~~
# struct Point { x: float, y: float }
# struct Point { x: f64, y: f64 }
# enum Shape { Rectangle(Point, Point) }
# impl Shape { fn area(&self) -> int { 0 } }
let start = @Point { x: 10f, y: 20f };
let end = ~Point { x: (*start).x + 100f, y: (*start).y + 100f };
let start = @Point { x: 10.0, y: 20.0 };
let end = ~Point { x: (*start).x + 100.0, y: (*start).y + 100.0 };
let rect = &Rectangle(*start, *end);
let area = (*rect).area();
~~~
@ -1225,11 +1225,11 @@ dereferencing_ to the receiver (the value on the left-hand side of the
dot), so in most cases, explicitly dereferencing the receiver is not necessary.
~~~
# struct Point { x: float, y: float }
# struct Point { x: f64, y: f64 }
# enum Shape { Rectangle(Point, Point) }
# impl Shape { fn area(&self) -> int { 0 } }
let start = @Point { x: 10f, y: 20f };
let end = ~Point { x: start.x + 100f, y: start.y + 100f };
let start = @Point { x: 10.0, y: 20.0 };
let end = ~Point { x: start.x + 100.0, y: start.y + 100.0 };
let rect = &Rectangle(*start, *end);
let area = rect.area();
~~~
@ -1239,8 +1239,8 @@ automatically. For example, if you feel inclined, you could write
something silly like
~~~
# struct Point { x: float, y: float }
let point = &@~Point { x: 10f, y: 20f };
# struct Point { x: f64, y: f64 }
let point = &@~Point { x: 10.0, y: 20.0 };
println!("{:f}", point.x);
~~~
@ -1601,15 +1601,15 @@ methods on most Rust types, including structs and enums.
As an example, let's define a `draw` method on our `Shape` enum.
~~~
# fn draw_circle(p: Point, f: float) { }
# fn draw_circle(p: Point, f: f64) { }
# fn draw_rectangle(p: Point, p: Point) { }
struct Point {
x: float,
y: float
x: f64,
y: f64
}
enum Shape {
Circle(Point, float),
Circle(Point, f64),
Rectangle(Point, Point)
}
@ -1622,7 +1622,7 @@ impl Shape {
}
}
let s = Circle(Point { x: 1f, y: 2f }, 3f);
let s = Circle(Point { x: 1.0, y: 2.0 }, 3.0);
s.draw();
~~~
@ -1636,11 +1636,11 @@ or a pointer thereof. As an argument it is written either `self`,
A caller must in turn have a compatible pointer type to call the method.
~~~
# fn draw_circle(p: Point, f: float) { }
# fn draw_circle(p: Point, f: f64) { }
# fn draw_rectangle(p: Point, p: Point) { }
# struct Point { x: float, y: float }
# struct Point { x: f64, y: f64 }
# enum Shape {
# Circle(Point, float),
# Circle(Point, f64),
# Rectangle(Point, Point)
# }
impl Shape {
@ -1650,7 +1650,7 @@ impl Shape {
fn draw_value(self) { ... }
}
let s = Circle(Point { x: 1f, y: 2f }, 3f);
let s = Circle(Point { x: 1.0, y: 2.0 }, 3.0);
(@s).draw_managed();
(~s).draw_owned();
@ -1663,11 +1663,11 @@ so the compiler will go to great lengths to convert a callee
to a borrowed pointer.
~~~
# fn draw_circle(p: Point, f: float) { }
# fn draw_circle(p: Point, f: f64) { }
# fn draw_rectangle(p: Point, p: Point) { }
# struct Point { x: float, y: float }
# struct Point { x: f64, y: f64 }
# enum Shape {
# Circle(Point, float),
# Circle(Point, f64),
# Rectangle(Point, Point)
# }
# impl Shape {
@ -1676,7 +1676,7 @@ to a borrowed pointer.
# fn draw_owned(~self) { ... }
# fn draw_value(self) { ... }
# }
# let s = Circle(Point { x: 1f, y: 2f }, 3f);
# let s = Circle(Point { x: 1.0, y: 2.0 }, 3.0);
// As with typical function arguments, managed and owned pointers
// are automatically converted to borrowed pointers
@ -1700,18 +1700,18 @@ These methods are the preferred way to define constructor functions.
~~~~ {.xfail-test}
impl Circle {
fn area(&self) -> float { ... }
fn new(area: float) -> Circle { ... }
fn area(&self) -> f64 { ... }
fn new(area: f64) -> Circle { ... }
}
~~~~
To call such a method, just prefix it with the type name and a double colon:
~~~~
use std::float::consts::pi;
struct Circle { radius: float }
use std::f64::consts::pi;
struct Circle { radius: f64 }
impl Circle {
fn new(area: float) -> Circle { Circle { radius: (area / pi).sqrt() } }
fn new(area: f64) -> Circle { Circle { radius: (area / pi).sqrt() } }
}
let c = Circle::new(42.5);
~~~~
@ -1777,9 +1777,9 @@ combination of arguments of the appropriate types. The usual way is to write
a function that returns `Option<T>` instead of `T`.
~~~~
# struct Point { x: float, y: float }
# enum Shape { Circle(Point, float), Rectangle(Point, Point) }
fn radius(shape: Shape) -> Option<float> {
# struct Point { x: f64, y: f64 }
# enum Shape { Circle(Point, f64), Rectangle(Point, Point) }
fn radius(shape: Shape) -> Option<f64> {
match shape {
Circle(_, radius) => Some(radius),
Rectangle(*) => None
@ -1986,16 +1986,16 @@ name and a double colon. The compiler uses type inference to decide which
implementation to use.
~~~~
use std::float::consts::pi;
trait Shape { fn new(area: float) -> Self; }
struct Circle { radius: float }
struct Square { length: float }
use std::f64::consts::pi;
trait Shape { fn new(area: f64) -> Self; }
struct Circle { radius: f64 }
struct Square { length: f64 }
impl Shape for Circle {
fn new(area: float) -> Circle { Circle { radius: (area / pi).sqrt() } }
fn new(area: f64) -> Circle { Circle { radius: (area / pi).sqrt() } }
}
impl Shape for Square {
fn new(area: float) -> Square { Square { length: (area).sqrt() } }
fn new(area: f64) -> Square { Square { length: (area).sqrt() } }
}
let area = 42.5;
@ -2159,24 +2159,24 @@ For example,
we can define a `Circle` trait that inherits from `Shape`.
~~~~
trait Shape { fn area(&self) -> float; }
trait Circle : Shape { fn radius(&self) -> float; }
trait Shape { fn area(&self) -> f64; }
trait Circle : Shape { fn radius(&self) -> f64; }
~~~~
Now, we can implement `Circle` on a type only if we also implement `Shape`.
~~~~
use std::float::consts::pi;
# trait Shape { fn area(&self) -> float; }
# trait Circle : Shape { fn radius(&self) -> float; }
# struct Point { x: float, y: float }
# fn square(x: float) -> float { x * x }
struct CircleStruct { center: Point, radius: float }
use std::f64::consts::pi;
# trait Shape { fn area(&self) -> f64; }
# trait Circle : Shape { fn radius(&self) -> f64; }
# struct Point { x: f64, y: f64 }
# fn square(x: f64) -> f64 { x * x }
struct CircleStruct { center: Point, radius: f64 }
impl Circle for CircleStruct {
fn radius(&self) -> float { (self.area() / pi).sqrt() }
fn radius(&self) -> f64 { (self.area() / pi).sqrt() }
}
impl Shape for CircleStruct {
fn area(&self) -> float { pi * square(self.radius) }
fn area(&self) -> f64 { pi * square(self.radius) }
}
~~~~
@ -2190,9 +2190,9 @@ methods of the supertrait may be called on values of subtrait-bound type paramet
Refering to the previous example of `trait Circle : Shape`:
~~~
# trait Shape { fn area(&self) -> float; }
# trait Circle : Shape { fn radius(&self) -> float; }
fn radius_times_area<T: Circle>(c: T) -> float {
# trait Shape { fn area(&self) -> f64; }
# trait Circle : Shape { fn radius(&self) -> f64; }
fn radius_times_area<T: Circle>(c: T) -> f64 {
// `c` is both a Circle and a Shape
c.radius() * c.area()
}
@ -2201,13 +2201,13 @@ fn radius_times_area<T: Circle>(c: T) -> float {
Likewise, supertrait methods may also be called on trait objects.
~~~ {.xfail-test}
use std::float::consts::pi;
# trait Shape { fn area(&self) -> float; }
# trait Circle : Shape { fn radius(&self) -> float; }
# struct Point { x: float, y: float }
# struct CircleStruct { center: Point, radius: float }
# impl Circle for CircleStruct { fn radius(&self) -> float { (self.area() / pi).sqrt() } }
# impl Shape for CircleStruct { fn area(&self) -> float { pi * square(self.radius) } }
use std::f64::consts::pi;
# trait Shape { fn area(&self) -> f64; }
# trait Circle : Shape { fn radius(&self) -> f64; }
# struct Point { x: f64, y: f64 }
# struct CircleStruct { center: Point, radius: f64 }
# impl Circle for CircleStruct { fn radius(&self) -> f64 { (self.area() / pi).sqrt() } }
# impl Shape for CircleStruct { fn area(&self) -> f64 { pi * square(self.radius) } }
let concrete = @CircleStruct{center:Point{x:3f,y:4f},radius:5f};
let mycircle: @Circle = concrete as @Circle;
@ -2227,7 +2227,7 @@ of type `ABC` can be randomly generated and converted to a string:
~~~
#[deriving(Eq)]
struct Circle { radius: float }
struct Circle { radius: f64 }
#[deriving(Rand, ToStr)]
enum ABC { A, B, C }

9
src/libextra/ebml.rs
View File

@ -422,10 +422,6 @@ pub mod reader {
let bits = doc_as_u32(self.next_doc(EsF32));
unsafe { transmute(bits) }
}
fn read_float(&mut self) -> float {
let bits = doc_as_u64(self.next_doc(EsFloat));
(unsafe { transmute::<u64, f64>(bits) }) as float
}
fn read_char(&mut self) -> char {
char::from_u32(doc_as_u32(self.next_doc(EsChar))).unwrap()
}
@ -839,11 +835,6 @@ pub mod writer {
let bits = unsafe { cast::transmute(v) };
self.wr_tagged_u32(EsF32 as uint, bits);
}
fn emit_float(&mut self, v: float) {
let bits = unsafe { cast::transmute(v as f64) };
self.wr_tagged_u64(EsFloat as uint, bits);
}
fn emit_char(&mut self, v: char) {
self.wr_tagged_u32(EsChar as uint, v as u32);
}

2
src/libextra/flate.rs
View File

@ -127,7 +127,7 @@ mod tests {
let out = inflate_bytes(cmp);
debug2!("{} bytes deflated to {} ({:.1f}% size)",
input.len(), cmp.len(),
100.0 * ((cmp.len() as float) / (input.len() as float)));
100.0 * ((cmp.len() as f64) / (input.len() as f64)));
assert_eq!(input, out);
}
}

211
src/libextra/json.rs
View File

@ -18,10 +18,11 @@
use std::char;
use std::cast::transmute;
use std::float;
use std::f64;
use std::hashmap::HashMap;
use std::io::WriterUtil;
use std::io;
use std::num;
use std::str;
use std::to_str;
@ -32,7 +33,7 @@ use treemap::TreeMap;
/// Represents a json value
#[deriving(Clone, Eq)]
pub enum Json {
Number(float),
Number(f64),
String(~str),
Boolean(bool),
List(List),
@ -99,17 +100,17 @@ pub fn Encoder(wr: @io::Writer) -> Encoder {
impl serialize::Encoder for Encoder {
fn emit_nil(&mut self) { self.wr.write_str("null") }
fn emit_uint(&mut self, v: uint) { self.emit_float(v as float); }
fn emit_u64(&mut self, v: u64) { self.emit_float(v as float); }
fn emit_u32(&mut self, v: u32) { self.emit_float(v as float); }
fn emit_u16(&mut self, v: u16) { self.emit_float(v as float); }
fn emit_u8(&mut self, v: u8) { self.emit_float(v as float); }
fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); }
fn emit_u64(&mut self, v: u64) { self.emit_f64(v as f64); }
fn emit_u32(&mut self, v: u32) { self.emit_f64(v as f64); }
fn emit_u16(&mut self, v: u16) { self.emit_f64(v as f64); }
fn emit_u8(&mut self, v: u8) { self.emit_f64(v as f64); }
fn emit_int(&mut self, v: int) { self.emit_float(v as float); }
fn emit_i64(&mut self, v: i64) { self.emit_float(v as float); }
fn emit_i32(&mut self, v: i32) { self.emit_float(v as float); }
fn emit_i16(&mut self, v: i16) { self.emit_float(v as float); }
fn emit_i8(&mut self, v: i8) { self.emit_float(v as float); }
fn emit_int(&mut self, v: int) { self.emit_f64(v as f64); }
fn emit_i64(&mut self, v: i64) { self.emit_f64(v as f64); }
fn emit_i32(&mut self, v: i32) { self.emit_f64(v as f64); }
fn emit_i16(&mut self, v: i16) { self.emit_f64(v as f64); }
fn emit_i8(&mut self, v: i8) { self.emit_f64(v as f64); }
fn emit_bool(&mut self, v: bool) {
if v {
@ -119,11 +120,8 @@ impl serialize::Encoder for Encoder {
}
}
fn emit_f64(&mut self, v: f64) { self.emit_float(v as float); }
fn emit_f32(&mut self, v: f32) { self.emit_float(v as float); }
fn emit_float(&mut self, v: float) {
self.wr.write_str(float::to_str_digits(v, 6u));
}
fn emit_f64(&mut self, v: f64) { self.wr.write_str(f64::to_str_digits(v, 6u)) }
fn emit_f32(&mut self, v: f32) { self.emit_f64(v as f64); }
fn emit_char(&mut self, v: char) { self.emit_str(str::from_char(v)) }
fn emit_str(&mut self, v: &str) { self.wr.write_str(escape_str(v)) }
@ -260,17 +258,17 @@ pub fn PrettyEncoder(wr: @io::Writer) -> PrettyEncoder {
impl serialize::Encoder for PrettyEncoder {
fn emit_nil(&mut self) { self.wr.write_str("null") }
fn emit_uint(&mut self, v: uint) { self.emit_float(v as float); }
fn emit_u64(&mut self, v: u64) { self.emit_float(v as float); }
fn emit_u32(&mut self, v: u32) { self.emit_float(v as float); }
fn emit_u16(&mut self, v: u16) { self.emit_float(v as float); }
fn emit_u8(&mut self, v: u8) { self.emit_float(v as float); }
fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); }
fn emit_u64(&mut self, v: u64) { self.emit_f64(v as f64); }
fn emit_u32(&mut self, v: u32) { self.emit_f64(v as f64); }
fn emit_u16(&mut self, v: u16) { self.emit_f64(v as f64); }
fn emit_u8(&mut self, v: u8) { self.emit_f64(v as f64); }
fn emit_int(&mut self, v: int) { self.emit_float(v as float); }
fn emit_i64(&mut self, v: i64) { self.emit_float(v as float); }
fn emit_i32(&mut self, v: i32) { self.emit_float(v as float); }
fn emit_i16(&mut self, v: i16) { self.emit_float(v as float); }
fn emit_i8(&mut self, v: i8) { self.emit_float(v as float); }
fn emit_int(&mut self, v: int) { self.emit_f64(v as f64); }
fn emit_i64(&mut self, v: i64) { self.emit_f64(v as f64); }
fn emit_i32(&mut self, v: i32) { self.emit_f64(v as f64); }
fn emit_i16(&mut self, v: i16) { self.emit_f64(v as f64); }
fn emit_i8(&mut self, v: i8) { self.emit_f64(v as f64); }
fn emit_bool(&mut self, v: bool) {
if v {
@ -280,11 +278,8 @@ impl serialize::Encoder for PrettyEncoder {
}
}
fn emit_f64(&mut self, v: f64) { self.emit_float(v as float); }
fn emit_f32(&mut self, v: f32) { self.emit_float(v as float); }
fn emit_float(&mut self, v: float) {
self.wr.write_str(float::to_str_digits(v, 6u));
}
fn emit_f64(&mut self, v: f64) { self.wr.write_str(f64::to_str_digits(v, 6u)) }
fn emit_f32(&mut self, v: f32) { self.emit_f64(v as f64); }
fn emit_char(&mut self, v: char) { self.emit_str(str::from_char(v)) }
fn emit_str(&mut self, v: &str) { self.wr.write_str(escape_str(v)); }
@ -585,11 +580,11 @@ impl<T : Iterator<char>> Parser<T> {
}
fn parse_number(&mut self) -> Result<Json, Error> {
let mut neg = 1f;
let mut neg = 1.0;
if self.ch == '-' {
self.bump();
neg = -1f;
neg = -1.0;
}
let mut res = match self.parse_integer() {
@ -614,8 +609,8 @@ impl<T : Iterator<char>> Parser<T> {
Ok(Number(neg * res))
}
fn parse_integer(&mut self) -> Result<float, Error> {
let mut res = 0f;
fn parse_integer(&mut self) -> Result<f64, Error> {
let mut res = 0.0;
match self.ch {
'0' => {
@ -631,8 +626,8 @@ impl<T : Iterator<char>> Parser<T> {
while !self.eof() {
match self.ch {
'0' .. '9' => {
res *= 10f;
res += ((self.ch as int) - ('0' as int)) as float;
res *= 10.0;
res += ((self.ch as int) - ('0' as int)) as f64;
self.bump();
}
@ -646,7 +641,7 @@ impl<T : Iterator<char>> Parser<T> {
Ok(res)
}
fn parse_decimal(&mut self, res: float) -> Result<float, Error> {
fn parse_decimal(&mut self, res: f64) -> Result<f64, Error> {
self.bump();
// Make sure a digit follows the decimal place.
@ -656,12 +651,12 @@ impl<T : Iterator<char>> Parser<T> {
}
let mut res = res;
let mut dec = 1f;
let mut dec = 1.0;
while !self.eof() {
match self.ch {
'0' .. '9' => {
dec /= 10f;
res += (((self.ch as int) - ('0' as int)) as float) * dec;
dec /= 10.0;
res += (((self.ch as int) - ('0' as int)) as f64) * dec;
self.bump();
}
@ -672,7 +667,7 @@ impl<T : Iterator<char>> Parser<T> {
Ok(res)
}
fn parse_exponent(&mut self, mut res: float) -> Result<float, Error> {
fn parse_exponent(&mut self, mut res: f64) -> Result<f64, Error> {
self.bump();
let mut exp = 0u;
@ -702,7 +697,7 @@ impl<T : Iterator<char>> Parser<T> {
}
}
let exp = float::pow_with_uint(10u, exp);
let exp: f64 = num::pow_with_uint(10u, exp);
if neg_exp {
res /= exp;
} else {
@ -892,17 +887,17 @@ impl serialize::Decoder for Decoder {
}
}
fn read_u64(&mut self) -> u64 { self.read_float() as u64 }
fn read_u32(&mut self) -> u32 { self.read_float() as u32 }
fn read_u16(&mut self) -> u16 { self.read_float() as u16 }
fn read_u8 (&mut self) -> u8 { self.read_float() as u8 }
fn read_uint(&mut self) -> uint { self.read_float() as uint }
fn read_u64(&mut self) -> u64 { self.read_f64() as u64 }
fn read_u32(&mut self) -> u32 { self.read_f64() as u32 }
fn read_u16(&mut self) -> u16 { self.read_f64() as u16 }
fn read_u8 (&mut self) -> u8 { self.read_f64() as u8 }
fn read_uint(&mut self) -> uint { self.read_f64() as uint }
fn read_i64(&mut self) -> i64 { self.read_float() as i64 }
fn read_i32(&mut self) -> i32 { self.read_float() as i32 }
fn read_i16(&mut self) -> i16 { self.read_float() as i16 }
fn read_i8 (&mut self) -> i8 { self.read_float() as i8 }
fn read_int(&mut self) -> int { self.read_float() as int }
fn read_i64(&mut self) -> i64 { self.read_f64() as i64 }
fn read_i32(&mut self) -> i32 { self.read_f64() as i32 }
fn read_i16(&mut self) -> i16 { self.read_f64() as i16 }
fn read_i8 (&mut self) -> i8 { self.read_f64() as i8 }
fn read_int(&mut self) -> int { self.read_f64() as int }
fn read_bool(&mut self) -> bool {
debug2!("read_bool");
@ -912,15 +907,15 @@ impl serialize::Decoder for Decoder {
}
}
fn read_f64(&mut self) -> f64 { self.read_float() as f64 }
fn read_f32(&mut self) -> f32 { self.read_float() as f32 }
fn read_float(&mut self) -> float {
debug2!("read_float");
fn read_f64(&mut self) -> f64 {
debug2!("read_f64");
match self.stack.pop() {
Number(f) => f,
value => fail2!("not a number: {:?}", value)
}
}
fn read_f32(&mut self) -> f32 { self.read_f64() as f32 }
fn read_f32(&mut self) -> f32 { self.read_f64() as f32 }
fn read_char(&mut self) -> char {
let mut v = ~[];
@ -1192,55 +1187,51 @@ impl ToJson for @Json {
}
impl ToJson for int {
fn to_json(&self) -> Json { Number(*self as float) }
fn to_json(&self) -> Json { Number(*self as f64) }
}
impl ToJson for i8 {
fn to_json(&self) -> Json { Number(*self as float) }
fn to_json(&self) -> Json { Number(*self as f64) }
}
impl ToJson for i16 {
fn to_json(&self) -> Json { Number(*self as float) }
fn to_json(&self) -> Json { Number(*self as f64) }
}
impl ToJson for i32 {
fn to_json(&self) -> Json { Number(*self as float) }
fn to_json(&self) -> Json { Number(*self as f64) }
}
impl ToJson for i64 {
fn to_json(&self) -> Json { Number(*self as float) }
fn to_json(&self) -> Json { Number(*self as f64) }
}
impl ToJson for uint {
fn to_json(&self) -> Json { Number(*self as float) }
fn to_json(&self) -> Json { Number(*self as f64) }
}
impl ToJson for u8 {
fn to_json(&self) -> Json { Number(*self as float) }
fn to_json(&self) -> Json { Number(*self as f64) }
}
impl ToJson for u16 {
fn to_json(&self) -> Json { Number(*self as float) }
fn to_json(&self) -> Json { Number(*self as f64) }
}
impl ToJson for u32 {
fn to_json(&self) -> Json { Number(*self as float) }
fn to_json(&self) -> Json { Number(*self as f64) }
}
impl ToJson for u64 {
fn to_json(&self) -> Json { Number(*self as float) }
}
impl ToJson for float {
fn to_json(&self) -> Json { Number(*self) }
fn to_json(&self) -> Json { Number(*self as f64) }
}
impl ToJson for f32 {
fn to_json(&self) -> Json { Number(*self as float) }
fn to_json(&self) -> Json { Number(*self as f64) }
}
impl ToJson for f64 {
fn to_json(&self) -> Json { Number(*self as float) }
fn to_json(&self) -> Json { Number(*self) }
}
impl ToJson for () {
@ -1374,17 +1365,17 @@ mod tests {
#[test]
fn test_write_number() {
assert_eq!(Number(3f).to_str(), ~"3");
assert_eq!(Number(3f).to_pretty_str(), ~"3");
assert_eq!(Number(3.0).to_str(), ~"3");
assert_eq!(Number(3.0).to_pretty_str(), ~"3");
assert_eq!(Number(3.1f).to_str(), ~"3.1");
assert_eq!(Number(3.1f).to_pretty_str(), ~"3.1");
assert_eq!(Number(3.1).to_str(), ~"3.1");
assert_eq!(Number(3.1).to_pretty_str(), ~"3.1");
assert_eq!(Number(-1.5f).to_str(), ~"-1.5");
assert_eq!(Number(-1.5f).to_pretty_str(), ~"-1.5");
assert_eq!(Number(-1.5).to_str(), ~"-1.5");
assert_eq!(Number(-1.5).to_pretty_str(), ~"-1.5");
assert_eq!(Number(0.5f).to_str(), ~"0.5");
assert_eq!(Number(0.5f).to_pretty_str(), ~"0.5");
assert_eq!(Number(0.5).to_str(), ~"0.5");
assert_eq!(Number(0.5).to_pretty_str(), ~"0.5");
}
#[test]
@ -1422,7 +1413,7 @@ mod tests {
let longTestList = List(~[
Boolean(false),
Null,
List(~[String(~"foo\nbar"), Number(3.5f)])]);
List(~[String(~"foo\nbar"), Number(3.5)])]);
assert_eq!(longTestList.to_str(),
~"[false,null,[\"foo\\nbar\",3.5]]");
@ -1649,45 +1640,45 @@ mod tests {
assert_eq!(from_str("1e+"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid number"}));
assert_eq!(from_str("3"), Ok(Number(3f)));
assert_eq!(from_str("3.1"), Ok(Number(3.1f)));
assert_eq!(from_str("-1.2"), Ok(Number(-1.2f)));
assert_eq!(from_str("0.4"), Ok(Number(0.4f)));
assert_eq!(from_str("0.4e5"), Ok(Number(0.4e5f)));
assert_eq!(from_str("0.4e+15"), Ok(Number(0.4e15f)));
assert_eq!(from_str("0.4e-01"), Ok(Number(0.4e-01f)));
assert_eq!(from_str(" 3 "), Ok(Number(3f)));
assert_eq!(from_str("3"), Ok(Number(3.0)));
assert_eq!(from_str("3.1"), Ok(Number(3.1)));
assert_eq!(from_str("-1.2"), Ok(Number(-1.2)));
assert_eq!(from_str("0.4"), Ok(Number(0.4)));
assert_eq!(from_str("0.4e5"), Ok(Number(0.4e5)));
assert_eq!(from_str("0.4e+15"), Ok(Number(0.4e15)));
assert_eq!(from_str("0.4e-01"), Ok(Number(0.4e-01)));
assert_eq!(from_str(" 3 "), Ok(Number(3.0)));
}
#[test]
fn test_decode_numbers() {
let mut decoder = Decoder(from_str("3").unwrap());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 3f);
let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 3.0);
let mut decoder = Decoder(from_str("3.1").unwrap());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 3.1f);
let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 3.1);
let mut decoder = Decoder(from_str("-1.2").unwrap());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, -1.2f);
let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, -1.2);
let mut decoder = Decoder(from_str("0.4").unwrap());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4f);
let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4);
let mut decoder = Decoder(from_str("0.4e5").unwrap());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e5f);
let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e5);
let mut decoder = Decoder(from_str("0.4e15").unwrap());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e15f);
let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e15);
let mut decoder = Decoder(from_str("0.4e-01").unwrap());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e-01f);
let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e-01);
}
#[test]
@ -1769,11 +1760,11 @@ mod tests {
assert_eq!(from_str("[ false ]"), Ok(List(~[Boolean(false)])));
assert_eq!(from_str("[null]"), Ok(List(~[Null])));
assert_eq!(from_str("[3, 1]"),
Ok(List(~[Number(3f), Number(1f)])));
Ok(List(~[Number(3.0), Number(1.0)])));
assert_eq!(from_str("\n[3, 2]\n"),
Ok(List(~[Number(3f), Number(2f)])));
Ok(List(~[Number(3.0), Number(2.0)])));
assert_eq!(from_str("[2, [4, 1]]"),
Ok(List(~[Number(2f), List(~[Number(4f), Number(1f)])])));
Ok(List(~[Number(2.0), List(~[Number(4.0), Number(1.0)])])));
}
#[test]
@ -1855,7 +1846,7 @@ mod tests {
assert_eq!(from_str("{}").unwrap(), mk_object([]));
assert_eq!(from_str("{\"a\": 3}").unwrap(),
mk_object([(~"a", Number(3.0f))]));
mk_object([(~"a", Number(3.0))]));
assert_eq!(from_str(
"{ \"a\": null, \"b\" : true }").unwrap(),
@ -1882,7 +1873,7 @@ mod tests {
"]" +
"}").unwrap(),
mk_object([
(~"a", Number(1.0f)),
(~"a", Number(1.0)),
(~"b", List(~[
Boolean(true),
String(~"foo\nbar"),

61
src/libextra/num/complex.rs
View File

@ -30,7 +30,6 @@ pub struct Cmplx<T> {
im: T
}
pub type Complex = Cmplx<float>;
pub type Complex32 = Cmplx<f32>;
pub type Complex64 = Cmplx<f64>;
@ -196,25 +195,25 @@ mod test {
use super::*;
use std::num::{Zero,One,Real};
pub static _0_0i : Complex = Cmplx { re: 0f, im: 0f };
pub static _1_0i : Complex = Cmplx { re: 1f, im: 0f };
pub static _1_1i : Complex = Cmplx { re: 1f, im: 1f };
pub static _0_1i : Complex = Cmplx { re: 0f, im: 1f };
pub static _neg1_1i : Complex = Cmplx { re: -1f, im: 1f };
pub static _05_05i : Complex = Cmplx { re: 0.5f, im: 0.5f };
pub static all_consts : [Complex, .. 5] = [_0_0i, _1_0i, _1_1i, _neg1_1i, _05_05i];
pub static _0_0i : Complex64 = Cmplx { re: 0.0, im: 0.0 };
pub static _1_0i : Complex64 = Cmplx { re: 1.0, im: 0.0 };
pub static _1_1i : Complex64 = Cmplx { re: 1.0, im: 1.0 };
pub static _0_1i : Complex64 = Cmplx { re: 0.0, im: 1.0 };
pub static _neg1_1i : Complex64 = Cmplx { re: -1.0, im: 1.0 };
pub static _05_05i : Complex64 = Cmplx { re: 0.5, im: 0.5 };
pub static all_consts : [Complex64, .. 5] = [_0_0i, _1_0i, _1_1i, _neg1_1i, _05_05i];
#[test]
fn test_consts() {
// check our constants are what Cmplx::new creates
fn test(c : Complex, r : float, i: float) {
fn test(c : Complex64, r : f64, i: f64) {
assert_eq!(c, Cmplx::new(r,i));
}
test(_0_0i, 0f, 0f);
test(_1_0i, 1f, 0f);
test(_1_1i, 1f, 1f);
test(_neg1_1i, -1f, 1f);
test(_05_05i, 0.5f, 0.5f);
test(_0_0i, 0.0, 0.0);
test(_1_0i, 1.0, 0.0);
test(_1_1i, 1.0, 1.0);
test(_neg1_1i, -1.0, 1.0);
test(_05_05i, 0.5, 0.5);
assert_eq!(_0_0i, Zero::zero());
assert_eq!(_1_0i, One::one());
@ -224,23 +223,23 @@ mod test {
#[ignore(cfg(target_arch = "x86"))]
// FIXME #7158: (maybe?) currently failing on x86.
fn test_norm() {
fn test(c: Complex, ns: float) {
fn test(c: Complex64, ns: f64) {
assert_eq!(c.norm_sqr(), ns);
assert_eq!(c.norm(), ns.sqrt())
}
test(_0_0i, 0f);
test(_1_0i, 1f);
test(_1_1i, 2f);
test(_neg1_1i, 2f);
test(_05_05i, 0.5f);
test(_0_0i, 0.0);
test(_1_0i, 1.0);
test(_1_1i, 2.0);
test(_neg1_1i, 2.0);
test(_05_05i, 0.5);
}
#[test]
fn test_scale_unscale() {
assert_eq!(_05_05i.scale(2f), _1_1i);
assert_eq!(_1_1i.unscale(2f), _05_05i);
assert_eq!(_05_05i.scale(2.0), _1_1i);
assert_eq!(_1_1i.unscale(2.0), _05_05i);
for &c in all_consts.iter() {
assert_eq!(c.scale(2f).unscale(2f), c);
assert_eq!(c.scale(2.0).unscale(2.0), c);
}
}
@ -268,18 +267,18 @@ mod test {
#[test]
fn test_arg() {
fn test(c: Complex, arg: float) {
fn test(c: Complex64, arg: f64) {
assert!(c.arg().approx_eq(&arg))
}
test(_1_0i, 0f);
test(_1_1i, 0.25f * Real::pi());
test(_neg1_1i, 0.75f * Real::pi());
test(_05_05i, 0.25f * Real::pi());
test(_1_0i, 0.0);
test(_1_1i, 0.25 * Real::pi());
test(_neg1_1i, 0.75 * Real::pi());
test(_05_05i, 0.25 * Real::pi());
}
#[test]
fn test_polar_conv() {
fn test(c: Complex) {
fn test(c: Complex64) {
let (r, theta) = c.to_polar();
assert!((c - Cmplx::from_polar(&r, &theta)).norm() < 1e-6);
}
@ -316,7 +315,7 @@ mod test {
#[test]
fn test_mul() {
assert_eq!(_05_05i * _05_05i, _0_1i.unscale(2f));
assert_eq!(_05_05i * _05_05i, _0_1i.unscale(2.0));
assert_eq!(_1_1i * _0_1i, _neg1_1i);
// i^2 & i^4
@ -349,7 +348,7 @@ mod test {
#[test]
fn test_to_str() {
fn test(c : Complex, s: ~str) {
fn test(c : Complex64, s: ~str) {
assert_eq!(c.to_str(), s);
}
test(_0_0i, ~"0+0i");

14
src/libextra/serialize.rs
View File

@ -41,7 +41,6 @@ pub trait Encoder {
fn emit_i16(&mut self, v: i16);
fn emit_i8(&mut self, v: i8);
fn emit_bool(&mut self, v: bool);
fn emit_float(&mut self, v: float);
fn emit_f64(&mut self, v: f64);
fn emit_f32(&mut self, v: f32);
fn emit_char(&mut self, v: char);
@ -108,7 +107,6 @@ pub trait Decoder {
fn read_bool(&mut self) -> bool;
fn read_f64(&mut self) -> f64;
fn read_f32(&mut self) -> f32;
fn read_float(&mut self) -> float;
fn read_char(&mut self) -> char;
fn read_str(&mut self) -> ~str;
@ -326,18 +324,6 @@ impl<D:Decoder> Decodable<D> for @str {
}
}
impl<S:Encoder> Encodable<S> for float {
fn encode(&self, s: &mut S) {
s.emit_float(*self)
}
}
impl<D:Decoder> Decodable<D> for float {
fn decode(d: &mut D) -> float {
d.read_float()
}
}
impl<S:Encoder> Encodable<S> for f32 {
fn encode(&self, s: &mut S) {
s.emit_f32(*self)

12
src/libextra/sort.rs
View File

@ -915,13 +915,13 @@ mod test_tim_sort {
#[deriving(Clone)]
struct CVal {
val: float,
val: f64,
}
impl Ord for CVal {
fn lt(&self, other: &CVal) -> bool {
let mut rng = rand::rng();
if rng.gen::<float>() > 0.995 {
if rng.gen::<f64>() > 0.995 {
fail2!("It's happening!!!");
}
(*self).val < other.val
@ -1054,7 +1054,7 @@ mod big_tests {
for i in range(lo, hi) {
let n = 1 << i;
let mut arr: ~[float] = do vec::from_fn(n) |_i| {
let mut arr: ~[f64] = do vec::from_fn(n) |_i| {
rng.gen()
};
@ -1106,7 +1106,7 @@ mod big_tests {
isSorted(arr);
let half = n / 2;
let mut arr = makeRange(half).map(|i| *i as float);
let mut arr = makeRange(half).map(|i| *i as f64);
tim_sort(arr); // !sort
isSorted(arr);
}
@ -1125,7 +1125,7 @@ mod big_tests {
for i in range(lo, hi) {
let n = 1 << i;
let arr: ~[@float] = do vec::from_fn(n) |_i| {
let arr: ~[@f64] = do vec::from_fn(n) |_i| {
@rng.gen()
};
let mut arr = arr;
@ -1178,7 +1178,7 @@ mod big_tests {
isSorted(arr);
let half = n / 2;
let mut arr = makeRange(half).map(|i| @(*i as float));
let mut arr = makeRange(half).map(|i| @(*i as f64));
tim_sort(arr); // !sort
isSorted(arr);
}

20
src/libextra/test.rs
View File

@ -485,14 +485,14 @@ impl ConsoleTestState {
self.out.write_str(*k);
self.out.write_str(": ");
self.write_improved();
self.out.write_line(format!(" by {:.2f}%", pct as float))
self.out.write_line(format!(" by {:.2f}%", pct as f64))
}
Regression(pct) => {
regressed += 1;
self.out.write_str(*k);
self.out.write_str(": ");
self.write_regressed();
self.out.write_line(format!(" by {:.2f}%", pct as float))
self.out.write_line(format!(" by {:.2f}%", pct as f64))
}
}
}
@ -519,7 +519,7 @@ impl ConsoleTestState {
None => (),
Some(pct) =>
self.out.write_str(format!("with noise-tolerance forced to: {}%%\n",
pct as float))
pct as f64))
}
let (diff, ok) = self.metrics.ratchet(pth, ratchet_pct);
self.write_metric_diff(&diff);
@ -551,8 +551,8 @@ pub fn fmt_metrics(mm: &MetricMap) -> ~str {
let v : ~[~str] = mm.iter()
.map(|(k,v)| format!("{}: {} (+/- {})",
*k,
v.value as float,
v.noise as float))
v.value as f64,
v.noise as f64))
.collect();
v.connect(", ")
}
@ -878,8 +878,8 @@ fn calc_result(desc: &TestDesc, task_succeeded: bool) -> TestResult {
impl ToJson for Metric {
fn to_json(&self) -> json::Json {
let mut map = ~TreeMap::new();
map.insert(~"value", json::Number(self.value as float));
map.insert(~"noise", json::Number(self.noise as float));
map.insert(~"value", json::Number(self.value as f64));
map.insert(~"noise", json::Number(self.noise as f64));
json::Object(map)
}
}
@ -1083,9 +1083,9 @@ impl BenchHarness {
debug2!("{} samples, median {}, MAD={}, MADP={}",
samples.len(),
summ.median as float,
summ.median_abs_dev as float,
summ.median_abs_dev_pct as float);
summ.median as f64,
summ.median_abs_dev as f64,
summ.median_abs_dev_pct as f64);
let now = precise_time_ns();
let loop_run = now - loop_start;

8
src/libextra/time.rs
View File

@ -92,8 +92,8 @@ pub fn precise_time_ns() -> u64 {
* Returns the current value of a high-resolution performance counter
* in seconds since an unspecified epoch.
*/
pub fn precise_time_s() -> float {
return (precise_time_ns() as float) / 1000000000.;
pub fn precise_time_s() -> f64 {
return (precise_time_ns() as f64) / 1000000000.;
}
pub fn tzset() {
@ -905,7 +905,7 @@ fn do_strftime(format: &str, tm: &Tm) -> ~str {
mod tests {
use super::*;
use std::float;
use std::f64;
use std::os;
use std::result::{Err, Ok};
@ -934,7 +934,7 @@ mod tests {
let s0 = precise_time_s();
let ns1 = precise_time_ns();
debug2!("s0={} sec", float::to_str_digits(s0, 9u));
debug2!("s0={} sec", f64::to_str_digits(s0, 9u));
assert!(s0 > 0.);
let ns0 = (s0 * 1000000000.) as u64;
debug2!("ns0={:?} ns", ns0);

11
src/librustc/driver/driver.rs
View File

@ -603,11 +603,11 @@ pub fn build_target_config(sopts: @session::options,
None => early_error(demitter,
~"unknown architecture: " + sopts.target_triple)
};
let (int_type, uint_type, float_type) = match arch {
abi::X86 => (ast::ty_i32, ast::ty_u32, ast::ty_f64),
abi::X86_64 => (ast::ty_i64, ast::ty_u64, ast::ty_f64),
abi::Arm => (ast::ty_i32, ast::ty_u32, ast::ty_f64),
abi::Mips => (ast::ty_i32, ast::ty_u32, ast::ty_f64)
let (int_type, uint_type) = match arch {
abi::X86 => (ast::ty_i32, ast::ty_u32),
abi::X86_64 => (ast::ty_i64, ast::ty_u64),
abi::Arm => (ast::ty_i32, ast::ty_u32),
abi::Mips => (ast::ty_i32, ast::ty_u32)
};
let target_triple = sopts.target_triple.clone();
let target_strs = match arch {
@ -622,7 +622,6 @@ pub fn build_target_config(sopts: @session::options,
target_strs: target_strs,
int_type: int_type,
uint_type: uint_type,
float_type: float_type
};
return target_cfg;
}

3
src/librustc/driver/session.rs
View File

@ -19,7 +19,7 @@ use metadata;
use middle::lint;
use syntax::ast::NodeId;
use syntax::ast::{int_ty, uint_ty, float_ty};
use syntax::ast::{int_ty, uint_ty};
use syntax::codemap::Span;
use syntax::diagnostic;
use syntax::parse::ParseSess;
@ -47,7 +47,6 @@ pub struct config {
target_strs: target_strs::t,
int_type: int_ty,
uint_type: uint_ty,
float_type: float_ty
}
pub static verbose: uint = 1 << 0;

1
src/librustc/metadata/tydecode.rs
View File

@ -304,7 +304,6 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
'b' => return ty::mk_bool(),
'i' => return ty::mk_int(),
'u' => return ty::mk_uint(),
'l' => return ty::mk_float(),
'M' => {
match next(st) {
'b' => return ty::mk_mach_uint(ast::ty_u8),

1
src/librustc/metadata/tyencode.rs
View File

@ -260,7 +260,6 @@ fn enc_sty(w: @io::Writer, cx: @ctxt, st: &ty::sty) {
}
ty::ty_float(t) => {
match t {
ty_f => w.write_char('l'),
ty_f32 => w.write_str(&"Mf"),
ty_f64 => w.write_str(&"MF"),
}

6
src/librustc/middle/borrowck/mod.rs
View File

@ -115,9 +115,9 @@ pub fn check_crate(
return (bccx.root_map, bccx.write_guard_map);
fn make_stat(bccx: &mut BorrowckCtxt, stat: uint) -> ~str {
let stat_f = stat as float;
let total = bccx.stats.guaranteed_paths as float;
format!("{} ({:.0f}%)", stat , stat_f * 100f / total)
let stat_f = stat as f64;
let total = bccx.stats.guaranteed_paths as f64;
format!("{} ({:.0f}%)", stat , stat_f * 100.0 / total)
}
}

4
src/librustc/middle/const_eval.rs
View File

@ -475,9 +475,9 @@ pub fn lit_to_const(lit: &lit) -> const_val {
lit_int(n, _) => const_int(n),
lit_uint(n, _) => const_uint(n),
lit_int_unsuffixed(n) => const_int(n),
lit_float(n, _) => const_float(from_str::<float>(n).unwrap() as f64),
lit_float(n, _) => const_float(from_str::<f64>(n).unwrap() as f64),
lit_float_unsuffixed(n) =>
const_float(from_str::<float>(n).unwrap() as f64),
const_float(from_str::<f64>(n).unwrap() as f64),
lit_nil => const_int(0i64),
lit_bool(b) => const_bool(b)
}

1
src/librustc/middle/resolve.rs
View File

@ -772,7 +772,6 @@ pub fn PrimitiveTypeTable() -> PrimitiveTypeTable {
table.intern("bool", ty_bool);
table.intern("char", ty_char);
table.intern("float", ty_float(ty_f));
table.intern("f32", ty_float(ty_f32));
table.intern("f64", ty_float(ty_f64));
table.intern("int", ty_int(ty_i));

4
src/librustc/middle/trans/consts.rs
View File

@ -56,12 +56,12 @@ pub fn const_lit(cx: &mut CrateContext, e: &ast::Expr, lit: ast::lit)
ty_to_str(cx.tcx, lit_int_ty)))
}
}
ast::lit_float(fs, t) => C_floating(fs, Type::float_from_ty(cx, t)),
ast::lit_float(fs, t) => C_floating(fs, Type::float_from_ty(t)),
ast::lit_float_unsuffixed(fs) => {
let lit_float_ty = ty::node_id_to_type(cx.tcx, e.id);
match ty::get(lit_float_ty).sty {
ty::ty_float(t) => {
C_floating(fs, Type::float_from_ty(cx, t))
C_floating(fs, Type::float_from_ty(t))
}
_ => {
cx.sess.span_bug(lit.span,

3
src/librustc/middle/trans/context.rs
View File

@ -109,7 +109,6 @@ pub struct CrateContext {
upcalls: @upcall::Upcalls,
tydesc_type: Type,
int_type: Type,
float_type: Type,
opaque_vec_type: Type,
builder: BuilderRef_res,
crate_map: ValueRef,
@ -156,7 +155,6 @@ impl CrateContext {
base::declare_dbg_intrinsics(llmod, &mut intrinsics);
}
let int_type = Type::int(targ_cfg.arch);
let float_type = Type::float(targ_cfg.arch);
let tydesc_type = Type::tydesc(targ_cfg.arch);
let opaque_vec_type = Type::opaque_vec(targ_cfg.arch);
@ -234,7 +232,6 @@ impl CrateContext {
upcalls: upcall::declare_upcalls(targ_cfg, llmod),
tydesc_type: tydesc_type,
int_type: int_type,
float_type: float_type,
opaque_vec_type: opaque_vec_type,
builder: BuilderRef_res(llvm::LLVMCreateBuilderInContext(llcx)),
crate_map: crate_map,

1
src/librustc/middle/trans/debuginfo.rs
View File

@ -1046,7 +1046,6 @@ fn basic_type_metadata(cx: &mut CrateContext, t: ty::t) -> DIType {
ast::ty_u64 => (~"u64", DW_ATE_unsigned)
},
ty::ty_float(float_ty) => match float_ty {
ast::ty_f => (~"float", DW_ATE_float),
ast::ty_f32 => (~"f32", DW_ATE_float),
ast::ty_f64 => (~"f64", DW_ATE_float)
},

1
src/librustc/middle/trans/reflect.rs
View File

@ -168,7 +168,6 @@ impl Reflector {
ty::ty_uint(ast::ty_u16) => self.leaf("u16"),
ty::ty_uint(ast::ty_u32) => self.leaf("u32"),
ty::ty_uint(ast::ty_u64) => self.leaf("u64"),
ty::ty_float(ast::ty_f) => self.leaf("float"),
ty::ty_float(ast::ty_f32) => self.leaf("f32"),
ty::ty_float(ast::ty_f64) => self.leaf("f64"),

3
src/librustc/middle/trans/type_.rs
View File

@ -136,9 +136,8 @@ impl Type {
}
}
pub fn float_from_ty(ctx: &CrateContext, t: ast::float_ty) -> Type {
pub fn float_from_ty(t: ast::float_ty) -> Type {
match t {
ast::ty_f => ctx.float_type,
ast::ty_f32 => Type::f32(),
ast::ty_f64 => Type::f64()
}

4
src/librustc/middle/trans/type_of.rs
View File

@ -111,7 +111,7 @@ pub fn sizing_type_of(cx: &mut CrateContext, t: ty::t) -> Type {
ty::ty_char => Type::char(),
ty::ty_int(t) => Type::int_from_ty(cx, t),
ty::ty_uint(t) => Type::uint_from_ty(cx, t),
ty::ty_float(t) => Type::float_from_ty(cx, t),
ty::ty_float(t) => Type::float_from_ty(t),
ty::ty_estr(ty::vstore_uniq) |
ty::ty_estr(ty::vstore_box) |
@ -199,7 +199,7 @@ pub fn type_of(cx: &mut CrateContext, t: ty::t) -> Type {
ty::ty_char => Type::char(),
ty::ty_int(t) => Type::int_from_ty(cx, t),
ty::ty_uint(t) => Type::uint_from_ty(cx, t),
ty::ty_float(t) => Type::float_from_ty(cx, t),
ty::ty_float(t) => Type::float_from_ty(t),
ty::ty_estr(ty::vstore_uniq) => {
Type::vec(cx.sess.targ_cfg.arch, &Type::i8()).ptr_to()
}

7
src/librustc/middle/ty.rs
View File

@ -583,7 +583,6 @@ mod primitives {
def_prim_ty!(TY_U16, super::ty_uint(ast::ty_u16), 10)
def_prim_ty!(TY_U32, super::ty_uint(ast::ty_u32), 11)
def_prim_ty!(TY_U64, super::ty_uint(ast::ty_u64), 12)
def_prim_ty!(TY_FLOAT, super::ty_float(ast::ty_f), 13)
def_prim_ty!(TY_F32, super::ty_float(ast::ty_f32), 14)
def_prim_ty!(TY_F64, super::ty_float(ast::ty_f64), 15)
@ -1121,9 +1120,6 @@ pub fn mk_i32() -> t { mk_prim_t(&primitives::TY_I32) }
#[inline]
pub fn mk_i64() -> t { mk_prim_t(&primitives::TY_I64) }
#[inline]
pub fn mk_float() -> t { mk_prim_t(&primitives::TY_FLOAT) }
#[inline]
pub fn mk_f32() -> t { mk_prim_t(&primitives::TY_F32) }
@ -1167,7 +1163,6 @@ pub fn mk_mach_uint(tm: ast::uint_ty) -> t {
pub fn mk_mach_float(tm: ast::float_ty) -> t {
match tm {
ast::ty_f => mk_float(),
ast::ty_f32 => mk_f32(),
ast::ty_f64 => mk_f64(),
}
@ -2560,7 +2555,7 @@ pub fn type_is_signed(ty: t) -> bool {
pub fn type_is_machine(ty: t) -> bool {
match get(ty).sty {
ty_int(ast::ty_i) | ty_uint(ast::ty_u) | ty_float(ast::ty_f) => false,
ty_int(ast::ty_i) | ty_uint(ast::ty_u) => false,
ty_int(*) | ty_uint(*) | ty_float(*) => true,
_ => false
}

6
src/librustc/middle/typeck/infer/resolve.rs
View File

@ -269,9 +269,9 @@ impl ResolveState {
Some(t) => ty::mk_mach_float(t),
None => {
if self.should(force_fvar) {
// As a last resort, default to float.
let ty = ty::mk_float();
self.infcx.set(vid, Root(Some(ast::ty_f), node.rank));
// As a last resort, default to f64.
let ty = ty::mk_f64();
self.infcx.set(vid, Root(Some(ast::ty_f64), node.rank));
ty
} else {
ty::mk_float_var(self.infcx.tcx, vid)

1
src/librustc/util/ppaux.rs
View File

@ -417,7 +417,6 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
ty_int(t) => ast_util::int_ty_to_str(t),
ty_uint(ast::ty_u) => ~"uint",
ty_uint(t) => ast_util::uint_ty_to_str(t),
ty_float(ast::ty_f) => ~"float",
ty_float(t) => ast_util::float_ty_to_str(t),
ty_box(ref tm) => ~"@" + mt_to_str(cx, tm),
ty_uniq(ref tm) => ~"~" + mt_to_str(cx, tm),

1
src/librustdoc/html/format.rs
View File

@ -233,7 +233,6 @@ impl fmt::Default for clean::Type {
ast::ty_uint(ast::ty_u16) => "u16",
ast::ty_uint(ast::ty_u32) => "u32",
ast::ty_uint(ast::ty_u64) => "u64",
ast::ty_float(ast::ty_f) => "float",
ast::ty_float(ast::ty_f32) => "f32",
ast::ty_float(ast::ty_f64) => "f64",
ast::ty_str => "str",

6
src/libstd/clone.rs
View File

@ -89,7 +89,6 @@ clone_impl!(u16)
clone_impl!(u32)
clone_impl!(u64)
clone_impl!(float)
clone_impl!(f32)
clone_impl!(f64)
@ -169,7 +168,6 @@ deep_clone_impl!(u16)
deep_clone_impl!(u32)
deep_clone_impl!(u64)
deep_clone_impl!(float)
deep_clone_impl!(f32)
deep_clone_impl!(f64)
@ -241,9 +239,9 @@ fn test_extern_fn_clone() {
trait Empty {}
impl Empty for int {}
fn test_fn_a() -> float { 1.0 }
fn test_fn_a() -> f64 { 1.0 }
fn test_fn_b<T: Empty>(x: T) -> T { x }
fn test_fn_c(_: int, _: float, _: ~[int], _: int, _: int, _: int) {}
fn test_fn_c(_: int, _: f64, _: ~[int], _: int, _: int, _: int) {}
let _ = test_fn_a.clone();
let _ = test_fn_b::<int>.clone();

2
src/libstd/fmt/mod.rs
View File

@ -1035,7 +1035,6 @@ macro_rules! floating(($ty:ident) => {
}
}
})
floating!(float)
floating!(f32)
floating!(f64)
@ -1096,7 +1095,6 @@ delegate!(~str to String)
delegate!(&'self str to String)
delegate!(bool to Bool)
delegate!(char to Char)
delegate!(float to Float)
delegate!(f32 to Float)
delegate!(f64 to Float)

6
src/libstd/iter.rs
View File

@ -2269,12 +2269,12 @@ mod tests {
#[test]
fn test_iterator_scan() {
// test the type inference
fn add(old: &mut int, new: &uint) -> Option<float> {
fn add(old: &mut int, new: &uint) -> Option<f64> {
*old += *new as int;
Some(*old as float)
Some(*old as f64)
}
let xs = [0u, 1, 2, 3, 4];
let ys = [0f, 1f, 3f, 6f, 10f];
let ys = [0f64, 1.0, 3.0, 6.0, 10.0];
let mut it = xs.iter().scan(0, add);
let mut i = 0;

1444
src/libstd/num/float.rs
View File

File diff suppressed because it is too large Load Diff

7
src/libstd/num/num.rs
View File

@ -385,7 +385,6 @@ pub trait NumCast {
fn to_f32(&self) -> f32;
fn to_f64(&self) -> f64;
fn to_float(&self) -> float;
}
macro_rules! impl_num_cast(
@ -412,7 +411,6 @@ macro_rules! impl_num_cast(
#[inline] fn to_f32(&self) -> f32 { *self as f32 }
#[inline] fn to_f64(&self) -> f64 { *self as f64 }
#[inline] fn to_float(&self) -> float { *self as float }
}
)
)
@ -429,7 +427,6 @@ impl_num_cast!(i64, to_i64)
impl_num_cast!(int, to_int)
impl_num_cast!(f32, to_f32)
impl_num_cast!(f64, to_f64)
impl_num_cast!(float, to_float)
pub trait ToStrRadix {
fn to_str_radix(&self, radix: uint) -> ~str;
@ -579,7 +576,6 @@ mod tests {
assert_eq!(20i16, _20.to_i16());
assert_eq!(20i32, _20.to_i32());
assert_eq!(20i64, _20.to_i64());
assert_eq!(20f, _20.to_float());
assert_eq!(20f32, _20.to_f32());
assert_eq!(20f64, _20.to_f64());
@ -593,7 +589,6 @@ mod tests {
assert_eq!(_20, NumCast::from(20i16));
assert_eq!(_20, NumCast::from(20i32));
assert_eq!(_20, NumCast::from(20i64));
assert_eq!(_20, NumCast::from(20f));
assert_eq!(_20, NumCast::from(20f32));
assert_eq!(_20, NumCast::from(20f64));
@ -607,7 +602,6 @@ mod tests {
assert_eq!(_20, cast(20i16));
assert_eq!(_20, cast(20i32));
assert_eq!(_20, cast(20i64));
assert_eq!(_20, cast(20f));
assert_eq!(_20, cast(20f32));
assert_eq!(_20, cast(20f64));
})
@ -625,7 +619,6 @@ mod tests {
#[test] fn test_int_cast() { test_cast_20!(20i) }
#[test] fn test_f32_cast() { test_cast_20!(20f32) }
#[test] fn test_f64_cast() { test_cast_20!(20f64) }
#[test] fn test_float_cast() { test_cast_20!(20f) }
#[test]
fn test_saturating_add_uint() {

5
src/libstd/num/strconv.rs
View File

@ -83,7 +83,6 @@ macro_rules! impl_NumStrConv_Integer (($t:ty) => (
// FIXME: #4955
// Replace by two generic impls for traits 'Integral' and 'Floating'
impl_NumStrConv_Floating!(float)
impl_NumStrConv_Floating!(f32)
impl_NumStrConv_Floating!(f64)
@ -735,8 +734,8 @@ mod test {
mod bench {
use extra::test::BenchHarness;
use rand::{XorShiftRng, Rng};
use float;
use to_str::ToStr;
use f64;
#[bench]
fn uint_to_str_rand(bh: &mut BenchHarness) {
@ -750,7 +749,7 @@ mod bench {
fn float_to_str_rand(bh: &mut BenchHarness) {
let mut rng = XorShiftRng::new();
do bh.iter {
float::to_str(rng.gen());
f64::to_str(rng.gen());
}
}
}

21
src/libstd/rand/mod.rs
View File

@ -14,7 +14,7 @@ Random number generation.
The key functions are `random()` and `Rng::gen()`. These are polymorphic
and so can be used to generate any type that implements `Rand`. Type inference
means that often a simple call to `rand::random()` or `rng.gen()` will
suffice, but sometimes an annotation is required, e.g. `rand::random::<float>()`.
suffice, but sometimes an annotation is required, e.g. `rand::random::<f64>()`.
See the `distributions` submodule for sampling random numbers from
distributions like normal and exponential.
@ -145,13 +145,6 @@ impl Rand for u64 {
}
}
impl Rand for float {
#[inline]
fn rand<R: Rng>(rng: &mut R) -> float {
rng.gen::<f64>() as float
}
}
impl Rand for f32 {
#[inline]
fn rand<R: Rng>(rng: &mut R) -> f32 {
@ -271,7 +264,7 @@ pub trait Rng {
/// let rng = rand::task_rng();
/// let x: uint = rng.gen();
/// println!("{}", x);
/// println!("{:?}", rng.gen::<(float, bool)>());
/// println!("{:?}", rng.gen::<(f64, bool)>());
/// }
/// ```
#[inline(always)]
@ -290,7 +283,7 @@ pub trait Rng {
/// let rng = rand::task_rng();
/// let x: ~[uint] = rng.gen_vec(10);
/// println!("{:?}", x);
/// println!("{:?}", rng.gen_vec::<(float, bool)>(5));
/// println!("{:?}", rng.gen_vec::<(f64, bool)>(5));
/// }
/// ```
fn gen_vec<T: Rand>(&mut self, len: uint) -> ~[T] {
@ -936,10 +929,10 @@ mod test {
}
#[test]
fn test_gen_float() {
fn test_gen_f64() {
let mut r = rng();
let a = r.gen::<float>();
let b = r.gen::<float>();
let a = r.gen::<f64>();
let b = r.gen::<f64>();
debug2!("{:?}", (a, b));
}
@ -1049,7 +1042,7 @@ mod test {
let _many : ((),
(~uint, @int, ~Option<~(@u32, ~(@bool,))>),
(u8, i8, u16, i16, u32, i32, u64, i64),
(f32, (f64, (float,)))) = random();
(f32, (f64, (f64,)))) = random();
}
#[test]

1
src/libstd/reflect.rs
View File

@ -166,6 +166,7 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
true
}
#[cfg(stage0)]
fn visit_float(&mut self) -> bool {
self.align_to::<float>();
if ! self.inner.visit_float() { return false; }

20
src/libstd/repr.rs
View File

@ -78,13 +78,6 @@ int_repr!(u16, "u16")
int_repr!(u32, "u32")
int_repr!(u64, "u64")
impl Repr for float {
fn write_repr(&self, writer: &mut io::Writer) {
let s = self.to_str();
writer.write(s.as_bytes());
}
}
macro_rules! num_repr(($ty:ident, $suffix:expr) => (impl Repr for $ty {
fn write_repr(&self, writer: &mut io::Writer) {
let s = self.to_str();
@ -278,7 +271,8 @@ impl<'self> TyVisitor for ReprVisitor<'self> {
fn visit_u32(&mut self) -> bool { self.write::<u32>() }
fn visit_u64(&mut self) -> bool { self.write::<u64>() }
fn visit_float(&mut self) -> bool { self.write::<float>() }
#[cfg(stage0)]
fn visit_float(&mut self) -> bool { self.write::<f64>() }
fn visit_f32(&mut self) -> bool { self.write::<f32>() }
fn visit_f64(&mut self) -> bool { self.write::<f64>() }
@ -632,7 +626,7 @@ pub fn write_repr<T>(writer: &mut io::Writer, object: &T) {
}
#[cfg(test)]
struct P {a: int, b: float}
struct P {a: int, b: f64}
#[test]
fn test_repr() {
@ -653,7 +647,7 @@ fn test_repr() {
exact_test(&10, "10");
exact_test(&true, "true");
exact_test(&false, "false");
exact_test(&1.234, "1.234");
exact_test(&1.234, "1.234f64");
exact_test(&(&"hello"), "\"hello\"");
exact_test(&(@"hello"), "@\"hello\"");
exact_test(&(~"he\u10f3llo"), "~\"he\\u10f3llo\"");
@ -682,11 +676,11 @@ fn test_repr() {
exact_test(&(&["hi", "there"]),
"&[\"hi\", \"there\"]");
exact_test(&(P{a:10, b:1.234}),
"repr::P{a: 10, b: 1.234}");
"repr::P{a: 10, b: 1.234f64}");
exact_test(&(@P{a:10, b:1.234}),
"@repr::P{a: 10, b: 1.234}");
"@repr::P{a: 10, b: 1.234f64}");
exact_test(&(~P{a:10, b:1.234}),
"~repr::P{a: 10, b: 1.234}");
"~repr::P{a: 10, b: 1.234f64}");
exact_test(&(10u8, ~"hello"),
"(10u8, ~\"hello\")");
exact_test(&(10u16, ~"hello"),

1
src/libstd/std.rs
View File

@ -109,7 +109,6 @@ pub mod prelude;
#[path = "num/u32.rs"] pub mod u32;
#[path = "num/u64.rs"] pub mod u64;
#[path = "num/float.rs"] pub mod float;
#[path = "num/f32.rs"] pub mod f32;
#[path = "num/f64.rs"] pub mod f64;

7
src/libstd/to_bytes.rs
View File

@ -198,13 +198,6 @@ impl IterBytes for int {
}
}
impl IterBytes for float {
#[inline]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
(*self as f64).iter_bytes(lsb0, f)
}
}
impl IterBytes for f32 {
#[inline]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {

8
src/libstd/unstable/extfmt.rs
View File

@ -480,7 +480,7 @@ pub mod ct {
#[doc(hidden)]
#[allow(non_uppercase_statics)]
pub mod rt {
use float;
use f64;
use str;
use sys;
use num;
@ -563,10 +563,10 @@ pub mod rt {
};
pad(cv, unpadded, None, PadNozero, buf);
}
pub fn conv_float(cv: Conv, f: float, buf: &mut ~str) {
pub fn conv_float(cv: Conv, f: f64, buf: &mut ~str) {
let (to_str, digits) = match cv.precision {
CountIs(c) => (float::to_str_exact, c as uint),
CountImplied => (float::to_str_digits, 6u)
CountIs(c) => (f64::to_str_exact, c as uint),
CountImplied => (f64::to_str_digits, 6u)
};
let s = to_str(f, digits);
let head = if 0.0 <= f {

1
src/libstd/unstable/intrinsics.rs
View File

@ -94,6 +94,7 @@ pub trait TyVisitor {
fn visit_u32(&mut self) -> bool;
fn visit_u64(&mut self) -> bool;
#[cfg(stage0)]
fn visit_float(&mut self) -> bool;
fn visit_f32(&mut self) -> bool;
fn visit_f64(&mut self) -> bool;

1
src/libsyntax/ast.rs
View File

@ -765,7 +765,6 @@ impl ToStr for uint_ty {
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
pub enum float_ty {
ty_f,
ty_f32,
ty_f64,
}

2
src/libsyntax/ast_util.rs
View File

@ -190,7 +190,7 @@ pub fn uint_ty_max(t: uint_ty) -> u64 {
}
pub fn float_ty_to_str(t: float_ty) -> ~str {
match t { ty_f => ~"f", ty_f32 => ~"f32", ty_f64 => ~"f64" }
match t { ty_f32 => ~"f32", ty_f64 => ~"f64" }
}
pub fn is_call_expr(e: @Expr) -> bool {

1
src/libsyntax/ext/quote.rs
View File

@ -446,7 +446,6 @@ fn mk_token(cx: @ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
LIT_FLOAT(fident, fty) => {
let s_fty = match fty {
ast::ty_f => ~"ty_f",
ast::ty_f32 => ~"ty_f32",
ast::ty_f64 => ~"ty_f64"
};

7
src/libsyntax/parse/lexer.rs
View File

@ -530,7 +530,6 @@ fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
None => ()
}
let mut is_machine_float = false;
if rdr.curr == 'f' {
bump(rdr);
c = rdr.curr;
@ -549,14 +548,10 @@ fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
32-bit or 64-bit float, it won't be noticed till the
back-end. */
} else {
is_float = true;
is_machine_float = true;
fatal_span(rdr, start_bpos, rdr.last_pos, ~"expected `f32` or `f64` suffix");
}
}
if is_float {
if is_machine_float {
return token::LIT_FLOAT(str_to_ident(num_str), ast::ty_f);
}
return token::LIT_FLOAT_UNSUFFIXED(str_to_ident(num_str));
} else {
if num_str.len() == 0u {

6
src/test/auxiliary/static_fn_inline_xc_aux.rs
View File

@ -15,9 +15,9 @@ pub mod num {
}
}
pub mod float {
impl ::num::Num2 for float {
pub mod f64 {
impl ::num::Num2 for f64 {
#[inline]
fn from_int2(n: int) -> float { return n as float; }
fn from_int2(n: int) -> f64 { return n as f64; }
}
}

6
src/test/auxiliary/static_fn_trait_xc_aux.rs
View File

@ -4,8 +4,8 @@ pub mod num {
}
}
pub mod float {
impl ::num::Num2 for float {
fn from_int2(n: int) -> float { return n as float; }
pub mod f64 {
impl ::num::Num2 for f64 {
fn from_int2(n: int) -> f64 { return n as f64; }
}
}

2
src/test/auxiliary/trait_default_method_xc_aux.rs
View File

@ -23,7 +23,7 @@ trait B<T> {
}
impl<T> B<T> for int { }
impl B<float> for bool { }
impl B<f64> for bool { }

2
src/test/auxiliary/xc_conditions_4.rs
View File

@ -16,7 +16,7 @@ pub enum Color {
}
condition! {
pub oops: (int,float,~str) -> Color;
pub oops: (int,f64,~str) -> Color;
}
pub trait Thunk<T> {

28
src/test/bench/core-set.rs
View File

@ -19,16 +19,16 @@ use std::rand;
use std::uint;
struct Results {
sequential_ints: float,
random_ints: float,
delete_ints: float,
sequential_ints: f64,
random_ints: f64,
delete_ints: f64,
sequential_strings: float,
random_strings: float,
delete_strings: float
sequential_strings: f64,
random_strings: f64,
delete_strings: f64
}
fn timed(result: &mut float, op: &fn()) {
fn timed(result: &mut f64, op: &fn()) {
let start = extra::time::precise_time_s();
op();
let end = extra::time::precise_time_s();
@ -127,7 +127,7 @@ fn write_header(header: &str) {
io::stdout().write_str("\n");
}
fn write_row(label: &str, value: float) {
fn write_row(label: &str, value: f64) {
io::stdout().write_str(format!("{:30s} {} s\n", label, value));
}
@ -143,13 +143,13 @@ fn write_results(label: &str, results: &Results) {
fn empty_results() -> Results {
Results {
sequential_ints: 0f,
random_ints: 0f,
delete_ints: 0f,
sequential_ints: 0.0,
random_ints: 0.0,
delete_ints: 0.0,
sequential_strings: 0f,
random_strings: 0f,
delete_strings: 0f,
sequential_strings: 0.0,
random_strings: 0.0,
delete_strings: 0.0,
}
}

2
src/test/bench/core-std.rs
View File

@ -55,7 +55,7 @@ fn maybe_run_test(argv: &[~str], name: ~str, test: &fn()) {
test();
let stop = precise_time_s();
println!("{}:\t\t{} ms", name, (stop - start) * 1000f);
println!("{}:\t\t{} ms", name, (stop - start) * 1000.0);
}
fn shift_push() {

2
src/test/bench/msgsend-pipes-shared.rs
View File

@ -92,7 +92,7 @@ fn run(args: &[~str]) {
let elapsed = end - start;
io::stdout().write_str(format!("Count is {:?}\n", result));
io::stdout().write_str(format!("Test took {:?} seconds\n", elapsed));
let thruput = ((size / workers * workers) as float) / (elapsed as float);
let thruput = ((size / workers * workers) as f64) / (elapsed as f64);
io::stdout().write_str(format!("Throughput={} per sec\n", thruput));
assert_eq!(result, num_bytes * size);
}

2
src/test/bench/msgsend-pipes.rs
View File

@ -86,7 +86,7 @@ fn run(args: &[~str]) {
let elapsed = end - start;
io::stdout().write_str(format!("Count is {:?}\n", result));
io::stdout().write_str(format!("Test took {:?} seconds\n", elapsed));
let thruput = ((size / workers * workers) as float) / (elapsed as float);
let thruput = ((size / workers * workers) as f64) / (elapsed as f64);
io::stdout().write_str(format!("Throughput={} per sec\n", thruput));
assert_eq!(result, num_bytes * size);
}

2
src/test/bench/msgsend-ring-mutex-arcs.rs
View File

@ -116,7 +116,7 @@ fn main() {
// all done, report stats.
let num_msgs = num_tasks * msg_per_task;
let elapsed = (stop - start);
let rate = (num_msgs as float) / elapsed;
let rate = (num_msgs as f64) / elapsed;
println!("Sent {} messages in {} seconds", num_msgs, elapsed);
println!(" {} messages / second", rate);

2
src/test/bench/msgsend-ring-rw-arcs.rs
View File

@ -112,7 +112,7 @@ fn main() {
// all done, report stats.
let num_msgs = num_tasks * msg_per_task;
let elapsed = (stop - start);
let rate = (num_msgs as float) / elapsed;
let rate = (num_msgs as f64) / elapsed;
println!("Sent {} messages in {} seconds", num_msgs, elapsed);
println!(" {} messages / second", rate);

4
src/test/bench/noise.rs
View File

@ -1,6 +1,6 @@
// Perlin noise benchmark from https://gist.github.com/1170424
use std::float;
use std::f64;
use std::rand::Rng;
use std::rand;
@ -16,7 +16,7 @@ fn lerp(a: f32, b: f32, v: f32) -> f32 { a * (1.0 - v) + b * v }
fn smooth(v: f32) -> f32 { v * v * (3.0 - 2.0 * v) }
fn random_gradient<R:Rng>(r: &mut R) -> Vec2 {
let v = 2.0 * float::consts::pi * r.gen();
let v = 2.0 * f64::consts::pi * r.gen();
Vec2 {
x: v.cos() as f32,
y: v.sin() as f32,

4
src/test/bench/shootout-k-nucleotide-pipes.rs
View File

@ -29,8 +29,8 @@ use std::vec;
// given a map, print a sorted version of it
fn sort_and_fmt(mm: &HashMap<~[u8], uint>, total: uint) -> ~str {
fn pct(xx: uint, yy: uint) -> float {
return (xx as float) * 100f / (yy as float);
fn pct(xx: uint, yy: uint) -> f64 {
return (xx as f64) * 100.0 / (yy as f64);
}
fn le_by_val<TT:Clone,

6
src/test/bench/std-smallintmap.rs
View File

@ -53,11 +53,11 @@ fn main() {
check_sequential(0u, max, &map);
let end = extra::time::precise_time_s();
checkf += (end - mid) as float;
appendf += (mid - start) as float;
checkf += (end - mid) as f64;
appendf += (mid - start) as f64;
}
let maxf = max as float;
let maxf = max as f64;
io::stdout().write_str(format!("insert(): {:?} seconds\n", checkf));
io::stdout().write_str(format!(" : {} op/sec\n", maxf/checkf));

8
src/test/compile-fail/bad-mid-path-type-params.rs
View File

@ -29,9 +29,9 @@ impl Trait<int> for S2 {
}
fn main() {
let _ = S::new::<int,float>(1, 1.0); //~ ERROR the impl referenced by this path has 1 type parameter, but 0 type parameters were supplied
let _ = S::<'self,int>::new::<float>(1, 1.0); //~ ERROR this impl has no lifetime parameter
let _: S2 = Trait::new::<int,float>(1, 1.0); //~ ERROR the trait referenced by this path has 1 type parameter, but 0 type parameters were supplied
let _: S2 = Trait::<'self,int>::new::<float>(1, 1.0); //~ ERROR this trait has no lifetime parameter
let _ = S::new::<int,f64>(1, 1.0); //~ ERROR the impl referenced by this path has 1 type parameter, but 0 type parameters were supplied
let _ = S::<'self,int>::new::<f64>(1, 1.0); //~ ERROR this impl has no lifetime parameter
let _: S2 = Trait::new::<int,f64>(1, 1.0); //~ ERROR the trait referenced by this path has 1 type parameter, but 0 type parameters were supplied
let _: S2 = Trait::<'self,int>::new::<f64>(1, 1.0); //~ ERROR this trait has no lifetime parameter
}

8
src/test/compile-fail/block-arg-as-stmt-with-value.rs
View File

@ -8,15 +8,15 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
fn compute1() -> float {
let v = ~[0f, 1f, 2f, 3f];
fn compute1() -> f64 {
let v = ~[0f64, 1.0, 2.0, 3.0];
do v.iter().fold(0f) |x, y| { x + *y } - 10f
do v.iter().fold(0.0) |x, y| { x + *y } - 10.0
//~^ ERROR mismatched types: expected `()`
}
fn main() {
let x = compute1();
info2!("{:?}", x);
assert_eq!(x, -4f);
assert_eq!(x, -4f64);
}

10
src/test/compile-fail/borrowck-loan-local-as-both-mut-and-imm.rs
View File

@ -10,7 +10,7 @@
use std::either::{Either, Left, Right};
fn f(x: &mut Either<int,float>, y: &Either<int,float>) -> int {
fn f(x: &mut Either<int,f64>, y: &Either<int,f64>) -> int {
match *y {
Left(ref z) => {
*x = Right(1.0);
@ -21,14 +21,14 @@ use std::either::{Either, Left, Right};
}
fn g() {
let mut x: Either<int,float> = Left(3);
let mut x: Either<int,f64> = Left(3);
println(f(&mut x, &x).to_str()); //~ ERROR cannot borrow
}
fn h() {
let mut x: Either<int,float> = Left(3);
let y: &Either<int, float> = &x;
let z: &mut Either<int, float> = &mut x; //~ ERROR cannot borrow
let mut x: Either<int,f64> = Left(3);
let y: &Either<int, f64> = &x;
let z: &mut Either<int, f64> = &mut x; //~ ERROR cannot borrow
*z = *y;
}

2
src/test/compile-fail/float-literal-inference-restrictions.rs
View File

@ -10,5 +10,5 @@
fn main() {
let x: f32 = 1; //~ ERROR mismatched types
let y: f32 = 1f; //~ ERROR mismatched types
let y: f32 = 1f64; //~ ERROR mismatched types
}

6
src/test/compile-fail/issue-3973.rs
View File

@ -12,12 +12,12 @@
use std::io;
struct Point {
x: float,
y: float,
x: f64,
y: f64,
}
impl ToStr for Point { //~ ERROR implements a method not defined in the trait
fn new(x: float, y: float) -> Point {
fn new(x: f64, y: f64) -> Point {
Point { x: x, y: y }
}

2
src/test/compile-fail/issue-6804.rs
View File

@ -1,6 +1,6 @@
// Matching against NaN should result in a warning
use std::float::NaN;
use std::f64::NaN;
fn main() {
let x = NaN;

2
src/test/compile-fail/lint-unused-import-tricky-names.rs
View File

@ -19,7 +19,7 @@ mod issue6633 {
pub mod name {
pub type a = int;
pub mod name {
pub type a = float;
pub type a = f64;
}
}
}

2
src/test/compile-fail/macro-local-data-key-priv.rs
View File

@ -13,7 +13,7 @@ use std::local_data;
// check that the local data keys are private by default.
mod bar {
local_data_key!(baz: float)
local_data_key!(baz: f64)
}
fn main() {

4
src/test/compile-fail/no-binary-float-literal.rs
View File

@ -11,7 +11,7 @@
// error-pattern:binary float literal is not supported
fn main() {
0b101010f;
0b101010f64;
0b101.010;
0b101p4f;
0b101p4f64;
}

2
src/test/compile-fail/prim-with-args.rs
View File

@ -20,7 +20,6 @@ let x: u8<int>; //~ ERROR type parameters are not allowed on this type
let x: u16<int>; //~ ERROR type parameters are not allowed on this type
let x: u32<int>; //~ ERROR type parameters are not allowed on this type
let x: u64<int>; //~ ERROR type parameters are not allowed on this type
let x: float<int>; //~ ERROR type parameters are not allowed on this type
let x: char<int>; //~ ERROR type parameters are not allowed on this type
let x: int<'static>; //~ ERROR lifetime parameters are not allowed on this type
@ -33,7 +32,6 @@ let x: u8<'static>; //~ ERROR lifetime parameters are not allowed on this type
let x: u16<'static>; //~ ERROR lifetime parameters are not allowed on this type
let x: u32<'static>; //~ ERROR lifetime parameters are not allowed on this type
let x: u64<'static>; //~ ERROR lifetime parameters are not allowed on this type
let x: float<'static>; //~ ERROR lifetime parameters are not allowed on this type
let x: char<'static>; //~ ERROR lifetime parameters are not allowed on this type
}

2
src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs
View File

@ -9,5 +9,5 @@
// except according to those terms.
fn main() {
let vec = bytes!(45f); //~ ERROR Unsupported literal in bytes!
let vec = bytes!(45f64); //~ ERROR Unsupported literal in bytes!
}

2
src/test/compile-fail/tuple-arity-mismatch.rs
View File

@ -10,7 +10,7 @@
// Issue #6155
fn first((value, _): (int, float)) -> int { value }
fn first((value, _): (int, f64)) -> int { value }
fn main() {
let y = first ((1,2,3)); //~ ERROR expected a tuple with 2 elements but found one with 3 elements

7
src/test/debug-info/basic-types.rs
View File

@ -42,12 +42,10 @@
// check:$11 = 32
// debugger:print u64
// check:$12 = 64
// debugger:print f
// check:$13 = 1.5
// debugger:print f32
// check:$14 = 2.5
// check:$13 = 2.5
// debugger:print f64
// check:$15 = 3.5
// check:$14 = 3.5
#[allow(unused_variable)];
@ -64,7 +62,6 @@ fn main() {
let u16: u16 = 16;
let u32: u32 = 32;
let u64: u64 = 64;
let f: float = 1.5;
let f32: f32 = 2.5;
let f64: f64 = 3.5;
_zzz();

10
src/test/debug-info/borrowed-basic.rs
View File

@ -51,14 +51,11 @@
// debugger:print *u64_ref
// check:$12 = 64
// debugger:print *float_ref
// check:$13 = 1.5
// debugger:print *f32_ref
// check:$14 = 2.5
// check:$13 = 2.5
// debugger:print *f64_ref
// check:$15 = 3.5
// check:$14 = 3.5
#[allow(unused_variable)];
@ -99,9 +96,6 @@ fn main() {
let u64_val: u64 = 64;
let u64_ref: &u64 = &u64_val;
let float_val: float = 1.5;
let float_ref: &float = &float_val;
let f32_val: f32 = 2.5;
let f32_ref: &f32 = &f32_val;

10
src/test/debug-info/borrowed-managed-basic.rs
View File

@ -51,14 +51,11 @@
// debugger:print *u64_ref
// check:$12 = 64
// debugger:print *float_ref
// check:$13 = 1.5
// debugger:print *f32_ref
// check:$14 = 2.5
// check:$13 = 2.5
// debugger:print *f64_ref
// check:$15 = 3.5
// check:$14 = 3.5
#[allow(unused_variable)];
@ -99,9 +96,6 @@ fn main() {
let u64_box: @u64 = @64;
let u64_ref: &u64 = u64_box;
let float_box: @float = @1.5;
let float_ref: &float = float_box;
let f32_box: @f32 = @2.5;
let f32_ref: &f32 = f32_box;

10
src/test/debug-info/borrowed-unique-basic.rs
View File

@ -51,14 +51,11 @@
// debugger:print *u64_ref
// check:$12 = 64
// debugger:print *float_ref
// check:$13 = 1.5
// debugger:print *f32_ref
// check:$14 = 2.5
// check:$13 = 2.5
// debugger:print *f64_ref
// check:$15 = 3.5
// check:$14 = 3.5
#[allow(unused_variable)];
@ -100,9 +97,6 @@ fn main() {
let u64_box: ~u64 = ~64;
let u64_ref: &u64 = u64_box;
let float_box: ~float = ~1.5;
let float_ref: &float = float_box;
let f32_box: ~f32 = ~2.5;
let f32_ref: &f32 = f32_box;

6
src/test/debug-info/by-value-non-immediate-argument.rs
View File

@ -44,7 +44,7 @@
#[deriving(Clone)]
struct Struct {
a: int,
b: float
b: f64
}
#[deriving(Clone)]
@ -61,11 +61,11 @@ fn fun_fun(StructStruct { a: x, b: Struct { a: y, b: z } }: StructStruct) {
zzz();
}
fn tup(a: (int, uint, float, float)) {
fn tup(a: (int, uint, f64, f64)) {
zzz();
}
struct Newtype(float, float, int, uint);
struct Newtype(f64, f64, int, uint);
fn new_type(a: Newtype) {
zzz();

4
src/test/debug-info/by-value-self-argument-in-trait-impl.rs
View File

@ -55,8 +55,8 @@ impl Trait for Struct {
}
}
impl Trait for (float, int, int, float) {
fn method(self) -> (float, int, int, float) {
impl Trait for (f64, int, int, f64) {
fn method(self) -> (f64, int, int, f64) {
zzz();
self
}

2
src/test/debug-info/destructured-fn-argument.rs
View File

@ -190,7 +190,7 @@ enum Univariant {
Unit(i32)
}
struct TupleStruct (float, int);
struct TupleStruct (f64, int);
fn simple_tuple((a, b): (int, bool)) {

2
src/test/debug-info/destructured-local.rs
View File

@ -134,7 +134,7 @@ enum Univariant {
Unit(i32)
}
struct TupleStruct (float, int);
struct TupleStruct (f64, int);
fn main() {

2
src/test/debug-info/generic-function.rs
View File

@ -42,7 +42,7 @@
#[deriving(Clone)]
struct Struct {
a: int,
b: float
b: f64
}
fn dup_tup<T0: Clone, T1: Clone>(t0: &T0, t1: &T1) -> ((T0, T1), (T1, T0)) {

2
src/test/debug-info/generic-static-method-on-struct-and-enum.rs
View File

@ -46,7 +46,7 @@ impl Struct {
enum Enum {
Variant1 { x: int },
Variant2,
Variant3(float, int, char),
Variant3(f64, int, char),
}
impl Enum {

2
src/test/debug-info/method-on-tuple-struct.rs
View File

@ -92,7 +92,7 @@
// check:$21 = -16
// debugger:continue
struct TupleStruct(int, float);
struct TupleStruct(int, f64);
impl TupleStruct {

4
src/test/debug-info/static-method-on-struct-and-enum.rs
View File

@ -46,12 +46,12 @@ impl Struct {
enum Enum {
Variant1 { x: int },
Variant2,
Variant3(float, int, char),
Variant3(f64, int, char),
}
impl Enum {
fn static_method(arg1: int, arg2: float, arg3: uint) -> int {
fn static_method(arg1: int, arg2: f64, arg3: uint) -> int {
zzz();
arg1
}

2
src/test/debug-info/trait-pointers.rs
View File

@ -19,7 +19,7 @@ trait Trait {
struct Struct {
a: int,
b: float
b: f64
}
impl Trait for Struct {}

2
src/test/debug-info/var-captured-in-nested-closure.rs
View File

@ -50,7 +50,7 @@
struct Struct {
a: int,
b: float,
b: f64,
c: uint
}

2
src/test/debug-info/var-captured-in-sendable-closure.rs
View File

@ -24,7 +24,7 @@
struct Struct {
a: int,
b: float,
b: f64,
c: uint
}

2
src/test/debug-info/var-captured-in-stack-closure.rs
View File

@ -30,7 +30,7 @@
struct Struct {
a: int,
b: float,
b: f64,
c: uint
}

4
src/test/run-fail/assert-approx-eq-eps-macro-fail.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// error-pattern:left: 1.0000001 does not approximately equal right: 1 with epsilon: 0.0000001
// error-pattern:left: 1.0000001f64 does not approximately equal right: 1f64 with epsilon: 0.0000001f64
pub fn main() {
assert_approx_eq!(1.0000001f, 1.0f, 1.0e-7);
assert_approx_eq!(1.0000001f64, 1.0f64, 1.0e-7);
}

4
src/test/run-fail/assert-approx-eq-macro-fail.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// error-pattern:left: 1.00001 does not approximately equal right: 1
// error-pattern:left: 1.00001f64 does not approximately equal right: 1f64
pub fn main() {
assert_approx_eq!(1.00001f, 1.0f);
assert_approx_eq!(1.00001f64, 1.0);
}

8
src/test/run-pass/assert-approx-eq-macro-success.rs
View File

@ -9,8 +9,8 @@
// except according to those terms.
pub fn main() {
assert_approx_eq!(1.0f, 1.0f);
assert_approx_eq!(1.0000001f, 1.0f);
assert_approx_eq!(1.0000001f, 1.0f, 1.0e-6);
assert_approx_eq!(1.000001f, 1.0f, 1.0e-5);
assert_approx_eq!(1.0f64, 1.0);
assert_approx_eq!(1.0000001f64, 1.0);
assert_approx_eq!(1.0000001f64, 1.0, 1.0e-6);
assert_approx_eq!(1.000001f64, 1.0, 1.0e-5);
}

6
src/test/run-pass/block-arg-can-be-followed-by-binop.rs
View File

@ -9,10 +9,10 @@
// except according to those terms.
pub fn main() {
let v = ~[-1f, 0f, 1f, 2f, 3f];
let v = ~[-1.0, 0.0, 1.0, 2.0, 3.0];
// Trailing expressions don't require parentheses:
let y = do v.iter().fold(0f) |x, y| { x + *y } + 10f;
let y = do v.iter().fold(0.0) |x, y| { x + *y } + 10.0;
assert_eq!(y, 15f);
assert_eq!(y, 15.0);
}

2
src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs
View File

@ -10,7 +10,7 @@
pub fn main() {
fn f(i: &fn() -> uint) -> uint { i() }
let v = ~[-1f, 0f, 1f, 2f, 3f];
let v = ~[-1.0, 0.0, 1.0, 2.0, 3.0];
let z = do do v.iter().fold(f) |x, _y| { x } { 22u };
assert_eq!(z, 22u);
}

2
src/test/run-pass/block-arg-can-be-followed-by-call.rs
View File

@ -10,7 +10,7 @@
pub fn main() {
fn f(i: uint) -> uint { i }
let v = ~[-1f, 0f, 1f, 2f, 3f];
let v = ~[-1.0, 0.0, 1.0, 2.0, 3.0];
let z = do v.iter().fold(f) |x, _y| { x } (22u);
assert_eq!(z, 22u);
}

10
src/test/run-pass/block-arg.rs
View File

@ -10,7 +10,7 @@
// Check usage and precedence of block arguments in expressions:
pub fn main() {
let v = ~[-1f, 0f, 1f, 2f, 3f];
let v = ~[-1.0f64, 0.0, 1.0, 2.0, 3.0];
// Statement form does not require parentheses:
for i in v.iter() {
@ -26,7 +26,7 @@ pub fn main() {
assert!(any_negative);
// Higher precedence than unary operations:
let abs_v = do v.iter().map |e| { e.abs() }.collect::<~[float]>();
let abs_v = do v.iter().map |e| { e.abs() }.collect::<~[f64]>();
assert!(do abs_v.iter().all |e| { e.is_positive() });
assert!(!do abs_v.iter().any |e| { e.is_negative() });
@ -48,9 +48,9 @@ pub fn main() {
// Lower precedence than binary operations:
let w = do v.iter().fold(0f) |x, y| { x + *y } + 10f;
let y = do v.iter().fold(0f) |x, y| { x + *y } + 10f;
let z = 10f + do v.iter().fold(0f) |x, y| { x + *y };
let w = do v.iter().fold(0.0) |x, y| { x + *y } + 10.0;
let y = do v.iter().fold(0.0) |x, y| { x + *y } + 10.0;
let z = 10.0 + do v.iter().fold(0.0) |x, y| { x + *y };
assert_eq!(w, y);
assert_eq!(y, z);

8
src/test/run-pass/const-binops.rs
View File

@ -1,18 +1,18 @@
static a: int = -4 + 3;
static a2: uint = 3 + 3;
static b: float = 3.0 + 2.7;
static b: f64 = 3.0 + 2.7;
static c: int = 3 - 4;
static d: uint = 3 - 3;
static e: float = 3.0 - 2.7;
static e: f64 = 3.0 - 2.7;
static e2: int = -3 * 3;
static f: uint = 3 * 3;
static g: float = 3.3 * 3.3;
static g: f64 = 3.3 * 3.3;
static h: int = 3 / -1;
static i: uint = 3 / 3;
static j: float = 3.3 / 3.3;
static j: f64 = 3.3 / 3.3;
static n: bool = true && false;

4
src/test/run-pass/const-contents.rs
View File

@ -12,7 +12,7 @@
static lsl : int = 1 << 2;
static add : int = 1 + 2;
static addf : float = 1.0f + 2.0f;
static addf : f64 = 1.0 + 2.0;
static not : int = !0;
static notb : bool = !true;
static neg : int = -(1);
@ -20,7 +20,7 @@ static neg : int = -(1);
pub fn main() {
assert_eq!(lsl, 4);
assert_eq!(add, 3);
assert_eq!(addf, 3.0f);
assert_eq!(addf, 3.0);
assert_eq!(not, -1);
assert_eq!(notb, false);
assert_eq!(neg, -1);

8
src/test/run-pass/const-enum-cast.rs
View File

@ -14,12 +14,12 @@ enum B { B1=0, B2=2 }
pub fn main () {
static c1: int = A2 as int;
static c2: int = B2 as int;
static c3: float = A2 as float;
static c4: float = B2 as float;
static c3: f64 = A2 as f64;
static c4: f64 = B2 as f64;
let a1 = A2 as int;
let a2 = B2 as int;
let a3 = A2 as float;
let a4 = B2 as float;
let a3 = A2 as f64;
let a4 = B2 as f64;
assert_eq!(c1, 1);
assert_eq!(c2, 2);
assert_eq!(c3, 1.0);

2
src/test/run-pass/const-rec-and-tup.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
struct Pair { a: float, b: float }
struct Pair { a: f64, b: f64 }
struct AnotherPair { x: (i64, i64), y: Pair }

1
src/test/run-pass/deriving-clone-struct.rs
View File

@ -22,7 +22,6 @@ struct S {
_u32: u32,
_u64: u64,
_float: float,
_f32: f32,
_f64: f64,

2
src/test/run-pass/deriving-via-extension-enum.rs
View File

@ -11,7 +11,7 @@
#[deriving(Eq)]
enum Foo {
Bar(int, int),
Baz(float, float)
Baz(f64, f64)
}
pub fn main() {

Some files were not shown because too many files have changed in this diff Show More