---

yaml
---
r: 232347
b: refs/heads/try
c: a406627
h: refs/heads/master
i:
  232345: f6cf3c9
  232343: 2ae3959
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: edeb4f1c86cbf6af8ef9874d4b3af50f721ea1b8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: b0b29521896d280a2f5340edc901a812ad618266
+refs/heads/try: a4066271b77810aec0a4a309f66a45e4f8b940de
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/mk/tests.mk

@@ -268,9 +268,10 @@ tidy-basic:
 .PHONY: tidy-binaries
 tidy-binaries:
 		@$(call E, check: binaries)
-		$(Q)find $(S)src -type f -perm +a+x \
+		$(Q)find $(S)src -type f \
+		    \( -perm -u+x -or -perm -g+x -or -perm -o+x \) \
 		    -not -name '*.rs' -and -not -name '*.py' \
-		    -and -not -name '*.sh' \
+		    -and -not -name '*.sh' -and -not -name '*.pp' \
 		| grep '^$(S)src/jemalloc' -v \
 		| grep '^$(S)src/libuv' -v \
 		| grep '^$(S)src/llvm' -v \

branches/try/src/etc/dec2flt_table.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python2.7
+#
+# Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+# file at the top-level directory of this distribution and at
+# http://rust-lang.org/COPYRIGHT.
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+"""
+Generate powers of ten using William Clinger's ``AlgorithmM`` for use in
+decimal to floating point conversions.
+
+Specifically, computes and outputs (as Rust code) a table of 10^e for some
+range of exponents e. The output is one array of 64 bit significands and
+another array of corresponding base two exponents. The approximations are
+normalized and rounded perfectly, i.e., within 0.5 ULP of the true value.
+
+The representation ([u64], [i16]) instead of the more natural [(u64, i16)]
+is used because (u64, i16) has a ton of padding which would make the table
+even larger, and it's already uncomfortably large (6 KiB).
+"""
+from __future__ import print_function
+import sys
+from fractions import Fraction
+from collections import namedtuple
+
+
+N = 64  # Size of the significand field in bits
+MIN_SIG = 2 ** (N - 1)
+MAX_SIG = (2 ** N) - 1
+
+
+# Hand-rolled fp representation without arithmetic or any other operations.
+# The significand is normalized and always N bit, but the exponent is
+# unrestricted in range.
+Fp = namedtuple('Fp', 'sig exp')
+
+
+def algorithm_m(f, e):
+    assert f > 0
+    if e < 0:
+        u = f
+        v = 10 ** abs(e)
+    else:
+        u = f * 10 ** e
+        v = 1
+    k = 0
+    x = u // v
+    while True:
+        if x < MIN_SIG:
+            u <<= 1
+            k -= 1
+        elif x >= MAX_SIG:
+            v <<= 1
+            k += 1
+        else:
+            break
+        x = u // v
+    return ratio_to_float(u, v, k)
+
+
+def ratio_to_float(u, v, k):
+    q, r = divmod(u, v)
+    v_r = v - r
+    z = Fp(q, k)
+    if r < v_r:
+        return z
+    elif r > v_r:
+        return next_float(z)
+    elif q % 2 == 0:
+        return z
+    else:
+        return next_float(z)
+
+
+def next_float(z):
+    if z.sig == MAX_SIG:
+        return Fp(MIN_SIG, z.exp + 1)
+    else:
+        return Fp(z.sig + 1, z.exp)
+
+
+def error(f, e, z):
+    decimal = f * Fraction(10) ** e
+    binary = z.sig * Fraction(2) ** z.exp
+    abs_err = abs(decimal - binary)
+    # The unit in the last place has value z.exp
+    ulp_err = abs_err / Fraction(2) ** z.exp
+    return float(ulp_err)
+
+LICENSE = """
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+"""
+
+def main():
+    MIN_E = -305
+    MAX_E = 305
+    e_range = range(MIN_E, MAX_E+1)
+    powers = []
+    for e in e_range:
+        z = algorithm_m(1, e)
+        err = error(1, e, z)
+        assert err < 0.5
+        powers.append(z)
+    typ = "([u64; {0}], [i16; {0}])".format(len(e_range))
+    print(LICENSE.strip())
+    print("// Table of approximations of powers of ten.")
+    print("// DO NOT MODIFY: Generated by a src/etc/dec2flt_table.py")
+    print("pub const MIN_E: i16 = {};".format(MIN_E))
+    print("pub const MAX_E: i16 = {};".format(MAX_E))
+    print()
+    print("pub const POWERS: ", typ, " = ([", sep='')
+    for z in powers:
+        print("    0x{:x},".format(z.sig))
+    print("], [")
+    for z in powers:
+        print("    {},".format(z.exp))
+    print("]);")
+
+
+if __name__ == '__main__':
+    main()

branches/try/src/etc/test-float-parse/_common.rs

@@ -0,0 +1,26 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::io;
+use std::io::prelude::*;
+use std::mem::transmute;
+
+// Nothing up my sleeve: Just (PI - 3) in base 16.
+#[allow(dead_code)]
+pub const SEED: [u32; 3] = [0x243f_6a88, 0x85a3_08d3, 0x1319_8a2e];
+
+pub fn validate(text: String) {
+    let mut out = io::stdout();
+    let x: f64 = text.parse().unwrap();
+    let f64_bytes: u64 = unsafe { transmute(x) };
+    let x: f32 = text.parse().unwrap();
+    let f32_bytes: u32 = unsafe { transmute(x) };
+    writeln!(&mut out, "{:016x} {:08x} {}", f64_bytes, f32_bytes, text).unwrap();
+}

branches/try/src/etc/test-float-parse/few-ones.rs

@@ -0,0 +1,27 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+mod _common;
+
+use _common::validate;
+
+fn main() {
+    let mut pow = vec![];
+    for i in 0..63 {
+        pow.push(1u64 << i);
+    }
+    for a in &pow {
+        for b in &pow {
+            for c in &pow {
+                validate((a | b | c).to_string());
+            }
+        }
+    }
+}

branches/try/src/etc/test-float-parse/huge-pow10.rs

@@ -0,0 +1,21 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+mod _common;
+
+use _common::validate;
+
+fn main() {
+    for e in 300..310 {
+        for i in 0..100000 {
+            validate(format!("{}e{}", i, e));
+        }
+    }
+}

branches/try/src/etc/test-float-parse/many-digits.rs

@@ -0,0 +1,39 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(rand)]
+
+extern crate rand;
+
+mod _common;
+
+use std::char;
+use rand::{IsaacRng, Rng, SeedableRng};
+use rand::distributions::{Range, Sample};
+use _common::{validate, SEED};
+
+fn main() {
+    let mut rnd = IsaacRng::from_seed(&SEED);
+    let mut range = Range::new(0, 10);
+    for _ in 0..5_000_000u64 {
+        let num_digits = rnd.gen_range(100, 300);
+        let digits = gen_digits(num_digits, &mut range, &mut rnd);
+        validate(digits);
+    }
+}
+
+fn gen_digits<R: Rng>(n: u32, range: &mut Range<u32>, rnd: &mut R) -> String {
+    let mut s = String::new();
+    for _ in 0..n {
+        let digit = char::from_digit(range.sample(rnd), 10).unwrap();
+        s.push(digit);
+    }
+    s
+}

branches/try/src/etc/test-float-parse/rand-f64.rs

@@ -0,0 +1,32 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(rand)]
+
+extern crate rand;
+
+mod _common;
+
+use _common::{validate, SEED};
+use rand::{IsaacRng, Rng, SeedableRng};
+use std::mem::transmute;
+
+fn main() {
+    let mut rnd = IsaacRng::from_seed(&SEED);
+    let mut i = 0;
+    while i < 10_000_000 {
+        let bits = rnd.next_u64();
+        let x: f64 = unsafe { transmute(bits) };
+        if x.is_finite() {
+            validate(format!("{:e}", x));
+            i += 1;
+        }
+    }
+}