Update readme

Author: tgross35

src/etc/test-float-parse/README.md

@@ -17,4 +17,4 @@ Some tests generate strings, others generate bit patterns. For those that
 generate bit patterns, we need to use float -> dec conversions so that also
 gets tested.
 
-TODO
+todo

src/etc/test-float-parse/src/validate.rs

@@ -38,9 +38,11 @@ pub struct Constants {
     neg_inf_cutoff: BigRational,
     /// The powers of two for all relevant integers.
     powers_of_two: BTreeMap<i32, BigRational>,
-    /// Half of each power of two. ULP = "unit in last position", so these are one bit
-    /// more precise than what is representable by the float (i.e. in between representable
-    /// values).
+    /// Half of each power of two. ULP = "unit in last position".
+    ///
+    /// This is a mapping from integers to half of the precision that can be had at that
+    /// exponent. That is, these values are in between values that can be represented with a
+    /// certain exponent, assuming an integer significand (always true for float representations).
     half_ulp: BTreeMap<i32, BigRational>,
     /// Handy to have around so we don't need to reallocate for it
     two: BigInt,
@@ -187,7 +189,7 @@ impl<F: Float> FloatRes<F> {
         }
 
         let one_ulp = consts.half_ulp.get(&(exp + 1)).unwrap();
-        assert_eq!(one_ulp, &(half_ulp * &consts.two));
+        assert_eq!(one_ulp, &(half_ulp * &consts.two), "ULP values are incorrect");
 
         let relative_error = error / one_ulp;
 

src/etc/test-float-parse/src/validate/tests.rs

@@ -0,0 +1,97 @@
+use num::ToPrimitive;
+
+use super::*;
+
+#[test]
+fn test_parse_rational() {
+    assert_eq!(Rational::parse("1234").expect_finite(), BigRational::new(1234.into(), 1.into()));
+    assert_eq!(
+        Rational::parse("-1234").expect_finite(),
+        BigRational::new((-1234).into(), 1.into())
+    );
+    assert_eq!(Rational::parse("1e+6").expect_finite(), BigRational::new(1000000.into(), 1.into()));
+    assert_eq!(Rational::parse("1e-6").expect_finite(), BigRational::new(1.into(), 1000000.into()));
+    assert_eq!(
+        Rational::parse("10.4e6").expect_finite(),
+        BigRational::new(10400000.into(), 1.into())
+    );
+    assert_eq!(
+        Rational::parse("10.4e+6").expect_finite(),
+        BigRational::new(10400000.into(), 1.into())
+    );
+    assert_eq!(
+        Rational::parse("10.4e-6").expect_finite(),
+        BigRational::new(13.into(), 1250000.into())
+    );
+    assert_eq!(
+        Rational::parse("10.4243566462342456234124").expect_finite(),
+        BigRational::new(104243566462342456234124_i128.into(), 10000000000000000000000_i128.into())
+    );
+    assert_eq!(Rational::parse("inf"), Rational::Inf);
+    assert_eq!(Rational::parse("+inf"), Rational::Inf);
+    assert_eq!(Rational::parse("-inf"), Rational::NegInf);
+    assert_eq!(Rational::parse("NaN"), Rational::Nan);
+}
+
+#[test]
+fn test_decode() {
+    assert_eq!(decode(0f32, false), FloatRes::Zero);
+    assert_eq!(decode(f32::INFINITY, false), FloatRes::Inf);
+    assert_eq!(decode(f32::NEG_INFINITY, false), FloatRes::NegInf);
+    assert_eq!(decode(1.0f32, false).normalize(), FloatRes::Real { sig: 1, exp: 0 });
+    assert_eq!(decode(-1.0f32, false).normalize(), FloatRes::Real { sig: -1, exp: 0 });
+    assert_eq!(decode(100.0f32, false).normalize(), FloatRes::Real { sig: 100, exp: 0 });
+    assert_eq!(decode(100.5f32, false).normalize(), FloatRes::Real { sig: 201, exp: -1 });
+    assert_eq!(decode(-4.004f32, false).normalize(), FloatRes::Real { sig: -8396997, exp: -21 });
+    assert_eq!(decode(0.0004f32, false).normalize(), FloatRes::Real { sig: 13743895, exp: -35 });
+    assert_eq!(
+        decode(f32::from_bits(0x1), false).normalize(),
+        FloatRes::Real { sig: 1, exp: -149 }
+    );
+}
+
+#[test]
+fn test_validate() {
+    validate::<f32>("0", false).unwrap();
+    validate::<f32>("-0", false).unwrap();
+    validate::<f32>("1", false).unwrap();
+    validate::<f32>("-1", false).unwrap();
+    validate::<f32>("1.1", false).unwrap();
+    validate::<f32>("-1.1", false).unwrap();
+    validate::<f32>("1e10", false).unwrap();
+    validate::<f32>("1e1000", false).unwrap();
+    validate::<f32>("-1e1000", false).unwrap();
+    validate::<f32>("1e-1000", false).unwrap();
+    validate::<f32>("-1e-1000", false).unwrap();
+}
+
+#[test]
+fn test_check() {
+    // Most of the arbitrary values come from checking against <http://weitz.de/ieee/>.
+    let r = &BigRational::from_float(10.0).unwrap();
+    FloatRes::<f32>::validate_real(r.clone(), 10, 0).unwrap();
+    FloatRes::<f32>::validate_real(r.clone(), 10, -1).unwrap_err();
+    FloatRes::<f32>::validate_real(r.clone(), 10, 1).unwrap_err();
+
+    let r = &BigRational::from_float(0.25).unwrap();
+    FloatRes::<f32>::validate_real(r.clone(), 1, -2).unwrap();
+    FloatRes::<f32>::validate_real(r.clone(), 2, -2).unwrap_err();
+
+    let r = &BigRational::from_float(1234.5678).unwrap();
+    FloatRes::<f32>::validate_real(r.clone(), 0b100110100101001000101011, -13).unwrap();
+    FloatRes::<f32>::validate_real(r.clone(), 0b100110100101001000101010, -13).unwrap_err();
+    FloatRes::<f32>::validate_real(r.clone(), 0b100110100101001000101100, -13).unwrap_err();
+
+    let r = &BigRational::from_float(-1234.5678).unwrap();
+    FloatRes::<f32>::validate_real(r.clone(), -0b100110100101001000101011, -13).unwrap();
+    FloatRes::<f32>::validate_real(r.clone(), -0b100110100101001000101010, -13).unwrap_err();
+    FloatRes::<f32>::validate_real(r.clone(), -0b100110100101001000101100, -13).unwrap_err();
+}
+
+#[test]
+fn check_constants() {
+    assert_eq!(f32::constants().max.to_f32().unwrap(), f32::MAX);
+    assert_eq!(f32::constants().min_subnormal.to_f32().unwrap(), f32::from_bits(0x1));
+    assert_eq!(f64::constants().max.to_f64().unwrap(), f64::MAX);
+    assert_eq!(f64::constants().min_subnormal.to_f64().unwrap(), f64::from_bits(0x1));
+}