rounding.rs - mozsearch

comm-central/third_party/rust/serde_json/tests/lexical/rounding.rs

Enable keyboard shortcuts

Revision control

Copy as Markdown

Other Tools

HG Web

// Adapted from https://github.com/Alexhuszagh/rust-lexical.

use crate::lexical::float::ExtendedFloat;

use crate::lexical::num::Float;

use crate::lexical::rounding::*;

// MASKS

#[test]

fn lower_n_mask_test() {

    assert_eq!(lower_n_mask(0u64), 0b0);

    assert_eq!(lower_n_mask(1u64), 0b1);

    assert_eq!(lower_n_mask(2u64), 0b11);

    assert_eq!(lower_n_mask(10u64), 0b1111111111);

    assert_eq!(lower_n_mask(32u64), 0b11111111111111111111111111111111);

#[test]

fn lower_n_halfway_test() {

    assert_eq!(lower_n_halfway(0u64), 0b0);

    assert_eq!(lower_n_halfway(1u64), 0b1);

    assert_eq!(lower_n_halfway(2u64), 0b10);

    assert_eq!(lower_n_halfway(10u64), 0b1000000000);

    assert_eq!(lower_n_halfway(32u64), 0b10000000000000000000000000000000);

#[test]

fn nth_bit_test() {

    assert_eq!(nth_bit(0u64), 0b1);

    assert_eq!(nth_bit(1u64), 0b10);

    assert_eq!(nth_bit(2u64), 0b100);

    assert_eq!(nth_bit(10u64), 0b10000000000);

    assert_eq!(nth_bit(31u64), 0b10000000000000000000000000000000);

#[test]

fn internal_n_mask_test() {

    assert_eq!(internal_n_mask(1u64, 0u64), 0b0);

    assert_eq!(internal_n_mask(1u64, 1u64), 0b1);

    assert_eq!(internal_n_mask(2u64, 1u64), 0b10);

    assert_eq!(internal_n_mask(4u64, 2u64), 0b1100);

    assert_eq!(internal_n_mask(10u64, 2u64), 0b1100000000);

    assert_eq!(internal_n_mask(10u64, 4u64), 0b1111000000);

    assert_eq!(

        internal_n_mask(32u64, 4u64),

        0b11110000000000000000000000000000

);

// NEAREST ROUNDING

#[test]

fn round_nearest_test() {

    // Check exactly halfway (b'1100000')

    let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };

    let (above, halfway) = round_nearest(&mut fp, 6);

    assert!(!above);

    assert!(halfway);

    assert_eq!(fp.mant, 1);

    // Check above halfway (b'1100001')

    let mut fp = ExtendedFloat { mant: 0x61, exp: 0 };

    let (above, halfway) = round_nearest(&mut fp, 6);

    assert!(above);

    assert!(!halfway);

    assert_eq!(fp.mant, 1);

    // Check below halfway (b'1011111')

    let mut fp = ExtendedFloat { mant: 0x5F, exp: 0 };

    let (above, halfway) = round_nearest(&mut fp, 6);

    assert!(!above);

    assert!(!halfway);

    assert_eq!(fp.mant, 1);

// DIRECTED ROUNDING

#[test]

fn round_downward_test() {

    // b0000000

    let mut fp = ExtendedFloat { mant: 0x00, exp: 0 };

    round_downward(&mut fp, 6);

    assert_eq!(fp.mant, 0);

    // b1000000

    let mut fp = ExtendedFloat { mant: 0x40, exp: 0 };

    round_downward(&mut fp, 6);

    assert_eq!(fp.mant, 1);

    // b1100000

    let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };

    round_downward(&mut fp, 6);

    assert_eq!(fp.mant, 1);

    // b1110000

    let mut fp = ExtendedFloat { mant: 0x70, exp: 0 };

    round_downward(&mut fp, 6);

    assert_eq!(fp.mant, 1);

#[test]

fn round_nearest_tie_even_test() {

    // Check round-up, halfway

    let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };

    round_nearest_tie_even(&mut fp, 6);

    assert_eq!(fp.mant, 2);

    // Check round-down, halfway

    let mut fp = ExtendedFloat { mant: 0x20, exp: 0 };

    round_nearest_tie_even(&mut fp, 6);

    assert_eq!(fp.mant, 0);

    // Check round-up, above halfway

    let mut fp = ExtendedFloat { mant: 0x61, exp: 0 };

    round_nearest_tie_even(&mut fp, 6);

    assert_eq!(fp.mant, 2);

    let mut fp = ExtendedFloat { mant: 0x21, exp: 0 };

    round_nearest_tie_even(&mut fp, 6);

    assert_eq!(fp.mant, 1);

    // Check round-down, below halfway

    let mut fp = ExtendedFloat { mant: 0x5F, exp: 0 };

    round_nearest_tie_even(&mut fp, 6);

    assert_eq!(fp.mant, 1);

    let mut fp = ExtendedFloat { mant: 0x1F, exp: 0 };

    round_nearest_tie_even(&mut fp, 6);

    assert_eq!(fp.mant, 0);

// HIGH-LEVEL

#[test]

fn round_to_float_test() {

    // Denormal

    let mut fp = ExtendedFloat {

        mant: 1 << 63,

        exp: f64::DENORMAL_EXPONENT - 15,

};

    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, 1 << 48);

    assert_eq!(fp.exp, f64::DENORMAL_EXPONENT);

    // Halfway, round-down (b'1000000000000000000000000000000000000000000000000000010000000000')

    let mut fp = ExtendedFloat {

        mant: 0x8000000000000400,

        exp: -63,

};

    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, 1 << 52);

    assert_eq!(fp.exp, -52);

    // Halfway, round-up (b'1000000000000000000000000000000000000000000000000000110000000000')

    let mut fp = ExtendedFloat {

        mant: 0x8000000000000C00,

        exp: -63,

};

    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, (1 << 52) + 2);

    assert_eq!(fp.exp, -52);

    // Above halfway

    let mut fp = ExtendedFloat {

        mant: 0x8000000000000401,

        exp: -63,

};

    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, (1 << 52) + 1);

    assert_eq!(fp.exp, -52);

    let mut fp = ExtendedFloat {

        mant: 0x8000000000000C01,

        exp: -63,

};

    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, (1 << 52) + 2);

    assert_eq!(fp.exp, -52);

    // Below halfway

    let mut fp = ExtendedFloat {

        mant: 0x80000000000003FF,

        exp: -63,

};

    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, 1 << 52);

    assert_eq!(fp.exp, -52);

    let mut fp = ExtendedFloat {

        mant: 0x8000000000000BFF,

        exp: -63,

};

    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, (1 << 52) + 1);

    assert_eq!(fp.exp, -52);

#[test]

fn avoid_overflow_test() {

    // Avoid overflow, fails by 1

    let mut fp = ExtendedFloat {

        mant: 0xFFFFFFFFFFFF,

        exp: f64::MAX_EXPONENT + 5,

};

    avoid_overflow::<f64>(&mut fp);

    assert_eq!(fp.mant, 0xFFFFFFFFFFFF);

    assert_eq!(fp.exp, f64::MAX_EXPONENT + 5);

    // Avoid overflow, succeeds

    let mut fp = ExtendedFloat {

        mant: 0xFFFFFFFFFFFF,

        exp: f64::MAX_EXPONENT + 4,

};

    avoid_overflow::<f64>(&mut fp);

    assert_eq!(fp.mant, 0x1FFFFFFFFFFFE0);

    assert_eq!(fp.exp, f64::MAX_EXPONENT - 1);

#[test]

fn round_to_native_test() {

    // Overflow

    let mut fp = ExtendedFloat {

        mant: 0xFFFFFFFFFFFF,

        exp: f64::MAX_EXPONENT + 4,

};

    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, 0x1FFFFFFFFFFFE0);

    assert_eq!(fp.exp, f64::MAX_EXPONENT - 1);

    // Need denormal

    let mut fp = ExtendedFloat {

        mant: 1,

        exp: f64::DENORMAL_EXPONENT + 48,

};

    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, 1 << 48);

    assert_eq!(fp.exp, f64::DENORMAL_EXPONENT);

    // Halfway, round-down (b'10000000000000000000000000000000000000000000000000000100000')

    let mut fp = ExtendedFloat {

        mant: 0x400000000000020,

        exp: -58,

};

    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, 1 << 52);

    assert_eq!(fp.exp, -52);

    // Halfway, round-up (b'10000000000000000000000000000000000000000000000000001100000')

    let mut fp = ExtendedFloat {

        mant: 0x400000000000060,

        exp: -58,

};

    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, (1 << 52) + 2);

    assert_eq!(fp.exp, -52);

    // Above halfway

    let mut fp = ExtendedFloat {

        mant: 0x400000000000021,

        exp: -58,

};

    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, (1 << 52) + 1);

    assert_eq!(fp.exp, -52);

    let mut fp = ExtendedFloat {

        mant: 0x400000000000061,

        exp: -58,

};

    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, (1 << 52) + 2);

    assert_eq!(fp.exp, -52);

    // Below halfway

    let mut fp = ExtendedFloat {

        mant: 0x40000000000001F,

        exp: -58,

};

    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, 1 << 52);

    assert_eq!(fp.exp, -52);

    let mut fp = ExtendedFloat {

        mant: 0x40000000000005F,

        exp: -58,

};

    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, (1 << 52) + 1);

    assert_eq!(fp.exp, -52);

    // Underflow

    // Adapted from failures in strtod.

    let mut fp = ExtendedFloat {

        exp: -1139,

        mant: 18446744073709550712,

};

    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, 0);

    assert_eq!(fp.exp, 0);

    let mut fp = ExtendedFloat {

        exp: -1139,

        mant: 18446744073709551460,

};

    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, 0);

    assert_eq!(fp.exp, 0);

    let mut fp = ExtendedFloat {

        exp: -1138,

        mant: 9223372036854776103,

};

    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);

    assert_eq!(fp.mant, 1);

    assert_eq!(fp.exp, -1074);